From d50c3ebdcab35a996783f904572f315e47ce1876 Mon Sep 17 00:00:00 2001 From: AzeezIsh Date: Wed, 20 Mar 2024 13:13:39 -0400 Subject: [PATCH 1/5] Adding logical tests Added several logical tests --- tests/test_logical.py | 113 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100644 tests/test_logical.py diff --git a/tests/test_logical.py b/tests/test_logical.py new file mode 100644 index 0000000..4cb3105 --- /dev/null +++ b/tests/test_logical.py @@ -0,0 +1,113 @@ +import random + +import numpy as np +import pytest + +import arrayfire_wrapper.dtypes as dtype +import arrayfire_wrapper.lib as wrapper + +from arrayfire_wrapper.lib.create_and_modify_array.helper_functions import array_to_string + +dtype_map = { + "int16": dtype.s16, + "int32": dtype.s32, + "int64": dtype.s64, + "uint8": dtype.u8, + "uint16": dtype.u16, + "uint32": dtype.u32, + "uint64": dtype.u64, + "float16": dtype.f16, + "float32": dtype.f32, + # 'float64': dtype.f64, + # 'complex64': dtype.c64, + "complex32": dtype.c32, + "bool": dtype.b8, + "s16": dtype.s16, + "s32": dtype.s32, + "s64": dtype.s64, + "u8": dtype.u8, + "u16": dtype.u16, + "u32": dtype.u32, + "u64": dtype.u64, + "f16": dtype.f16, + "f32": dtype.f32, + # 'f64': dtype.f64, + "c32": dtype.c32, + # 'c64': dtype.c64, + "b8": dtype.b8, +} + + +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_and_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test and_ operation between two arrays of the same shape""" + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.and_(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_and_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test and_ operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + + result = wrapper.and_(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {invdtypes}" # noqa +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_bitandshape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test bitand operation between two arrays of the same shape""" + print(dtype_name) + if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + pytest.skip() + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.bitand(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_bitandshapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test bitand operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) \ No newline at end of file From 430ad1a4496b052c9ec42ea3084a08fc9a3dce11 Mon Sep 17 00:00:00 2001 From: AzeezIsh Date: Wed, 20 Mar 2024 14:08:49 -0400 Subject: [PATCH 2/5] Completed all logical operations tests Tested for shapes and datatypes --- tests/test_logical.py | 391 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 387 insertions(+), 4 deletions(-) diff --git a/tests/test_logical.py b/tests/test_logical.py index 4cb3105..056868a 100644 --- a/tests/test_logical.py +++ b/tests/test_logical.py @@ -86,9 +86,8 @@ def test_and_shapes_invalid(invdtypes: dtype.Dtype) -> None: ], ) @pytest.mark.parametrize("dtype_name", dtype_map.values()) -def test_bitandshape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: +def test_bitand_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitand operation between two arrays of the same shape""" - print(dtype_name) if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: pytest.skip() lhs = wrapper.randu(shape, dtype_name) @@ -105,9 +104,393 @@ def test_bitandshape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: dtype.f64, ], ) -def test_bitandshapes_invalid(invdtypes: dtype.Dtype) -> None: +def test_bitand_shapes_invalid(invdtypes: dtype.Dtype) -> None: """Test bitand operation between two arrays of the same shape""" with pytest.raises(RuntimeError): shape = (3, 3) lhs = wrapper.randu(shape, invdtypes) - rhs = wrapper.randu(shape, invdtypes) \ No newline at end of file + rhs = wrapper.randu(shape, invdtypes) + wrapper.bitand(lhs, rhs) +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_bitnot_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test bitnot operation between two arrays of the same shape""" + if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + pytest.skip() + out = wrapper.randu(shape, dtype_name) + + result = wrapper.bitnot(out) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_bitnot_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test bitnot operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + out = wrapper.randu(shape, invdtypes) + wrapper.bitnot(out) +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_bitor_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test bitor operation between two arrays of the same shape""" + if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + pytest.skip() + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.bitor(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_bitor_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test bitor operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.bitor(lhs, rhs) + +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_bitxor_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test bitxor operation between two arrays of the same shape""" + if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + pytest.skip() + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.bitxor(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_bitxor_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test bitxor operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.bitxor(lhs, rhs) +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_eq_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test eq operation between two arrays of the same shape""" + if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + pytest.skip() + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.eq(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_eq_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test eq operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.eq(lhs, rhs) +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_ge_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test >= operation between two arrays of the same shape""" + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.ge(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_ge_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test >= operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.ge(lhs, rhs) + +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_gt_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test > operation between two arrays of the same shape""" + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.gt(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_gt_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test > operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.gt(lhs, rhs) + +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_le_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test <= operation between two arrays of the same shape""" + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.le(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_le_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test <= operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.le(lhs, rhs) +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_lt_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test < operation between two arrays of the same shape""" + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.lt(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_lt_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test < operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.lt(lhs, rhs) +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_neq_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test not equal operation between two arrays of the same shape""" + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.neq(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_neq_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test neq operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.neq(lhs, rhs) +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_not_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test not operation between two arrays of the same shape""" + if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + pytest.skip() + out = wrapper.randu(shape, dtype_name) + + result = wrapper.not_(out) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_not_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test not operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + out = wrapper.randu(shape, invdtypes) + wrapper.not_(out) +@pytest.mark.parametrize( + "shape", + [ + (), + (random.randint(1, 10),), + (random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), + ], +) +@pytest.mark.parametrize("dtype_name", dtype_map.values()) +def test_or_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: + """Test or operation between two arrays of the same shape""" + lhs = wrapper.randu(shape, dtype_name) + rhs = wrapper.randu(shape, dtype_name) + + result = wrapper.or_(lhs, rhs) + + assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + +@pytest.mark.parametrize( + "invdtypes", + [ + dtype.c64, + dtype.f64, + ], +) +def test_or_shapes_invalid(invdtypes: dtype.Dtype) -> None: + """Test or operation between two arrays of the same shape""" + with pytest.raises(RuntimeError): + shape = (3, 3) + lhs = wrapper.randu(shape, invdtypes) + rhs = wrapper.randu(shape, invdtypes) + wrapper.or_(lhs, rhs) \ No newline at end of file From 0bc17beefccb2d993fb027bdd2765d11ef716041 Mon Sep 17 00:00:00 2001 From: AzeezIsh Date: Wed, 20 Mar 2024 14:13:49 -0400 Subject: [PATCH 3/5] Adhered to all checkstyle requirements. --- tests/test_logical.py | 143 +++++++++++++++++++++++++++++++++++------- 1 file changed, 119 insertions(+), 24 deletions(-) diff --git a/tests/test_logical.py b/tests/test_logical.py index 056868a..87c60e3 100644 --- a/tests/test_logical.py +++ b/tests/test_logical.py @@ -1,13 +1,10 @@ import random -import numpy as np import pytest import arrayfire_wrapper.dtypes as dtype import arrayfire_wrapper.lib as wrapper -from arrayfire_wrapper.lib.create_and_modify_array.helper_functions import array_to_string - dtype_map = { "int16": dtype.s16, "int32": dtype.s32, @@ -56,7 +53,10 @@ def test_and_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: result = wrapper.and_(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -74,7 +74,11 @@ def test_and_shapes_invalid(invdtypes: dtype.Dtype) -> None: result = wrapper.and_(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {invdtypes}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {invdtypes}" + + @pytest.mark.parametrize( "shape", [ @@ -88,14 +92,23 @@ def test_and_shapes_invalid(invdtypes: dtype.Dtype) -> None: @pytest.mark.parametrize("dtype_name", dtype_map.values()) def test_bitand_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitand operation between two arrays of the same shape""" - if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + if ( + dtype_name == dtype.c32 + or dtype_name == dtype.c64 + or dtype_name == dtype.f32 + or dtype_name == dtype.f64 + or dtype_name == dtype.f16 + ): pytest.skip() lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) result = wrapper.bitand(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -111,6 +124,8 @@ def test_bitand_shapes_invalid(invdtypes: dtype.Dtype) -> None: lhs = wrapper.randu(shape, invdtypes) rhs = wrapper.randu(shape, invdtypes) wrapper.bitand(lhs, rhs) + + @pytest.mark.parametrize( "shape", [ @@ -124,13 +139,22 @@ def test_bitand_shapes_invalid(invdtypes: dtype.Dtype) -> None: @pytest.mark.parametrize("dtype_name", dtype_map.values()) def test_bitnot_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitnot operation between two arrays of the same shape""" - if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + if ( + dtype_name == dtype.c32 + or dtype_name == dtype.c64 + or dtype_name == dtype.f32 + or dtype_name == dtype.f64 + or dtype_name == dtype.f16 + ): pytest.skip() out = wrapper.randu(shape, dtype_name) result = wrapper.bitnot(out) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -145,6 +169,8 @@ def test_bitnot_shapes_invalid(invdtypes: dtype.Dtype) -> None: shape = (3, 3) out = wrapper.randu(shape, invdtypes) wrapper.bitnot(out) + + @pytest.mark.parametrize( "shape", [ @@ -158,14 +184,23 @@ def test_bitnot_shapes_invalid(invdtypes: dtype.Dtype) -> None: @pytest.mark.parametrize("dtype_name", dtype_map.values()) def test_bitor_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitor operation between two arrays of the same shape""" - if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + if ( + dtype_name == dtype.c32 + or dtype_name == dtype.c64 + or dtype_name == dtype.f32 + or dtype_name == dtype.f64 + or dtype_name == dtype.f16 + ): pytest.skip() lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) result = wrapper.bitor(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -182,6 +217,7 @@ def test_bitor_shapes_invalid(invdtypes: dtype.Dtype) -> None: rhs = wrapper.randu(shape, invdtypes) wrapper.bitor(lhs, rhs) + @pytest.mark.parametrize( "shape", [ @@ -195,14 +231,23 @@ def test_bitor_shapes_invalid(invdtypes: dtype.Dtype) -> None: @pytest.mark.parametrize("dtype_name", dtype_map.values()) def test_bitxor_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitxor operation between two arrays of the same shape""" - if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + if ( + dtype_name == dtype.c32 + or dtype_name == dtype.c64 + or dtype_name == dtype.f32 + or dtype_name == dtype.f64 + or dtype_name == dtype.f16 + ): pytest.skip() lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) result = wrapper.bitxor(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -218,6 +263,8 @@ def test_bitxor_shapes_invalid(invdtypes: dtype.Dtype) -> None: lhs = wrapper.randu(shape, invdtypes) rhs = wrapper.randu(shape, invdtypes) wrapper.bitxor(lhs, rhs) + + @pytest.mark.parametrize( "shape", [ @@ -231,14 +278,23 @@ def test_bitxor_shapes_invalid(invdtypes: dtype.Dtype) -> None: @pytest.mark.parametrize("dtype_name", dtype_map.values()) def test_eq_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test eq operation between two arrays of the same shape""" - if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + if ( + dtype_name == dtype.c32 + or dtype_name == dtype.c64 + or dtype_name == dtype.f32 + or dtype_name == dtype.f64 + or dtype_name == dtype.f16 + ): pytest.skip() lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) result = wrapper.eq(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -254,6 +310,8 @@ def test_eq_shapes_invalid(invdtypes: dtype.Dtype) -> None: lhs = wrapper.randu(shape, invdtypes) rhs = wrapper.randu(shape, invdtypes) wrapper.eq(lhs, rhs) + + @pytest.mark.parametrize( "shape", [ @@ -272,7 +330,10 @@ def test_ge_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: result = wrapper.ge(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -289,6 +350,7 @@ def test_ge_shapes_invalid(invdtypes: dtype.Dtype) -> None: rhs = wrapper.randu(shape, invdtypes) wrapper.ge(lhs, rhs) + @pytest.mark.parametrize( "shape", [ @@ -307,7 +369,10 @@ def test_gt_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: result = wrapper.gt(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -324,6 +389,7 @@ def test_gt_shapes_invalid(invdtypes: dtype.Dtype) -> None: rhs = wrapper.randu(shape, invdtypes) wrapper.gt(lhs, rhs) + @pytest.mark.parametrize( "shape", [ @@ -342,7 +408,10 @@ def test_le_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: result = wrapper.le(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -358,6 +427,8 @@ def test_le_shapes_invalid(invdtypes: dtype.Dtype) -> None: lhs = wrapper.randu(shape, invdtypes) rhs = wrapper.randu(shape, invdtypes) wrapper.le(lhs, rhs) + + @pytest.mark.parametrize( "shape", [ @@ -376,7 +447,10 @@ def test_lt_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: result = wrapper.lt(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -392,6 +466,8 @@ def test_lt_shapes_invalid(invdtypes: dtype.Dtype) -> None: lhs = wrapper.randu(shape, invdtypes) rhs = wrapper.randu(shape, invdtypes) wrapper.lt(lhs, rhs) + + @pytest.mark.parametrize( "shape", [ @@ -410,7 +486,10 @@ def test_neq_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: result = wrapper.neq(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -426,6 +505,8 @@ def test_neq_shapes_invalid(invdtypes: dtype.Dtype) -> None: lhs = wrapper.randu(shape, invdtypes) rhs = wrapper.randu(shape, invdtypes) wrapper.neq(lhs, rhs) + + @pytest.mark.parametrize( "shape", [ @@ -439,13 +520,22 @@ def test_neq_shapes_invalid(invdtypes: dtype.Dtype) -> None: @pytest.mark.parametrize("dtype_name", dtype_map.values()) def test_not_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test not operation between two arrays of the same shape""" - if dtype_name == dtype.c32 or dtype_name == dtype.c64 or dtype_name == dtype.f32 or dtype_name == dtype.f64 or dtype_name == dtype.f16: + if ( + dtype_name == dtype.c32 + or dtype_name == dtype.c64 + or dtype_name == dtype.f32 + or dtype_name == dtype.f64 + or dtype_name == dtype.f16 + ): pytest.skip() out = wrapper.randu(shape, dtype_name) result = wrapper.not_(out) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -460,6 +550,8 @@ def test_not_shapes_invalid(invdtypes: dtype.Dtype) -> None: shape = (3, 3) out = wrapper.randu(shape, invdtypes) wrapper.not_(out) + + @pytest.mark.parametrize( "shape", [ @@ -478,7 +570,10 @@ def test_or_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: result = wrapper.or_(lhs, rhs) - assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"failed for shape: {shape} and dtype {dtype_name}" # noqa + assert ( + wrapper.get_dims(result)[0 : len(shape)] == shape # noqa + ), f"failed for shape: {shape} and dtype {dtype_name}" + @pytest.mark.parametrize( "invdtypes", @@ -493,4 +588,4 @@ def test_or_shapes_invalid(invdtypes: dtype.Dtype) -> None: shape = (3, 3) lhs = wrapper.randu(shape, invdtypes) rhs = wrapper.randu(shape, invdtypes) - wrapper.or_(lhs, rhs) \ No newline at end of file + wrapper.or_(lhs, rhs) From 6e58189959d7a076aebdecda0da4079d9ae70589 Mon Sep 17 00:00:00 2001 From: AzeezIsh Date: Tue, 26 Mar 2024 15:45:15 -0400 Subject: [PATCH 4/5] Added all necessary dtype coverage. --- tests/test_logical.py | 117 ++++++++++-------------------------------- 1 file changed, 27 insertions(+), 90 deletions(-) diff --git a/tests/test_logical.py b/tests/test_logical.py index 87c60e3..feba97d 100644 --- a/tests/test_logical.py +++ b/tests/test_logical.py @@ -4,35 +4,7 @@ import arrayfire_wrapper.dtypes as dtype import arrayfire_wrapper.lib as wrapper - -dtype_map = { - "int16": dtype.s16, - "int32": dtype.s32, - "int64": dtype.s64, - "uint8": dtype.u8, - "uint16": dtype.u16, - "uint32": dtype.u32, - "uint64": dtype.u64, - "float16": dtype.f16, - "float32": dtype.f32, - # 'float64': dtype.f64, - # 'complex64': dtype.c64, - "complex32": dtype.c32, - "bool": dtype.b8, - "s16": dtype.s16, - "s32": dtype.s32, - "s64": dtype.s64, - "u8": dtype.u8, - "u16": dtype.u16, - "u32": dtype.u32, - "u64": dtype.u64, - "f16": dtype.f16, - "f32": dtype.f32, - # 'f64': dtype.f64, - "c32": dtype.c32, - # 'c64': dtype.c64, - "b8": dtype.b8, -} +from tests.utility_functions import check_type_supported, get_all_types @pytest.mark.parametrize( @@ -45,9 +17,10 @@ (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_and_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test and_ operation between two arrays of the same shape""" + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -89,17 +62,10 @@ def test_and_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_bitand_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitand operation between two arrays of the same shape""" - if ( - dtype_name == dtype.c32 - or dtype_name == dtype.c64 - or dtype_name == dtype.f32 - or dtype_name == dtype.f64 - or dtype_name == dtype.f16 - ): - pytest.skip() + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -136,17 +102,10 @@ def test_bitand_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_bitnot_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitnot operation between two arrays of the same shape""" - if ( - dtype_name == dtype.c32 - or dtype_name == dtype.c64 - or dtype_name == dtype.f32 - or dtype_name == dtype.f64 - or dtype_name == dtype.f16 - ): - pytest.skip() + check_type_supported(dtype_name) out = wrapper.randu(shape, dtype_name) result = wrapper.bitnot(out) @@ -181,17 +140,10 @@ def test_bitnot_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_bitor_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitor operation between two arrays of the same shape""" - if ( - dtype_name == dtype.c32 - or dtype_name == dtype.c64 - or dtype_name == dtype.f32 - or dtype_name == dtype.f64 - or dtype_name == dtype.f16 - ): - pytest.skip() + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -228,17 +180,10 @@ def test_bitor_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_bitxor_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitxor operation between two arrays of the same shape""" - if ( - dtype_name == dtype.c32 - or dtype_name == dtype.c64 - or dtype_name == dtype.f32 - or dtype_name == dtype.f64 - or dtype_name == dtype.f16 - ): - pytest.skip() + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -275,17 +220,10 @@ def test_bitxor_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_eq_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test eq operation between two arrays of the same shape""" - if ( - dtype_name == dtype.c32 - or dtype_name == dtype.c64 - or dtype_name == dtype.f32 - or dtype_name == dtype.f64 - or dtype_name == dtype.f16 - ): - pytest.skip() + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -322,9 +260,10 @@ def test_eq_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_ge_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test >= operation between two arrays of the same shape""" + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -361,9 +300,10 @@ def test_ge_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_gt_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test > operation between two arrays of the same shape""" + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -400,9 +340,10 @@ def test_gt_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_le_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test <= operation between two arrays of the same shape""" + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -439,9 +380,10 @@ def test_le_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_lt_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test < operation between two arrays of the same shape""" + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -478,9 +420,10 @@ def test_lt_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_neq_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test not equal operation between two arrays of the same shape""" + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -517,17 +460,10 @@ def test_neq_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_not_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test not operation between two arrays of the same shape""" - if ( - dtype_name == dtype.c32 - or dtype_name == dtype.c64 - or dtype_name == dtype.f32 - or dtype_name == dtype.f64 - or dtype_name == dtype.f16 - ): - pytest.skip() + check_type_supported(dtype_name) out = wrapper.randu(shape, dtype_name) result = wrapper.not_(out) @@ -562,9 +498,10 @@ def test_not_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", dtype_map.values()) +@pytest.mark.parametrize("dtype_name", get_all_types()) def test_or_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test or operation between two arrays of the same shape""" + check_type_supported(dtype_name) lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) From 76970d5a4ce7365831021b03fc622c599ebed93b Mon Sep 17 00:00:00 2001 From: AzeezIsh Date: Tue, 26 Mar 2024 15:49:31 -0400 Subject: [PATCH 5/5] Removed float coverage for bit specific tests. --- tests/test_logical.py | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/tests/test_logical.py b/tests/test_logical.py index feba97d..b9e8db2 100644 --- a/tests/test_logical.py +++ b/tests/test_logical.py @@ -4,7 +4,7 @@ import arrayfire_wrapper.dtypes as dtype import arrayfire_wrapper.lib as wrapper -from tests.utility_functions import check_type_supported, get_all_types +from tests.utility_functions import check_type_supported, get_all_types, get_real_types @pytest.mark.parametrize( @@ -62,10 +62,12 @@ def test_and_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", get_all_types()) +@pytest.mark.parametrize("dtype_name", get_real_types()) def test_bitand_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitand operation between two arrays of the same shape""" check_type_supported(dtype_name) + if dtype_name == dtype.f16 or dtype_name == dtype.f32: + pytest.skip() lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -102,10 +104,12 @@ def test_bitand_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", get_all_types()) +@pytest.mark.parametrize("dtype_name", get_real_types()) def test_bitnot_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitnot operation between two arrays of the same shape""" check_type_supported(dtype_name) + if dtype_name == dtype.f16 or dtype_name == dtype.f32: + pytest.skip() out = wrapper.randu(shape, dtype_name) result = wrapper.bitnot(out) @@ -140,10 +144,12 @@ def test_bitnot_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", get_all_types()) +@pytest.mark.parametrize("dtype_name", get_real_types()) def test_bitor_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitor operation between two arrays of the same shape""" check_type_supported(dtype_name) + if dtype_name == dtype.f16 or dtype_name == dtype.f32: + pytest.skip() lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name) @@ -180,10 +186,12 @@ def test_bitor_shapes_invalid(invdtypes: dtype.Dtype) -> None: (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)), ], ) -@pytest.mark.parametrize("dtype_name", get_all_types()) +@pytest.mark.parametrize("dtype_name", get_real_types()) def test_bitxor_shape_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None: """Test bitxor operation between two arrays of the same shape""" check_type_supported(dtype_name) + if dtype_name == dtype.f16 or dtype_name == dtype.f32: + pytest.skip() lhs = wrapper.randu(shape, dtype_name) rhs = wrapper.randu(shape, dtype_name)