ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ThreadLocalRandomTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ThreadLocalRandomTest.java (file contents):
Revision 1.22 by jsr166, Sun Nov 13 03:36:50 2016 UTC vs.
Revision 1.26 by jsr166, Tue Oct 3 22:27:04 2017 UTC

# Line 57 | Line 57 | public class ThreadLocalRandomTest exten
57       * possible values.
58       */
59      public void testNext() throws ReflectiveOperationException {
60 +        // Inhibit "An illegal reflective access operation has occurred"
61 +        if (!testImplementationDetails) return;
62 +
63          ThreadLocalRandom rnd = ThreadLocalRandom.current();
64 +        final java.lang.reflect.Method m;
65          try {
66 <            java.lang.reflect.Method m
63 <                = ThreadLocalRandom.class.getDeclaredMethod(
66 >            m = ThreadLocalRandom.class.getDeclaredMethod(
67                      "next", new Class[] { int.class });
68              m.setAccessible(true);
69 +        } catch (SecurityException acceptable) {
70 +            // Security manager may deny access
71 +            return;
72 +        } catch (Exception ex) {
73 +            // jdk9 module system may deny access
74 +            if (ex.getClass().getSimpleName()
75 +                .equals("InaccessibleObjectException"))
76 +                return;
77 +            throw ex;
78 +        }
79  
80 <            int i;
81 <            {
82 <                int val = new java.util.Random().nextInt(4);
83 <                for (i = 0; i < NCALLS; i++) {
84 <                    int q = (int) m.invoke(rnd, new Object[] { 2 });
85 <                    if (val == q) break;
73 <                }
74 <                assertTrue(i < NCALLS);
80 >        int i;
81 >        {
82 >            int val = new java.util.Random().nextInt(4);
83 >            for (i = 0; i < NCALLS; i++) {
84 >                int q = (int) m.invoke(rnd, new Object[] { 2 });
85 >                if (val == q) break;
86              }
87 +            assertTrue(i < NCALLS);
88 +        }
89  
90 <            {
91 <                int r = (int) m.invoke(rnd, new Object[] { 3 });
92 <                for (i = 0; i < NCALLS; i++) {
93 <                    int q = (int) m.invoke(rnd, new Object[] { 3 });
94 <                    assertTrue(q < (1<<3));
95 <                    if (r != q) break;
83 <                }
84 <                assertTrue(i < NCALLS);
90 >        {
91 >            int r = (int) m.invoke(rnd, new Object[] { 3 });
92 >            for (i = 0; i < NCALLS; i++) {
93 >                int q = (int) m.invoke(rnd, new Object[] { 3 });
94 >                assertTrue(q < (1<<3));
95 >                if (r != q) break;
96              }
97 <        } catch (SecurityException acceptable) {}
97 >            assertTrue(i < NCALLS);
98 >        }
99      }
100  
101      /**
# Line 373 | Line 385 | public class ThreadLocalRandomTest exten
385          fail("all threads generate the same pseudo-random sequence");
386      }
387  
388 +    /**
389 +     * Repeated calls to nextBytes produce at least values of different signs for every byte
390 +     */
391 +    public void testNextBytes() {
392 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
393 +        int n = rnd.nextInt(20);
394 +        byte[] bytes = new byte[n];
395 +        outer:
396 +        for (int i = 0; i < n; i++) {
397 +            for (int tries = NCALLS; tries-->0; ) {
398 +                byte before = bytes[i];
399 +                rnd.nextBytes(bytes);
400 +                byte after = bytes[i];
401 +                if (after * before < 0)
402 +                    continue outer;
403 +            }
404 +            fail("not enough variation in random bytes");
405 +        }
406 +    }
407 +
408   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines