--- old/test/java/nio/Buffer/Basic-X.java.template	2016-05-13 12:28:55.000000000 +0100
+++ new/test/java/nio/Buffer/Basic-X.java.template	2016-05-13 12:28:55.000000000 +0100
@@ -31,7 +31,6 @@
 #warn This file is preprocessed before being compiled
 
 import java.nio.*;
-import java.lang.reflect.Method;
 
 
 public class Basic$Type$
@@ -60,25 +59,25 @@
 
     private static void relGet($Type$Buffer b) {
         int n = b.capacity();
-        $type$ v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)(($type$)ic(i)));
+        }
         b.rewind();
     }
 
     private static void relGet($Type$Buffer b, int start) {
         int n = b.remaining();
-        $type$ v;
-        for (int i = start; i < n; i++)
+        for (int i = start; i < n; i++) {
             ck(b, (long)b.get(), (long)(($type$)ic(i)));
+        }
         b.rewind();
     }
 
     private static void absGet($Type$Buffer b) {
         int n = b.capacity();
-        $type$ v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)(($type$)ic(i)));
+        }
         b.rewind();
     }
 
@@ -86,23 +85,26 @@
         int n = b.capacity();
         $type$[] a = new $type$[n + 7];
         b.get(a, 7, n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)a[i + 7], (long)(($type$)ic(i)));
+        }
     }
 
     private static void relPut($Type$Buffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(($type$)ic(i));
+        }
         b.flip();
     }
 
     private static void absPut($Type$Buffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(i, ($type$)ic(i));
+        }
         b.limit(n);
         b.position(0);
     }
@@ -111,8 +113,9 @@
         int n = b.capacity();
         b.clear();
         $type$[] a = new $type$[n + 7];
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             a[i + 7] = ($type$)ic(i);
+        }
         b.put(a, 7, n);
         b.flip();
     }
@@ -122,8 +125,9 @@
         b.clear();
         $Type$Buffer c = $Type$Buffer.allocate(n + 7);
         c.position(7);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             c.put(($type$)ic(i));
+        }
         c.flip();
         c.position(7);
         b.put(c);
@@ -178,10 +182,11 @@
     private static void bulkPutString($Type$Buffer b) {
         int n = b.capacity();
         b.clear();
-        StringBuffer sb = new StringBuffer(n + 7);
+        StringBuilder sb = new StringBuilder(n + 7);
         sb.append("1234567");
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             sb.append((char)ic(i));
+        }
         b.put(sb.toString(), 7, 7 + n);
         b.flip();
     }
@@ -192,10 +197,12 @@
         ck(slice, 0, slice.position());
         ck(slice, b.remaining(), slice.limit());
         ck(slice, b.remaining(), slice.capacity());
-        if (b.isDirect() != slice.isDirect())
+        if (b.isDirect() != slice.isDirect()) {
             fail("Lost direction", slice);
-        if (b.isReadOnly() != slice.isReadOnly())
+        }
+        if (b.isReadOnly() != slice.isReadOnly()) {
             fail("Lost read-only", slice);
+        }
     }
 
 #if[byte]
@@ -203,13 +210,14 @@
     private static void checkBytes(ByteBuffer b, byte[] bs) {
         int n = bs.length;
         int p = b.position();
-        byte v;
         if (b.order() == ByteOrder.BIG_ENDIAN) {
-            for (int i = 0; i < n; i++)
+            for (int i = 0; i < n; i++) {
                 ck(b, b.get(), bs[i]);
+            }
         } else {
-            for (int i = n - 1; i >= 0; i--)
+            for (int i = n - 1; i >= 0; i--) {
                 ck(b, b.get(), bs[i]);
+            }
         }
         b.position(p);
     }
@@ -217,7 +225,7 @@
     private static void compact(Buffer b) {
         try {
             Class<?> cl = b.getClass();
-            Method m = cl.getDeclaredMethod("compact");
+            java.lang.reflect.Method m = cl.getDeclaredMethod("compact");
             m.setAccessible(true);
             m.invoke(b);
         } catch (Exception e) {
@@ -226,12 +234,11 @@
     }
 
     private static void checkInvalidMarkException(final Buffer b) {
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-            public void run() {
+        tryCatch(b, InvalidMarkException.class, () -> {
                 b.mark();
                 compact(b);
                 b.reset();
-            }});
+            });
     }
 
     private static void testViews(int level, ByteBuffer b, boolean direct) {
@@ -364,29 +371,32 @@
         if (direct) {
             // Freshly created direct byte buffers should be aligned at index 0
             // for ref and primitive values (see Unsafe.allocateMemory)
-            if (longMisalignmentAtZero != 0)
-                fail("Direct byte buffer misalligned at index 0 for ref and primitive values " + longMisalignmentAtZero);
+            if (longMisalignmentAtZero != 0) {
+                fail("Direct byte buffer misaligned at index 0 for ref and primitive values " + longMisalignmentAtZero);
+            }
         } else {
             // For heap byte buffers misalignment may occur on 32-bit systems
             // where Unsafe.ARRAY_BYTE_BASE_OFFSET % 8 == 4 and not 0
             // Note the GC will preserve alignment of the base address of the
             // array
-            if (jdk.internal.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET % 8 != longMisalignmentAtZero)
-                fail("Heap byte buffer misalligned at index 0 for ref and primitive values " + longMisalignmentAtZero);
+            if (jdk.internal.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET % 8 != longMisalignmentAtZero) {
+                fail("Heap byte buffer misaligned at index 0 for ref and primitive values " + longMisalignmentAtZero);
+            }
         }
 
         // Ensure test buffer is correctly aligned at index 0
-        if (b.alignmentOffset(0, 8) != longMisalignmentAtZero)
+        if (b.alignmentOffset(0, 8) != longMisalignmentAtZero) {
             fail("Test input buffer not correctly aligned at index 0", b);
-
+        }
         // Test misalignment values
         for (int us : new int[]{1, 2, 4, 8}) {
             for (int i = 0; i < us * 2; i++) {
                 int am = b.alignmentOffset(i, us);
                 int expectedAm = (longMisalignmentAtZero + i) % us;
 
-                if (am != expectedAm)
+                if (am != expectedAm) {
                     fail(String.format("b.alignmentOffset(%d, %d) == %d incorrect, expected %d", i, us, am, expectedAm));
+                }
             }
         }
 
@@ -395,10 +405,12 @@
         int al = b.limit() - b.alignmentOffset(b.limit(), 8);
         ByteBuffer ab = b.position(ap).limit(al).
                 slice();
-        if (ab.limit() == 0)
+        if (ab.limit() == 0) {
             fail("Test input buffer not sufficiently sized to cover an aligned region for all values", b);
-        if (ab.alignmentOffset(0, 8) != 0)
+        }
+        if (ab.alignmentOffset(0, 8) != 0) {
             fail("Aligned test input buffer not correctly aligned at index 0", ab);
+        }
 
         for (int us : new int[]{1, 2, 4, 8}) {
             for (int p = 1; p < 16; p++) {
@@ -409,17 +421,18 @@
 
                 ck(as, 0, as.position());
                 ck(as, as.capacity(), as.limit());
-                if (b.isDirect() != as.isDirect())
+                if (b.isDirect() != as.isDirect()) {
                     fail("Lost direction", as);
-                if (b.isReadOnly() != as.isReadOnly())
+                }
+                if (b.isReadOnly() != as.isReadOnly()) {
                     fail("Lost read-only", as);
-
-                if (as.alignmentOffset(0, us) != 0)
+                }
+                if (as.alignmentOffset(0, us) != 0) {
                     fail("Buffer not correctly aligned at index 0", as);
-
-                if (as.alignmentOffset(as.limit(), us) != 0)
+                }
+                if (as.alignmentOffset(as.limit(), us) != 0) {
                     fail("Buffer not correctly aligned at limit", as);
-
+                }
                 int p_mod = ab.alignmentOffset(p, us);
                 int l_mod = ab.alignmentOffset(l, us);
                 // Round up position
@@ -428,8 +441,9 @@
                 l = l - l_mod;
 
                 int ec = l - p;
-                if (as.limit() != ec)
+                if (as.limit() != ec) {
                     fail("Buffer capacity incorrect, expected: " + ec, as);
+                }
             }
         }
     }
@@ -452,8 +466,9 @@
                 fail(x.getMessage() + " not expected");
             }
         }
-        if (!caught)
+        if (!caught) {
             fail(ex.getName() + " not thrown", b);
+        }
     }
 
     private static void tryCatch($type$ [] t, Class<?> ex, Runnable thunk) {
@@ -464,8 +479,9 @@
 
         show(level, b);
 
-        if (direct != b.isDirect())
+        if (direct != b.isDirect()) {
             fail("Wrong direction", b);
+        }
 
         // Gets and puts
 
@@ -513,11 +529,10 @@
         // 7190219
         b.clear();
         int pos = b.position();
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-            public void run() {
+        tryCatch(b, BufferOverflowException.class, () ->
                 b.put(String.valueOf(new char[b.capacity() + 1]), 0,
-                        b.capacity() + 1);
-            }});
+                        b.capacity() + 1)
+            );
         ck(b, b.position(), pos);
         relGet(b);
 
@@ -537,38 +552,13 @@
         b.limit(b.capacity() / 2);
         b.position(b.limit());
 
-        tryCatch(b, BufferUnderflowException.class, new Runnable() {
-                public void run() {
-                    b.get();
-                }});
-
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-                public void run() {
-                    b.put(($type$)42);
-                }});
-
-        // The index must be non-negative and lesss than the buffer's limit.
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(b.limit());
-                }});
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(-1);
-                }});
-
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.put(b.limit(), ($type$)42);
-                }});
-
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-                public void run() {
-                    b.position(0);
-                    b.mark();
-                    b.compact();
-                    b.reset();
-                }});
+        tryCatch(b, BufferUnderflowException.class, () -> b.get());
+        tryCatch(b, BufferOverflowException.class, () -> b.put(($type$)42));
+        // The index must be non-negative and less than the buffer's limit.
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(b.limit()));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(-1));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.put(b.limit(), ($type$)42));
+        tryCatch(b, InvalidMarkException.class, () -> b.position(0).mark().compact().reset());
 
         try {
             b.position(b.limit() + 1);
@@ -635,7 +625,6 @@
         b.put(0.5121609353879392);      // Changes value if incorrectly swapped
 #end[double]
 
-        $type$ v;
         b.flip();
         ck(b, b.get(), 0);
         ck(b, b.get(), ($type$)-1);
@@ -644,23 +633,27 @@
         ck(b, b.get(), $Fulltype$.MIN_VALUE);
 
 #if[float]
+        $type$ v;
         ck(b, b.get(), -Float.MAX_VALUE);
         ck(b, b.get(), -Float.MIN_VALUE);
         ck(b, b.get(), Float.NEGATIVE_INFINITY);
         ck(b, b.get(), Float.POSITIVE_INFINITY);
         if (Float.floatToRawIntBits(v = b.get()) !=
-            Float.floatToRawIntBits(Float.NaN))
+            Float.floatToRawIntBits(Float.NaN)) {
             fail(b, (long)Float.NaN, (long)v);
+        }
         ck(b, b.get(), 0.91697687f);
 #end[float]
 #if[double]
+        $type$ v;
         ck(b, b.get(), -Double.MAX_VALUE);
         ck(b, b.get(), -Double.MIN_VALUE);
         ck(b, b.get(), Double.NEGATIVE_INFINITY);
         ck(b, b.get(), Double.POSITIVE_INFINITY);
         if (Double.doubleToRawLongBits(v = b.get())
-            != Double.doubleToRawLongBits(Double.NaN))
+            != Double.doubleToRawLongBits(Double.NaN)) {
             fail(b, (long)Double.NaN, (long)v);
+        }
         ck(b, b.get(), 0.5121609353879392);
 #end[double]
 
@@ -683,30 +676,35 @@
 #if[float]
                     || Float.compare(x, y) != 0
 #end[float]
-                    )
+                    ) {
                     out.println("[" + i + "] " + x + " != " + y);
+                }
             }
             fail("Identical buffers not equal", b, b2);
         }
-        if (b.compareTo(b2) != 0)
+        if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
-
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put(($type$)99);
         b.rewind();
         b2.rewind();
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to shorter buffer <= 0", b, b2);
+        }
         b.limit(b.limit() - 1);
 
         b.put(2, ($type$)42);
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to lesser buffer <= 0", b, b2);
+        }
 
         // Check equals and compareTo with interesting values
         for ($type$ x : VALUES) {
@@ -714,7 +712,7 @@
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
-            if (! xb.equals(xb)) {
+            if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
             for ($type$ y : VALUES) {
@@ -763,11 +761,13 @@
         $Type$Buffer sb2 = sb.slice();
         checkSlice(sb, sb2);
 
-        if (!sb.equals(sb2))
+        if (!sb.equals(sb2)) {
             fail("Sliced slices do not match", sb, sb2);
-        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
+        }
+        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
             fail("Array offsets do not match: "
                  + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
+        }
 
 #if[byte]
 
@@ -804,98 +804,37 @@
 
         b.rewind();
         final $Type$Buffer rb = b.asReadOnlyBuffer();
-        if (!b.equals(rb))
+        if (!b.equals(rb)) {
             fail("Buffer not equal to read-only view", b, rb);
+        }
         show(level + 1, rb);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    relPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    absPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutArray(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutBuffer(rb);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> relPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> absPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutArray(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutBuffer(rb));
 
         // put($Type$Buffer) should not change source position
         final $Type$Buffer src = $Type$Buffer.allocate(1);
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.put(src);
-                 }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.put(src));
         ck(src, src.position(), 0);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.compact();
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.compact());
 
 #if[byte]
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putChar((char)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putChar(0, (char)1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putShort((short)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putShort(0, (short)1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putInt(1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putInt(0, 1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putLong((long)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putLong(0, (long)1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putFloat((float)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putFloat(0, (float)1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putDouble((double)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putDouble(0, (double)1);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putChar((char)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putChar(0, (char)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putShort((short)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putShort(0, (short)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putInt(1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putInt(0, 1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putLong((long)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putLong(0, (long)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putFloat((float)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putFloat(0, (float)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putDouble((double)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putDouble(0, (double)1));
 
 #end[byte]
 
@@ -916,21 +855,11 @@
 #end[char]
 
         if (rb.getClass().getName().startsWith("java.nio.Heap")) {
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.array();
-                    }});
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.arrayOffset();
-                    }});
-
-            if (rb.hasArray())
-                fail("Read-only heap buffer's backing array is accessible",
-                     rb);
-
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.array());
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.arrayOffset());
+            if (rb.hasArray()) {
+                fail("Read-only heap buffer's backing array is accessible", rb);
+            }
         }
 
         // Bulk puts from read-only buffers
@@ -1052,40 +981,19 @@
         ck(b, b.limit(), offset + length);
 
         // The offset must be non-negative and no larger than <array.length>.
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    $Type$Buffer.wrap(ba, -1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    $Type$Buffer.wrap(ba, ba.length + 1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    $Type$Buffer.wrap(ba, 0, -1);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    $Type$Buffer.wrap(ba, 0, ba.length + 1);
-                }});
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> $Type$Buffer.wrap(ba, -1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> $Type$Buffer.wrap(ba, ba.length + 1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> $Type$Buffer.wrap(ba, 0, -1));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> $Type$Buffer.wrap(ba, 0, ba.length + 1));
 
         // A NullPointerException will be thrown if the array is null.
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    $Type$Buffer.wrap(($type$ []) null, 0, 5);
-                }});
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    $Type$Buffer.wrap(($type$ []) null);
-                }});
+        tryCatch(ba, NullPointerException.class, () -> $Type$Buffer.wrap(($type$ []) null, 0, 5));
+        tryCatch(ba, NullPointerException.class, () -> $Type$Buffer.wrap(($type$ []) null));
     }
 
     private static void testAllocate() {
         // An IllegalArgumentException will be thrown for negative capacities.
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    $Type$Buffer.allocate(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> $Type$Buffer.allocate(-1));
         try {
             $Type$Buffer.allocate(-1);
         } catch (IllegalArgumentException e) {
@@ -1095,10 +1003,7 @@
             }
         }
 #if[byte]
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    $Type$Buffer.allocateDirect(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> $Type$Buffer.allocateDirect(-1));
         try {
             $Type$Buffer.allocateDirect(-1);
         } catch (IllegalArgumentException e) {
@@ -1117,8 +1022,9 @@
         test(new $type$[1024]);
 #if[byte]
         $Type$Buffer b = $Type$Buffer.allocateDirect(7 * 1024);
-        for (b.position(0); b.position() < b.limit(); )
+        for (b.position(0); b.position() < b.limit(); ) {
             ck(b, b.get(), 0);
+        }
         test(0, b, true);
 #end[byte]
 #if[char]
--- old/test/java/nio/Buffer/BasicByte.java	2016-05-13 12:28:56.000000000 +0100
+++ new/test/java/nio/Buffer/BasicByte.java	2016-05-13 12:28:56.000000000 +0100
@@ -31,7 +31,6 @@
 // -- This file was mechanically generated: Do not edit! -- //
 
 import java.nio.*;
-import java.lang.reflect.Method;
 
 
 public class BasicByte
@@ -60,25 +59,25 @@
 
     private static void relGet(ByteBuffer b) {
         int n = b.capacity();
-        byte v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((byte)ic(i)));
+        }
         b.rewind();
     }
 
     private static void relGet(ByteBuffer b, int start) {
         int n = b.remaining();
-        byte v;
-        for (int i = start; i < n; i++)
+        for (int i = start; i < n; i++) {
             ck(b, (long)b.get(), (long)((byte)ic(i)));
+        }
         b.rewind();
     }
 
     private static void absGet(ByteBuffer b) {
         int n = b.capacity();
-        byte v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((byte)ic(i)));
+        }
         b.rewind();
     }
 
@@ -86,23 +85,26 @@
         int n = b.capacity();
         byte[] a = new byte[n + 7];
         b.get(a, 7, n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)a[i + 7], (long)((byte)ic(i)));
+        }
     }
 
     private static void relPut(ByteBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put((byte)ic(i));
+        }
         b.flip();
     }
 
     private static void absPut(ByteBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(i, (byte)ic(i));
+        }
         b.limit(n);
         b.position(0);
     }
@@ -111,8 +113,9 @@
         int n = b.capacity();
         b.clear();
         byte[] a = new byte[n + 7];
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             a[i + 7] = (byte)ic(i);
+        }
         b.put(a, 7, n);
         b.flip();
     }
@@ -122,8 +125,9 @@
         b.clear();
         ByteBuffer c = ByteBuffer.allocate(n + 7);
         c.position(7);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             c.put((byte)ic(i));
+        }
         c.flip();
         c.position(7);
         b.put(c);
@@ -188,14 +192,17 @@
 
 
 
+
     private static void checkSlice(ByteBuffer b, ByteBuffer slice) {
         ck(slice, 0, slice.position());
         ck(slice, b.remaining(), slice.limit());
         ck(slice, b.remaining(), slice.capacity());
-        if (b.isDirect() != slice.isDirect())
+        if (b.isDirect() != slice.isDirect()) {
             fail("Lost direction", slice);
-        if (b.isReadOnly() != slice.isReadOnly())
+        }
+        if (b.isReadOnly() != slice.isReadOnly()) {
             fail("Lost read-only", slice);
+        }
     }
 
 
@@ -203,13 +210,14 @@
     private static void checkBytes(ByteBuffer b, byte[] bs) {
         int n = bs.length;
         int p = b.position();
-        byte v;
         if (b.order() == ByteOrder.BIG_ENDIAN) {
-            for (int i = 0; i < n; i++)
+            for (int i = 0; i < n; i++) {
                 ck(b, b.get(), bs[i]);
+            }
         } else {
-            for (int i = n - 1; i >= 0; i--)
+            for (int i = n - 1; i >= 0; i--) {
                 ck(b, b.get(), bs[i]);
+            }
         }
         b.position(p);
     }
@@ -217,7 +225,7 @@
     private static void compact(Buffer b) {
         try {
             Class<?> cl = b.getClass();
-            Method m = cl.getDeclaredMethod("compact");
+            java.lang.reflect.Method m = cl.getDeclaredMethod("compact");
             m.setAccessible(true);
             m.invoke(b);
         } catch (Exception e) {
@@ -226,12 +234,11 @@
     }
 
     private static void checkInvalidMarkException(final Buffer b) {
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-            public void run() {
+        tryCatch(b, InvalidMarkException.class, () -> {
                 b.mark();
                 compact(b);
                 b.reset();
-            }});
+            });
     }
 
     private static void testViews(int level, ByteBuffer b, boolean direct) {
@@ -364,29 +371,32 @@
         if (direct) {
             // Freshly created direct byte buffers should be aligned at index 0
             // for ref and primitive values (see Unsafe.allocateMemory)
-            if (longMisalignmentAtZero != 0)
-                fail("Direct byte buffer misalligned at index 0 for ref and primitive values " + longMisalignmentAtZero);
+            if (longMisalignmentAtZero != 0) {
+                fail("Direct byte buffer misaligned at index 0 for ref and primitive values " + longMisalignmentAtZero);
+            }
         } else {
             // For heap byte buffers misalignment may occur on 32-bit systems
             // where Unsafe.ARRAY_BYTE_BASE_OFFSET % 8 == 4 and not 0
             // Note the GC will preserve alignment of the base address of the
             // array
-            if (jdk.internal.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET % 8 != longMisalignmentAtZero)
-                fail("Heap byte buffer misalligned at index 0 for ref and primitive values " + longMisalignmentAtZero);
+            if (jdk.internal.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET % 8 != longMisalignmentAtZero) {
+                fail("Heap byte buffer misaligned at index 0 for ref and primitive values " + longMisalignmentAtZero);
+            }
         }
 
         // Ensure test buffer is correctly aligned at index 0
-        if (b.alignmentOffset(0, 8) != longMisalignmentAtZero)
+        if (b.alignmentOffset(0, 8) != longMisalignmentAtZero) {
             fail("Test input buffer not correctly aligned at index 0", b);
-
+        }
         // Test misalignment values
         for (int us : new int[]{1, 2, 4, 8}) {
             for (int i = 0; i < us * 2; i++) {
                 int am = b.alignmentOffset(i, us);
                 int expectedAm = (longMisalignmentAtZero + i) % us;
 
-                if (am != expectedAm)
+                if (am != expectedAm) {
                     fail(String.format("b.alignmentOffset(%d, %d) == %d incorrect, expected %d", i, us, am, expectedAm));
+                }
             }
         }
 
@@ -395,10 +405,12 @@
         int al = b.limit() - b.alignmentOffset(b.limit(), 8);
         ByteBuffer ab = b.position(ap).limit(al).
                 slice();
-        if (ab.limit() == 0)
+        if (ab.limit() == 0) {
             fail("Test input buffer not sufficiently sized to cover an aligned region for all values", b);
-        if (ab.alignmentOffset(0, 8) != 0)
+        }
+        if (ab.alignmentOffset(0, 8) != 0) {
             fail("Aligned test input buffer not correctly aligned at index 0", ab);
+        }
 
         for (int us : new int[]{1, 2, 4, 8}) {
             for (int p = 1; p < 16; p++) {
@@ -409,17 +421,18 @@
 
                 ck(as, 0, as.position());
                 ck(as, as.capacity(), as.limit());
-                if (b.isDirect() != as.isDirect())
+                if (b.isDirect() != as.isDirect()) {
                     fail("Lost direction", as);
-                if (b.isReadOnly() != as.isReadOnly())
+                }
+                if (b.isReadOnly() != as.isReadOnly()) {
                     fail("Lost read-only", as);
-
-                if (as.alignmentOffset(0, us) != 0)
+                }
+                if (as.alignmentOffset(0, us) != 0) {
                     fail("Buffer not correctly aligned at index 0", as);
-
-                if (as.alignmentOffset(as.limit(), us) != 0)
+                }
+                if (as.alignmentOffset(as.limit(), us) != 0) {
                     fail("Buffer not correctly aligned at limit", as);
-
+                }
                 int p_mod = ab.alignmentOffset(p, us);
                 int l_mod = ab.alignmentOffset(l, us);
                 // Round up position
@@ -428,8 +441,9 @@
                 l = l - l_mod;
 
                 int ec = l - p;
-                if (as.limit() != ec)
+                if (as.limit() != ec) {
                     fail("Buffer capacity incorrect, expected: " + ec, as);
+                }
             }
         }
     }
@@ -452,8 +466,9 @@
                 fail(x.getMessage() + " not expected");
             }
         }
-        if (!caught)
+        if (!caught) {
             fail(ex.getName() + " not thrown", b);
+        }
     }
 
     private static void tryCatch(byte [] t, Class<?> ex, Runnable thunk) {
@@ -464,8 +479,9 @@
 
         show(level, b);
 
-        if (direct != b.isDirect())
+        if (direct != b.isDirect()) {
             fail("Wrong direction", b);
+        }
 
         // Gets and puts
 
@@ -522,7 +538,6 @@
 
 
 
-
         // Compact
 
         relPut(b);
@@ -537,38 +552,13 @@
         b.limit(b.capacity() / 2);
         b.position(b.limit());
 
-        tryCatch(b, BufferUnderflowException.class, new Runnable() {
-                public void run() {
-                    b.get();
-                }});
-
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-                public void run() {
-                    b.put((byte)42);
-                }});
-
-        // The index must be non-negative and lesss than the buffer's limit.
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(b.limit());
-                }});
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(-1);
-                }});
-
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.put(b.limit(), (byte)42);
-                }});
-
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-                public void run() {
-                    b.position(0);
-                    b.mark();
-                    b.compact();
-                    b.reset();
-                }});
+        tryCatch(b, BufferUnderflowException.class, () -> b.get());
+        tryCatch(b, BufferOverflowException.class, () -> b.put((byte)42));
+        // The index must be non-negative and less than the buffer's limit.
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(b.limit()));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(-1));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.put(b.limit(), (byte)42));
+        tryCatch(b, InvalidMarkException.class, () -> b.position(0).mark().compact().reset());
 
         try {
             b.position(b.limit() + 1);
@@ -635,7 +625,6 @@
 
 
 
-        byte v;
         b.flip();
         ck(b, b.get(), 0);
         ck(b, b.get(), (byte)-1);
@@ -665,6 +654,10 @@
 
 
 
+
+
+
+
         // Comparison
         b.rewind();
         ByteBuffer b2 = ByteBuffer.allocate(b.capacity());
@@ -683,30 +676,35 @@
 
 
 
-                    )
+                    ) {
                     out.println("[" + i + "] " + x + " != " + y);
+                }
             }
             fail("Identical buffers not equal", b, b2);
         }
-        if (b.compareTo(b2) != 0)
+        if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
-
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((byte)99);
         b.rewind();
         b2.rewind();
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to shorter buffer <= 0", b, b2);
+        }
         b.limit(b.limit() - 1);
 
         b.put(2, (byte)42);
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to lesser buffer <= 0", b, b2);
+        }
 
         // Check equals and compareTo with interesting values
         for (byte x : VALUES) {
@@ -714,7 +712,7 @@
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
-            if (! xb.equals(xb)) {
+            if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
             for (byte y : VALUES) {
@@ -763,11 +761,13 @@
         ByteBuffer sb2 = sb.slice();
         checkSlice(sb, sb2);
 
-        if (!sb.equals(sb2))
+        if (!sb.equals(sb2)) {
             fail("Sliced slices do not match", sb, sb2);
-        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
+        }
+        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
             fail("Array offsets do not match: "
                  + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
+        }
 
 
 
@@ -804,98 +804,37 @@
 
         b.rewind();
         final ByteBuffer rb = b.asReadOnlyBuffer();
-        if (!b.equals(rb))
+        if (!b.equals(rb)) {
             fail("Buffer not equal to read-only view", b, rb);
+        }
         show(level + 1, rb);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    relPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    absPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutArray(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutBuffer(rb);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> relPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> absPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutArray(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutBuffer(rb));
 
         // put(ByteBuffer) should not change source position
         final ByteBuffer src = ByteBuffer.allocate(1);
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.put(src);
-                 }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.put(src));
         ck(src, src.position(), 0);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.compact();
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.compact());
 
 
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putChar((char)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putChar(0, (char)1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putShort((short)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putShort(0, (short)1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putInt(1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putInt(0, 1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putLong((long)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putLong(0, (long)1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putFloat((float)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putFloat(0, (float)1);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putDouble((double)1);
-                }});
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.putDouble(0, (double)1);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putChar((char)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putChar(0, (char)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putShort((short)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putShort(0, (short)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putInt(1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putInt(0, 1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putLong((long)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putLong(0, (long)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putFloat((float)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putFloat(0, (float)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putDouble((double)1));
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.putDouble(0, (double)1));
 
 
 
@@ -916,21 +855,11 @@
 
 
         if (rb.getClass().getName().startsWith("java.nio.Heap")) {
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.array();
-                    }});
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.arrayOffset();
-                    }});
-
-            if (rb.hasArray())
-                fail("Read-only heap buffer's backing array is accessible",
-                     rb);
-
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.array());
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.arrayOffset());
+            if (rb.hasArray()) {
+                fail("Read-only heap buffer's backing array is accessible", rb);
+            }
         }
 
         // Bulk puts from read-only buffers
@@ -1052,40 +981,19 @@
         ck(b, b.limit(), offset + length);
 
         // The offset must be non-negative and no larger than <array.length>.
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    ByteBuffer.wrap(ba, -1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    ByteBuffer.wrap(ba, ba.length + 1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    ByteBuffer.wrap(ba, 0, -1);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    ByteBuffer.wrap(ba, 0, ba.length + 1);
-                }});
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> ByteBuffer.wrap(ba, -1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> ByteBuffer.wrap(ba, ba.length + 1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> ByteBuffer.wrap(ba, 0, -1));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> ByteBuffer.wrap(ba, 0, ba.length + 1));
 
         // A NullPointerException will be thrown if the array is null.
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    ByteBuffer.wrap((byte []) null, 0, 5);
-                }});
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    ByteBuffer.wrap((byte []) null);
-                }});
+        tryCatch(ba, NullPointerException.class, () -> ByteBuffer.wrap((byte []) null, 0, 5));
+        tryCatch(ba, NullPointerException.class, () -> ByteBuffer.wrap((byte []) null));
     }
 
     private static void testAllocate() {
         // An IllegalArgumentException will be thrown for negative capacities.
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    ByteBuffer.allocate(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> ByteBuffer.allocate(-1));
         try {
             ByteBuffer.allocate(-1);
         } catch (IllegalArgumentException e) {
@@ -1095,10 +1003,7 @@
             }
         }
 
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    ByteBuffer.allocateDirect(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> ByteBuffer.allocateDirect(-1));
         try {
             ByteBuffer.allocateDirect(-1);
         } catch (IllegalArgumentException e) {
@@ -1117,8 +1022,9 @@
         test(new byte[1024]);
 
         ByteBuffer b = ByteBuffer.allocateDirect(7 * 1024);
-        for (b.position(0); b.position() < b.limit(); )
+        for (b.position(0); b.position() < b.limit(); ) {
             ck(b, b.get(), 0);
+        }
         test(0, b, true);
 
 
--- old/test/java/nio/Buffer/BasicChar.java	2016-05-13 12:28:56.000000000 +0100
+++ new/test/java/nio/Buffer/BasicChar.java	2016-05-13 12:28:56.000000000 +0100
@@ -31,7 +31,6 @@
 // -- This file was mechanically generated: Do not edit! -- //
 
 import java.nio.*;
-import java.lang.reflect.Method;
 
 
 public class BasicChar
@@ -60,25 +59,25 @@
 
     private static void relGet(CharBuffer b) {
         int n = b.capacity();
-        char v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((char)ic(i)));
+        }
         b.rewind();
     }
 
     private static void relGet(CharBuffer b, int start) {
         int n = b.remaining();
-        char v;
-        for (int i = start; i < n; i++)
+        for (int i = start; i < n; i++) {
             ck(b, (long)b.get(), (long)((char)ic(i)));
+        }
         b.rewind();
     }
 
     private static void absGet(CharBuffer b) {
         int n = b.capacity();
-        char v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((char)ic(i)));
+        }
         b.rewind();
     }
 
@@ -86,23 +85,26 @@
         int n = b.capacity();
         char[] a = new char[n + 7];
         b.get(a, 7, n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)a[i + 7], (long)((char)ic(i)));
+        }
     }
 
     private static void relPut(CharBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put((char)ic(i));
+        }
         b.flip();
     }
 
     private static void absPut(CharBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(i, (char)ic(i));
+        }
         b.limit(n);
         b.position(0);
     }
@@ -111,8 +113,9 @@
         int n = b.capacity();
         b.clear();
         char[] a = new char[n + 7];
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             a[i + 7] = (char)ic(i);
+        }
         b.put(a, 7, n);
         b.flip();
     }
@@ -122,8 +125,9 @@
         b.clear();
         CharBuffer c = CharBuffer.allocate(n + 7);
         c.position(7);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             c.put((char)ic(i));
+        }
         c.flip();
         c.position(7);
         b.put(c);
@@ -178,10 +182,11 @@
     private static void bulkPutString(CharBuffer b) {
         int n = b.capacity();
         b.clear();
-        StringBuffer sb = new StringBuffer(n + 7);
+        StringBuilder sb = new StringBuilder(n + 7);
         sb.append("1234567");
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             sb.append((char)ic(i));
+        }
         b.put(sb.toString(), 7, 7 + n);
         b.flip();
     }
@@ -192,10 +197,12 @@
         ck(slice, 0, slice.position());
         ck(slice, b.remaining(), slice.limit());
         ck(slice, b.remaining(), slice.capacity());
-        if (b.isDirect() != slice.isDirect())
+        if (b.isDirect() != slice.isDirect()) {
             fail("Lost direction", slice);
-        if (b.isReadOnly() != slice.isReadOnly())
+        }
+        if (b.isReadOnly() != slice.isReadOnly()) {
             fail("Lost read-only", slice);
+        }
     }
 
 
@@ -435,6 +442,13 @@
 
 
 
+
+
+
+
+
+
+
     private static void fail(String problem,
                              CharBuffer xb, CharBuffer yb,
                              char x, char y) {
@@ -452,8 +466,9 @@
                 fail(x.getMessage() + " not expected");
             }
         }
-        if (!caught)
+        if (!caught) {
             fail(ex.getName() + " not thrown", b);
+        }
     }
 
     private static void tryCatch(char [] t, Class<?> ex, Runnable thunk) {
@@ -464,8 +479,9 @@
 
         show(level, b);
 
-        if (direct != b.isDirect())
+        if (direct != b.isDirect()) {
             fail("Wrong direction", b);
+        }
 
         // Gets and puts
 
@@ -513,11 +529,10 @@
         // 7190219
         b.clear();
         int pos = b.position();
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-            public void run() {
+        tryCatch(b, BufferOverflowException.class, () ->
                 b.put(String.valueOf(new char[b.capacity() + 1]), 0,
-                        b.capacity() + 1);
-            }});
+                        b.capacity() + 1)
+            );
         ck(b, b.position(), pos);
         relGet(b);
 
@@ -537,38 +552,13 @@
         b.limit(b.capacity() / 2);
         b.position(b.limit());
 
-        tryCatch(b, BufferUnderflowException.class, new Runnable() {
-                public void run() {
-                    b.get();
-                }});
-
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-                public void run() {
-                    b.put((char)42);
-                }});
-
-        // The index must be non-negative and lesss than the buffer's limit.
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(b.limit());
-                }});
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(-1);
-                }});
-
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.put(b.limit(), (char)42);
-                }});
-
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-                public void run() {
-                    b.position(0);
-                    b.mark();
-                    b.compact();
-                    b.reset();
-                }});
+        tryCatch(b, BufferUnderflowException.class, () -> b.get());
+        tryCatch(b, BufferOverflowException.class, () -> b.put((char)42));
+        // The index must be non-negative and less than the buffer's limit.
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(b.limit()));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(-1));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.put(b.limit(), (char)42));
+        tryCatch(b, InvalidMarkException.class, () -> b.position(0).mark().compact().reset());
 
         try {
             b.position(b.limit() + 1);
@@ -635,7 +625,6 @@
 
 
 
-        char v;
         b.flip();
         ck(b, b.get(), 0);
         ck(b, b.get(), (char)-1);
@@ -665,6 +654,10 @@
 
 
 
+
+
+
+
         // Comparison
         b.rewind();
         CharBuffer b2 = CharBuffer.allocate(b.capacity());
@@ -683,30 +676,35 @@
 
 
 
-                    )
+                    ) {
                     out.println("[" + i + "] " + x + " != " + y);
+                }
             }
             fail("Identical buffers not equal", b, b2);
         }
-        if (b.compareTo(b2) != 0)
+        if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
-
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((char)99);
         b.rewind();
         b2.rewind();
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to shorter buffer <= 0", b, b2);
+        }
         b.limit(b.limit() - 1);
 
         b.put(2, (char)42);
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to lesser buffer <= 0", b, b2);
+        }
 
         // Check equals and compareTo with interesting values
         for (char x : VALUES) {
@@ -714,7 +712,7 @@
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
-            if (! xb.equals(xb)) {
+            if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
             for (char y : VALUES) {
@@ -763,11 +761,13 @@
         CharBuffer sb2 = sb.slice();
         checkSlice(sb, sb2);
 
-        if (!sb.equals(sb2))
+        if (!sb.equals(sb2)) {
             fail("Sliced slices do not match", sb, sb2);
-        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
+        }
+        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
             fail("Array offsets do not match: "
                  + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
+        }
 
 
 
@@ -804,83 +804,22 @@
 
         b.rewind();
         final CharBuffer rb = b.asReadOnlyBuffer();
-        if (!b.equals(rb))
+        if (!b.equals(rb)) {
             fail("Buffer not equal to read-only view", b, rb);
+        }
         show(level + 1, rb);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    relPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    absPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutArray(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutBuffer(rb);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> relPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> absPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutArray(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutBuffer(rb));
 
         // put(CharBuffer) should not change source position
         final CharBuffer src = CharBuffer.allocate(1);
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.put(src);
-                 }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.put(src));
         ck(src, src.position(), 0);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.compact();
-                }});
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.compact());
 
 
 
@@ -916,21 +855,11 @@
 
 
         if (rb.getClass().getName().startsWith("java.nio.Heap")) {
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.array();
-                    }});
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.arrayOffset();
-                    }});
-
-            if (rb.hasArray())
-                fail("Read-only heap buffer's backing array is accessible",
-                     rb);
-
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.array());
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.arrayOffset());
+            if (rb.hasArray()) {
+                fail("Read-only heap buffer's backing array is accessible", rb);
+            }
         }
 
         // Bulk puts from read-only buffers
@@ -1052,40 +981,19 @@
         ck(b, b.limit(), offset + length);
 
         // The offset must be non-negative and no larger than <array.length>.
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    CharBuffer.wrap(ba, -1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    CharBuffer.wrap(ba, ba.length + 1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    CharBuffer.wrap(ba, 0, -1);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    CharBuffer.wrap(ba, 0, ba.length + 1);
-                }});
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> CharBuffer.wrap(ba, -1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> CharBuffer.wrap(ba, ba.length + 1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> CharBuffer.wrap(ba, 0, -1));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> CharBuffer.wrap(ba, 0, ba.length + 1));
 
         // A NullPointerException will be thrown if the array is null.
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    CharBuffer.wrap((char []) null, 0, 5);
-                }});
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    CharBuffer.wrap((char []) null);
-                }});
+        tryCatch(ba, NullPointerException.class, () -> CharBuffer.wrap((char []) null, 0, 5));
+        tryCatch(ba, NullPointerException.class, () -> CharBuffer.wrap((char []) null));
     }
 
     private static void testAllocate() {
         // An IllegalArgumentException will be thrown for negative capacities.
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    CharBuffer.allocate(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> CharBuffer.allocate(-1));
         try {
             CharBuffer.allocate(-1);
         } catch (IllegalArgumentException e) {
@@ -1105,9 +1013,6 @@
 
 
 
-
-
-
     }
 
     public static void test() {
@@ -1122,6 +1027,7 @@
 
 
 
+
         testStr();
 
 
--- old/test/java/nio/Buffer/BasicDouble.java	2016-05-13 12:28:57.000000000 +0100
+++ new/test/java/nio/Buffer/BasicDouble.java	2016-05-13 12:28:57.000000000 +0100
@@ -31,7 +31,6 @@
 // -- This file was mechanically generated: Do not edit! -- //
 
 import java.nio.*;
-import java.lang.reflect.Method;
 
 
 public class BasicDouble
@@ -60,25 +59,25 @@
 
     private static void relGet(DoubleBuffer b) {
         int n = b.capacity();
-        double v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((double)ic(i)));
+        }
         b.rewind();
     }
 
     private static void relGet(DoubleBuffer b, int start) {
         int n = b.remaining();
-        double v;
-        for (int i = start; i < n; i++)
+        for (int i = start; i < n; i++) {
             ck(b, (long)b.get(), (long)((double)ic(i)));
+        }
         b.rewind();
     }
 
     private static void absGet(DoubleBuffer b) {
         int n = b.capacity();
-        double v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((double)ic(i)));
+        }
         b.rewind();
     }
 
@@ -86,23 +85,26 @@
         int n = b.capacity();
         double[] a = new double[n + 7];
         b.get(a, 7, n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)a[i + 7], (long)((double)ic(i)));
+        }
     }
 
     private static void relPut(DoubleBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put((double)ic(i));
+        }
         b.flip();
     }
 
     private static void absPut(DoubleBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(i, (double)ic(i));
+        }
         b.limit(n);
         b.position(0);
     }
@@ -111,8 +113,9 @@
         int n = b.capacity();
         b.clear();
         double[] a = new double[n + 7];
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             a[i + 7] = (double)ic(i);
+        }
         b.put(a, 7, n);
         b.flip();
     }
@@ -122,8 +125,9 @@
         b.clear();
         DoubleBuffer c = DoubleBuffer.allocate(n + 7);
         c.position(7);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             c.put((double)ic(i));
+        }
         c.flip();
         c.position(7);
         b.put(c);
@@ -188,14 +192,17 @@
 
 
 
+
     private static void checkSlice(DoubleBuffer b, DoubleBuffer slice) {
         ck(slice, 0, slice.position());
         ck(slice, b.remaining(), slice.limit());
         ck(slice, b.remaining(), slice.capacity());
-        if (b.isDirect() != slice.isDirect())
+        if (b.isDirect() != slice.isDirect()) {
             fail("Lost direction", slice);
-        if (b.isReadOnly() != slice.isReadOnly())
+        }
+        if (b.isReadOnly() != slice.isReadOnly()) {
             fail("Lost read-only", slice);
+        }
     }
 
 
@@ -435,6 +442,13 @@
 
 
 
+
+
+
+
+
+
+
     private static void fail(String problem,
                              DoubleBuffer xb, DoubleBuffer yb,
                              double x, double y) {
@@ -452,8 +466,9 @@
                 fail(x.getMessage() + " not expected");
             }
         }
-        if (!caught)
+        if (!caught) {
             fail(ex.getName() + " not thrown", b);
+        }
     }
 
     private static void tryCatch(double [] t, Class<?> ex, Runnable thunk) {
@@ -464,8 +479,9 @@
 
         show(level, b);
 
-        if (direct != b.isDirect())
+        if (direct != b.isDirect()) {
             fail("Wrong direction", b);
+        }
 
         // Gets and puts
 
@@ -522,7 +538,6 @@
 
 
 
-
         // Compact
 
         relPut(b);
@@ -537,38 +552,13 @@
         b.limit(b.capacity() / 2);
         b.position(b.limit());
 
-        tryCatch(b, BufferUnderflowException.class, new Runnable() {
-                public void run() {
-                    b.get();
-                }});
-
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-                public void run() {
-                    b.put((double)42);
-                }});
-
-        // The index must be non-negative and lesss than the buffer's limit.
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(b.limit());
-                }});
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(-1);
-                }});
-
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.put(b.limit(), (double)42);
-                }});
-
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-                public void run() {
-                    b.position(0);
-                    b.mark();
-                    b.compact();
-                    b.reset();
-                }});
+        tryCatch(b, BufferUnderflowException.class, () -> b.get());
+        tryCatch(b, BufferOverflowException.class, () -> b.put((double)42));
+        // The index must be non-negative and less than the buffer's limit.
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(b.limit()));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(-1));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.put(b.limit(), (double)42));
+        tryCatch(b, InvalidMarkException.class, () -> b.position(0).mark().compact().reset());
 
         try {
             b.position(b.limit() + 1);
@@ -635,7 +625,6 @@
         b.put(0.5121609353879392);      // Changes value if incorrectly swapped
 
 
-        double v;
         b.flip();
         ck(b, b.get(), 0);
         ck(b, b.get(), (double)-1);
@@ -654,13 +643,17 @@
 
 
 
+
+
+        double v;
         ck(b, b.get(), -Double.MAX_VALUE);
         ck(b, b.get(), -Double.MIN_VALUE);
         ck(b, b.get(), Double.NEGATIVE_INFINITY);
         ck(b, b.get(), Double.POSITIVE_INFINITY);
         if (Double.doubleToRawLongBits(v = b.get())
-            != Double.doubleToRawLongBits(Double.NaN))
+            != Double.doubleToRawLongBits(Double.NaN)) {
             fail(b, (long)Double.NaN, (long)v);
+        }
         ck(b, b.get(), 0.5121609353879392);
 
 
@@ -683,30 +676,35 @@
 
 
 
-                    )
+                    ) {
                     out.println("[" + i + "] " + x + " != " + y);
+                }
             }
             fail("Identical buffers not equal", b, b2);
         }
-        if (b.compareTo(b2) != 0)
+        if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
-
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((double)99);
         b.rewind();
         b2.rewind();
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to shorter buffer <= 0", b, b2);
+        }
         b.limit(b.limit() - 1);
 
         b.put(2, (double)42);
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to lesser buffer <= 0", b, b2);
+        }
 
         // Check equals and compareTo with interesting values
         for (double x : VALUES) {
@@ -714,7 +712,7 @@
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
-            if (! xb.equals(xb)) {
+            if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
             for (double y : VALUES) {
@@ -763,11 +761,13 @@
         DoubleBuffer sb2 = sb.slice();
         checkSlice(sb, sb2);
 
-        if (!sb.equals(sb2))
+        if (!sb.equals(sb2)) {
             fail("Sliced slices do not match", sb, sb2);
-        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
+        }
+        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
             fail("Array offsets do not match: "
                  + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
+        }
 
 
 
@@ -804,83 +804,22 @@
 
         b.rewind();
         final DoubleBuffer rb = b.asReadOnlyBuffer();
-        if (!b.equals(rb))
+        if (!b.equals(rb)) {
             fail("Buffer not equal to read-only view", b, rb);
+        }
         show(level + 1, rb);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    relPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    absPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutArray(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutBuffer(rb);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> relPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> absPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutArray(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutBuffer(rb));
 
         // put(DoubleBuffer) should not change source position
         final DoubleBuffer src = DoubleBuffer.allocate(1);
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.put(src);
-                 }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.put(src));
         ck(src, src.position(), 0);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.compact();
-                }});
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.compact());
 
 
 
@@ -916,21 +855,11 @@
 
 
         if (rb.getClass().getName().startsWith("java.nio.Heap")) {
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.array();
-                    }});
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.arrayOffset();
-                    }});
-
-            if (rb.hasArray())
-                fail("Read-only heap buffer's backing array is accessible",
-                     rb);
-
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.array());
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.arrayOffset());
+            if (rb.hasArray()) {
+                fail("Read-only heap buffer's backing array is accessible", rb);
+            }
         }
 
         // Bulk puts from read-only buffers
@@ -1052,40 +981,19 @@
         ck(b, b.limit(), offset + length);
 
         // The offset must be non-negative and no larger than <array.length>.
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    DoubleBuffer.wrap(ba, -1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    DoubleBuffer.wrap(ba, ba.length + 1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    DoubleBuffer.wrap(ba, 0, -1);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    DoubleBuffer.wrap(ba, 0, ba.length + 1);
-                }});
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> DoubleBuffer.wrap(ba, -1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> DoubleBuffer.wrap(ba, ba.length + 1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> DoubleBuffer.wrap(ba, 0, -1));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> DoubleBuffer.wrap(ba, 0, ba.length + 1));
 
         // A NullPointerException will be thrown if the array is null.
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    DoubleBuffer.wrap((double []) null, 0, 5);
-                }});
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    DoubleBuffer.wrap((double []) null);
-                }});
+        tryCatch(ba, NullPointerException.class, () -> DoubleBuffer.wrap((double []) null, 0, 5));
+        tryCatch(ba, NullPointerException.class, () -> DoubleBuffer.wrap((double []) null));
     }
 
     private static void testAllocate() {
         // An IllegalArgumentException will be thrown for negative capacities.
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    DoubleBuffer.allocate(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> DoubleBuffer.allocate(-1));
         try {
             DoubleBuffer.allocate(-1);
         } catch (IllegalArgumentException e) {
@@ -1105,9 +1013,6 @@
 
 
 
-
-
-
     }
 
     public static void test() {
@@ -1125,6 +1030,7 @@
 
 
 
+
         callReset(DoubleBuffer.allocate(10));
 
 
--- old/test/java/nio/Buffer/BasicFloat.java	2016-05-13 12:28:58.000000000 +0100
+++ new/test/java/nio/Buffer/BasicFloat.java	2016-05-13 12:28:58.000000000 +0100
@@ -31,7 +31,6 @@
 // -- This file was mechanically generated: Do not edit! -- //
 
 import java.nio.*;
-import java.lang.reflect.Method;
 
 
 public class BasicFloat
@@ -60,25 +59,25 @@
 
     private static void relGet(FloatBuffer b) {
         int n = b.capacity();
-        float v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((float)ic(i)));
+        }
         b.rewind();
     }
 
     private static void relGet(FloatBuffer b, int start) {
         int n = b.remaining();
-        float v;
-        for (int i = start; i < n; i++)
+        for (int i = start; i < n; i++) {
             ck(b, (long)b.get(), (long)((float)ic(i)));
+        }
         b.rewind();
     }
 
     private static void absGet(FloatBuffer b) {
         int n = b.capacity();
-        float v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((float)ic(i)));
+        }
         b.rewind();
     }
 
@@ -86,23 +85,26 @@
         int n = b.capacity();
         float[] a = new float[n + 7];
         b.get(a, 7, n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)a[i + 7], (long)((float)ic(i)));
+        }
     }
 
     private static void relPut(FloatBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put((float)ic(i));
+        }
         b.flip();
     }
 
     private static void absPut(FloatBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(i, (float)ic(i));
+        }
         b.limit(n);
         b.position(0);
     }
@@ -111,8 +113,9 @@
         int n = b.capacity();
         b.clear();
         float[] a = new float[n + 7];
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             a[i + 7] = (float)ic(i);
+        }
         b.put(a, 7, n);
         b.flip();
     }
@@ -122,8 +125,9 @@
         b.clear();
         FloatBuffer c = FloatBuffer.allocate(n + 7);
         c.position(7);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             c.put((float)ic(i));
+        }
         c.flip();
         c.position(7);
         b.put(c);
@@ -188,14 +192,17 @@
 
 
 
+
     private static void checkSlice(FloatBuffer b, FloatBuffer slice) {
         ck(slice, 0, slice.position());
         ck(slice, b.remaining(), slice.limit());
         ck(slice, b.remaining(), slice.capacity());
-        if (b.isDirect() != slice.isDirect())
+        if (b.isDirect() != slice.isDirect()) {
             fail("Lost direction", slice);
-        if (b.isReadOnly() != slice.isReadOnly())
+        }
+        if (b.isReadOnly() != slice.isReadOnly()) {
             fail("Lost read-only", slice);
+        }
     }
 
 
@@ -435,6 +442,13 @@
 
 
 
+
+
+
+
+
+
+
     private static void fail(String problem,
                              FloatBuffer xb, FloatBuffer yb,
                              float x, float y) {
@@ -452,8 +466,9 @@
                 fail(x.getMessage() + " not expected");
             }
         }
-        if (!caught)
+        if (!caught) {
             fail(ex.getName() + " not thrown", b);
+        }
     }
 
     private static void tryCatch(float [] t, Class<?> ex, Runnable thunk) {
@@ -464,8 +479,9 @@
 
         show(level, b);
 
-        if (direct != b.isDirect())
+        if (direct != b.isDirect()) {
             fail("Wrong direction", b);
+        }
 
         // Gets and puts
 
@@ -522,7 +538,6 @@
 
 
 
-
         // Compact
 
         relPut(b);
@@ -537,38 +552,13 @@
         b.limit(b.capacity() / 2);
         b.position(b.limit());
 
-        tryCatch(b, BufferUnderflowException.class, new Runnable() {
-                public void run() {
-                    b.get();
-                }});
-
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-                public void run() {
-                    b.put((float)42);
-                }});
-
-        // The index must be non-negative and lesss than the buffer's limit.
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(b.limit());
-                }});
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(-1);
-                }});
-
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.put(b.limit(), (float)42);
-                }});
-
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-                public void run() {
-                    b.position(0);
-                    b.mark();
-                    b.compact();
-                    b.reset();
-                }});
+        tryCatch(b, BufferUnderflowException.class, () -> b.get());
+        tryCatch(b, BufferOverflowException.class, () -> b.put((float)42));
+        // The index must be non-negative and less than the buffer's limit.
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(b.limit()));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(-1));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.put(b.limit(), (float)42));
+        tryCatch(b, InvalidMarkException.class, () -> b.position(0).mark().compact().reset());
 
         try {
             b.position(b.limit() + 1);
@@ -635,7 +625,6 @@
 
 
 
-        float v;
         b.flip();
         ck(b, b.get(), 0);
         ck(b, b.get(), (float)-1);
@@ -644,13 +633,15 @@
         ck(b, b.get(), Float.MIN_VALUE);
 
 
+        float v;
         ck(b, b.get(), -Float.MAX_VALUE);
         ck(b, b.get(), -Float.MIN_VALUE);
         ck(b, b.get(), Float.NEGATIVE_INFINITY);
         ck(b, b.get(), Float.POSITIVE_INFINITY);
         if (Float.floatToRawIntBits(v = b.get()) !=
-            Float.floatToRawIntBits(Float.NaN))
+            Float.floatToRawIntBits(Float.NaN)) {
             fail(b, (long)Float.NaN, (long)v);
+        }
         ck(b, b.get(), 0.91697687f);
 
 
@@ -665,6 +656,8 @@
 
 
 
+
+
         // Comparison
         b.rewind();
         FloatBuffer b2 = FloatBuffer.allocate(b.capacity());
@@ -683,30 +676,35 @@
 
                     || Float.compare(x, y) != 0
 
-                    )
+                    ) {
                     out.println("[" + i + "] " + x + " != " + y);
+                }
             }
             fail("Identical buffers not equal", b, b2);
         }
-        if (b.compareTo(b2) != 0)
+        if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
-
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((float)99);
         b.rewind();
         b2.rewind();
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to shorter buffer <= 0", b, b2);
+        }
         b.limit(b.limit() - 1);
 
         b.put(2, (float)42);
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to lesser buffer <= 0", b, b2);
+        }
 
         // Check equals and compareTo with interesting values
         for (float x : VALUES) {
@@ -714,7 +712,7 @@
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
-            if (! xb.equals(xb)) {
+            if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
             for (float y : VALUES) {
@@ -763,11 +761,13 @@
         FloatBuffer sb2 = sb.slice();
         checkSlice(sb, sb2);
 
-        if (!sb.equals(sb2))
+        if (!sb.equals(sb2)) {
             fail("Sliced slices do not match", sb, sb2);
-        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
+        }
+        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
             fail("Array offsets do not match: "
                  + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
+        }
 
 
 
@@ -804,83 +804,22 @@
 
         b.rewind();
         final FloatBuffer rb = b.asReadOnlyBuffer();
-        if (!b.equals(rb))
+        if (!b.equals(rb)) {
             fail("Buffer not equal to read-only view", b, rb);
+        }
         show(level + 1, rb);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    relPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    absPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutArray(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutBuffer(rb);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> relPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> absPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutArray(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutBuffer(rb));
 
         // put(FloatBuffer) should not change source position
         final FloatBuffer src = FloatBuffer.allocate(1);
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.put(src);
-                 }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.put(src));
         ck(src, src.position(), 0);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.compact();
-                }});
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.compact());
 
 
 
@@ -916,21 +855,11 @@
 
 
         if (rb.getClass().getName().startsWith("java.nio.Heap")) {
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.array();
-                    }});
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.arrayOffset();
-                    }});
-
-            if (rb.hasArray())
-                fail("Read-only heap buffer's backing array is accessible",
-                     rb);
-
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.array());
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.arrayOffset());
+            if (rb.hasArray()) {
+                fail("Read-only heap buffer's backing array is accessible", rb);
+            }
         }
 
         // Bulk puts from read-only buffers
@@ -1052,40 +981,19 @@
         ck(b, b.limit(), offset + length);
 
         // The offset must be non-negative and no larger than <array.length>.
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    FloatBuffer.wrap(ba, -1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    FloatBuffer.wrap(ba, ba.length + 1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    FloatBuffer.wrap(ba, 0, -1);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    FloatBuffer.wrap(ba, 0, ba.length + 1);
-                }});
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> FloatBuffer.wrap(ba, -1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> FloatBuffer.wrap(ba, ba.length + 1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> FloatBuffer.wrap(ba, 0, -1));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> FloatBuffer.wrap(ba, 0, ba.length + 1));
 
         // A NullPointerException will be thrown if the array is null.
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    FloatBuffer.wrap((float []) null, 0, 5);
-                }});
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    FloatBuffer.wrap((float []) null);
-                }});
+        tryCatch(ba, NullPointerException.class, () -> FloatBuffer.wrap((float []) null, 0, 5));
+        tryCatch(ba, NullPointerException.class, () -> FloatBuffer.wrap((float []) null));
     }
 
     private static void testAllocate() {
         // An IllegalArgumentException will be thrown for negative capacities.
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    FloatBuffer.allocate(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> FloatBuffer.allocate(-1));
         try {
             FloatBuffer.allocate(-1);
         } catch (IllegalArgumentException e) {
@@ -1105,9 +1013,6 @@
 
 
 
-
-
-
     }
 
     public static void test() {
@@ -1125,6 +1030,7 @@
 
 
 
+
         callReset(FloatBuffer.allocate(10));
 
 
--- old/test/java/nio/Buffer/BasicInt.java	2016-05-13 12:28:58.000000000 +0100
+++ new/test/java/nio/Buffer/BasicInt.java	2016-05-13 12:28:58.000000000 +0100
@@ -31,7 +31,6 @@
 // -- This file was mechanically generated: Do not edit! -- //
 
 import java.nio.*;
-import java.lang.reflect.Method;
 
 
 public class BasicInt
@@ -60,25 +59,25 @@
 
     private static void relGet(IntBuffer b) {
         int n = b.capacity();
-        int v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((int)ic(i)));
+        }
         b.rewind();
     }
 
     private static void relGet(IntBuffer b, int start) {
         int n = b.remaining();
-        int v;
-        for (int i = start; i < n; i++)
+        for (int i = start; i < n; i++) {
             ck(b, (long)b.get(), (long)((int)ic(i)));
+        }
         b.rewind();
     }
 
     private static void absGet(IntBuffer b) {
         int n = b.capacity();
-        int v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((int)ic(i)));
+        }
         b.rewind();
     }
 
@@ -86,23 +85,26 @@
         int n = b.capacity();
         int[] a = new int[n + 7];
         b.get(a, 7, n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)a[i + 7], (long)((int)ic(i)));
+        }
     }
 
     private static void relPut(IntBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put((int)ic(i));
+        }
         b.flip();
     }
 
     private static void absPut(IntBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(i, (int)ic(i));
+        }
         b.limit(n);
         b.position(0);
     }
@@ -111,8 +113,9 @@
         int n = b.capacity();
         b.clear();
         int[] a = new int[n + 7];
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             a[i + 7] = (int)ic(i);
+        }
         b.put(a, 7, n);
         b.flip();
     }
@@ -122,8 +125,9 @@
         b.clear();
         IntBuffer c = IntBuffer.allocate(n + 7);
         c.position(7);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             c.put((int)ic(i));
+        }
         c.flip();
         c.position(7);
         b.put(c);
@@ -188,14 +192,17 @@
 
 
 
+
     private static void checkSlice(IntBuffer b, IntBuffer slice) {
         ck(slice, 0, slice.position());
         ck(slice, b.remaining(), slice.limit());
         ck(slice, b.remaining(), slice.capacity());
-        if (b.isDirect() != slice.isDirect())
+        if (b.isDirect() != slice.isDirect()) {
             fail("Lost direction", slice);
-        if (b.isReadOnly() != slice.isReadOnly())
+        }
+        if (b.isReadOnly() != slice.isReadOnly()) {
             fail("Lost read-only", slice);
+        }
     }
 
 
@@ -435,6 +442,13 @@
 
 
 
+
+
+
+
+
+
+
     private static void fail(String problem,
                              IntBuffer xb, IntBuffer yb,
                              int x, int y) {
@@ -452,8 +466,9 @@
                 fail(x.getMessage() + " not expected");
             }
         }
-        if (!caught)
+        if (!caught) {
             fail(ex.getName() + " not thrown", b);
+        }
     }
 
     private static void tryCatch(int [] t, Class<?> ex, Runnable thunk) {
@@ -464,8 +479,9 @@
 
         show(level, b);
 
-        if (direct != b.isDirect())
+        if (direct != b.isDirect()) {
             fail("Wrong direction", b);
+        }
 
         // Gets and puts
 
@@ -522,7 +538,6 @@
 
 
 
-
         // Compact
 
         relPut(b);
@@ -537,38 +552,13 @@
         b.limit(b.capacity() / 2);
         b.position(b.limit());
 
-        tryCatch(b, BufferUnderflowException.class, new Runnable() {
-                public void run() {
-                    b.get();
-                }});
-
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-                public void run() {
-                    b.put((int)42);
-                }});
-
-        // The index must be non-negative and lesss than the buffer's limit.
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(b.limit());
-                }});
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(-1);
-                }});
-
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.put(b.limit(), (int)42);
-                }});
-
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-                public void run() {
-                    b.position(0);
-                    b.mark();
-                    b.compact();
-                    b.reset();
-                }});
+        tryCatch(b, BufferUnderflowException.class, () -> b.get());
+        tryCatch(b, BufferOverflowException.class, () -> b.put((int)42));
+        // The index must be non-negative and less than the buffer's limit.
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(b.limit()));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(-1));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.put(b.limit(), (int)42));
+        tryCatch(b, InvalidMarkException.class, () -> b.position(0).mark().compact().reset());
 
         try {
             b.position(b.limit() + 1);
@@ -635,7 +625,6 @@
 
 
 
-        int v;
         b.flip();
         ck(b, b.get(), 0);
         ck(b, b.get(), (int)-1);
@@ -665,6 +654,10 @@
 
 
 
+
+
+
+
         // Comparison
         b.rewind();
         IntBuffer b2 = IntBuffer.allocate(b.capacity());
@@ -683,30 +676,35 @@
 
 
 
-                    )
+                    ) {
                     out.println("[" + i + "] " + x + " != " + y);
+                }
             }
             fail("Identical buffers not equal", b, b2);
         }
-        if (b.compareTo(b2) != 0)
+        if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
-
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((int)99);
         b.rewind();
         b2.rewind();
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to shorter buffer <= 0", b, b2);
+        }
         b.limit(b.limit() - 1);
 
         b.put(2, (int)42);
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to lesser buffer <= 0", b, b2);
+        }
 
         // Check equals and compareTo with interesting values
         for (int x : VALUES) {
@@ -714,7 +712,7 @@
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
-            if (! xb.equals(xb)) {
+            if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
             for (int y : VALUES) {
@@ -763,11 +761,13 @@
         IntBuffer sb2 = sb.slice();
         checkSlice(sb, sb2);
 
-        if (!sb.equals(sb2))
+        if (!sb.equals(sb2)) {
             fail("Sliced slices do not match", sb, sb2);
-        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
+        }
+        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
             fail("Array offsets do not match: "
                  + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
+        }
 
 
 
@@ -804,83 +804,22 @@
 
         b.rewind();
         final IntBuffer rb = b.asReadOnlyBuffer();
-        if (!b.equals(rb))
+        if (!b.equals(rb)) {
             fail("Buffer not equal to read-only view", b, rb);
+        }
         show(level + 1, rb);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    relPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    absPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutArray(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutBuffer(rb);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> relPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> absPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutArray(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutBuffer(rb));
 
         // put(IntBuffer) should not change source position
         final IntBuffer src = IntBuffer.allocate(1);
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.put(src);
-                 }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.put(src));
         ck(src, src.position(), 0);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.compact();
-                }});
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.compact());
 
 
 
@@ -916,21 +855,11 @@
 
 
         if (rb.getClass().getName().startsWith("java.nio.Heap")) {
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.array();
-                    }});
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.arrayOffset();
-                    }});
-
-            if (rb.hasArray())
-                fail("Read-only heap buffer's backing array is accessible",
-                     rb);
-
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.array());
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.arrayOffset());
+            if (rb.hasArray()) {
+                fail("Read-only heap buffer's backing array is accessible", rb);
+            }
         }
 
         // Bulk puts from read-only buffers
@@ -1052,40 +981,19 @@
         ck(b, b.limit(), offset + length);
 
         // The offset must be non-negative and no larger than <array.length>.
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    IntBuffer.wrap(ba, -1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    IntBuffer.wrap(ba, ba.length + 1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    IntBuffer.wrap(ba, 0, -1);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    IntBuffer.wrap(ba, 0, ba.length + 1);
-                }});
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> IntBuffer.wrap(ba, -1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> IntBuffer.wrap(ba, ba.length + 1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> IntBuffer.wrap(ba, 0, -1));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> IntBuffer.wrap(ba, 0, ba.length + 1));
 
         // A NullPointerException will be thrown if the array is null.
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    IntBuffer.wrap((int []) null, 0, 5);
-                }});
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    IntBuffer.wrap((int []) null);
-                }});
+        tryCatch(ba, NullPointerException.class, () -> IntBuffer.wrap((int []) null, 0, 5));
+        tryCatch(ba, NullPointerException.class, () -> IntBuffer.wrap((int []) null));
     }
 
     private static void testAllocate() {
         // An IllegalArgumentException will be thrown for negative capacities.
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    IntBuffer.allocate(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> IntBuffer.allocate(-1));
         try {
             IntBuffer.allocate(-1);
         } catch (IllegalArgumentException e) {
@@ -1105,9 +1013,6 @@
 
 
 
-
-
-
     }
 
     public static void test() {
@@ -1125,6 +1030,7 @@
 
 
 
+
         callReset(IntBuffer.allocate(10));
 
 
--- old/test/java/nio/Buffer/BasicLong.java	2016-05-13 12:28:59.000000000 +0100
+++ new/test/java/nio/Buffer/BasicLong.java	2016-05-13 12:28:59.000000000 +0100
@@ -31,7 +31,6 @@
 // -- This file was mechanically generated: Do not edit! -- //
 
 import java.nio.*;
-import java.lang.reflect.Method;
 
 
 public class BasicLong
@@ -60,25 +59,25 @@
 
     private static void relGet(LongBuffer b) {
         int n = b.capacity();
-        long v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((long)ic(i)));
+        }
         b.rewind();
     }
 
     private static void relGet(LongBuffer b, int start) {
         int n = b.remaining();
-        long v;
-        for (int i = start; i < n; i++)
+        for (int i = start; i < n; i++) {
             ck(b, (long)b.get(), (long)((long)ic(i)));
+        }
         b.rewind();
     }
 
     private static void absGet(LongBuffer b) {
         int n = b.capacity();
-        long v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((long)ic(i)));
+        }
         b.rewind();
     }
 
@@ -86,23 +85,26 @@
         int n = b.capacity();
         long[] a = new long[n + 7];
         b.get(a, 7, n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)a[i + 7], (long)((long)ic(i)));
+        }
     }
 
     private static void relPut(LongBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put((long)ic(i));
+        }
         b.flip();
     }
 
     private static void absPut(LongBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(i, (long)ic(i));
+        }
         b.limit(n);
         b.position(0);
     }
@@ -111,8 +113,9 @@
         int n = b.capacity();
         b.clear();
         long[] a = new long[n + 7];
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             a[i + 7] = (long)ic(i);
+        }
         b.put(a, 7, n);
         b.flip();
     }
@@ -122,8 +125,9 @@
         b.clear();
         LongBuffer c = LongBuffer.allocate(n + 7);
         c.position(7);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             c.put((long)ic(i));
+        }
         c.flip();
         c.position(7);
         b.put(c);
@@ -188,14 +192,17 @@
 
 
 
+
     private static void checkSlice(LongBuffer b, LongBuffer slice) {
         ck(slice, 0, slice.position());
         ck(slice, b.remaining(), slice.limit());
         ck(slice, b.remaining(), slice.capacity());
-        if (b.isDirect() != slice.isDirect())
+        if (b.isDirect() != slice.isDirect()) {
             fail("Lost direction", slice);
-        if (b.isReadOnly() != slice.isReadOnly())
+        }
+        if (b.isReadOnly() != slice.isReadOnly()) {
             fail("Lost read-only", slice);
+        }
     }
 
 
@@ -435,6 +442,13 @@
 
 
 
+
+
+
+
+
+
+
     private static void fail(String problem,
                              LongBuffer xb, LongBuffer yb,
                              long x, long y) {
@@ -452,8 +466,9 @@
                 fail(x.getMessage() + " not expected");
             }
         }
-        if (!caught)
+        if (!caught) {
             fail(ex.getName() + " not thrown", b);
+        }
     }
 
     private static void tryCatch(long [] t, Class<?> ex, Runnable thunk) {
@@ -464,8 +479,9 @@
 
         show(level, b);
 
-        if (direct != b.isDirect())
+        if (direct != b.isDirect()) {
             fail("Wrong direction", b);
+        }
 
         // Gets and puts
 
@@ -522,7 +538,6 @@
 
 
 
-
         // Compact
 
         relPut(b);
@@ -537,38 +552,13 @@
         b.limit(b.capacity() / 2);
         b.position(b.limit());
 
-        tryCatch(b, BufferUnderflowException.class, new Runnable() {
-                public void run() {
-                    b.get();
-                }});
-
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-                public void run() {
-                    b.put((long)42);
-                }});
-
-        // The index must be non-negative and lesss than the buffer's limit.
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(b.limit());
-                }});
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(-1);
-                }});
-
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.put(b.limit(), (long)42);
-                }});
-
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-                public void run() {
-                    b.position(0);
-                    b.mark();
-                    b.compact();
-                    b.reset();
-                }});
+        tryCatch(b, BufferUnderflowException.class, () -> b.get());
+        tryCatch(b, BufferOverflowException.class, () -> b.put((long)42));
+        // The index must be non-negative and less than the buffer's limit.
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(b.limit()));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(-1));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.put(b.limit(), (long)42));
+        tryCatch(b, InvalidMarkException.class, () -> b.position(0).mark().compact().reset());
 
         try {
             b.position(b.limit() + 1);
@@ -635,7 +625,6 @@
 
 
 
-        long v;
         b.flip();
         ck(b, b.get(), 0);
         ck(b, b.get(), (long)-1);
@@ -665,6 +654,10 @@
 
 
 
+
+
+
+
         // Comparison
         b.rewind();
         LongBuffer b2 = LongBuffer.allocate(b.capacity());
@@ -683,30 +676,35 @@
 
 
 
-                    )
+                    ) {
                     out.println("[" + i + "] " + x + " != " + y);
+                }
             }
             fail("Identical buffers not equal", b, b2);
         }
-        if (b.compareTo(b2) != 0)
+        if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
-
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((long)99);
         b.rewind();
         b2.rewind();
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to shorter buffer <= 0", b, b2);
+        }
         b.limit(b.limit() - 1);
 
         b.put(2, (long)42);
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to lesser buffer <= 0", b, b2);
+        }
 
         // Check equals and compareTo with interesting values
         for (long x : VALUES) {
@@ -714,7 +712,7 @@
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
-            if (! xb.equals(xb)) {
+            if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
             for (long y : VALUES) {
@@ -763,11 +761,13 @@
         LongBuffer sb2 = sb.slice();
         checkSlice(sb, sb2);
 
-        if (!sb.equals(sb2))
+        if (!sb.equals(sb2)) {
             fail("Sliced slices do not match", sb, sb2);
-        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
+        }
+        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
             fail("Array offsets do not match: "
                  + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
+        }
 
 
 
@@ -804,83 +804,22 @@
 
         b.rewind();
         final LongBuffer rb = b.asReadOnlyBuffer();
-        if (!b.equals(rb))
+        if (!b.equals(rb)) {
             fail("Buffer not equal to read-only view", b, rb);
+        }
         show(level + 1, rb);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    relPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    absPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutArray(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutBuffer(rb);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> relPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> absPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutArray(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutBuffer(rb));
 
         // put(LongBuffer) should not change source position
         final LongBuffer src = LongBuffer.allocate(1);
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.put(src);
-                 }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.put(src));
         ck(src, src.position(), 0);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.compact();
-                }});
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.compact());
 
 
 
@@ -916,21 +855,11 @@
 
 
         if (rb.getClass().getName().startsWith("java.nio.Heap")) {
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.array();
-                    }});
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.arrayOffset();
-                    }});
-
-            if (rb.hasArray())
-                fail("Read-only heap buffer's backing array is accessible",
-                     rb);
-
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.array());
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.arrayOffset());
+            if (rb.hasArray()) {
+                fail("Read-only heap buffer's backing array is accessible", rb);
+            }
         }
 
         // Bulk puts from read-only buffers
@@ -1052,40 +981,19 @@
         ck(b, b.limit(), offset + length);
 
         // The offset must be non-negative and no larger than <array.length>.
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    LongBuffer.wrap(ba, -1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    LongBuffer.wrap(ba, ba.length + 1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    LongBuffer.wrap(ba, 0, -1);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    LongBuffer.wrap(ba, 0, ba.length + 1);
-                }});
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> LongBuffer.wrap(ba, -1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> LongBuffer.wrap(ba, ba.length + 1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> LongBuffer.wrap(ba, 0, -1));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> LongBuffer.wrap(ba, 0, ba.length + 1));
 
         // A NullPointerException will be thrown if the array is null.
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    LongBuffer.wrap((long []) null, 0, 5);
-                }});
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    LongBuffer.wrap((long []) null);
-                }});
+        tryCatch(ba, NullPointerException.class, () -> LongBuffer.wrap((long []) null, 0, 5));
+        tryCatch(ba, NullPointerException.class, () -> LongBuffer.wrap((long []) null));
     }
 
     private static void testAllocate() {
         // An IllegalArgumentException will be thrown for negative capacities.
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    LongBuffer.allocate(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> LongBuffer.allocate(-1));
         try {
             LongBuffer.allocate(-1);
         } catch (IllegalArgumentException e) {
@@ -1105,9 +1013,6 @@
 
 
 
-
-
-
     }
 
     public static void test() {
@@ -1125,6 +1030,7 @@
 
 
 
+
         callReset(LongBuffer.allocate(10));
 
 
--- old/test/java/nio/Buffer/BasicShort.java	2016-05-13 12:29:00.000000000 +0100
+++ new/test/java/nio/Buffer/BasicShort.java	2016-05-13 12:29:00.000000000 +0100
@@ -31,7 +31,6 @@
 // -- This file was mechanically generated: Do not edit! -- //
 
 import java.nio.*;
-import java.lang.reflect.Method;
 
 
 public class BasicShort
@@ -60,25 +59,25 @@
 
     private static void relGet(ShortBuffer b) {
         int n = b.capacity();
-        short v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((short)ic(i)));
+        }
         b.rewind();
     }
 
     private static void relGet(ShortBuffer b, int start) {
         int n = b.remaining();
-        short v;
-        for (int i = start; i < n; i++)
+        for (int i = start; i < n; i++) {
             ck(b, (long)b.get(), (long)((short)ic(i)));
+        }
         b.rewind();
     }
 
     private static void absGet(ShortBuffer b) {
         int n = b.capacity();
-        short v;
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)b.get(), (long)((short)ic(i)));
+        }
         b.rewind();
     }
 
@@ -86,23 +85,26 @@
         int n = b.capacity();
         short[] a = new short[n + 7];
         b.get(a, 7, n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             ck(b, (long)a[i + 7], (long)((short)ic(i)));
+        }
     }
 
     private static void relPut(ShortBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put((short)ic(i));
+        }
         b.flip();
     }
 
     private static void absPut(ShortBuffer b) {
         int n = b.capacity();
         b.clear();
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             b.put(i, (short)ic(i));
+        }
         b.limit(n);
         b.position(0);
     }
@@ -111,8 +113,9 @@
         int n = b.capacity();
         b.clear();
         short[] a = new short[n + 7];
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             a[i + 7] = (short)ic(i);
+        }
         b.put(a, 7, n);
         b.flip();
     }
@@ -122,8 +125,9 @@
         b.clear();
         ShortBuffer c = ShortBuffer.allocate(n + 7);
         c.position(7);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             c.put((short)ic(i));
+        }
         c.flip();
         c.position(7);
         b.put(c);
@@ -188,14 +192,17 @@
 
 
 
+
     private static void checkSlice(ShortBuffer b, ShortBuffer slice) {
         ck(slice, 0, slice.position());
         ck(slice, b.remaining(), slice.limit());
         ck(slice, b.remaining(), slice.capacity());
-        if (b.isDirect() != slice.isDirect())
+        if (b.isDirect() != slice.isDirect()) {
             fail("Lost direction", slice);
-        if (b.isReadOnly() != slice.isReadOnly())
+        }
+        if (b.isReadOnly() != slice.isReadOnly()) {
             fail("Lost read-only", slice);
+        }
     }
 
 
@@ -435,6 +442,13 @@
 
 
 
+
+
+
+
+
+
+
     private static void fail(String problem,
                              ShortBuffer xb, ShortBuffer yb,
                              short x, short y) {
@@ -452,8 +466,9 @@
                 fail(x.getMessage() + " not expected");
             }
         }
-        if (!caught)
+        if (!caught) {
             fail(ex.getName() + " not thrown", b);
+        }
     }
 
     private static void tryCatch(short [] t, Class<?> ex, Runnable thunk) {
@@ -464,8 +479,9 @@
 
         show(level, b);
 
-        if (direct != b.isDirect())
+        if (direct != b.isDirect()) {
             fail("Wrong direction", b);
+        }
 
         // Gets and puts
 
@@ -522,7 +538,6 @@
 
 
 
-
         // Compact
 
         relPut(b);
@@ -537,38 +552,13 @@
         b.limit(b.capacity() / 2);
         b.position(b.limit());
 
-        tryCatch(b, BufferUnderflowException.class, new Runnable() {
-                public void run() {
-                    b.get();
-                }});
-
-        tryCatch(b, BufferOverflowException.class, new Runnable() {
-                public void run() {
-                    b.put((short)42);
-                }});
-
-        // The index must be non-negative and lesss than the buffer's limit.
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(b.limit());
-                }});
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.get(-1);
-                }});
-
-        tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    b.put(b.limit(), (short)42);
-                }});
-
-        tryCatch(b, InvalidMarkException.class, new Runnable() {
-                public void run() {
-                    b.position(0);
-                    b.mark();
-                    b.compact();
-                    b.reset();
-                }});
+        tryCatch(b, BufferUnderflowException.class, () -> b.get());
+        tryCatch(b, BufferOverflowException.class, () -> b.put((short)42));
+        // The index must be non-negative and less than the buffer's limit.
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(b.limit()));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.get(-1));
+        tryCatch(b, IndexOutOfBoundsException.class, () -> b.put(b.limit(), (short)42));
+        tryCatch(b, InvalidMarkException.class, () -> b.position(0).mark().compact().reset());
 
         try {
             b.position(b.limit() + 1);
@@ -635,7 +625,6 @@
 
 
 
-        short v;
         b.flip();
         ck(b, b.get(), 0);
         ck(b, b.get(), (short)-1);
@@ -665,6 +654,10 @@
 
 
 
+
+
+
+
         // Comparison
         b.rewind();
         ShortBuffer b2 = ShortBuffer.allocate(b.capacity());
@@ -683,30 +676,35 @@
 
 
 
-                    )
+                    ) {
                     out.println("[" + i + "] " + x + " != " + y);
+                }
             }
             fail("Identical buffers not equal", b, b2);
         }
-        if (b.compareTo(b2) != 0)
+        if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
-
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((short)99);
         b.rewind();
         b2.rewind();
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to shorter buffer <= 0", b, b2);
+        }
         b.limit(b.limit() - 1);
 
         b.put(2, (short)42);
-        if (b.equals(b2))
+        if (b.equals(b2)) {
             fail("Non-identical buffers equal", b, b2);
-        if (b.compareTo(b2) <= 0)
+        }
+        if (b.compareTo(b2) <= 0) {
             fail("Comparison to lesser buffer <= 0", b, b2);
+        }
 
         // Check equals and compareTo with interesting values
         for (short x : VALUES) {
@@ -714,7 +712,7 @@
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
-            if (! xb.equals(xb)) {
+            if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
             for (short y : VALUES) {
@@ -763,11 +761,13 @@
         ShortBuffer sb2 = sb.slice();
         checkSlice(sb, sb2);
 
-        if (!sb.equals(sb2))
+        if (!sb.equals(sb2)) {
             fail("Sliced slices do not match", sb, sb2);
-        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
+        }
+        if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
             fail("Array offsets do not match: "
                  + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
+        }
 
 
 
@@ -804,83 +804,22 @@
 
         b.rewind();
         final ShortBuffer rb = b.asReadOnlyBuffer();
-        if (!b.equals(rb))
+        if (!b.equals(rb)) {
             fail("Buffer not equal to read-only view", b, rb);
+        }
         show(level + 1, rb);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    relPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    absPut(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutArray(rb);
-                }});
-
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    bulkPutBuffer(rb);
-                }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> relPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> absPut(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutArray(rb));
+        tryCatch(b, ReadOnlyBufferException.class, () -> bulkPutBuffer(rb));
 
         // put(ShortBuffer) should not change source position
         final ShortBuffer src = ShortBuffer.allocate(1);
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.put(src);
-                 }});
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.put(src));
         ck(src, src.position(), 0);
 
-        tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                public void run() {
-                    rb.compact();
-                }});
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+        tryCatch(b, ReadOnlyBufferException.class, () -> rb.compact());
 
 
 
@@ -916,21 +855,11 @@
 
 
         if (rb.getClass().getName().startsWith("java.nio.Heap")) {
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.array();
-                    }});
-
-            tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
-                    public void run() {
-                        rb.arrayOffset();
-                    }});
-
-            if (rb.hasArray())
-                fail("Read-only heap buffer's backing array is accessible",
-                     rb);
-
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.array());
+            tryCatch(b, ReadOnlyBufferException.class, () -> rb.arrayOffset());
+            if (rb.hasArray()) {
+                fail("Read-only heap buffer's backing array is accessible", rb);
+            }
         }
 
         // Bulk puts from read-only buffers
@@ -1052,40 +981,19 @@
         ck(b, b.limit(), offset + length);
 
         // The offset must be non-negative and no larger than <array.length>.
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    ShortBuffer.wrap(ba, -1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    ShortBuffer.wrap(ba, ba.length + 1, ba.length);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    ShortBuffer.wrap(ba, 0, -1);
-                }});
-        tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
-                public void run() {
-                    ShortBuffer.wrap(ba, 0, ba.length + 1);
-                }});
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> ShortBuffer.wrap(ba, -1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> ShortBuffer.wrap(ba, ba.length + 1, ba.length));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> ShortBuffer.wrap(ba, 0, -1));
+        tryCatch(ba, IndexOutOfBoundsException.class, () -> ShortBuffer.wrap(ba, 0, ba.length + 1));
 
         // A NullPointerException will be thrown if the array is null.
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    ShortBuffer.wrap((short []) null, 0, 5);
-                }});
-        tryCatch(ba, NullPointerException.class, new Runnable() {
-                public void run() {
-                    ShortBuffer.wrap((short []) null);
-                }});
+        tryCatch(ba, NullPointerException.class, () -> ShortBuffer.wrap((short []) null, 0, 5));
+        tryCatch(ba, NullPointerException.class, () -> ShortBuffer.wrap((short []) null));
     }
 
     private static void testAllocate() {
         // An IllegalArgumentException will be thrown for negative capacities.
-        tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
-                public void run() {
-                    ShortBuffer.allocate(-1);
-                }});
+        tryCatch((Buffer) null, IllegalArgumentException.class, () -> ShortBuffer.allocate(-1));
         try {
             ShortBuffer.allocate(-1);
         } catch (IllegalArgumentException e) {
@@ -1105,9 +1013,6 @@
 
 
 
-
-
-
     }
 
     public static void test() {
@@ -1125,6 +1030,7 @@
 
 
 
+
         callReset(ShortBuffer.allocate(10));