--- jsr166/src/test/tck/ThreadLocalRandomTest.java	2016/12/09 06:56:30	1.23
+++ jsr166/src/test/tck/ThreadLocalRandomTest.java	2018/01/28 16:41:13	1.29
@@ -57,16 +57,23 @@ public class ThreadLocalRandomTest exten
      * possible values.
      */
     public void testNext() throws ReflectiveOperationException {
+        // Inhibit "An illegal reflective access operation has occurred"
+        if (!testImplementationDetails) return;
+
         ThreadLocalRandom rnd = ThreadLocalRandom.current();
         final java.lang.reflect.Method m;
         try {
-            m = ThreadLocalRandom.class.getDeclaredMethod(
-                    "next", new Class[] { int.class });
+            m = ThreadLocalRandom.class.getDeclaredMethod("next", int.class);
             m.setAccessible(true);
-        } catch (SecurityException
-                 | java.lang.reflect.InaccessibleObjectException acceptable) {
-            // Either jdk9 module system or security manager might deny access.
+        } catch (SecurityException acceptable) {
+            // Security manager may deny access
             return;
+        } catch (Exception ex) {
+            // jdk9 module system may deny access
+            if (ex.getClass().getSimpleName()
+                .equals("InaccessibleObjectException"))
+                return;
+            throw ex;
         }
 
         int i;
@@ -347,7 +354,7 @@ public class ThreadLocalRandomTest exten
         // Don't use main thread's ThreadLocalRandom - it is likely to
         // be polluted by previous tests.
         final AtomicReference<ThreadLocalRandom> threadLocalRandom =
-            new AtomicReference<ThreadLocalRandom>();
+            new AtomicReference<>();
         final AtomicLong rand = new AtomicLong();
 
         long firstRand = 0;
@@ -377,4 +384,38 @@ public class ThreadLocalRandomTest exten
         fail("all threads generate the same pseudo-random sequence");
     }
 
+    /**
+     * Repeated calls to nextBytes produce at least values of different signs for every byte
+     */
+    public void testNextBytes() {
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        int n = rnd.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];
+                rnd.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() {
+        ThreadLocalRandom.current().nextBytes(new byte[0]);
+    }
+
+    public void testNextBytes_nullArray() {
+        try {
+            ThreadLocalRandom.current().nextBytes(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
 }