Merge changes Ib164c294,Ie40c0226
* changes:
Android patch: Disable OpenJDK 11 Duration tests
Add java.time tests into EXPECTED_UPSTREAM - aosp/master
diff --git a/luni/src/main/java/libcore/io/Memory.java b/luni/src/main/java/libcore/io/Memory.java
index efd3ac5..d9df6d5 100644
--- a/luni/src/main/java/libcore/io/Memory.java
+++ b/luni/src/main/java/libcore/io/Memory.java
@@ -287,36 +287,43 @@
* @hide
*/
@UnsupportedAppUsage
+ @FastNative
public static native void peekByteArray(long address, byte[] dst, int dstOffset, int byteCount);
/**
* @hide
*/
+ @FastNative
public static native void peekCharArray(long address, char[] dst, int dstOffset, int charCount, boolean swap);
/**
* @hide
*/
+ @FastNative
public static native void peekDoubleArray(long address, double[] dst, int dstOffset, int doubleCount, boolean swap);
/**
* @hide
*/
+ @FastNative
public static native void peekFloatArray(long address, float[] dst, int dstOffset, int floatCount, boolean swap);
/**
* @hide
*/
+ @FastNative
public static native void peekIntArray(long address, int[] dst, int dstOffset, int intCount, boolean swap);
/**
* @hide
*/
+ @FastNative
public static native void peekLongArray(long address, long[] dst, int dstOffset, int longCount, boolean swap);
/**
* @hide
*/
+ @FastNative
public static native void peekShortArray(long address, short[] dst, int dstOffset, int shortCount, boolean swap);
/**
diff --git a/luni/src/main/native/libcore_io_Memory.cpp b/luni/src/main/native/libcore_io_Memory.cpp
index b8a8845..b015988 100644
--- a/luni/src/main/native/libcore_io_Memory.cpp
+++ b/luni/src/main/native/libcore_io_Memory.cpp
@@ -293,16 +293,16 @@
static JNINativeMethod gMethods[] = {
NATIVE_METHOD(Memory, memmove, "(Ljava/lang/Object;ILjava/lang/Object;IJ)V"),
FAST_NATIVE_METHOD(Memory, peekByte, "(J)B"),
- NATIVE_METHOD(Memory, peekByteArray, "(J[BII)V"),
- NATIVE_METHOD(Memory, peekCharArray, "(J[CIIZ)V"),
- NATIVE_METHOD(Memory, peekDoubleArray, "(J[DIIZ)V"),
- NATIVE_METHOD(Memory, peekFloatArray, "(J[FIIZ)V"),
+ FAST_NATIVE_METHOD(Memory, peekByteArray, "(J[BII)V"),
+ FAST_NATIVE_METHOD(Memory, peekCharArray, "(J[CIIZ)V"),
+ FAST_NATIVE_METHOD(Memory, peekDoubleArray, "(J[DIIZ)V"),
+ FAST_NATIVE_METHOD(Memory, peekFloatArray, "(J[FIIZ)V"),
FAST_NATIVE_METHOD(Memory, peekIntNative, "(J)I"),
- NATIVE_METHOD(Memory, peekIntArray, "(J[IIIZ)V"),
+ FAST_NATIVE_METHOD(Memory, peekIntArray, "(J[IIIZ)V"),
FAST_NATIVE_METHOD(Memory, peekLongNative, "(J)J"),
- NATIVE_METHOD(Memory, peekLongArray, "(J[JIIZ)V"),
+ FAST_NATIVE_METHOD(Memory, peekLongArray, "(J[JIIZ)V"),
FAST_NATIVE_METHOD(Memory, peekShortNative, "(J)S"),
- NATIVE_METHOD(Memory, peekShortArray, "(J[SIIZ)V"),
+ FAST_NATIVE_METHOD(Memory, peekShortArray, "(J[SIIZ)V"),
FAST_NATIVE_METHOD(Memory, pokeByte, "(JB)V"),
NATIVE_METHOD(Memory, pokeByteArray, "(J[BII)V"),
NATIVE_METHOD(Memory, pokeCharArray, "(J[CIIZ)V"),
diff --git a/luni/src/test/java/libcore/java/lang/IntegerTest.java b/luni/src/test/java/libcore/java/lang/IntegerTest.java
index 79d1acc..4954f02 100644
--- a/luni/src/test/java/libcore/java/lang/IntegerTest.java
+++ b/luni/src/test/java/libcore/java/lang/IntegerTest.java
@@ -16,163 +16,164 @@
package libcore.java.lang;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
import java.util.Properties;
-public class IntegerTest extends junit.framework.TestCase {
+@RunWith(JUnit4.class)
+public class IntegerTest {
+ static final int[] INT_VALUES = {0, 1, 23, 456, 0x7fff_ffff, 0x8000_0000, 0xffff_ffff};
- public void testSystemProperties() {
- Properties originalProperties = System.getProperties();
- try {
- Properties testProperties = new Properties();
- testProperties.put("testIncInt", "notInt");
- System.setProperties(testProperties);
- assertNull("returned incorrect default Integer",
- Integer.getInteger("testIncInt"));
- assertEquals(new Integer(4), Integer.getInteger("testIncInt", 4));
- assertEquals(new Integer(4),
- Integer.getInteger("testIncInt", new Integer(4)));
- } finally {
- System.setProperties(originalProperties);
+ static final long[] LONG_VALUES = {
+ 0x1_0000_0000L, (long) Integer.MIN_VALUE - 1L, Long.MIN_VALUE, Long.MAX_VALUE
+ };
+
+ @Test
+ public void testSystemProperties() {
+ Properties originalProperties = System.getProperties();
+ try {
+ Properties testProperties = new Properties();
+ testProperties.put("testIncInt", "notInt");
+ System.setProperties(testProperties);
+ assertNull("returned incorrect default Integer", Integer.getInteger("testIncInt"));
+ assertEquals(new Integer(4), Integer.getInteger("testIncInt", 4));
+ assertEquals(new Integer(4), Integer.getInteger("testIncInt", new Integer(4)));
+ } finally {
+ System.setProperties(originalProperties);
+ }
}
- }
- public void testCompare() throws Exception {
- final int min = Integer.MIN_VALUE;
- final int zero = 0;
- final int max = Integer.MAX_VALUE;
- assertTrue(Integer.compare(max, max) == 0);
- assertTrue(Integer.compare(min, min) == 0);
- assertTrue(Integer.compare(zero, zero) == 0);
- assertTrue(Integer.compare(max, zero) > 0);
- assertTrue(Integer.compare(max, min) > 0);
- assertTrue(Integer.compare(zero, max) < 0);
- assertTrue(Integer.compare(zero, min) > 0);
- assertTrue(Integer.compare(min, zero) < 0);
- assertTrue(Integer.compare(min, max) < 0);
- }
+ @Test
+ public void testCompare() throws Exception {
+ final int min = Integer.MIN_VALUE;
+ final int zero = 0;
+ final int max = Integer.MAX_VALUE;
+ assertTrue(Integer.compare(max, max) == 0);
+ assertTrue(Integer.compare(min, min) == 0);
+ assertTrue(Integer.compare(zero, zero) == 0);
+ assertTrue(Integer.compare(max, zero) > 0);
+ assertTrue(Integer.compare(max, min) > 0);
+ assertTrue(Integer.compare(zero, max) < 0);
+ assertTrue(Integer.compare(zero, min) > 0);
+ assertTrue(Integer.compare(min, zero) < 0);
+ assertTrue(Integer.compare(min, max) < 0);
+ }
- public void testParseInt() throws Exception {
- assertEquals(0, Integer.parseInt("+0", 10));
- assertEquals(473, Integer.parseInt("+473", 10));
- assertEquals(255, Integer.parseInt("+FF", 16));
- assertEquals(102, Integer.parseInt("+1100110", 2));
- assertEquals(2147483647, Integer.parseInt("+2147483647", 10));
- assertEquals(411787, Integer.parseInt("Kona", 27));
- assertEquals(411787, Integer.parseInt("+Kona", 27));
- assertEquals(-145, Integer.parseInt("-145", 10));
+ @Test
+ public void testParseInt() throws Exception {
+ assertEquals(0, Integer.parseInt("+0", 10));
+ assertEquals(473, Integer.parseInt("+473", 10));
+ assertEquals(255, Integer.parseInt("+FF", 16));
+ assertEquals(102, Integer.parseInt("+1100110", 2));
+ assertEquals(2147483647, Integer.parseInt("+2147483647", 10));
+ assertEquals(411787, Integer.parseInt("Kona", 27));
+ assertEquals(411787, Integer.parseInt("+Kona", 27));
+ assertEquals(-145, Integer.parseInt("-145", 10));
- try {
- Integer.parseInt("--1", 10); // multiple sign chars
- fail();
- } catch (NumberFormatException expected) {}
+ // multiple sign chars
+ assertThrows(NumberFormatException.class, () -> Integer.parseInt("--1", 10));
+ assertThrows(NumberFormatException.class, () -> Integer.parseInt("++1", 10));
- try {
- Integer.parseInt("++1", 10); // multiple sign chars
- fail();
- } catch (NumberFormatException expected) {}
+ // base too small
+ assertThrows(NumberFormatException.class, () -> Integer.parseInt("Kona", 10));
+ }
- try {
- Integer.parseInt("Kona", 10); // base too small
- fail();
- } catch (NumberFormatException expected) {}
- }
+ @Test
+ public void testDecodeInt() throws Exception {
+ assertEquals(0, Integer.decode("+0").intValue());
+ assertEquals(473, Integer.decode("+473").intValue());
+ assertEquals(255, Integer.decode("+0xFF").intValue());
+ assertEquals(16, Integer.decode("+020").intValue());
+ assertEquals(2147483647, Integer.decode("+2147483647").intValue());
+ assertEquals(-73, Integer.decode("-73").intValue());
+ assertEquals(-255, Integer.decode("-0xFF").intValue());
+ assertEquals(255, Integer.decode("+#FF").intValue());
+ assertEquals(-255, Integer.decode("-#FF").intValue());
- public void testDecodeInt() throws Exception {
- assertEquals(0, Integer.decode("+0").intValue());
- assertEquals(473, Integer.decode("+473").intValue());
- assertEquals(255, Integer.decode("+0xFF").intValue());
- assertEquals(16, Integer.decode("+020").intValue());
- assertEquals(2147483647, Integer.decode("+2147483647").intValue());
- assertEquals(-73, Integer.decode("-73").intValue());
- assertEquals(-255, Integer.decode("-0xFF").intValue());
- assertEquals(255, Integer.decode("+#FF").intValue());
- assertEquals(-255, Integer.decode("-#FF").intValue());
+ assertThrows(NumberFormatException.class, () -> Integer.decode("--1"));
+ assertThrows(NumberFormatException.class, () -> Integer.decode("++1"));
+ assertThrows(NumberFormatException.class, () -> Integer.decode("-+1"));
+ assertThrows(NumberFormatException.class, () -> Integer.decode("Kona"));
+ }
- try {
- Integer.decode("--1"); // multiple sign chars
- fail();
- } catch (NumberFormatException expected) {}
+ /*
+ public void testParsePositiveInt() throws Exception {
+ assertEquals(0, Integer.parsePositiveInt("0", 10));
+ assertEquals(473, Integer.parsePositiveInt("473", 10));
+ assertEquals(255, Integer.parsePositiveInt("FF", 16));
- try {
- Integer.decode("++1"); // multiple sign chars
- fail();
- } catch (NumberFormatException expected) {}
+ try {
+ Integer.parsePositiveInt("-1", 10);
+ fail();
+ } catch (NumberFormatException e) {}
- try {
- Integer.decode("-+1"); // multiple sign chars
- fail();
- } catch (NumberFormatException expected) {}
+ try {
+ Integer.parsePositiveInt("+1", 10);
+ fail();
+ } catch (NumberFormatException e) {}
- try {
- Integer.decode("Kona"); // invalid number
- fail();
- } catch (NumberFormatException expected) {}
- }
+ try {
+ Integer.parsePositiveInt("+0", 16);
+ fail();
+ } catch (NumberFormatException e) {}
+ }
+ */
- /*
- public void testParsePositiveInt() throws Exception {
- assertEquals(0, Integer.parsePositiveInt("0", 10));
- assertEquals(473, Integer.parsePositiveInt("473", 10));
- assertEquals(255, Integer.parsePositiveInt("FF", 16));
-
- try {
- Integer.parsePositiveInt("-1", 10);
- fail();
- } catch (NumberFormatException e) {}
-
- try {
- Integer.parsePositiveInt("+1", 10);
- fail();
- } catch (NumberFormatException e) {}
-
- try {
- Integer.parsePositiveInt("+0", 16);
- fail();
- } catch (NumberFormatException e) {}
- }
- */
-
+ @Test
public void testStaticHashCode() {
assertEquals(Integer.valueOf(567).hashCode(), Integer.hashCode(567));
}
+ @Test
public void testMax() {
int a = 567;
int b = 578;
assertEquals(Math.max(a, b), Integer.max(a, b));
}
+ @Test
public void testMin() {
int a = 567;
int b = 578;
assertEquals(Math.min(a, b), Integer.min(a, b));
}
+ @Test
public void testSum() {
int a = 567;
int b = 578;
assertEquals(a + b, Integer.sum(a, b));
}
+ @Test
public void testBYTES() {
- assertEquals(4, Integer.BYTES);
+ assertEquals(4, Integer.BYTES);
}
+ @Test
public void testCompareUnsigned() {
- int[] ordVals = {0, 1, 23, 456, 0x7fff_ffff, 0x8000_0000, 0xffff_ffff};
- for(int i = 0; i < ordVals.length; ++i) {
- for(int j = 0; j < ordVals.length; ++j) {
- assertEquals(Integer.compare(i, j),
- Integer.compareUnsigned(ordVals[i], ordVals[j]));
+ for (int i = 0; i < INT_VALUES.length; ++i) {
+ for (int j = 0; j < INT_VALUES.length; ++j) {
+ assertEquals(
+ Integer.compare(i, j),
+ Integer.compareUnsigned(INT_VALUES[i], INT_VALUES[j]));
}
}
}
+ @Test
public void testDivideAndRemainderUnsigned() {
long[] vals = {1L, 23L, 456L, 0x7fff_ffffL, 0x8000_0000L, 0xffff_ffffL};
- for(long dividend : vals) {
- for(long divisor : vals) {
+ for (long dividend : vals) {
+ for (long divisor : vals) {
int uq = Integer.divideUnsigned((int) dividend, (int) divisor);
int ur = Integer.remainderUnsigned((int) dividend, (int) divisor);
assertEquals((int) (dividend / divisor), uq);
@@ -181,83 +182,220 @@
}
}
- for(long dividend : vals) {
- try {
- Integer.divideUnsigned((int) dividend, 0);
- fail();
- } catch (ArithmeticException expected) { }
- try {
- Integer.remainderUnsigned((int) dividend, 0);
- fail();
- } catch (ArithmeticException expected) { }
+ for (long dividend : vals) {
+ assertThrows(
+ ArithmeticException.class, () -> Integer.divideUnsigned((int) dividend, 0));
+ assertThrows(
+ ArithmeticException.class, () -> Integer.remainderUnsigned((int) dividend, 0));
}
}
+ @Test
public void testParseUnsignedInt() {
- int[] vals = {0, 1, 23, 456, 0x7fff_ffff, 0x8000_0000, 0xffff_ffff};
-
- for(int val : vals) {
+ for (int value : INT_VALUES) {
// Special radices
- assertEquals(val, Integer.parseUnsignedInt(Integer.toBinaryString(val), 2));
- assertEquals(val, Integer.parseUnsignedInt(Integer.toOctalString(val), 8));
- assertEquals(val, Integer.parseUnsignedInt(Integer.toUnsignedString(val)));
- assertEquals(val, Integer.parseUnsignedInt(Integer.toHexString(val), 16));
+ assertEquals(value, Integer.parseUnsignedInt(Integer.toBinaryString(value), 2));
+ assertEquals(value, Integer.parseUnsignedInt(Integer.toOctalString(value), 8));
+ assertEquals(value, Integer.parseUnsignedInt(Integer.toUnsignedString(value)));
+ assertEquals(value, Integer.parseUnsignedInt(Integer.toHexString(value), 16));
- for(int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; ++radix) {
- assertEquals(val,
- Integer.parseUnsignedInt(Integer.toUnsignedString(val, radix), radix));
+ for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; ++radix) {
+ assertEquals(
+ value,
+ Integer.parseUnsignedInt(Integer.toUnsignedString(value, radix), radix));
}
}
- try {
- Integer.parseUnsignedInt("-1");
- fail();
- } catch (NumberFormatException expected) { }
- try {
- Integer.parseUnsignedInt("123", 2);
- fail();
- } catch (NumberFormatException expected) { }
- try {
- Integer.parseUnsignedInt(null);
- fail();
- } catch (NumberFormatException expected) { }
- try {
- Integer.parseUnsignedInt("0", Character.MAX_RADIX + 1);
- fail();
- } catch (NumberFormatException expected) { }
- try {
- Integer.parseUnsignedInt("0", Character.MIN_RADIX - 1);
- fail();
- } catch (NumberFormatException expected) { }
+ for (long longValue : LONG_VALUES) {
+ // Special radices
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(Long.toBinaryString(longValue), 2));
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(Long.toOctalString(longValue), 8));
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(Long.toUnsignedString(longValue), 10));
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(Long.toHexString(longValue), 16));
+ for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; ++radix) {
+ final int r = radix;
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(Long.toUnsignedString(longValue, r), r));
+ }
+ }
+
+ assertThrows(NumberFormatException.class, () -> Integer.parseUnsignedInt("-1"));
+ assertThrows(NumberFormatException.class, () -> Integer.parseUnsignedInt("123", 2));
+ assertThrows(NumberFormatException.class, () -> Integer.parseUnsignedInt(null));
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt("0", Character.MAX_RADIX + 1));
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt("0", Character.MIN_RADIX - 1));
}
- public void testToUnsignedLong() {
- int[] vals = {0, 1, 23, 456, 0x7fff_ffff, 0x8000_0000, 0xffff_ffff};
+ @Test
+ public void testParseUnsignedIntSubstring() {
+ final String LEFT = "1";
+ final String RIGHT = "0";
- for(int val : vals) {
+ for (int ii = 0; ii < 8; ii = 2 * ii + 1) {
+ for (int jj = 0; jj < 8; jj = 2 * jj + 1) {
+ final int i = ii; // final for use in lambdas
+ final int j = jj; // final for use in lambdas
+ final String leftPad = LEFT.repeat(i);
+ final String rightPad = RIGHT.repeat(j);
+ for (int value : INT_VALUES) {
+ String binary = leftPad + Integer.toBinaryString(value) + rightPad;
+ assertEquals(
+ value, Integer.parseUnsignedInt(binary, i, binary.length() - j, 2));
+
+ String octal = leftPad + Integer.toOctalString(value) + rightPad;
+ assertEquals(value, Integer.parseUnsignedInt(octal, i, octal.length() - j, 8));
+
+ String denary = leftPad + Integer.toUnsignedString(value) + rightPad;
+ assertEquals(
+ value, Integer.parseUnsignedInt(denary, i, denary.length() - j, 10));
+
+ String hex = leftPad + Integer.toHexString(value) + rightPad;
+ assertEquals(value, Integer.parseUnsignedInt(hex, i, hex.length() - j, 16));
+
+ for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; ++radix) {
+ String arb = leftPad + Integer.toUnsignedString(value, radix) + rightPad;
+ assertEquals(
+ value, Integer.parseUnsignedInt(arb, i, arb.length() - j, radix));
+ }
+ }
+
+ for (long large_value : LONG_VALUES) {
+ {
+ final String input = leftPad + Long.toBinaryString(large_value) + rightPad;
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(input, i, input.length() - j, 2));
+ }
+ {
+ final String input = leftPad + Long.toOctalString(large_value) + rightPad;
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(input, i, input.length() - j, 8));
+ }
+ {
+ final String input =
+ leftPad + Long.toUnsignedString(large_value) + rightPad;
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(input, i, input.length() - j, 10));
+ }
+ {
+ final String input = leftPad + Long.toHexString(large_value) + rightPad;
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(input, i, input.length() - j, 16));
+ }
+ for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; ++radix) {
+ final int r = radix;
+ String input =
+ leftPad + Long.toUnsignedString(large_value, radix) + rightPad;
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt(input, i, input.length() - j, r));
+ }
+ }
+ }
+ }
+
+ assertThrows(
+ IndexOutOfBoundsException.class, () -> Integer.parseUnsignedInt("123", -1, 3, 10));
+ assertThrows(
+ IndexOutOfBoundsException.class, () -> Integer.parseUnsignedInt("123", 4, 5, 10));
+ assertThrows(
+ IndexOutOfBoundsException.class, () -> Integer.parseUnsignedInt("123", 2, 1, 10));
+ assertThrows(
+ IndexOutOfBoundsException.class, () -> Integer.parseUnsignedInt("123", 2, 4, 10));
+ assertThrows(NumberFormatException.class, () -> Integer.parseUnsignedInt("-1", 0, 2, 10));
+ assertThrows(NumberFormatException.class, () -> Integer.parseUnsignedInt("123", 0, 3, 2));
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt("0", 0, 1, Character.MAX_RADIX + 1));
+ assertThrows(
+ NumberFormatException.class,
+ () -> Integer.parseUnsignedInt("0", 0, 1, Character.MIN_RADIX - 1));
+ assertThrows(NullPointerException.class, () -> Integer.parseUnsignedInt(null, 0, 1, 10));
+ }
+
+ @Test
+ public void testToUnsignedLong() {
+ for (int val : INT_VALUES) {
long ul = Integer.toUnsignedLong(val);
assertEquals(0, ul >>> Integer.BYTES * 8);
assertEquals(val, (int) ul);
}
}
+ @Test
public void testToUnsignedString() {
- int[] vals = {0, 1, 23, 456, 0x7fff_ffff, 0x8000_0000, 0xffff_ffff};
-
- for(int val : vals) {
+ for (int val : INT_VALUES) {
// Special radices
assertTrue(Integer.toUnsignedString(val, 2).equals(Integer.toBinaryString(val)));
assertTrue(Integer.toUnsignedString(val, 8).equals(Integer.toOctalString(val)));
assertTrue(Integer.toUnsignedString(val, 10).equals(Integer.toUnsignedString(val)));
assertTrue(Integer.toUnsignedString(val, 16).equals(Integer.toHexString(val)));
- for(int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; ++radix) {
- assertTrue(Integer.toUnsignedString(val, radix)
- .equals(Long.toString(Integer.toUnsignedLong(val), radix)));
+ for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; ++radix) {
+ assertTrue(
+ Integer.toUnsignedString(val, radix)
+ .equals(Long.toString(Integer.toUnsignedLong(val), radix)));
}
// Behavior is not defined by Java API specification if the radix falls outside of valid
// range, thus we don't test for such cases.
}
}
+
+ @Test
+ public void testParseUnsignedIntSubstringForBackports() {
+ // Rudimentary test to register coverage on older branches where we may see backports for
+ // OpenJDK 11 methods (b/191859202). NB using Integer_parseUnsignedInt rather than
+ // Integer.parseUnsignedInt.
+ assertEquals(
+ 0xaa55aa55,
+ Integer_parseUnsignedInt("left10101010010101011010101001010101right", 4, 36, 2));
+ assertEquals(8003, Integer_parseUnsignedInt("left17503right", 4, 9, 8));
+ assertEquals(0xffff_ffff, Integer_parseUnsignedInt("left4294967295right", 4, 14, 10));
+ assertEquals(0x1234_5678, Integer_parseUnsignedInt("lefty12345678righty", 5, 13, 16));
+ }
+
+ /**
+ * Parses an unsigned integer using a {@code MethodHandle} to invoke {@code
+ * Integer.parseUnsignedInt}.
+ *
+ * @param val the {@code CharSequence} to be parsed.
+ * @param start the starting index in {@code val}.
+ * @param end the ending ing index in {@code val}, exclusive.
+ * @param radix the radix to parse {@code val} with.
+ * @return the parsed unsigned integer.
+ */
+ private static int Integer_parseUnsignedInt(CharSequence val, int start, int end, int radix) {
+ try {
+ MethodType parseUnsignedIntType =
+ MethodType.methodType(
+ int.class, CharSequence.class, int.class, int.class, int.class);
+ MethodHandle parseUnsignedInt =
+ MethodHandles.lookup()
+ .findStatic(Integer.class, "parseUnsignedInt", parseUnsignedIntType);
+ return (int) parseUnsignedInt.invokeExact(val, start, end, radix);
+ } catch (IndexOutOfBoundsException | NullPointerException | NumberFormatException e) {
+ // Expected exceptions from the target method during the tests here.
+ throw e;
+ } catch (Throwable t) {
+ // Everything else.
+ throw new RuntimeException(t);
+ }
+ }
}
diff --git a/luni/src/test/java/libcore/java/security/spec/EdECPointTest.java b/luni/src/test/java/libcore/java/security/spec/EdECPointTest.java
new file mode 100644
index 0000000..95b3951
--- /dev/null
+++ b/luni/src/test/java/libcore/java/security/spec/EdECPointTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.java.security.spec;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigInteger;
+import java.security.spec.EdECPoint;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class EdECPointTest {
+
+ @Test
+ public void testConstructor() {
+ EdECPoint p = new EdECPoint(false, BigInteger.TEN);
+ assertFalse(p.isXOdd());
+ assertEquals(BigInteger.TEN, p.getY());
+
+ p = new EdECPoint(true, BigInteger.valueOf(Long.MAX_VALUE));
+ assertTrue(p.isXOdd());
+ assertEquals(BigInteger.valueOf(Long.MAX_VALUE), p.getY());
+ }
+}
diff --git a/luni/src/test/java/libcore/java/security/spec/EdECPrivateKeySpecTest.java b/luni/src/test/java/libcore/java/security/spec/EdECPrivateKeySpecTest.java
new file mode 100644
index 0000000..f5e0604
--- /dev/null
+++ b/luni/src/test/java/libcore/java/security/spec/EdECPrivateKeySpecTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.java.security.spec;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import java.security.spec.EdECPrivateKeySpec;
+import java.security.spec.NamedParameterSpec;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class EdECPrivateKeySpecTest {
+
+ @Test
+ public void testConstructor() {
+ byte[] bytes = new byte[] {9, 8, 7};
+ EdECPrivateKeySpec keySpec = new EdECPrivateKeySpec(NamedParameterSpec.ED448, bytes);
+ assertEquals(NamedParameterSpec.ED448, keySpec.getParams());
+ assertArrayEquals(bytes, keySpec.getBytes());
+
+ bytes = new byte[] {1, 3, 5, 7, 9};
+ keySpec = new EdECPrivateKeySpec(NamedParameterSpec.ED25519, bytes);
+ assertEquals(NamedParameterSpec.ED25519, keySpec.getParams());
+ assertArrayEquals(bytes, keySpec.getBytes());
+ }
+}
diff --git a/luni/src/test/java/libcore/java/security/spec/EdECPublicKeySpecTest.java b/luni/src/test/java/libcore/java/security/spec/EdECPublicKeySpecTest.java
new file mode 100644
index 0000000..cc58871
--- /dev/null
+++ b/luni/src/test/java/libcore/java/security/spec/EdECPublicKeySpecTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.java.security.spec;
+
+import static org.junit.Assert.assertEquals;
+
+import java.math.BigInteger;
+import java.security.spec.EdECPoint;
+import java.security.spec.EdECPublicKeySpec;
+import java.security.spec.NamedParameterSpec;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class EdECPublicKeySpecTest {
+
+ @Test
+ public void testConstructor() {
+ EdECPoint point = new EdECPoint(true, BigInteger.ONE);
+ EdECPublicKeySpec keySpec = new EdECPublicKeySpec(NamedParameterSpec.ED448, point);
+ assertEquals(NamedParameterSpec.ED448, keySpec.getParams());
+ assertEquals(point.isXOdd(), keySpec.getPoint().isXOdd());
+ assertEquals(point.getY(), keySpec.getPoint().getY());
+
+ point = new EdECPoint(false, BigInteger.TEN);
+ keySpec = new EdECPublicKeySpec(NamedParameterSpec.ED25519, point);
+ assertEquals(NamedParameterSpec.ED25519, keySpec.getParams());
+ assertEquals(point.isXOdd(), keySpec.getPoint().isXOdd());
+ assertEquals(point.getY(), keySpec.getPoint().getY());
+ }
+}
diff --git a/luni/src/test/java/libcore/java/security/spec/XECPrivateKeySpecTest.java b/luni/src/test/java/libcore/java/security/spec/XECPrivateKeySpecTest.java
new file mode 100644
index 0000000..64b84e1
--- /dev/null
+++ b/luni/src/test/java/libcore/java/security/spec/XECPrivateKeySpecTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.java.security.spec;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import java.security.spec.MGF1ParameterSpec;
+import java.security.spec.NamedParameterSpec;
+import java.security.spec.XECPrivateKeySpec;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class XECPrivateKeySpecTest {
+
+ @Test
+ public void testConstructor() {
+ byte[] scalar = new byte[] {9, 8, 7};
+ XECPrivateKeySpec keySpec = new XECPrivateKeySpec(NamedParameterSpec.X25519, scalar);
+ assertEquals(NamedParameterSpec.X25519, keySpec.getParams());
+ assertArrayEquals(scalar, keySpec.getScalar());
+
+ scalar = new byte[] {1, 3, 5, 7, 9};
+ keySpec = new XECPrivateKeySpec(MGF1ParameterSpec.SHA512, scalar);
+ assertEquals(MGF1ParameterSpec.SHA512, keySpec.getParams());
+ assertArrayEquals(scalar, keySpec.getScalar());
+ }
+}
diff --git a/luni/src/test/java/libcore/java/security/spec/XECPublicKeySpecTest.java b/luni/src/test/java/libcore/java/security/spec/XECPublicKeySpecTest.java
new file mode 100644
index 0000000..5d4f8b1
--- /dev/null
+++ b/luni/src/test/java/libcore/java/security/spec/XECPublicKeySpecTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.java.security.spec;
+
+import static org.junit.Assert.assertEquals;
+
+import java.math.BigInteger;
+import java.security.spec.MGF1ParameterSpec;
+import java.security.spec.NamedParameterSpec;
+import java.security.spec.XECPublicKeySpec;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class XECPublicKeySpecTest {
+
+ @Test
+ public void testConstructor() {
+ XECPublicKeySpec keySpec = new XECPublicKeySpec(NamedParameterSpec.X25519, BigInteger.TEN);
+ assertEquals(NamedParameterSpec.X25519, keySpec.getParams());
+ assertEquals(BigInteger.TEN, keySpec.getU());
+
+ keySpec = new XECPublicKeySpec(MGF1ParameterSpec.SHA512, BigInteger.ONE);
+ assertEquals(MGF1ParameterSpec.SHA512, keySpec.getParams());
+ assertEquals(BigInteger.ONE, keySpec.getU());
+ }
+}
diff --git a/luni/src/test/java/libcore/javax/xml/namespace/QNameTest.java b/luni/src/test/java/libcore/javax/xml/namespace/QNameTest.java
index 8214c11..b0afcae 100644
--- a/luni/src/test/java/libcore/javax/xml/namespace/QNameTest.java
+++ b/luni/src/test/java/libcore/javax/xml/namespace/QNameTest.java
@@ -27,6 +27,32 @@
assertEquals("hello", qName.getLocalPart());
}
+ public void testEquals() {
+ QName qName = new QName("namespace", "local part", "prefix");
+ assertTrue(qName.equals(qName));
+ assertFalse(qName.equals(null));
+ assertFalse(qName.equals(new Object()));
+
+ QName qNameSame = new QName("namespace", "local part", "prefix");
+ assertTrue(qName.equals(qNameSame));
+ assertTrue(qNameSame.equals(qName));
+
+ // Check the namespace is considered in equality considerations.
+ QName qNameDifferentNamespace = new QName("another namespace", "local part", "prefix");
+ assertFalse(qName.equals(qNameDifferentNamespace));
+ assertFalse(qNameDifferentNamespace.equals(qName));
+
+ // Check the local part is considered in equality considerations.
+ QName qNameDifferentLocalPart = new QName("namespace", "another local part", "prefix");
+ assertFalse(qName.equals(qNameDifferentLocalPart));
+ assertFalse(qNameDifferentLocalPart.equals(qName));
+
+ // Check the prefix is not considered in equality considerations.
+ QName qNameDifferentPrefix = new QName("namespace", "local part", "another prefix");
+ assertTrue(qName.equals(qNameDifferentPrefix));
+ assertTrue(qNameDifferentPrefix.equals(qName));
+ }
+
public void testGetNamespaceURI() {
QName qName = new QName("namespace", "local part", "prefix");
assertEquals("namespace", qName.getNamespaceURI());
diff --git a/luni/src/test/java/libcore/javax/xml/transform/TransformerConfigurationExceptionTest.java b/luni/src/test/java/libcore/javax/xml/transform/TransformerConfigurationExceptionTest.java
index c72af96..254a586 100644
--- a/luni/src/test/java/libcore/javax/xml/transform/TransformerConfigurationExceptionTest.java
+++ b/luni/src/test/java/libcore/javax/xml/transform/TransformerConfigurationExceptionTest.java
@@ -71,4 +71,12 @@
assertEquals("java.lang.Throwable", e.getMessage());
assertEquals(t, e.getCause());
}
+
+ @Test
+ public void constructorWithString() {
+ TransformerConfigurationException e = new TransformerConfigurationException("message");
+ assertEquals("message", e.getMessage());
+ assertNull(e.getCause());
+ assertNull(e.getLocator());
+ }
}
diff --git a/luni/src/test/java/libcore/javax/xml/transform/sax/SAXSourceTest.java b/luni/src/test/java/libcore/javax/xml/transform/sax/SAXSourceTest.java
index 9a35869..a032a36 100644
--- a/luni/src/test/java/libcore/javax/xml/transform/sax/SAXSourceTest.java
+++ b/luni/src/test/java/libcore/javax/xml/transform/sax/SAXSourceTest.java
@@ -17,10 +17,15 @@
package libcore.javax.xml.transform.sax;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import java.io.IOException;
+import java.io.StringReader;
+
+import javax.xml.transform.Source;
import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.stream.StreamSource;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -81,6 +86,32 @@
assertNull(source.getXMLReader());
}
+ @Test
+ public void sourceToInputSource() {
+ XMLReader reader = new XMLReaderImpl();
+ InputSource is = new InputSource();
+ source = new SAXSource(reader, is);
+ assertEquals(is, SAXSource.sourceToInputSource(source));
+
+ StreamSource ss = new StreamSource(new StringReader("<tag></tag>"));
+ assertNotNull(SAXSource.sourceToInputSource(ss));
+
+ assertNull(SAXSource.sourceToInputSource(new UnknownSource()));
+ assertNull(SAXSource.sourceToInputSource(null));
+ }
+
+ private static final class UnknownSource implements Source {
+ private String systemId;
+
+ public void setSystemId(String systemId) {
+ this.systemId = systemId;
+ }
+
+ public String getSystemId() {
+ return systemId;
+ }
+ }
+
private static final class XMLReaderImpl implements XMLReader {
@Override
diff --git a/luni/src/test/java/libcore/javax/xml/transform/stream/StreamResultTest.java b/luni/src/test/java/libcore/javax/xml/transform/stream/StreamResultTest.java
new file mode 100644
index 0000000..c4d3be4
--- /dev/null
+++ b/luni/src/test/java/libcore/javax/xml/transform/stream/StreamResultTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.javax.xml.transform.stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+
+import javax.xml.transform.stream.StreamResult;
+
+@RunWith(JUnit4.class)
+public class StreamResultTest {
+
+ @Test
+ public void constructor() {
+ StreamResult sr = new StreamResult();
+ assertNull(sr.getOutputStream());
+ assertNull(sr.getSystemId());
+ assertNull(sr.getWriter());
+ }
+
+ @Test
+ public void constructorWithFile() throws IOException {
+ final String PREFIX = "StreamResultTest52";
+ File file = File.createTempFile(PREFIX, null);
+ StreamResult sr = new StreamResult(file);
+ assertNull(sr.getOutputStream());
+ assertTrue(sr.getSystemId().contains(PREFIX));
+ assertNull(sr.getWriter());
+ if (file.exists()) {
+ file.delete();
+ }
+ }
+
+ @Test
+ public void constructorWithOutputStream() {
+ ByteArrayOutputStream os = new ByteArrayOutputStream(16);
+ StreamResult sr = new StreamResult(os);
+ assertEquals(os, sr.getOutputStream());
+ assertNull(sr.getSystemId());
+ assertNull(sr.getWriter());
+ }
+
+ @Test
+ public void constructorWithSystemId() {
+ final String ID = "System74";
+ StreamResult sr = new StreamResult(ID);
+ assertNull(sr.getOutputStream());
+ assertEquals(ID, sr.getSystemId());
+ assertNull(sr.getWriter());
+ }
+
+ @Test
+ public void constructorWithWriter() {
+ StringWriter sw = new StringWriter();
+ StreamResult sr = new StreamResult(sw);
+ assertNull(sr.getOutputStream());
+ assertNull(sr.getSystemId());
+ assertEquals(sw, sr.getWriter());
+ }
+
+ @Test
+ public void setOutputStream() {
+ StreamResult sr = new StreamResult();
+ ByteArrayOutputStream os = new ByteArrayOutputStream(16);
+ sr.setOutputStream(os);
+ assertEquals(os, sr.getOutputStream());
+ }
+
+ @Test
+ public void setSystemIdWithFile() throws IOException {
+ final String PREFIX = "StreamResultTest100";
+ StreamResult sr = new StreamResult();
+ File file = File.createTempFile(PREFIX, null);
+ sr.setSystemId(file);
+ assertTrue(sr.getSystemId().contains(PREFIX));
+ if (file.exists()) {
+ file.delete();
+ }
+ }
+
+ @Test
+ public void setSystemIdWithString() {
+ final String ID = "System112";
+ StreamResult sr = new StreamResult();
+ sr.setSystemId(ID);
+ assertEquals(ID, sr.getSystemId());
+ }
+
+ @Test
+ public void setWriter() {
+ StreamResult sr = new StreamResult();
+ StringWriter sw = new StringWriter();
+ sr.setWriter(sw);
+ assertEquals(sw, sr.getWriter());
+ }
+}
diff --git a/luni/src/test/java/libcore/javax/xml/transform/stream/StreamSourceTest.java b/luni/src/test/java/libcore/javax/xml/transform/stream/StreamSourceTest.java
new file mode 100644
index 0000000..58d8155
--- /dev/null
+++ b/luni/src/test/java/libcore/javax/xml/transform/stream/StreamSourceTest.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.javax.xml.transform.stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.File;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.io.StringReader;
+import javax.xml.transform.Result;
+import javax.xml.transform.stream.StreamSource;
+
+@RunWith(JUnit4.class)
+public class StreamSourceTest {
+
+ @Test
+ public void constructor() {
+ StreamSource ss = new StreamSource();
+ assertNull(ss.getInputStream());
+ assertNull(ss.getPublicId());
+ assertNull(ss.getReader());
+ assertNull(ss.getSystemId());
+ }
+
+ @Test
+ public void constructorWithFile() throws IOException {
+ final String PREFIX = "StreamSourceTest";
+ File file = File.createTempFile(PREFIX, null);
+ StreamSource ss = new StreamSource(file);
+ assertNull(ss.getInputStream());
+ assertNull(ss.getPublicId());
+ assertNull(ss.getReader());
+ assertTrue("SystemId is " + ss.getSystemId(), ss.getSystemId().contains(PREFIX));
+ if (file.exists()) {
+ file.delete();
+ }
+ }
+
+ @Test
+ public void constructorWithInputStreamAndSystemId() {
+ final String SYSTEM_ID = "System 65";
+ ByteArrayInputStream is = new ByteArrayInputStream(new byte[] { (byte) 0 });
+ StreamSource ss = new StreamSource(is, SYSTEM_ID);
+ assertEquals(is, ss.getInputStream());
+ assertNull(ss.getPublicId());
+ assertNull(ss.getReader());
+ assertEquals(SYSTEM_ID, ss.getSystemId());
+ }
+
+ @Test
+ public void constructorWithSystemId() {
+ final String SYSTEM_ID = "System 76";
+ StreamSource ss = new StreamSource(SYSTEM_ID);
+ assertNull(ss.getInputStream());
+ assertNull(ss.getPublicId());
+ assertNull(ss.getReader());
+ assertEquals(SYSTEM_ID, ss.getSystemId());
+ }
+
+ @Test
+ public void constructorWithReader() {
+ StringReader sr = new StringReader("House");
+ StreamSource ss = new StreamSource(sr);
+ assertNull(ss.getInputStream());
+ assertNull(ss.getPublicId());
+ assertEquals(sr, ss.getReader());
+ assertNull(ss.getSystemId());
+ }
+
+ @Test
+ public void constructorWithReaderAndSystemId() {
+ final String SYSTEM_ID = "System 96";
+ StringReader sr = new StringReader("House");
+ StreamSource ss = new StreamSource(sr, SYSTEM_ID);
+ assertNull(ss.getInputStream());
+ assertNull(ss.getPublicId());
+ assertEquals(sr, ss.getReader());
+ assertEquals(SYSTEM_ID, ss.getSystemId());
+ }
+
+ @Test
+ public void setInputStream() {
+ StreamSource ss = new StreamSource();
+ ByteArrayInputStream is = new ByteArrayInputStream(new byte[] {(byte) 0});
+ ss.setInputStream(is);
+ assertEquals(is, ss.getInputStream());
+ }
+
+ @Test
+ public void setReader() {
+ StreamSource ss = new StreamSource();
+ StringReader sr = new StringReader("Thirteen-twenty-one");
+ ss.setReader(sr);
+ assertEquals(sr, ss.getReader());
+ }
+
+ @Test
+ public void setPublicId() {
+ final String PUBLIC_ID = "Thirteen-twenty-three";
+ StreamSource ss = new StreamSource();
+ ss.setPublicId(PUBLIC_ID);
+ assertEquals(PUBLIC_ID, ss.getPublicId());
+ }
+
+ @Test
+ public void setSystemId() {
+ final String SYSTEM_ID = "Thirteen-twenty-four";
+ StreamSource ss = new StreamSource();
+ ss.setSystemId(SYSTEM_ID);
+ assertEquals(SYSTEM_ID, ss.getSystemId());
+ }
+
+ @Test
+ public void setSystemIdWithFile() throws IOException {
+ final String PREFIX = "StreamSourceTest100";
+ StreamSource ss = new StreamSource();
+ File file = File.createTempFile(PREFIX, null);
+ ss.setSystemId(file);
+ assertTrue(ss.getSystemId().contains(PREFIX));
+ if (file.exists()) {
+ file.delete();
+ }
+ }
+}
diff --git a/ojluni/src/main/java/java/nio/ByteBufferAs-X-Buffer.java.template b/ojluni/src/main/java/java/nio/ByteBufferAs-X-Buffer.java.template
new file mode 100644
index 0000000..dfa442e
--- /dev/null
+++ b/ojluni/src/main/java/java/nio/ByteBufferAs-X-Buffer.java.template
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#warn This file is preprocessed before being compiled
+
+package java.nio;
+
+import jdk.internal.misc.Unsafe;
+
+
+class ByteBufferAs$Type$Buffer$RW$$BO$ // package-private
+ extends {#if[ro]?ByteBufferAs}$Type$Buffer{#if[ro]?$BO$}
+{
+
+#if[rw]
+
+ protected final ByteBuffer bb;
+
+#end[rw]
+
+ ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb) { // package-private
+#if[rw]
+ super(-1, 0,
+ bb.remaining() >> $LG_BYTES_PER_VALUE$,
+ bb.remaining() >> $LG_BYTES_PER_VALUE$);
+ this.bb = bb;
+ // enforce limit == capacity
+ int cap = this.capacity();
+ this.limit(cap);
+ int pos = this.position();
+ assert (pos <= cap);
+ address = bb.address;
+#else[rw]
+ super(bb);
+#end[rw]
+ }
+
+ ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb,
+ int mark, int pos, int lim, int cap,
+ long addr)
+ {
+#if[rw]
+ super(mark, pos, lim, cap);
+ this.bb = bb;
+ address = addr;
+ assert address >= bb.address;
+#else[rw]
+ super(bb, mark, pos, lim, cap, addr);
+#end[rw]
+ }
+
+ @Override
+ Object base() {
+ return bb.hb;
+ }
+
+ public $Type$Buffer slice() {
+ int pos = this.position();
+ int lim = this.limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+ long addr = byteOffset(pos);
+ return new ByteBufferAs$Type$Buffer$RW$$BO$(bb, -1, 0, rem, rem, addr);
+ }
+
+ public $Type$Buffer duplicate() {
+ return new ByteBufferAs$Type$Buffer$RW$$BO$(bb,
+ this.markValue(),
+ this.position(),
+ this.limit(),
+ this.capacity(),
+ address);
+ }
+
+ public $Type$Buffer asReadOnlyBuffer() {
+#if[rw]
+ return new ByteBufferAs$Type$BufferR$BO$(bb,
+ this.markValue(),
+ this.position(),
+ this.limit(),
+ this.capacity(),
+ address);
+#else[rw]
+ return duplicate();
+#end[rw]
+ }
+
+#if[rw]
+
+ private int ix(int i) {
+ int off = (int) (address - bb.address);
+ return (i << $LG_BYTES_PER_VALUE$) + off;
+ }
+
+ protected long byteOffset(long i) {
+ return (i << $LG_BYTES_PER_VALUE$) + address;
+ }
+
+ public $type$ get() {
+ $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(nextGetIndex()),
+ {#if[boB]?true:false});
+ return $fromBits$(x);
+ }
+
+ public $type$ get(int i) {
+ $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(checkIndex(i)),
+ {#if[boB]?true:false});
+ return $fromBits$(x);
+ }
+
+#if[streamableType]
+ $type$ getUnchecked(int i) {
+ $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(i),
+ {#if[boB]?true:false});
+ return $fromBits$(x);
+ }
+#end[streamableType]
+
+#end[rw]
+
+ public $Type$Buffer put($type$ x) {
+#if[rw]
+ $memtype$ y = $toBits$(x);
+ UNSAFE.put$Memtype$Unaligned(bb.hb, byteOffset(nextPutIndex()), y,
+ {#if[boB]?true:false});
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer put(int i, $type$ x) {
+#if[rw]
+ $memtype$ y = $toBits$(x);
+ UNSAFE.put$Memtype$Unaligned(bb.hb, byteOffset(checkIndex(i)), y,
+ {#if[boB]?true:false});
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer compact() {
+#if[rw]
+ int pos = position();
+ int lim = limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+
+ ByteBuffer db = bb.duplicate();
+ db.limit(ix(lim));
+ db.position(ix(0));
+ ByteBuffer sb = db.slice();
+ sb.position(pos << $LG_BYTES_PER_VALUE$);
+ sb.compact();
+ position(rem);
+ limit(capacity());
+ discardMark();
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public boolean isDirect() {
+ return bb.isDirect();
+ }
+
+ public boolean isReadOnly() {
+ return {#if[rw]?false:true};
+ }
+
+#if[char]
+
+ public String toString(int start, int end) {
+ if ((end > limit()) || (start > end))
+ throw new IndexOutOfBoundsException();
+ try {
+ int len = end - start;
+ char[] ca = new char[len];
+ CharBuffer cb = CharBuffer.wrap(ca);
+ CharBuffer db = this.duplicate();
+ db.position(start);
+ db.limit(end);
+ cb.put(db);
+ return new String(ca);
+ } catch (StringIndexOutOfBoundsException x) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+
+
+ // --- Methods to support CharSequence ---
+
+ public CharBuffer subSequence(int start, int end) {
+ int pos = position();
+ int lim = limit();
+ assert (pos <= lim);
+ pos = (pos <= lim ? pos : lim);
+ int len = lim - pos;
+
+ if ((start < 0) || (end > len) || (start > end))
+ throw new IndexOutOfBoundsException();
+ return new ByteBufferAsCharBuffer$RW$$BO$(bb,
+ -1,
+ pos + start,
+ pos + end,
+ capacity(),
+ address);
+ }
+
+#end[char]
+
+
+ public ByteOrder order() {
+#if[boB]
+ return ByteOrder.BIG_ENDIAN;
+#end[boB]
+#if[boL]
+ return ByteOrder.LITTLE_ENDIAN;
+#end[boL]
+ }
+
+#if[char]
+ ByteOrder charRegionOrder() {
+ return order();
+ }
+#end[char]
+}
\ No newline at end of file
diff --git a/ojluni/src/main/java/java/nio/Direct-X-Buffer-bin.java.template b/ojluni/src/main/java/java/nio/Direct-X-Buffer-bin.java.template
new file mode 100644
index 0000000..8c75116
--- /dev/null
+++ b/ojluni/src/main/java/java/nio/Direct-X-Buffer-bin.java.template
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#warn This file is preprocessed before being compiled
+
+class XXX {
+
+#begin
+
+#if[rw]
+
+ private $type$ get$Type$(long a) {
+ try {
+ $memtype$ x = UNSAFE.get$Memtype$Unaligned(null, a, bigEndian);
+ return $fromBits$(x);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ }
+
+ public $type$ get$Type$() {
+ try {
+ return get$Type$(ix(nextGetIndex($BYTES_PER_VALUE$)));
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ }
+
+ public $type$ get$Type$(int i) {
+ try {
+ return get$Type$(ix(checkIndex(i, $BYTES_PER_VALUE$)));
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ }
+
+#end[rw]
+
+ private ByteBuffer put$Type$(long a, $type$ x) {
+#if[rw]
+ try {
+ $memtype$ y = $toBits$(x);
+ UNSAFE.put$Memtype$Unaligned(null, a, y, bigEndian);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public ByteBuffer put$Type$($type$ x) {
+#if[rw]
+ put$Type$(ix(nextPutIndex($BYTES_PER_VALUE$)), x);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public ByteBuffer put$Type$(int i, $type$ x) {
+#if[rw]
+ put$Type$(ix(checkIndex(i, $BYTES_PER_VALUE$)), x);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer as$Type$Buffer() {
+ int off = this.position();
+ int lim = this.limit();
+ assert (off <= lim);
+ int rem = (off <= lim ? lim - off : 0);
+
+ int size = rem >> $LG_BYTES_PER_VALUE$;
+ if (!UNALIGNED && ((address + off) % $BYTES_PER_VALUE$ != 0)) {
+ return (bigEndian
+ ? ($Type$Buffer)(new ByteBufferAs$Type$Buffer$RW$B(this,
+ -1,
+ 0,
+ size,
+ size,
+ address + off))
+ : ($Type$Buffer)(new ByteBufferAs$Type$Buffer$RW$L(this,
+ -1,
+ 0,
+ size,
+ size,
+ address + off)));
+ } else {
+ return (nativeByteOrder
+ ? ($Type$Buffer)(new Direct$Type$Buffer$RW$U(this,
+ -1,
+ 0,
+ size,
+ size,
+ off))
+ : ($Type$Buffer)(new Direct$Type$Buffer$RW$S(this,
+ -1,
+ 0,
+ size,
+ size,
+ off)));
+ }
+ }
+
+#end
+
+}
\ No newline at end of file
diff --git a/ojluni/src/main/java/java/nio/Direct-X-Buffer.java.template b/ojluni/src/main/java/java/nio/Direct-X-Buffer.java.template
new file mode 100644
index 0000000..7f7e0f1
--- /dev/null
+++ b/ojluni/src/main/java/java/nio/Direct-X-Buffer.java.template
@@ -0,0 +1,544 @@
+/*
+ * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#warn This file is preprocessed before being compiled
+
+package java.nio;
+
+import java.io.FileDescriptor;
+import java.lang.ref.Reference;
+import jdk.internal.misc.VM;
+import jdk.internal.ref.Cleaner;
+import sun.nio.ch.DirectBuffer;
+
+
+class Direct$Type$Buffer$RW$$BO$
+#if[rw]
+ extends {#if[byte]?Mapped$Type$Buffer:$Type$Buffer}
+#else[rw]
+ extends Direct$Type$Buffer$BO$
+#end[rw]
+ implements DirectBuffer
+{
+
+#if[rw]
+
+ // Cached array base offset
+ private static final long ARRAY_BASE_OFFSET = UNSAFE.arrayBaseOffset($type$[].class);
+
+ // Cached unaligned-access capability
+ protected static final boolean UNALIGNED = Bits.unaligned();
+
+ // Base address, used in all indexing calculations
+ // NOTE: moved up to Buffer.java for speed in JNI GetDirectBufferAddress
+ // protected long address;
+
+ // An object attached to this buffer. If this buffer is a view of another
+ // buffer then we use this field to keep a reference to that buffer to
+ // ensure that its memory isn't freed before we are done with it.
+ private final Object att;
+
+ public Object attachment() {
+ return att;
+ }
+
+#if[byte]
+
+ private static class Deallocator
+ implements Runnable
+ {
+
+ private long address;
+ private long size;
+ private int capacity;
+
+ private Deallocator(long address, long size, int capacity) {
+ assert (address != 0);
+ this.address = address;
+ this.size = size;
+ this.capacity = capacity;
+ }
+
+ public void run() {
+ if (address == 0) {
+ // Paranoia
+ return;
+ }
+ UNSAFE.freeMemory(address);
+ address = 0;
+ Bits.unreserveMemory(size, capacity);
+ }
+
+ }
+
+ private final Cleaner cleaner;
+
+ public Cleaner cleaner() { return cleaner; }
+
+#else[byte]
+
+ public Cleaner cleaner() { return null; }
+
+#end[byte]
+
+#end[rw]
+
+#if[byte]
+
+ // Primary constructor
+ //
+ Direct$Type$Buffer$RW$(int cap) { // package-private
+#if[rw]
+ super(-1, 0, cap, cap);
+ boolean pa = VM.isDirectMemoryPageAligned();
+ int ps = Bits.pageSize();
+ long size = Math.max(1L, (long)cap + (pa ? ps : 0));
+ Bits.reserveMemory(size, cap);
+
+ long base = 0;
+ try {
+ base = UNSAFE.allocateMemory(size);
+ } catch (OutOfMemoryError x) {
+ Bits.unreserveMemory(size, cap);
+ throw x;
+ }
+ UNSAFE.setMemory(base, size, (byte) 0);
+ if (pa && (base % ps != 0)) {
+ // Round up to page boundary
+ address = base + ps - (base & (ps - 1));
+ } else {
+ address = base;
+ }
+ cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
+ att = null;
+#else[rw]
+ super(cap);
+ this.isReadOnly = true;
+#end[rw]
+ }
+
+#if[rw]
+
+ // Invoked to construct a direct ByteBuffer referring to the block of
+ // memory. A given arbitrary object may also be attached to the buffer.
+ //
+ Direct$Type$Buffer(long addr, int cap, Object ob) {
+ super(-1, 0, cap, cap);
+ address = addr;
+ cleaner = null;
+ att = ob;
+ }
+
+
+ // Invoked only by JNI: NewDirectByteBuffer(void*, long)
+ //
+ private Direct$Type$Buffer(long addr, int cap) {
+ super(-1, 0, cap, cap);
+ address = addr;
+ cleaner = null;
+ att = null;
+ }
+
+#end[rw]
+
+ // For memory-mapped buffers -- invoked by FileChannelImpl via reflection
+ //
+ protected Direct$Type$Buffer$RW$(int cap, long addr,
+ FileDescriptor fd,
+ Runnable unmapper)
+ {
+#if[rw]
+ super(-1, 0, cap, cap, fd);
+ address = addr;
+ cleaner = Cleaner.create(this, unmapper);
+ att = null;
+#else[rw]
+ super(cap, addr, fd, unmapper);
+ this.isReadOnly = true;
+#end[rw]
+ }
+
+#end[byte]
+
+ // For duplicates and slices
+ //
+ Direct$Type$Buffer$RW$$BO$(DirectBuffer db, // package-private
+ int mark, int pos, int lim, int cap,
+ int off)
+ {
+#if[rw]
+ super(mark, pos, lim, cap);
+ address = db.address() + off;
+#if[byte]
+ cleaner = null;
+#end[byte]
+ att = db;
+#else[rw]
+ super(db, mark, pos, lim, cap, off);
+ this.isReadOnly = true;
+#end[rw]
+ }
+
+ @Override
+ Object base() {
+ return null;
+ }
+
+ public $Type$Buffer slice() {
+ int pos = this.position();
+ int lim = this.limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+ int off = (pos << $LG_BYTES_PER_VALUE$);
+ assert (off >= 0);
+ return new Direct$Type$Buffer$RW$$BO$(this, -1, 0, rem, rem, off);
+ }
+
+#if[byte]
+ public $Type$Buffer slice(int pos, int lim) {
+ assert (pos >= 0);
+ assert (pos <= lim);
+ int rem = lim - pos;
+ return new Direct$Type$Buffer$RW$$BO$(this, -1, 0, rem, rem, pos);
+ }
+#end[byte]
+
+ public $Type$Buffer duplicate() {
+ return new Direct$Type$Buffer$RW$$BO$(this,
+ this.markValue(),
+ this.position(),
+ this.limit(),
+ this.capacity(),
+ 0);
+ }
+
+ public $Type$Buffer asReadOnlyBuffer() {
+#if[rw]
+ return new Direct$Type$BufferR$BO$(this,
+ this.markValue(),
+ this.position(),
+ this.limit(),
+ this.capacity(),
+ 0);
+#else[rw]
+ return duplicate();
+#end[rw]
+ }
+
+#if[rw]
+
+ public long address() {
+ return address;
+ }
+
+ private long ix(int i) {
+ return address + ((long)i << $LG_BYTES_PER_VALUE$);
+ }
+
+ public $type$ get() {
+ try {
+ return $fromBits$($swap$(UNSAFE.get$Swaptype$(ix(nextGetIndex()))));
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ }
+
+ public $type$ get(int i) {
+ try {
+ return $fromBits$($swap$(UNSAFE.get$Swaptype$(ix(checkIndex(i)))));
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ }
+
+#if[streamableType]
+ $type$ getUnchecked(int i) {
+ try {
+ return $fromBits$($swap$(UNSAFE.get$Swaptype$(ix(i))));
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ }
+#end[streamableType]
+
+ public $Type$Buffer get($type$[] dst, int offset, int length) {
+#if[rw]
+ if (((long)length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
+ checkBounds(offset, length, dst.length);
+ int pos = position();
+ int lim = limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+ if (length > rem)
+ throw new BufferUnderflowException();
+
+ long dstOffset = ARRAY_BASE_OFFSET + ((long)offset << $LG_BYTES_PER_VALUE$);
+ try {
+#if[!byte]
+ if (order() != ByteOrder.nativeOrder())
+ UNSAFE.copySwapMemory(null,
+ ix(pos),
+ dst,
+ dstOffset,
+ (long)length << $LG_BYTES_PER_VALUE$,
+ (long)1 << $LG_BYTES_PER_VALUE$);
+ else
+#end[!byte]
+ UNSAFE.copyMemory(null,
+ ix(pos),
+ dst,
+ dstOffset,
+ (long)length << $LG_BYTES_PER_VALUE$);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ position(pos + length);
+ } else {
+ super.get(dst, offset, length);
+ }
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+#end[rw]
+
+ public $Type$Buffer put($type$ x) {
+#if[rw]
+ try {
+ UNSAFE.put$Swaptype$(ix(nextPutIndex()), $swap$($toBits$(x)));
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer put(int i, $type$ x) {
+#if[rw]
+ try {
+ UNSAFE.put$Swaptype$(ix(checkIndex(i)), $swap$($toBits$(x)));
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer put($Type$Buffer src) {
+#if[rw]
+ if (src instanceof Direct$Type$Buffer$BO$) {
+ if (src == this)
+ throw createSameBufferException();
+ Direct$Type$Buffer$RW$$BO$ sb = (Direct$Type$Buffer$RW$$BO$)src;
+
+ int spos = sb.position();
+ int slim = sb.limit();
+ assert (spos <= slim);
+ int srem = (spos <= slim ? slim - spos : 0);
+
+ int pos = position();
+ int lim = limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+
+ if (srem > rem)
+ throw new BufferOverflowException();
+ try {
+ UNSAFE.copyMemory(sb.ix(spos), ix(pos), (long)srem << $LG_BYTES_PER_VALUE$);
+ } finally {
+ Reference.reachabilityFence(sb);
+ Reference.reachabilityFence(this);
+ }
+ sb.position(spos + srem);
+ position(pos + srem);
+ } else if (src.hb != null) {
+
+ int spos = src.position();
+ int slim = src.limit();
+ assert (spos <= slim);
+ int srem = (spos <= slim ? slim - spos : 0);
+
+ put(src.hb, src.offset + spos, srem);
+ src.position(spos + srem);
+
+ } else {
+ super.put(src);
+ }
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer put($type$[] src, int offset, int length) {
+#if[rw]
+ if (((long)length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
+ checkBounds(offset, length, src.length);
+ int pos = position();
+ int lim = limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+ if (length > rem)
+ throw new BufferOverflowException();
+
+ long srcOffset = ARRAY_BASE_OFFSET + ((long)offset << $LG_BYTES_PER_VALUE$);
+ try {
+#if[!byte]
+ if (order() != ByteOrder.nativeOrder())
+ UNSAFE.copySwapMemory(src,
+ srcOffset,
+ null,
+ ix(pos),
+ (long)length << $LG_BYTES_PER_VALUE$,
+ (long)1 << $LG_BYTES_PER_VALUE$);
+ else
+#end[!byte]
+ UNSAFE.copyMemory(src,
+ srcOffset,
+ null,
+ ix(pos),
+ (long)length << $LG_BYTES_PER_VALUE$);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ position(pos + length);
+ } else {
+ super.put(src, offset, length);
+ }
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer compact() {
+#if[rw]
+ int pos = position();
+ int lim = limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+ try {
+ UNSAFE.copyMemory(ix(pos), ix(0), (long)rem << $LG_BYTES_PER_VALUE$);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ position(rem);
+ limit(capacity());
+ discardMark();
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public boolean isDirect() {
+ return true;
+ }
+
+ public boolean isReadOnly() {
+ return {#if[rw]?false:true};
+ }
+
+
+#if[char]
+
+ public String toString(int start, int end) {
+ if ((end > limit()) || (start > end))
+ throw new IndexOutOfBoundsException();
+ try {
+ int len = end - start;
+ char[] ca = new char[len];
+ CharBuffer cb = CharBuffer.wrap(ca);
+ CharBuffer db = this.duplicate();
+ db.position(start);
+ db.limit(end);
+ cb.put(db);
+ return new String(ca);
+ } catch (StringIndexOutOfBoundsException x) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+
+
+ // --- Methods to support CharSequence ---
+
+ public CharBuffer subSequence(int start, int end) {
+ int pos = position();
+ int lim = limit();
+ assert (pos <= lim);
+ pos = (pos <= lim ? pos : lim);
+ int len = lim - pos;
+
+ if ((start < 0) || (end > len) || (start > end))
+ throw new IndexOutOfBoundsException();
+ return new DirectCharBuffer$RW$$BO$(this,
+ -1,
+ pos + start,
+ pos + end,
+ capacity(),
+ offset);
+ }
+
+#end[char]
+
+
+
+#if[!byte]
+
+ public ByteOrder order() {
+#if[boS]
+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
+#end[boS]
+#if[boU]
+ return ((ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN)
+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
+#end[boU]
+ }
+
+#end[!byte]
+
+#if[char]
+ ByteOrder charRegionOrder() {
+ return order();
+ }
+#end[char]
+
+
+#if[byte]
+ // #BIN
+ //
+ // Binary-data access methods for short, char, int, long, float,
+ // and double will be inserted here
+
+#end[byte]
+
+}
\ No newline at end of file
diff --git a/ojluni/src/main/java/java/nio/Heap-X-Buffer.java.template b/ojluni/src/main/java/java/nio/Heap-X-Buffer.java.template
new file mode 100644
index 0000000..6304292
--- /dev/null
+++ b/ojluni/src/main/java/java/nio/Heap-X-Buffer.java.template
@@ -0,0 +1,640 @@
+/*
+ * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#warn This file is preprocessed before being compiled
+
+package java.nio;
+
+/**
+#if[rw]
+ * A read/write Heap$Type$Buffer.
+#else[rw]
+ * A read-only Heap$Type$Buffer. This class extends the corresponding
+ * read/write class, overriding the mutation methods to throw a {@link
+ * ReadOnlyBufferException} and overriding the view-buffer methods to return an
+ * instance of this class rather than of the superclass.
+#end[rw]
+ */
+
+class Heap$Type$Buffer$RW$
+ extends {#if[ro]?Heap}$Type$Buffer
+{
+ // Cached array base offset
+ private static final long ARRAY_BASE_OFFSET = UNSAFE.arrayBaseOffset($type$[].class);
+
+ // Cached array base offset
+ private static final long ARRAY_INDEX_SCALE = UNSAFE.arrayIndexScale($type$[].class);
+
+ // For speed these fields are actually declared in X-Buffer;
+ // these declarations are here as documentation
+ /*
+#if[rw]
+ protected final $type$[] hb;
+ protected final int offset;
+#end[rw]
+ */
+
+ Heap$Type$Buffer$RW$(int cap, int lim) { // package-private
+#if[rw]
+ super(-1, 0, lim, cap, new $type$[cap], 0);
+ /*
+ hb = new $type$[cap];
+ offset = 0;
+ */
+ this.address = ARRAY_BASE_OFFSET;
+#else[rw]
+ super(cap, lim);
+ this.isReadOnly = true;
+#end[rw]
+ }
+
+ Heap$Type$Buffer$RW$($type$[] buf, int off, int len) { // package-private
+#if[rw]
+ super(-1, off, off + len, buf.length, buf, 0);
+ /*
+ hb = buf;
+ offset = 0;
+ */
+ this.address = ARRAY_BASE_OFFSET;
+#else[rw]
+ super(buf, off, len);
+ this.isReadOnly = true;
+#end[rw]
+ }
+
+ protected Heap$Type$Buffer$RW$($type$[] buf,
+ int mark, int pos, int lim, int cap,
+ int off)
+ {
+#if[rw]
+ super(mark, pos, lim, cap, buf, off);
+ /*
+ hb = buf;
+ offset = off;
+ */
+ this.address = ARRAY_BASE_OFFSET + off * ARRAY_INDEX_SCALE;
+#else[rw]
+ super(buf, mark, pos, lim, cap, off);
+ this.isReadOnly = true;
+#end[rw]
+ }
+
+ public $Type$Buffer slice() {
+ return new Heap$Type$Buffer$RW$(hb,
+ -1,
+ 0,
+ this.remaining(),
+ this.remaining(),
+ this.position() + offset);
+ }
+
+#if[byte]
+ $Type$Buffer slice(int pos, int lim) {
+ assert (pos >= 0);
+ assert (pos <= lim);
+ int rem = lim - pos;
+ return new Heap$Type$Buffer$RW$(hb,
+ -1,
+ 0,
+ rem,
+ rem,
+ pos + offset);
+ }
+#end[byte]
+
+ public $Type$Buffer duplicate() {
+ return new Heap$Type$Buffer$RW$(hb,
+ this.markValue(),
+ this.position(),
+ this.limit(),
+ this.capacity(),
+ offset);
+ }
+
+ public $Type$Buffer asReadOnlyBuffer() {
+#if[rw]
+ return new Heap$Type$BufferR(hb,
+ this.markValue(),
+ this.position(),
+ this.limit(),
+ this.capacity(),
+ offset);
+#else[rw]
+ return duplicate();
+#end[rw]
+ }
+
+#if[rw]
+
+ protected int ix(int i) {
+ return i + offset;
+ }
+
+#if[byte]
+ private long byteOffset(long i) {
+ return address + i;
+ }
+#end[byte]
+
+ public $type$ get() {
+ return hb[ix(nextGetIndex())];
+ }
+
+ public $type$ get(int i) {
+ return hb[ix(checkIndex(i))];
+ }
+
+#if[streamableType]
+ $type$ getUnchecked(int i) {
+ return hb[ix(i)];
+ }
+#end[streamableType]
+
+ public $Type$Buffer get($type$[] dst, int offset, int length) {
+ checkBounds(offset, length, dst.length);
+ if (length > remaining())
+ throw new BufferUnderflowException();
+ System.arraycopy(hb, ix(position()), dst, offset, length);
+ position(position() + length);
+ return this;
+ }
+
+ public boolean isDirect() {
+ return false;
+ }
+
+#end[rw]
+
+ public boolean isReadOnly() {
+ return {#if[rw]?false:true};
+ }
+
+ public $Type$Buffer put($type$ x) {
+#if[rw]
+ hb[ix(nextPutIndex())] = x;
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer put(int i, $type$ x) {
+#if[rw]
+ hb[ix(checkIndex(i))] = x;
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer put($type$[] src, int offset, int length) {
+#if[rw]
+ checkBounds(offset, length, src.length);
+ if (length > remaining())
+ throw new BufferOverflowException();
+ System.arraycopy(src, offset, hb, ix(position()), length);
+ position(position() + length);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer put($Type$Buffer src) {
+#if[rw]
+ if (src instanceof Heap$Type$Buffer) {
+ if (src == this)
+ throw createSameBufferException();
+ Heap$Type$Buffer sb = (Heap$Type$Buffer)src;
+ int n = sb.remaining();
+ if (n > remaining())
+ throw new BufferOverflowException();
+ System.arraycopy(sb.hb, sb.ix(sb.position()),
+ hb, ix(position()), n);
+ sb.position(sb.position() + n);
+ position(position() + n);
+ } else if (src.isDirect()) {
+ int n = src.remaining();
+ if (n > remaining())
+ throw new BufferOverflowException();
+ src.get(hb, ix(position()), n);
+ position(position() + n);
+ } else {
+ super.put(src);
+ }
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer compact() {
+#if[rw]
+ System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
+ position(remaining());
+ limit(capacity());
+ discardMark();
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+
+
+#if[byte]
+
+ byte _get(int i) { // package-private
+ return hb[i];
+ }
+
+ void _put(int i, byte b) { // package-private
+#if[rw]
+ hb[i] = b;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ // char
+
+#if[rw]
+
+ public char getChar() {
+ return UNSAFE.getCharUnaligned(hb, byteOffset(nextGetIndex(2)), bigEndian);
+ }
+
+ public char getChar(int i) {
+ return UNSAFE.getCharUnaligned(hb, byteOffset(checkIndex(i, 2)), bigEndian);
+ }
+
+#end[rw]
+
+ public $Type$Buffer putChar(char x) {
+#if[rw]
+ UNSAFE.putCharUnaligned(hb, byteOffset(nextPutIndex(2)), x, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer putChar(int i, char x) {
+#if[rw]
+ UNSAFE.putCharUnaligned(hb, byteOffset(checkIndex(i, 2)), x, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public CharBuffer asCharBuffer() {
+ int size = this.remaining() >> 1;
+ long addr = address + position();
+ return (bigEndian
+ ? (CharBuffer)(new ByteBufferAsCharBuffer$RW$B(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr))
+ : (CharBuffer)(new ByteBufferAsCharBuffer$RW$L(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr)));
+ }
+
+
+ // short
+
+#if[rw]
+
+ public short getShort() {
+ return UNSAFE.getShortUnaligned(hb, byteOffset(nextGetIndex(2)), bigEndian);
+ }
+
+ public short getShort(int i) {
+ return UNSAFE.getShortUnaligned(hb, byteOffset(checkIndex(i, 2)), bigEndian);
+ }
+
+#end[rw]
+
+ public $Type$Buffer putShort(short x) {
+#if[rw]
+ UNSAFE.putShortUnaligned(hb, byteOffset(nextPutIndex(2)), x, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer putShort(int i, short x) {
+#if[rw]
+ UNSAFE.putShortUnaligned(hb, byteOffset(checkIndex(i, 2)), x, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public ShortBuffer asShortBuffer() {
+ int size = this.remaining() >> 1;
+ long addr = address + position();
+ return (bigEndian
+ ? (ShortBuffer)(new ByteBufferAsShortBuffer$RW$B(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr))
+ : (ShortBuffer)(new ByteBufferAsShortBuffer$RW$L(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr)));
+ }
+
+
+ // int
+
+#if[rw]
+
+ public int getInt() {
+ return UNSAFE.getIntUnaligned(hb, byteOffset(nextGetIndex(4)), bigEndian);
+ }
+
+ public int getInt(int i) {
+ return UNSAFE.getIntUnaligned(hb, byteOffset(checkIndex(i, 4)), bigEndian);
+ }
+
+#end[rw]
+
+ public $Type$Buffer putInt(int x) {
+#if[rw]
+ UNSAFE.putIntUnaligned(hb, byteOffset(nextPutIndex(4)), x, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer putInt(int i, int x) {
+#if[rw]
+ UNSAFE.putIntUnaligned(hb, byteOffset(checkIndex(i, 4)), x, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public IntBuffer asIntBuffer() {
+ int size = this.remaining() >> 2;
+ long addr = address + position();
+ return (bigEndian
+ ? (IntBuffer)(new ByteBufferAsIntBuffer$RW$B(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr))
+ : (IntBuffer)(new ByteBufferAsIntBuffer$RW$L(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr)));
+ }
+
+
+ // long
+
+#if[rw]
+
+ public long getLong() {
+ return UNSAFE.getLongUnaligned(hb, byteOffset(nextGetIndex(8)), bigEndian);
+ }
+
+ public long getLong(int i) {
+ return UNSAFE.getLongUnaligned(hb, byteOffset(checkIndex(i, 8)), bigEndian);
+ }
+
+#end[rw]
+
+ public $Type$Buffer putLong(long x) {
+#if[rw]
+ UNSAFE.putLongUnaligned(hb, byteOffset(nextPutIndex(8)), x, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer putLong(int i, long x) {
+#if[rw]
+ UNSAFE.putLongUnaligned(hb, byteOffset(checkIndex(i, 8)), x, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public LongBuffer asLongBuffer() {
+ int size = this.remaining() >> 3;
+ long addr = address + position();
+ return (bigEndian
+ ? (LongBuffer)(new ByteBufferAsLongBuffer$RW$B(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr))
+ : (LongBuffer)(new ByteBufferAsLongBuffer$RW$L(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr)));
+ }
+
+
+ // float
+
+#if[rw]
+
+ public float getFloat() {
+ int x = UNSAFE.getIntUnaligned(hb, byteOffset(nextGetIndex(4)), bigEndian);
+ return Float.intBitsToFloat(x);
+ }
+
+ public float getFloat(int i) {
+ int x = UNSAFE.getIntUnaligned(hb, byteOffset(checkIndex(i, 4)), bigEndian);
+ return Float.intBitsToFloat(x);
+ }
+
+#end[rw]
+
+ public $Type$Buffer putFloat(float x) {
+#if[rw]
+ int y = Float.floatToRawIntBits(x);
+ UNSAFE.putIntUnaligned(hb, byteOffset(nextPutIndex(4)), y, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer putFloat(int i, float x) {
+#if[rw]
+ int y = Float.floatToRawIntBits(x);
+ UNSAFE.putIntUnaligned(hb, byteOffset(checkIndex(i, 4)), y, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public FloatBuffer asFloatBuffer() {
+ int size = this.remaining() >> 2;
+ long addr = address + position();
+ return (bigEndian
+ ? (FloatBuffer)(new ByteBufferAsFloatBuffer$RW$B(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr))
+ : (FloatBuffer)(new ByteBufferAsFloatBuffer$RW$L(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr)));
+ }
+
+
+ // double
+
+#if[rw]
+
+ public double getDouble() {
+ long x = UNSAFE.getLongUnaligned(hb, byteOffset(nextGetIndex(8)), bigEndian);
+ return Double.longBitsToDouble(x);
+ }
+
+ public double getDouble(int i) {
+ long x = UNSAFE.getLongUnaligned(hb, byteOffset(checkIndex(i, 8)), bigEndian);
+ return Double.longBitsToDouble(x);
+ }
+
+#end[rw]
+
+ public $Type$Buffer putDouble(double x) {
+#if[rw]
+ long y = Double.doubleToRawLongBits(x);
+ UNSAFE.putLongUnaligned(hb, byteOffset(nextPutIndex(8)), y, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public $Type$Buffer putDouble(int i, double x) {
+#if[rw]
+ long y = Double.doubleToRawLongBits(x);
+ UNSAFE.putLongUnaligned(hb, byteOffset(checkIndex(i, 8)), y, bigEndian);
+ return this;
+#else[rw]
+ throw new ReadOnlyBufferException();
+#end[rw]
+ }
+
+ public DoubleBuffer asDoubleBuffer() {
+ int size = this.remaining() >> 3;
+ long addr = address + position();
+ return (bigEndian
+ ? (DoubleBuffer)(new ByteBufferAsDoubleBuffer$RW$B(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr))
+ : (DoubleBuffer)(new ByteBufferAsDoubleBuffer$RW$L(this,
+ -1,
+ 0,
+ size,
+ size,
+ addr)));
+ }
+
+
+#end[byte]
+
+
+#if[char]
+
+ String toString(int start, int end) { // package-private
+ try {
+ return new String(hb, start + offset, end - start);
+ } catch (StringIndexOutOfBoundsException x) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+
+
+ // --- Methods to support CharSequence ---
+
+ public CharBuffer subSequence(int start, int end) {
+ if ((start < 0)
+ || (end > length())
+ || (start > end))
+ throw new IndexOutOfBoundsException();
+ int pos = position();
+ return new HeapCharBuffer$RW$(hb,
+ -1,
+ pos + start,
+ pos + end,
+ capacity(),
+ offset);
+ }
+
+#end[char]
+
+
+#if[!byte]
+
+ public ByteOrder order() {
+ return ByteOrder.nativeOrder();
+ }
+#end[!byte]
+#if[char]
+
+ ByteOrder charRegionOrder() {
+ return order();
+ }
+#end[char]
+}
\ No newline at end of file
diff --git a/ojluni/src/main/java/java/nio/X-Buffer-bin.java.template b/ojluni/src/main/java/java/nio/X-Buffer-bin.java.template
new file mode 100644
index 0000000..490f165
--- /dev/null
+++ b/ojluni/src/main/java/java/nio/X-Buffer-bin.java.template
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#warn This file is preprocessed before being compiled
+
+class XXX {
+
+#begin
+
+ /**
+ * Relative <i>get</i> method for reading $a$ $type$ value.
+ *
+ * <p> Reads the next $nbytes$ bytes at this buffer's current position,
+ * composing them into $a$ $type$ value according to the current byte order,
+ * and then increments the position by $nbytes$. </p>
+ *
+ * @return The $type$ value at the buffer's current position
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than $nbytes$ bytes
+ * remaining in this buffer
+ */
+ public abstract $type$ get$Type$();
+
+ /**
+ * Relative <i>put</i> method for writing $a$ $type$
+ * value <i>(optional operation)</i>.
+ *
+ * <p> Writes $nbytes$ bytes containing the given $type$ value, in the
+ * current byte order, into this buffer at the current position, and then
+ * increments the position by $nbytes$. </p>
+ *
+ * @param value
+ * The $type$ value to be written
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there are fewer than $nbytes$ bytes
+ * remaining in this buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public abstract ByteBuffer put$Type$($type$ value);
+
+ /**
+ * Absolute <i>get</i> method for reading $a$ $type$ value.
+ *
+ * <p> Reads $nbytes$ bytes at the given index, composing them into a
+ * $type$ value according to the current byte order. </p>
+ *
+ * @param index
+ * The index from which the bytes will be read
+ *
+ * @return The $type$ value at the given index
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative
+ * or not smaller than the buffer's limit,
+ * minus $nbytesButOne$
+ */
+ public abstract $type$ get$Type$(int index);
+
+ /**
+ * Absolute <i>put</i> method for writing $a$ $type$
+ * value <i>(optional operation)</i>.
+ *
+ * <p> Writes $nbytes$ bytes containing the given $type$ value, in the
+ * current byte order, into this buffer at the given index. </p>
+ *
+ * @param index
+ * The index at which the bytes will be written
+ *
+ * @param value
+ * The $type$ value to be written
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative
+ * or not smaller than the buffer's limit,
+ * minus $nbytesButOne$
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public abstract ByteBuffer put$Type$(int index, $type$ value);
+
+ /**
+ * Creates a view of this byte buffer as $a$ $type$ buffer.
+ *
+ * <p> The content of the new buffer will start at this buffer's current
+ * position. Changes to this buffer's content will be visible in the new
+ * buffer, and vice versa; the two buffers' position, limit, and mark
+ * values will be independent.
+ *
+ * <p> The new buffer's position will be zero, its capacity and its limit
+ * will be the number of bytes remaining in this buffer divided by
+ * $nbytes$, its mark will be undefined, and its byte order will be that
+ * of the byte buffer at the moment the view is created. The new buffer
+ * will be direct if, and only if, this buffer is direct, and it will be
+ * read-only if, and only if, this buffer is read-only. </p>
+ *
+ * @return A new $type$ buffer
+ */
+ public abstract $Type$Buffer as$Type$Buffer();
+
+#end
+
+}
\ No newline at end of file
diff --git a/ojluni/src/main/java/java/nio/X-Buffer.java.template b/ojluni/src/main/java/java/nio/X-Buffer.java.template
new file mode 100644
index 0000000..888e5fa
--- /dev/null
+++ b/ojluni/src/main/java/java/nio/X-Buffer.java.template
@@ -0,0 +1,1803 @@
+/*
+ * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#warn This file is preprocessed before being compiled
+
+package java.nio;
+
+#if[char]
+import java.io.IOException;
+#end[char]
+#if[streamableType]
+import java.util.Spliterator;
+import java.util.stream.StreamSupport;
+import java.util.stream.$Streamtype$Stream;
+#end[streamableType]
+
+import jdk.internal.util.ArraysSupport;
+
+/**
+ * $A$ $type$ buffer.
+ *
+ * <p> This class defines {#if[byte]?six:four} categories of operations upon
+ * $type$ buffers:
+ *
+ * <ul>
+ *
+ * <li><p> Absolute and relative {@link #get() <i>get</i>} and
+ * {@link #put($type$) <i>put</i>} methods that read and write
+ * single $type$s; </p></li>
+ *
+ * <li><p> Relative {@link #get($type$[]) <i>bulk get</i>}
+ * methods that transfer contiguous sequences of $type$s from this buffer
+ * into an array; {#if[!byte]?and}</p></li>
+ *
+ * <li><p> Relative {@link #put($type$[]) <i>bulk put</i>}
+ * methods that transfer contiguous sequences of $type$s from $a$
+ * $type$ array{#if[char]?, a string,} or some other $type$
+ * buffer into this buffer;{#if[!byte]? and} </p></li>
+ *
+#if[byte]
+ *
+ * <li><p> Absolute and relative {@link #getChar() <i>get</i>}
+ * and {@link #putChar(char) <i>put</i>} methods that read and
+ * write values of other primitive types, translating them to and from
+ * sequences of bytes in a particular byte order; </p></li>
+ *
+ * <li><p> Methods for creating <i><a href="#views">view buffers</a></i>,
+ * which allow a byte buffer to be viewed as a buffer containing values of
+ * some other primitive type; and </p></li>
+ *
+#end[byte]
+ *
+ * <li><p> A method for {@link #compact compacting}
+ * $a$ $type$ buffer. </p></li>
+ *
+ * </ul>
+ *
+ * <p> $Type$ buffers can be created either by {@link #allocate
+ * <i>allocation</i>}, which allocates space for the buffer's
+ *
+#if[byte]
+ *
+ * content, or by {@link #wrap($type$[]) <i>wrapping</i>} an
+ * existing $type$ array {#if[char]?or string} into a buffer.
+ *
+#else[byte]
+ *
+ * content, by {@link #wrap($type$[]) <i>wrapping</i>} an existing
+ * $type$ array {#if[char]?or string} into a buffer, or by creating a
+ * <a href="ByteBuffer.html#views"><i>view</i></a> of an existing byte buffer.
+ *
+#end[byte]
+ *
+#if[byte]
+ *
+ * <a id="direct"></a>
+ * <h2> Direct <i>vs.</i> non-direct buffers </h2>
+ *
+ * <p> A byte buffer is either <i>direct</i> or <i>non-direct</i>. Given a
+ * direct byte buffer, the Java virtual machine will make a best effort to
+ * perform native I/O operations directly upon it. That is, it will attempt to
+ * avoid copying the buffer's content to (or from) an intermediate buffer
+ * before (or after) each invocation of one of the underlying operating
+ * system's native I/O operations.
+ *
+ * <p> A direct byte buffer may be created by invoking the {@link
+ * #allocateDirect(int) allocateDirect} factory method of this class. The
+ * buffers returned by this method typically have somewhat higher allocation
+ * and deallocation costs than non-direct buffers. The contents of direct
+ * buffers may reside outside of the normal garbage-collected heap, and so
+ * their impact upon the memory footprint of an application might not be
+ * obvious. It is therefore recommended that direct buffers be allocated
+ * primarily for large, long-lived buffers that are subject to the underlying
+ * system's native I/O operations. In general it is best to allocate direct
+ * buffers only when they yield a measureable gain in program performance.
+ *
+ * <p> A direct byte buffer may also be created by {@link
+ * java.nio.channels.FileChannel#map mapping} a region of a file
+ * directly into memory. An implementation of the Java platform may optionally
+ * support the creation of direct byte buffers from native code via JNI. If an
+ * instance of one of these kinds of buffers refers to an inaccessible region
+ * of memory then an attempt to access that region will not change the buffer's
+ * content and will cause an unspecified exception to be thrown either at the
+ * time of the access or at some later time.
+ *
+ * <p> Whether a byte buffer is direct or non-direct may be determined by
+ * invoking its {@link #isDirect isDirect} method. This method is provided so
+ * that explicit buffer management can be done in performance-critical code.
+ *
+ *
+ * <a id="bin"></a>
+ * <h2> Access to binary data </h2>
+ *
+ * <p> This class defines methods for reading and writing values of all other
+ * primitive types, except {@code boolean}. Primitive values are translated
+ * to (or from) sequences of bytes according to the buffer's current byte
+ * order, which may be retrieved and modified via the {@link #order order}
+ * methods. Specific byte orders are represented by instances of the {@link
+ * ByteOrder} class. The initial order of a byte buffer is always {@link
+ * ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
+ *
+ * <p> For access to heterogeneous binary data, that is, sequences of values of
+ * different types, this class defines a family of absolute and relative
+ * <i>get</i> and <i>put</i> methods for each type. For 32-bit floating-point
+ * values, for example, this class defines:
+ *
+ * <blockquote><pre>
+ * float {@link #getFloat()}
+ * float {@link #getFloat(int) getFloat(int index)}
+ * void {@link #putFloat(float) putFloat(float f)}
+ * void {@link #putFloat(int,float) putFloat(int index, float f)}</pre></blockquote>
+ *
+ * <p> Corresponding methods are defined for the types {@code char,
+ * short, int, long}, and {@code double}. The index
+ * parameters of the absolute <i>get</i> and <i>put</i> methods are in terms of
+ * bytes rather than of the type being read or written.
+ *
+ * <a id="views"></a>
+ *
+ * <p> For access to homogeneous binary data, that is, sequences of values of
+ * the same type, this class defines methods that can create <i>views</i> of a
+ * given byte buffer. A <i>view buffer</i> is simply another buffer whose
+ * content is backed by the byte buffer. Changes to the byte buffer's content
+ * will be visible in the view buffer, and vice versa; the two buffers'
+ * position, limit, and mark values are independent. The {@link
+ * #asFloatBuffer() asFloatBuffer} method, for example, creates an instance of
+ * the {@link FloatBuffer} class that is backed by the byte buffer upon which
+ * the method is invoked. Corresponding view-creation methods are defined for
+ * the types {@code char, short, int, long}, and {@code double}.
+ *
+ * <p> View buffers have three important advantages over the families of
+ * type-specific <i>get</i> and <i>put</i> methods described above:
+ *
+ * <ul>
+ *
+ * <li><p> A view buffer is indexed not in terms of bytes but rather in terms
+ * of the type-specific size of its values; </p></li>
+ *
+ * <li><p> A view buffer provides relative bulk <i>get</i> and <i>put</i>
+ * methods that can transfer contiguous sequences of values between a buffer
+ * and an array or some other buffer of the same type; and </p></li>
+ *
+ * <li><p> A view buffer is potentially much more efficient because it will
+ * be direct if, and only if, its backing byte buffer is direct. </p></li>
+ *
+ * </ul>
+ *
+ * <p> The byte order of a view buffer is fixed to be that of its byte buffer
+ * at the time that the view is created. </p>
+ *
+#end[byte]
+*
+#if[!byte]
+ *
+ * <p> Like a byte buffer, $a$ $type$ buffer is either <a
+ * href="ByteBuffer.html#direct"><i>direct</i> or <i>non-direct</i></a>. A
+ * $type$ buffer created via the {@code wrap} methods of this class will
+ * be non-direct. $A$ $type$ buffer created as a view of a byte buffer will
+ * be direct if, and only if, the byte buffer itself is direct. Whether or not
+ * $a$ $type$ buffer is direct may be determined by invoking the {@link
+ * #isDirect isDirect} method. </p>
+ *
+#end[!byte]
+*
+#if[char]
+ *
+ * <p> This class implements the {@link CharSequence} interface so that
+ * character buffers may be used wherever character sequences are accepted, for
+ * example in the regular-expression package {@link java.util.regex}.
+ * </p>
+ *
+#end[char]
+ *
+#if[byte]
+ * <h2> Invocation chaining </h2>
+#end[byte]
+ *
+ * <p> Methods in this class that do not otherwise have a value to return are
+ * specified to return the buffer upon which they are invoked. This allows
+ * method invocations to be chained.
+ *
+#if[byte]
+ *
+ * The sequence of statements
+ *
+ * <blockquote><pre>
+ * bb.putInt(0xCAFEBABE);
+ * bb.putShort(3);
+ * bb.putShort(45);</pre></blockquote>
+ *
+ * can, for example, be replaced by the single statement
+ *
+ * <blockquote><pre>
+ * bb.putInt(0xCAFEBABE).putShort(3).putShort(45);</pre></blockquote>
+ *
+#end[byte]
+#if[char]
+ *
+ * The sequence of statements
+ *
+ * <blockquote><pre>
+ * cb.put("text/");
+ * cb.put(subtype);
+ * cb.put("; charset=");
+ * cb.put(enc);</pre></blockquote>
+ *
+ * can, for example, be replaced by the single statement
+ *
+ * <blockquote><pre>
+ * cb.put("text/").put(subtype).put("; charset=").put(enc);</pre></blockquote>
+ *
+#end[char]
+ *
+ *
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+
+public abstract class $Type$Buffer
+ extends Buffer
+ implements Comparable<$Type$Buffer>{#if[char]?, Appendable, CharSequence, Readable}
+{
+
+ // These fields are declared here rather than in Heap-X-Buffer in order to
+ // reduce the number of virtual method invocations needed to access these
+ // values, which is especially costly when coding small buffers.
+ //
+ final $type$[] hb; // Non-null only for heap buffers
+ final int offset;
+ boolean isReadOnly;
+
+ // Creates a new buffer with the given mark, position, limit, capacity,
+ // backing array, and array offset
+ //
+ $Type$Buffer(int mark, int pos, int lim, int cap, // package-private
+ $type$[] hb, int offset)
+ {
+ super(mark, pos, lim, cap);
+ this.hb = hb;
+ this.offset = offset;
+ }
+
+ // Creates a new buffer with the given mark, position, limit, and capacity
+ //
+ $Type$Buffer(int mark, int pos, int lim, int cap) { // package-private
+ this(mark, pos, lim, cap, null, 0);
+ }
+
+ @Override
+ Object base() {
+ return hb;
+ }
+
+#if[byte]
+
+ /**
+ * Allocates a new direct $type$ buffer.
+ *
+ * <p> The new buffer's position will be zero, its limit will be its
+ * capacity, its mark will be undefined, each of its elements will be
+ * initialized to zero, and its byte order will be
+ * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. Whether or not it has a
+ * {@link #hasArray backing array} is unspecified.
+ *
+ * @param capacity
+ * The new buffer's capacity, in $type$s
+ *
+ * @return The new $type$ buffer
+ *
+ * @throws IllegalArgumentException
+ * If the {@code capacity} is a negative integer
+ */
+ public static $Type$Buffer allocateDirect(int capacity) {
+ return new Direct$Type$Buffer(capacity);
+ }
+
+#end[byte]
+
+ /**
+ * Allocates a new $type$ buffer.
+ *
+ * <p> The new buffer's position will be zero, its limit will be its
+ * capacity, its mark will be undefined, each of its elements will be
+ * initialized to zero, and its byte order will be
+#if[byte]
+ * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
+#else[byte]
+ * the {@link ByteOrder#nativeOrder native order} of the underlying
+ * hardware.
+#end[byte]
+ * It will have a {@link #array backing array}, and its
+ * {@link #arrayOffset array offset} will be zero.
+ *
+ * @param capacity
+ * The new buffer's capacity, in $type$s
+ *
+ * @return The new $type$ buffer
+ *
+ * @throws IllegalArgumentException
+ * If the {@code capacity} is a negative integer
+ */
+ public static $Type$Buffer allocate(int capacity) {
+ if (capacity < 0)
+ throw createCapacityException(capacity);
+ return new Heap$Type$Buffer(capacity, capacity);
+ }
+
+ /**
+ * Wraps $a$ $type$ array into a buffer.
+ *
+ * <p> The new buffer will be backed by the given $type$ array;
+ * that is, modifications to the buffer will cause the array to be modified
+ * and vice versa. The new buffer's capacity will be
+ * {@code array.length}, its position will be {@code offset}, its limit
+ * will be {@code offset + length}, its mark will be undefined, and its
+ * byte order will be
+#if[byte]
+ * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
+#else[byte]
+ * the {@link ByteOrder#nativeOrder native order} of the underlying
+ * hardware.
+#end[byte]
+ * Its {@link #array backing array} will be the given array, and
+ * its {@link #arrayOffset array offset} will be zero. </p>
+ *
+ * @param array
+ * The array that will back the new buffer
+ *
+ * @param offset
+ * The offset of the subarray to be used; must be non-negative and
+ * no larger than {@code array.length}. The new buffer's position
+ * will be set to this value.
+ *
+ * @param length
+ * The length of the subarray to be used;
+ * must be non-negative and no larger than
+ * {@code array.length - offset}.
+ * The new buffer's limit will be set to {@code offset + length}.
+ *
+ * @return The new $type$ buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ */
+ public static $Type$Buffer wrap($type$[] array,
+ int offset, int length)
+ {
+ try {
+ return new Heap$Type$Buffer(array, offset, length);
+ } catch (IllegalArgumentException x) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+
+ /**
+ * Wraps $a$ $type$ array into a buffer.
+ *
+ * <p> The new buffer will be backed by the given $type$ array;
+ * that is, modifications to the buffer will cause the array to be modified
+ * and vice versa. The new buffer's capacity and limit will be
+ * {@code array.length}, its position will be zero, its mark will be
+ * undefined, and its byte order will be
+#if[byte]
+ * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
+#else[byte]
+ * the {@link ByteOrder#nativeOrder native order} of the underlying
+ * hardware.
+#end[byte]
+ * Its {@link #array backing array} will be the given array, and its
+ * {@link #arrayOffset array offset} will be zero. </p>
+ *
+ * @param array
+ * The array that will back this buffer
+ *
+ * @return The new $type$ buffer
+ */
+ public static $Type$Buffer wrap($type$[] array) {
+ return wrap(array, 0, array.length);
+ }
+
+#if[char]
+
+ /**
+ * Attempts to read characters into the specified character buffer.
+ * The buffer is used as a repository of characters as-is: the only
+ * changes made are the results of a put operation. No flipping or
+ * rewinding of the buffer is performed.
+ *
+ * @param target the buffer to read characters into
+ * @return The number of characters added to the buffer, or
+ * -1 if this source of characters is at its end
+ * @throws IOException if an I/O error occurs
+ * @throws NullPointerException if target is null
+ * @throws ReadOnlyBufferException if target is a read only buffer
+ * @since 1.5
+ */
+ public int read(CharBuffer target) throws IOException {
+ // Determine the number of bytes n that can be transferred
+ int targetRemaining = target.remaining();
+ int remaining = remaining();
+ if (remaining == 0)
+ return -1;
+ int n = Math.min(remaining, targetRemaining);
+ int limit = limit();
+ // Set source limit to prevent target overflow
+ if (targetRemaining < remaining)
+ limit(position() + n);
+ try {
+ if (n > 0)
+ target.put(this);
+ } finally {
+ limit(limit); // restore real limit
+ }
+ return n;
+ }
+
+ /**
+ * Wraps a character sequence into a buffer.
+ *
+ * <p> The content of the new, read-only buffer will be the content of the
+ * given character sequence. The buffer's capacity will be
+ * {@code csq.length()}, its position will be {@code start}, its limit
+ * will be {@code end}, and its mark will be undefined. </p>
+ *
+ * @param csq
+ * The character sequence from which the new character buffer is to
+ * be created
+ *
+ * @param start
+ * The index of the first character to be used;
+ * must be non-negative and no larger than {@code csq.length()}.
+ * The new buffer's position will be set to this value.
+ *
+ * @param end
+ * The index of the character following the last character to be
+ * used; must be no smaller than {@code start} and no larger
+ * than {@code csq.length()}.
+ * The new buffer's limit will be set to this value.
+ *
+ * @return The new character buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code start} and {@code end}
+ * parameters do not hold
+ */
+ public static CharBuffer wrap(CharSequence csq, int start, int end) {
+ try {
+ return new StringCharBuffer(csq, start, end);
+ } catch (IllegalArgumentException x) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+
+ /**
+ * Wraps a character sequence into a buffer.
+ *
+ * <p> The content of the new, read-only buffer will be the content of the
+ * given character sequence. The new buffer's capacity and limit will be
+ * {@code csq.length()}, its position will be zero, and its mark will be
+ * undefined. </p>
+ *
+ * @param csq
+ * The character sequence from which the new character buffer is to
+ * be created
+ *
+ * @return The new character buffer
+ */
+ public static CharBuffer wrap(CharSequence csq) {
+ return wrap(csq, 0, csq.length());
+ }
+
+#end[char]
+
+ /**
+ * Creates a new $type$ buffer whose content is a shared subsequence of
+ * this buffer's content.
+ *
+ * <p> The content of the new buffer will start at this buffer's current
+ * position. Changes to this buffer's content will be visible in the new
+ * buffer, and vice versa; the two buffers' position, limit, and mark
+ * values will be independent.
+ *
+ * <p> The new buffer's position will be zero, its capacity and its limit
+ * will be the number of $type$s remaining in this buffer, its mark will be
+ * undefined, and its byte order will be
+#if[byte]
+ * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
+#else[byte]
+ * identical to that of this buffer.
+#end[byte]
+ * The new buffer will be direct if, and only if, this buffer is direct, and
+ * it will be read-only if, and only if, this buffer is read-only. </p>
+ *
+ * @return The new $type$ buffer
+#if[byte]
+ *
+ * @see #alignedSlice(int)
+#end[byte]
+ */
+ @Override
+ public abstract $Type$Buffer slice();
+
+ /**
+ * Creates a new $type$ buffer that shares this buffer's content.
+ *
+ * <p> The content of the new buffer will be that of this buffer. Changes
+ * to this buffer's content will be visible in the new buffer, and vice
+ * versa; the two buffers' position, limit, and mark values will be
+ * independent.
+ *
+ * <p> The new buffer's capacity, limit, position,
+#if[byte]
+ * and mark values will be identical to those of this buffer, and its byte
+ * order will be {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
+#else[byte]
+ * mark values, and byte order will be identical to those of this buffer.
+#end[byte]
+ * The new buffer will be direct if, and only if, this buffer is direct, and
+ * it will be read-only if, and only if, this buffer is read-only. </p>
+ *
+ * @return The new $type$ buffer
+ */
+ @Override
+ public abstract $Type$Buffer duplicate();
+
+ /**
+ * Creates a new, read-only $type$ buffer that shares this buffer's
+ * content.
+ *
+ * <p> The content of the new buffer will be that of this buffer. Changes
+ * to this buffer's content will be visible in the new buffer; the new
+ * buffer itself, however, will be read-only and will not allow the shared
+ * content to be modified. The two buffers' position, limit, and mark
+ * values will be independent.
+ *
+ * <p> The new buffer's capacity, limit, position,
+#if[byte]
+ * and mark values will be identical to those of this buffer, and its byte
+ * order will be {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
+#else[byte]
+ * mark values, and byte order will be identical to those of this buffer.
+#end[byte]
+ *
+ * <p> If this buffer is itself read-only then this method behaves in
+ * exactly the same way as the {@link #duplicate duplicate} method. </p>
+ *
+ * @return The new, read-only $type$ buffer
+ */
+ public abstract $Type$Buffer asReadOnlyBuffer();
+
+
+ // -- Singleton get/put methods --
+
+ /**
+ * Relative <i>get</i> method. Reads the $type$ at this buffer's
+ * current position, and then increments the position.
+ *
+ * @return The $type$ at the buffer's current position
+ *
+ * @throws BufferUnderflowException
+ * If the buffer's current position is not smaller than its limit
+ */
+ public abstract $type$ get();
+
+ /**
+ * Relative <i>put</i> method <i>(optional operation)</i>.
+ *
+ * <p> Writes the given $type$ into this buffer at the current
+ * position, and then increments the position. </p>
+ *
+ * @param $x$
+ * The $type$ to be written
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If this buffer's current position is not smaller than its limit
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public abstract $Type$Buffer put($type$ $x$);
+
+ /**
+ * Absolute <i>get</i> method. Reads the $type$ at the given
+ * index.
+ *
+ * @param index
+ * The index from which the $type$ will be read
+ *
+ * @return The $type$ at the given index
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative
+ * or not smaller than the buffer's limit
+ */
+ public abstract $type$ get(int index);
+
+#if[streamableType]
+ /**
+ * Absolute <i>get</i> method. Reads the $type$ at the given
+ * index without any validation of the index.
+ *
+ * @param index
+ * The index from which the $type$ will be read
+ *
+ * @return The $type$ at the given index
+ */
+ abstract $type$ getUnchecked(int index); // package-private
+#end[streamableType]
+
+ /**
+ * Absolute <i>put</i> method <i>(optional operation)</i>.
+ *
+ * <p> Writes the given $type$ into this buffer at the given
+ * index. </p>
+ *
+ * @param index
+ * The index at which the $type$ will be written
+ *
+ * @param $x$
+ * The $type$ value to be written
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative
+ * or not smaller than the buffer's limit
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public abstract $Type$Buffer put(int index, $type$ $x$);
+
+
+ // -- Bulk get operations --
+
+ /**
+ * Relative bulk <i>get</i> method.
+ *
+ * <p> This method transfers $type$s from this buffer into the given
+ * destination array. If there are fewer $type$s remaining in the
+ * buffer than are required to satisfy the request, that is, if
+ * {@code length} {@code >} {@code remaining()}, then no
+ * $type$s are transferred and a {@link BufferUnderflowException} is
+ * thrown.
+ *
+ * <p> Otherwise, this method copies {@code length} $type$s from this
+ * buffer into the given array, starting at the current position of this
+ * buffer and at the given offset in the array. The position of this
+ * buffer is then incremented by {@code length}.
+ *
+ * <p> In other words, an invocation of this method of the form
+ * <code>src.get(dst, off, len)</code> has exactly the same effect as
+ * the loop
+ *
+ * <pre>{@code
+ * for (int i = off; i < off + len; i++)
+ * dst[i] = src.get();
+ * }</pre>
+ *
+ * except that it first checks that there are sufficient $type$s in
+ * this buffer and it is potentially much more efficient.
+ *
+ * @param dst
+ * The array into which $type$s are to be written
+ *
+ * @param offset
+ * The offset within the array of the first $type$ to be
+ * written; must be non-negative and no larger than
+ * {@code dst.length}
+ *
+ * @param length
+ * The maximum number of $type$s to be written to the given
+ * array; must be non-negative and no larger than
+ * {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than {@code length} $type$s
+ * remaining in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ */
+ public $Type$Buffer get($type$[] dst, int offset, int length) {
+ checkBounds(offset, length, dst.length);
+ if (length > remaining())
+ throw new BufferUnderflowException();
+ int end = offset + length;
+ for (int i = offset; i < end; i++)
+ dst[i] = get();
+ return this;
+ }
+
+ /**
+ * Relative bulk <i>get</i> method.
+ *
+ * <p> This method transfers $type$s from this buffer into the given
+ * destination array. An invocation of this method of the form
+ * {@code src.get(a)} behaves in exactly the same way as the invocation
+ *
+ * <pre>
+ * src.get(a, 0, a.length) </pre>
+ *
+ * @param dst
+ * The destination array
+ *
+ * @return This buffer
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than {@code length} $type$s
+ * remaining in this buffer
+ */
+ public $Type$Buffer get($type$[] dst) {
+ return get(dst, 0, dst.length);
+ }
+
+
+ // -- Bulk put operations --
+
+ /**
+ * Relative bulk <i>put</i> method <i>(optional operation)</i>.
+ *
+ * <p> This method transfers the $type$s remaining in the given source
+ * buffer into this buffer. If there are more $type$s remaining in the
+ * source buffer than in this buffer, that is, if
+ * {@code src.remaining()} {@code >} {@code remaining()},
+ * then no $type$s are transferred and a {@link
+ * BufferOverflowException} is thrown.
+ *
+ * <p> Otherwise, this method copies
+ * <i>n</i> = {@code src.remaining()} $type$s from the given
+ * buffer into this buffer, starting at each buffer's current position.
+ * The positions of both buffers are then incremented by <i>n</i>.
+ *
+ * <p> In other words, an invocation of this method of the form
+ * {@code dst.put(src)} has exactly the same effect as the loop
+ *
+ * <pre>
+ * while (src.hasRemaining())
+ * dst.put(src.get()); </pre>
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The source buffer from which $type$s are to be read;
+ * must not be this buffer
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ * for the remaining $type$s in the source buffer
+ *
+ * @throws IllegalArgumentException
+ * If the source buffer is this buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public $Type$Buffer put($Type$Buffer src) {
+ if (src == this)
+ throw createSameBufferException();
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ int n = src.remaining();
+ if (n > remaining())
+ throw new BufferOverflowException();
+ for (int i = 0; i < n; i++)
+ put(src.get());
+ return this;
+ }
+
+ /**
+ * Relative bulk <i>put</i> method <i>(optional operation)</i>.
+ *
+ * <p> This method transfers $type$s into this buffer from the given
+ * source array. If there are more $type$s to be copied from the array
+ * than remain in this buffer, that is, if
+ * {@code length} {@code >} {@code remaining()}, then no
+ * $type$s are transferred and a {@link BufferOverflowException} is
+ * thrown.
+ *
+ * <p> Otherwise, this method copies {@code length} $type$s from the
+ * given array into this buffer, starting at the given offset in the array
+ * and at the current position of this buffer. The position of this buffer
+ * is then incremented by {@code length}.
+ *
+ * <p> In other words, an invocation of this method of the form
+ * <code>dst.put(src, off, len)</code> has exactly the same effect as
+ * the loop
+ *
+ * <pre>{@code
+ * for (int i = off; i < off + len; i++)
+ * dst.put(a[i]);
+ * }</pre>
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The array from which $type$s are to be read
+ *
+ * @param offset
+ * The offset within the array of the first $type$ to be read;
+ * must be non-negative and no larger than {@code array.length}
+ *
+ * @param length
+ * The number of $type$s to be read from the given array;
+ * must be non-negative and no larger than
+ * {@code array.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public $Type$Buffer put($type$[] src, int offset, int length) {
+ checkBounds(offset, length, src.length);
+ if (length > remaining())
+ throw new BufferOverflowException();
+ int end = offset + length;
+ for (int i = offset; i < end; i++)
+ this.put(src[i]);
+ return this;
+ }
+
+ /**
+ * Relative bulk <i>put</i> method <i>(optional operation)</i>.
+ *
+ * <p> This method transfers the entire content of the given source
+ * $type$ array into this buffer. An invocation of this method of the
+ * form {@code dst.put(a)} behaves in exactly the same way as the
+ * invocation
+ *
+ * <pre>
+ * dst.put(a, 0, a.length) </pre>
+ *
+ * @param src
+ * The source array
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public final $Type$Buffer put($type$[] src) {
+ return put(src, 0, src.length);
+ }
+
+#if[char]
+
+ /**
+ * Relative bulk <i>put</i> method <i>(optional operation)</i>.
+ *
+ * <p> This method transfers $type$s from the given string into this
+ * buffer. If there are more $type$s to be copied from the string than
+ * remain in this buffer, that is, if
+ * <code>end - start</code> {@code >} {@code remaining()},
+ * then no $type$s are transferred and a {@link
+ * BufferOverflowException} is thrown.
+ *
+ * <p> Otherwise, this method copies
+ * <i>n</i> = {@code end} - {@code start} $type$s
+ * from the given string into this buffer, starting at the given
+ * {@code start} index and at the current position of this buffer. The
+ * position of this buffer is then incremented by <i>n</i>.
+ *
+ * <p> In other words, an invocation of this method of the form
+ * <code>dst.put(src, start, end)</code> has exactly the same effect
+ * as the loop
+ *
+ * <pre>{@code
+ * for (int i = start; i < end; i++)
+ * dst.put(src.charAt(i));
+ * }</pre>
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The string from which $type$s are to be read
+ *
+ * @param start
+ * The offset within the string of the first $type$ to be read;
+ * must be non-negative and no larger than
+ * {@code string.length()}
+ *
+ * @param end
+ * The offset within the string of the last $type$ to be read,
+ * plus one; must be non-negative and no larger than
+ * {@code string.length()}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code start} and {@code end}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public $Type$Buffer put(String src, int start, int end) {
+ checkBounds(start, end - start, src.length());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ if (end - start > remaining())
+ throw new BufferOverflowException();
+ for (int i = start; i < end; i++)
+ this.put(src.charAt(i));
+ return this;
+ }
+
+ /**
+ * Relative bulk <i>put</i> method <i>(optional operation)</i>.
+ *
+ * <p> This method transfers the entire content of the given source string
+ * into this buffer. An invocation of this method of the form
+ * {@code dst.put(s)} behaves in exactly the same way as the invocation
+ *
+ * <pre>
+ * dst.put(s, 0, s.length()) </pre>
+ *
+ * @param src
+ * The source string
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public final $Type$Buffer put(String src) {
+ return put(src, 0, src.length());
+ }
+
+#end[char]
+
+
+ // -- Other stuff --
+
+ /**
+ * Tells whether or not this buffer is backed by an accessible $type$
+ * array.
+ *
+ * <p> If this method returns {@code true} then the {@link #array() array}
+ * and {@link #arrayOffset() arrayOffset} methods may safely be invoked.
+ * </p>
+ *
+ * @return {@code true} if, and only if, this buffer
+ * is backed by an array and is not read-only
+ */
+ public final boolean hasArray() {
+ return (hb != null) && !isReadOnly;
+ }
+
+ /**
+ * Returns the $type$ array that backs this
+ * buffer <i>(optional operation)</i>.
+ *
+ * <p> Modifications to this buffer's content will cause the returned
+ * array's content to be modified, and vice versa.
+ *
+ * <p> Invoke the {@link #hasArray hasArray} method before invoking this
+ * method in order to ensure that this buffer has an accessible backing
+ * array. </p>
+ *
+ * @return The array that backs this buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is backed by an array but is read-only
+ *
+ * @throws UnsupportedOperationException
+ * If this buffer is not backed by an accessible array
+ */
+ public final $type$[] array() {
+ if (hb == null)
+ throw new UnsupportedOperationException();
+ if (isReadOnly)
+ throw new ReadOnlyBufferException();
+ return hb;
+ }
+
+ /**
+ * Returns the offset within this buffer's backing array of the first
+ * element of the buffer <i>(optional operation)</i>.
+ *
+ * <p> If this buffer is backed by an array then buffer position <i>p</i>
+ * corresponds to array index <i>p</i> + {@code arrayOffset()}.
+ *
+ * <p> Invoke the {@link #hasArray hasArray} method before invoking this
+ * method in order to ensure that this buffer has an accessible backing
+ * array. </p>
+ *
+ * @return The offset within this buffer's array
+ * of the first element of the buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is backed by an array but is read-only
+ *
+ * @throws UnsupportedOperationException
+ * If this buffer is not backed by an accessible array
+ */
+ public final int arrayOffset() {
+ if (hb == null)
+ throw new UnsupportedOperationException();
+ if (isReadOnly)
+ throw new ReadOnlyBufferException();
+ return offset;
+ }
+
+ // -- Covariant return type overrides
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public
+#if[!byte]
+ final
+#end[!byte]
+ $Type$Buffer position(int newPosition) {
+ super.position(newPosition);
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public
+#if[!byte]
+ final
+#end[!byte]
+ $Type$Buffer limit(int newLimit) {
+ super.limit(newLimit);
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public
+#if[!byte]
+ final
+#end[!byte]
+ $Type$Buffer mark() {
+ super.mark();
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public
+#if[!byte]
+ final
+#end[!byte]
+ $Type$Buffer reset() {
+ super.reset();
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public
+#if[!byte]
+ final
+#end[!byte]
+ $Type$Buffer clear() {
+ super.clear();
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public
+#if[!byte]
+ final
+#end[!byte]
+ $Type$Buffer flip() {
+ super.flip();
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public
+#if[!byte]
+ final
+#end[!byte]
+ $Type$Buffer rewind() {
+ super.rewind();
+ return this;
+ }
+
+ /**
+ * Compacts this buffer <i>(optional operation)</i>.
+ *
+ * <p> The $type$s between the buffer's current position and its limit,
+ * if any, are copied to the beginning of the buffer. That is, the
+ * $type$ at index <i>p</i> = {@code position()} is copied
+ * to index zero, the $type$ at index <i>p</i> + 1 is copied
+ * to index one, and so forth until the $type$ at index
+ * {@code limit()} - 1 is copied to index
+ * <i>n</i> = {@code limit()} - {@code 1} - <i>p</i>.
+ * The buffer's position is then set to <i>n+1</i> and its limit is set to
+ * its capacity. The mark, if defined, is discarded.
+ *
+ * <p> The buffer's position is set to the number of $type$s copied,
+ * rather than to zero, so that an invocation of this method can be
+ * followed immediately by an invocation of another relative <i>put</i>
+ * method. </p>
+ *
+#if[byte]
+ *
+ * <p> Invoke this method after writing data from a buffer in case the
+ * write was incomplete. The following loop, for example, copies bytes
+ * from one channel to another via the buffer {@code buf}:
+ *
+ * <blockquote><pre>{@code
+ * buf.clear(); // Prepare buffer for use
+ * while (in.read(buf) >= 0 || buf.position != 0) {
+ * buf.flip();
+ * out.write(buf);
+ * buf.compact(); // In case of partial write
+ * }
+ * }</pre></blockquote>
+ *
+#end[byte]
+ *
+ * @return This buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public abstract $Type$Buffer compact();
+
+ /**
+ * Tells whether or not this $type$ buffer is direct.
+ *
+ * @return {@code true} if, and only if, this buffer is direct
+ */
+ public abstract boolean isDirect();
+
+#if[!char]
+
+ /**
+ * Returns a string summarizing the state of this buffer.
+ *
+ * @return A summary string
+ */
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ sb.append(getClass().getName());
+ sb.append("[pos=");
+ sb.append(position());
+ sb.append(" lim=");
+ sb.append(limit());
+ sb.append(" cap=");
+ sb.append(capacity());
+ sb.append("]");
+ return sb.toString();
+ }
+
+#end[!char]
+
+
+ // ## Should really use unchecked accessors here for speed
+
+ /**
+ * Returns the current hash code of this buffer.
+ *
+ * <p> The hash code of a $type$ buffer depends only upon its remaining
+ * elements; that is, upon the elements from {@code position()} up to, and
+ * including, the element at {@code limit()} - {@code 1}.
+ *
+ * <p> Because buffer hash codes are content-dependent, it is inadvisable
+ * to use buffers as keys in hash maps or similar data structures unless it
+ * is known that their contents will not change. </p>
+ *
+ * @return The current hash code of this buffer
+ */
+ public int hashCode() {
+ int h = 1;
+ int p = position();
+ for (int i = limit() - 1; i >= p; i--)
+#if[int]
+ h = 31 * h + get(i);
+#else[int]
+ h = 31 * h + (int)get(i);
+#end[int]
+ return h;
+ }
+
+ /**
+ * Tells whether or not this buffer is equal to another object.
+ *
+ * <p> Two $type$ buffers are equal if, and only if,
+ *
+ * <ol>
+ *
+ * <li><p> They have the same element type, </p></li>
+ *
+ * <li><p> They have the same number of remaining elements, and
+ * </p></li>
+ *
+ * <li><p> The two sequences of remaining elements, considered
+ * independently of their starting positions, are pointwise equal.
+#if[floatingPointType]
+ * This method considers two $type$ elements {@code a} and {@code b}
+ * to be equal if
+ * {@code (a == b) || ($Fulltype$.isNaN(a) && $Fulltype$.isNaN(b))}.
+ * The values {@code -0.0} and {@code +0.0} are considered to be
+ * equal, unlike {@link $Fulltype$#equals(Object)}.
+#end[floatingPointType]
+ * </p></li>
+ *
+ * </ol>
+ *
+ * <p> A $type$ buffer is not equal to any other type of object. </p>
+ *
+ * @param ob The object to which this buffer is to be compared
+ *
+ * @return {@code true} if, and only if, this buffer is equal to the
+ * given object
+ */
+ public boolean equals(Object ob) {
+ if (this == ob)
+ return true;
+ if (!(ob instanceof $Type$Buffer))
+ return false;
+ $Type$Buffer that = ($Type$Buffer)ob;
+ if (this.remaining() != that.remaining())
+ return false;
+ return BufferMismatch.mismatch(this, this.position(),
+ that, that.position(),
+ this.remaining()) < 0;
+ }
+
+ /**
+ * Compares this buffer to another.
+ *
+ * <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.
+#if[floatingPointType]
+ * Pairs of {@code $type$} elements are compared as if by invoking
+ * {@link $Fulltype$#compare($type$,$type$)}, except that
+ * {@code -0.0} and {@code 0.0} are considered to be equal.
+ * {@code $Fulltype$.NaN} is considered by this method to be equal
+ * to itself and greater than all other {@code $type$} values
+ * (including {@code $Fulltype$.POSITIVE_INFINITY}).
+#else[floatingPointType]
+ * Pairs of {@code $type$} elements are compared as if by invoking
+ * {@link $Fulltype$#compare($type$,$type$)}.
+#end[floatingPointType]
+ *
+ * <p> A $type$ buffer is not comparable to any other type of object.
+ *
+ * @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 compareTo($Type$Buffer that) {
+ int i = BufferMismatch.mismatch(this, this.position(),
+ that, that.position(),
+ Math.min(this.remaining(), that.remaining()));
+ if (i >= 0) {
+ return compare(this.get(this.position() + i), that.get(that.position() + i));
+ }
+ return this.remaining() - that.remaining();
+ }
+
+ private static int compare($type$ x, $type$ y) {
+#if[floatingPointType]
+ return ((x < y) ? -1 :
+ (x > y) ? +1 :
+ (x == y) ? 0 :
+ $Fulltype$.isNaN(x) ? ($Fulltype$.isNaN(y) ? 0 : +1) : -1);
+#else[floatingPointType]
+ return $Fulltype$.compare(x, y);
+#end[floatingPointType]
+ }
+
+ /**
+ * Finds and returns the relative index of the first mismatch between this
+ * buffer and a given buffer. The index is relative to the
+ * {@link #position() position} of each buffer and will be in the range of
+ * 0 (inclusive) up to the smaller of the {@link #remaining() remaining}
+ * elements in each buffer (exclusive).
+ *
+ * <p> If the two buffers share a common prefix then the returned index is
+ * the length of the common prefix and it follows that there is a mismatch
+ * between the two buffers at that index within the respective buffers.
+ * If one buffer is a proper prefix of the other then the returned index is
+ * the smaller of the remaining elements in each buffer, and it follows that
+ * the index is only valid for the buffer with the larger number of
+ * remaining elements.
+ * Otherwise, there is no mismatch.
+ *
+ * @param that
+ * The byte buffer to be tested for a mismatch with this buffer
+ *
+ * @return The relative index of the first mismatch between this and the
+ * given buffer, otherwise -1 if no mismatch.
+ *
+ * @since 11
+ */
+ public int mismatch($Type$Buffer that) {
+ int length = Math.min(this.remaining(), that.remaining());
+ int r = BufferMismatch.mismatch(this, this.position(),
+ that, that.position(),
+ length);
+ return (r == -1 && this.remaining() != that.remaining()) ? length : r;
+ }
+
+ // -- Other char stuff --
+
+#if[char]
+
+ /**
+ * Returns a string containing the characters in this buffer.
+ *
+ * <p> The first character of the resulting string will be the character at
+ * this buffer's position, while the last character will be the character
+ * at index {@code limit()} - 1. Invoking this method does not
+ * change the buffer's position. </p>
+ *
+ * @return The specified string
+ */
+ public String toString() {
+ return toString(position(), limit());
+ }
+
+ abstract String toString(int start, int end); // package-private
+
+
+ // --- Methods to support CharSequence ---
+
+ /**
+ * Returns the length of this character buffer.
+ *
+ * <p> When viewed as a character sequence, the length of a character
+ * buffer is simply the number of characters between the position
+ * (inclusive) and the limit (exclusive); that is, it is equivalent to
+ * {@code remaining()}. </p>
+ *
+ * @return The length of this character buffer
+ */
+ public final int length() {
+ return remaining();
+ }
+
+ /**
+ * Reads the character at the given index relative to the current
+ * position.
+ *
+ * @param index
+ * The index of the character to be read, relative to the position;
+ * must be non-negative and smaller than {@code remaining()}
+ *
+ * @return The character at index
+ * <code>position() + index</code>
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on {@code index} do not hold
+ */
+ public final char charAt(int index) {
+ return get(position() + checkIndex(index, 1));
+ }
+
+ /**
+ * Creates a new character buffer that represents the specified subsequence
+ * of this buffer, relative to the current position.
+ *
+ * <p> The new buffer will share this buffer's content; that is, if the
+ * content of this buffer is mutable then modifications to one buffer will
+ * cause the other to be modified. The new buffer's capacity will be that
+ * of this buffer, its position will be
+ * {@code position()} + {@code start}, and its limit will be
+ * {@code position()} + {@code end}. The new buffer will be
+ * direct if, and only if, this buffer is direct, and it will be read-only
+ * if, and only if, this buffer is read-only. </p>
+ *
+ * @param start
+ * The index, relative to the current position, of the first
+ * character in the subsequence; must be non-negative and no larger
+ * than {@code remaining()}
+ *
+ * @param end
+ * The index, relative to the current position, of the character
+ * following the last character in the subsequence; must be no
+ * smaller than {@code start} and no larger than
+ * {@code remaining()}
+ *
+ * @return The new character buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on {@code start} and {@code end}
+ * do not hold
+ */
+ public abstract CharBuffer subSequence(int start, int end);
+
+
+ // --- Methods to support Appendable ---
+
+ /**
+ * Appends the specified character sequence to this
+ * buffer <i>(optional operation)</i>.
+ *
+ * <p> An invocation of this method of the form {@code dst.append(csq)}
+ * behaves in exactly the same way as the invocation
+ *
+ * <pre>
+ * dst.put(csq.toString()) </pre>
+ *
+ * <p> Depending on the specification of {@code toString} for the
+ * character sequence {@code csq}, the entire sequence may not be
+ * appended. For instance, invoking the {@link $Type$Buffer#toString()
+ * toString} method of a character buffer will return a subsequence whose
+ * content depends upon the buffer's position and limit.
+ *
+ * @param csq
+ * The character sequence to append. If {@code csq} is
+ * {@code null}, then the four characters {@code "null"} are
+ * appended to this character buffer.
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 1.5
+ */
+ public $Type$Buffer append(CharSequence csq) {
+ if (csq == null)
+ return put("null");
+ else
+ return put(csq.toString());
+ }
+
+ /**
+ * Appends a subsequence of the specified character sequence to this
+ * buffer <i>(optional operation)</i>.
+ *
+ * <p> An invocation of this method of the form {@code dst.append(csq, start,
+ * end)} when {@code csq} is not {@code null}, behaves in exactly the
+ * same way as the invocation
+ *
+ * <pre>
+ * dst.put(csq.subSequence(start, end).toString()) </pre>
+ *
+ * @param csq
+ * The character sequence from which a subsequence will be
+ * appended. If {@code csq} is {@code null}, then characters
+ * will be appended as if {@code csq} contained the four
+ * characters {@code "null"}.
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code start} or {@code end} are negative, {@code start}
+ * is greater than {@code end}, or {@code end} is greater than
+ * {@code csq.length()}
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 1.5
+ */
+ public $Type$Buffer append(CharSequence csq, int start, int end) {
+ CharSequence cs = (csq == null ? "null" : csq);
+ return put(cs.subSequence(start, end).toString());
+ }
+
+ /**
+ * Appends the specified $type$ to this
+ * buffer <i>(optional operation)</i>.
+ *
+ * <p> An invocation of this method of the form {@code dst.append($x$)}
+ * behaves in exactly the same way as the invocation
+ *
+ * <pre>
+ * dst.put($x$) </pre>
+ *
+ * @param $x$
+ * The 16-bit $type$ to append
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 1.5
+ */
+ public $Type$Buffer append($type$ $x$) {
+ return put($x$);
+ }
+
+#end[char]
+
+
+ // -- Other byte stuff: Access to binary data --
+
+#if[!byte]
+
+ /**
+ * Retrieves this buffer's byte order.
+ *
+ * <p> The byte order of $a$ $type$ buffer created by allocation or by
+ * wrapping an existing {@code $type$} array is the {@link
+ * ByteOrder#nativeOrder native order} of the underlying
+ * hardware. The byte order of $a$ $type$ buffer created as a <a
+ * href="ByteBuffer.html#views">view</a> of a byte buffer is that of the
+ * byte buffer at the moment that the view is created. </p>
+ *
+ * @return This buffer's byte order
+ */
+ public abstract ByteOrder order();
+
+#end[!byte]
+
+#if[char]
+ // The order or null if the buffer does not cover a memory region,
+ // such as StringCharBuffer
+ abstract ByteOrder charRegionOrder();
+#end[char]
+
+#if[byte]
+
+ boolean bigEndian // package-private
+ = true;
+ boolean nativeByteOrder // package-private
+ = (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN);
+
+ /**
+ * Retrieves this buffer's byte order.
+ *
+ * <p> The byte order is used when reading or writing multibyte values, and
+ * when creating buffers that are views of this byte buffer. The order of
+ * a newly-created byte buffer is always {@link ByteOrder#BIG_ENDIAN
+ * BIG_ENDIAN}. </p>
+ *
+ * @return This buffer's byte order
+ */
+ public final ByteOrder order() {
+ return bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
+ }
+
+ /**
+ * Modifies this buffer's byte order.
+ *
+ * @param bo
+ * The new byte order,
+ * either {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}
+ * or {@link ByteOrder#LITTLE_ENDIAN LITTLE_ENDIAN}
+ *
+ * @return This buffer
+ */
+ public final $Type$Buffer order(ByteOrder bo) {
+ bigEndian = (bo == ByteOrder.BIG_ENDIAN);
+ nativeByteOrder =
+ (bigEndian == (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN));
+ return this;
+ }
+
+ /**
+ * Returns the memory address, pointing to the byte at the given index,
+ * modulus the given unit size.
+ *
+ * <p> A return value greater than zero indicates the address of the byte at
+ * the index is misaligned for the unit size, and the value's quantity
+ * indicates how much the index should be rounded up or down to locate a
+ * byte at an aligned address. Otherwise, a value of {@code 0} indicates
+ * that the address of the byte at the index is aligned for the unit size.
+ *
+ * @apiNote
+ * This method may be utilized to determine if unit size bytes from an
+ * index can be accessed atomically, if supported by the native platform.
+ *
+ * @implNote
+ * This implementation throws {@code UnsupportedOperationException} for
+ * non-direct buffers when the given unit size is greater then {@code 8}.
+ *
+ * @param index
+ * The index to query for alignment offset, must be non-negative, no
+ * upper bounds check is performed
+ *
+ * @param unitSize
+ * The unit size in bytes, must be a power of {@code 2}
+ *
+ * @return The indexed byte's memory address modulus the unit size
+ *
+ * @throws IllegalArgumentException
+ * If the index is negative or the unit size is not a power of
+ * {@code 2}
+ *
+ * @throws UnsupportedOperationException
+ * If the native platform does not guarantee stable alignment offset
+ * values for the given unit size when managing the memory regions
+ * of buffers of the same kind as this buffer (direct or
+ * non-direct). For example, if garbage collection would result
+ * in the moving of a memory region covered by a non-direct buffer
+ * from one location to another and both locations have different
+ * alignment characteristics.
+ *
+ * @see #alignedSlice(int)
+ * @since 9
+ */
+ public final int alignmentOffset(int index, int unitSize) {
+ if (index < 0)
+ throw new IllegalArgumentException("Index less than zero: " + index);
+ if (unitSize < 1 || (unitSize & (unitSize - 1)) != 0)
+ throw new IllegalArgumentException("Unit size not a power of two: " + unitSize);
+ if (unitSize > 8 && !isDirect())
+ throw new UnsupportedOperationException("Unit size unsupported for non-direct buffers: " + unitSize);
+
+ return (int) ((address + index) % unitSize);
+ }
+
+ /**
+ * Creates a new byte buffer whose content is a shared and aligned
+ * subsequence of this buffer's content.
+ *
+ * <p> The content of the new buffer will start at this buffer's current
+ * position rounded up to the index of the nearest aligned byte for the
+ * given unit size, and end at this buffer's limit rounded down to the index
+ * of the nearest aligned byte for the given unit size.
+ * If rounding results in out-of-bound values then the new buffer's capacity
+ * and limit will be zero. If rounding is within bounds the following
+ * expressions will be true for a new buffer {@code nb} and unit size
+ * {@code unitSize}:
+ * <pre>{@code
+ * nb.alignmentOffset(0, unitSize) == 0
+ * nb.alignmentOffset(nb.limit(), unitSize) == 0
+ * }</pre>
+ *
+ * <p> Changes to this buffer's content will be visible in the new
+ * buffer, and vice versa; the two buffers' position, limit, and mark
+ * values will be independent.
+ *
+ * <p> The new buffer's position will be zero, its capacity and its limit
+ * will be the number of bytes remaining in this buffer or fewer subject to
+ * alignment, its mark will be undefined, and its byte order will be
+ * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
+ *
+ * The new buffer will be direct if, and only if, this buffer is direct, and
+ * it will be read-only if, and only if, this buffer is read-only. </p>
+ *
+ * @apiNote
+ * This method may be utilized to create a new buffer where unit size bytes
+ * from index, that is a multiple of the unit size, may be accessed
+ * atomically, if supported by the native platform.
+ *
+ * @implNote
+ * This implementation throws {@code UnsupportedOperationException} for
+ * non-direct buffers when the given unit size is greater then {@code 8}.
+ *
+ * @param unitSize
+ * The unit size in bytes, must be a power of {@code 2}
+ *
+ * @return The new byte buffer
+ *
+ * @throws IllegalArgumentException
+ * If the unit size not a power of {@code 2}
+ *
+ * @throws UnsupportedOperationException
+ * If the native platform does not guarantee stable aligned slices
+ * for the given unit size when managing the memory regions
+ * of buffers of the same kind as this buffer (direct or
+ * non-direct). For example, if garbage collection would result
+ * in the moving of a memory region covered by a non-direct buffer
+ * from one location to another and both locations have different
+ * alignment characteristics.
+ *
+ * @see #alignmentOffset(int, int)
+ * @see #slice()
+ * @since 9
+ */
+ public final ByteBuffer alignedSlice(int unitSize) {
+ int pos = position();
+ int lim = limit();
+
+ int pos_mod = alignmentOffset(pos, unitSize);
+ int lim_mod = alignmentOffset(lim, unitSize);
+
+ // Round up the position to align with unit size
+ int aligned_pos = (pos_mod > 0)
+ ? pos + (unitSize - pos_mod)
+ : pos;
+
+ // Round down the limit to align with unit size
+ int aligned_lim = lim - lim_mod;
+
+ if (aligned_pos > lim || aligned_lim < pos) {
+ aligned_pos = aligned_lim = pos;
+ }
+
+ return slice(aligned_pos, aligned_lim);
+ }
+
+ abstract ByteBuffer slice(int pos, int lim);
+
+ // #BIN
+ //
+ // Binary-data access methods for short, char, int, long, float,
+ // and double will be inserted here
+
+#end[byte]
+
+#if[streamableType]
+
+#if[char]
+ @Override
+#end[char]
+ public $Streamtype$Stream $type$s() {
+ return StreamSupport.$streamtype$Stream(() -> new $Type$BufferSpliterator(this),
+ Buffer.SPLITERATOR_CHARACTERISTICS, false);
+ }
+
+#end[streamableType]
+
+}
\ No newline at end of file
diff --git a/ojluni/src/test/java/util/function/PredicateNotTest.java b/ojluni/src/test/java/util/function/PredicateNotTest.java
index 55b3618..4c3ec25 100644
--- a/ojluni/src/test/java/util/function/PredicateNotTest.java
+++ b/ojluni/src/test/java/util/function/PredicateNotTest.java
@@ -28,15 +28,44 @@
*/
package test.java.util.function;
+// Android-added: workaround for d8 backports.
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
import java.util.List;
import java.util.function.Predicate;
import org.testng.annotations.Test;
-import static java.util.function.Predicate.not;
+
import static java.util.stream.Collectors.joining;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
public class PredicateNotTest {
+ // BEGIN Android-added
+ // MethodHandle for invoking Predicate.not() to prevent d8 inserting it's backported
+ // `Predicate.not()` method (b/191859202, OpenJDK 11) and masking test coverage results.
+ static final MethodHandle NOT = initializeNot();
+
+ private static MethodHandle initializeNot()
+ {
+ try {
+ MethodType notType = MethodType.methodType(Predicate.class, Predicate.class);
+ return MethodHandles.lookup().findStatic(Predicate.class, "not", notType);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+
+ static <T> Predicate<T> not​(Predicate<? super T> target) {
+ try {
+ return (Predicate<T>) NOT.invoke(target);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+ // END Android-added
+
static class IsEmptyPredicate implements Predicate<String> {
@Override
public boolean test(String s) {