test/tck/ThreadLocalRandom8Test.java

/*
 * 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/
 */
import junit.framework.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;

public class ThreadLocalRandom8Test extends JSR166TestCase {

    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    public static Test suite() {
        return new TestSuite(ThreadLocalRandom8Test.class);
    }

    // max sampled int bound
    static final int MAX_INT_BOUND = (1 << 28);

    // 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
     */
    public void testBadStreamSize() {
        ThreadLocalRandom r = ThreadLocalRandom.current();
        try {
            java.util.stream.IntStream x = r.ints(-1L);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.IntStream x = r.ints(-1L, 2, 3);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.LongStream x = r.longs(-1L);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.LongStream x = r.longs(-1L, -1L, 1L);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.DoubleStream x = r.doubles(-1L);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * Invoking bounded ints, long, doubles, with illegal bounds throws
     * IllegalArgumentException
     */
    public void testBadStreamBounds() {
        ThreadLocalRandom r = ThreadLocalRandom.current();
        try {
            java.util.stream.IntStream x = r.ints(2, 1);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.IntStream x = r.ints(10, 42, 42);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.LongStream x = r.longs(-1L, -1L);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.LongStream x = r.longs(10, 1L, -2L);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.DoubleStream x = r.doubles(0.0, 0.0);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
        try {
            java.util.stream.DoubleStream x = r.doubles(10, .5, .4);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * 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());
    }

}
Revision:	1.4
Committed:	Mon Sep 23 17:23:50 2013 UTC (10 years, 7 months ago) by jsr166
Branch:	MAIN
Changes since 1.3:	+2 -1 lines
Log Message:	Reduce default value of REPS
#	Content
1	/*
2	* Written by Doug Lea with assistance from members of JCP JSR-166
3	* Expert Group and released to the public domain, as explained at
4	* http://creativecommons.org/publicdomain/zero/1.0/
5	*/
6	import junit.framework.*;
7	import java.util.*;
8	import java.util.concurrent.ThreadLocalRandom;
9	import java.util.concurrent.atomic.AtomicInteger;
10	import java.util.concurrent.atomic.LongAdder;
11
12	public class ThreadLocalRandom8Test extends JSR166TestCase {
13
14	public static void main(String[] args) {
15	junit.textui.TestRunner.run(suite());
16	}
17	public static Test suite() {
18	return new TestSuite(ThreadLocalRandom8Test.class);
19	}
20
21	// max sampled int bound
22	static final int MAX_INT_BOUND = (1 << 28);
23
24	// max sampled long bound
25	static final long MAX_LONG_BOUND = (1L << 42);
26
27	// Number of replications for other checks
28	static final int REPS =
29	Integer.getInteger("ThreadLocalRandom8Test.reps", 4);
30
31	/**
32	* Invoking sized ints, long, doubles, with negative sizes throws
33	* IllegalArgumentException
34	*/
35	public void testBadStreamSize() {
36	ThreadLocalRandom r = ThreadLocalRandom.current();
37	try {
38	java.util.stream.IntStream x = r.ints(-1L);
39	shouldThrow();
40	} catch (IllegalArgumentException success) {}
41	try {
42	java.util.stream.IntStream x = r.ints(-1L, 2, 3);
43	shouldThrow();
44	} catch (IllegalArgumentException success) {}
45	try {
46	java.util.stream.LongStream x = r.longs(-1L);
47	shouldThrow();
48	} catch (IllegalArgumentException success) {}
49	try {
50	java.util.stream.LongStream x = r.longs(-1L, -1L, 1L);
51	shouldThrow();
52	} catch (IllegalArgumentException success) {}
53	try {
54	java.util.stream.DoubleStream x = r.doubles(-1L);
55	shouldThrow();
56	} catch (IllegalArgumentException success) {}
57	try {
58	java.util.stream.DoubleStream x = r.doubles(-1L, .5, .6);
59	shouldThrow();
60	} catch (IllegalArgumentException success) {}
61	}
62
63	/**
64	* Invoking bounded ints, long, doubles, with illegal bounds throws
65	* IllegalArgumentException
66	*/
67	public void testBadStreamBounds() {
68	ThreadLocalRandom r = ThreadLocalRandom.current();
69	try {
70	java.util.stream.IntStream x = r.ints(2, 1);
71	shouldThrow();
72	} catch (IllegalArgumentException success) {}
73	try {
74	java.util.stream.IntStream x = r.ints(10, 42, 42);
75	shouldThrow();
76	} catch (IllegalArgumentException success) {}
77	try {
78	java.util.stream.LongStream x = r.longs(-1L, -1L);
79	shouldThrow();
80	} catch (IllegalArgumentException success) {}
81	try {
82	java.util.stream.LongStream x = r.longs(10, 1L, -2L);
83	shouldThrow();
84	} catch (IllegalArgumentException success) {}
85	try {
86	java.util.stream.DoubleStream x = r.doubles(0.0, 0.0);
87	shouldThrow();
88	} catch (IllegalArgumentException success) {}
89	try {
90	java.util.stream.DoubleStream x = r.doubles(10, .5, .4);
91	shouldThrow();
92	} catch (IllegalArgumentException success) {}
93	}
94
95	/**
96	* A parallel sized stream of ints generates the given number of values
97	*/
98	public void testIntsCount() {
99	LongAdder counter = new LongAdder();
100	ThreadLocalRandom r = ThreadLocalRandom.current();
101	long size = 0;
102	for (int reps = 0; reps < REPS; ++reps) {
103	counter.reset();
104	r.ints(size).parallel().forEach(x -> counter.increment());
105	assertEquals(size, counter.sum());
106	size += 524959;
107	}
108	}
109
110	/**
111	* A parallel sized stream of longs generates the given number of values
112	*/
113	public void testLongsCount() {
114	LongAdder counter = new LongAdder();
115	ThreadLocalRandom r = ThreadLocalRandom.current();
116	long size = 0;
117	for (int reps = 0; reps < REPS; ++reps) {
118	counter.reset();
119	r.longs(size).parallel().forEach(x -> counter.increment());
120	assertEquals(size, counter.sum());
121	size += 524959;
122	}
123	}
124
125	/**
126	* A parallel sized stream of doubles generates the given number of values
127	*/
128	public void testDoublesCount() {
129	LongAdder counter = new LongAdder();
130	ThreadLocalRandom r = ThreadLocalRandom.current();
131	long size = 0;
132	for (int reps = 0; reps < REPS; ++reps) {
133	counter.reset();
134	r.doubles(size).parallel().forEach(x -> counter.increment());
135	assertEquals(size, counter.sum());
136	size += 524959;
137	}
138	}
139
140	/**
141	* Each of a parallel sized stream of bounded ints is within bounds
142	*/
143	public void testBoundedInts() {
144	AtomicInteger fails = new AtomicInteger(0);
145	ThreadLocalRandom r = ThreadLocalRandom.current();
146	long size = 12345L;
147	for (int least = -15485867; least < MAX_INT_BOUND; least += 524959) {
148	for (int bound = least + 2; bound > least && bound < MAX_INT_BOUND; bound += 67867967) {
149	final int lo = least, hi = bound;
150	r.ints(size, lo, hi).parallel().
151	forEach(x -> {if (x < lo \|\| x >= hi)
152	fails.getAndIncrement(); });
153	}
154	}
155	assertEquals(0, fails.get());
156	}
157
158	/**
159	* Each of a parallel sized stream of bounded longs is within bounds
160	*/
161	public void testBoundedLongs() {
162	AtomicInteger fails = new AtomicInteger(0);
163	ThreadLocalRandom r = ThreadLocalRandom.current();
164	long size = 123L;
165	for (long least = -86028121; least < MAX_LONG_BOUND; least += 1982451653L) {
166	for (long bound = least + 2; bound > least && bound < MAX_LONG_BOUND; bound += Math.abs(bound * 7919)) {
167	final long lo = least, hi = bound;
168	r.longs(size, lo, hi).parallel().
169	forEach(x -> {if (x < lo \|\| x >= hi)
170	fails.getAndIncrement(); });
171	}
172	}
173	assertEquals(0, fails.get());
174	}
175
176	/**
177	* Each of a parallel sized stream of bounded doubles is within bounds
178	*/
179	public void testBoundedDoubles() {
180	AtomicInteger fails = new AtomicInteger(0);
181	ThreadLocalRandom r = ThreadLocalRandom.current();
182	long size = 456;
183	for (double least = 0.00011; least < 1.0e20; least *= 9) {
184	for (double bound = least * 1.0011; bound < 1.0e20; bound *= 17) {
185	final double lo = least, hi = bound;
186	r.doubles(size, lo, hi).parallel().
187	forEach(x -> {if (x < lo \|\| x >= hi)
188	fails.getAndIncrement(); });
189	}
190	}
191	assertEquals(0, fails.get());
192	}
193
194	/**
195	* A parallel unsized stream of ints generates at least 100 values
196	*/
197	public void testUnsizedIntsCount() {
198	LongAdder counter = new LongAdder();
199	ThreadLocalRandom r = ThreadLocalRandom.current();
200	long size = 100;
201	r.ints().limit(size).parallel().forEach(x -> counter.increment());
202	assertEquals(size, counter.sum());
203	}
204
205	/**
206	* A parallel unsized stream of longs generates at least 100 values
207	*/
208	public void testUnsizedLongsCount() {
209	LongAdder counter = new LongAdder();
210	ThreadLocalRandom r = ThreadLocalRandom.current();
211	long size = 100;
212	r.longs().limit(size).parallel().forEach(x -> counter.increment());
213	assertEquals(size, counter.sum());
214	}
215
216	/**
217	* A parallel unsized stream of doubles generates at least 100 values
218	*/
219	public void testUnsizedDoublesCount() {
220	LongAdder counter = new LongAdder();
221	ThreadLocalRandom r = ThreadLocalRandom.current();
222	long size = 100;
223	r.doubles().limit(size).parallel().forEach(x -> counter.increment());
224	assertEquals(size, counter.sum());
225	}
226
227	/**
228	* A sequential unsized stream of ints generates at least 100 values
229	*/
230	public void testUnsizedIntsCountSeq() {
231	LongAdder counter = new LongAdder();
232	ThreadLocalRandom r = ThreadLocalRandom.current();
233	long size = 100;
234	r.ints().limit(size).forEach(x -> counter.increment());
235	assertEquals(size, counter.sum());
236	}
237
238	/**
239	* A sequential unsized stream of longs generates at least 100 values
240	*/
241	public void testUnsizedLongsCountSeq() {
242	LongAdder counter = new LongAdder();
243	ThreadLocalRandom r = ThreadLocalRandom.current();
244	long size = 100;
245	r.longs().limit(size).forEach(x -> counter.increment());
246	assertEquals(size, counter.sum());
247	}
248
249	/**
250	* A sequential unsized stream of doubles generates at least 100 values
251	*/
252	public void testUnsizedDoublesCountSeq() {
253	LongAdder counter = new LongAdder();
254	ThreadLocalRandom r = ThreadLocalRandom.current();
255	long size = 100;
256	r.doubles().limit(size).forEach(x -> counter.increment());
257	assertEquals(size, counter.sum());
258	}
259
260	}