Adhered to checkstyle and fixed dtype checking.

Author: AzeezIsh

tests/complex_testing.py renamed to tests/test_complex.py

@@ -1,39 +1,10 @@
 import random
 
-# import numpy as np
 import pytest
 
 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, get_float_types, get_real_types
 
 
 @pytest.mark.parametrize(
@@ -46,9 +17,12 @@
         (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_float_types())
 def test_complex_supported_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None:
     """Test complex operation across all supported data types."""
+    check_type_supported(dtype_name)
+    if dtype_name == dtype.f16:
+        pytest.skip()
     tester = wrapper.randu(shape, dtype_name)
     result = wrapper.cplx(tester)
     assert wrapper.is_complex(result), f"Failed for dtype: {dtype_name}"
@@ -57,8 +31,8 @@ def test_complex_supported_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None
 @pytest.mark.parametrize(
     "invdtypes",
     [
-        dtype.c64,
-        dtype.f64,
+        dtype.int32,
+        dtype.complex32,
     ],
 )
 def test_complex_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
@@ -79,9 +53,10 @@ def test_complex_unsupported_dtypes(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_real_types())
 def test_complex2_supported_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> None:
     """Test complex2 operation across all supported data types."""
+    check_type_supported(dtype_name)
     lhs = wrapper.randu(shape, dtype_name)
     rhs = wrapper.randu(shape, dtype_name)
     result = wrapper.cplx2(lhs, rhs)
@@ -91,8 +66,7 @@ def test_complex2_supported_dtypes(shape: tuple, dtype_name: dtype.Dtype) -> Non
 @pytest.mark.parametrize(
     "invdtypes",
     [
-        dtype.c64,
-        dtype.f64,
+        dtype.c32,
     ],
 )
 def test_complex2_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
@@ -114,26 +88,13 @@ def test_complex2_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
         (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)),
     ],
 )
-def test_conj_supported_dtypes(shape: tuple) -> None:
+@pytest.mark.parametrize("dtypes", get_all_types())
+def test_conj_supported_dtypes(shape: tuple, dtypes: dtype.Dtype) -> None:
     """Test conjugate operation for supported data types."""
-    arr = wrapper.constant(7, shape, dtype.c32)
+    check_type_supported(dtypes)
+    arr = wrapper.constant(7, shape, dtypes)
     result = wrapper.conjg(arr)
-    assert wrapper.is_complex(result), f"Failed for shape: {shape}"
-
-
-@pytest.mark.parametrize(
-    "invdtypes",
-    [
-        dtype.c64,
-        dtype.f64,
-    ],
-)
-def test_conj_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
-    """Test conjugate operation for unsupported data types."""
-    with pytest.raises(RuntimeError):
-        shape = (5, 5)
-        arr = wrapper.randu(shape, invdtypes)
-        wrapper.conjg(arr)
+    assert wrapper.get_dims(result)[0 : len(shape)] == shape, f"Failed for shape: {shape}, and dtype: {dtypes}"  # noqa
 
 
 @pytest.mark.parametrize(
@@ -146,40 +107,29 @@ def test_conj_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
         (random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)),
     ],
 )
-def test_imag_real_supported_dtypes(shape: tuple) -> None:
+@pytest.mark.parametrize("dtypes", get_all_types())
+def test_imag_supported_dtypes(shape: tuple, dtypes: dtype.Dtype) -> None:
     """Test imaginary and real operations for supported data types."""
-    arr = wrapper.randu(shape, dtype.c32)
-    imaginary = wrapper.imag(arr)
+    check_type_supported(dtypes)
+    arr = wrapper.randu(shape, dtypes)
     real = wrapper.real(arr)
-    assert not wrapper.is_empty(imaginary), f"Failed for shape: {shape}"
-    assert not wrapper.is_empty(real), f"Failed for shape: {shape}"
-
-
-@pytest.mark.parametrize(
-    "invdtypes",
-    [
-        dtype.c64,
-        dtype.f64,
-    ],
-)
-def test_imag_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
-    """Test conjugate operation for unsupported data types."""
-    with pytest.raises(RuntimeError):
-        shape = (5, 5)
-        arr = wrapper.randu(shape, invdtypes)
-        wrapper.imag(arr)
+    assert wrapper.is_real(real), f"Failed for shape: {shape}"
 
 
 @pytest.mark.parametrize(
-    "invdtypes",
+    "shape",
     [
-        dtype.c64,
-        dtype.f64,
+        (),
+        (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)),
     ],
 )
-def test_real_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
-    """Test real operation for unsupported data types."""
-    with pytest.raises(RuntimeError):
-        shape = (5, 5)
-        arr = wrapper.randu(shape, invdtypes)
-        wrapper.real(arr)
+@pytest.mark.parametrize("dtypes", get_all_types())
+def test_real_supported_dtypes(shape: tuple, dtypes: dtype.Dtype) -> None:
+    """Test imaginary and real operations for supported data types."""
+    check_type_supported(dtypes)
+    arr = wrapper.randu(shape, dtypes)
+    real = wrapper.real(arr)
+    assert wrapper.is_real(real), f"Failed for shape: {shape}"