add no_int8 kwarg

Author: Vahid Tavanashad

dpnp/tests/third_party/cupy/linalg_tests/test_einsum.py

@@ -464,15 +464,11 @@ def test_scalar_float(self, xp, dtype):
     )
 )
 class TestEinSumBinaryOperation:
-    @testing.for_all_dtypes_combination(
-        ["dtype_a", "dtype_b"], no_bool=False, no_float16=False
-    )
+    @testing.for_all_dtypes_combination(["dtype_a", "dtype_b"], no_int8=True)
     @testing.numpy_cupy_allclose(
         type_check=has_support_aspect64(), contiguous_check=False
     )
     def test_einsum_binary(self, xp, dtype_a, dtype_b):
-        if all(dtype in [xp.int8, xp.uint8] for dtype in [dtype_a, dtype_b]):
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange(self.shape_a, xp, dtype_a)
         b = testing.shaped_arange(self.shape_b, xp, dtype_b)
         # casting should be added for dpnp to allow cast int64 to float32
@@ -558,9 +554,7 @@ def test_scalar_2(self, xp, dtype):
 )
 class TestEinSumTernaryOperation:
 
-    @testing.for_all_dtypes_combination(
-        ["dtype_a", "dtype_b", "dtype_c"], no_bool=False, no_float16=False
-    )
+    @testing.for_all_dtypes_combination(["dtype_a", "dtype_b", "dtype_c"])
     @testing.numpy_cupy_allclose(
         type_check=has_support_aspect64(), contiguous_check=False
     )

dpnp/tests/third_party/cupy/linalg_tests/test_product.py

@@ -40,21 +40,9 @@
 )
 class TestDot(unittest.TestCase):
 
-    # Avoid overflow
-    skip_dtypes = {
-        (numpy.int8, numpy.int8),
-        (numpy.int8, numpy.uint8),
-        (numpy.uint8, numpy.uint8),
-    }
-
-    @testing.for_all_dtypes_combination(["dtype_a", "dtype_b"])
+    @testing.for_all_dtypes_combination(["dtype_a", "dtype_b"], no_int8=True)
     @testing.numpy_cupy_allclose(type_check=has_support_aspect64())
     def test_dot(self, xp, dtype_a, dtype_b):
-        if (dtype_a, dtype_b) in self.skip_dtypes or (
-            dtype_b,
-            dtype_a,
-        ) in self.skip_dtypes:
-            pytest.skip("avoid overflow")
         shape_a, shape_b = self.shape
         if self.trans_a:
             a = testing.shaped_arange(shape_a[::-1], xp, dtype_a).T
@@ -250,20 +238,16 @@ def test_dot_vec3(self, xp, dtype):
         b = testing.shaped_arange((2,), xp, dtype)
         return xp.dot(a, b)
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose()
     def test_transposed_dot(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange((2, 3, 4), xp, dtype).transpose(1, 0, 2)
         b = testing.shaped_arange((2, 3, 4), xp, dtype).transpose(0, 2, 1)
         return xp.dot(a, b)
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose()
     def test_transposed_dot_with_out(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange((2, 3, 4), xp, dtype).transpose(1, 0, 2)
         b = testing.shaped_arange((4, 2, 3), xp, dtype).transpose(2, 0, 1)
         c = xp.ndarray((3, 2, 3, 2), dtype=dtype)
@@ -336,20 +320,16 @@ def test_reversed_inner(self, xp, dtype):
         b = testing.shaped_reverse_arange((5,), xp, dtype)[::-1]
         return xp.inner(a, b)
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose()
     def test_multidim_inner(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange((2, 3, 4), xp, dtype)
         b = testing.shaped_arange((3, 2, 4), xp, dtype)
         return xp.inner(a, b)
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose()
     def test_transposed_higher_order_inner(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange((2, 4, 3), xp, dtype).transpose(2, 0, 1)
         b = testing.shaped_arange((4, 2, 3), xp, dtype).transpose(1, 2, 0)
         return xp.inner(a, b)
@@ -375,20 +355,16 @@ def test_multidim_outer(self, xp, dtype):
         b = testing.shaped_arange((4, 5), xp, dtype)
         return xp.outer(a, b)
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose()
     def test_tensordot(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange((2, 3, 4), xp, dtype)
         b = testing.shaped_arange((3, 4, 5), xp, dtype)
         return xp.tensordot(a, b)
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose()
     def test_transposed_tensordot(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange((2, 3, 4), xp, dtype).transpose(1, 0, 2)
         b = testing.shaped_arange((4, 3, 2), xp, dtype).transpose(2, 0, 1)
         return xp.tensordot(a, b)
@@ -540,19 +516,15 @@ def test_matrix_power_1(self, xp, dtype):
         a = testing.shaped_arange((3, 3), xp, dtype)
         return xp.linalg.matrix_power(a, 1)
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose()
     def test_matrix_power_2(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange((3, 3), xp, dtype)
         return xp.linalg.matrix_power(a, 2)
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose()
     def test_matrix_power_3(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         a = testing.shaped_arange((3, 3), xp, dtype)
         return xp.linalg.matrix_power(a, 3)
 

dpnp/tests/third_party/cupy/logic_tests/test_comparison.py

@@ -242,11 +242,9 @@ def test_allclose_array_scalar(self, xp, dtype):
 
 class TestIsclose(unittest.TestCase):
 
-    @testing.for_all_dtypes(no_complex=True)
+    @testing.for_all_dtypes(no_complex=True, no_int8=True)
     @testing.numpy_cupy_array_equal()
     def test_is_close_finite(self, xp, dtype):
-        if dtype in [xp.int8, xp.uint8]:
-            pytest.skip("avoid overflow")
         # In numpy<1.10 this test fails when dtype is bool
         a = xp.array([0.9e-5, 1.1e-5, 1000 + 1e-4, 1000 - 1e-4]).astype(dtype)
         b = xp.array([0, 0, 1000, 1000]).astype(dtype)

dpnp/tests/third_party/cupy/math_tests/test_matmul.py

@@ -60,39 +60,22 @@
 )
 class TestMatmul(unittest.TestCase):
 
-    # Avoid overflow
-    skip_dtypes = {
-        (numpy.int8, numpy.int8),
-        (numpy.int8, numpy.uint8),
-        (numpy.uint8, numpy.uint8),
-    }
-
-    @testing.for_all_dtypes(name="dtype1")
-    @testing.for_all_dtypes(name="dtype2")
+    @testing.for_all_dtypes(name="dtype1", no_int8=True)
+    @testing.for_all_dtypes(name="dtype2", no_int8=True)
     @testing.numpy_cupy_allclose(
         rtol=1e-3, atol=1e-3, type_check=has_support_aspect64()
     )  # required for uint8
     def test_operator_matmul(self, xp, dtype1, dtype2):
-        if (dtype1, dtype2) in self.skip_dtypes or (
-            dtype2,
-            dtype1,
-        ) in self.skip_dtypes:
-            pytest.skip("avoid overflow")
         x1 = testing.shaped_arange(self.shape_pair[0], xp, dtype1)
         x2 = testing.shaped_arange(self.shape_pair[1], xp, dtype2)
         return operator.matmul(x1, x2)
 
-    @testing.for_all_dtypes(name="dtype1")
-    @testing.for_all_dtypes(name="dtype2")
+    @testing.for_all_dtypes(name="dtype1", no_int8=True)
+    @testing.for_all_dtypes(name="dtype2", no_int8=True)
     @testing.numpy_cupy_allclose(
         rtol=1e-3, atol=1e-3, type_check=has_support_aspect64()
     )  # required for uint8
     def test_cupy_matmul(self, xp, dtype1, dtype2):
-        if (dtype1, dtype2) in self.skip_dtypes or (
-            dtype2,
-            dtype1,
-        ) in self.skip_dtypes:
-            pytest.skip("avoid overflow")
         x1 = testing.shaped_arange(self.shape_pair[0], xp, dtype1)
         x2 = testing.shaped_arange(self.shape_pair[1], xp, dtype2)
         return xp.matmul(x1, x2)
@@ -114,25 +97,12 @@ def test_cupy_matmul(self, xp, dtype1, dtype2):
 )
 class TestMatmulOut(unittest.TestCase):
 
-    # Avoid overflow
-    skip_dtypes = {
-        (numpy.int8, numpy.int8),
-        (numpy.int8, numpy.uint8),
-        (numpy.uint8, numpy.uint8),
-    }
-
-    @testing.for_all_dtypes(name="dtype1")
-    @testing.for_all_dtypes(name="dtype2")
+    @testing.for_all_dtypes(name="dtype1", no_int8=True)
+    @testing.for_all_dtypes(name="dtype2", no_int8=True)
     @testing.numpy_cupy_allclose(
         rtol=1e-3, atol=1e-3, accept_error=TypeError  # required for uint8
     )
     def test_cupy_matmul_noncontiguous(self, xp, dtype1, dtype2):
-        if (dtype1, dtype2) in self.skip_dtypes or (
-            dtype2,
-            dtype1,
-        ) in self.skip_dtypes:
-            pytest.skip("avoid overflow")
-
         x1 = testing.shaped_arange(self.shape_pair[0], xp, dtype1)
         x2 = testing.shaped_arange(self.shape_pair[1], xp, dtype2)
         out = xp.zeros(self.shape_pair[2], dtype=dtype1)[::-1]
@@ -170,11 +140,9 @@ def test_overlap_both(self, xp, dtype, shape):
 
 class TestMatmulStrides:
 
-    @testing.for_all_dtypes()
+    @testing.for_all_dtypes(no_int8=True)
     @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-3)  # required for uint8
     def test_relaxed_c_contiguous_input(self, xp, dtype):
-        if dtype in [numpy.int8, numpy.uint8]:
-            pytest.skip("avoid overflow")
         x1 = testing.shaped_arange((2, 2, 3), xp, dtype)[:, None, :, :]
         x2 = testing.shaped_arange((2, 1, 3, 1), xp, dtype)
         return x1 @ x2

dpnp/tests/third_party/cupy/testing/_loops.py

@@ -1091,7 +1091,7 @@ def _get_int_bool_dtypes():
 _dtypes = _float_dtypes + _int_bool_dtypes
 
 
-def _make_all_dtypes(no_float16, no_bool, no_complex):
+def _make_all_dtypes(no_float16, no_bool, no_complex, no_int8):
     if no_float16:
         dtypes = _regular_float_dtypes
     else:
@@ -1102,14 +1102,24 @@ def _make_all_dtypes(no_float16, no_bool, no_complex):
     else:
         dtypes += _int_bool_dtypes
 
+    if no_int8:
+        _dtypes = list(dtypes)
+        _dtypes.remove(numpy.int8)
+        _dtypes.remove(numpy.uint8)
+        dtypes = tuple(_dtypes)
+
     if config.complex_types and not no_complex:
         dtypes += _complex_dtypes
 
     return dtypes
 
 
 def for_all_dtypes(
-    name="dtype", no_float16=False, no_bool=False, no_complex=False
+    name="dtype",
+    no_float16=False,
+    no_bool=False,
+    no_complex=False,
+    no_int8=False,
 ):
     """Decorator that checks the fixture with all dtypes.
 
@@ -1121,6 +1131,9 @@ def for_all_dtypes(
              omitted from candidate dtypes.
          no_complex(bool): If ``True``, ``numpy.complex64`` and
              ``numpy.complex128`` are omitted from candidate dtypes.
+         no_int8(bool): If ``True``, ``numpy.int8`` and
+             ``numpy.uint8`` are omitted from candidate dtypes.
+             This option is generally used to avoid overflow.
 
     dtypes to be tested: ``numpy.complex64`` (optional),
     ``numpy.complex128`` (optional),
@@ -1164,7 +1177,7 @@ def for_all_dtypes(
     .. seealso:: :func:`cupy.testing.for_dtypes`
     """
     return for_dtypes(
-        _make_all_dtypes(no_float16, no_bool, no_complex), name=name
+        _make_all_dtypes(no_float16, no_bool, no_complex, no_int8), name=name
     )
 
 
@@ -1334,6 +1347,7 @@ def for_all_dtypes_combination(
     no_bool=False,
     full=None,
     no_complex=False,
+    no_int8=False,
 ):
     """Decorator that checks the fixture with a product set of all dtypes.
 
@@ -1347,12 +1361,15 @@ def for_all_dtypes_combination(
              will be tested.
              Otherwise, the subset of combinations will be tested
              (see description in :func:`cupy.testing.for_dtypes_combination`).
-         no_complex(bool): If, True, ``numpy.complex64`` and
+         no_complex(bool): If, ``True``, ``numpy.complex64`` and
              ``numpy.complex128`` are omitted from candidate dtypes.
+         no_int8(bool): If, ``True``, ``numpy.int8`` and
+             ``numpy.uint8`` are omitted from candidate dtypes.
+             This option is generally used to avoid overflow.
 
     .. seealso:: :func:`cupy.testing.for_dtypes_combination`
     """
-    types = _make_all_dtypes(no_float16, no_bool, no_complex)
+    types = _make_all_dtypes(no_float16, no_bool, no_complex, no_int8)
     return for_dtypes_combination(types, names, full)