from __future__ import print_function, division, absolute_import import copy as copylib import sys # unittest only added in 3.4 self.subTest() if sys.version_info[0] < 3 or sys.version_info[1] < 4: import unittest2 as unittest else: import unittest # unittest.mock is not available in 2.7 (though unittest2 might contain it?) try: import unittest.mock as mock except ImportError: import mock import numpy as np import imgaug as ia import imgaug.augmenters as iaa from imgaug.testutils import reseed import imgaug.random as iarandom NP_VERSION = np.__version__ IS_NP_117_OR_HIGHER = ( NP_VERSION.startswith("2.") or NP_VERSION.startswith("1.25") or NP_VERSION.startswith("1.24") or NP_VERSION.startswith("1.23") or NP_VERSION.startswith("1.22") or NP_VERSION.startswith("1.21") or NP_VERSION.startswith("1.20") or NP_VERSION.startswith("1.19") or NP_VERSION.startswith("1.18") or NP_VERSION.startswith("1.17") ) class _Base(unittest.TestCase): def setUp(self): reseed() class TestConstants(_Base): def test_supports_new_np_rng_style_is_true(self): assert iarandom.SUPPORTS_NEW_NP_RNG_STYLE is IS_NP_117_OR_HIGHER def test_global_rng(self): iarandom.get_global_rng() # creates global RNG upon first call assert iarandom.GLOBAL_RNG is not None class TestRNG(_Base): @mock.patch("imgaug.random.normalize_generator_") def test___init___calls_normalize_mocked(self, mock_norm): _ = iarandom.RNG(0) mock_norm.assert_called_once_with(0) def test___init___with_rng(self): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(rng1) assert rng2.generator is rng1.generator @mock.patch("imgaug.random.get_generator_state") def test_state_getter_mocked(self, mock_get): mock_get.return_value = "mock" rng = iarandom.RNG(0) result = rng.state assert result == "mock" mock_get.assert_called_once_with(rng.generator) @mock.patch("imgaug.random.RNG.set_state_") def test_state_setter_mocked(self, mock_set): rng = iarandom.RNG(0) state = {"foo"} rng.state = state mock_set.assert_called_once_with(state) @mock.patch("imgaug.random.set_generator_state_") def test_set_state__mocked(self, mock_set): rng = iarandom.RNG(0) state = {"foo"} result = rng.set_state_(state) assert result is rng mock_set.assert_called_once_with(rng.generator, state) @mock.patch("imgaug.random.set_generator_state_") def test_use_state_of__mocked(self, mock_set): rng1 = iarandom.RNG(0) rng2 = mock.MagicMock() state = {"foo"} rng2.state = state result = rng1.use_state_of_(rng2) assert result == rng1 mock_set.assert_called_once_with(rng1.generator, state) @mock.patch("imgaug.random.get_global_rng") def test_is_global__is_global__rng_mocked(self, mock_get): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(rng1.generator) mock_get.return_value = rng2 assert rng1.is_global_rng() is True @mock.patch("imgaug.random.get_global_rng") def test_is_global_rng__is_not_global__mocked(self, mock_get): rng1 = iarandom.RNG(0) # different instance with same state/seed should still be viewed as # different by the method rng2 = iarandom.RNG(0) mock_get.return_value = rng2 assert rng1.is_global_rng() is False @mock.patch("imgaug.random.get_global_rng") def test_equals_global_rng__is_global__mocked(self, mock_get): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(0) mock_get.return_value = rng2 assert rng1.equals_global_rng() is True @mock.patch("imgaug.random.get_global_rng") def test_equals_global_rng__is_not_global__mocked(self, mock_get): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(1) mock_get.return_value = rng2 assert rng1.equals_global_rng() is False @mock.patch("imgaug.random.generate_seed_") def test_generate_seed__mocked(self, mock_gen): rng = iarandom.RNG(0) mock_gen.return_value = -1 seed = rng.generate_seed_() assert seed == -1 mock_gen.assert_called_once_with(rng.generator) @mock.patch("imgaug.random.generate_seeds_") def test_generate_seeds__mocked(self, mock_gen): rng = iarandom.RNG(0) mock_gen.return_value = [-1, -2] seeds = rng.generate_seeds_(2) assert seeds == [-1, -2] mock_gen.assert_called_once_with(rng.generator, 2) @mock.patch("imgaug.random.reset_generator_cache_") def test_reset_cache__mocked(self, mock_reset): rng = iarandom.RNG(0) result = rng.reset_cache_() assert result is rng mock_reset.assert_called_once_with(rng.generator) @mock.patch("imgaug.random.derive_generators_") def test_derive_rng__mocked(self, mock_derive): gen = iarandom.convert_seed_to_generator(0) mock_derive.return_value = [gen] rng = iarandom.RNG(0) result = rng.derive_rng_() assert result.generator is gen mock_derive.assert_called_once_with(rng.generator, 1) @mock.patch("imgaug.random.derive_generators_") def test_derive_rngs__mocked(self, mock_derive): gen1 = iarandom.convert_seed_to_generator(0) gen2 = iarandom.convert_seed_to_generator(1) mock_derive.return_value = [gen1, gen2] rng = iarandom.RNG(0) result = rng.derive_rngs_(2) assert result[0].generator is gen1 assert result[1].generator is gen2 mock_derive.assert_called_once_with(rng.generator, 2) @mock.patch("imgaug.random.is_generator_equal_to") def test_equals_mocked(self, mock_equal): mock_equal.return_value = "foo" rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(1) result = rng1.equals(rng2) assert result == "foo" mock_equal.assert_called_once_with(rng1.generator, rng2.generator) def test_equals_identical_generators(self): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(rng1) assert rng1.equals(rng2) def test_equals_with_similar_generators(self): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(0) assert rng1.equals(rng2) def test_equals_with_different_generators(self): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(1) assert not rng1.equals(rng2) def test_equals_with_advanced_generator(self): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(0) rng2.advance_() assert not rng1.equals(rng2) @mock.patch("imgaug.random.advance_generator_") def test_advance__mocked(self, mock_advance): rng = iarandom.RNG(0) result = rng.advance_() assert result is rng mock_advance.assert_called_once_with(rng.generator) @mock.patch("imgaug.random.copy_generator") def test_copy_mocked(self, mock_copy): rng1 = iarandom.RNG(0) rng2 = iarandom.RNG(1) mock_copy.return_value = rng2.generator result = rng1.copy() assert result.generator is rng2.generator mock_copy.assert_called_once_with(rng1.generator) @mock.patch("imgaug.random.RNG.copy") @mock.patch("imgaug.random.RNG.is_global_rng") def test_copy_unless_global_rng__is_global__mocked(self, mock_is_global, mock_copy): rng = iarandom.RNG(0) mock_is_global.return_value = True mock_copy.return_value = "foo" result = rng.copy_unless_global_rng() assert result is rng mock_is_global.assert_called_once_with() assert mock_copy.call_count == 0 @mock.patch("imgaug.random.RNG.copy") @mock.patch("imgaug.random.RNG.is_global_rng") def test_copy_unless_global_rng__is_not_global__mocked(self, mock_is_global, mock_copy): rng = iarandom.RNG(0) mock_is_global.return_value = False mock_copy.return_value = "foo" result = rng.copy_unless_global_rng() assert result is "foo" mock_is_global.assert_called_once_with() mock_copy.assert_called_once_with() def test_duplicate(self): rng = iarandom.RNG(0) rngs = rng.duplicate(1) assert rngs == [rng] def test_duplicate_two_entries(self): rng = iarandom.RNG(0) rngs = rng.duplicate(2) assert rngs == [rng, rng] @mock.patch("imgaug.random.create_fully_random_generator") def test_create_fully_random_mocked(self, mock_create): gen = iarandom.convert_seed_to_generator(0) mock_create.return_value = gen rng = iarandom.RNG.create_fully_random() mock_create.assert_called_once_with() assert rng.generator is gen @mock.patch("imgaug.random.derive_generators_") def test_create_pseudo_random__mocked(self, mock_get): rng_glob = iarandom.get_global_rng() rng = iarandom.RNG(0) mock_get.return_value = [rng.generator] result = iarandom.RNG.create_pseudo_random_() assert result.generator is rng.generator mock_get.assert_called_once_with(rng_glob.generator, 1) @mock.patch("imgaug.random.polyfill_integers") def test_integers_mocked(self, mock_func): mock_func.return_value = "foo" rng = iarandom.RNG(0) result = rng.integers(low=0, high=1, size=(1,), dtype="int64", endpoint=True) assert result == "foo" mock_func.assert_called_once_with( rng.generator, low=0, high=1, size=(1,), dtype="int64", endpoint=True) @mock.patch("imgaug.random.polyfill_random") def test_random_mocked(self, mock_func): mock_func.return_value = "foo" rng = iarandom.RNG(0) out = np.zeros((1,), dtype="float64") result = rng.random(size=(1,), dtype="float64", out=out) assert result == "foo" mock_func.assert_called_once_with( rng.generator, size=(1,), dtype="float64", out=out) # TODO below test for generator methods are all just mock-based, add # non-mocked versions def test_choice_mocked(self): self._test_sampling_func("choice", a=[1, 2, 3], size=(1,), replace=False, p=[0.1, 0.2, 0.7]) def test_bytes_mocked(self): self._test_sampling_func("bytes", length=[10]) def test_shuffle_mocked(self): mock_gen = mock.MagicMock() rng = iarandom.RNG(0) rng.generator = mock_gen rng.shuffle([1, 2, 3]) mock_gen.shuffle.assert_called_once_with([1, 2, 3]) def test_permutation_mocked(self): mock_gen = mock.MagicMock() rng = iarandom.RNG(0) rng.generator = mock_gen mock_gen.permutation.return_value = "foo" result = rng.permutation([1, 2, 3]) assert result == "foo" mock_gen.permutation.assert_called_once_with([1, 2, 3]) def test_beta_mocked(self): self._test_sampling_func("beta", a=1.0, b=2.0, size=(1,)) def test_binomial_mocked(self): self._test_sampling_func("binomial", n=10, p=0.1, size=(1,)) def test_chisquare_mocked(self): self._test_sampling_func("chisquare", df=2, size=(1,)) def test_dirichlet_mocked(self): self._test_sampling_func("dirichlet", alpha=0.1, size=(1,)) def test_exponential_mocked(self): self._test_sampling_func("exponential", scale=1.1, size=(1,)) def test_f_mocked(self): self._test_sampling_func("f", dfnum=1, dfden=2, size=(1,)) def test_gamma_mocked(self): self._test_sampling_func("gamma", shape=1, scale=1.2, size=(1,)) def test_geometric_mocked(self): self._test_sampling_func("geometric", p=0.5, size=(1,)) def test_gumbel_mocked(self): self._test_sampling_func("gumbel", loc=0.1, scale=1.1, size=(1,)) def test_hypergeometric_mocked(self): self._test_sampling_func("hypergeometric", ngood=2, nbad=4, nsample=6, size=(1,)) def test_laplace_mocked(self): self._test_sampling_func("laplace", loc=0.5, scale=1.5, size=(1,)) def test_logistic_mocked(self): self._test_sampling_func("logistic", loc=0.5, scale=1.5, size=(1,)) def test_lognormal_mocked(self): self._test_sampling_func("lognormal", mean=0.5, sigma=1.5, size=(1,)) def test_logseries_mocked(self): self._test_sampling_func("logseries", p=0.5, size=(1,)) def test_multinomial_mocked(self): self._test_sampling_func("multinomial", n=5, pvals=0.5, size=(1,)) def test_multivariate_normal_mocked(self): self._test_sampling_func("multivariate_normal", mean=0.5, cov=1.0, size=(1,), check_valid="foo", tol=1e-2) def test_negative_binomial_mocked(self): self._test_sampling_func("negative_binomial", n=10, p=0.5, size=(1,)) def test_noncentral_chisquare_mocked(self): self._test_sampling_func("noncentral_chisquare", df=0.5, nonc=1.0, size=(1,)) def test_noncentral_f_mocked(self): self._test_sampling_func("noncentral_f", dfnum=0.5, dfden=1.5, nonc=2.0, size=(1,)) def test_normal_mocked(self): self._test_sampling_func("normal", loc=0.5, scale=1.0, size=(1,)) def test_pareto_mocked(self): self._test_sampling_func("pareto", a=0.5, size=(1,)) def test_poisson_mocked(self): self._test_sampling_func("poisson", lam=1.5, size=(1,)) def test_power_mocked(self): self._test_sampling_func("power", a=0.5, size=(1,)) def test_rayleigh_mocked(self): self._test_sampling_func("rayleigh", scale=1.5, size=(1,)) def test_standard_cauchy_mocked(self): self._test_sampling_func("standard_cauchy", size=(1,)) def test_standard_exponential_np117_mocked(self): fname = "standard_exponential" arr = np.zeros((1,), dtype="float16") args = [] kwargs = {"size": (1,), "dtype": "float16", "method": "foo", "out": arr} mock_gen = mock.MagicMock() getattr(mock_gen, fname).return_value = "foo" rng = iarandom.RNG(0) rng.generator = mock_gen rng._is_new_rng_style = True result = getattr(rng, fname)(*args, **kwargs) assert result == "foo" getattr(mock_gen, fname).assert_called_once_with(*args, **kwargs) def test_standard_exponential_np116_mocked(self): fname = "standard_exponential" arr_out = np.zeros((1,), dtype="float16") arr_result = np.ones((1,), dtype="float16") def _side_effect(x): return arr_result args = [] kwargs = {"size": (1,), "dtype": "float16", "method": "foo", "out": arr_out} kwargs_subcall = {"size": (1,)} mock_gen = mock.MagicMock() mock_gen.astype.side_effect = _side_effect getattr(mock_gen, fname).return_value = mock_gen rng = iarandom.RNG(0) rng.generator = mock_gen rng._is_new_rng_style = False result = getattr(rng, fname)(*args, **kwargs) getattr(mock_gen, fname).assert_called_once_with(*args, **kwargs_subcall) mock_gen.astype.assert_called_once_with("float16") assert np.allclose(result, arr_result) assert np.allclose(arr_out, arr_result) def test_standard_gamma_np117_mocked(self): fname = "standard_gamma" arr = np.zeros((1,), dtype="float16") args = [] kwargs = {"shape": 1.0, "size": (1,), "dtype": "float16", "out": arr} mock_gen = mock.MagicMock() getattr(mock_gen, fname).return_value = "foo" rng = iarandom.RNG(0) rng.generator = mock_gen rng._is_new_rng_style = True result = getattr(rng, fname)(*args, **kwargs) assert result == "foo" getattr(mock_gen, fname).assert_called_once_with(*args, **kwargs) def test_standard_gamma_np116_mocked(self): fname = "standard_gamma" arr_out = np.zeros((1,), dtype="float16") arr_result = np.ones((1,), dtype="float16") def _side_effect(x): return arr_result args = [] kwargs = {"shape": 1.0, "size": (1,), "dtype": "float16", "out": arr_out} kwargs_subcall = {"shape": 1.0, "size": (1,)} mock_gen = mock.MagicMock() mock_gen.astype.side_effect = _side_effect getattr(mock_gen, fname).return_value = mock_gen rng = iarandom.RNG(0) rng.generator = mock_gen rng._is_new_rng_style = False result = getattr(rng, fname)(*args, **kwargs) getattr(mock_gen, fname).assert_called_once_with(*args, **kwargs_subcall) mock_gen.astype.assert_called_once_with("float16") assert np.allclose(result, arr_result) assert np.allclose(arr_out, arr_result) def test_standard_normal_np117_mocked(self): fname = "standard_normal" arr = np.zeros((1,), dtype="float16") args = [] kwargs = {"size": (1,), "dtype": "float16", "out": arr} mock_gen = mock.MagicMock() getattr(mock_gen, fname).return_value = "foo" rng = iarandom.RNG(0) rng.generator = mock_gen rng._is_new_rng_style = True result = getattr(rng, fname)(*args, **kwargs) assert result == "foo" getattr(mock_gen, fname).assert_called_once_with(*args, **kwargs) def test_standard_normal_np116_mocked(self): fname = "standard_normal" arr_out = np.zeros((1,), dtype="float16") arr_result = np.ones((1,), dtype="float16") def _side_effect(x): return arr_result args = [] kwargs = {"size": (1,), "dtype": "float16", "out": arr_out} kwargs_subcall = {"size": (1,)} mock_gen = mock.MagicMock() mock_gen.astype.side_effect = _side_effect getattr(mock_gen, fname).return_value = mock_gen rng = iarandom.RNG(0) rng.generator = mock_gen rng._is_new_rng_style = False result = getattr(rng, fname)(*args, **kwargs) getattr(mock_gen, fname).assert_called_once_with(*args, **kwargs_subcall) mock_gen.astype.assert_called_once_with("float16") assert np.allclose(result, arr_result) assert np.allclose(arr_out, arr_result) def test_standard_t_mocked(self): self._test_sampling_func("standard_t", df=1.5, size=(1,)) def test_triangular_mocked(self): self._test_sampling_func("triangular", left=1.0, mode=1.5, right=2.0, size=(1,)) def test_uniform_mocked(self): self._test_sampling_func("uniform", low=0.5, high=1.5, size=(1,)) def test_vonmises_mocked(self): self._test_sampling_func("vonmises", mu=1.0, kappa=1.5, size=(1,)) def test_wald_mocked(self): self._test_sampling_func("wald", mean=0.5, scale=1.0, size=(1,)) def test_weibull_mocked(self): self._test_sampling_func("weibull", a=1.0, size=(1,)) def test_zipf_mocked(self): self._test_sampling_func("zipf", a=1.0, size=(1,)) @classmethod def _test_sampling_func(cls, fname, *args, **kwargs): mock_gen = mock.MagicMock() getattr(mock_gen, fname).return_value = "foo" rng = iarandom.RNG(0) rng.generator = mock_gen result = getattr(rng, fname)(*args, **kwargs) assert result == "foo" getattr(mock_gen, fname).assert_called_once_with(*args, **kwargs) # # outdated methods from RandomState # def test_rand_mocked(self): self._test_sampling_func_alias("rand", "random", 1, 2, 3) def test_randint_mocked(self): self._test_sampling_func_alias("randint", "integers", 0, 100) def randn(self): self._test_sampling_func_alias("randn", "standard_normal", 1, 2, 3) def random_integers(self): self._test_sampling_func_alias("random_integers", "integers", 1, 2) def random_sample(self): self._test_sampling_func_alias("random_sample", "uniform", (1, 2, 3)) def tomaxint(self): self._test_sampling_func_alias("tomaxint", "integers", (1, 2, 3)) def test_rand(self): result = iarandom.RNG(0).rand(10, 20, 3) assert result.dtype.name == "float32" assert result.shape == (10, 20, 3) assert np.all(result >= 0.0) assert np.all(result <= 1.0) assert np.any(result > 0.0) assert np.any(result < 1.0) def test_randint(self): result = iarandom.RNG(0).randint(10, 100, size=(10, 20, 3)) assert result.dtype.name == "int32" assert result.shape == (10, 20, 3) assert np.all(result >= 10) assert np.all(result <= 99) assert np.any(result > 10) assert np.any(result < 99) def test_randn(self): result = iarandom.RNG(0).randn(10, 50, 3) assert result.dtype.name == "float32" assert result.shape == (10, 50, 3) assert np.any(result > 0.5) assert np.any(result < -0.5) assert np.average(np.logical_or(result < 2.0, result > -2.0)) > 0.5 def test_random_integers(self): result = iarandom.RNG(0).random_integers(10, 100, size=(10, 20, 3)) assert result.dtype.name == "int32" assert result.shape == (10, 20, 3) assert np.all(result >= 10) assert np.all(result <= 100) assert np.any(result > 10) assert np.any(result < 100) def test_random_integers__no_high(self): result = iarandom.RNG(0).random_integers(100, size=(10, 20, 3)) assert result.dtype.name == "int32" assert result.shape == (10, 20, 3) assert np.all(result >= 1) assert np.all(result <= 100) assert np.any(result > 1) assert np.any(result < 100) def test_random_sample(self): result = iarandom.RNG(0).random_sample((10, 20, 3)) assert result.dtype.name == "float64" assert result.shape == (10, 20, 3) assert np.all(result >= 0.0) assert np.all(result <= 1.0) assert np.any(result > 0.0) assert np.any(result < 1.0) def test_tomaxint(self): result = iarandom.RNG(0).tomaxint((10, 200, 3)) assert result.dtype.name == "int32" assert result.shape == (10, 200, 3) assert np.all(result >= 0) assert np.any(result > 10000) @classmethod def _test_sampling_func_alias(cls, fname_alias, fname_subcall, *args, **kwargs): rng = iarandom.RNG(0) mock_func = mock.Mock() mock_func.return_value = "foo" setattr(rng, fname_subcall, mock_func) result = getattr(rng, fname_alias)(*args, **kwargs) assert result == "foo" assert mock_func.call_count == 1 class Test_supports_new_numpy_rng_style(_Base): def test_call(self): assert iarandom.supports_new_numpy_rng_style() is IS_NP_117_OR_HIGHER class Test_get_global_rng(_Base): def test_call(self): iarandom.seed(0) rng = iarandom.get_global_rng() expected = iarandom.RNG(0) assert rng is not None assert rng.equals(expected) class Test_seed(_Base): @mock.patch("imgaug.random._seed_np117_") @mock.patch("imgaug.random._seed_np116_") def test_mocked_call(self, mock_np116, mock_np117): iarandom.seed(1) if IS_NP_117_OR_HIGHER: mock_np117.assert_called_once_with(1) assert mock_np116.call_count == 0 else: mock_np116.assert_called_once_with(1) assert mock_np117.call_count == 0 def test_integrationtest(self): iarandom.seed(1) assert iarandom.GLOBAL_RNG.equals(iarandom.RNG(1)) def test_seed_affects_augmenters_created_after_its_call(self): image = np.full((50, 50, 3), 128, dtype=np.uint8) images_aug = [] for _ in np.arange(5): iarandom.seed(100) aug = iaa.AdditiveGaussianNoise(scale=50, per_channel=True) images_aug.append(aug(image=image)) # assert all images identical for other_image_aug in images_aug[1:]: assert np.array_equal(images_aug[0], other_image_aug) # but different seed must lead to different image iarandom.seed(101) aug = iaa.AdditiveGaussianNoise(scale=50, per_channel=True) image_aug = aug(image=image) assert not np.array_equal(images_aug[0], image_aug) def test_seed_affects_augmenters_created_before_its_call(self): image = np.full((50, 50, 3), 128, dtype=np.uint8) images_aug = [] for _ in np.arange(5): aug = iaa.AdditiveGaussianNoise(scale=50, per_channel=True) iarandom.seed(100) images_aug.append(aug(image=image)) # assert all images identical for other_image_aug in images_aug[1:]: assert np.array_equal(images_aug[0], other_image_aug) # but different seed must lead to different image aug = iaa.AdditiveGaussianNoise(scale=50, per_channel=True) iarandom.seed(101) image_aug = aug(image=image) assert not np.array_equal(images_aug[0], image_aug) class Test_normalize_generator(_Base): @mock.patch("imgaug.random.normalize_generator_") def test_mocked_call(self, mock_subfunc): mock_subfunc.return_value = "foo" inputs = ["bar"] result = iarandom.normalize_generator(inputs) assert mock_subfunc.call_count == 1 assert mock_subfunc.call_args[0][0] is not inputs assert mock_subfunc.call_args[0][0] == inputs assert result == "foo" class Test_normalize_generator_(_Base): @mock.patch("imgaug.random._normalize_generator_np117_") @mock.patch("imgaug.random._normalize_generator_np116_") def test_mocked_call(self, mock_np116, mock_np117): mock_np116.return_value = "np116" mock_np117.return_value = "np117" result = iarandom.normalize_generator_(None) if IS_NP_117_OR_HIGHER: assert result == "np117" mock_np117.assert_called_once_with(None) assert mock_np116.call_count == 0 else: assert result == "np116" mock_np116.assert_called_once_with(None) assert mock_np117.call_count == 0 def test_called_with_none(self): result = iarandom.normalize_generator_(None) assert result is iarandom.get_global_rng().generator @unittest.skipIf(not IS_NP_117_OR_HIGHER, "SeedSequence does not exist in numpy <=1.16") def test_called_with_seed_sequence(self): seedseq = np.random.SeedSequence(0) result = iarandom.normalize_generator_(seedseq) expected = np.random.Generator( iarandom.BIT_GENERATOR(np.random.SeedSequence(0))) assert iarandom.is_generator_equal_to(result, expected) @unittest.skipIf(not IS_NP_117_OR_HIGHER, "BitGenerator does not exist in numpy <=1.16") def test_called_with_bit_generator(self): bgen = iarandom.BIT_GENERATOR(np.random.SeedSequence(0)) result = iarandom.normalize_generator_(bgen) assert result.bit_generator is bgen @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Generator does not exist in numpy <=1.16") def test_called_with_generator(self): gen = np.random.Generator( iarandom.BIT_GENERATOR(np.random.SeedSequence(0)) ) result = iarandom.normalize_generator_(gen) assert result is gen def test_called_with_random_state(self): rs = np.random.RandomState(0) result = iarandom.normalize_generator_(rs) if IS_NP_117_OR_HIGHER: seed = iarandom.generate_seed_(np.random.RandomState(0)) expected = iarandom.convert_seed_to_generator(seed) assert iarandom.is_generator_equal_to(result, expected) else: assert result is rs def test_called_int(self): seed = 0 result = iarandom.normalize_generator_(seed) expected = iarandom.convert_seed_to_generator(seed) assert iarandom.is_generator_equal_to(result, expected) class Test_convert_seed_to_generator(_Base): @mock.patch("imgaug.random._convert_seed_to_generator_np117") @mock.patch("imgaug.random._convert_seed_to_generator_np116") def test_mocked_call(self, mock_np116, mock_np117): mock_np116.return_value = "np116" mock_np117.return_value = "np117" result = iarandom.convert_seed_to_generator(1) if IS_NP_117_OR_HIGHER: assert result == "np117" mock_np117.assert_called_once_with(1) assert mock_np116.call_count == 0 else: assert result == "np116" mock_np116.assert_called_once_with(1) assert mock_np117.call_count == 0 def test_call(self): gen = iarandom.convert_seed_to_generator(1) if IS_NP_117_OR_HIGHER: expected = np.random.Generator( iarandom.BIT_GENERATOR(np.random.SeedSequence(1))) assert iarandom.is_generator_equal_to(gen, expected) else: expected = np.random.RandomState(1) assert iarandom.is_generator_equal_to(gen, expected) class Test_convert_seed_sequence_to_generator(_Base): @unittest.skipIf(not IS_NP_117_OR_HIGHER, "SeedSequence does not exist in numpy <=1.16") def test_call(self): seedseq = np.random.SeedSequence(1) gen = iarandom.convert_seed_sequence_to_generator(seedseq) expected = np.random.Generator( iarandom.BIT_GENERATOR(np.random.SeedSequence(1))) assert iarandom.is_generator_equal_to(gen, expected) class Test_create_pseudo_random_generator_(_Base): def test_call(self): global_gen = copylib.deepcopy(iarandom.get_global_rng().generator) gen = iarandom.create_pseudo_random_generator_() expected = iarandom.convert_seed_to_generator( iarandom.generate_seed_(global_gen)) assert iarandom.is_generator_equal_to(gen, expected) class Test_create_fully_random_generator(_Base): @mock.patch("imgaug.random._create_fully_random_generator_np117") @mock.patch("imgaug.random._create_fully_random_generator_np116") def test_mocked_call(self, mock_np116, mock_np117): mock_np116.return_value = "np116" mock_np117.return_value = "np117" result = iarandom.create_fully_random_generator() if IS_NP_117_OR_HIGHER: assert result == "np117" mock_np117.assert_called_once_with() assert mock_np116.call_count == 0 else: assert result == "np116" mock_np116.assert_called_once_with() assert mock_np117.call_count == 0 @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_np117_mocked(self): dummy_bitgen = np.random.SFC64(1) with mock.patch("numpy.random.SFC64") as mock_bitgen: mock_bitgen.return_value = dummy_bitgen result = iarandom._create_fully_random_generator_np117() assert mock_bitgen.call_count == 1 assert iarandom.is_generator_equal_to( result, np.random.Generator(dummy_bitgen)) def test_np116_mocked(self): dummy_rs = np.random.RandomState(1) with mock.patch("numpy.random.RandomState") as mock_rs: mock_rs.return_value = dummy_rs result = iarandom._create_fully_random_generator_np116() assert mock_rs.call_count == 1 assert iarandom.is_generator_equal_to(result, np.random.RandomState(1)) class Test_generate_seed_(_Base): @mock.patch("imgaug.random.generate_seeds_") def test_mocked_call(self, mock_seeds): gen = iarandom.convert_seed_to_generator(0) _ = iarandom.generate_seed_(gen) mock_seeds.assert_called_once_with(gen, 1) class Test_generate_seeds_(_Base): @mock.patch("imgaug.random.polyfill_integers") def test_mocked_call(self, mock_integers): gen = iarandom.convert_seed_to_generator(0) _ = iarandom.generate_seeds_(gen, 10) mock_integers.assert_called_once_with( gen, iarandom.SEED_MIN_VALUE, iarandom.SEED_MAX_VALUE, size=(10,)) def test_call(self): gen = iarandom.convert_seed_to_generator(0) seeds = iarandom.generate_seeds_(gen, 2) assert len(seeds) == 2 assert ia.is_np_array(seeds) assert seeds.dtype.name == "int32" class Test_copy_generator(_Base): @mock.patch("imgaug.random._copy_generator_np116") def test_mocked_call_with_random_state(self, mock_np116): mock_np116.return_value = "np116" gen = np.random.RandomState(1) gen_copy = iarandom.copy_generator(gen) assert gen_copy == "np116" mock_np116.assert_called_once_with(gen) @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") @mock.patch("imgaug.random._copy_generator_np117") def test_mocked_call_with_generator(self, mock_np117): mock_np117.return_value = "np117" gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen_copy = iarandom.copy_generator(gen) assert gen_copy == "np117" mock_np117.assert_called_once_with(gen) def test_call_with_random_state(self): gen = np.random.RandomState(1) gen_copy = iarandom._copy_generator_np116(gen) assert gen is not gen_copy assert iarandom.is_generator_equal_to(gen, gen_copy) @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_call_with_generator(self): gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen_copy = iarandom._copy_generator_np117(gen) assert gen is not gen_copy assert iarandom.is_generator_equal_to(gen, gen_copy) class Test_copy_generator_unless_global_generator(_Base): @mock.patch("imgaug.random.get_global_rng") @mock.patch("imgaug.random.copy_generator") def test_mocked_gen_is_global(self, mock_copy, mock_get_global_rng): gen = iarandom.convert_seed_to_generator(1) mock_copy.return_value = "foo" mock_get_global_rng.return_value = iarandom.RNG(gen) result = iarandom.copy_generator_unless_global_generator(gen) assert mock_get_global_rng.call_count == 1 assert mock_copy.call_count == 0 assert result is gen @mock.patch("imgaug.random.get_global_rng") @mock.patch("imgaug.random.copy_generator") def test_mocked_gen_is_not_global(self, mock_copy, mock_get_global_rng): gen1 = iarandom.convert_seed_to_generator(1) gen2 = iarandom.convert_seed_to_generator(2) mock_copy.return_value = "foo" mock_get_global_rng.return_value = iarandom.RNG(gen2) result = iarandom.copy_generator_unless_global_generator(gen1) assert mock_get_global_rng.call_count == 1 mock_copy.assert_called_once_with(gen1) assert result == "foo" class Test_reset_generator_cache_(_Base): @mock.patch("imgaug.random._reset_generator_cache_np117_") @mock.patch("imgaug.random._reset_generator_cache_np116_") def test_mocked_call(self, mock_np116, mock_np117): mock_np116.return_value = "np116" mock_np117.return_value = "np117" gen = iarandom.convert_seed_to_generator(1) result = iarandom.reset_generator_cache_(gen) if IS_NP_117_OR_HIGHER: assert result == "np117" mock_np117.assert_called_once_with(gen) assert mock_np116.call_count == 0 else: assert result == "np116" mock_np116.assert_called_once_with(gen) assert mock_np117.call_count == 0 @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_call_np117(self): gen = iarandom.convert_seed_to_generator(1) gen_without_cache_copy = copylib.deepcopy(gen) state = iarandom._get_generator_state_np117(gen) state["has_uint32"] = 1 gen_with_cache = copylib.deepcopy(gen) iarandom.set_generator_state_(gen_with_cache, state) gen_with_cache_copy = copylib.deepcopy(gen_with_cache) gen_cache_reset = iarandom.reset_generator_cache_(gen_with_cache) assert iarandom.is_generator_equal_to(gen_cache_reset, gen_without_cache_copy) assert not iarandom.is_generator_equal_to(gen_cache_reset, gen_with_cache_copy) def test_call_np116(self): gen = np.random.RandomState(1) gen_without_cache_copy = copylib.deepcopy(gen) state = iarandom._get_generator_state_np116(gen) state = list(state) state[-2] = 1 gen_with_cache = copylib.deepcopy(gen) iarandom.set_generator_state_(gen_with_cache, tuple(state)) gen_with_cache_copy = copylib.deepcopy(gen_with_cache) gen_cache_reset = iarandom.reset_generator_cache_(gen_with_cache) assert iarandom.is_generator_equal_to(gen_cache_reset, gen_without_cache_copy) assert not iarandom.is_generator_equal_to(gen_cache_reset, gen_with_cache_copy) class Test_derive_generator_(_Base): @mock.patch("imgaug.random.derive_generators_") def test_mocked_call(self, mock_derive_gens): mock_derive_gens.return_value = ["foo"] gen = iarandom.convert_seed_to_generator(1) gen_derived = iarandom.derive_generator_(gen) mock_derive_gens.assert_called_once_with(gen, n=1) assert gen_derived == "foo" def test_integration(self): gen = iarandom.convert_seed_to_generator(1) gen_copy = copylib.deepcopy(gen) gen_derived = iarandom.derive_generator_(gen) assert not iarandom.is_generator_equal_to(gen_derived, gen_copy) # should have advanced the state assert not iarandom.is_generator_equal_to(gen_copy, gen) class Test_derive_generators_(_Base): @mock.patch("imgaug.random._derive_generators_np117_") @mock.patch("imgaug.random._derive_generators_np116_") def test_mocked_call(self, mock_np116, mock_np117): mock_np116.return_value = "np116" mock_np117.return_value = "np117" gen = iarandom.convert_seed_to_generator(1) result = iarandom.derive_generators_(gen, 1) if isinstance(gen, np.random.RandomState): assert result == "np116" mock_np116.assert_called_once_with(gen, n=1) assert mock_np117.call_count == 0 else: assert result == "np117" mock_np117.assert_called_once_with(gen, n=1) assert mock_np116.call_count == 0 @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_call_np117(self): gen = iarandom.convert_seed_to_generator(1) gen_copy = copylib.deepcopy(gen) result = iarandom.derive_generators_(gen, 2) assert len(result) == 2 assert np.all([isinstance(gen, np.random.Generator) for gen in result]) assert not iarandom.is_generator_equal_to(result[0], gen_copy) assert not iarandom.is_generator_equal_to(result[1], gen_copy) assert not iarandom.is_generator_equal_to(result[0], result[1]) # derive should advance state assert not iarandom.is_generator_equal_to(gen, gen_copy) def test_call_np116(self): gen = np.random.RandomState(1) gen_copy = copylib.deepcopy(gen) result = iarandom.derive_generators_(gen, 2) assert len(result) == 2 assert np.all([isinstance(gen, np.random.RandomState) for gen in result]) assert not iarandom.is_generator_equal_to(result[0], gen_copy) assert not iarandom.is_generator_equal_to(result[1], gen_copy) assert not iarandom.is_generator_equal_to(result[0], result[1]) # derive should advance state assert not iarandom.is_generator_equal_to(gen, gen_copy) class Test_get_generator_state(_Base): @mock.patch("imgaug.random._get_generator_state_np117") @mock.patch("imgaug.random._get_generator_state_np116") def test_mocked_call(self, mock_np116, mock_np117): mock_np116.return_value = "np116" mock_np117.return_value = "np117" gen = iarandom.convert_seed_to_generator(1) result = iarandom.get_generator_state(gen) if isinstance(gen, np.random.RandomState): assert result == "np116" mock_np116.assert_called_once_with(gen) assert mock_np117.call_count == 0 else: assert result == "np117" mock_np117.assert_called_once_with(gen) assert mock_np116.call_count == 0 @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_call_np117(self): gen = iarandom.convert_seed_to_generator(1) state = iarandom.get_generator_state(gen) assert str(state) == str(gen.bit_generator.state) def test_call_np116(self): gen = np.random.RandomState(1) state = iarandom.get_generator_state(gen) assert str(state) == str(gen.get_state()) class Test_set_generator_state_(_Base): @mock.patch("imgaug.random._set_generator_state_np117_") @mock.patch("imgaug.random._set_generator_state_np116_") def test_mocked_call(self, mock_np116, mock_np117): gen = iarandom.convert_seed_to_generator(1) state = {"state": 0} iarandom.set_generator_state_(gen, state) if isinstance(gen, np.random.RandomState): mock_np116.assert_called_once_with(gen, state) assert mock_np117.call_count == 0 else: mock_np117.assert_called_once_with(gen, state) assert mock_np116.call_count == 0 @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_call_np117(self): gen1 = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen2 = np.random.Generator(iarandom.BIT_GENERATOR(2)) gen1_copy = copylib.deepcopy(gen1) gen2_copy = copylib.deepcopy(gen2) iarandom._set_generator_state_np117_( gen2, iarandom.get_generator_state(gen1)) assert iarandom.is_generator_equal_to(gen2, gen1) assert iarandom.is_generator_equal_to(gen1, gen1_copy) assert not iarandom.is_generator_equal_to(gen2, gen2_copy) @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_call_np117_via_samples(self): gen1 = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen2 = np.random.Generator(iarandom.BIT_GENERATOR(2)) gen1_copy = copylib.deepcopy(gen1) gen2_copy = copylib.deepcopy(gen2) iarandom._set_generator_state_np117_( gen2, iarandom.get_generator_state(gen1)) samples1 = gen1.random(size=(100,)) samples2 = gen2.random(size=(100,)) samples1_copy = gen1_copy.random(size=(100,)) samples2_copy = gen2_copy.random(size=(100,)) assert np.allclose(samples1, samples2) assert np.allclose(samples1, samples1_copy) assert not np.allclose(samples2, samples2_copy) def test_call_np116(self): gen1 = np.random.RandomState(1) gen2 = np.random.RandomState(2) gen1_copy = copylib.deepcopy(gen1) gen2_copy = copylib.deepcopy(gen2) iarandom._set_generator_state_np116_( gen2, iarandom.get_generator_state(gen1)) assert iarandom.is_generator_equal_to(gen2, gen1) assert iarandom.is_generator_equal_to(gen1, gen1_copy) assert not iarandom.is_generator_equal_to(gen2, gen2_copy) def test_call_np116_via_samples(self): gen1 = np.random.RandomState(1) gen2 = np.random.RandomState(2) gen1_copy = copylib.deepcopy(gen1) gen2_copy = copylib.deepcopy(gen2) iarandom._set_generator_state_np116_( gen2, iarandom.get_generator_state(gen1)) samples1 = gen1.uniform(0.0, 1.0, size=(100,)) samples2 = gen2.uniform(0.0, 1.0, size=(100,)) samples1_copy = gen1_copy.uniform(0.0, 1.0, size=(100,)) samples2_copy = gen2_copy.uniform(0.0, 1.0, size=(100,)) assert np.allclose(samples1, samples2) assert np.allclose(samples1, samples1_copy) assert not np.allclose(samples2, samples2_copy) class Test_is_generator_equal_to(_Base): @mock.patch("imgaug.random._is_generator_equal_to_np117") @mock.patch("imgaug.random._is_generator_equal_to_np116") def test_mocked_call(self, mock_np116, mock_np117): mock_np116.return_value = "np116" mock_np117.return_value = "np117" gen = iarandom.convert_seed_to_generator(1) result = iarandom.is_generator_equal_to(gen, gen) if isinstance(gen, np.random.RandomState): assert result == "np116" mock_np116.assert_called_once_with(gen, gen) assert mock_np117.call_count == 0 else: assert result == "np117" mock_np117.assert_called_once_with(gen, gen) assert mock_np116.call_count == 0 @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_generator_is_identical_np117(self): gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) result = iarandom._is_generator_equal_to_np117(gen, gen) assert result is True def test_generator_is_identical_np116(self): gen = np.random.RandomState(1) result = iarandom._is_generator_equal_to_np116(gen, gen) assert result is True @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_generator_created_with_same_seed_np117(self): gen1 = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen2 = np.random.Generator(iarandom.BIT_GENERATOR(1)) result = iarandom._is_generator_equal_to_np117(gen1, gen2) assert result is True def test_generator_created_with_same_seed_np116(self): gen1 = np.random.RandomState(1) gen2 = np.random.RandomState(1) result = iarandom._is_generator_equal_to_np116(gen1, gen2) assert result is True @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_generator_is_copy_of_itself_np117(self): gen1 = np.random.Generator(iarandom.BIT_GENERATOR(1)) result = iarandom._is_generator_equal_to_np117(gen1, copylib.deepcopy(gen1)) assert result is True def test_generator_is_copy_of_itself_np116(self): gen1 = np.random.RandomState(1) result = iarandom._is_generator_equal_to_np116(gen1, copylib.deepcopy(gen1)) assert result is True @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_generator_created_with_different_seed_np117(self): gen1 = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen2 = np.random.Generator(iarandom.BIT_GENERATOR(2)) result = iarandom._is_generator_equal_to_np117(gen1, gen2) assert result is False def test_generator_created_with_different_seed_np116(self): gen1 = np.random.RandomState(1) gen2 = np.random.RandomState(2) result = iarandom._is_generator_equal_to_np116(gen1, gen2) assert result is False @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_generator_modified_to_have_same_state_np117(self): gen1 = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen2 = np.random.Generator(iarandom.BIT_GENERATOR(2)) iarandom.set_generator_state_(gen2, iarandom.get_generator_state(gen1)) result = iarandom._is_generator_equal_to_np117(gen1, gen2) assert result is True def test_generator_modified_to_have_same_state_np116(self): gen1 = np.random.RandomState(1) gen2 = np.random.RandomState(2) iarandom.set_generator_state_(gen2, iarandom.get_generator_state(gen1)) result = iarandom._is_generator_equal_to_np116(gen1, gen2) assert result is True class Test_advance_generator_(_Base): @mock.patch("imgaug.random._advance_generator_np117_") @mock.patch("imgaug.random._advance_generator_np116_") def test_mocked_call(self, mock_np116, mock_np117): gen = iarandom.convert_seed_to_generator(1) iarandom.advance_generator_(gen) if isinstance(gen, np.random.RandomState): mock_np116.assert_called_once_with(gen) assert mock_np117.call_count == 0 else: mock_np117.assert_called_once_with(gen) assert mock_np116.call_count == 0 @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_call_np117(self): gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen_copy1 = copylib.deepcopy(gen) iarandom._advance_generator_np117_(gen) gen_copy2 = copylib.deepcopy(gen) iarandom._advance_generator_np117_(gen) assert iarandom.is_generator_equal_to(gen, copylib.deepcopy(gen)) assert not iarandom.is_generator_equal_to(gen_copy1, gen_copy2) assert not iarandom.is_generator_equal_to(gen_copy2, gen) assert not iarandom.is_generator_equal_to(gen_copy1, gen) def test_call_np116(self): gen = np.random.RandomState(1) gen_copy1 = copylib.deepcopy(gen) iarandom._advance_generator_np116_(gen) gen_copy2 = copylib.deepcopy(gen) iarandom._advance_generator_np116_(gen) assert iarandom.is_generator_equal_to(gen, copylib.deepcopy(gen)) assert not iarandom.is_generator_equal_to(gen_copy1, gen_copy2) assert not iarandom.is_generator_equal_to(gen_copy2, gen) assert not iarandom.is_generator_equal_to(gen_copy1, gen) @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_samples_different_after_advance_np117(self): gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) gen_copy1 = copylib.deepcopy(gen) # first advance iarandom._advance_generator_np117_(gen) gen_copy2 = copylib.deepcopy(gen) # second advance iarandom._advance_generator_np117_(gen) sample_before = gen_copy1.uniform(0.0, 1.0) sample_after = gen_copy2.uniform(0.0, 1.0) sample_after_after = gen.uniform(0.0, 1.0) assert not np.isclose(sample_after, sample_before, rtol=0) assert not np.isclose(sample_after_after, sample_after, rtol=0) assert not np.isclose(sample_after_after, sample_before, rtol=0) def test_samples_different_after_advance_np116(self): gen = np.random.RandomState(1) gen_copy1 = copylib.deepcopy(gen) # first advance iarandom._advance_generator_np116_(gen) gen_copy2 = copylib.deepcopy(gen) # second advance iarandom._advance_generator_np116_(gen) sample_before = gen_copy1.uniform(0.0, 1.0) sample_after = gen_copy2.uniform(0.0, 1.0) sample_after_after = gen.uniform(0.0, 1.0) assert not np.isclose(sample_after, sample_before, rtol=0) assert not np.isclose(sample_after_after, sample_after, rtol=0) assert not np.isclose(sample_after_after, sample_before, rtol=0) class Test_polyfill_integers(_Base): def test_mocked_standard_call_np116(self): def side_effect(low, high=None, size=None, dtype='l'): return "np116" gen = mock.MagicMock() gen.randint.side_effect = side_effect result = iarandom.polyfill_integers(gen, 2, 2000, size=(10,), dtype="int8") assert result == "np116" gen.randint.assert_called_once_with(low=2, high=2000, size=(10,), dtype="int8") @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_mocked_standard_call_np117(self): def side_effect(low, high=None, size=None, dtype='int64', endpoint=False): return "np117" gen = mock.MagicMock() gen.integers.side_effect = side_effect del gen.randint result = iarandom.polyfill_integers(gen, 2, 2000, size=(10,), dtype="int8", endpoint=True) assert result == "np117" gen.integers.assert_called_once_with(low=2, high=2000, size=(10,), dtype="int8", endpoint=True) def test_mocked_call_with_default_values_np116(self): def side_effect(low, high=None, size=None, dtype='l'): return "np116" gen = mock.MagicMock() gen.randint.side_effect = side_effect result = iarandom.polyfill_integers(gen, 2) assert result == "np116" gen.randint.assert_called_once_with(low=2, high=None, size=None, dtype="int32") @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_mocked_call_with_default_values_np117(self): def side_effect(low, high=None, size=None, dtype='int64', endpoint=False): return "np117" gen = mock.MagicMock() gen.integers.side_effect = side_effect del gen.randint result = iarandom.polyfill_integers(gen, 2) assert result == "np117" gen.integers.assert_called_once_with(low=2, high=None, size=None, dtype="int32", endpoint=False) def test_mocked_call_with_default_values_and_endpoint_np116(self): def side_effect(low, high=None, size=None, dtype='l'): return "np116" gen = mock.MagicMock() gen.randint.side_effect = side_effect result = iarandom.polyfill_integers(gen, 2, endpoint=True) assert result == "np116" gen.randint.assert_called_once_with(low=0, high=3, size=None, dtype="int32") def test_mocked_call_with_low_high_and_endpoint_np116(self): def side_effect(low, high=None, size=None, dtype='l'): return "np116" gen = mock.MagicMock() gen.randint.side_effect = side_effect result = iarandom.polyfill_integers(gen, 2, 5, endpoint=True) assert result == "np116" gen.randint.assert_called_once_with(low=2, high=6, size=None, dtype="int32") @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_sampled_values_np117(self): gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) result = iarandom.polyfill_integers(gen, 1, 10, size=(1000,), endpoint=False) assert result.dtype.name == "int32" assert np.all(result >= 1) assert np.all(result < 10) @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_sampled_values_with_endpoint_np117(self): gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) result = iarandom.polyfill_integers(gen, 1, 10, size=(1000,), endpoint=True) assert result.dtype.name == "int32" assert np.all(result >= 1) assert np.all(result <= 10) def test_sampled_values_np116(self): gen = np.random.RandomState(1) result = iarandom.polyfill_integers(gen, 1, 10, size=(1000,), endpoint=False) assert result.dtype.name == "int32" assert np.all(result >= 1) assert np.all(result < 10) def test_sampled_values_with_endpoint_np116(self): gen = np.random.RandomState(1) result = iarandom.polyfill_integers(gen, 1, 10, size=(1000,), endpoint=True) assert result.dtype.name == "int32" assert np.all(result >= 1) assert np.all(result <= 10) class Test_polyfill_random(_Base): def test_mocked_standard_call_np116(self): def side_effect(size=None): return np.zeros((1,), dtype="float64") gen = mock.MagicMock() gen.random_sample.side_effect = side_effect result = iarandom.polyfill_random(gen, size=(10,), dtype="float16") assert result.dtype.name == "float16" gen.random_sample.assert_called_once_with( size=(10,)) def test_mocked_standard_call_np117(self): def side_effect(size=None, dtype='d', out=None): return "np117" gen = mock.MagicMock() gen.random.side_effect = side_effect del gen.random_sample result = iarandom.polyfill_random(gen, size=(10,), dtype="float16") assert result == "np117" gen.random.assert_called_once_with( size=(10,), dtype="float16", out=None) def test_mocked_call_with_out_arg_np116(self): def side_effect(size=None): return np.zeros((1,), dtype="float64") gen = mock.MagicMock() gen.random_sample.side_effect = side_effect out = np.empty((10,), dtype="float16") result = iarandom.polyfill_random(gen, size=(10,), dtype="float16", out=out) assert result.dtype.name == "float16" # np1.16 does not support an out arg, hence it is not part of the # expected call gen.random_sample.assert_called_once_with(size=(10,)) def test_mocked_call_with_out_arg_np117(self): def side_effect(size=None, dtype='d', out=None): return "np117" gen = mock.MagicMock() gen.random.side_effect = side_effect del gen.random_sample out = np.empty((10,), dtype="float16") result = iarandom.polyfill_random(gen, size=(10,), dtype="float16", out=out) assert result == "np117" gen.random.assert_called_once_with(size=(10,), dtype="float16", out=out) def test_sampled_values_np116(self): gen = np.random.RandomState(1) result = iarandom.polyfill_random(gen, size=(1000,)) assert result.dtype.name == "float32" assert np.all(result >= 0) assert np.all(result < 1.0) @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_sampled_values_np117(self): gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) result = iarandom.polyfill_random(gen, size=(1000,)) assert result.dtype.name == "float32" assert np.all(result >= 0) assert np.all(result < 1.0) def test_sampled_values_with_out_arg_np116(self): gen = np.random.RandomState(1) out = np.zeros((1000,), dtype="float32") result = iarandom.polyfill_random(gen, size=(1000,), out=out) assert result.dtype.name == "float32" assert np.all(result >= 0) assert np.all(result < 1.0) assert np.any(out > 0.9) assert np.all(out >= 0) assert np.all(out < 1.0) @unittest.skipIf(not IS_NP_117_OR_HIGHER, "Function uses classes from numpy 1.17+") def test_sampled_values_with_out_arg_np117(self): gen = np.random.Generator(iarandom.BIT_GENERATOR(1)) out = np.zeros((1000,), dtype="float32") result = iarandom.polyfill_random(gen, size=(1000,), out=out) assert result.dtype.name == "float32" assert np.all(result >= 0) assert np.all(result < 1.0) assert np.any(out > 0.9) assert np.all(out >= 0) assert np.all(out < 1.0)