From e8b323c7cb7d55be9a4df579231e44f04f53d766 Mon Sep 17 00:00:00 2001 From: Przemyslaw Szczepaniak Date: Fri, 11 Mar 2016 15:59:10 +0000 Subject: JSR-166 update without java 1.9 method/classes Second attempt, in frist one I've submitted some code from openJdk 1.9 that shouldn't be here, orignial change can be found at 5328e07d282bef36ac8b757bbee16a761415b2c4 Adapted from sources taken from CVS using: cvs -d ':pserver:anonymous@gee.cs.oswego.edu/home/jsr166/jsr166' checkout -D "03/03/2016 10:00:00 GMT" jsr166 This time with hidden/removed "@since 9" methods and classes Bug: 27426599 Change-Id: Ibd8d26e13cba091bfd983c73d005e4f8d8f5946d (cherry picked from commit b8b75116273ecfdb8ffdd1869b1c0dd04570a95e) --- .../test/java/jsr166/ThreadLocalRandom8Test.java | 241 +++++++++++++++++++++ 1 file changed, 241 insertions(+) create mode 100644 jsr166-tests/src/test/java/jsr166/ThreadLocalRandom8Test.java (limited to 'jsr166-tests/src/test/java/jsr166/ThreadLocalRandom8Test.java') diff --git a/jsr166-tests/src/test/java/jsr166/ThreadLocalRandom8Test.java b/jsr166-tests/src/test/java/jsr166/ThreadLocalRandom8Test.java new file mode 100644 index 0000000000..614af8372c --- /dev/null +++ b/jsr166-tests/src/test/java/jsr166/ThreadLocalRandom8Test.java @@ -0,0 +1,241 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +package jsr166; + +import java.util.concurrent.ThreadLocalRandom; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.LongAdder; + +import junit.framework.Test; +import junit.framework.TestSuite; + +public class ThreadLocalRandom8Test extends JSR166TestCase { + + // android-note: Removed because the CTS runner does a bad job of + // retrying tests that have suite() declarations. + // + // public static void main(String[] args) { + // main(suite(), args); + // } + // public static Test suite() { + // return new TestSuite(ThreadLocalRandom8Test.class); + // } + + // max sampled int bound + static final int MAX_INT_BOUND = (1 << 26); + + // max sampled long bound + static final long MAX_LONG_BOUND = (1L << 42); + + // Number of replications for other checks + static final int REPS = + Integer.getInteger("ThreadLocalRandom8Test.reps", 4); + + /** + * Invoking sized ints, long, doubles, with negative sizes throws + * IllegalArgumentException + */ + // TODO(streams): + // public void testBadStreamSize() { + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // Runnable[] throwingActions = { + // () -> r.ints(-1L), + // () -> r.ints(-1L, 2, 3), + // () -> r.longs(-1L), + // () -> r.longs(-1L, -1L, 1L), + // () -> r.doubles(-1L), + // () -> r.doubles(-1L, .5, .6), + // }; + // assertThrows(IllegalArgumentException.class, throwingActions); + // } + + // /** + // * Invoking bounded ints, long, doubles, with illegal bounds throws + // * IllegalArgumentException + // */ + // public void testBadStreamBounds() { + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // Runnable[] throwingActions = { + // () -> r.ints(2, 1), + // () -> r.ints(10, 42, 42), + // () -> r.longs(-1L, -1L), + // () -> r.longs(10, 1L, -2L), + // () -> r.doubles(0.0, 0.0), + // () -> r.doubles(10, .5, .4), + // }; + // assertThrows(IllegalArgumentException.class, throwingActions); + // } + + // /** + // * A parallel sized stream of ints generates the given number of values + // */ + // public void testIntsCount() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 0; + // for (int reps = 0; reps < REPS; ++reps) { + // counter.reset(); + // r.ints(size).parallel().forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // size += 524959; + // } + // } + + // /** + // * A parallel sized stream of longs generates the given number of values + // */ + // public void testLongsCount() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 0; + // for (int reps = 0; reps < REPS; ++reps) { + // counter.reset(); + // r.longs(size).parallel().forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // size += 524959; + // } + // } + + // /** + // * A parallel sized stream of doubles generates the given number of values + // */ + // public void testDoublesCount() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 0; + // for (int reps = 0; reps < REPS; ++reps) { + // counter.reset(); + // r.doubles(size).parallel().forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // size += 524959; + // } + // } + + // /** + // * Each of a parallel sized stream of bounded ints is within bounds + // */ + // public void testBoundedInts() { + // AtomicInteger fails = new AtomicInteger(0); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 12345L; + // 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(); }); + // } + // } + // assertEquals(0, fails.get()); + // } + + // /** + // * Each of a parallel sized stream of bounded longs is within bounds + // */ + // public void testBoundedLongs() { + // AtomicInteger fails = new AtomicInteger(0); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 123L; + // 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(); }); + // } + // } + // assertEquals(0, fails.get()); + // } + + // /** + // * Each of a parallel sized stream of bounded doubles is within bounds + // */ + // public void testBoundedDoubles() { + // AtomicInteger fails = new AtomicInteger(0); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 456; + // 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(); }); + // } + // } + // assertEquals(0, fails.get()); + // } + + // /** + // * A parallel unsized stream of ints generates at least 100 values + // */ + // public void testUnsizedIntsCount() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 100; + // r.ints().limit(size).parallel().forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // } + + // /** + // * A parallel unsized stream of longs generates at least 100 values + // */ + // public void testUnsizedLongsCount() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 100; + // r.longs().limit(size).parallel().forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // } + + // /** + // * A parallel unsized stream of doubles generates at least 100 values + // */ + // public void testUnsizedDoublesCount() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 100; + // r.doubles().limit(size).parallel().forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // } + + // /** + // * A sequential unsized stream of ints generates at least 100 values + // */ + // public void testUnsizedIntsCountSeq() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 100; + // r.ints().limit(size).forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // } + + // /** + // * A sequential unsized stream of longs generates at least 100 values + // */ + // public void testUnsizedLongsCountSeq() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 100; + // r.longs().limit(size).forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // } + + // /** + // * A sequential unsized stream of doubles generates at least 100 values + // */ + // public void testUnsizedDoublesCountSeq() { + // LongAdder counter = new LongAdder(); + // ThreadLocalRandom r = ThreadLocalRandom.current(); + // long size = 100; + // r.doubles().limit(size).forEach(x -> counter.increment()); + // assertEquals(size, counter.sum()); + // } + +} -- cgit v1.2.3