# HG changeset patch
# User Robert Stupp <snazy@snazy.de>
# Date 1524399060 -7200
#      Sun Apr 22 14:11:00 2018 +0200
# Branch buffer-compUns-mismatch
# Node ID 06f0013900eba02b3136aa3bd72b3f981e3339df
# Parent  fcd5df7aa235ca39852b04eb589e25f156870ce4
Add unsigned comparison to *Buffer

diff --git a/src/java.base/share/classes/java/nio/X-Buffer.java.template b/src/java.base/share/classes/java/nio/X-Buffer.java.template
--- a/src/java.base/share/classes/java/nio/X-Buffer.java.template
+++ b/src/java.base/share/classes/java/nio/X-Buffer.java.template
@@ -1342,6 +1342,35 @@
         return this.remaining() - that.remaining();
     }
 
+#if[!char]
+#if[integralType]
+    /**
+     * Compares this buffer to another treating the values as unsigned.
+     *
+     * <p> Two $type$ buffers are compared by comparing their sequences of
+     * remaining elements lexicographically, without regard to the starting
+     * position of each sequence within its corresponding buffer.
+     * Pairs of {@code $type$} elements are compared as if by invoking
+     * {@link $Fulltype$#compareUnsigned($type$,$type$)}.
+     *
+     * <p> A $type$ buffer is not comparable to any other type of object.
+     *
+     * @param   that the $type$ buffer to be compared.
+     * @return  A negative integer, zero, or a positive integer as this buffer
+     *          is less than, equal to, or greater than the given buffer
+     */
+    public int compareToUnsigned($Type$Buffer that) {
+        int i = BufferMismatch.mismatch(this, this.position(),
+                                        that, that.position(),
+                                        Math.min(this.remaining(), that.remaining()));
+        if (i >= 0) {
+            return compareUnsigned(this.get(this.position() + i), that.get(that.position() + i));
+        }
+        return this.remaining() - that.remaining();
+    }
+#end[integralType]
+#end[!char]
+
     private static int compare($type$ x, $type$ y) {
 #if[floatingPointType]
         return ((x < y)  ? -1 :
@@ -1353,6 +1382,34 @@
 #end[floatingPointType]
     }
 
+#if[!char]
+#if[integralType]
+    private static int compareUnsigned($type$ x, $type$ y) {
+        return $Fulltype$.compareUnsigned(x, y);
+    }
+#end[integralType]
+#end[!char]
+
+    /**
+     * Find the relative index of a mismatch between this buffer and another
+     * starting the current positions.
+     *
+     * <p> A $type$ buffer is not comparable to any other type of object.
+     *
+     * @param  that the $type$ buffer to be compared.
+     * @return the relative index of a mismatch between the two buffers,
+     *         otherwise -1 if no mismatch.  The index will be within the range of
+     *         (inclusive) {@link #position()} to (exclusive) the smaller of
+     *         {@link #remaining() this.position()+this.remaining()} and
+     *         {@link #remaining() this.position()+that.remaining()}.
+     */
+    public int mismatch($Type$Buffer that) {
+        int r = BufferMismatch.mismatch(this, this.position(),
+                                        that, that.position(),
+                                        Math.min(this.remaining(), that.remaining()));
+        return r == -1 ? -1 : r + this.position();
+    }
+
     // -- Other char stuff --
 
 #if[char]
diff --git a/test/jdk/java/nio/Buffer/Basic-X.java.template b/test/jdk/java/nio/Buffer/Basic-X.java.template
--- a/test/jdk/java/nio/Buffer/Basic-X.java.template
+++ b/test/jdk/java/nio/Buffer/Basic-X.java.template
@@ -697,6 +697,17 @@
         if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
         }
+#if[compareToUnsigned]
+        if (b.compareToUnsigned(b2) != 0) {
+            fail("Unsighed comparison to identical buffer != 0", b, b2);
+        }
+#end[compareToUnsigned]
+        if (b.mismatch(b2) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
+        if (b2.mismatch(b) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put(($type$)99);
@@ -706,6 +717,11 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to shorter buffer <= 0", b, b2);
+#if[compareToUnsigned]
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser shorter buffer <= 0", b, b2);
+        }
+#end[compareToUnsigned]
         b.limit(b.limit() - 1);
 
         b.put(2, ($type$)42);
@@ -713,16 +729,29 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to lesser buffer <= 0", b, b2);
+#if[compareToUnsigned]
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser value <= 0", b, b2);
+        }
+#end[compareToUnsigned]
 
-        // Check equals and compareTo with interesting values
+        // Check equals, compareTo, compareToUnsigned, mismatch with interesting values
         for ($type$ x : VALUES) {
             $Type$Buffer xb = $Type$Buffer.wrap(new $type$[] { x });
             if (xb.compareTo(xb) != 0) {
                 fail("compareTo not reflexive", xb, xb, x, x);
             }
+#if[compareToUnsigned]
+            if (xb.compareToUnsigned(xb) != 0) {
+                fail("compareToUnsigned not reflexive", xb, xb, x, x);
+            }
+#end[compareToUnsigned]
             if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
+            if (xb.mismatch(xb) != -1) {
+                fail("mismatch not reflexive", xb, xb, x, x);
+            }
             for ($type$ y : VALUES) {
                 $Type$Buffer yb = $Type$Buffer.wrap(new $type$[] { y });
                 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
@@ -743,10 +772,34 @@
                     fail("Incorrect results for $Type$Buffer.compareTo",
                          xb, yb, x, y);
                 }
+#if[compareToUnsigned]
+                if (xb.compareToUnsigned(yb) != - yb.compareToUnsigned(xb)) {
+                    fail("compareToUnsigned not anti-symmetric",
+                         xb, yb, x, y);
+                }
+                if ((xb.compareToUnsigned(yb) == 0) != xb.equals(yb)) {
+                    fail("compareToUnsigned inconsistent with equals",
+                         xb, yb, x, y);
+                }
+                if (xb.compareToUnsigned(yb) != $Fulltype$.compareUnsigned(x, y)) {
+#if[float]
+                    if (x == 0.0 && y == 0.0) continue;
+#end[float]
+#if[double]
+                    if (x == 0.0 && y == 0.0) continue;
+#end[double]
+                    fail("Incorrect results for $Type$Buffer.compareToUnsigned",
+                         xb, yb, x, y);
+                }
+#end[compareToUnsigned]
                 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
                     fail("Incorrect results for $Type$Buffer.equals",
                          xb, yb, x, y);
                 }
+                if (xb.mismatch(yb) == -1 != ((x == y) || ((x != x) && (y != y)))) {
+                    fail("Incorrect results for $Type$Buffer.mismatch",
+                         xb, yb, x, y);
+                }
             }
         }
 
diff --git a/test/jdk/java/nio/Buffer/BasicByte.java b/test/jdk/java/nio/Buffer/BasicByte.java
--- a/test/jdk/java/nio/Buffer/BasicByte.java
+++ b/test/jdk/java/nio/Buffer/BasicByte.java
@@ -697,6 +697,17 @@
         if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
         }
+
+        if (b.compareToUnsigned(b2) != 0) {
+            fail("Unsighed comparison to identical buffer != 0", b, b2);
+        }
+
+        if (b.mismatch(b2) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
+        if (b2.mismatch(b) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((byte)99);
@@ -706,6 +717,11 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to shorter buffer <= 0", b, b2);
+
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser shorter buffer <= 0", b, b2);
+        }
+
         b.limit(b.limit() - 1);
 
         b.put(2, (byte)42);
@@ -714,7 +730,12 @@
         if (b.compareTo(b2) <= 0)
             fail("Comparison to lesser buffer <= 0", b, b2);
 
-        // Check equals and compareTo with interesting values
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser value <= 0", b, b2);
+        }
+
+
+        // Check equals, compareTo, compareToUnsigned, mismatch with interesting values
         for (byte x : VALUES) {
             ByteBuffer xb = ByteBuffer.wrap(new byte[] { x });
             if (xb.compareTo(xb) != 0) {
@@ -723,6 +744,9 @@
             if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
+            if (xb.mismatch(xb) != -1) {
+                fail("mismatch not reflexive", xb, xb, x, x);
+            }
             for (byte y : VALUES) {
                 ByteBuffer yb = ByteBuffer.wrap(new byte[] { y });
                 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
@@ -743,10 +767,34 @@
                     fail("Incorrect results for ByteBuffer.compareTo",
                          xb, yb, x, y);
                 }
+
+                if (xb.compareToUnsigned(yb) != - yb.compareToUnsigned(xb)) {
+                    fail("compareToUnsigned not anti-symmetric",
+                         xb, yb, x, y);
+                }
+                if ((xb.compareToUnsigned(yb) == 0) != xb.equals(yb)) {
+                    fail("compareToUnsigned inconsistent with equals",
+                         xb, yb, x, y);
+                }
+                if (xb.compareToUnsigned(yb) != Byte.compareUnsigned(x, y)) {
+
+
+
+
+
+
+                    fail("Incorrect results for ByteBuffer.compareToUnsigned",
+                         xb, yb, x, y);
+                }
+
                 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
                     fail("Incorrect results for ByteBuffer.equals",
                          xb, yb, x, y);
                 }
+                if (xb.mismatch(yb) == -1 != ((x == y) || ((x != x) && (y != y)))) {
+                    fail("Incorrect results for ByteBuffer.mismatch",
+                         xb, yb, x, y);
+                }
             }
         }
 
diff --git a/test/jdk/java/nio/Buffer/BasicChar.java b/test/jdk/java/nio/Buffer/BasicChar.java
--- a/test/jdk/java/nio/Buffer/BasicChar.java
+++ b/test/jdk/java/nio/Buffer/BasicChar.java
@@ -697,6 +697,17 @@
         if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
         }
+
+
+
+
+
+        if (b.mismatch(b2) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
+        if (b2.mismatch(b) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((char)99);
@@ -706,6 +717,11 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to shorter buffer <= 0", b, b2);
+
+
+
+
+
         b.limit(b.limit() - 1);
 
         b.put(2, (char)42);
@@ -714,7 +730,12 @@
         if (b.compareTo(b2) <= 0)
             fail("Comparison to lesser buffer <= 0", b, b2);
 
-        // Check equals and compareTo with interesting values
+
+
+
+
+
+        // Check equals, compareTo, compareToUnsigned, mismatch with interesting values
         for (char x : VALUES) {
             CharBuffer xb = CharBuffer.wrap(new char[] { x });
             if (xb.compareTo(xb) != 0) {
@@ -723,6 +744,9 @@
             if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
+            if (xb.mismatch(xb) != -1) {
+                fail("mismatch not reflexive", xb, xb, x, x);
+            }
             for (char y : VALUES) {
                 CharBuffer yb = CharBuffer.wrap(new char[] { y });
                 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
@@ -743,10 +767,34 @@
                     fail("Incorrect results for CharBuffer.compareTo",
                          xb, yb, x, y);
                 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
                 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
                     fail("Incorrect results for CharBuffer.equals",
                          xb, yb, x, y);
                 }
+                if (xb.mismatch(yb) == -1 != ((x == y) || ((x != x) && (y != y)))) {
+                    fail("Incorrect results for CharBuffer.mismatch",
+                         xb, yb, x, y);
+                }
             }
         }
 
diff --git a/test/jdk/java/nio/Buffer/BasicDouble.java b/test/jdk/java/nio/Buffer/BasicDouble.java
--- a/test/jdk/java/nio/Buffer/BasicDouble.java
+++ b/test/jdk/java/nio/Buffer/BasicDouble.java
@@ -697,6 +697,17 @@
         if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
         }
+
+
+
+
+
+        if (b.mismatch(b2) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
+        if (b2.mismatch(b) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((double)99);
@@ -706,6 +717,11 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to shorter buffer <= 0", b, b2);
+
+
+
+
+
         b.limit(b.limit() - 1);
 
         b.put(2, (double)42);
@@ -714,7 +730,12 @@
         if (b.compareTo(b2) <= 0)
             fail("Comparison to lesser buffer <= 0", b, b2);
 
-        // Check equals and compareTo with interesting values
+
+
+
+
+
+        // Check equals, compareTo, compareToUnsigned, mismatch with interesting values
         for (double x : VALUES) {
             DoubleBuffer xb = DoubleBuffer.wrap(new double[] { x });
             if (xb.compareTo(xb) != 0) {
@@ -723,6 +744,9 @@
             if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
+            if (xb.mismatch(xb) != -1) {
+                fail("mismatch not reflexive", xb, xb, x, x);
+            }
             for (double y : VALUES) {
                 DoubleBuffer yb = DoubleBuffer.wrap(new double[] { y });
                 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
@@ -743,10 +767,34 @@
                     fail("Incorrect results for DoubleBuffer.compareTo",
                          xb, yb, x, y);
                 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
                 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
                     fail("Incorrect results for DoubleBuffer.equals",
                          xb, yb, x, y);
                 }
+                if (xb.mismatch(yb) == -1 != ((x == y) || ((x != x) && (y != y)))) {
+                    fail("Incorrect results for DoubleBuffer.mismatch",
+                         xb, yb, x, y);
+                }
             }
         }
 
diff --git a/test/jdk/java/nio/Buffer/BasicFloat.java b/test/jdk/java/nio/Buffer/BasicFloat.java
--- a/test/jdk/java/nio/Buffer/BasicFloat.java
+++ b/test/jdk/java/nio/Buffer/BasicFloat.java
@@ -697,6 +697,17 @@
         if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
         }
+
+
+
+
+
+        if (b.mismatch(b2) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
+        if (b2.mismatch(b) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((float)99);
@@ -706,6 +717,11 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to shorter buffer <= 0", b, b2);
+
+
+
+
+
         b.limit(b.limit() - 1);
 
         b.put(2, (float)42);
@@ -714,7 +730,12 @@
         if (b.compareTo(b2) <= 0)
             fail("Comparison to lesser buffer <= 0", b, b2);
 
-        // Check equals and compareTo with interesting values
+
+
+
+
+
+        // Check equals, compareTo, compareToUnsigned, mismatch with interesting values
         for (float x : VALUES) {
             FloatBuffer xb = FloatBuffer.wrap(new float[] { x });
             if (xb.compareTo(xb) != 0) {
@@ -723,6 +744,9 @@
             if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
+            if (xb.mismatch(xb) != -1) {
+                fail("mismatch not reflexive", xb, xb, x, x);
+            }
             for (float y : VALUES) {
                 FloatBuffer yb = FloatBuffer.wrap(new float[] { y });
                 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
@@ -743,10 +767,34 @@
                     fail("Incorrect results for FloatBuffer.compareTo",
                          xb, yb, x, y);
                 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
                 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
                     fail("Incorrect results for FloatBuffer.equals",
                          xb, yb, x, y);
                 }
+                if (xb.mismatch(yb) == -1 != ((x == y) || ((x != x) && (y != y)))) {
+                    fail("Incorrect results for FloatBuffer.mismatch",
+                         xb, yb, x, y);
+                }
             }
         }
 
diff --git a/test/jdk/java/nio/Buffer/BasicInt.java b/test/jdk/java/nio/Buffer/BasicInt.java
--- a/test/jdk/java/nio/Buffer/BasicInt.java
+++ b/test/jdk/java/nio/Buffer/BasicInt.java
@@ -697,6 +697,17 @@
         if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
         }
+
+        if (b.compareToUnsigned(b2) != 0) {
+            fail("Unsighed comparison to identical buffer != 0", b, b2);
+        }
+
+        if (b.mismatch(b2) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
+        if (b2.mismatch(b) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((int)99);
@@ -706,6 +717,11 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to shorter buffer <= 0", b, b2);
+
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser shorter buffer <= 0", b, b2);
+        }
+
         b.limit(b.limit() - 1);
 
         b.put(2, (int)42);
@@ -714,7 +730,12 @@
         if (b.compareTo(b2) <= 0)
             fail("Comparison to lesser buffer <= 0", b, b2);
 
-        // Check equals and compareTo with interesting values
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser value <= 0", b, b2);
+        }
+
+
+        // Check equals, compareTo, compareToUnsigned, mismatch with interesting values
         for (int x : VALUES) {
             IntBuffer xb = IntBuffer.wrap(new int[] { x });
             if (xb.compareTo(xb) != 0) {
@@ -723,6 +744,9 @@
             if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
+            if (xb.mismatch(xb) != -1) {
+                fail("mismatch not reflexive", xb, xb, x, x);
+            }
             for (int y : VALUES) {
                 IntBuffer yb = IntBuffer.wrap(new int[] { y });
                 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
@@ -743,10 +767,34 @@
                     fail("Incorrect results for IntBuffer.compareTo",
                          xb, yb, x, y);
                 }
+
+                if (xb.compareToUnsigned(yb) != - yb.compareToUnsigned(xb)) {
+                    fail("compareToUnsigned not anti-symmetric",
+                         xb, yb, x, y);
+                }
+                if ((xb.compareToUnsigned(yb) == 0) != xb.equals(yb)) {
+                    fail("compareToUnsigned inconsistent with equals",
+                         xb, yb, x, y);
+                }
+                if (xb.compareToUnsigned(yb) != Integer.compareUnsigned(x, y)) {
+
+
+
+
+
+
+                    fail("Incorrect results for IntBuffer.compareToUnsigned",
+                         xb, yb, x, y);
+                }
+
                 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
                     fail("Incorrect results for IntBuffer.equals",
                          xb, yb, x, y);
                 }
+                if (xb.mismatch(yb) == -1 != ((x == y) || ((x != x) && (y != y)))) {
+                    fail("Incorrect results for IntBuffer.mismatch",
+                         xb, yb, x, y);
+                }
             }
         }
 
diff --git a/test/jdk/java/nio/Buffer/BasicLong.java b/test/jdk/java/nio/Buffer/BasicLong.java
--- a/test/jdk/java/nio/Buffer/BasicLong.java
+++ b/test/jdk/java/nio/Buffer/BasicLong.java
@@ -697,6 +697,17 @@
         if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
         }
+
+        if (b.compareToUnsigned(b2) != 0) {
+            fail("Unsighed comparison to identical buffer != 0", b, b2);
+        }
+
+        if (b.mismatch(b2) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
+        if (b2.mismatch(b) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((long)99);
@@ -706,6 +717,11 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to shorter buffer <= 0", b, b2);
+
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser shorter buffer <= 0", b, b2);
+        }
+
         b.limit(b.limit() - 1);
 
         b.put(2, (long)42);
@@ -714,7 +730,12 @@
         if (b.compareTo(b2) <= 0)
             fail("Comparison to lesser buffer <= 0", b, b2);
 
-        // Check equals and compareTo with interesting values
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser value <= 0", b, b2);
+        }
+
+
+        // Check equals, compareTo, compareToUnsigned, mismatch with interesting values
         for (long x : VALUES) {
             LongBuffer xb = LongBuffer.wrap(new long[] { x });
             if (xb.compareTo(xb) != 0) {
@@ -723,6 +744,9 @@
             if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
+            if (xb.mismatch(xb) != -1) {
+                fail("mismatch not reflexive", xb, xb, x, x);
+            }
             for (long y : VALUES) {
                 LongBuffer yb = LongBuffer.wrap(new long[] { y });
                 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
@@ -743,10 +767,34 @@
                     fail("Incorrect results for LongBuffer.compareTo",
                          xb, yb, x, y);
                 }
+
+                if (xb.compareToUnsigned(yb) != - yb.compareToUnsigned(xb)) {
+                    fail("compareToUnsigned not anti-symmetric",
+                         xb, yb, x, y);
+                }
+                if ((xb.compareToUnsigned(yb) == 0) != xb.equals(yb)) {
+                    fail("compareToUnsigned inconsistent with equals",
+                         xb, yb, x, y);
+                }
+                if (xb.compareToUnsigned(yb) != Long.compareUnsigned(x, y)) {
+
+
+
+
+
+
+                    fail("Incorrect results for LongBuffer.compareToUnsigned",
+                         xb, yb, x, y);
+                }
+
                 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
                     fail("Incorrect results for LongBuffer.equals",
                          xb, yb, x, y);
                 }
+                if (xb.mismatch(yb) == -1 != ((x == y) || ((x != x) && (y != y)))) {
+                    fail("Incorrect results for LongBuffer.mismatch",
+                         xb, yb, x, y);
+                }
             }
         }
 
diff --git a/test/jdk/java/nio/Buffer/BasicShort.java b/test/jdk/java/nio/Buffer/BasicShort.java
--- a/test/jdk/java/nio/Buffer/BasicShort.java
+++ b/test/jdk/java/nio/Buffer/BasicShort.java
@@ -697,6 +697,17 @@
         if (b.compareTo(b2) != 0) {
             fail("Comparison to identical buffer != 0", b, b2);
         }
+
+        if (b.compareToUnsigned(b2) != 0) {
+            fail("Unsighed comparison to identical buffer != 0", b, b2);
+        }
+
+        if (b.mismatch(b2) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
+        if (b2.mismatch(b) != -1) {
+            fail("Mismatch to identical buffer != -1", b, b2);
+        }
         b.limit(b.limit() + 1);
         b.position(b.limit() - 1);
         b.put((short)99);
@@ -706,6 +717,11 @@
             fail("Non-identical buffers equal", b, b2);
         if (b.compareTo(b2) <= 0)
             fail("Comparison to shorter buffer <= 0", b, b2);
+
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser shorter buffer <= 0", b, b2);
+        }
+
         b.limit(b.limit() - 1);
 
         b.put(2, (short)42);
@@ -714,7 +730,12 @@
         if (b.compareTo(b2) <= 0)
             fail("Comparison to lesser buffer <= 0", b, b2);
 
-        // Check equals and compareTo with interesting values
+        if (b.compareToUnsigned(b2) <= 0) {
+            fail("Unsighed comparison to lesser value <= 0", b, b2);
+        }
+
+
+        // Check equals, compareTo, compareToUnsigned, mismatch with interesting values
         for (short x : VALUES) {
             ShortBuffer xb = ShortBuffer.wrap(new short[] { x });
             if (xb.compareTo(xb) != 0) {
@@ -723,6 +744,9 @@
             if (!xb.equals(xb)) {
                 fail("equals not reflexive", xb, xb, x, x);
             }
+            if (xb.mismatch(xb) != -1) {
+                fail("mismatch not reflexive", xb, xb, x, x);
+            }
             for (short y : VALUES) {
                 ShortBuffer yb = ShortBuffer.wrap(new short[] { y });
                 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
@@ -743,10 +767,34 @@
                     fail("Incorrect results for ShortBuffer.compareTo",
                          xb, yb, x, y);
                 }
+
+                if (xb.compareToUnsigned(yb) != - yb.compareToUnsigned(xb)) {
+                    fail("compareToUnsigned not anti-symmetric",
+                         xb, yb, x, y);
+                }
+                if ((xb.compareToUnsigned(yb) == 0) != xb.equals(yb)) {
+                    fail("compareToUnsigned inconsistent with equals",
+                         xb, yb, x, y);
+                }
+                if (xb.compareToUnsigned(yb) != Short.compareUnsigned(x, y)) {
+
+
+
+
+
+
+                    fail("Incorrect results for ShortBuffer.compareToUnsigned",
+                         xb, yb, x, y);
+                }
+
                 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
                     fail("Incorrect results for ShortBuffer.equals",
                          xb, yb, x, y);
                 }
+                if (xb.mismatch(yb) == -1 != ((x == y) || ((x != x) && (y != y)))) {
+                    fail("Incorrect results for ShortBuffer.mismatch",
+                         xb, yb, x, y);
+                }
             }
         }
 
diff --git a/test/jdk/java/nio/Buffer/EqualsCompareTest.java b/test/jdk/java/nio/Buffer/EqualsCompareTest.java
--- a/test/jdk/java/nio/Buffer/EqualsCompareTest.java
+++ b/test/jdk/java/nio/Buffer/EqualsCompareTest.java
@@ -83,22 +83,28 @@
         final BufferKind k;
         final Class<?> bufferType;
         final Class<?> elementType;
+        final boolean withCompareUnsigned;
 
         final MethodHandle eq;
         final MethodHandle cmp;
+        final MethodHandle cmpUns;
+        final MethodHandle mism;
 
         final MethodHandle getter;
         final MethodHandle setter;
 
-        BufferType(BufferKind k, Class<T> bufferType, Class<?> elementType) {
+        BufferType(BufferKind k, Class<T> bufferType, Class<?> elementType, boolean withCompareUnsigned) {
             this.k = k;
             this.bufferType = bufferType;
             this.elementType = elementType;
+            this.withCompareUnsigned = withCompareUnsigned;
 
             var lookup = MethodHandles.lookup();
             try {
                 eq = lookup.findVirtual(bufferType, "equals", MethodType.methodType(boolean.class, Object.class));
                 cmp = lookup.findVirtual(bufferType, "compareTo", MethodType.methodType(int.class, bufferType));
+                cmpUns = withCompareUnsigned ? lookup.findVirtual(bufferType, "compareToUnsigned", MethodType.methodType(int.class, bufferType)) : null;
+                mism = lookup.findVirtual(bufferType, "mismatch", MethodType.methodType(int.class, bufferType));
 
                 getter = lookup.findVirtual(bufferType, "get", MethodType.methodType(elementType, int.class));
                 setter = lookup.findVirtual(bufferType, "put", MethodType.methodType(bufferType, int.class, elementType));
@@ -176,6 +182,30 @@
             }
         }
 
+        int compareUnsigned(T a, T b) {
+            try {
+                return (int) cmpUns.invoke(a, b);
+            }
+            catch (RuntimeException | Error e) {
+                throw e;
+            }
+            catch (Throwable t) {
+                throw new Error(t);
+            }
+        }
+
+        int mismatch(T a, T b) {
+            try {
+                return (int) mism.invoke(a, b);
+            }
+            catch (RuntimeException | Error e) {
+                throw e;
+            }
+            catch (Throwable t) {
+                throw new Error(t);
+            }
+        }
+
         boolean pairWiseEquals(T a, T b) {
             if (a.remaining() != b.remaining())
                 return false;
@@ -186,9 +216,16 @@
             return true;
         }
 
+        int pairWiseMismatch(T a, T b) {
+            for (int i = a.position(), j = b.position(); i < a.position() + a.remaining() && j < b.position() + b.remaining(); i++, j++)
+                if (!get(a, i).equals(get(b, j)))
+                    return i;
+            return -1;
+        }
+
         static class Bytes extends BufferType<ByteBuffer, Byte> {
             Bytes(BufferKind k) {
-                super(k, ByteBuffer.class, byte.class);
+                super(k, ByteBuffer.class, byte.class, true);
             }
 
             @Override
@@ -213,7 +250,7 @@
 
         static class Chars extends BufferType<CharBuffer, Character> {
             Chars(BufferKind k) {
-                super(k, CharBuffer.class, char.class);
+                super(k, CharBuffer.class, char.class, false);
             }
 
             @Override
@@ -249,7 +286,7 @@
 
         static class Shorts extends BufferType<ShortBuffer, Short> {
             Shorts(BufferKind k) {
-                super(k, ShortBuffer.class, short.class);
+                super(k, ShortBuffer.class, short.class, true);
             }
 
             @Override
@@ -279,7 +316,7 @@
 
         static class Ints extends BufferType<IntBuffer, Integer> {
             Ints(BufferKind k) {
-                super(k, IntBuffer.class, int.class);
+                super(k, IntBuffer.class, int.class, true);
             }
 
             @Override
@@ -306,7 +343,7 @@
 
         static class Floats extends BufferType<FloatBuffer, Float> {
             Floats(BufferKind k) {
-                super(k, FloatBuffer.class, float.class);
+                super(k, FloatBuffer.class, float.class, false);
             }
 
             @Override
@@ -346,11 +383,22 @@
                 }
                 return true;
             }
+
+            @Override
+            int pairWiseMismatch(FloatBuffer a, FloatBuffer b) {
+                for (int i = a.position(), j = b.position(); i < a.position() + a.remaining() && j < b.position() + b.remaining(); i++, j++) {
+                    float av = a.get(i);
+                    float bv = b.get(j);
+                    if (av != bv && (!Float.isNaN(av) || !Float.isNaN(bv)))
+                        return i;
+                }
+                return -1;
+            }
         }
 
         static class Longs extends BufferType<LongBuffer, Long> {
             Longs(BufferKind k) {
-                super(k, LongBuffer.class, long.class);
+                super(k, LongBuffer.class, long.class, true);
             }
 
             @Override
@@ -380,7 +428,7 @@
 
         static class Doubles extends BufferType<DoubleBuffer, Double> {
             Doubles(BufferKind k) {
-                super(k, DoubleBuffer.class, double.class);
+                super(k, DoubleBuffer.class, double.class, false);
             }
 
             @Override
@@ -420,6 +468,17 @@
                 }
                 return true;
             }
+
+            @Override
+            int pairWiseMismatch(DoubleBuffer a, DoubleBuffer b) {
+                for (int i = a.position(), j = b.position(); i < a.position() + a.remaining() && j < b.position() + b.remaining(); i++, j++) {
+                    double av = a.get(i);
+                    double bv = b.get(j);
+                    if (av != bv && (!Double.isNaN(av) || !Double.isNaN(bv)))
+                        return i;
+                }
+                return -1;
+            }
         }
     }
 
@@ -635,13 +694,28 @@
                                 if (eq) {
                                     Assert.assertEquals(bt.compare(as, bs), 0);
                                     Assert.assertEquals(bt.compare(bs, as), 0);
+
+                                    if (bt.withCompareUnsigned) {
+                                        Assert.assertEquals(bt.compareUnsigned(as, bs), 0);
+                                        Assert.assertEquals(bt.compareUnsigned(bs, as), 0);
+                                    }
                                 }
                                 else {
                                     int aCb = bt.compare(as, bs);
                                     int bCa = bt.compare(bs, as);
                                     int v = Integer.signum(aCb) * Integer.signum(bCa);
                                     Assert.assertTrue(v == -1);
+
+                                    if (bt.withCompareUnsigned) {
+                                        aCb = bt.compareUnsigned(as, bs);
+                                        bCa = bt.compareUnsigned(bs, as);
+                                        v = Integer.signum(aCb) * Integer.signum(bCa);
+                                        Assert.assertTrue(v == -1);
+                                    }
                                 }
+
+                                Assert.assertEquals(bt.mismatch(as, bs), bt.pairWiseMismatch(as, bs));
+                                Assert.assertEquals(bt.mismatch(bs, as), bt.pairWiseMismatch(bs, as));
                             }
                         }
 
@@ -661,6 +735,16 @@
                                 int aCc = bt.compare(as, cs);
                                 int v = Integer.signum(cCa) * Integer.signum(aCc);
                                 Assert.assertTrue(v == -1);
+
+                                if (bt.withCompareUnsigned) {
+                                    cCa = bt.compareUnsigned(cs, as);
+                                    aCc = bt.compareUnsigned(as, cs);
+                                    v = Integer.signum(cCa) * Integer.signum(aCc);
+                                    Assert.assertTrue(v == -1);
+                                }
+
+                                Assert.assertEquals(bt.mismatch(as, cs), bt.pairWiseMismatch(as, cs));
+                                Assert.assertEquals(bt.mismatch(cs, as), bt.pairWiseMismatch(cs, as));
                             }
                         }
                     }
diff --git a/test/jdk/java/nio/Buffer/genBasic.sh b/test/jdk/java/nio/Buffer/genBasic.sh
--- a/test/jdk/java/nio/Buffer/genBasic.sh
+++ b/test/jdk/java/nio/Buffer/genBasic.sh
@@ -23,16 +23,20 @@
 # questions.
 #
 
-javac -d . ../../../../make/src/classes/build/tools/spp/Spp.java
+javac -d . ../../../../../make/jdk/src/classes/build/tools/spp/Spp.java
 
 gen() {
     java build.tools.spp.Spp -K$1 -Dtype=$1 -DType=$2 -DFulltype=$3 <Basic-X.java.template >Basic$2.java
 }
 
-gen byte Byte Byte
+genu() {
+    java build.tools.spp.Spp -K$1 -Dtype=$1 -DType=$2 -DFulltype=$3 -KcompareToUnsigned <Basic-X.java.template >Basic$2.java
+}
+
+genu byte Byte Byte
 gen char Char Character
-gen short Short Short
-gen int Int Integer
-gen long Long Long
+genu short Short Short
+genu int Int Integer
+genu long Long Long
 gen float Float Float
 gen double Double Double
diff --git a/test/jdk/java/nio/Buffer/genCopyDirectMemory.sh b/test/jdk/java/nio/Buffer/genCopyDirectMemory.sh
--- a/test/jdk/java/nio/Buffer/genCopyDirectMemory.sh
+++ b/test/jdk/java/nio/Buffer/genCopyDirectMemory.sh
@@ -23,7 +23,7 @@
 # questions.
 #
 
-javac -d . ../../../../make/src/classes/build/tools/spp/Spp.java > Spp.java
+javac -d . ../../../../../make/jdk/src/classes/build/tools/spp/Spp.java
 
 gen() {
     java  build.tools.spp.Spp -K$1 -Dtype=$1 -DType=$2 -DFulltype=$3<CopyDirect-X-Memory.java.template >CopyDirect$2Memory.java
diff --git a/test/jdk/java/nio/Buffer/genOrder.sh b/test/jdk/java/nio/Buffer/genOrder.sh
--- a/test/jdk/java/nio/Buffer/genOrder.sh
+++ b/test/jdk/java/nio/Buffer/genOrder.sh
@@ -23,7 +23,7 @@
 # questions.
 #
 
-javac -d . ../../../../make/src/classes/build/tools/spp/Spp.java > Spp.java
+javac -d . ../../../../../make/jdk/src/classes/build/tools/spp/Spp.java
 
 gen() {
     java  build.tools.spp.Spp -K$1 -Dtype=$1 -DType=$2 -DFulltype=$3<Order-X.java.template >Order$2.java