/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.harmony.nio.tests.java.nio;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.AndroidOnly;
import java.nio.BufferOverflowException;
import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.InvalidMarkException;
import java.nio.LongBuffer;
import java.nio.ReadOnlyBufferException;
import java.nio.ShortBuffer;
import java.util.Arrays;
/**
* Tests java.nio.ByteBuffer
*
*/
@TestTargetClass(ByteBuffer.class)
public abstract class ByteBufferTest extends AbstractBufferTest {
protected static final int SMALL_TEST_LENGTH = 5;
protected static final int BUFFER_LENGTH = 250;
protected ByteBuffer buf;
protected void setUp() throws Exception {
capacity = BUFFER_LENGTH;
buf = ByteBuffer.allocate(BUFFER_LENGTH);
loadTestData1(buf);
baseBuf = buf;
}
protected void tearDown() throws Exception {
super.tearDown();
buf = null;
baseBuf = null;
}
/*
* test for method static ByteBuffer allocate(int capacity)
* test covers following usecases:
* 1. case for check ByteBuffer testBuf properties
* 2. case expected IllegalArgumentException
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "allocate",
args = {int.class}
)
public void test_AllocateI() {
// case: ByteBuffer testBuf properties is satisfy the conditions
// specification
ByteBuffer testBuf = ByteBuffer.allocate(20);
assertEquals(0, testBuf.position());
assertNotNull(testBuf.array());
assertEquals(0, testBuf.arrayOffset());
assertEquals(20, testBuf.limit());
assertEquals(20, testBuf.capacity());
testBuf = ByteBuffer.allocate(0);
assertEquals(0, testBuf.position());
assertNotNull(testBuf.array());
assertEquals(0, testBuf.arrayOffset());
assertEquals(0, testBuf.limit());
assertEquals(0, testBuf.capacity());
// case: expected IllegalArgumentException
try {
testBuf = ByteBuffer.allocate(-20);
fail("allocate method does not throws expected exception");
} catch (IllegalArgumentException e) {
//expected
}
}
/*
* test for method static ByteBuffer allocateDirect(int capacity)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "allocateDirect",
args = {int.class}
)
public void test_AllocateDirectI() {
// case: ByteBuffer testBuf properties is satisfy the conditions
// specification
ByteBuffer testBuf = ByteBuffer.allocateDirect(20);
assertEquals(0, testBuf.position());
assertEquals(20, testBuf.limit());
assertEquals(20, testBuf.capacity());
testBuf = ByteBuffer.allocateDirect(0);
assertEquals(0, testBuf.position());
assertEquals(0, testBuf.limit());
assertEquals(0, testBuf.capacity());
try {
testBuf.array();
fail("Didn't throw expected UnsupportedOperationException.");
} catch (UnsupportedOperationException e) {
//expected
}
try {
testBuf.arrayOffset();
fail("Didn't throw expected UnsupportedOperationException.");
} catch (UnsupportedOperationException e) {
//expected
}
// case: expected IllegalArgumentException
try {
testBuf = ByteBuffer.allocate(-20);
fail("allocate method does not throws expected exception");
} catch (IllegalArgumentException e) {
//expected
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "array",
args = {}
)
public void testArray() {
byte array[] = buf.array();
assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
loadTestData1(array, buf.arrayOffset(), buf.capacity());
assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
loadTestData2(array, buf.arrayOffset(), buf.capacity());
assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
loadTestData1(buf);
assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
loadTestData2(buf);
assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "arrayOffset",
args = {}
)
public void testArrayOffset() {
byte array[] = buf.array();
for(int i = 0; i < buf.capacity(); i++) {
array[i] = (byte) i;
}
int offset = buf.arrayOffset();
assertContentEquals(buf, array, offset, buf.capacity());
ByteBuffer wrapped = ByteBuffer.wrap(array, 3, array.length - 3);
loadTestData1(array, wrapped.arrayOffset(), wrapped.capacity());
assertContentEquals(buf, array, offset, buf.capacity());
loadTestData2(array, wrapped.arrayOffset(), wrapped.capacity());
assertContentEquals(buf, array, offset, buf.capacity());
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "asReadOnlyBuffer",
args = {}
)
public void testAsReadOnlyBuffer() {
loadTestData1(buf);
buf.clear();
buf.mark();
buf.position(buf.limit());
// readonly's contents should be the same as buf
ByteBuffer readonly = buf.asReadOnlyBuffer();
assertNotSame(buf, readonly);
assertTrue(readonly.isReadOnly());
assertEquals(buf.position(), readonly.position());
assertEquals(buf.limit(), readonly.limit());
assertEquals(buf.isDirect(), readonly.isDirect());
assertEquals(buf.order(), readonly.order());
assertContentEquals(buf, readonly);
// readonly's position, mark, and limit should be independent to buf
readonly.reset();
assertEquals(0, readonly.position());
readonly.clear();
assertEquals(buf.position(), buf.limit());
buf.reset();
assertEquals(0, buf.position());
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "compact",
args = {}
)
@AndroidOnly("Fails on RI. See comment below")
public void testCompact() {
if (buf.isReadOnly()) {
try {
buf.compact();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
// case: buffer is full
buf.clear();
buf.mark();
loadTestData1(buf);
ByteBuffer ret = buf.compact();
assertSame(ret, buf);
assertEquals(buf.capacity(), buf.position());
assertEquals(buf.capacity(), buf.limit());
assertContentLikeTestData1(buf, 0, (byte) 0, buf.capacity());
try {
// Fails on RI. Spec doesn't specify the behavior if
// actually nothing to be done by compact(). So RI doesn't reset
// mark position
buf.reset();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (InvalidMarkException e) {
// expected
}
// case: buffer is empty
buf.position(0);
buf.limit(0);
buf.mark();
ret = buf.compact();
assertSame(ret, buf);
assertEquals(0, buf.position());
assertEquals(buf.limit(), buf.capacity());
assertContentLikeTestData1(buf, 0, (byte) 0, buf.capacity());
try {
buf.reset();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (InvalidMarkException e) {
// expected
}
// case: normal
assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
buf.position(1);
buf.limit(SMALL_TEST_LENGTH);
buf.mark();
ret = buf.compact();
assertSame(ret, buf);
assertEquals(4, buf.position());
assertEquals(buf.limit(), buf.capacity());
assertContentLikeTestData1(buf, 0, (byte) 1, 4);
try {
buf.reset();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (InvalidMarkException e) {
// expected
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "compareTo",
args = {java.nio.ByteBuffer.class}
)
public void testCompareTo() {
// compare to self
assertEquals(0, buf.compareTo(buf));
// normal cases
if (!buf.isReadOnly()) {
assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
buf.clear();
ByteBuffer other = ByteBuffer.allocate(buf.capacity());
loadTestData1(buf);
loadTestData1(other);
assertEquals(0, buf.compareTo(other));
assertEquals(0, other.compareTo(buf));
buf.position(1);
assertTrue(buf.compareTo(other) > 0);
assertTrue(other.compareTo(buf) < 0);
other.position(2);
assertTrue(buf.compareTo(other) < 0);
assertTrue(other.compareTo(buf) > 0);
buf.position(2);
other.limit(SMALL_TEST_LENGTH);
assertTrue(buf.compareTo(other) > 0);
assertTrue(other.compareTo(buf) < 0);
}
assertTrue(ByteBuffer.wrap(new byte[21]).compareTo(ByteBuffer.allocateDirect(21)) == 0);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "duplicate",
args = {}
)
public void testDuplicate() {
buf.clear();
buf.mark();
buf.position(buf.limit());
// duplicate's contents should be the same as buf
ByteBuffer duplicate = buf.duplicate();
assertNotSame(buf, duplicate);
assertEquals(buf.position(), duplicate.position());
assertEquals(buf.limit(), duplicate.limit());
assertEquals(buf.isReadOnly(), duplicate.isReadOnly());
assertEquals(buf.isDirect(), duplicate.isDirect());
assertEquals(buf.order(), duplicate.order());
assertContentEquals(buf, duplicate);
// duplicate's position, mark, and limit should be independent to buf
duplicate.reset();
assertEquals(0, duplicate.position());
duplicate.clear();
assertEquals(buf.position(), buf.limit());
buf.reset();
assertEquals(0, buf.position());
// duplicate share the same content with buf
if (!duplicate.isReadOnly()) {
loadTestData1(buf);
assertContentEquals(buf, duplicate);
loadTestData2(duplicate);
assertContentEquals(buf, duplicate);
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
public void testEquals() {
loadTestData1(buf);
// equal to self
assertTrue(buf.equals(buf));
ByteBuffer readonly = buf.asReadOnlyBuffer();
assertTrue(buf.equals(readonly));
ByteBuffer duplicate = buf.duplicate();
assertTrue(buf.equals(duplicate));
// always false, if type mismatch
assertFalse(buf.equals(Boolean.TRUE));
assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
buf.limit(buf.capacity()).position(0);
readonly.limit(readonly.capacity()).position(1);
assertFalse(buf.equals(readonly));
buf.limit(buf.capacity() - 1).position(0);
duplicate.limit(duplicate.capacity()).position(0);
assertFalse(buf.equals(duplicate));
buf.limit(buf.capacity() - 1).position(0);
duplicate.limit(duplicate.capacity()).position(1);
assertFalse(buf.equals(duplicate));
}
/*
* Class under test for byte get()
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "get",
args = {}
)
public void testGet() {
loadTestData1(buf);
buf.clear();
for (int i = 0; i < buf.capacity(); i++) {
assertEquals(i, buf.position());
assertEquals(buf.get(), buf.get(i));
}
try {
buf.get();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
}
/*
* Class under test for java.nio.ByteBuffer get(byte[])
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "get",
args = {byte[].class}
)
public void testGetbyteArray() {
byte array[] = new byte[1];
loadTestData1(buf);
buf.clear();
for (int i = 0; i < buf.capacity(); i++) {
assertEquals(i, buf.position());
ByteBuffer ret = buf.get(array);
assertEquals(array[0], buf.get(i));
assertSame(ret, buf);
}
buf.get(new byte[0]);
try {
buf.get(array);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
try {
buf.get((byte[])null);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (NullPointerException e) {
// expected
}
}
/*
* Class under test for java.nio.ByteBuffer get(byte[], int, int)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "get",
args = {byte[].class, int.class, int.class}
)
public void testGetbyteArrayintint() {
loadTestData1(buf);
buf.clear();
byte array[] = new byte[buf.capacity()];
try {
buf.get(new byte[buf.capacity() + 1], 0, buf.capacity() + 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
assertEquals(0, buf.position());
try {
buf.get(array, -1, array.length);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.get(array, array.length, 0);
try {
buf.get(array, array.length + 1, 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
assertEquals(0, buf.position());
try {
buf.get(array, 2, -1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.get(array, 2, array.length);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.get((byte[])null, -1, 0);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (NullPointerException e) {
// expected
}
try {
buf.get(array, 1, Integer.MAX_VALUE);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.get(array, Integer.MAX_VALUE, 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
assertEquals(0, buf.position());
buf.clear();
ByteBuffer ret = buf.get(array, 0, array.length);
assertEquals(buf.position(), buf.capacity());
assertContentEquals(buf, array, 0, array.length);
assertSame(ret, buf);
}
/*
* Class under test for byte get(int)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "get",
args = {int.class}
)
public void testGetint() {
loadTestData1(buf);
buf.clear();
for (int i = 0; i < buf.capacity(); i++) {
assertEquals(i, buf.position());
assertEquals(buf.get(), buf.get(i));
}
try {
buf.get(-1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.get(buf.limit());
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies hasArray method for wrapped ByteBuffer.",
method = "hasArray",
args = {}
)
public void testHasArray() {
assertTrue(buf.hasArray());
assertNotNull(buf.array());
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
public void testHashCode() {
buf.clear();
loadTestData1(buf);
ByteBuffer readonly = buf.asReadOnlyBuffer();
ByteBuffer duplicate = buf.duplicate();
assertTrue(buf.hashCode() == readonly.hashCode());
assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
duplicate.position(buf.capacity()/2);
assertTrue(buf.hashCode()!= duplicate.hashCode());
}
//for the testHashCode() method of readonly subclasses
protected void readOnlyHashCode(boolean direct) {
//create a new buffer initiated with some data
ByteBuffer buf;
if (direct) {
buf = ByteBuffer.allocateDirect(BUFFER_LENGTH);
} else {
buf = ByteBuffer.allocate(BUFFER_LENGTH);
}
loadTestData1(buf);
buf = buf.asReadOnlyBuffer();
buf.clear();
ByteBuffer readonly = buf.asReadOnlyBuffer();
ByteBuffer duplicate = buf.duplicate();
assertEquals(buf.hashCode(),readonly.hashCode());
duplicate.position(buf.capacity()/2);
assertTrue(buf.hashCode()!= duplicate.hashCode());
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies isDirect method with not direct buffer.",
method = "isDirect",
args = {}
)
public void testIsDirect() {
assertFalse(buf.isDirect());
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "isReadOnly",
args = {}
)
public void testIsReadOnly() {
assertFalse(buf.isReadOnly());
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "order",
args = {}
)
public void testOrder() {
// BIG_ENDIAN is the default byte order
assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
buf.order(ByteOrder.LITTLE_ENDIAN);
assertEquals(ByteOrder.LITTLE_ENDIAN, buf.order());
buf.order(ByteOrder.BIG_ENDIAN);
assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
// Regression test for HARMONY-798
buf.order((ByteOrder)null);
assertEquals(ByteOrder.LITTLE_ENDIAN, buf.order());
buf.order(ByteOrder.BIG_ENDIAN);
}
/*
* test for method public final ByteBuffer order(ByteOrder bo)
* test covers following usecases:
* 1. case for check
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "order",
args = {java.nio.ByteOrder.class}
)
public void test_OrderLjava_lang_ByteOrder() {
// BIG_ENDIAN is the default byte order
assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
buf.order(ByteOrder.LITTLE_ENDIAN);
assertEquals(ByteOrder.LITTLE_ENDIAN, buf.order());
buf.order(ByteOrder.BIG_ENDIAN);
assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
// Regression test for HARMONY-798
buf.order((ByteOrder)null);
assertEquals(ByteOrder.LITTLE_ENDIAN, buf.order());
buf.order(ByteOrder.BIG_ENDIAN);
}
/*
* Class under test for java.nio.ByteBuffer put(byte)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "put",
args = {byte.class}
)
public void testPutbyte() {
if (buf.isReadOnly()) {
try {
buf.clear();
buf.put((byte) 0);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
buf.clear();
for (int i = 0; i < buf.capacity(); i++) {
assertEquals(i, buf.position());
ByteBuffer ret = buf.put((byte) i);
assertEquals((byte) i, buf.get(i));
assertSame(ret, buf);
}
try {
buf.put((byte) 0);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
buf.rewind();
buf.put(Byte.MAX_VALUE);
assertEquals(Byte.MAX_VALUE, buf.get(0));
buf.rewind();
buf.put(Byte.MIN_VALUE);
assertEquals(Byte.MIN_VALUE, buf.get(0));
}
/*
* Class under test for java.nio.ByteBuffer put(byte[])
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "put",
args = {byte[].class}
)
public void testPutbyteArray() {
byte array[] = new byte[1];
if (buf.isReadOnly()) {
try {
buf.put(array);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
buf.clear();
for (int i = 0; i < buf.capacity(); i++) {
assertEquals(i, buf.position());
array[0] = (byte) i;
ByteBuffer ret = buf.put(array);
assertEquals((byte) i, buf.get(i));
assertSame(ret, buf);
}
try {
buf.put(array);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
try {
buf.put((byte[])null);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (NullPointerException e) {
// expected
}
}
/*
* Class under test for java.nio.ByteBuffer put(byte[], int, int)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "put",
args = {byte[].class, int.class, int.class}
)
public void testPutbyteArrayintint() {
buf.clear();
byte array[] = new byte[buf.capacity()];
if (buf.isReadOnly()) {
try {
buf.put(array, 0, array.length);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
try {
buf.put(new byte[buf.capacity() + 1], 0, buf.capacity() + 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
assertEquals(0, buf.position());
try {
buf.put(array, -1, array.length);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.put(array, array.length + 1, 0);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.put(array, array.length, 0);
assertEquals(0, buf.position());
try {
buf.put(array, 0, -1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.put(array, 2, array.length);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.put(array, 2, Integer.MAX_VALUE);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.put(array, Integer.MAX_VALUE, 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.put((byte[])null, 2, Integer.MAX_VALUE);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (NullPointerException e) {
// expected
}
assertEquals(0, buf.position());
loadTestData2(array, 0, array.length);
ByteBuffer ret = buf.put(array, 0, array.length);
assertEquals(buf.position(), buf.capacity());
assertContentEquals(buf, array, 0, array.length);
assertSame(ret, buf);
}
/*
* Class under test for java.nio.ByteBuffer put(java.nio.ByteBuffer)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "put",
args = {java.nio.ByteBuffer.class}
)
public void testPutByteBuffer() {
ByteBuffer other = ByteBuffer.allocate(buf.capacity());
if (buf.isReadOnly()) {
try {
buf.clear();
buf.put(other);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
try {
buf.clear();
buf.put((ByteBuffer)null);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
try {
buf.put(buf);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
// expected
}
try {
buf.put(ByteBuffer.allocate(buf.capacity() + 1));
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
try {
buf.put((ByteBuffer)null);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (NullPointerException e) {
// expected
}
loadTestData2(other);
other.clear();
buf.clear();
ByteBuffer ret = buf.put(other);
assertEquals(other.position(), other.capacity());
assertEquals(buf.position(), buf.capacity());
assertContentEquals(other, buf);
assertSame(ret, buf);
}
/*
* Class under test for java.nio.ByteBuffer put(int, byte)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "put",
args = {int.class, byte.class}
)
public void testPutintbyte() {
if (buf.isReadOnly()) {
try {
buf.put(0, (byte) 0);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
buf.clear();
for (int i = 0; i < buf.capacity(); i++) {
assertEquals(0, buf.position());
ByteBuffer ret = buf.put(i, (byte) i);
assertEquals((byte) i, buf.get(i));
assertSame(ret, buf);
}
try {
buf.put(-1, (byte) 0);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.put(buf.limit(), (byte) 0);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.put(0, Byte.MAX_VALUE);
assertEquals(Byte.MAX_VALUE, buf.get(0));
buf.put(0, Byte.MIN_VALUE);
assertEquals(Byte.MIN_VALUE, buf.get(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "slice",
args = {}
)
public void testSlice() {
loadTestData1(buf);
assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
buf.position(1);
buf.limit(buf.capacity() - 1);
ByteBuffer slice = buf.slice();
assertEquals(buf.isReadOnly(), slice.isReadOnly());
assertEquals(buf.isDirect(), slice.isDirect());
assertEquals(buf.order(), slice.order());
assertEquals(0, slice.position());
assertEquals(buf.remaining(), slice.limit());
assertEquals(buf.remaining(), slice.capacity());
try {
slice.reset();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (InvalidMarkException e) {
// expected
}
// slice share the same content with buf
if (!slice.isReadOnly()) {
loadTestData1(slice);
assertContentLikeTestData1(buf, 1, (byte) 0, slice.capacity());
buf.put(2, (byte) 100);
assertEquals(100, slice.get(1));
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "toString",
args = {}
)
public void testToString() {
String str = buf.toString();
assertTrue(str.indexOf("Byte") >= 0 || str.indexOf("byte") >= 0);
assertTrue(str.indexOf("" + buf.position()) >= 0);
assertTrue(str.indexOf("" + buf.limit()) >= 0);
assertTrue(str.indexOf("" + buf.capacity()) >= 0);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "asCharBuffer",
args = {}
)
public void testAsCharBuffer() {
CharBuffer charBuffer;
byte bytes[] = new byte[2];
char value;
loadTestData1(buf);
// test BIG_ENDIAN char buffer, read
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
charBuffer = buf.asCharBuffer();
assertSame(ByteOrder.BIG_ENDIAN, charBuffer.order());
while (charBuffer.remaining() > 0) {
buf.get(bytes);
value = charBuffer.get();
assertEquals(bytes2char(bytes, buf.order()), value);
}
// test LITTLE_ENDIAN char buffer, read
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
charBuffer = buf.asCharBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, charBuffer.order());
while (charBuffer.remaining() > 0) {
buf.get(bytes);
value = charBuffer.get();
assertEquals(bytes2char(bytes, buf.order()), value);
}
if (!buf.isReadOnly()) {
// test BIG_ENDIAN char buffer, write
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
charBuffer = buf.asCharBuffer();
assertSame(ByteOrder.BIG_ENDIAN, charBuffer.order());
while (charBuffer.remaining() > 0) {
value = (char) charBuffer.remaining();
charBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, char2bytes(value, buf.order())));
}
// test LITTLE_ENDIAN char buffer, write
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
charBuffer = buf.asCharBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, charBuffer.order());
while (charBuffer.remaining() > 0) {
value = (char) charBuffer.remaining();
charBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, char2bytes(value, buf.order())));
}
}
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "asDoubleBuffer",
args = {}
)
public void testAsDoubleBuffer() {
DoubleBuffer doubleBuffer;
byte bytes[] = new byte[8];
double value;
loadTestData1(buf);
// test BIG_ENDIAN double buffer, read
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
doubleBuffer = buf.asDoubleBuffer();
assertSame(ByteOrder.BIG_ENDIAN, doubleBuffer.order());
while (doubleBuffer.remaining() > 0) {
buf.get(bytes);
value = doubleBuffer.get();
if (!(Double.isNaN(bytes2double(bytes, buf.order())) && Double
.isNaN(value))) {
assertEquals(bytes2double(bytes, buf.order()), value, 0.00);
}
}
// test LITTLE_ENDIAN double buffer, read
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
doubleBuffer = buf.asDoubleBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, doubleBuffer.order());
while (doubleBuffer.remaining() > 0) {
buf.get(bytes);
value = doubleBuffer.get();
if (!(Double.isNaN(bytes2double(bytes, buf.order())) && Double
.isNaN(value))) {
assertEquals(bytes2double(bytes, buf.order()), value, 0.00);
}
}
if (!buf.isReadOnly()) {
// test BIG_ENDIAN double buffer, write
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
doubleBuffer = buf.asDoubleBuffer();
assertSame(ByteOrder.BIG_ENDIAN, doubleBuffer.order());
while (doubleBuffer.remaining() > 0) {
value = doubleBuffer.remaining();
doubleBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, double2bytes(value, buf.order())));
}
// test LITTLE_ENDIAN double buffer, write
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
doubleBuffer = buf.asDoubleBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, doubleBuffer.order());
while (doubleBuffer.remaining() > 0) {
value = doubleBuffer.remaining();
doubleBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, double2bytes(value, buf.order())));
}
}
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "asFloatBuffer",
args = {}
)
public void testAsFloatBuffer() {
FloatBuffer floatBuffer;
byte bytes[] = new byte[4];
float value;
loadTestData1(buf);
// test BIG_ENDIAN float buffer, read
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
floatBuffer = buf.asFloatBuffer();
assertSame(ByteOrder.BIG_ENDIAN, floatBuffer.order());
while (floatBuffer.remaining() > 0) {
buf.get(bytes);
value = floatBuffer.get();
if (!(Float.isNaN(bytes2float(bytes, buf.order())) && Float
.isNaN(value))) {
assertEquals(bytes2float(bytes, buf.order()), value, 0.00);
}
}
// test LITTLE_ENDIAN float buffer, read
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
floatBuffer = buf.asFloatBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, floatBuffer.order());
while (floatBuffer.remaining() > 0) {
buf.get(bytes);
value = floatBuffer.get();
if (!(Float.isNaN(bytes2float(bytes, buf.order())) && Float
.isNaN(value))) {
assertEquals(bytes2float(bytes, buf.order()), value, 0.00);
}
}
if (!buf.isReadOnly()) {
// test BIG_ENDIAN float buffer, write
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
floatBuffer = buf.asFloatBuffer();
assertSame(ByteOrder.BIG_ENDIAN, floatBuffer.order());
while (floatBuffer.remaining() > 0) {
value = floatBuffer.remaining();
floatBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, float2bytes(value, buf.order())));
}
// test LITTLE_ENDIAN float buffer, write
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
floatBuffer = buf.asFloatBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, floatBuffer.order());
while (floatBuffer.remaining() > 0) {
value = floatBuffer.remaining();
floatBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, float2bytes(value, buf.order())));
}
}
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "asIntBuffer",
args = {}
)
public void testAsIntBuffer() {
IntBuffer intBuffer;
byte bytes[] = new byte[4];
int value;
loadTestData1(buf);
// test BIG_ENDIAN int buffer, read
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
intBuffer = buf.asIntBuffer();
assertSame(ByteOrder.BIG_ENDIAN, intBuffer.order());
while (intBuffer.remaining() > 0) {
buf.get(bytes);
value = intBuffer.get();
assertEquals(bytes2int(bytes, buf.order()), value);
}
// test LITTLE_ENDIAN int buffer, read
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
intBuffer = buf.asIntBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, intBuffer.order());
while (intBuffer.remaining() > 0) {
buf.get(bytes);
value = intBuffer.get();
assertEquals(bytes2int(bytes, buf.order()), value);
}
if (!buf.isReadOnly()) {
// test BIG_ENDIAN int buffer, write
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
intBuffer = buf.asIntBuffer();
assertSame(ByteOrder.BIG_ENDIAN, intBuffer.order());
while (intBuffer.remaining() > 0) {
value = intBuffer.remaining();
intBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, int2bytes(value, buf.order())));
}
// test LITTLE_ENDIAN int buffer, write
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
intBuffer = buf.asIntBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, intBuffer.order());
while (intBuffer.remaining() > 0) {
value = intBuffer.remaining();
intBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, int2bytes(value, buf.order())));
}
}
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "asLongBuffer",
args = {}
)
public void testAsLongBuffer() {
LongBuffer longBuffer;
byte bytes[] = new byte[8];
long value;
loadTestData1(buf);
// test BIG_ENDIAN long buffer, read
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
longBuffer = buf.asLongBuffer();
assertSame(ByteOrder.BIG_ENDIAN, longBuffer.order());
while (longBuffer.remaining() > 0) {
buf.get(bytes);
value = longBuffer.get();
assertEquals(bytes2long(bytes, buf.order()), value);
}
// test LITTLE_ENDIAN long buffer, read
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
longBuffer = buf.asLongBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, longBuffer.order());
while (longBuffer.remaining() > 0) {
buf.get(bytes);
value = longBuffer.get();
assertEquals(bytes2long(bytes, buf.order()), value);
}
if (!buf.isReadOnly()) {
// test BIG_ENDIAN long buffer, write
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
longBuffer = buf.asLongBuffer();
assertSame(ByteOrder.BIG_ENDIAN, longBuffer.order());
while (longBuffer.remaining() > 0) {
value = longBuffer.remaining();
longBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, long2bytes(value, buf.order())));
}
// test LITTLE_ENDIAN long buffer, write
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
longBuffer = buf.asLongBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, longBuffer.order());
while (longBuffer.remaining() > 0) {
value = longBuffer.remaining();
longBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, long2bytes(value, buf.order())));
}
}
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "asShortBuffer",
args = {}
)
public void testAsShortBuffer() {
ShortBuffer shortBuffer;
byte bytes[] = new byte[2];
short value;
loadTestData1(buf);
// test BIG_ENDIAN short buffer, read
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
shortBuffer = buf.asShortBuffer();
assertSame(ByteOrder.BIG_ENDIAN, shortBuffer.order());
while (shortBuffer.remaining() > 0) {
buf.get(bytes);
value = shortBuffer.get();
assertEquals(bytes2short(bytes, buf.order()), value);
}
// test LITTLE_ENDIAN short buffer, read
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
shortBuffer = buf.asShortBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, shortBuffer.order());
while (shortBuffer.remaining() > 0) {
buf.get(bytes);
value = shortBuffer.get();
assertEquals(bytes2short(bytes, buf.order()), value);
}
if (!buf.isReadOnly()) {
// test BIG_ENDIAN short buffer, write
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
shortBuffer = buf.asShortBuffer();
assertSame(ByteOrder.BIG_ENDIAN, shortBuffer.order());
while (shortBuffer.remaining() > 0) {
value = (short) shortBuffer.remaining();
shortBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, short2bytes(value, buf.order())));
}
// test LITTLE_ENDIAN short buffer, write
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
shortBuffer = buf.asShortBuffer();
assertSame(ByteOrder.LITTLE_ENDIAN, shortBuffer.order());
while (shortBuffer.remaining() > 0) {
value = (short) shortBuffer.remaining();
shortBuffer.put(value);
buf.get(bytes);
assertTrue(Arrays.equals(bytes, short2bytes(value, buf.order())));
}
}
buf.clear();
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getChar",
args = {}
)
public void testGetChar() {
int nbytes = 2;
byte bytes[] = new byte[nbytes];
char value;
loadTestData1(buf);
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
assertEquals(i * nbytes, buf.position());
buf.mark();
buf.get(bytes);
buf.reset();
value = buf.getChar();
assertEquals(bytes2char(bytes, buf.order()), value);
}
try {
buf.getChar();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getChar",
args = {int.class}
)
public void testGetCharint() {
int nbytes = 2;
byte bytes[] = new byte[nbytes];
char value;
loadTestData1(buf);
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
buf.position(i);
value = buf.getChar(i);
assertEquals(i, buf.position());
buf.get(bytes);
assertEquals(bytes2char(bytes, buf.order()), value);
}
try {
buf.getChar(-1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.getChar(buf.limit() - nbytes + 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putChar",
args = {char.class}
)
public void testPutChar() {
if (buf.isReadOnly()) {
try {
buf.clear();
buf.putChar((char) 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 2;
byte bytes[] = new byte[nbytes];
char value = 0;
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = (char) i;
buf.mark();
buf.putChar(value);
assertEquals((i + 1) * nbytes, buf.position());
buf.reset();
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(char2bytes(value, buf.order()), bytes));
}
try {
buf.putChar(value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.rewind();
buf.putChar(0, Character.MAX_VALUE);
assertEquals(Character.MAX_VALUE, buf.getChar(0));
buf.rewind();
buf.putChar(0, Character.MIN_VALUE);
assertEquals(Character.MIN_VALUE, buf.getChar(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putChar",
args = {int.class, char.class}
)
public void testPutCharint() {
if (buf.isReadOnly()) {
try {
buf.putChar(0, (char) 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 2;
byte bytes[] = new byte[nbytes];
char value = 0;
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = (char) i;
buf.position(i);
buf.putChar(i, value);
assertEquals(i, buf.position());
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(char2bytes(value, buf.order()), bytes));
}
try {
buf.putChar(-1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.putChar(buf.limit() - nbytes + 1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
try {
ByteBuffer.allocateDirect(16).putChar(Integer.MAX_VALUE, 'h');
} catch (IndexOutOfBoundsException e) {
//expected
}
buf.putChar(0, Character.MAX_VALUE);
assertEquals(Character.MAX_VALUE, buf.getChar(0));
buf.putChar(0, Character.MIN_VALUE);
assertEquals(Character.MIN_VALUE, buf.getChar(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getDouble",
args = {}
)
public void testGetDouble() {
int nbytes = 8;
byte bytes[] = new byte[nbytes];
double value;
loadTestData1(buf);
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
assertEquals(i * nbytes, buf.position());
buf.mark();
buf.get(bytes);
buf.reset();
value = buf.getDouble();
if (!(Double.isNaN(bytes2double(bytes, buf.order())) && Double
.isNaN(value))) {
assertEquals(bytes2double(bytes, buf.order()), value, 0.00);
}
}
try {
buf.getDouble();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getDouble",
args = {int.class}
)
public void testGetDoubleint() {
int nbytes = 8;
byte bytes[] = new byte[nbytes];
double value;
loadTestData1(buf);
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
buf.position(i);
value = buf.getDouble(i);
assertEquals(i, buf.position());
buf.get(bytes);
if (!(Double.isNaN(bytes2double(bytes, buf.order())) && Double
.isNaN(value))) {
assertEquals(bytes2double(bytes, buf.order()), value, 0.00);
}
}
try {
buf.getDouble(-1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.getDouble(buf.limit() - nbytes + 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
try {
ByteBuffer.allocateDirect(16).getDouble(Integer.MAX_VALUE);
} catch (IndexOutOfBoundsException e) {
//expected
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putDouble",
args = {double.class}
)
public void testPutDouble() {
if (buf.isReadOnly()) {
try {
buf.clear();
buf.putDouble(1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 8;
byte bytes[] = new byte[nbytes];
double value = 0;
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = i;
buf.mark();
buf.putDouble(value);
assertEquals((i + 1) * nbytes, buf.position());
buf.reset();
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(double2bytes(value, buf.order()), bytes));
}
try {
buf.putDouble(value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.rewind();
buf.putDouble(Double.MAX_VALUE);
assertEquals(Double.MAX_VALUE, buf.getDouble(0));
buf.rewind();
buf.putDouble(Double.MIN_VALUE);
assertEquals(Double.MIN_VALUE, buf.getDouble(0));
buf.rewind();
buf.putDouble(Double.NaN);
assertEquals(Double.NaN, buf.getDouble(0));
buf.rewind();
buf.putDouble(Double.NEGATIVE_INFINITY);
assertEquals(Double.NEGATIVE_INFINITY, buf.getDouble(0));
buf.rewind();
buf.putDouble(Double.POSITIVE_INFINITY);
assertEquals(Double.POSITIVE_INFINITY, buf.getDouble(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putDouble",
args = {int.class, double.class}
)
public void testPutDoubleint() {
if (buf.isReadOnly()) {
try {
buf.putDouble(0, 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 8;
byte bytes[] = new byte[nbytes];
double value = 0;
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = i;
buf.position(i);
buf.putDouble(i, value);
assertEquals(i, buf.position());
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(double2bytes(value, buf.order()), bytes));
}
try {
buf.putDouble(-1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.putDouble(buf.limit() - nbytes + 1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.putDouble(0, Double.MAX_VALUE);
assertEquals(Double.MAX_VALUE, buf.getDouble(0));
buf.putDouble(0, Double.MIN_VALUE);
assertEquals(Double.MIN_VALUE, buf.getDouble(0));
buf.putDouble(0, Double.NaN);
assertEquals(Double.NaN, buf.getDouble(0));
buf.putDouble(0, Double.NEGATIVE_INFINITY);
assertEquals(Double.NEGATIVE_INFINITY, buf.getDouble(0));
buf.putDouble(0, Double.POSITIVE_INFINITY);
assertEquals(Double.POSITIVE_INFINITY, buf.getDouble(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getFloat",
args = {}
)
public void testGetFloat() {
int nbytes = 4;
byte bytes[] = new byte[nbytes];
float value;
loadTestData1(buf);
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
assertEquals(i * nbytes, buf.position());
buf.mark();
buf.get(bytes);
buf.reset();
value = buf.getFloat();
if (!(Float.isNaN(bytes2float(bytes, buf.order())) && Float
.isNaN(value))) {
assertEquals(bytes2float(bytes, buf.order()), value, 0.00);
}
}
try {
buf.getFloat();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getFloat",
args = {int.class}
)
public void testGetFloatint() {
int nbytes = 4;
byte bytes[] = new byte[nbytes];
float value;
loadTestData1(buf);
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
buf.position(i);
value = buf.getFloat(i);
assertEquals(i, buf.position());
buf.get(bytes);
if (!(Float.isNaN(bytes2float(bytes, buf.order())) && Float
.isNaN(value))) {
assertEquals(bytes2float(bytes, buf.order()), value, 0.00);
}
}
try {
buf.getFloat(-1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.getFloat(buf.limit() - nbytes + 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putFloat",
args = {float.class}
)
public void testPutFloat() {
if (buf.isReadOnly()) {
try {
buf.clear();
buf.putFloat(1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 4;
byte bytes[] = new byte[nbytes];
float value = 0;
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = i;
buf.mark();
buf.putFloat(value);
assertEquals((i + 1) * nbytes, buf.position());
buf.reset();
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(float2bytes(value, buf.order()), bytes));
}
try {
buf.putFloat(value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.rewind();
buf.putFloat(Float.MAX_VALUE);
assertEquals(Float.MAX_VALUE, buf.getFloat(0));
buf.rewind();
buf.putFloat(Float.MIN_VALUE);
assertEquals(Float.MIN_VALUE, buf.getFloat(0));
buf.rewind();
buf.putFloat(Float.NaN);
assertEquals(Float.NaN, buf.getFloat(0));
buf.rewind();
buf.putFloat(Float.NEGATIVE_INFINITY);
assertEquals(Float.NEGATIVE_INFINITY, buf.getFloat(0));
buf.rewind();
buf.putFloat(Float.POSITIVE_INFINITY);
assertEquals(Float.POSITIVE_INFINITY, buf.getFloat(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putFloat",
args = {int.class, float.class}
)
public void testPutFloatint() {
if (buf.isReadOnly()) {
try {
buf.putFloat(0, 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 4;
byte bytes[] = new byte[nbytes];
float value = 0;
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = i;
buf.position(i);
buf.putFloat(i, value);
assertEquals(i, buf.position());
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(float2bytes(value, buf.order()), bytes));
}
try {
buf.putFloat(-1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.putFloat(buf.limit() - nbytes + 1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.putFloat(0, Float.MAX_VALUE);
assertEquals(Float.MAX_VALUE, buf.getFloat(0));
buf.putFloat(0, Float.MIN_VALUE);
assertEquals(Float.MIN_VALUE, buf.getFloat(0));
buf.putFloat(0, Float.NaN);
assertEquals(Float.NaN, buf.getFloat(0));
buf.putFloat(0, Float.NEGATIVE_INFINITY);
assertEquals(Float.NEGATIVE_INFINITY, buf.getFloat(0));
buf.putFloat(0, Float.POSITIVE_INFINITY);
assertEquals(Float.POSITIVE_INFINITY, buf.getFloat(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getInt",
args = {}
)
public void testGetInt() {
int nbytes = 4;
byte bytes[] = new byte[nbytes];
int value;
loadTestData1(buf);
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
assertEquals(i * nbytes, buf.position());
buf.mark();
buf.get(bytes);
buf.reset();
value = buf.getInt();
assertEquals(bytes2int(bytes, buf.order()), value);
}
try {
buf.getInt();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getInt",
args = {int.class}
)
public void testGetIntint() {
int nbytes = 4;
byte bytes[] = new byte[nbytes];
int value;
loadTestData1(buf);
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
buf.position(i);
value = buf.getInt(i);
assertEquals(i, buf.position());
buf.get(bytes);
assertEquals(bytes2int(bytes, buf.order()), value);
}
try {
buf.getInt(-1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.getInt(buf.limit() - nbytes + 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
try {
ByteBuffer.allocateDirect(16).getInt(Integer.MAX_VALUE);
} catch (IndexOutOfBoundsException e) {
//expected
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putInt",
args = {int.class}
)
public void testPutInt() {
if (buf.isReadOnly()) {
try {
buf.clear();
buf.putInt(1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 4;
byte bytes[] = new byte[nbytes];
int value = 0;
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = i;
buf.mark();
buf.putInt(value);
assertEquals((i + 1) * nbytes, buf.position());
buf.reset();
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(int2bytes(value, buf.order()), bytes));
}
try {
buf.putInt(value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.rewind();
buf.putInt(Integer.MAX_VALUE);
assertEquals(Integer.MAX_VALUE, buf.getInt(0));
buf.rewind();
buf.putInt(Integer.MIN_VALUE);
assertEquals(Integer.MIN_VALUE, buf.getInt(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putInt",
args = {int.class, int.class}
)
public void testPutIntint() {
if (buf.isReadOnly()) {
try {
buf.putInt(0, 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 4;
byte bytes[] = new byte[nbytes];
int value = 0;
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = i;
buf.position(i);
buf.putInt(i, value);
assertEquals(i, buf.position());
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(int2bytes(value, buf.order()), bytes));
}
try {
buf.putInt(-1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.putInt(buf.limit() - nbytes + 1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.putInt(0, Integer.MAX_VALUE);
assertEquals(Integer.MAX_VALUE, buf.getInt(0));
buf.putInt(0, Integer.MIN_VALUE);
assertEquals(Integer.MIN_VALUE, buf.getInt(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getLong",
args = {}
)
public void testGetLong() {
int nbytes = 8;
byte bytes[] = new byte[nbytes];
long value;
loadTestData1(buf);
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
assertEquals(i * nbytes, buf.position());
buf.mark();
buf.get(bytes);
buf.reset();
value = buf.getLong();
assertEquals(bytes2long(bytes, buf.order()), value);
}
try {
buf.getLong();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getLong",
args = {int.class}
)
public void testGetLongint() {
int nbytes = 8;
byte bytes[] = new byte[nbytes];
long value;
loadTestData1(buf);
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
buf.position(i);
value = buf.getLong(i);
assertEquals(i, buf.position());
buf.get(bytes);
assertEquals(bytes2long(bytes, buf.order()), value);
}
try {
buf.getLong(-1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.getLong(buf.limit() - nbytes + 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putLong",
args = {long.class}
)
public void testPutLong() {
if (buf.isReadOnly()) {
try {
buf.clear();
buf.putLong(1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 8;
byte bytes[] = new byte[nbytes];
long value = 0;
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = i;
buf.mark();
buf.putLong(value);
assertEquals((i + 1) * nbytes, buf.position());
buf.reset();
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(long2bytes(value, buf.order()), bytes));
}
try {
buf.putLong(value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.rewind();
buf.putLong(Long.MAX_VALUE);
assertEquals(Long.MAX_VALUE, buf.getLong(0));
buf.rewind();
buf.putLong(Long.MIN_VALUE);
assertEquals(Long.MIN_VALUE, buf.getLong(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putLong",
args = {int.class, long.class}
)
public void testPutLongint() {
if (buf.isReadOnly()) {
try {
buf.putLong(0, 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 8;
byte bytes[] = new byte[nbytes];
long value = 0;
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = i;
buf.position(i);
buf.putLong(i, value);
assertEquals(i, buf.position());
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(long2bytes(value, buf.order()), bytes));
}
try {
buf.putLong(-1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.putLong(buf.limit() - nbytes + 1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.putLong(0, Long.MAX_VALUE);
assertEquals(Long.MAX_VALUE, buf.getLong(0));
buf.putLong(0, Long.MIN_VALUE);
assertEquals(Long.MIN_VALUE, buf.getLong(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getShort",
args = {}
)
public void testGetShort() {
int nbytes = 2;
byte bytes[] = new byte[nbytes];
short value;
loadTestData1(buf);
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
assertEquals(i * nbytes, buf.position());
buf.mark();
buf.get(bytes);
buf.reset();
value = buf.getShort();
assertEquals(bytes2short(bytes, buf.order()), value);
}
try {
buf.getShort();
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferUnderflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getShort",
args = {int.class}
)
public void testGetShortint() {
int nbytes = 2;
byte bytes[] = new byte[nbytes];
short value;
loadTestData1(buf);
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
buf.position(i);
value = buf.getShort(i);
assertEquals(i, buf.position());
buf.get(bytes);
assertEquals(bytes2short(bytes, buf.order()), value);
}
try {
buf.getShort(-1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.getShort(buf.limit() - nbytes + 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putShort",
args = {short.class}
)
public void testPutShort() {
if (buf.isReadOnly()) {
try {
buf.clear();
buf.putShort((short) 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 2;
byte bytes[] = new byte[nbytes];
short value = 0;
buf.clear();
for (int i = 0; buf.remaining() >= nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = (short) i;
buf.mark();
buf.putShort(value);
assertEquals((i + 1) * nbytes, buf.position());
buf.reset();
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(short2bytes(value, buf.order()), bytes));
}
try {
buf.putShort(value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (BufferOverflowException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.rewind();
buf.putShort(Short.MAX_VALUE);
assertEquals(Short.MAX_VALUE, buf.getShort(0));
buf.rewind();
buf.putShort(Short.MIN_VALUE);
assertEquals(Short.MIN_VALUE, buf.getShort(0));
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "putShort",
args = {int.class, short.class}
)
public void testPutShortint() {
if (buf.isReadOnly()) {
try {
buf.putShort(0, (short) 1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (ReadOnlyBufferException e) {
// expected
}
return;
}
int nbytes = 2;
byte bytes[] = new byte[nbytes];
short value = 0;
buf.clear();
for (int i = 0; i <= buf.limit() - nbytes; i++) {
buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
: ByteOrder.LITTLE_ENDIAN);
value = (short) i;
buf.position(i);
buf.putShort(i, value);
assertEquals(i, buf.position());
buf.get(bytes);
assertTrue("Wrong value at " + i,
Arrays.equals(short2bytes(value, buf.order()), bytes));
}
try {
buf.putShort(-1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
buf.putShort(buf.limit() - nbytes + 1, value);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
// expected
}
buf.order(ByteOrder.BIG_ENDIAN);
buf.putShort(0, Short.MAX_VALUE);
assertEquals(Short.MAX_VALUE, buf.getShort(0));
buf.putShort(0, Short.MIN_VALUE);
assertEquals(Short.MIN_VALUE, buf.getShort(0));
}
/**
* @tests java.nio.ByteBuffer.wrap(byte[],int,int)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Regression test. Verifies NullPointerException, IndexOutOfBoundsException.",
method = "wrap",
args = {byte[].class, int.class, int.class}
)
public void testWrappedByteBuffer_null_array() {
// Regression for HARMONY-264
byte array[] = null;
try {
ByteBuffer.wrap(array, -1, 0);
fail("Should throw NPE"); //$NON-NLS-1$
} catch (NullPointerException e) {
}
try {
ByteBuffer.wrap(new byte[10], Integer.MAX_VALUE, 2);
fail("Should throw IndexOutOfBoundsException"); //$NON-NLS-1$
} catch (IndexOutOfBoundsException e) {
}
}
/*
* test for method static ByteBuffer wrap(byte[] array)
* test covers following usecases:
* 1. case for check ByteBuffer buf2 properties
* 2. case for check equal between buf2 and byte array[]
* 3. case for check a buf2 dependens to array[]
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "wrap",
args = {byte[].class}
)
public void test_Wrap$B() {
byte array[] = new byte[BUFFER_LENGTH];
loadTestData1(array, 0, BUFFER_LENGTH);
ByteBuffer buf2 = ByteBuffer.wrap(array);
// case: ByteBuffer buf2 properties is satisfy the conditions specification
assertEquals(array.length, buf2.capacity());
assertEquals(array.length, buf2.limit());
assertEquals(0, buf2.position());
// case: ByteBuffer buf2 is equal to byte array[]
assertContentEquals(buf2, array, 0, array.length);
// case: ByteBuffer buf2 is depended to byte array[]
loadTestData2(array, 0, buf.capacity());
assertContentEquals(buf2, array, 0, array.length);
}
/*
* test for method static ByteBuffer wrap(byte[] array, int offset, int length)
* test covers following usecases:
* 1. case for check ByteBuffer buf2 properties
* 2. case for check equal between buf2 and byte array[]
* 3. case for check a buf2 dependens to array[]
* 4. case expected IndexOutOfBoundsException
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "wrap",
args = {byte[].class, int.class, int.class}
)
public void test_Wrap$BII() {
byte array[] = new byte[BUFFER_LENGTH];
int offset = 5;
int length = BUFFER_LENGTH - offset;
loadTestData1(array, 0, BUFFER_LENGTH);
ByteBuffer buf2 = ByteBuffer.wrap(array, offset, length);
// case: ByteBuffer buf2 properties is satisfy the conditions specification
assertEquals(array.length, buf2.capacity());
assertEquals(offset, buf2.position());
assertEquals(offset + length, buf2.limit());
assertEquals(0, buf2.arrayOffset());
// case: ByteBuffer buf2 is equal to byte array[]
assertContentEquals(buf2, array, 0, array.length);
// case: ByteBuffer buf2 is depended to byte array[]
loadTestData2(array, 0, buf.capacity());
assertContentEquals(buf2, array, 0, array.length);
// case: expected IndexOutOfBoundsException
try {
offset = 7;
buf2 = ByteBuffer.wrap(array, offset, length);
fail("wrap method does not throws expected exception");
} catch (IndexOutOfBoundsException e) {
//expected
}
}
protected void loadTestData1(byte array[], int offset, int length) {
for (int i = 0; i < length; i++) {
array[offset + i] = (byte) i;
}
}
protected void loadTestData2(byte array[], int offset, int length) {
for (int i = 0; i < length; i++) {
array[offset + i] = (byte) (length - i);
}
}
protected void loadTestData1(ByteBuffer buf) {
if (buf.isReadOnly()) {
return;
}
buf.clear();
for (int i = 0; i < buf.capacity(); i++) {
buf.put(i, (byte) i);
}
}
protected void loadTestData2(ByteBuffer buf) {
buf.clear();
for (int i = 0; i < buf.capacity(); i++) {
buf.put(i, (byte) (buf.capacity() - i));
}
}
private void assertContentEquals(ByteBuffer buf, byte array[],
int offset, int length) {
for (int i = 0; i < length; i++) {
assertEquals(array[offset + i], buf.get(i));
}
}
private void assertContentEquals(ByteBuffer buf, ByteBuffer other) {
assertEquals(buf.capacity(), other.capacity());
for (int i = 0; i < buf.capacity(); i++) {
assertEquals(buf.get(i), other.get(i));
}
}
private void assertContentLikeTestData1(ByteBuffer buf,
int startIndex, byte startValue, int length) {
byte value = startValue;
for (int i = 0; i < length; i++) {
assertEquals(buf.get(startIndex + i), value);
value = (byte) (value + 1);
}
}
private int bytes2int(byte bytes[], ByteOrder order) {
int nbytes = 4, bigHead, step;
if (order == ByteOrder.BIG_ENDIAN) {
bigHead = 0;
step = 1;
} else {
bigHead = nbytes - 1;
step = -1;
}
int result = 0;
int p = bigHead;
for (int i = 0; i < nbytes; i++) {
result = result << 8;
result = result | (bytes[p] & 0xff);
p += step;
}
return result;
}
private long bytes2long(byte bytes[], ByteOrder order) {
int nbytes = 8, bigHead, step;
if (order == ByteOrder.BIG_ENDIAN) {
bigHead = 0;
step = 1;
} else {
bigHead = nbytes - 1;
step = -1;
}
long result = 0;
int p = bigHead;
for (int i = 0; i < nbytes; i++) {
result = result << 8;
result = result | (bytes[p] & 0xff);
p += step;
}
return result;
}
private short bytes2short(byte bytes[], ByteOrder order) {
int nbytes = 2, bigHead, step;
if (order == ByteOrder.BIG_ENDIAN) {
bigHead = 0;
step = 1;
} else {
bigHead = nbytes - 1;
step = -1;
}
short result = 0;
int p = bigHead;
for (int i = 0; i < nbytes; i++) {
result = (short) (result << 8);
result = (short) (result | (bytes[p] & 0xff));
p += step;
}
return result;
}
private char bytes2char(byte bytes[], ByteOrder order) {
return (char) bytes2short(bytes, order);
}
private float bytes2float(byte bytes[], ByteOrder order) {
return Float.intBitsToFloat(bytes2int(bytes, order));
}
private double bytes2double(byte bytes[], ByteOrder order) {
return Double.longBitsToDouble(bytes2long(bytes, order));
}
private byte[] int2bytes(int value, ByteOrder order) {
int nbytes = 4, smallHead, step;
if (order == ByteOrder.BIG_ENDIAN) {
smallHead = nbytes - 1;
step = -1;
} else {
smallHead = 0;
step = 1;
}
byte bytes[] = new byte[nbytes];
int p = smallHead;
for (int i = 0; i < nbytes; i++) {
bytes[p] = (byte) (value & 0xff);
value = value >> 8;
p += step;
}
return bytes;
}
private byte[] long2bytes(long value, ByteOrder order) {
int nbytes = 8, smallHead, step;
if (order == ByteOrder.BIG_ENDIAN) {
smallHead = nbytes - 1;
step = -1;
} else {
smallHead = 0;
step = 1;
}
byte bytes[] = new byte[nbytes];
int p = smallHead;
for (int i = 0; i < nbytes; i++) {
bytes[p] = (byte) (value & 0xff);
value = value >> 8;
p += step;
}
return bytes;
}
private byte[] short2bytes(short value, ByteOrder order) {
int nbytes = 2, smallHead, step;
if (order == ByteOrder.BIG_ENDIAN) {
smallHead = nbytes - 1;
step = -1;
} else {
smallHead = 0;
step = 1;
}
byte bytes[] = new byte[nbytes];
int p = smallHead;
for (int i = 0; i < nbytes; i++) {
bytes[p] = (byte) (value & 0xff);
value = (short) (value >> 8);
p += step;
}
return bytes;
}
private byte[] char2bytes(char value, ByteOrder order) {
return short2bytes((short) value, order);
}
private byte[] float2bytes(float value, ByteOrder order) {
return int2bytes(Float.floatToRawIntBits(value), order);
}
private byte[] double2bytes(double value, ByteOrder order) {
return long2bytes(Double.doubleToRawLongBits(value), order);
}
}
|
