1 #!/usr/bin/env python 2 3 import unittest 4 import random 5 import time 6 import pickle 7 import warnings 8 from math import log, exp, pi, fsum, sin 9 from functools import reduce 10 from test import test_support 11 12 class TestBasicOps(unittest.TestCase): 13 # Superclass with tests common to all generators. 14 # Subclasses must arrange for self.gen to retrieve the Random instance 15 # to be tested. 16 17 def randomlist(self, n): 18 """Helper function to make a list of random numbers""" 19 return [self.gen.random() for i in xrange(n)] 20 21 def test_autoseed(self): 22 self.gen.seed() 23 state1 = self.gen.getstate() 24 time.sleep(0.1) 25 self.gen.seed() # diffent seeds at different times 26 state2 = self.gen.getstate() 27 self.assertNotEqual(state1, state2) 28 29 def test_saverestore(self): 30 N = 1000 31 self.gen.seed() 32 state = self.gen.getstate() 33 randseq = self.randomlist(N) 34 self.gen.setstate(state) # should regenerate the same sequence 35 self.assertEqual(randseq, self.randomlist(N)) 36 37 def test_seedargs(self): 38 for arg in [None, 0, 0L, 1, 1L, -1, -1L, 10**20, -(10**20), 39 3.14, 1+2j, 'a', tuple('abc')]: 40 self.gen.seed(arg) 41 for arg in [range(3), dict(one=1)]: 42 self.assertRaises(TypeError, self.gen.seed, arg) 43 self.assertRaises(TypeError, self.gen.seed, 1, 2) 44 self.assertRaises(TypeError, type(self.gen), []) 45 46 def test_jumpahead(self): 47 self.gen.seed() 48 state1 = self.gen.getstate() 49 self.gen.jumpahead(100) 50 state2 = self.gen.getstate() # s/b distinct from state1 51 self.assertNotEqual(state1, state2) 52 self.gen.jumpahead(100) 53 state3 = self.gen.getstate() # s/b distinct from state2 54 self.assertNotEqual(state2, state3) 55 56 with test_support.check_py3k_warnings(quiet=True): 57 self.assertRaises(TypeError, self.gen.jumpahead) # needs an arg 58 self.assertRaises(TypeError, self.gen.jumpahead, 2, 3) # too many 59 60 def test_sample(self): 61 # For the entire allowable range of 0 <= k <= N, validate that 62 # the sample is of the correct length and contains only unique items 63 N = 100 64 population = xrange(N) 65 for k in xrange(N+1): 66 s = self.gen.sample(population, k) 67 self.assertEqual(len(s), k) 68 uniq = set(s) 69 self.assertEqual(len(uniq), k) 70 self.assertTrue(uniq <= set(population)) 71 self.assertEqual(self.gen.sample([], 0), []) # test edge case N==k==0 72 73 def test_sample_distribution(self): 74 # For the entire allowable range of 0 <= k <= N, validate that 75 # sample generates all possible permutations 76 n = 5 77 pop = range(n) 78 trials = 10000 # large num prevents false negatives without slowing normal case 79 def factorial(n): 80 return reduce(int.__mul__, xrange(1, n), 1) 81 for k in xrange(n): 82 expected = factorial(n) // factorial(n-k) 83 perms = {} 84 for i in xrange(trials): 85 perms[tuple(self.gen.sample(pop, k))] = None 86 if len(perms) == expected: 87 break 88 else: 89 self.fail() 90 91 def test_sample_inputs(self): 92 # SF bug #801342 -- population can be any iterable defining __len__() 93 self.gen.sample(set(range(20)), 2) 94 self.gen.sample(range(20), 2) 95 self.gen.sample(xrange(20), 2) 96 self.gen.sample(str('abcdefghijklmnopqrst'), 2) 97 self.gen.sample(tuple('abcdefghijklmnopqrst'), 2) 98 99 def test_sample_on_dicts(self): 100 self.gen.sample(dict.fromkeys('abcdefghijklmnopqrst'), 2) 101 102 # SF bug #1460340 -- random.sample can raise KeyError 103 a = dict.fromkeys(range(10)+range(10,100,2)+range(100,110)) 104 self.gen.sample(a, 3) 105 106 # A followup to bug #1460340: sampling from a dict could return 107 # a subset of its keys or of its values, depending on the size of 108 # the subset requested. 109 N = 30 110 d = dict((i, complex(i, i)) for i in xrange(N)) 111 for k in xrange(N+1): 112 samp = self.gen.sample(d, k) 113 # Verify that we got ints back (keys); the values are complex. 114 for x in samp: 115 self.assertTrue(type(x) is int) 116 samp.sort() 117 self.assertEqual(samp, range(N)) 118 119 def test_gauss(self): 120 # Ensure that the seed() method initializes all the hidden state. In 121 # particular, through 2.2.1 it failed to reset a piece of state used 122 # by (and only by) the .gauss() method. 123 124 for seed in 1, 12, 123, 1234, 12345, 123456, 654321: 125 self.gen.seed(seed) 126 x1 = self.gen.random() 127 y1 = self.gen.gauss(0, 1) 128 129 self.gen.seed(seed) 130 x2 = self.gen.random() 131 y2 = self.gen.gauss(0, 1) 132 133 self.assertEqual(x1, x2) 134 self.assertEqual(y1, y2) 135 136 def test_pickling(self): 137 state = pickle.dumps(self.gen) 138 origseq = [self.gen.random() for i in xrange(10)] 139 newgen = pickle.loads(state) 140 restoredseq = [newgen.random() for i in xrange(10)] 141 self.assertEqual(origseq, restoredseq) 142 143 def test_bug_1727780(self): 144 # verify that version-2-pickles can be loaded 145 # fine, whether they are created on 32-bit or 64-bit 146 # platforms, and that version-3-pickles load fine. 147 files = [("randv2_32.pck", 780), 148 ("randv2_64.pck", 866), 149 ("randv3.pck", 343)] 150 for file, value in files: 151 f = open(test_support.findfile(file),"rb") 152 r = pickle.load(f) 153 f.close() 154 self.assertEqual(r.randrange(1000), value) 155 156 class WichmannHill_TestBasicOps(TestBasicOps): 157 gen = random.WichmannHill() 158 159 def test_setstate_first_arg(self): 160 self.assertRaises(ValueError, self.gen.setstate, (2, None, None)) 161 162 def test_strong_jumpahead(self): 163 # tests that jumpahead(n) semantics correspond to n calls to random() 164 N = 1000 165 s = self.gen.getstate() 166 self.gen.jumpahead(N) 167 r1 = self.gen.random() 168 # now do it the slow way 169 self.gen.setstate(s) 170 for i in xrange(N): 171 self.gen.random() 172 r2 = self.gen.random() 173 self.assertEqual(r1, r2) 174 175 def test_gauss_with_whseed(self): 176 # Ensure that the seed() method initializes all the hidden state. In 177 # particular, through 2.2.1 it failed to reset a piece of state used 178 # by (and only by) the .gauss() method. 179 180 for seed in 1, 12, 123, 1234, 12345, 123456, 654321: 181 self.gen.whseed(seed) 182 x1 = self.gen.random() 183 y1 = self.gen.gauss(0, 1) 184 185 self.gen.whseed(seed) 186 x2 = self.gen.random() 187 y2 = self.gen.gauss(0, 1) 188 189 self.assertEqual(x1, x2) 190 self.assertEqual(y1, y2) 191 192 def test_bigrand(self): 193 # Verify warnings are raised when randrange is too large for random() 194 with warnings.catch_warnings(): 195 warnings.filterwarnings("error", "Underlying random") 196 self.assertRaises(UserWarning, self.gen.randrange, 2**60) 197 198 class SystemRandom_TestBasicOps(TestBasicOps): 199 gen = random.SystemRandom() 200 201 def test_autoseed(self): 202 # Doesn't need to do anything except not fail 203 self.gen.seed() 204 205 def test_saverestore(self): 206 self.assertRaises(NotImplementedError, self.gen.getstate) 207 self.assertRaises(NotImplementedError, self.gen.setstate, None) 208 209 def test_seedargs(self): 210 # Doesn't need to do anything except not fail 211 self.gen.seed(100) 212 213 def test_jumpahead(self): 214 # Doesn't need to do anything except not fail 215 self.gen.jumpahead(100) 216 217 def test_gauss(self): 218 self.gen.gauss_next = None 219 self.gen.seed(100) 220 self.assertEqual(self.gen.gauss_next, None) 221 222 def test_pickling(self): 223 self.assertRaises(NotImplementedError, pickle.dumps, self.gen) 224 225 def test_53_bits_per_float(self): 226 # This should pass whenever a C double has 53 bit precision. 227 span = 2 ** 53 228 cum = 0 229 for i in xrange(100): 230 cum |= int(self.gen.random() * span) 231 self.assertEqual(cum, span-1) 232 233 def test_bigrand(self): 234 # The randrange routine should build-up the required number of bits 235 # in stages so that all bit positions are active. 236 span = 2 ** 500 237 cum = 0 238 for i in xrange(100): 239 r = self.gen.randrange(span) 240 self.assertTrue(0 <= r < span) 241 cum |= r 242 self.assertEqual(cum, span-1) 243 244 def test_bigrand_ranges(self): 245 for i in [40,80, 160, 200, 211, 250, 375, 512, 550]: 246 start = self.gen.randrange(2 ** i) 247 stop = self.gen.randrange(2 ** (i-2)) 248 if stop <= start: 249 return 250 self.assertTrue(start <= self.gen.randrange(start, stop) < stop) 251 252 def test_rangelimits(self): 253 for start, stop in [(-2,0), (-(2**60)-2,-(2**60)), (2**60,2**60+2)]: 254 self.assertEqual(set(range(start,stop)), 255 set([self.gen.randrange(start,stop) for i in xrange(100)])) 256 257 def test_genrandbits(self): 258 # Verify ranges 259 for k in xrange(1, 1000): 260 self.assertTrue(0 <= self.gen.getrandbits(k) < 2**k) 261 262 # Verify all bits active 263 getbits = self.gen.getrandbits 264 for span in [1, 2, 3, 4, 31, 32, 32, 52, 53, 54, 119, 127, 128, 129]: 265 cum = 0 266 for i in xrange(100): 267 cum |= getbits(span) 268 self.assertEqual(cum, 2**span-1) 269 270 # Verify argument checking 271 self.assertRaises(TypeError, self.gen.getrandbits) 272 self.assertRaises(TypeError, self.gen.getrandbits, 1, 2) 273 self.assertRaises(ValueError, self.gen.getrandbits, 0) 274 self.assertRaises(ValueError, self.gen.getrandbits, -1) 275 self.assertRaises(TypeError, self.gen.getrandbits, 10.1) 276 277 def test_randbelow_logic(self, _log=log, int=int): 278 # check bitcount transition points: 2**i and 2**(i+1)-1 279 # show that: k = int(1.001 + _log(n, 2)) 280 # is equal to or one greater than the number of bits in n 281 for i in xrange(1, 1000): 282 n = 1L << i # check an exact power of two 283 numbits = i+1 284 k = int(1.00001 + _log(n, 2)) 285 self.assertEqual(k, numbits) 286 self.assertTrue(n == 2**(k-1)) 287 288 n += n - 1 # check 1 below the next power of two 289 k = int(1.00001 + _log(n, 2)) 290 self.assertIn(k, [numbits, numbits+1]) 291 self.assertTrue(2**k > n > 2**(k-2)) 292 293 n -= n >> 15 # check a little farther below the next power of two 294 k = int(1.00001 + _log(n, 2)) 295 self.assertEqual(k, numbits) # note the stronger assertion 296 self.assertTrue(2**k > n > 2**(k-1)) # note the stronger assertion 297 298 299 class MersenneTwister_TestBasicOps(TestBasicOps): 300 gen = random.Random() 301 302 def test_setstate_first_arg(self): 303 self.assertRaises(ValueError, self.gen.setstate, (1, None, None)) 304 305 def test_setstate_middle_arg(self): 306 # Wrong type, s/b tuple 307 self.assertRaises(TypeError, self.gen.setstate, (2, None, None)) 308 # Wrong length, s/b 625 309 self.assertRaises(ValueError, self.gen.setstate, (2, (1,2,3), None)) 310 # Wrong type, s/b tuple of 625 ints 311 self.assertRaises(TypeError, self.gen.setstate, (2, ('a',)*625, None)) 312 # Last element s/b an int also 313 self.assertRaises(TypeError, self.gen.setstate, (2, (0,)*624+('a',), None)) 314 315 def test_referenceImplementation(self): 316 # Compare the python implementation with results from the original 317 # code. Create 2000 53-bit precision random floats. Compare only 318 # the last ten entries to show that the independent implementations 319 # are tracking. Here is the main() function needed to create the 320 # list of expected random numbers: 321 # void main(void){ 322 # int i; 323 # unsigned long init[4]={61731, 24903, 614, 42143}, length=4; 324 # init_by_array(init, length); 325 # for (i=0; i<2000; i++) { 326 # printf("%.15f ", genrand_res53()); 327 # if (i%5==4) printf("\n"); 328 # } 329 # } 330 expected = [0.45839803073713259, 331 0.86057815201978782, 332 0.92848331726782152, 333 0.35932681119782461, 334 0.081823493762449573, 335 0.14332226470169329, 336 0.084297823823520024, 337 0.53814864671831453, 338 0.089215024911993401, 339 0.78486196105372907] 340 341 self.gen.seed(61731L + (24903L<<32) + (614L<<64) + (42143L<<96)) 342 actual = self.randomlist(2000)[-10:] 343 for a, e in zip(actual, expected): 344 self.assertAlmostEqual(a,e,places=14) 345 346 def test_strong_reference_implementation(self): 347 # Like test_referenceImplementation, but checks for exact bit-level 348 # equality. This should pass on any box where C double contains 349 # at least 53 bits of precision (the underlying algorithm suffers 350 # no rounding errors -- all results are exact). 351 from math import ldexp 352 353 expected = [0x0eab3258d2231fL, 354 0x1b89db315277a5L, 355 0x1db622a5518016L, 356 0x0b7f9af0d575bfL, 357 0x029e4c4db82240L, 358 0x04961892f5d673L, 359 0x02b291598e4589L, 360 0x11388382c15694L, 361 0x02dad977c9e1feL, 362 0x191d96d4d334c6L] 363 self.gen.seed(61731L + (24903L<<32) + (614L<<64) + (42143L<<96)) 364 actual = self.randomlist(2000)[-10:] 365 for a, e in zip(actual, expected): 366 self.assertEqual(long(ldexp(a, 53)), e) 367 368 def test_long_seed(self): 369 # This is most interesting to run in debug mode, just to make sure 370 # nothing blows up. Under the covers, a dynamically resized array 371 # is allocated, consuming space proportional to the number of bits 372 # in the seed. Unfortunately, that's a quadratic-time algorithm, 373 # so don't make this horribly big. 374 seed = (1L << (10000 * 8)) - 1 # about 10K bytes 375 self.gen.seed(seed) 376 377 def test_53_bits_per_float(self): 378 # This should pass whenever a C double has 53 bit precision. 379 span = 2 ** 53 380 cum = 0 381 for i in xrange(100): 382 cum |= int(self.gen.random() * span) 383 self.assertEqual(cum, span-1) 384 385 def test_bigrand(self): 386 # The randrange routine should build-up the required number of bits 387 # in stages so that all bit positions are active. 388 span = 2 ** 500 389 cum = 0 390 for i in xrange(100): 391 r = self.gen.randrange(span) 392 self.assertTrue(0 <= r < span) 393 cum |= r 394 self.assertEqual(cum, span-1) 395 396 def test_bigrand_ranges(self): 397 for i in [40,80, 160, 200, 211, 250, 375, 512, 550]: 398 start = self.gen.randrange(2 ** i) 399 stop = self.gen.randrange(2 ** (i-2)) 400 if stop <= start: 401 return 402 self.assertTrue(start <= self.gen.randrange(start, stop) < stop) 403 404 def test_rangelimits(self): 405 for start, stop in [(-2,0), (-(2**60)-2,-(2**60)), (2**60,2**60+2)]: 406 self.assertEqual(set(range(start,stop)), 407 set([self.gen.randrange(start,stop) for i in xrange(100)])) 408 409 def test_genrandbits(self): 410 # Verify cross-platform repeatability 411 self.gen.seed(1234567) 412 self.assertEqual(self.gen.getrandbits(100), 413 97904845777343510404718956115L) 414 # Verify ranges 415 for k in xrange(1, 1000): 416 self.assertTrue(0 <= self.gen.getrandbits(k) < 2**k) 417 418 # Verify all bits active 419 getbits = self.gen.getrandbits 420 for span in [1, 2, 3, 4, 31, 32, 32, 52, 53, 54, 119, 127, 128, 129]: 421 cum = 0 422 for i in xrange(100): 423 cum |= getbits(span) 424 self.assertEqual(cum, 2**span-1) 425 426 # Verify argument checking 427 self.assertRaises(TypeError, self.gen.getrandbits) 428 self.assertRaises(TypeError, self.gen.getrandbits, 'a') 429 self.assertRaises(TypeError, self.gen.getrandbits, 1, 2) 430 self.assertRaises(ValueError, self.gen.getrandbits, 0) 431 self.assertRaises(ValueError, self.gen.getrandbits, -1) 432 433 def test_randbelow_logic(self, _log=log, int=int): 434 # check bitcount transition points: 2**i and 2**(i+1)-1 435 # show that: k = int(1.001 + _log(n, 2)) 436 # is equal to or one greater than the number of bits in n 437 for i in xrange(1, 1000): 438 n = 1L << i # check an exact power of two 439 numbits = i+1 440 k = int(1.00001 + _log(n, 2)) 441 self.assertEqual(k, numbits) 442 self.assertTrue(n == 2**(k-1)) 443 444 n += n - 1 # check 1 below the next power of two 445 k = int(1.00001 + _log(n, 2)) 446 self.assertIn(k, [numbits, numbits+1]) 447 self.assertTrue(2**k > n > 2**(k-2)) 448 449 n -= n >> 15 # check a little farther below the next power of two 450 k = int(1.00001 + _log(n, 2)) 451 self.assertEqual(k, numbits) # note the stronger assertion 452 self.assertTrue(2**k > n > 2**(k-1)) # note the stronger assertion 453 454 def test_randrange_bug_1590891(self): 455 start = 1000000000000 456 stop = -100000000000000000000 457 step = -200 458 x = self.gen.randrange(start, stop, step) 459 self.assertTrue(stop < x <= start) 460 self.assertEqual((x+stop)%step, 0) 461 462 def gamma(z, sqrt2pi=(2.0*pi)**0.5): 463 # Reflection to right half of complex plane 464 if z < 0.5: 465 return pi / sin(pi*z) / gamma(1.0-z) 466 # Lanczos approximation with g=7 467 az = z + (7.0 - 0.5) 468 return az ** (z-0.5) / exp(az) * sqrt2pi * fsum([ 469 0.9999999999995183, 470 676.5203681218835 / z, 471 -1259.139216722289 / (z+1.0), 472 771.3234287757674 / (z+2.0), 473 -176.6150291498386 / (z+3.0), 474 12.50734324009056 / (z+4.0), 475 -0.1385710331296526 / (z+5.0), 476 0.9934937113930748e-05 / (z+6.0), 477 0.1659470187408462e-06 / (z+7.0), 478 ]) 479 480 class TestDistributions(unittest.TestCase): 481 def test_zeroinputs(self): 482 # Verify that distributions can handle a series of zero inputs' 483 g = random.Random() 484 x = [g.random() for i in xrange(50)] + [0.0]*5 485 g.random = x[:].pop; g.uniform(1,10) 486 g.random = x[:].pop; g.paretovariate(1.0) 487 g.random = x[:].pop; g.expovariate(1.0) 488 g.random = x[:].pop; g.weibullvariate(1.0, 1.0) 489 g.random = x[:].pop; g.normalvariate(0.0, 1.0) 490 g.random = x[:].pop; g.gauss(0.0, 1.0) 491 g.random = x[:].pop; g.lognormvariate(0.0, 1.0) 492 g.random = x[:].pop; g.vonmisesvariate(0.0, 1.0) 493 g.random = x[:].pop; g.gammavariate(0.01, 1.0) 494 g.random = x[:].pop; g.gammavariate(1.0, 1.0) 495 g.random = x[:].pop; g.gammavariate(200.0, 1.0) 496 g.random = x[:].pop; g.betavariate(3.0, 3.0) 497 g.random = x[:].pop; g.triangular(0.0, 1.0, 1.0/3.0) 498 499 def test_avg_std(self): 500 # Use integration to test distribution average and standard deviation. 501 # Only works for distributions which do not consume variates in pairs 502 g = random.Random() 503 N = 5000 504 x = [i/float(N) for i in xrange(1,N)] 505 for variate, args, mu, sigmasqrd in [ 506 (g.uniform, (1.0,10.0), (10.0+1.0)/2, (10.0-1.0)**2/12), 507 (g.triangular, (0.0, 1.0, 1.0/3.0), 4.0/9.0, 7.0/9.0/18.0), 508 (g.expovariate, (1.5,), 1/1.5, 1/1.5**2), 509 (g.paretovariate, (5.0,), 5.0/(5.0-1), 510 5.0/((5.0-1)**2*(5.0-2))), 511 (g.weibullvariate, (1.0, 3.0), gamma(1+1/3.0), 512 gamma(1+2/3.0)-gamma(1+1/3.0)**2) ]: 513 g.random = x[:].pop 514 y = [] 515 for i in xrange(len(x)): 516 try: 517 y.append(variate(*args)) 518 except IndexError: 519 pass 520 s1 = s2 = 0 521 for e in y: 522 s1 += e 523 s2 += (e - mu) ** 2 524 N = len(y) 525 self.assertAlmostEqual(s1/N, mu, 2) 526 self.assertAlmostEqual(s2/(N-1), sigmasqrd, 2) 527 528 class TestModule(unittest.TestCase): 529 def testMagicConstants(self): 530 self.assertAlmostEqual(random.NV_MAGICCONST, 1.71552776992141) 531 self.assertAlmostEqual(random.TWOPI, 6.28318530718) 532 self.assertAlmostEqual(random.LOG4, 1.38629436111989) 533 self.assertAlmostEqual(random.SG_MAGICCONST, 2.50407739677627) 534 535 def test__all__(self): 536 # tests validity but not completeness of the __all__ list 537 self.assertTrue(set(random.__all__) <= set(dir(random))) 538 539 def test_random_subclass_with_kwargs(self): 540 # SF bug #1486663 -- this used to erroneously raise a TypeError 541 class Subclass(random.Random): 542 def __init__(self, newarg=None): 543 random.Random.__init__(self) 544 Subclass(newarg=1) 545 546 547 def test_main(verbose=None): 548 testclasses = [WichmannHill_TestBasicOps, 549 MersenneTwister_TestBasicOps, 550 TestDistributions, 551 TestModule] 552 553 try: 554 random.SystemRandom().random() 555 except NotImplementedError: 556 pass 557 else: 558 testclasses.append(SystemRandom_TestBasicOps) 559 560 test_support.run_unittest(*testclasses) 561 562 # verify reference counting 563 import sys 564 if verbose and hasattr(sys, "gettotalrefcount"): 565 counts = [None] * 5 566 for i in xrange(len(counts)): 567 test_support.run_unittest(*testclasses) 568 counts[i] = sys.gettotalrefcount() 569 print counts 570 571 if __name__ == "__main__": 572 test_main(verbose=True) 573
