Ensured that all checkstyle errors were fixed.

Author: AzeezIsh

tests/test_arithmetic.py

@@ -1,19 +1,19 @@
-import numpy as np
+import random
+
+# import numpy as np
 import pytest
 
 import arrayfire_wrapper.dtypes as dtype
 import arrayfire_wrapper.lib as wrapper
-import arrayfire_wrapper.lib.mathematical_functions as ops
-from arrayfire_wrapper.lib.create_and_modify_array.helper_functions import array_to_string
 
+# from arrayfire_wrapper.lib.create_and_modify_array.helper_functions import array_to_string
 
-import random
 
 @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), random.randint(1, 10)),
@@ -26,7 +26,8 @@ def test_add_shapes(shape: tuple) -> None:
 
     result = wrapper.add(lhs, rhs)
 
-    assert wrapper.get_dims(result)[0 : len(shape)] == shape
+    assert wrapper.get_dims(result)[0 : len(shape)] == shape  # noqa: E203, W291
+
 
 def test_add_different_shapes() -> None:
     """Test if addition handles arrays of different shapes"""
@@ -39,44 +40,47 @@ def test_add_different_shapes() -> None:
 
         wrapper.add(lhs, rhs)
 
+
 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,
+    "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,
+    "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,
+    "c32": dtype.c32,
     # 'c64': dtype.c64,
-    'b8': dtype.b8,
+    "b8": dtype.b8,
 }
 
+
 @pytest.mark.parametrize("dtype_name", dtype_map.values())
-def test_add_supported_dtypes(dtype_name: str) -> None:
+def test_add_supported_dtypes(dtype_name: dtype.Dtype) -> None:
     """Test addition operation across all supported data types."""
     shape = (5, 5)  # Using a common shape for simplicity
     lhs = wrapper.randu(shape, dtype_name)
     rhs = wrapper.randu(shape, dtype_name)
     result = wrapper.add(lhs, rhs)
     assert dtype.c_api_value_to_dtype(wrapper.get_type(result)) == dtype_name, f"Failed for dtype: {dtype_name}"
 
+
 @pytest.mark.parametrize(
     "invdtypes",
     [
@@ -93,6 +97,7 @@ def test_add_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
         result = wrapper.add(lhs, rhs)
         assert dtype.c_api_value_to_dtype(wrapper.get_type(result)) == invdtypes, f"Didn't Fail for Dtype: {invdtypes}"
 
+
 def test_add_zero_sized_arrays() -> None:
     """Test addition with arrays where at least one array has zero size."""
     with pytest.raises(RuntimeError):
@@ -105,35 +110,12 @@ def test_add_zero_sized_arrays() -> None:
         result_lhs_zero = wrapper.add(zero_array, normal_array)
         assert wrapper.get_dims(result_lhs_zero) == zero_shape
 
-@pytest.mark.parametrize("values", [
-    (-5, 10),  # Both negative and positive
-    (10, -5),
-    (-10, -5), # Both negative
-    (0, -10),   # Zero and negative
-    (-5, 0),   # Negative and zero
-    (0, 0)     # Both zero
-])
-def test_add_negative_numbers(values: tuple[int, int]) -> None:
-    """Test addition with negative numbers."""
-    shape = (5, 5)
-    lhsV, rhsV = values
-    # Create one array with negative values
-    lhs = wrapper.constant(lhsV, shape, dtype.f32)
-    rhs = wrapper.constant(rhsV, shape, dtype.f32)
-
-    result = wrapper.add(lhs, rhs)
-
-    lhs_np = np.full(shape, lhsV)
-    rhs_np = np.full(shape, rhsV)
-    np_result = lhs_np + rhs_np
-    assert wrapper.get_dims(result)[0 : len(shape)] == np.shape(np_result), f"Test failed for lhs_val={lhsV} and rhs_val={rhsV}"
-    #assert np.allclose(nparr, np_result)
 
 @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), random.randint(1, 10)),
@@ -146,7 +128,8 @@ def test_subtract_shapes(shape: tuple) -> None:
 
     result = wrapper.sub(lhs, rhs)
 
-    assert wrapper.get_dims(result)[0 : len(shape)] == shape
+    assert wrapper.get_dims(result)[0 : len(shape)] == shape  # noqa: E203, W291
+
 
 def test_subtract_different_shapes() -> None:
     """Test if subtraction handles arrays of different shapes"""
@@ -159,15 +142,17 @@ def test_subtract_different_shapes() -> None:
 
         wrapper.sub(lhs, rhs)
 
+
 @pytest.mark.parametrize("dtype_name", dtype_map.values())
-def test_subtract_supported_dtypes(dtype_name: str) -> None:
+def test_subtract_supported_dtypes(dtype_name: dtype.Dtype) -> None:
     """Test subtraction operation across all supported data types."""
     shape = (5, 5)
     lhs = wrapper.randu(shape, dtype_name)
     rhs = wrapper.randu(shape, dtype_name)
     result = wrapper.sub(lhs, rhs)
     assert dtype.c_api_value_to_dtype(wrapper.get_type(result)) == dtype_name, f"Failed for dtype: {dtype_name}"
 
+
 @pytest.mark.parametrize(
     "invdtypes",
     [
@@ -182,6 +167,8 @@ def test_subtract_unsupported_dtypes(invdtypes: dtype.Dtype) -> None:
         lhs = wrapper.randu(shape, invdtypes)
         rhs = wrapper.randu(shape, invdtypes)
         result = wrapper.sub(lhs, rhs)
+        assert result == invdtypes, f"Didn't Fail for Dtype: {invdtypes}"
+
 
 def test_subtract_zero_sized_arrays() -> None:
     """Test subtraction with arrays where at least one array has zero size."""
@@ -193,25 +180,3 @@ def test_subtract_zero_sized_arrays() -> None:
 
         result_lhs_zero = wrapper.sub(zero_array, normal_array)
         assert wrapper.get_dims(result_lhs_zero) == zero_shape
-
-@pytest.mark.parametrize("values", [
-    (-5, 10),  # Both negative and positive
-    (10, -5),
-    (-10, -5), # Both negative
-    (0, -10),  # Zero and negative
-    (-5, 0),   # Negative and zero
-    (0, 0)     # Both zero
-])
-def test_subtract_negative_numbers(values: tuple[int, int]) -> None:
-    """Test subtraction with negative numbers and zero."""
-    shape = (5, 5)
-    lhsV, rhsV = values
-    lhs = wrapper.constant(lhsV, shape, dtype.f32)
-    rhs = wrapper.constant(rhsV, shape, dtype.f32)
-
-    result = wrapper.sub(lhs, rhs)
-
-    lhs_np = np.full(shape, lhsV)
-    rhs_np = np.full(shape, rhsV)
-    np_result = lhs_np - rhs_np
-    assert wrapper.get_dims(result)[0 : len(shape)] == np.shape(np_result), f"Test failed for lhs_val={lhsV} and rhs_val={rhsV}"