Lines Matching refs:self
18 # Subclasses must arrange for self.gen to retrieve the Random instance
21 def randomlist(self, n):
23 return [self.gen.random() for i in range(n)]
25 def test_autoseed(self):
26 self.gen.seed()
27 state1 = self.gen.getstate()
29 self.gen.seed() # different seeds at different times
30 state2 = self.gen.getstate()
31 self.assertNotEqual(state1, state2)
33 def test_saverestore(self):
35 self.gen.seed()
36 state = self.gen.getstate()
37 randseq = self.randomlist(N)
38 self.gen.setstate(state) # should regenerate the same sequence
39 self.assertEqual(randseq, self.randomlist(N))
41 def test_seedargs(self):
44 def __hash__(self):
48 self.gen.seed(arg)
51 with self.assertRaises(TypeError):
52 self.gen.seed(arg)
55 self.assertRaises(TypeError, self.gen.seed, arg)
56 self.assertRaises(TypeError, self.gen.seed, 1, 2, 3, 4)
57 self.assertRaises(TypeError, type(self.gen), [])
59 def test_seed_no_mutate_bug_44018(self):
61 self.gen.seed(a)
62 self.assertEqual(a, bytearray(b'1234'))
65 def test_seed_when_randomness_source_not_found(self, urandom_mock):
72 self.test_seedargs()
74 def test_shuffle(self):
75 shuffle = self.gen.shuffle
78 self.assertEqual(lst, [])
81 self.assertEqual(lst, [37])
87 self.assertEqual(len(seq), len(shuffled_seq))
88 self.assertEqual(set(seq), set(shuffled_seq))
102 self.assertTrue(lst != shuffled_lst)
104 self.assertTrue(lst != shuffled_lst)
105 self.assertRaises(TypeError, shuffle, (1, 2, 3))
107 def test_choice(self):
108 choice = self.gen.choice
109 with self.assertRaises(IndexError):
111 self.assertEqual(choice([50]), 50)
112 self.assertIn(choice([25, 75]), [25, 75])
114 def test_choice_with_numpy(self):
117 choice = self.gen.choice
121 def __bool__(self):
124 with self.assertRaises(IndexError):
126 self.assertEqual(choice(NA([50])), 50)
127 self.assertIn(choice(NA([25, 75])), [25, 75])
129 def test_sample(self):
135 s = self.gen.sample(population, k)
136 self.assertEqual(len(s), k)
138 self.assertEqual(len(uniq), k)
139 self.assertTrue(uniq <= set(population))
140 self.assertEqual(self.gen.sample([], 0), []) # test edge case N==k==0
142 self.assertRaises(ValueError, self.gen.sample, population, N+1)
143 self.assertRaises(ValueError, self.gen.sample, [], -1)
145 def test_sample_distribution(self):
155 perms[tuple(self.gen.sample(pop, k))] = None
159 self.fail()
161 def test_sample_inputs(self):
163 self.gen.sample(range(20), 2)
164 self.gen.sample(range(20), 2)
165 self.gen.sample(str('abcdefghijklmnopqrst'), 2)
166 self.gen.sample(tuple('abcdefghijklmnopqrst'), 2)
168 def test_sample_on_dicts(self):
169 self.assertRaises(TypeError, self.gen.sample, dict.fromkeys('abcdef'), 2)
171 def test_sample_on_sets(self):
172 with self.assertRaises(TypeError):
174 self.gen.sample(population, k=5)
176 def test_sample_on_seqsets(self):
178 def __init__(self, items):
179 self._items = items
181 def __len__(self):
182 return len(self._items)
184 def __getitem__(self, index):
185 return self._items[index]
190 self.gen.sample(population, k=2)
192 def test_sample_with_counts(self):
193 sample = self.gen.sample
200 self.assertEqual(sum(summary.values()), k)
202 self.assertLessEqual(summary[color], weight)
203 self.assertNotIn('brown', summary)
208 self.assertEqual(sum(summary.values()), k)
210 self.assertLessEqual(summary[color], weight)
211 self.assertNotIn('brown', summary)
215 self.assertEqual(summary, Counter(x=8))
220 self.assertEqual(summary, Counter(10*colors))
223 with self.assertRaises(TypeError):
225 with self.assertRaises(ValueError):
227 with self.assertRaises(ValueError):
229 with self.assertRaises(ValueError):
231 with self.assertRaises(ValueError):
233 with self.assertRaises(ValueError):
236 def test_choices(self):
237 choices = self.gen.choices
250 self.assertEqual(len(sample), 5)
251 self.assertEqual(type(sample), list)
252 self.assertTrue(set(sample) <= set(data))
255 with self.assertRaises(TypeError): # missing arguments
258 self.assertEqual(choices(data, k=0), []) # k == 0
259 self.assertEqual(choices(data, k=-1), []) # negative k behaves like ``[0] * -1``
260 with self.assertRaises(TypeError):
263 self.assertTrue(set(choices(str_data, k=5)) <= set(str_data)) # population is a string sequence
264 self.assertTrue(set(choices(range_data, k=5)) <= set(range_data)) # population is a range
265 with self.assertRaises(TypeError):
268 self.assertTrue(set(choices(data, None, k=5)) <= set(data)) # weights is None
269 self.assertTrue(set(choices(data, weights=None, k=5)) <= set(data))
270 with self.assertRaises(ValueError):
272 with self.assertRaises(TypeError):
274 with self.assertRaises(TypeError):
282 self.assertTrue(set(choices(data, weights, k=5)) <= set(data))
284 with self.assertRaises(ValueError):
286 with self.assertRaises(TypeError):
288 with self.assertRaises(TypeError):
290 with self.assertRaises(TypeError):
297 self.assertTrue(set(choices(data, cum_weights=weights, k=5)) <= set(data))
300 self.assertEqual(choices('abcd', [1, 0, 0, 0]), ['a'])
301 self.assertEqual(choices('abcd', [0, 1, 0, 0]), ['b'])
302 self.assertEqual(choices('abcd', [0, 0, 1, 0]), ['c'])
303 self.assertEqual(choices('abcd', [0, 0, 0, 1]), ['d'])
306 with self.assertRaises(IndexError):
308 with self.assertRaises(IndexError):
310 with self.assertRaises(IndexError):
313 def test_choices_subnormal(self):
318 choices = self.gen.choices
321 def test_choices_with_all_zero_weights(self):
323 with self.assertRaises(ValueError):
324 self.gen.choices('AB', [0.0, 0.0])
326 def test_choices_negative_total(self):
327 with self.assertRaises(ValueError):
328 self.gen.choices('ABC', [3, -5, 1])
330 def test_choices_infinite_total(self):
331 with self.assertRaises(ValueError):
332 self.gen.choices('A', [float('inf')])
333 with self.assertRaises(ValueError):
334 self.gen.choices('AB', [0.0, float('inf')])
335 with self.assertRaises(ValueError):
336 self.gen.choices('AB', [-float('inf'), 123])
337 with self.assertRaises(ValueError):
338 self.gen.choices('AB', [0.0, float('nan')])
339 with self.assertRaises(ValueError):
340 self.gen.choices('AB', [float('-inf'), float('inf')])
342 def test_gauss(self):
348 self.gen.seed(seed)
349 x1 = self.gen.random()
350 y1 = self.gen.gauss(0, 1)
352 self.gen.seed(seed)
353 x2 = self.gen.random()
354 y2 = self.gen.gauss(0, 1)
356 self.assertEqual(x1, x2)
357 self.assertEqual(y1, y2)
359 def test_getrandbits(self):
362 self.assertTrue(0 <= self.gen.getrandbits(k) < 2**k)
363 self.assertEqual(self.gen.getrandbits(0), 0)
366 getbits = self.gen.getrandbits
375 self.assertEqual(cum, all_bits)
376 self.assertEqual(cpl_cum, all_bits)
379 self.assertRaises(TypeError, self.gen.getrandbits)
380 self.assertRaises(TypeError, self.gen.getrandbits, 1, 2)
381 self.assertRaises(ValueError, self.gen.getrandbits, -1)
382 self.assertRaises(TypeError, self.gen.getrandbits, 10.1)
384 def test_pickling(self):
386 state = pickle.dumps(self.gen, proto)
387 origseq = [self.gen.random() for i in range(10)]
390 self.assertEqual(origseq, restoredseq)
392 def test_bug_1727780(self):
402 self.assertEqual(int(r.random()*1000), value)
404 def test_bug_9025(self):
408 randrange = self.gen.randrange
410 self.assertTrue(0.30 < k/n < .37, (k/n))
412 def test_randbytes(self):
415 data = self.gen.randbytes(n)
416 self.assertEqual(type(data), bytes)
417 self.assertEqual(len(data), n)
419 self.assertEqual(self.gen.randbytes(0), b'')
422 self.assertRaises(TypeError, self.gen.randbytes)
423 self.assertRaises(TypeError, self.gen.randbytes, 1, 2)
424 self.assertRaises(ValueError, self.gen.randbytes, -1)
425 self.assertRaises(TypeError, self.gen.randbytes, 1.0)
427 def test_mu_sigma_default_args(self):
428 self.assertIsInstance(self.gen.normalvariate(), float)
429 self.assertIsInstance(self.gen.gauss(), float)
443 def test_autoseed(self):
445 self.gen.seed()
447 def test_saverestore(self):
448 self.assertRaises(NotImplementedError, self.gen.getstate)
449 self.assertRaises(NotImplementedError, self.gen.setstate, None)
451 def test_seedargs(self):
453 self.gen.seed(100)
455 def test_gauss(self):
456 self.gen.gauss_next = None
457 self.gen.seed(100)
458 self.assertEqual(self.gen.gauss_next, None)
460 def test_pickling(self):
462 self.assertRaises(NotImplementedError, pickle.dumps, self.gen, proto)
464 def test_53_bits_per_float(self):
469 cum |= int(self.gen.random() * span)
470 self.assertEqual(cum, span-1)
472 def test_bigrand(self):
478 r = self.gen.randrange(span)
479 self.assertTrue(0 <= r < span)
481 self.assertEqual(cum, span-1)
483 def test_bigrand_ranges(self):
485 start = self.gen.randrange(2 ** (i-2))
486 stop = self.gen.randrange(2 ** i)
489 self.assertTrue(start <= self.gen.randrange(start, stop) < stop)
491 def test_rangelimits(self):
493 self.assertEqual(set(range(start,stop)),
494 set([self.gen.randrange(start,stop) for i in range(100)]))
496 def test_randrange_nonunit_step(self):
497 rint = self.gen.randrange(0, 10, 2)
498 self.assertIn(rint, (0, 2, 4, 6, 8))
499 rint = self.gen.randrange(0, 2, 2)
500 self.assertEqual(rint, 0)
502 def test_randrange_errors(self):
503 raises = partial(self.assertRaises, ValueError, self.gen.randrange)
509 self.assertWarns(DeprecationWarning, raises, 3.14159)
510 self.assertWarns(DeprecationWarning, self.gen.randrange, 3.0)
511 self.assertWarns(DeprecationWarning, self.gen.randrange, Fraction(3, 1))
512 self.assertWarns(DeprecationWarning, raises, '3')
513 self.assertWarns(DeprecationWarning, raises, 0, 2.71828)
514 self.assertWarns(DeprecationWarning, self.gen.randrange, 0, 2.0)
515 self.assertWarns(DeprecationWarning, self.gen.randrange, 0, Fraction(2, 1))
516 self.assertWarns(DeprecationWarning, raises, 0, '2')
519 self.assertWarns(DeprecationWarning, raises, 0, 42, 0.0)
520 self.assertWarns(DeprecationWarning, raises, 0, 0, 0.0)
521 self.assertWarns(DeprecationWarning, raises, 0, 42, 3.14159)
522 self.assertWarns(DeprecationWarning, self.gen.randrange, 0, 42, 3.0)
523 self.assertWarns(DeprecationWarning, self.gen.randrange, 0, 42, Fraction(3, 1))
524 self.assertWarns(DeprecationWarning, raises, 0, 42, '3')
525 self.assertWarns(DeprecationWarning, self.gen.randrange, 0, 42, 1.0)
526 self.assertWarns(DeprecationWarning, raises, 0, 0, 1.0)
528 def test_randrange_argument_handling(self):
529 randrange = self.gen.randrange
530 with self.assertWarns(DeprecationWarning):
532 with self.assertWarns(DeprecationWarning):
534 with self.assertWarns(DeprecationWarning):
536 with self.assertWarns(DeprecationWarning):
538 with self.assertWarns(DeprecationWarning):
539 with self.assertRaises(ValueError):
541 with self.assertWarns(DeprecationWarning):
542 with self.assertRaises(ValueError):
544 with self.assertWarns(DeprecationWarning):
545 with self.assertRaises(ValueError):
548 def test_randrange_step(self):
550 randrange = self.gen.randrange
551 with self.assertRaises(TypeError):
553 with self.assertRaises(TypeError):
556 def test_randbelow_logic(self, _log=log, int=int):
564 self.assertEqual(k, numbits)
565 self.assertEqual(n, 2**(k-1))
569 self.assertIn(k, [numbits, numbits+1])
570 self.assertTrue(2**k > n > 2**(k-2))
574 self.assertEqual(k, numbits) # note the stronger assertion
575 self.assertTrue(2**k > n > 2**(k-1)) # note the stronger assertion
580 def test_bug_41052(self):
585 self.assertRaises(TypeError, pickle.dumps, r, proto)
588 def test_bug_42008(self):
594 self.assertEqual(r1.random(), r2.random())
600 def test_guaranteed_stable(self):
602 self.gen.seed(3456147, version=1)
603 self.assertEqual([self.gen.random().hex() for i in range(4)],
606 self.gen.seed("the quick brown fox", version=2)
607 self.assertEqual([self.gen.random().hex() for i in range(4)],
611 def test_bug_27706(self):
614 self.gen.seed('nofar', version=1) # hash('nofar') == 5990528763808513177
615 self.assertEqual([self.gen.random().hex() for i in range(4)],
619 self.gen.seed('rachel', version=1) # hash('rachel') == -9091735575445484789
620 self.assertEqual([self.gen.random().hex() for i in range(4)],
624 self.gen.seed('', version=1) # hash('') == 0
625 self.assertEqual([self.gen.random().hex() for i in range(4)],
629 def test_bug_31478(self):
633 def __abs__(self):
636 self.gen.seed(BadInt())
640 def test_bug_31482(self):
646 self.gen.seed(b'nofar', version=1) # hash('nofar') == 5990528763808513177
647 self.assertEqual([self.gen.random().hex() for i in range(4)],
651 self.gen.seed(b'rachel', version=1) # hash('rachel') == -9091735575445484789
652 self.assertEqual([self.gen.random().hex() for i in range(4)],
656 self.gen.seed(b'', version=1) # hash('') == 0
657 self.assertEqual([self.gen.random().hex() for i in range(4)],
662 self.gen.seed(b, version=1) # hash(b) == 5015594239749365497
663 self.assertEqual([self.gen.random().hex() for i in range(4)],
667 def test_setstate_first_arg(self):
668 self.assertRaises(ValueError, self.gen.setstate, (1, None, None))
670 def test_setstate_middle_arg(self):
671 start_state = self.gen.getstate()
673 self.assertRaises(TypeError, self.gen.setstate, (2, None, None))
675 self.assertRaises(ValueError, self.gen.setstate, (2, (1,2,3), None))
677 self.assertRaises(TypeError, self.gen.setstate, (2, ('a',)*625, None))
679 self.assertRaises(TypeError, self.gen.setstate, (2, (0,)*624+('a',), None))
681 with self.assertRaises((ValueError, OverflowError)):
682 self.gen.setstate((2, (1,)*624+(625,), None))
683 with self.assertRaises((ValueError, OverflowError)):
684 self.gen.setstate((2, (1,)*624+(-1,), None))
686 bits100 = self.gen.getrandbits(100)
687 self.gen.setstate(start_state)
688 self.assertEqual(self.gen.getrandbits(100), bits100)
694 state_values = self.gen.getstate()[1]
698 self.assertRaises(TypeError, self.gen.setstate, (2, state, None))
700 def test_referenceImplementation(self):
726 self.gen.seed(61731 + (24903<<32) + (614<<64) + (42143<<96))
727 actual = self.randomlist(2000)[-10:]
729 self.assertAlmostEqual(a,e,places=14)
731 def test_strong_reference_implementation(self):
748 self.gen.seed(61731 + (24903<<32) + (614<<64) + (42143<<96))
749 actual = self.randomlist(2000)[-10:]
751 self.assertEqual(int(ldexp(a, 53)), e)
753 def test_long_seed(self):
760 self.gen.seed(seed)
762 def test_53_bits_per_float(self):
767 cum |= int(self.gen.random() * span)
768 self.assertEqual(cum, span-1)
770 def test_bigrand(self):
776 r = self.gen.randrange(span)
777 self.assertTrue(0 <= r < span)
779 self.assertEqual(cum, span-1)
781 def test_bigrand_ranges(self):
783 start = self.gen.randrange(2 ** (i-2))
784 stop = self.gen.randrange(2 ** i)
787 self.assertTrue(start <= self.gen.randrange(start, stop) < stop)
789 def test_rangelimits(self):
791 self.assertEqual(set(range(start,stop)),
792 set([self.gen.randrange(start,stop) for i in range(100)]))
794 def test_getrandbits(self):
798 self.gen.seed(1234567)
799 self.assertEqual(self.gen.getrandbits(100),
802 def test_randrange_uses_getrandbits(self):
806 self.gen.seed(1234567)
809 self.assertEqual(self.gen.randrange(2**99),
812 def test_randbelow_logic(self, _log=log, int=int):
820 self.assertEqual(k, numbits)
821 self.assertEqual(n, 2**(k-1))
825 self.assertIn(k, [numbits, numbits+1])
826 self.assertTrue(2**k > n > 2**(k-2))
830 self.assertEqual(k, numbits) # note the stronger assertion
831 self.assertTrue(2**k > n > 2**(k-1)) # note the stronger assertion
833 def test_randbelow_without_getrandbits(self):
840 self.gen._randbelow_without_getrandbits(
843 self.gen._randbelow_without_getrandbits(5640, maxsize=maxsize)
864 self.gen._randbelow_without_getrandbits(n, maxsize=maxsize)
865 self.assertEqual(random_mock.call_count, 2)
867 def test_randrange_bug_1590891(self):
871 x = self.gen.randrange(start, stop, step)
872 self.assertTrue(stop < x <= start)
873 self.assertEqual((x+stop)%step, 0)
875 def test_choices_algorithms(self):
877 choices = self.gen.choices
880 self.gen.seed(8675309)
881 a = self.gen.choices(range(n), k=10000)
883 self.gen.seed(8675309)
884 b = self.gen.choices(range(n), [1]*n, k=10000)
885 self.assertEqual(a, b)
887 self.gen.seed(8675309)
888 c = self.gen.choices(range(n), cum_weights=range(1, n+1), k=10000)
889 self.assertEqual(a, c)
897 self.gen.seed(9035768)
898 a = self.gen.choices(expanded_population, k=10000)
900 self.gen.seed(9035768)
901 b = self.gen.choices(population, weights, k=10000)
902 self.assertEqual(a, b)
904 self.gen.seed(9035768)
905 c = self.gen.choices(population, cum_weights=cum_weights, k=10000)
906 self.assertEqual(a, c)
908 def test_randbytes(self):
916 self.gen.seed(seed)
917 self.assertEqual(self.gen.randbytes(16), expected)
920 self.gen.seed(seed)
921 self.assertEqual(self.gen.randbytes(0), b'')
922 self.assertEqual(self.gen.randbytes(16), expected)
925 self.gen.seed(seed)
926 self.assertEqual(b''.join([self.gen.randbytes(4) for _ in range(4)]),
931 self.gen.seed(seed)
933 self.assertEqual(b''.join(self.gen.randbytes(1) for _ in range(4)),
936 self.gen.seed(seed)
939 self.assertEqual(b''.join(self.gen.randbytes(2) for _ in range(4)),
942 self.gen.seed(seed)
945 self.assertEqual(b''.join(self.gen.randbytes(3) for _ in range(4)),
948 def test_randbytes_getrandbits(self):
952 self.gen.seed(seed)
955 self.assertEqual(self.gen.randbytes(n),
958 def test_sample_counts_equivalence(self):
962 sample = self.gen.sample
963 seed = self.gen.seed
972 self.assertEqual(len(expanded), sum(counts))
974 self.assertEqual(s1, s2)
983 self.assertEqual(s1, s2)
1005 def test_zeroinputs(self):
1024 def test_avg_std(self):
1051 self.assertAlmostEqual(s1/N, mu, places=2,
1053 self.assertAlmostEqual(s2/(N-1), sigmasqrd, places=2,
1056 def test_constant(self):
1074 self.assertEqual(variate(*args), expected)
1076 def test_von_mises_range(self):
1085 self.assertTrue(
1090 def test_von_mises_large_kappa(self):
1095 def test_gammavariate_errors(self):
1097 self.assertRaises(ValueError, random.gammavariate, -1, 3)
1098 self.assertRaises(ValueError, random.gammavariate, 0, 2)
1099 self.assertRaises(ValueError, random.gammavariate, 2, 0)
1100 self.assertRaises(ValueError, random.gammavariate, 1, -3)
1107 def test_gammavariate_alpha_greater_one(self, random_mock):
1115 self.assertAlmostEqual(returned_value, 2.53)
1118 def test_gammavariate_alpha_equal_one(self, random_mock):
1126 self.assertAlmostEqual(returned_value, 1.877208182372648)
1129 def test_gammavariate_alpha_equal_one_equals_expovariate(self, random_mock):
1137 self.assertAlmostEqual(gammavariate_returned_value, expovariate_returned_value)
1140 def test_gammavariate_alpha_between_zero_and_one(self, random_mock):
1190 self.assertAlmostEqual(returned_value, 1.4499999999997544)
1207 self.assertAlmostEqual(returned_value, 1.5830349561760781)
1210 def test_betavariate_return_zero(self, gammavariate_mock):
1214 self.assertEqual(0.0, random.betavariate(2.71828, 3.14159))
1218 def test_random_subclass_with_kwargs(self):
1221 def __init__(self, newarg=None):
1222 random.Random.__init__(self)
1225 def test_subclasses_overriding_methods(self):
1234 def random(self):
1236 return random.Random.random(self)
1238 def getrandbits(self, n):
1240 return random.Random.getrandbits(self, n)
1243 self.assertEqual(called, {'SubClass1.getrandbits'})
1247 def random(self):
1249 return random.Random.random(self)
1252 self.assertEqual(called, {'SubClass2.random'})
1257 def getrandbits(self, n):
1259 return random.Random.getrandbits(self, n)
1262 self.assertEqual(called, {'SubClass3.getrandbits'})
1267 def random(self):
1269 return random.Random.random(self)
1272 self.assertEqual(called, {'SubClass4.random'})
1277 def random(self):
1279 return random.Random.random(self)
1281 def getrandbits(self, n):
1283 return random.Random.getrandbits(self, n)
1289 self.assertEqual(called, {'Mixin1.random'})
1295 self.assertEqual(called, {'Mixin2.getrandbits'})
1301 self.assertEqual(called, {'Mixin1.random'})
1307 self.assertEqual(called, {'Mixin2.getrandbits'})
1311 def testMagicConstants(self):
1312 self.assertAlmostEqual(random.NV_MAGICCONST, 1.71552776992141)
1313 self.assertAlmostEqual(random.TWOPI, 6.28318530718)
1314 self.assertAlmostEqual(random.LOG4, 1.38629436111989)
1315 self.assertAlmostEqual(random.SG_MAGICCONST, 2.50407739677627)
1317 def test__all__(self):
1319 self.assertTrue(set(random.__all__) <= set(dir(random)))
1322 def test_after_fork(self):
1340 self.assertNotEqual(val, child_val)