1 /* 2 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 import org.testng.Assert; 25 import org.testng.annotations.Test; 26 27 import java.util.SplittableRandom; 28 import java.util.concurrent.ThreadLocalRandom; 29 import java.util.concurrent.atomic.AtomicInteger; 30 import java.util.concurrent.atomic.LongAdder; 31 import java.util.function.BiConsumer; 32 33 import static org.testng.Assert.assertEquals; 34 import static org.testng.Assert.assertNotNull; 35 import static org.testng.AssertJUnit.assertTrue; 36 37 /** 38 * @test 39 * @run testng SplittableRandomTest 40 * @run testng/othervm -Djava.util.secureRandomSeed=true SplittableRandomTest 41 * @summary test methods on SplittableRandom 42 * @key randomness 43 */ 44 @Test 45 public class SplittableRandomTest { 46 47 // Note: this test was copied from the 166 TCK SplittableRandomTest test 48 // and modified to be a TestNG test 49 50 /* 51 * Testing coverage notes: 52 * 53 * 1. Many of the test methods are adapted from ThreadLocalRandomTest. 54 * 55 * 2. These tests do not check for random number generator quality. 56 * But we check for minimal API compliance by requiring that 57 * repeated calls to nextX methods, up to NCALLS tries, produce at 58 * least two distinct results. (In some possible universe, a 59 * "correct" implementation might fail, but the odds are vastly 60 * less than that of encountering a hardware failure while running 61 * the test.) For bounded nextX methods, we sample various 62 * intervals across multiples of primes. In other tests, we repeat 63 * under REPS different values. 64 */ 65 66 // max numbers of calls to detect getting stuck on one value 67 static final int NCALLS = 10000; 68 69 // max sampled int bound 70 static final int MAX_INT_BOUND = (1 << 28); 71 72 // max sampled long bound 73 static final long MAX_LONG_BOUND = (1L << 42); 74 75 // Number of replications for other checks 76 static final int REPS = 20; 77 78 /** 79 * Repeated calls to nextInt produce at least two distinct results 80 */ 81 public void testNextInt() { 82 SplittableRandom sr = new SplittableRandom(); 83 int f = sr.nextInt(); 84 int i = 0; 85 while (i < NCALLS && sr.nextInt() == f) 86 ++i; 87 assertTrue(i < NCALLS); 88 } 89 90 /** 91 * Repeated calls to nextLong produce at least two distinct results 92 */ 93 public void testNextLong() { 94 SplittableRandom sr = new SplittableRandom(); 95 long f = sr.nextLong(); 96 int i = 0; 97 while (i < NCALLS && sr.nextLong() == f) 98 ++i; 99 assertTrue(i < NCALLS); 100 } 101 102 /** 103 * Repeated calls to nextDouble produce at least two distinct results 104 */ 105 public void testNextDouble() { 106 SplittableRandom sr = new SplittableRandom(); 107 double f = sr.nextDouble(); 108 int i = 0; 109 while (i < NCALLS && sr.nextDouble() == f) 110 ++i; 111 assertTrue(i < NCALLS); 112 } 113 114 /** 115 * Two SplittableRandoms created with the same seed produce the 116 * same values for nextLong. 117 */ 118 public void testSeedConstructor() { 119 for (long seed = 2; seed < MAX_LONG_BOUND; seed += 15485863) { 120 SplittableRandom sr1 = new SplittableRandom(seed); 121 SplittableRandom sr2 = new SplittableRandom(seed); 122 for (int i = 0; i < REPS; ++i) 123 assertEquals(sr1.nextLong(), sr2.nextLong()); 124 } 125 } 126 127 /** 128 * A SplittableRandom produced by split() of a default-constructed 129 * SplittableRandom generates a different sequence 130 */ 131 public void testSplit1() { 132 SplittableRandom sr = new SplittableRandom(); 133 for (int reps = 0; reps < REPS; ++reps) { 134 SplittableRandom sc = sr.split(); 135 int i = 0; 136 while (i < NCALLS && sr.nextLong() == sc.nextLong()) 137 ++i; 138 assertTrue(i < NCALLS); 139 } 140 } 141 142 /** 143 * A SplittableRandom produced by split() of a seeded-constructed 144 * SplittableRandom generates a different sequence 145 */ 146 public void testSplit2() { 147 SplittableRandom sr = new SplittableRandom(12345); 148 for (int reps = 0; reps < REPS; ++reps) { 149 SplittableRandom sc = sr.split(); 150 int i = 0; 151 while (i < NCALLS && sr.nextLong() == sc.nextLong()) 152 ++i; 153 assertTrue(i < NCALLS); 154 } 155 } 156 157 /** 158 * nextInt(negative) throws IllegalArgumentException 159 */ 160 @Test(expectedExceptions = IllegalArgumentException.class) 161 public void testNextIntBoundedNeg() { 162 SplittableRandom sr = new SplittableRandom(); 163 int f = sr.nextInt(-17); 164 } 165 166 /** 167 * nextInt(least >= bound) throws IllegalArgumentException 168 */ 169 @Test(expectedExceptions = IllegalArgumentException.class) 170 public void testNextIntBadBounds() { 171 SplittableRandom sr = new SplittableRandom(); 172 int f = sr.nextInt(17, 2); 173 } 174 175 /** 176 * nextInt(bound) returns 0 <= value < bound; 177 * repeated calls produce at least two distinct results 178 */ 179 public void testNextIntBounded() { 180 SplittableRandom sr = new SplittableRandom(); 181 // sample bound space across prime number increments 182 for (int bound = 2; bound < MAX_INT_BOUND; bound += 524959) { 183 int f = sr.nextInt(bound); 184 assertTrue(0 <= f && f < bound); 185 int i = 0; 186 int j; 187 while (i < NCALLS && 188 (j = sr.nextInt(bound)) == f) { 189 assertTrue(0 <= j && j < bound); 190 ++i; 191 } 192 assertTrue(i < NCALLS); 193 } 194 } 195 196 /** 197 * nextInt(least, bound) returns least <= value < bound; 198 * repeated calls produce at least two distinct results 199 */ 200 public void testNextIntBounded2() { 201 SplittableRandom sr = new SplittableRandom(); 202 for (int least = -15485863; least < MAX_INT_BOUND; least += 524959) { 203 for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 49979687) { 204 int f = sr.nextInt(least, bound); 205 assertTrue(least <= f && f < bound); 206 int i = 0; 207 int j; 208 while (i < NCALLS && 209 (j = sr.nextInt(least, bound)) == f) { 210 assertTrue(least <= j && j < bound); 211 ++i; 212 } 213 assertTrue(i < NCALLS); 214 } 215 } 216 } 217 218 /** 219 * nextLong(negative) throws IllegalArgumentException 220 */ 221 @Test(expectedExceptions = IllegalArgumentException.class) 222 public void testNextLongBoundedNeg() { 223 SplittableRandom sr = new SplittableRandom(); 224 long f = sr.nextLong(-17); 225 } 226 227 /** 228 * nextLong(least >= bound) throws IllegalArgumentException 229 */ 230 @Test(expectedExceptions = IllegalArgumentException.class) 231 public void testNextLongBadBounds() { 232 SplittableRandom sr = new SplittableRandom(); 233 long f = sr.nextLong(17, 2); 234 } 235 236 /** 237 * nextLong(bound) returns 0 <= value < bound; 238 * repeated calls produce at least two distinct results 239 */ 240 public void testNextLongBounded() { 241 SplittableRandom sr = new SplittableRandom(); 242 for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) { 243 long f = sr.nextLong(bound); 244 assertTrue(0 <= f && f < bound); 245 int i = 0; 246 long j; 247 while (i < NCALLS && 248 (j = sr.nextLong(bound)) == f) { 249 assertTrue(0 <= j && j < bound); 250 ++i; 251 } 252 assertTrue(i < NCALLS); 253 } 254 } 255 256 /** 257 * nextLong(least, bound) returns least <= value < bound; 258 * repeated calls produce at least two distinct results 259 */ 260 public void testNextLongBounded2() { 261 SplittableRandom sr = new SplittableRandom(); 262 for (long least = -86028121; least < MAX_LONG_BOUND; least += 982451653L) { 263 for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) { 264 long f = sr.nextLong(least, bound); 265 assertTrue(least <= f && f < bound); 266 int i = 0; 267 long j; 268 while (i < NCALLS && 269 (j = sr.nextLong(least, bound)) == f) { 270 assertTrue(least <= j && j < bound); 271 ++i; 272 } 273 assertTrue(i < NCALLS); 274 } 275 } 276 } 277 278 /** 279 * nextDouble(bound) throws IllegalArgumentException 280 */ 281 public void testNextDoubleBadBound() { 282 SplittableRandom sr = new SplittableRandom(); 283 executeAndCatchIAE(() -> sr.nextDouble(0.0)); 284 executeAndCatchIAE(() -> sr.nextDouble(-0.0)); 285 executeAndCatchIAE(() -> sr.nextDouble(+0.0)); 286 executeAndCatchIAE(() -> sr.nextDouble(-1.0)); 287 executeAndCatchIAE(() -> sr.nextDouble(Double.NaN)); 288 executeAndCatchIAE(() -> sr.nextDouble(Double.NEGATIVE_INFINITY)); 289 290 // Returns Double.MAX_VALUE 291 // executeAndCatchIAE(() -> r.nextDouble(Double.POSITIVE_INFINITY)); 292 } 293 294 /** 295 * nextDouble(origin, bound) throws IllegalArgumentException 296 */ 297 public void testNextDoubleBadOriginBound() { 298 testDoubleBadOriginBound(new SplittableRandom()::nextDouble); 299 } 300 301 // An arbitrary finite double value 302 static final double FINITE = Math.PI; 303 304 void testDoubleBadOriginBound(BiConsumer<Double, Double> bi) { 305 executeAndCatchIAE(() -> bi.accept(17.0, 2.0)); 306 executeAndCatchIAE(() -> bi.accept(0.0, 0.0)); 307 executeAndCatchIAE(() -> bi.accept(Double.NaN, FINITE)); 308 executeAndCatchIAE(() -> bi.accept(FINITE, Double.NaN)); 309 executeAndCatchIAE(() -> bi.accept(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY)); 310 311 // Returns NaN 312 // executeAndCatchIAE(() -> bi.accept(Double.NEGATIVE_INFINITY, FINITE)); 313 // executeAndCatchIAE(() -> bi.accept(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY)); 314 315 executeAndCatchIAE(() -> bi.accept(FINITE, Double.NEGATIVE_INFINITY)); 316 317 // Returns Double.MAX_VALUE 318 // executeAndCatchIAE(() -> bi.accept(FINITE, Double.POSITIVE_INFINITY)); 319 320 executeAndCatchIAE(() -> bi.accept(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY)); 321 executeAndCatchIAE(() -> bi.accept(Double.POSITIVE_INFINITY, FINITE)); 322 executeAndCatchIAE(() -> bi.accept(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)); 323 } 324 325 /** 326 * nextDouble(least, bound) returns least <= value < bound; 327 * repeated calls produce at least two distinct results 328 */ 329 public void testNextDoubleBounded2() { 330 SplittableRandom sr = new SplittableRandom(); 331 for (double least = 0.0001; least < 1.0e20; least *= 8) { 332 for (double bound = least * 1.001; bound < 1.0e20; bound *= 16) { 333 double f = sr.nextDouble(least, bound); 334 assertTrue(least <= f && f < bound); 335 int i = 0; 336 double j; 337 while (i < NCALLS && 338 (j = sr.nextDouble(least, bound)) == f) { 339 assertTrue(least <= j && j < bound); 340 ++i; 341 } 342 assertTrue(i < NCALLS); 343 } 344 } 345 } 346 347 /** 348 * Invoking sized ints, long, doubles, with negative sizes throws 349 * IllegalArgumentException 350 */ 351 public void testBadStreamSize() { 352 SplittableRandom r = new SplittableRandom(); 353 executeAndCatchIAE(() -> r.ints(-1L)); 354 executeAndCatchIAE(() -> r.ints(-1L, 2, 3)); 355 executeAndCatchIAE(() -> r.longs(-1L)); 356 executeAndCatchIAE(() -> r.longs(-1L, -1L, 1L)); 357 executeAndCatchIAE(() -> r.doubles(-1L)); 358 executeAndCatchIAE(() -> r.doubles(-1L, .5, .6)); 359 } 360 361 /** 362 * Invoking bounded ints, long, doubles, with illegal bounds throws 363 * IllegalArgumentException 364 */ 365 public void testBadStreamBounds() { 366 SplittableRandom r = new SplittableRandom(); 367 executeAndCatchIAE(() -> r.ints(2, 1)); 368 executeAndCatchIAE(() -> r.ints(10, 42, 42)); 369 executeAndCatchIAE(() -> r.longs(-1L, -1L)); 370 executeAndCatchIAE(() -> r.longs(10, 1L, -2L)); 371 372 testDoubleBadOriginBound((o, b) -> r.doubles(10, o, b)); 373 } 374 375 private void executeAndCatchIAE(Runnable r) { 376 executeAndCatch(IllegalArgumentException.class, r); 377 } 378 379 private void executeAndCatch(Class<? extends Exception> expected, Runnable r) { 380 Exception caught = null; 381 try { 382 r.run(); 383 } 384 catch (Exception e) { 385 caught = e; 386 } 387 388 assertNotNull(caught, 389 String.format("No Exception was thrown, expected an Exception of %s to be thrown", 390 expected.getName())); 391 Assert.assertTrue(expected.isInstance(caught), 392 String.format("Exception thrown %s not an instance of %s", 393 caught.getClass().getName(), expected.getName())); 394 } 395 396 /** 397 * A parallel sized stream of ints generates the given number of values 398 */ 399 public void testIntsCount() { 400 LongAdder counter = new LongAdder(); 401 SplittableRandom r = new SplittableRandom(); 402 long size = 0; 403 for (int reps = 0; reps < REPS; ++reps) { 404 counter.reset(); 405 r.ints(size).parallel().forEach(x -> {counter.increment();}); 406 assertEquals(counter.sum(), size); 407 size += 524959; 408 } 409 } 410 411 /** 412 * A parallel sized stream of longs generates the given number of values 413 */ 414 public void testLongsCount() { 415 LongAdder counter = new LongAdder(); 416 SplittableRandom r = new SplittableRandom(); 417 long size = 0; 418 for (int reps = 0; reps < REPS; ++reps) { 419 counter.reset(); 420 r.longs(size).parallel().forEach(x -> {counter.increment();}); 421 assertEquals(counter.sum(), size); 422 size += 524959; 423 } 424 } 425 426 /** 427 * A parallel sized stream of doubles generates the given number of values 428 */ 429 public void testDoublesCount() { 430 LongAdder counter = new LongAdder(); 431 SplittableRandom r = new SplittableRandom(); 432 long size = 0; 433 for (int reps = 0; reps < REPS; ++reps) { 434 counter.reset(); 435 r.doubles(size).parallel().forEach(x -> {counter.increment();}); 436 assertEquals(counter.sum(), size); 437 size += 524959; 438 } 439 } 440 441 /** 442 * Each of a parallel sized stream of bounded ints is within bounds 443 */ 444 public void testBoundedInts() { 445 AtomicInteger fails = new AtomicInteger(0); 446 SplittableRandom r = new SplittableRandom(); 447 long size = 12345L; 448 for (int least = -15485867; least < MAX_INT_BOUND; least += 524959) { 449 for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 67867967) { 450 final int lo = least, hi = bound; 451 r.ints(size, lo, hi).parallel(). 452 forEach(x -> {if (x < lo || x >= hi) 453 fails.getAndIncrement(); }); 454 } 455 } 456 assertEquals(fails.get(), 0); 457 } 458 459 /** 460 * Each of a parallel sized stream of bounded longs is within bounds 461 */ 462 public void testBoundedLongs() { 463 AtomicInteger fails = new AtomicInteger(0); 464 SplittableRandom r = new SplittableRandom(); 465 long size = 123L; 466 for (long least = -86028121; least < MAX_LONG_BOUND; least += 1982451653L) { 467 for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) { 468 final long lo = least, hi = bound; 469 r.longs(size, lo, hi).parallel(). 470 forEach(x -> {if (x < lo || x >= hi) 471 fails.getAndIncrement(); }); 472 } 473 } 474 assertEquals(fails.get(), 0); 475 } 476 477 /** 478 * Each of a parallel sized stream of bounded doubles is within bounds 479 */ 480 public void testBoundedDoubles() { 481 AtomicInteger fails = new AtomicInteger(0); 482 SplittableRandom r = new SplittableRandom(); 483 long size = 456; 484 for (double least = 0.00011; least < 1.0e20; least *= 9) { 485 for (double bound = least * 1.0011; bound < 1.0e20; bound *= 17) { 486 final double lo = least, hi = bound; 487 r.doubles(size, lo, hi).parallel(). 488 forEach(x -> {if (x < lo || x >= hi) 489 fails.getAndIncrement(); }); 490 } 491 } 492 assertEquals(fails.get(), 0); 493 } 494 495 /** 496 * A parallel unsized stream of ints generates at least 100 values 497 */ 498 public void testUnsizedIntsCount() { 499 LongAdder counter = new LongAdder(); 500 SplittableRandom r = new SplittableRandom(); 501 long size = 100; 502 r.ints().limit(size).parallel().forEach(x -> {counter.increment();}); 503 assertEquals(counter.sum(), size); 504 } 505 506 /** 507 * A parallel unsized stream of longs generates at least 100 values 508 */ 509 public void testUnsizedLongsCount() { 510 LongAdder counter = new LongAdder(); 511 SplittableRandom r = new SplittableRandom(); 512 long size = 100; 513 r.longs().limit(size).parallel().forEach(x -> {counter.increment();}); 514 assertEquals(counter.sum(), size); 515 } 516 517 /** 518 * A parallel unsized stream of doubles generates at least 100 values 519 */ 520 public void testUnsizedDoublesCount() { 521 LongAdder counter = new LongAdder(); 522 SplittableRandom r = new SplittableRandom(); 523 long size = 100; 524 r.doubles().limit(size).parallel().forEach(x -> {counter.increment();}); 525 assertEquals(counter.sum(), size); 526 } 527 528 /** 529 * A sequential unsized stream of ints generates at least 100 values 530 */ 531 public void testUnsizedIntsCountSeq() { 532 LongAdder counter = new LongAdder(); 533 SplittableRandom r = new SplittableRandom(); 534 long size = 100; 535 r.ints().limit(size).forEach(x -> {counter.increment();}); 536 assertEquals(counter.sum(), size); 537 } 538 539 /** 540 * A sequential unsized stream of longs generates at least 100 values 541 */ 542 public void testUnsizedLongsCountSeq() { 543 LongAdder counter = new LongAdder(); 544 SplittableRandom r = new SplittableRandom(); 545 long size = 100; 546 r.longs().limit(size).forEach(x -> {counter.increment();}); 547 assertEquals(counter.sum(), size); 548 } 549 550 /** 551 * A sequential unsized stream of doubles generates at least 100 values 552 */ 553 public void testUnsizedDoublesCountSeq() { 554 LongAdder counter = new LongAdder(); 555 SplittableRandom r = new SplittableRandom(); 556 long size = 100; 557 r.doubles().limit(size).forEach(x -> {counter.increment();}); 558 assertEquals(counter.sum(), size); 559 } 560 561 }