diff options
Diffstat (limited to 'harmony-tests/src/test/java/org/apache/harmony/tests/java/nio/DoubleBufferTest.java')
| -rw-r--r-- | harmony-tests/src/test/java/org/apache/harmony/tests/java/nio/DoubleBufferTest.java | 664 |
1 files changed, 664 insertions, 0 deletions
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/java/nio/DoubleBufferTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/java/nio/DoubleBufferTest.java new file mode 100644 index 0000000..50e0b82 --- /dev/null +++ b/harmony-tests/src/test/java/org/apache/harmony/tests/java/nio/DoubleBufferTest.java @@ -0,0 +1,664 @@ +/* + * 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.tests.java.nio; + +import java.nio.BufferOverflowException; +import java.nio.BufferUnderflowException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.DoubleBuffer; +import java.nio.InvalidMarkException; + +/** + * Tests java.nio.DoubleBuffer + */ +public class DoubleBufferTest extends AbstractBufferTest { + + protected static final int SMALL_TEST_LENGTH = 5; + + protected static final int BUFFER_LENGTH = 20; + + protected DoubleBuffer buf; + + protected void setUp() throws Exception { + buf = DoubleBuffer.allocate(BUFFER_LENGTH); + loadTestData1(buf); + baseBuf = buf; + } + + protected void tearDown() throws Exception { + buf = null; + baseBuf = null; + } + + /* + * Test with bit sequences that represent the IEEE754 doubles Positive + * infinity, negative infinity, and NaN. + */ + public void testNaNs() { + long[] nans = new long[] { 0x7ff0000000000000L, 0xfff0000000000000L, + 0x7ff8000000000000L }; + for (int i = 0; i < nans.length; i++) { + long longBitsIn = nans[i]; + double dbl = Double.longBitsToDouble(longBitsIn); + long longBitsOut = Double.doubleToRawLongBits(dbl); + // Sanity check + assertTrue(longBitsIn == longBitsOut); + + // Store the double and retrieve it + ByteBuffer buffer = ByteBuffer.allocate(8); + buffer.putDouble(dbl); + double bufDoubleOut = buffer.getDouble(0); + + // Check the bits sequence was not normalized + long bufLongOut = Double.doubleToRawLongBits(bufDoubleOut); + assertTrue(longBitsIn == bufLongOut); + } + } + + public void testArray() { + double 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()); + } + + public void testArrayOffset() { + double 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()); + } + + public void testAsReadOnlyBuffer() { + buf.clear(); + buf.mark(); + buf.position(buf.limit()); + + // readonly's contents should be the same as buf + DoubleBuffer 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(readonly.position(), 0); + readonly.clear(); + assertEquals(buf.position(), buf.limit()); + buf.reset(); + assertEquals(buf.position(), 0); + } + + public void testCompact() { + // case: buffer is full + buf.clear(); + buf.mark(); + loadTestData1(buf); + DoubleBuffer ret = buf.compact(); + assertSame(ret, buf); + assertEquals(buf.position(), buf.capacity()); + assertEquals(buf.limit(), buf.capacity()); + assertContentLikeTestData1(buf, 0, 0.0, buf.capacity()); + try { + 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(buf.position(), 0); + assertEquals(buf.limit(), buf.capacity()); + assertContentLikeTestData1(buf, 0, 0.0, buf.capacity()); + try { + buf.reset(); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (InvalidMarkException e) { + // expected + } + + // case: normal + assertTrue(buf.capacity() > 5); + buf.position(1); + buf.limit(5); + buf.mark(); + ret = buf.compact(); + assertSame(ret, buf); + assertEquals(buf.position(), 4); + assertEquals(buf.limit(), buf.capacity()); + assertContentLikeTestData1(buf, 0, 1.0, 4); + try { + buf.reset(); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (InvalidMarkException e) { + // expected + } + } + + public void testCompareTo() { + DoubleBuffer other = DoubleBuffer.allocate(buf.capacity()); + 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(5); + assertTrue(buf.compareTo(other) > 0); + assertTrue(other.compareTo(buf) < 0); + + DoubleBuffer dbuffer1 = DoubleBuffer.wrap(new double[] { Double.NaN }); + DoubleBuffer dbuffer2 = DoubleBuffer.wrap(new double[] { Double.NaN }); + DoubleBuffer dbuffer3 = DoubleBuffer.wrap(new double[] { 42d }); + + assertEquals("Failed equal comparison with NaN entry", 0, dbuffer1 + .compareTo(dbuffer2)); + assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer3 + .compareTo(dbuffer1)); + assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer1 + .compareTo(dbuffer3)); + } + + public void testDuplicate() { + buf.clear(); + buf.mark(); + buf.position(buf.limit()); + + // duplicate's contents should be the same as buf + DoubleBuffer 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(duplicate.position(), 0); + duplicate.clear(); + assertEquals(buf.position(), buf.limit()); + buf.reset(); + assertEquals(buf.position(), 0); + + // duplicate share the same content with buf + // FIXME + if (!duplicate.isReadOnly()) { + loadTestData1(buf); + assertContentEquals(buf, duplicate); + loadTestData2(duplicate); + assertContentEquals(buf, duplicate); + } + } + + public void testEquals() { + // equal to self + assertTrue(buf.equals(buf)); + DoubleBuffer readonly = buf.asReadOnlyBuffer(); + assertTrue(buf.equals(readonly)); + DoubleBuffer duplicate = buf.duplicate(); + assertTrue(buf.equals(duplicate)); + + // always false, if type mismatch + assertFalse(buf.equals(Boolean.TRUE)); + + assertTrue(buf.capacity() > 5); + + 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)); + } + + /* + * Class under test for double get() + */ + public void testGet() { + buf.clear(); + for (int i = 0; i < buf.capacity(); i++) { + assertEquals(buf.position(), i); + assertEquals(buf.get(), buf.get(i), 0.01); + } + try { + buf.get(); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferUnderflowException e) { + // expected + } + } + + /* + * Class under test for java.nio.DoubleBuffer get(double[]) + */ + public void testGetdoubleArray() { + double array[] = new double[1]; + buf.clear(); + for (int i = 0; i < buf.capacity(); i++) { + assertEquals(buf.position(), i); + DoubleBuffer ret = buf.get(array); + assertEquals(array[0], buf.get(i), 0.01); + assertSame(ret, buf); + } + try { + buf.get(array); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferUnderflowException e) { + // expected + } + } + + /* + * Class under test for java.nio.DoubleBuffer get(double[], int, int) + */ + public void testGetdoubleArrayintint() { + buf.clear(); + double array[] = new double[buf.capacity()]; + + try { + buf.get(new double[buf.capacity() + 1], 0, buf.capacity() + 1); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferUnderflowException e) { + // expected + } + assertEquals(buf.position(), 0); + 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(buf.position(), 0); + try { + buf.get(array, 2, -1); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (IndexOutOfBoundsException e) { + // expected + } + try { + buf.get((double[])null, 0, -1); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (NullPointerException e) { + // expected + } + try { + buf.get(array, 2, array.length); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (IndexOutOfBoundsException e) { + // expected + } + try { + buf.get(array, 1, Integer.MAX_VALUE); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferUnderflowException expected) { + } catch (IndexOutOfBoundsException expected) { + } + try { + buf.get(array, Integer.MAX_VALUE, 1); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (IndexOutOfBoundsException e) { + // expected + } + assertEquals(buf.position(), 0); + + buf.clear(); + DoubleBuffer 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 double get(int) + */ + public void testGetint() { + buf.clear(); + for (int i = 0; i < buf.capacity(); i++) { + assertEquals(buf.position(), i); + assertEquals(buf.get(), buf.get(i), 0.01); + } + 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 + } + } + + public void testHasArray() { + assertTrue(buf.hasArray()); + } + + public void testHashCode() { + buf.clear(); + DoubleBuffer readonly = buf.asReadOnlyBuffer(); + DoubleBuffer duplicate = buf.duplicate(); + assertTrue(buf.hashCode() == readonly.hashCode()); + + assertTrue(buf.capacity() > 5); + duplicate.position(buf.capacity() / 2); + assertTrue(buf.hashCode() != duplicate.hashCode()); + } + + public void testIsDirect() { + assertFalse(buf.isDirect()); + } + + public void testOrder() { + assertEquals(ByteOrder.nativeOrder(), buf.order()); + } + + /* + * Class under test for java.nio.DoubleBuffer put(double) + */ + public void testPutdouble() { + + buf.clear(); + for (int i = 0; i < buf.capacity(); i++) { + assertEquals(buf.position(), i); + DoubleBuffer ret = buf.put((double) i); + assertEquals(buf.get(i), (double) i, 0.0); + assertSame(ret, buf); + } + try { + buf.put(0); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferOverflowException e) { + // expected + } + } + + /* + * Class under test for java.nio.DoubleBuffer put(double[]) + */ + public void testPutdoubleArray() { + double array[] = new double[1]; + + buf.clear(); + for (int i = 0; i < buf.capacity(); i++) { + assertEquals(buf.position(), i); + array[0] = (double) i; + DoubleBuffer ret = buf.put(array); + assertEquals(buf.get(i), (double) i, 0.0); + assertSame(ret, buf); + } + try { + buf.put(array); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferOverflowException e) { + // expected + } + } + + /* + * Class under test for java.nio.DoubleBuffer put(double[], int, int) + */ + public void testPutdoubleArrayintint() { + buf.clear(); + double array[] = new double[buf.capacity()]; + + try { + buf.put(new double[buf.capacity() + 1], 0, buf.capacity() + 1); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferOverflowException e) { + // expected + } + assertEquals(buf.position(), 0); + 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(buf.position(), 0); + try { + buf.put(array, 0, -1); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (IndexOutOfBoundsException e) { + // expected + } + try { + buf.put((double[])null, 0, -1); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (NullPointerException e) { + // expected + } + try { + buf.put(array, 2, array.length); + 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(array, 1, Integer.MAX_VALUE); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferOverflowException expected) { + } catch (IndexOutOfBoundsException expected) { + } + assertEquals(buf.position(), 0); + + loadTestData2(array, 0, array.length); + DoubleBuffer 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.DoubleBuffer put(java.nio.DoubleBuffer) + */ + public void testPutDoubleBuffer() { + DoubleBuffer other = DoubleBuffer.allocate(buf.capacity()); + + try { + buf.put(buf); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (IllegalArgumentException e) { + // expected + } + try { + buf.put(DoubleBuffer.allocate(buf.capacity() + 1)); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (BufferOverflowException e) { + // expected + } + + loadTestData2(other); + other.clear(); + buf.clear(); + DoubleBuffer 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.DoubleBuffer put(int, double) + */ + public void testPutintdouble() { + buf.clear(); + for (int i = 0; i < buf.capacity(); i++) { + assertEquals(buf.position(), 0); + DoubleBuffer ret = buf.put(i, (double) i); + assertEquals(buf.get(i), (double) i, 0.0); + assertSame(ret, buf); + } + try { + buf.put(-1, 0); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (IndexOutOfBoundsException e) { + // expected + } + try { + buf.put(buf.limit(), 0); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (IndexOutOfBoundsException e) { + // expected + } + } + + public void testSlice() { + assertTrue(buf.capacity() > 5); + buf.position(1); + buf.limit(buf.capacity() - 1); + + DoubleBuffer slice = buf.slice(); + assertEquals(buf.isReadOnly(), slice.isReadOnly()); + assertEquals(buf.isDirect(), slice.isDirect()); + assertEquals(buf.order(), slice.order()); + assertEquals(slice.position(), 0); + assertEquals(slice.limit(), buf.remaining()); + assertEquals(slice.capacity(), buf.remaining()); + try { + slice.reset(); + fail("Should throw Exception"); //$NON-NLS-1$ + } catch (InvalidMarkException e) { + // expected + } + + // slice share the same content with buf + // FIXME: + if (!slice.isReadOnly()) { + loadTestData1(slice); + assertContentLikeTestData1(buf, 1, 0, slice.capacity()); + buf.put(2, 500); + assertEquals(slice.get(1), 500, 0.0); + } + } + + public void testToString() { + String str = buf.toString(); + assertTrue(str.indexOf("Double") >= 0 || str.indexOf("double") >= 0); + assertTrue(str.indexOf("" + buf.position()) >= 0); + assertTrue(str.indexOf("" + buf.limit()) >= 0); + assertTrue(str.indexOf("" + buf.capacity()) >= 0); + } + + void loadTestData1(double array[], int offset, int length) { + for (int i = 0; i < length; i++) { + array[offset + i] = (double) i; + } + } + + void loadTestData2(double array[], int offset, int length) { + for (int i = 0; i < length; i++) { + array[offset + i] = (double) length - i; + } + } + + void loadTestData1(DoubleBuffer buf) { + buf.clear(); + for (int i = 0; i < buf.capacity(); i++) { + buf.put(i, (double) i); + } + } + + void loadTestData2(DoubleBuffer buf) { + buf.clear(); + for (int i = 0; i < buf.capacity(); i++) { + buf.put(i, (double) buf.capacity() - i); + } + } + + private void assertContentEquals(DoubleBuffer buf, double array[], + int offset, int length) { + for (int i = 0; i < length; i++) { + assertEquals(buf.get(i), array[offset + i], 0.01); + } + } + + private void assertContentEquals(DoubleBuffer buf, DoubleBuffer other) { + assertEquals(buf.capacity(), other.capacity()); + for (int i = 0; i < buf.capacity(); i++) { + assertEquals(buf.get(i), other.get(i), 0.01); + } + } + + private void assertContentLikeTestData1(DoubleBuffer buf, int startIndex, + double startValue, int length) { + double value = startValue; + for (int i = 0; i < length; i++) { + assertEquals(buf.get(startIndex + i), value, 0.01); + value = value + 1.0; + } + } +} |