Update third party tests

Author: antonwolfy

dpnp/tests/third_party/cupy/core_tests/test_dlpack.py

@@ -41,14 +41,15 @@ def __dlpack_device__(self):
 @pytest.mark.skip("toDlpack() and fromDlpack() are not supported")
 class TestDLPackConversion:
 
-    @pytest.mark.filterwarnings("ignore::DeprecationWarning")
     @testing.for_all_dtypes(no_bool=False)
-    def test_conversion(self, dtype):
+    def test_conversion(self, dtype, recwarn):
         orig_array = _gen_array(dtype)
         tensor = orig_array.toDlpack()
         out_array = cupy.fromDlpack(tensor)
         testing.assert_array_equal(orig_array, out_array)
-        assert orig_array.get_array()._pointer == out_array.get_array()._pointer
+        testing.assert_array_equal(orig_array.data.ptr, out_array.data.ptr)
+        for w in recwarn:
+            assert issubclass(w.category, cupy.VisibleDeprecationWarning)
 
 
 class TestNewDLPackConversion:
@@ -82,7 +83,7 @@ def test_conversion(self, dtype):
         orig_array = _gen_array(dtype)
         out_array = cupy.from_dlpack(orig_array)
         testing.assert_array_equal(orig_array, out_array)
-        assert orig_array.get_array()._pointer == out_array.get_array()._pointer
+        testing.assert_array_equal(orig_array.data.ptr, out_array.data.ptr)
 
     @pytest.mark.skip("no limitations in from_dlpack()")
     def test_from_dlpack_and_conv_errors(self):
@@ -121,7 +122,7 @@ def test_conversion_max_version(self, kwargs, versioned):
         )
 
         testing.assert_array_equal(orig_array, out_array)
-        assert orig_array.get_array()._pointer == out_array.get_array()._pointer
+        testing.assert_array_equal(orig_array.data.ptr, out_array.data.ptr)
 
     def test_conversion_device(self):
         orig_array = _gen_array("float32")
@@ -135,7 +136,7 @@ def test_conversion_device(self):
         )
 
         testing.assert_array_equal(orig_array, out_array)
-        assert orig_array.get_array()._pointer == out_array.get_array()._pointer
+        testing.assert_array_equal(orig_array.data.ptr, out_array.data.ptr)
 
     def test_conversion_bad_device(self):
         arr = _gen_array("float32")
@@ -212,9 +213,8 @@ def test_stream(self):
                 out_array = dlp.from_dlpack_capsule(dltensor)
                 out_array = cupy.from_dlpack(out_array, device=dst_s)
                 testing.assert_array_equal(orig_array, out_array)
-                assert (
-                    orig_array.get_array()._pointer
-                    == out_array.get_array()._pointer
+                testing.assert_array_equal(
+                    orig_array.data.ptr, out_array.data.ptr
                 )
 
 
@@ -267,12 +267,13 @@ def test_deleter2(self, pool, max_version):
         # assert pool.n_free_blocks() == 1
 
     @pytest.mark.skip("toDlpack() and fromDlpack() are not supported")
-    @pytest.mark.filterwarnings("ignore::DeprecationWarning")
-    def test_multiple_consumption_error(self):
+    def test_multiple_consumption_error(self, recwarn):
         # Prevent segfault, see #3611
         array = cupy.empty(10)
         tensor = array.toDlpack()
         array2 = cupy.fromDlpack(tensor)
         with pytest.raises(ValueError) as e:
             array3 = cupy.fromDlpack(tensor)
         assert "consumed multiple times" in str(e.value)
+        for w in recwarn:
+            assert issubclass(w.category, cupy.VisibleDeprecationWarning)

dpnp/tests/third_party/cupy/core_tests/test_ndarray.py

@@ -43,13 +43,13 @@ def test_shape_not_integer(self):
 
     def test_shape_int_with_strides(self):
         dummy = cupy.ndarray(3)
-        a = cupy.ndarray(3, strides=(0,), buffer=dummy)
+        a = cupy.ndarray(3, strides=(0,), buffer=dummy.data)
         assert a.shape == (3,)
         assert a.strides == (0,)
 
     def test_memptr(self):
         a = cupy.arange(6).astype(numpy.float32).reshape((2, 3))
-        memptr = a
+        memptr = a.data
 
         b = cupy.ndarray((2, 3), numpy.float32, memptr)
         testing.assert_array_equal(a, b)
@@ -62,7 +62,7 @@ def test_memptr(self):
     )
     def test_memptr_with_strides(self):
         buf = cupy.ndarray(20, numpy.uint8)
-        memptr = buf
+        memptr = buf.data
 
         # self-overlapping strides
         a = cupy.ndarray((2, 3), numpy.float32, memptr, strides=(2, 1))
@@ -82,7 +82,9 @@ def test_strides_without_memptr(self):
 
     def test_strides_is_given_and_order_is_ignored(self):
         buf = cupy.ndarray(20, numpy.uint8)
-        a = cupy.ndarray((2, 3), numpy.float32, buf, strides=(2, 1), order="C")
+        a = cupy.ndarray(
+            (2, 3), numpy.float32, buf.data, strides=(2, 1), order="C"
+        )
         assert a.strides == (2, 1)
 
     @testing.with_requires("numpy>=1.19")

dpnp/tests/third_party/cupy/creation_tests/test_from_data.py

@@ -62,7 +62,7 @@ def test_array_from_numpy_broad_cast(self, xp, dtype, order):
     @testing.for_orders("CFAK", name="src_order")
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_from_list_of_numpy(self, xp, dtype, src_order, dst_order):
         # compares numpy.array(<list of numpy.ndarray>) with
         # cupy.array(<list of numpy.ndarray>)
@@ -75,7 +75,7 @@ def test_array_from_list_of_numpy(self, xp, dtype, src_order, dst_order):
     @testing.for_orders("CFAK", name="src_order")
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_from_list_of_numpy_view(
         self, xp, dtype, src_order, dst_order
     ):
@@ -93,7 +93,7 @@ def test_array_from_list_of_numpy_view(
 
     @testing.for_orders("CFAK")
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_from_list_of_numpy_scalar(self, xp, dtype, order):
         # compares numpy.array(<list of numpy.ndarray>) with
         # cupy.array(<list of numpy.ndarray>)
@@ -103,7 +103,7 @@ def test_array_from_list_of_numpy_scalar(self, xp, dtype, order):
     @testing.for_orders("CFAK", name="src_order")
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_from_nested_list_of_numpy(
         self, xp, dtype, src_order, dst_order
     ):
@@ -118,7 +118,9 @@ def test_array_from_nested_list_of_numpy(
     @testing.for_orders("CFAK", name="src_order")
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes_combination(names=("dtype1", "dtype2"))
-    @testing.numpy_cupy_array_equal(type_check=has_support_aspect64())
+    @testing.numpy_cupy_array_equal(
+        type_check=has_support_aspect64(), strides_check=True
+    )
     def test_array_from_list_of_cupy(
         self, xp, dtype1, dtype2, src_order, dst_order
     ):
@@ -133,7 +135,7 @@ def test_array_from_list_of_cupy(
     @testing.for_orders("CFAK", name="src_order")
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_from_list_of_cupy_view(
         self, xp, dtype, src_order, dst_order
     ):
@@ -152,7 +154,7 @@ def test_array_from_list_of_cupy_view(
     @testing.for_orders("CFAK", name="src_order")
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_from_nested_list_of_cupy(
         self, xp, dtype, src_order, dst_order
     ):
@@ -166,7 +168,7 @@ def test_array_from_nested_list_of_cupy(
 
     @testing.for_orders("CFAK")
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_from_list_of_cupy_scalar(self, xp, dtype, order):
         # compares numpy.array(<list of numpy.ndarray>) with
         # cupy.array(<list of cupy.ndarray>)
@@ -240,7 +242,7 @@ def test_array_copy_with_dtype_being_none(self, xp, order):
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes(name="dtype1", no_complex=True)
     @testing.for_all_dtypes(name="dtype2")
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_copy_list_of_numpy_with_dtype(
         self, xp, dtype1, dtype2, src_order, dst_order
     ):
@@ -256,7 +258,7 @@ def test_array_copy_list_of_numpy_with_dtype(
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes(name="dtype1", no_complex=True)
     @testing.for_all_dtypes(name="dtype2")
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_copy_list_of_numpy_with_dtype_char(
         self, xp, dtype1, dtype2, src_order, dst_order
     ):
@@ -272,7 +274,7 @@ def test_array_copy_list_of_numpy_with_dtype_char(
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes(name="dtype1", no_complex=True)
     @testing.for_all_dtypes(name="dtype2")
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_copy_list_of_cupy_with_dtype(
         self, xp, dtype1, dtype2, src_order, dst_order
     ):
@@ -288,7 +290,7 @@ def test_array_copy_list_of_cupy_with_dtype(
     @testing.for_orders("CFAK", name="dst_order")
     @testing.for_all_dtypes(name="dtype1", no_complex=True)
     @testing.for_all_dtypes(name="dtype2")
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(strides_check=True)
     def test_array_copy_list_of_cupy_with_dtype_char(
         self, xp, dtype1, dtype2, src_order, dst_order
     ):
@@ -656,7 +658,7 @@ def test_with_strides(self, dtype):
             DummyObjectWithCudaArrayInterface(a, self.ver, self.strides)
         )
         assert a.strides == b.strides
-        assert a.nbytes == b.nbytes
+        assert a.nbytes == b.data.mem.size
 
     @testing.for_all_dtypes()
     def test_with_zero_size_array(self, dtype):
@@ -665,7 +667,8 @@ def test_with_zero_size_array(self, dtype):
             DummyObjectWithCudaArrayInterface(a, self.ver, self.strides)
         )
         assert a.strides == b.strides
-        assert a.nbytes == b.nbytes
+        assert a.nbytes == b.data.mem.size
+        assert a.data.ptr == 0
         assert a.size == 0
 
     @testing.for_all_dtypes()
@@ -724,7 +727,7 @@ def test_with_over_size_array(self):
         testing.assert_array_equal(a, b)
 
 
-class DummyObjectWithCudaArrayInterface(object):
+class DummyObjectWithCudaArrayInterface:
     def __init__(self, a, ver, include_strides=False, mask=None, stream=None):
         assert ver in tuple(range(max_cuda_array_interface_version + 1))
         self.a = None
@@ -834,7 +837,7 @@ def test_cupy_array(self, dtype):
         is_copied = not (
             (actual is a)
             or (self.xp is cupy)
-            and (a.get_array()._pointer == actual.get_array()._pointer)
+            and (a.data.ptr == actual.data.ptr)
         )
         assert should_copy == is_copied
 

dpnp/tests/third_party/cupy/misc_tests/test_byte_bounds.py

@@ -8,74 +8,68 @@ class TestByteBounds:
     def test_1d_contiguous(self, dtype):
         a = cupy.zeros(12, dtype=dtype)
         itemsize = a.itemsize
-        a_low = a.get_array()._pointer
-        a_high = a.get_array()._pointer + 12 * itemsize
+        a_low = a.data.ptr
+        a_high = a.data.ptr + 12 * itemsize
         assert cupy.byte_bounds(a) == (a_low, a_high)
 
     @testing.for_all_dtypes()
     def test_2d_contiguous(self, dtype):
         a = cupy.zeros((4, 7), dtype=dtype)
         itemsize = a.itemsize
-        a_low = a.get_array()._pointer
-        a_high = a.get_array()._pointer + 4 * 7 * itemsize
+        a_low = a.data.ptr
+        a_high = a.data.ptr + 4 * 7 * itemsize
         assert cupy.byte_bounds(a) == (a_low, a_high)
 
     @testing.for_all_dtypes()
     def test_1d_noncontiguous_pos_stride(self, dtype):
         a = cupy.zeros(12, dtype=dtype)
         itemsize = a.itemsize
         b = a[::2]
-        b_low = b.get_array()._pointer
-        b_high = b.get_array()._pointer + 11 * itemsize  # a[10]
+        b_low = b.data.ptr
+        b_high = b.data.ptr + 11 * itemsize  # a[10]
         assert cupy.byte_bounds(b) == (b_low, b_high)
 
     @testing.for_all_dtypes()
     def test_2d_noncontiguous_pos_stride(self, dtype):
         a = cupy.zeros((4, 7), dtype=dtype)
         b = a[::2, ::2]
         itemsize = b.itemsize
-        b_low = a.get_array()._pointer
-        b_high = b.get_array()._pointer + 3 * 7 * itemsize  # a[2][6]
+        b_low = a.data.ptr
+        b_high = b.data.ptr + 3 * 7 * itemsize  # a[2][6]
         assert cupy.byte_bounds(b) == (b_low, b_high)
 
     @testing.for_all_dtypes()
     def test_1d_contiguous_neg_stride(self, dtype):
         a = cupy.zeros(12, dtype=dtype)
         b = a[::-1]
         itemsize = b.itemsize
-        b_low = b.get_array()._pointer - 11 * itemsize
-        b_high = b.get_array()._pointer + 1 * itemsize
+        b_low = b.data.ptr - 11 * itemsize
+        b_high = b.data.ptr + 1 * itemsize
         assert cupy.byte_bounds(b) == (b_low, b_high)
 
     @testing.for_all_dtypes()
     def test_2d_noncontiguous_neg_stride(self, dtype):
         a = cupy.zeros((4, 7), dtype=dtype)
         b = a[::-2, ::-2]  # strides = (-56, -8), shape = (2, 4)
         itemsize = b.itemsize
-        b_low = (
-            b.get_array()._pointer
-            - 2 * 7 * itemsize * (2 - 1)
-            - 2 * itemsize * (4 - 1)
-        )
-        b_high = b.get_array()._pointer + 1 * itemsize
+        b_low = b.data.ptr - 2 * 7 * itemsize * (2 - 1) - 2 * itemsize * (4 - 1)
+        b_high = b.data.ptr + 1 * itemsize
         assert cupy.byte_bounds(b) == (b_low, b_high)
 
     @testing.for_all_dtypes()
     def test_2d_noncontiguous_posneg_stride_1(self, dtype):
         a = cupy.zeros((4, 7), dtype=dtype)
         b = a[::1, ::-1]  # strides = (28, -4), shape=(4, 7)
         itemsize = b.itemsize
-        b_low = b.get_array()._pointer - itemsize * (7 - 1)
-        b_high = b.get_array()._pointer + 1 * itemsize + 7 * itemsize * (4 - 1)
+        b_low = b.data.ptr - itemsize * (7 - 1)
+        b_high = b.data.ptr + 1 * itemsize + 7 * itemsize * (4 - 1)
         assert cupy.byte_bounds(b) == (b_low, b_high)
 
     @testing.for_all_dtypes()
     def test_2d_noncontiguous_posneg_stride_2(self, dtype):
         a = cupy.zeros((4, 7), dtype=dtype)
         b = a[::2, ::-2]  # strides = (56, -8), shape=(2, 4)
         itemsize = b.itemsize
-        b_low = b.get_array()._pointer - 2 * itemsize * (4 - 1)
-        b_high = (
-            b.get_array()._pointer + 1 * itemsize + 2 * 7 * itemsize * (2 - 1)
-        )
+        b_low = b.data.ptr - 2 * itemsize * (4 - 1)
+        b_high = b.data.ptr + 1 * itemsize + 2 * 7 * itemsize * (2 - 1)
         assert cupy.byte_bounds(b) == (b_low, b_high)