Fix the byte order of non-ByteBuffer duplicate and slice results.

ByteBuffer.duplicate and ByteBuffer.slice always return big-endian buffers.
Any other kind of buffer returns a buffer with the same endian as itself.

We didn't have tests for the latter, and broke this in Honeycomb.

Bug: http://code.google.com/p/android/issues/detail?id=16434
Bug: 4361578

git cherry-pick 87c354d8d6faa77dee1820df2f0ad2666b9f0331

Change-Id: Idf8dc6f47ffdbfe82b83e9ce1186f1717ec0ef8f

7 files changed, 202 insertions, 124 deletions

diff --git a/luni/src/main/java/java/nio/CharToByteBufferAdapter.java b/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
index fc07f52..a271274 100644
--- a/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
@@ -75,7 +75,8 @@ final class CharToByteBufferAdapter extends CharBuffer {
 
     @Override
     public CharBuffer duplicate() {
-        CharToByteBufferAdapter buf = new CharToByteBufferAdapter(byteBuffer.duplicate());
+        ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
+        CharToByteBufferAdapter buf = new CharToByteBufferAdapter(bb);
         buf.limit = limit;
         buf.position = position;
         buf.mark = mark;
@@ -172,7 +173,8 @@ final class CharToByteBufferAdapter extends CharBuffer {
     public CharBuffer slice() {
         byteBuffer.limit(limit * SizeOf.CHAR);
         byteBuffer.position(position * SizeOf.CHAR);
-        CharBuffer result = new CharToByteBufferAdapter(byteBuffer.slice());
+        ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
+        CharBuffer result = new CharToByteBufferAdapter(bb);
         byteBuffer.clear();
         return result;
     }
diff --git a/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java b/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
index 888cb88..9f7dda7 100644
--- a/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
@@ -75,7 +75,8 @@ final class DoubleToByteBufferAdapter extends DoubleBuffer {
 
     @Override
     public DoubleBuffer duplicate() {
-        DoubleToByteBufferAdapter buf = new DoubleToByteBufferAdapter(byteBuffer.duplicate());
+        ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
+        DoubleToByteBufferAdapter buf = new DoubleToByteBufferAdapter(bb);
         buf.limit = limit;
         buf.position = position;
         buf.mark = mark;
@@ -172,7 +173,8 @@ final class DoubleToByteBufferAdapter extends DoubleBuffer {
     public DoubleBuffer slice() {
         byteBuffer.limit(limit * SizeOf.DOUBLE);
         byteBuffer.position(position * SizeOf.DOUBLE);
-        DoubleBuffer result = new DoubleToByteBufferAdapter(byteBuffer.slice());
+        ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
+        DoubleBuffer result = new DoubleToByteBufferAdapter(bb);
         byteBuffer.clear();
         return result;
     }
diff --git a/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java b/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
index 0bdad81..f674fe3 100644
--- a/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
@@ -74,7 +74,8 @@ final class FloatToByteBufferAdapter extends FloatBuffer {
 
     @Override
     public FloatBuffer duplicate() {
-        FloatToByteBufferAdapter buf = new FloatToByteBufferAdapter(byteBuffer.duplicate());
+        ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
+        FloatToByteBufferAdapter buf = new FloatToByteBufferAdapter(bb);
         buf.limit = limit;
         buf.position = position;
         buf.mark = mark;
@@ -171,7 +172,8 @@ final class FloatToByteBufferAdapter extends FloatBuffer {
     public FloatBuffer slice() {
         byteBuffer.limit(limit * SizeOf.FLOAT);
         byteBuffer.position(position * SizeOf.FLOAT);
-        FloatBuffer result = new FloatToByteBufferAdapter(byteBuffer.slice());
+        ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
+        FloatBuffer result = new FloatToByteBufferAdapter(bb);
         byteBuffer.clear();
         return result;
     }
diff --git a/luni/src/main/java/java/nio/IntToByteBufferAdapter.java b/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
index c93de37..1694e77 100644
--- a/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
@@ -75,7 +75,8 @@ final class IntToByteBufferAdapter extends IntBuffer {
 
     @Override
     public IntBuffer duplicate() {
-        IntToByteBufferAdapter buf = new IntToByteBufferAdapter(byteBuffer.duplicate());
+        ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
+        IntToByteBufferAdapter buf = new IntToByteBufferAdapter(bb);
         buf.limit = limit;
         buf.position = position;
         buf.mark = mark;
@@ -172,7 +173,8 @@ final class IntToByteBufferAdapter extends IntBuffer {
     public IntBuffer slice() {
         byteBuffer.limit(limit * SizeOf.INT);
         byteBuffer.position(position * SizeOf.INT);
-        IntBuffer result = new IntToByteBufferAdapter(byteBuffer.slice());
+        ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
+        IntBuffer result = new IntToByteBufferAdapter(bb);
         byteBuffer.clear();
         return result;
     }
diff --git a/luni/src/main/java/java/nio/LongToByteBufferAdapter.java b/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
index 2f31d47..5f51d96 100644
--- a/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
@@ -75,7 +75,8 @@ final class LongToByteBufferAdapter extends LongBuffer {
 
     @Override
     public LongBuffer duplicate() {
-        LongToByteBufferAdapter buf = new LongToByteBufferAdapter(byteBuffer.duplicate());
+        ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
+        LongToByteBufferAdapter buf = new LongToByteBufferAdapter(bb);
         buf.limit = limit;
         buf.position = position;
         buf.mark = mark;
@@ -172,7 +173,8 @@ final class LongToByteBufferAdapter extends LongBuffer {
     public LongBuffer slice() {
         byteBuffer.limit(limit * SizeOf.LONG);
         byteBuffer.position(position * SizeOf.LONG);
-        LongBuffer result = new LongToByteBufferAdapter(byteBuffer.slice());
+        ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
+        LongBuffer result = new LongToByteBufferAdapter(bb);
         byteBuffer.clear();
         return result;
     }
diff --git a/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java b/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
index 18a4521..3fa2a63 100644
--- a/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
@@ -74,7 +74,8 @@ final class ShortToByteBufferAdapter extends ShortBuffer {
 
     @Override
     public ShortBuffer duplicate() {
-        ShortToByteBufferAdapter buf = new ShortToByteBufferAdapter(byteBuffer.duplicate());
+        ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
+        ShortToByteBufferAdapter buf = new ShortToByteBufferAdapter(bb);
         buf.limit = limit;
         buf.position = position;
         buf.mark = mark;
@@ -171,7 +172,8 @@ final class ShortToByteBufferAdapter extends ShortBuffer {
     public ShortBuffer slice() {
         byteBuffer.limit(limit * SizeOf.SHORT);
         byteBuffer.position(position * SizeOf.SHORT);
-        ShortBuffer result = new ShortToByteBufferAdapter(byteBuffer.slice());
+        ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
+        ShortBuffer result = new ShortToByteBufferAdapter(bb);
         byteBuffer.clear();
         return result;
     }
diff --git a/luni/src/test/java/libcore/java/nio/BufferTest.java b/luni/src/test/java/libcore/java/nio/BufferTest.java
index 82e12d7..537a5cc 100644
--- a/luni/src/test/java/libcore/java/nio/BufferTest.java
+++ b/luni/src/test/java/libcore/java/nio/BufferTest.java
@@ -246,124 +246,190 @@ public class BufferTest extends TestCase {
         assertEquals(ByteOrder.BIG_ENDIAN, b.asReadOnlyBuffer().order());
     }
 
-    public void testCharBufferByteOrder() throws Exception {
-        // Everything always returns a native-endian buffer.
-        CharBuffer b = CharBuffer.allocate(10);
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new char[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
+    public void testCharBufferByteOrderWrapped() throws Exception {
+        assertEquals(ByteOrder.nativeOrder(), CharBuffer.wrap(new char[10]).order());
+        assertEquals(ByteOrder.nativeOrder(), CharBuffer.wrap(new char[10]).asReadOnlyBuffer().order());
+    }
+
+    private void testCharBufferByteOrder(CharBuffer b, ByteOrder bo) throws Exception {
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
         b = b.asReadOnlyBuffer();
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new char[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
-        // ...except for asReadOnlyBuffer, which returns a current-endian buffer.
-        ByteBuffer bb = ByteBuffer.allocate(10);
-        bb.order(ByteOrder.BIG_ENDIAN);
-        assertEquals(ByteOrder.BIG_ENDIAN, bb.asCharBuffer().asReadOnlyBuffer().order());
-        bb.order(ByteOrder.LITTLE_ENDIAN);
-        assertEquals(ByteOrder.LITTLE_ENDIAN, bb.asCharBuffer().asReadOnlyBuffer().order());
-    }
-
-    public void testDoubleBufferByteOrder() throws Exception {
-        // Everything always returns a native-endian buffer.
-        DoubleBuffer b = DoubleBuffer.allocate(10);
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new double[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
+    }
+
+    private CharBuffer allocateCharBuffer(ByteOrder order) {
+        return ByteBuffer.allocate(10).order(order).asCharBuffer();
+    }
+
+    public void testCharBufferByteOrderArray() throws Exception {
+        testCharBufferByteOrder(CharBuffer.allocate(10), ByteOrder.nativeOrder());
+    }
+
+    public void testCharBufferByteOrderBE() throws Exception {
+        testCharBufferByteOrder(allocateCharBuffer(ByteOrder.BIG_ENDIAN), ByteOrder.BIG_ENDIAN);
+    }
+
+    public void testCharBufferByteOrderLE() throws Exception {
+        testCharBufferByteOrder(allocateCharBuffer(ByteOrder.LITTLE_ENDIAN), ByteOrder.LITTLE_ENDIAN);
+    }
+
+    public void testDoubleBufferByteOrderWrapped() throws Exception {
+        assertEquals(ByteOrder.nativeOrder(), DoubleBuffer.wrap(new double[10]).order());
+        assertEquals(ByteOrder.nativeOrder(), DoubleBuffer.wrap(new double[10]).asReadOnlyBuffer().order());
+    }
+
+    private void testDoubleBufferByteOrder(DoubleBuffer b, ByteOrder bo) throws Exception {
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
         b = b.asReadOnlyBuffer();
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new double[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
-        // ...except for asReadOnlyBuffer, which returns a current-endian buffer.
-        ByteBuffer bb = ByteBuffer.allocate(10);
-        bb.order(ByteOrder.BIG_ENDIAN);
-        assertEquals(ByteOrder.BIG_ENDIAN, bb.asDoubleBuffer().asReadOnlyBuffer().order());
-        bb.order(ByteOrder.LITTLE_ENDIAN);
-        assertEquals(ByteOrder.LITTLE_ENDIAN, bb.asDoubleBuffer().asReadOnlyBuffer().order());
-    }
-
-    public void testFloatBufferByteOrder() throws Exception {
-        // Everything always returns a native-endian buffer.
-        FloatBuffer b = FloatBuffer.allocate(10);
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new float[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
+    }
+
+    private DoubleBuffer allocateDoubleBuffer(ByteOrder order) {
+        return ByteBuffer.allocate(10*8).order(order).asDoubleBuffer();
+    }
+
+    public void testDoubleBufferByteOrderArray() throws Exception {
+        testDoubleBufferByteOrder(DoubleBuffer.allocate(10), ByteOrder.nativeOrder());
+    }
+
+    public void testDoubleBufferByteOrderBE() throws Exception {
+        testDoubleBufferByteOrder(allocateDoubleBuffer(ByteOrder.BIG_ENDIAN), ByteOrder.BIG_ENDIAN);
+    }
+
+    public void testDoubleBufferByteOrderLE() throws Exception {
+        testDoubleBufferByteOrder(allocateDoubleBuffer(ByteOrder.LITTLE_ENDIAN), ByteOrder.LITTLE_ENDIAN);
+    }
+
+    public void testFloatBufferByteOrderWrapped() throws Exception {
+        assertEquals(ByteOrder.nativeOrder(), FloatBuffer.wrap(new float[10]).order());
+        assertEquals(ByteOrder.nativeOrder(), FloatBuffer.wrap(new float[10]).asReadOnlyBuffer().order());
+    }
+
+    private void testFloatBufferByteOrder(FloatBuffer b, ByteOrder bo) throws Exception {
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
         b = b.asReadOnlyBuffer();
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new float[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
-        // ...except for asReadOnlyBuffer, which returns a current-endian buffer.
-        ByteBuffer bb = ByteBuffer.allocate(10);
-        bb.order(ByteOrder.BIG_ENDIAN);
-        assertEquals(ByteOrder.BIG_ENDIAN, bb.asFloatBuffer().asReadOnlyBuffer().order());
-        bb.order(ByteOrder.LITTLE_ENDIAN);
-        assertEquals(ByteOrder.LITTLE_ENDIAN, bb.asFloatBuffer().asReadOnlyBuffer().order());
-    }
-
-    public void testIntBufferByteOrder() throws Exception {
-        // Everything always returns a native-endian buffer.
-        IntBuffer b = IntBuffer.allocate(10);
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new int[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
+    }
+
+    private FloatBuffer allocateFloatBuffer(ByteOrder order) {
+        return ByteBuffer.allocate(10*8).order(order).asFloatBuffer();
+    }
+
+    public void testFloatBufferByteOrderArray() throws Exception {
+        testFloatBufferByteOrder(FloatBuffer.allocate(10), ByteOrder.nativeOrder());
+    }
+
+    public void testFloatBufferByteOrderBE() throws Exception {
+        testFloatBufferByteOrder(allocateFloatBuffer(ByteOrder.BIG_ENDIAN), ByteOrder.BIG_ENDIAN);
+    }
+
+    public void testFloatBufferByteOrderLE() throws Exception {
+        testFloatBufferByteOrder(allocateFloatBuffer(ByteOrder.LITTLE_ENDIAN), ByteOrder.LITTLE_ENDIAN);
+    }
+
+    public void testIntBufferByteOrderWrapped() throws Exception {
+        assertEquals(ByteOrder.nativeOrder(), IntBuffer.wrap(new int[10]).order());
+        assertEquals(ByteOrder.nativeOrder(), IntBuffer.wrap(new int[10]).asReadOnlyBuffer().order());
+    }
+
+    private void testIntBufferByteOrder(IntBuffer b, ByteOrder bo) throws Exception {
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
         b = b.asReadOnlyBuffer();
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new int[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
-        // ...except for asReadOnlyBuffer, which returns a current-endian buffer.
-        ByteBuffer bb = ByteBuffer.allocate(10);
-        bb.order(ByteOrder.BIG_ENDIAN);
-        assertEquals(ByteOrder.BIG_ENDIAN, bb.asIntBuffer().asReadOnlyBuffer().order());
-        bb.order(ByteOrder.LITTLE_ENDIAN);
-        assertEquals(ByteOrder.LITTLE_ENDIAN, bb.asIntBuffer().asReadOnlyBuffer().order());
-    }
-
-    public void testLongBufferByteOrder() throws Exception {
-        // Everything always returns a native-endian buffer.
-        LongBuffer b = LongBuffer.allocate(10);
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new long[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
+    }
+
+    private IntBuffer allocateIntBuffer(ByteOrder order) {
+        return ByteBuffer.allocate(10*8).order(order).asIntBuffer();
+    }
+
+    public void testIntBufferByteOrderArray() throws Exception {
+        testIntBufferByteOrder(IntBuffer.allocate(10), ByteOrder.nativeOrder());
+    }
+
+    public void testIntBufferByteOrderBE() throws Exception {
+        testIntBufferByteOrder(allocateIntBuffer(ByteOrder.BIG_ENDIAN), ByteOrder.BIG_ENDIAN);
+    }
+
+    public void testIntBufferByteOrderLE() throws Exception {
+        testIntBufferByteOrder(allocateIntBuffer(ByteOrder.LITTLE_ENDIAN), ByteOrder.LITTLE_ENDIAN);
+    }
+
+    public void testLongBufferByteOrderWrapped() throws Exception {
+        assertEquals(ByteOrder.nativeOrder(), LongBuffer.wrap(new long[10]).order());
+        assertEquals(ByteOrder.nativeOrder(), LongBuffer.wrap(new long[10]).asReadOnlyBuffer().order());
+    }
+
+    private void testLongBufferByteOrder(LongBuffer b, ByteOrder bo) throws Exception {
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
         b = b.asReadOnlyBuffer();
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new long[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
-        // ...except for asReadOnlyBuffer, which returns a current-endian buffer.
-        ByteBuffer bb = ByteBuffer.allocate(10);
-        bb.order(ByteOrder.BIG_ENDIAN);
-        assertEquals(ByteOrder.BIG_ENDIAN, bb.asLongBuffer().asReadOnlyBuffer().order());
-        bb.order(ByteOrder.LITTLE_ENDIAN);
-        assertEquals(ByteOrder.LITTLE_ENDIAN, bb.asLongBuffer().asReadOnlyBuffer().order());
-    }
-
-    public void testShortBufferByteOrder() throws Exception {
-        // Everything always returns a native-endian buffer.
-        ShortBuffer b = ShortBuffer.allocate(10);
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new short[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
+    }
+
+    private LongBuffer allocateLongBuffer(ByteOrder order) {
+        return ByteBuffer.allocate(10*8).order(order).asLongBuffer();
+    }
+
+    public void testLongBufferByteOrderArray() throws Exception {
+        testLongBufferByteOrder(LongBuffer.allocate(10), ByteOrder.nativeOrder());
+    }
+
+    public void testLongBufferByteOrderBE() throws Exception {
+        testLongBufferByteOrder(allocateLongBuffer(ByteOrder.BIG_ENDIAN), ByteOrder.BIG_ENDIAN);
+    }
+
+    public void testLongBufferByteOrderLE() throws Exception {
+        testLongBufferByteOrder(allocateLongBuffer(ByteOrder.LITTLE_ENDIAN), ByteOrder.LITTLE_ENDIAN);
+    }
+
+    public void testShortBufferByteOrderWrapped() throws Exception {
+        assertEquals(ByteOrder.nativeOrder(), ShortBuffer.wrap(new short[10]).order());
+        assertEquals(ByteOrder.nativeOrder(), ShortBuffer.wrap(new short[10]).asReadOnlyBuffer().order());
+    }
+
+    private void testShortBufferByteOrder(ShortBuffer b, ByteOrder bo) throws Exception {
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
         b = b.asReadOnlyBuffer();
-        assertEquals(ByteOrder.nativeOrder(), b.order());
-        assertEquals(ByteOrder.nativeOrder(), b.wrap(new short[10]).order());
-        assertEquals(ByteOrder.nativeOrder(), b.duplicate().order());
-        assertEquals(ByteOrder.nativeOrder(), b.slice().order());
-        // ...except for asReadOnlyBuffer, which returns a current-endian buffer.
-        ByteBuffer bb = ByteBuffer.allocate(10);
-        bb.order(ByteOrder.BIG_ENDIAN);
-        assertEquals(ByteOrder.BIG_ENDIAN, bb.asShortBuffer().asReadOnlyBuffer().order());
-        bb.order(ByteOrder.LITTLE_ENDIAN);
-        assertEquals(ByteOrder.LITTLE_ENDIAN, bb.asShortBuffer().asReadOnlyBuffer().order());
+        assertEquals(bo, b.order());
+        assertEquals(bo, b.duplicate().order());
+        assertEquals(bo, b.slice().order());
+    }
+
+    private ShortBuffer allocateShortBuffer(ByteOrder order) {
+        return ByteBuffer.allocate(10*8).order(order).asShortBuffer();
+    }
+
+    public void testShortBufferByteOrderArray() throws Exception {
+        testShortBufferByteOrder(ShortBuffer.allocate(10), ByteOrder.nativeOrder());
+    }
+
+    public void testShortBufferByteOrderBE() throws Exception {
+        testShortBufferByteOrder(allocateShortBuffer(ByteOrder.BIG_ENDIAN), ByteOrder.BIG_ENDIAN);
+    }
+
+    public void testShortBufferByteOrderLE() throws Exception {
+        testShortBufferByteOrder(allocateShortBuffer(ByteOrder.LITTLE_ENDIAN), ByteOrder.LITTLE_ENDIAN);
     }
 
     public void testRelativePositionsHeap() throws Exception {