Update random_tests/test_sample.py

Author: antonwolfy

dpnp/tests/third_party/cupy/random_tests/test_sample.py

@@ -11,63 +11,61 @@
 
 
 class TestRandint(unittest.TestCase):
+
     def test_lo_hi_reversed(self):
         with self.assertRaises(ValueError):
             random.randint(100, 1)
 
     def test_lo_hi_equal(self):
         with self.assertRaises(ValueError):
-            random.randint(3, 3, size=3)
+            random.randint(3, 3, size=0)
 
         with self.assertRaises(ValueError):
             # int(-0.2) is not less than int(0.3)
             random.randint(-0.2, 0.3)
 
     def test_lo_hi_nonrandom(self):
         a = random.randint(-0.9, 1.1, size=3)
-        numpy.testing.assert_array_equal(a, cupy.full((3,), 0))
+        testing.assert_array_equal(a, cupy.full((3,), 0))
 
         a = random.randint(-1.1, -0.9, size=(2, 2))
-        numpy.testing.assert_array_equal(a, cupy.full((2, 2), -1))
+        testing.assert_array_equal(a, cupy.full((2, 2), -1))
 
     def test_zero_sizes(self):
         a = random.randint(10, size=(0,))
-        numpy.testing.assert_array_equal(a, cupy.array(()))
+        testing.assert_array_equal(a, cupy.array(()))
 
         a = random.randint(10, size=0)
-        numpy.testing.assert_array_equal(a, cupy.array(()))
+        testing.assert_array_equal(a, cupy.array(()))
 
 
 @testing.fix_random()
 class TestRandint2(unittest.TestCase):
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
+
     @_condition.repeat(3, 10)
     def test_bound_1(self):
-        vals = [random.randint(0, 10, (2, 3)) for _ in range(10)]
+        vals = [random.randint(0, 10, (2, 3)) for _ in range(20)]
         for val in vals:
-            self.assertEqual(val.shape, (2, 3))
-        self.assertEqual(min(_.min() for _ in vals), 0)
-        self.assertEqual(max(_.max() for _ in vals), 9)
+            assert val.shape == (2, 3)
+        assert min(_.min() for _ in vals) == 0
+        assert max(_.max() for _ in vals) == 9
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @_condition.repeat(3, 10)
     def test_bound_2(self):
         vals = [random.randint(0, 2) for _ in range(20)]
         for val in vals:
-            self.assertEqual(val.shape, ())
-        self.assertEqual(min(_.min() for _ in vals), 0)
-        self.assertEqual(max(_.max() for _ in vals), 1)
+            assert val.shape == ()
+        assert min(vals) == 0
+        assert max(vals) == 1
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @_condition.repeat(3, 10)
     def test_bound_overflow(self):
         # 100 - (-100) exceeds the range of int8
         val = random.randint(numpy.int8(-100), numpy.int8(100), size=20)
-        self.assertEqual(val.shape, (20,))
-        self.assertGreaterEqual(val.min(), -100)
-        self.assertLess(val.max(), 100)
+        assert val.shape == (20,)
+        assert val.min() >= -100
+        assert val.max() < 100
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @_condition.repeat(3, 10)
     def test_bound_float1(self):
         # generate floats s.t. int(low) < int(high)
@@ -76,70 +74,78 @@ def test_bound_float1(self):
         high += 1
         vals = [random.randint(low, high, (2, 3)) for _ in range(10)]
         for val in vals:
-            self.assertEqual(val.shape, (2, 3))
-        self.assertEqual(min(_.min() for _ in vals), int(low))
-        self.assertEqual(max(_.max() for _ in vals), int(high) - 1)
+            assert val.shape == (2, 3)
+        assert min(_.min() for _ in vals) == int(low)
+        assert max(_.max() for _ in vals) == int(high) - 1
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_bound_float2(self):
         vals = [random.randint(-1.0, 1.0, (2, 3)) for _ in range(10)]
         for val in vals:
-            self.assertEqual(val.shape, (2, 3))
-        self.assertEqual(min(_.min() for _ in vals), -1)
-        self.assertEqual(max(_.max() for _ in vals), 0)
+            assert val.shape == (2, 3)
+        assert min(_.min() for _ in vals) == -1
+        assert max(_.max() for _ in vals) == 0
 
     @_condition.repeat(3, 10)
     def test_goodness_of_fit(self):
         mx = 5
         trial = 100
-        vals = [numpy.random.randint(mx) for _ in range(trial)]
+        vals = [random.randint(mx) for _ in range(trial)]
         counts = numpy.histogram(vals, bins=numpy.arange(mx + 1))[0]
         expected = numpy.array([float(trial) / mx] * mx)
-        self.assertTrue(_hypothesis.chi_square_test(counts, expected))
+        assert _hypothesis.chi_square_test(counts, expected)
 
     @_condition.repeat(3, 10)
     def test_goodness_of_fit_2(self):
         mx = 5
         vals = random.randint(mx, size=(5, 20))
         counts = numpy.histogram(vals, bins=numpy.arange(mx + 1))[0]
         expected = numpy.array([float(vals.size) / mx] * mx)
-        self.assertTrue(_hypothesis.chi_square_test(counts, expected))
+        assert _hypothesis.chi_square_test(counts, expected)
 
 
 class TestRandintDtype(unittest.TestCase):
-    # numpy.int8, numpy.uint8, numpy.int16, numpy.uint16, numpy.int32])
-    @testing.for_dtypes([numpy.int32])
+
+    @testing.with_requires("numpy>=2.0")
+    @testing.for_dtypes(
+        [numpy.int8, numpy.uint8, numpy.int16, numpy.uint16, numpy.int32]
+    )
     def test_dtype(self, dtype):
         size = (1000,)
         low = numpy.iinfo(dtype).min
-        high = numpy.iinfo(dtype).max
-        x = random.randint(low, high, size, dtype)
-        self.assertLessEqual(low, min(x))
-        self.assertLessEqual(max(x), high)
+        high = numpy.iinfo(dtype).max + 1
+        x = random.randint(low, high, size, dtype).get()
+        assert low <= min(x)
+        assert max(x) <= high
 
-    # @testing.for_int_dtypes(no_bool=True)
+    @pytest.mark.skip("high=(max+1) is not supported")
+    @testing.for_int_dtypes(no_bool=True)
     @testing.for_dtypes([numpy.int32])
     def test_dtype2(self, dtype):
         dtype = numpy.dtype(dtype)
 
+        # randint does not support 64 bit integers
+        if dtype in (numpy.int64, numpy.uint64):
+            return
+
         iinfo = numpy.iinfo(dtype)
         size = (10000,)
 
-        x = random.randint(iinfo.min, iinfo.max, size, dtype)
-        self.assertEqual(x.dtype, dtype)
-        self.assertLessEqual(iinfo.min, min(x))
-        self.assertLessEqual(max(x), iinfo.max)
+        x = random.randint(iinfo.min, iinfo.max + 1, size, dtype).get()
+        assert x.dtype == dtype
+        assert iinfo.min <= min(x)
+        assert max(x) <= iinfo.max
 
         # Lower bound check
-        with self.assertRaises(OverflowError):
+        with self.assertRaises(ValueError):
             random.randint(iinfo.min - 1, iinfo.min + 10, size, dtype)
 
         # Upper bound check
-        with self.assertRaises(OverflowError):
+        with self.assertRaises(ValueError):
             random.randint(iinfo.max - 10, iinfo.max + 2, size, dtype)
 
 
 class TestRandomIntegers(unittest.TestCase):
+
     def test_normal(self):
         with mock.patch("dpnp.random.RandomState.randint") as m:
             random.random_integers(3, 5)
@@ -164,50 +170,53 @@ def test_size_is_not_none(self):
 
 @testing.fix_random()
 class TestRandomIntegers2(unittest.TestCase):
+
     @_condition.repeat(3, 10)
     def test_bound_1(self):
-        vals = [random.random_integers(0, 10, (2, 3)).get() for _ in range(10)]
+        vals = [random.random_integers(0, 10, (2, 3)) for _ in range(10)]
         for val in vals:
-            self.assertEqual(val.shape, (2, 3))
-        self.assertEqual(min(_.min() for _ in vals), 0)
-        self.assertEqual(max(_.max() for _ in vals), 10)
+            assert val.shape == (2, 3)
+        assert min(_.min() for _ in vals) == 0
+        assert max(_.max() for _ in vals) == 10
 
     @_condition.repeat(3, 10)
     def test_bound_2(self):
-        vals = [random.random_integers(0, 2).get() for _ in range(20)]
+        vals = [random.random_integers(0, 2) for _ in range(20)]
         for val in vals:
-            self.assertEqual(val.shape, ())
-        self.assertEqual(min(vals), 0)
-        self.assertEqual(max(vals), 2)
+            assert val.shape == ()
+        assert min(vals) == 0
+        assert max(vals) == 2
 
     @_condition.repeat(3, 10)
     def test_goodness_of_fit(self):
         mx = 5
         trial = 100
-        vals = [random.randint(0, mx).get() for _ in range(trial)]
+        vals = [random.randint(0, mx) for _ in range(trial)]
         counts = numpy.histogram(vals, bins=numpy.arange(mx + 1))[0]
         expected = numpy.array([float(trial) / mx] * mx)
-        self.assertTrue(_hypothesis.chi_square_test(counts, expected))
+        assert _hypothesis.chi_square_test(counts, expected)
 
     @_condition.repeat(3, 10)
     def test_goodness_of_fit_2(self):
         mx = 5
-        vals = random.randint(0, mx, (5, 20)).get()
+        vals = random.randint(0, mx, (5, 20))
         counts = numpy.histogram(vals, bins=numpy.arange(mx + 1))[0]
         expected = numpy.array([float(vals.size) / mx] * mx)
-        self.assertTrue(_hypothesis.chi_square_test(counts, expected))
+        assert _hypothesis.chi_square_test(counts, expected)
 
 
+@pytest.mark.skip("random.choice() is not supported yet")
 class TestChoice(unittest.TestCase):
+
     def setUp(self):
-        self.rs_tmp = random.generator._random_states
+        self.rs_tmp = random._generator._random_states
         device_id = cuda.Device().id
         self.m = mock.Mock()
         self.m.choice.return_value = 0
-        random.generator._random_states = {device_id: self.m}
+        random._generator._random_states = {device_id: self.m}
 
     def tearDown(self):
-        random.generator._random_states = self.rs_tmp
+        random._generator._random_states = self.rs_tmp
 
     def test_size_and_replace_and_p_are_none(self):
         random.choice(3)
@@ -243,10 +252,11 @@ def test_no_none(self):
 
 
 class TestRandomSample(unittest.TestCase):
+
     def test_rand(self):
-        # no keyword argument 'dtype' in dpnp
-        with self.assertRaises(TypeError):
-            random.rand(1, 2, 3, dtype=numpy.float32)
+        with mock.patch("dpnp.random.RandomState.random_sample") as m:
+            random.rand(1, 2, 3)
+        m.assert_called_once_with(size=(1, 2, 3), usm_type="device")
 
     def test_rand_default_dtype(self):
         with mock.patch("dpnp.random.RandomState.random_sample") as m:
@@ -280,12 +290,14 @@ def test_randn_invalid_argument(self):
     {"size": (1, 0)},
 )
 @testing.fix_random()
+@pytest.mark.skip("random.multinomial() is not fully supported")
 class TestMultinomial(unittest.TestCase):
+
     @_condition.repeat(3, 10)
     @testing.for_float_dtypes()
     @testing.numpy_cupy_allclose(rtol=0.05)
     def test_multinomial(self, xp, dtype):
         pvals = xp.array([0.2, 0.3, 0.5], dtype)
         x = xp.random.multinomial(100000, pvals, self.size)
-        self.assertEqual(x.dtype, "l")
+        assert x.dtype.kind == "l"
         return x / 100000