--- jsr166/src/test/tck/SplittableRandomTest.java 2013/12/21 21:32:34 1.14 +++ jsr166/src/test/tck/SplittableRandomTest.java 2019/12/16 22:55:54 1.26 @@ -3,17 +3,26 @@ * Expert Group and released to the public domain, as explained at * http://creativecommons.org/publicdomain/zero/1.0/ */ -import junit.framework.*; -import java.util.*; + +import java.util.Arrays; +import java.util.List; import java.util.SplittableRandom; import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.LongAdder; +import java.lang.reflect.Method; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import java.util.stream.DoubleStream; +import java.util.stream.IntStream; +import java.util.stream.LongStream; + +import junit.framework.Test; +import junit.framework.TestSuite; public class SplittableRandomTest extends JSR166TestCase { public static void main(String[] args) { - junit.textui.TestRunner.run(suite()); + main(suite(), args); } public static Test suite() { return new TestSuite(SplittableRandomTest.class); @@ -132,12 +141,11 @@ public class SplittableRandomTest extend */ public void testNextIntBoundNonPositive() { SplittableRandom sr = new SplittableRandom(); - Runnable[] throwingActions = { + assertThrows( + IllegalArgumentException.class, () -> sr.nextInt(-17), () -> sr.nextInt(0), - () -> sr.nextInt(Integer.MIN_VALUE), - }; - assertThrows(IllegalArgumentException.class, throwingActions); + () -> sr.nextInt(Integer.MIN_VALUE)); } /** @@ -145,12 +153,11 @@ public class SplittableRandomTest extend */ public void testNextIntBadBounds() { SplittableRandom sr = new SplittableRandom(); - Runnable[] throwingActions = { + assertThrows( + IllegalArgumentException.class, () -> sr.nextInt(17, 2), () -> sr.nextInt(-42, -42), - () -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE), - }; - assertThrows(IllegalArgumentException.class, throwingActions); + () -> sr.nextInt(Integer.MAX_VALUE, Integer.MIN_VALUE)); } /** @@ -159,6 +166,7 @@ public class SplittableRandomTest extend */ public void testNextIntBounded() { SplittableRandom sr = new SplittableRandom(); + for (int i = 0; i < 2; i++) assertEquals(0, sr.nextInt(1)); // sample bound space across prime number increments for (int bound = 2; bound < MAX_INT_BOUND; bound += 524959) { int f = sr.nextInt(bound); @@ -201,12 +209,11 @@ public class SplittableRandomTest extend */ public void testNextLongBoundNonPositive() { SplittableRandom sr = new SplittableRandom(); - Runnable[] throwingActions = { + assertThrows( + IllegalArgumentException.class, () -> sr.nextLong(-17L), () -> sr.nextLong(0L), - () -> sr.nextLong(Long.MIN_VALUE), - }; - assertThrows(IllegalArgumentException.class, throwingActions); + () -> sr.nextLong(Long.MIN_VALUE)); } /** @@ -214,12 +221,11 @@ public class SplittableRandomTest extend */ public void testNextLongBadBounds() { SplittableRandom sr = new SplittableRandom(); - Runnable[] throwingActions = { + assertThrows( + IllegalArgumentException.class, () -> sr.nextLong(17L, 2L), () -> sr.nextLong(-42L, -42L), - () -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE), - }; - assertThrows(IllegalArgumentException.class, throwingActions); + () -> sr.nextLong(Long.MAX_VALUE, Long.MIN_VALUE)); } /** @@ -228,6 +234,7 @@ public class SplittableRandomTest extend */ public void testNextLongBounded() { SplittableRandom sr = new SplittableRandom(); + for (int i = 0; i < 2; i++) assertEquals(0L, sr.nextLong(1L)); for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) { long f = sr.nextLong(bound); assertTrue(0 <= f && f < bound); @@ -269,14 +276,13 @@ public class SplittableRandomTest extend */ public void testNextDoubleBoundNonPositive() { SplittableRandom sr = new SplittableRandom(); - Runnable[] throwingActions = { + assertThrows( + IllegalArgumentException.class, () -> sr.nextDouble(-17.0d), () -> sr.nextDouble(0.0d), () -> sr.nextDouble(-Double.MIN_VALUE), () -> sr.nextDouble(Double.NEGATIVE_INFINITY), - () -> sr.nextDouble(Double.NaN), - }; - assertThrows(IllegalArgumentException.class, throwingActions); + () -> sr.nextDouble(Double.NaN)); } /** @@ -284,14 +290,13 @@ public class SplittableRandomTest extend */ public void testNextDoubleBadBounds() { SplittableRandom sr = new SplittableRandom(); - Runnable[] throwingActions = { + assertThrows( + IllegalArgumentException.class, () -> sr.nextDouble(17.0d, 2.0d), () -> sr.nextDouble(-42.0d, -42.0d), () -> sr.nextDouble(Double.MAX_VALUE, Double.MIN_VALUE), () -> sr.nextDouble(Double.NaN, 0.0d), - () -> sr.nextDouble(0.0d, Double.NaN), - }; - assertThrows(IllegalArgumentException.class, throwingActions); + () -> sr.nextDouble(0.0d, Double.NaN)); } // TODO: Test infinite bounds! @@ -326,15 +331,14 @@ public class SplittableRandomTest extend */ public void testBadStreamSize() { SplittableRandom r = new SplittableRandom(); - Runnable[] throwingActions = { - () -> { java.util.stream.IntStream x = r.ints(-1L); }, - () -> { java.util.stream.IntStream x = r.ints(-1L, 2, 3); }, - () -> { java.util.stream.LongStream x = r.longs(-1L); }, - () -> { java.util.stream.LongStream x = r.longs(-1L, -1L, 1L); }, - () -> { java.util.stream.DoubleStream x = r.doubles(-1L); }, - () -> { java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6); }, - }; - assertThrows(IllegalArgumentException.class, throwingActions); + assertThrows( + IllegalArgumentException.class, + () -> { IntStream unused = r.ints(-1L); }, + () -> { IntStream unused = r.ints(-1L, 2, 3); }, + () -> { LongStream unused = r.longs(-1L); }, + () -> { LongStream unused = r.longs(-1L, -1L, 1L); }, + () -> { DoubleStream unused = r.doubles(-1L); }, + () -> { DoubleStream unused = r.doubles(-1L, .5, .6); }); } /** @@ -343,15 +347,14 @@ public class SplittableRandomTest extend */ public void testBadStreamBounds() { SplittableRandom r = new SplittableRandom(); - Runnable[] throwingActions = { - () -> { java.util.stream.IntStream x = r.ints(2, 1); }, - () -> { java.util.stream.IntStream x = r.ints(10, 42, 42); }, - () -> { java.util.stream.LongStream x = r.longs(-1L, -1L); }, - () -> { java.util.stream.LongStream x = r.longs(10, 1L, -2L); }, - () -> { java.util.stream.DoubleStream x = r.doubles(0.0, 0.0); }, - () -> { java.util.stream.DoubleStream x = r.doubles(10, .5, .4); }, - }; - assertThrows(IllegalArgumentException.class, throwingActions); + assertThrows( + IllegalArgumentException.class, + () -> { IntStream unused = r.ints(2, 1); }, + () -> { IntStream unused = r.ints(10, 42, 42); }, + () -> { LongStream unused = r.longs(-1L, -1L); }, + () -> { LongStream unused = r.longs(10, 1L, -2L); }, + () -> { DoubleStream unused = r.doubles(0.0, 0.0); }, + () -> { DoubleStream unused = r.doubles(10, .5, .4); }); } /** @@ -409,9 +412,10 @@ public class SplittableRandomTest extend for (int least = -15485867; least < MAX_INT_BOUND; least += 524959) { for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 67867967) { final int lo = least, hi = bound; - r.ints(size, lo, hi).parallel(). - forEach(x -> {if (x < lo || x >= hi) - fails.getAndIncrement(); }); + r.ints(size, lo, hi).parallel().forEach( + x -> { + if (x < lo || x >= hi) + fails.getAndIncrement(); }); } } assertEquals(0, fails.get()); @@ -427,9 +431,10 @@ public class SplittableRandomTest extend for (long least = -86028121; least < MAX_LONG_BOUND; least += 1982451653L) { for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) { final long lo = least, hi = bound; - r.longs(size, lo, hi).parallel(). - forEach(x -> {if (x < lo || x >= hi) - fails.getAndIncrement(); }); + r.longs(size, lo, hi).parallel().forEach( + x -> { + if (x < lo || x >= hi) + fails.getAndIncrement(); }); } } assertEquals(0, fails.get()); @@ -445,9 +450,10 @@ public class SplittableRandomTest extend for (double least = 0.00011; least < 1.0e20; least *= 9) { for (double bound = least * 1.0011; bound < 1.0e20; bound *= 17) { final double lo = least, hi = bound; - r.doubles(size, lo, hi).parallel(). - forEach(x -> {if (x < lo || x >= hi) - fails.getAndIncrement(); }); + r.doubles(size, lo, hi).parallel().forEach( + x -> { + if (x < lo || x >= hi) + fails.getAndIncrement(); }); } } assertEquals(0, fails.get()); @@ -519,4 +525,64 @@ public class SplittableRandomTest extend assertEquals(size, counter.sum()); } + /** + * SplittableRandom should implement most of Random's public methods + */ + public void testShouldImplementMostRandomMethods() throws Throwable { + Predicate wasForgotten = method -> { + String name = method.getName(); + // some methods deliberately not implemented + if (name.equals("setSeed")) return false; + if (name.equals("nextFloat")) return false; + if (name.equals("nextGaussian")) return false; + try { + SplittableRandom.class.getMethod( + method.getName(), method.getParameterTypes()); + } catch (ReflectiveOperationException ex) { + return true; + } + return false; + }; + List forgotten = + Arrays.stream(java.util.Random.class.getMethods()) + .filter(wasForgotten) + .collect(Collectors.toList()); + if (!forgotten.isEmpty()) + throw new AssertionError("Please implement: " + forgotten); + } + + /** + * Repeated calls to nextBytes produce at least values of different signs for every byte + */ + public void testNextBytes() { + SplittableRandom sr = new SplittableRandom(); + int n = sr.nextInt(1, 20); + byte[] bytes = new byte[n]; + outer: + for (int i = 0; i < n; i++) { + for (int tries = NCALLS; tries-->0; ) { + byte before = bytes[i]; + sr.nextBytes(bytes); + byte after = bytes[i]; + if (after * before < 0) + continue outer; + } + fail("not enough variation in random bytes"); + } + } + + /** + * Filling an empty array with random bytes succeeds without effect. + */ + public void testNextBytes_emptyArray() { + new SplittableRandom().nextBytes(new byte[0]); + } + + public void testNextBytes_nullArray() { + try { + new SplittableRandom().nextBytes(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + }