summaryrefslogtreecommitdiffstats
path: root/src/junit/com/jogamp/common/util
diff options
context:
space:
mode:
Diffstat (limited to 'src/junit/com/jogamp/common/util')
-rw-r--r--src/junit/com/jogamp/common/util/BitstreamData.java119
-rw-r--r--src/junit/com/jogamp/common/util/TestBitstream00.java115
-rw-r--r--src/junit/com/jogamp/common/util/TestBitstream01.java342
-rw-r--r--src/junit/com/jogamp/common/util/TestBitstream02.java133
-rw-r--r--src/junit/com/jogamp/common/util/TestBitstream03.java154
-rw-r--r--src/junit/com/jogamp/common/util/TestBitstream04.java158
6 files changed, 1021 insertions, 0 deletions
diff --git a/src/junit/com/jogamp/common/util/BitstreamData.java b/src/junit/com/jogamp/common/util/BitstreamData.java
new file mode 100644
index 0000000..93e8ad0
--- /dev/null
+++ b/src/junit/com/jogamp/common/util/BitstreamData.java
@@ -0,0 +1,119 @@
+/**
+ * Copyright 2014 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.common.util;
+
+import java.nio.ByteBuffer;
+
+public class BitstreamData {
+ //
+ // MSB -> LSB over whole data
+ //
+ public static final byte[] testBytesMSB = new byte[] { (byte)0xde, (byte)0xaf, (byte)0xca, (byte)0xfe };
+ public static final String[] testStringsMSB = new String[] { "11011110", "10101111", "11001010", "11111110" };
+ public static final String testStringMSB = testStringsMSB[0]+testStringsMSB[1]+testStringsMSB[2]+testStringsMSB[3];
+
+ //
+ // MSB -> LSB, reverse bit-order over each byte of testBytesLSB
+ //
+ public static final byte[] testBytesMSB_rev = new byte[] { (byte)0xfe, (byte)0xca, (byte)0xaf, (byte)0xde };
+ public static final String[] testStringsMSB_rev = new String[] { "11111110", "11001010", "10101111", "11011110" };
+ public static final String testStringMSB_rev = testStringsMSB_rev[0]+testStringsMSB_rev[1]+testStringsMSB_rev[2]+testStringsMSB_rev[3];
+
+ //
+ // LSB -> MSB over whole data
+ //
+ public static final byte[] testBytesLSB = new byte[] { (byte)0x7f, (byte)0x53, (byte)0xf5, (byte)0x7b };
+ public static final String[] testStringsLSB = new String[] { "01111111", "01010011", "11110101", "01111011" };
+ public static final String testStringLSB = testStringsLSB[0]+testStringsLSB[1]+testStringsLSB[2]+testStringsLSB[3];
+
+ //
+ // LSB -> MSB, reverse bit-order over each byte of testBytesMSB
+ //
+ public static final byte[] testBytesLSB_revByte = new byte[] { (byte)0x7b, (byte)0xf5, (byte)0x53, (byte)0x7f };
+ public static final String[] testStringsLSB_revByte = new String[] { "01111011", "11110101", "01010011", "01111111" };
+ public static final String testStringLSB_revByte = testStringsLSB_revByte[0]+testStringsLSB_revByte[1]+testStringsLSB_revByte[2]+testStringsLSB_revByte[3];
+
+ public static final void dumpData(String prefix, byte[] data, int offset, int len) {
+ for(int i=0; i<len; ) {
+ System.err.printf("%s: %03d: ", prefix, i);
+ for(int j=0; j<8 && i<len; j++, i++) {
+ final int v = 0xFF & data[offset+i];
+ System.err.printf(toHexBinaryString(v, 8)+", ");
+ }
+ System.err.println("");
+ }
+ }
+ public static final void dumpData(String prefix, ByteBuffer data, int offset, int len) {
+ for(int i=0; i<len; ) {
+ System.err.printf("%s: %03d: ", prefix, i);
+ for(int j=0; j<8 && i<len; j++, i++) {
+ final int v = 0xFF & data.get(offset+i);
+ System.err.printf(toHexBinaryString(v, 8)+", ");
+ }
+ System.err.println("");
+ }
+ }
+
+ public static String toHexString(int v) {
+ return "0x"+Integer.toHexString(v);
+ }
+ public static final String strZeroPadding= "0000000000000000000000000000000000000000000000000000000000000000"; // 64
+ public static String toBinaryString(int v, int bitCount) {
+ if( 0 == bitCount ) {
+ return "";
+ }
+ final int mask = (int) ( ( 1L << bitCount ) - 1L );
+ final String s0 = Integer.toBinaryString( mask & v );
+ return strZeroPadding.substring(0, bitCount-s0.length())+s0;
+ }
+ public static String toBinaryString(long v, int bitCount) {
+ if( 0 == bitCount ) {
+ return "";
+ }
+ final long mask = ( 1L << bitCount ) - 1L;
+ final String s0 = Long.toBinaryString( mask & v );
+ return strZeroPadding.substring(0, bitCount-s0.length())+s0;
+ }
+ public static String toHexBinaryString(long v, int bitCount) {
+ final int nibbles = 0 == bitCount ? 2 : ( bitCount + 3 ) / 4;
+ return String.format("[%0"+nibbles+"X, %s]", v, toBinaryString(v, bitCount));
+ }
+ public static String toHexBinaryString(int v, int bitCount) {
+ final int nibbles = 0 == bitCount ? 2 : ( bitCount + 3 ) / 4;
+ return String.format("[%0"+nibbles+"X, %s]", v, toBinaryString(v, bitCount));
+ }
+ public static String toHexBinaryString(short v, int bitCount) {
+ final int nibbles = 0 == bitCount ? 2 : ( bitCount + 3 ) / 4;
+ return String.format("[%0"+nibbles+"X, %s]", v, toBinaryString(v, bitCount));
+ }
+ public static String toUnsignedBinaryString(final int int32) {
+ final long l = 0xffffffffL & int32;
+ return l+", "+toHexBinaryString(l, 32);
+ }
+}
diff --git a/src/junit/com/jogamp/common/util/TestBitstream00.java b/src/junit/com/jogamp/common/util/TestBitstream00.java
new file mode 100644
index 0000000..ef1fd45
--- /dev/null
+++ b/src/junit/com/jogamp/common/util/TestBitstream00.java
@@ -0,0 +1,115 @@
+/**
+ * Copyright 2014 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.common.util;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+
+import org.junit.Test;
+
+import com.jogamp.common.nio.Buffers;
+import com.jogamp.common.os.Platform;
+import static com.jogamp.common.util.BitstreamData.*;
+import com.jogamp.junit.util.JunitTracer;
+
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+/**
+ * Test basic bit operations for {@link Bitstream}
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestBitstream00 extends JunitTracer {
+
+ @Test
+ public void test00ShowByteOrder() {
+ int i_ff = 0xff;
+ byte b_ff = (byte)i_ff;
+ System.err.println("i_ff "+i_ff+", "+toHexBinaryString(i_ff, 8));
+ System.err.println("b_ff "+b_ff+", "+toHexBinaryString(0xff & b_ff, 8));
+
+ System.err.println("Platform.LITTLE_ENDIAN: "+Platform.isLittleEndian());
+ showOrderImpl(null);
+ showOrderImpl(ByteOrder.BIG_ENDIAN);
+ showOrderImpl(ByteOrder.LITTLE_ENDIAN);
+
+ dumpData("tstMSB.whole", testBytesMSB, 0, testBytesMSB.length);
+ dumpData("tstLSB.pbyte", testBytesLSB_revByte, 0, testBytesLSB_revByte.length);
+ dumpData("tstLSB.whole", testBytesLSB, 0, testBytesLSB.length);
+ }
+ void showOrderImpl(ByteOrder byteOrder) {
+ final ByteBuffer bb_long = ByteBuffer.allocate(Buffers.SIZEOF_LONG);
+ if( null != byteOrder ) {
+ bb_long.order(byteOrder);
+ }
+ System.err.println("Order: "+byteOrder+" -> "+bb_long.order());
+ final LongBuffer lb = bb_long.asLongBuffer();
+ lb.put(0, 0x0807060504030201L);
+ dumpData("long."+byteOrder, bb_long, 0, bb_long.capacity());
+
+ final ByteBuffer bb_int = ByteBuffer.allocate(Buffers.SIZEOF_INT);
+ if( null != byteOrder ) {
+ bb_int.order(byteOrder);
+ }
+ final IntBuffer ib = bb_int.asIntBuffer();
+ ib.put(0, 0x04030201);
+ dumpData("long."+byteOrder, bb_int, 0, bb_int.capacity());
+
+ dumpData("tstMSB.whole", testBytesMSB, 0, testBytesMSB.length);
+ dumpData("tstLSB.pbyte", testBytesLSB_revByte, 0, testBytesLSB_revByte.length);
+ dumpData("tstLSB.whole", testBytesLSB, 0, testBytesLSB.length);
+ }
+
+ @Test
+ public void test01ShiftSigned() {
+ shiftSigned(0xA0000000); // negative w/ '1010' top-nibble
+ shiftSigned(-1);
+ }
+ void shiftSigned(final int i0) {
+ System.err.printf("i0 %012d, %s%n", i0, toHexBinaryString(i0, 32));
+ {
+ int im = i0;
+ for(int i=0; i<32; i++) {
+ final int bitA = ( 0 != ( i0 & ( 1 << i ) ) ) ? 1 : 0;
+ final int bitB = im & 0x01;
+ System.err.printf("[%02d]: bit[%d, %d], im %012d, %s%n", i, bitA, bitB, im, toHexBinaryString(im, 32));
+ im = im >>> 1;
+ }
+ }
+ }
+
+ public static void main(String args[]) throws IOException {
+ String tstname = TestBitstream00.class.getName();
+ org.junit.runner.JUnitCore.main(tstname);
+ }
+
+}
diff --git a/src/junit/com/jogamp/common/util/TestBitstream01.java b/src/junit/com/jogamp/common/util/TestBitstream01.java
new file mode 100644
index 0000000..a8ae4a5
--- /dev/null
+++ b/src/junit/com/jogamp/common/util/TestBitstream01.java
@@ -0,0 +1,342 @@
+/**
+ * Copyright 2014 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.common.util;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.jogamp.junit.util.JunitTracer;
+import static com.jogamp.common.util.BitstreamData.*;
+
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+/**
+ * Test {@link Bitstream} w/ raw linear and bulk read/write access w/o semantics:
+ * <ul>
+ * <li>{@link Bitstream#readBit(boolean)}</li>
+ * <li>{@link Bitstream#writeBit(boolean, int)}</li>
+ * <li>{@link Bitstream#mark(int)}</li>
+ * <li>{@link Bitstream#reset()}</li>
+ * <li>{@link Bitstream#flush()}</li>
+ * <li>{@link Bitstream#readBits31(boolean, int)}</li>
+ * <li>{@link Bitstream#writeBits31(boolean, int, int)}</li>
+ * </ul>
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestBitstream01 extends JunitTracer {
+
+ Bitstream<ByteBuffer> getTestStream(final boolean msbFirst, int preBits, final int skipBits, final int postBits) throws IOException {
+ final int byteCount = ( preBits + skipBits + postBits + 7 ) / 8;
+ final ByteBuffer bbTest = ByteBuffer.allocate(byteCount);
+ final Bitstream.ByteBufferStream bbsTest = new Bitstream.ByteBufferStream(bbTest);
+ final Bitstream<ByteBuffer> bsTest = new Bitstream<ByteBuffer>(bbsTest, true /* outputMode */);
+ final String sTest0;
+ if( msbFirst ) {
+ sTest0 = testStringMSB.substring(0, preBits+skipBits+postBits);
+ } else {
+ sTest0 = testStringLSB.substring(0, preBits+skipBits+postBits);
+ }
+ for(int i=0; i<preBits+skipBits+postBits; i++) {
+ final int bit = Integer.valueOf(sTest0.substring(i, i+1));
+ bsTest.writeBit(msbFirst, bit);
+ }
+ Assert.assertEquals(preBits+skipBits+postBits, bsTest.position());
+ bsTest.setStream(bsTest.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+ return bsTest;
+ }
+
+ String getTestStreamResultAsString(final boolean msbFirst, int preBits, final int skipBits, final int postBits) {
+ final String pre, post;
+ if( msbFirst ) {
+ pre = testStringMSB.substring(0, preBits);
+ post = testStringMSB.substring(preBits+skipBits, preBits+skipBits+postBits);
+ } else {
+ pre = testStringLSB.substring(0, preBits);
+ post = testStringLSB.substring(preBits+skipBits, preBits+skipBits+postBits);
+ }
+ final String r = pre + post;
+ System.err.println("Test: <"+pre+"> + <"+post+"> = <"+r+">");
+ return r;
+ }
+
+ @Test
+ public void test01LinearBitsMSBFirst() throws IOException {
+ testLinearBitsImpl(true /* msbFirst */);
+ }
+ @Test
+ public void test02LinearBitsLSBFirst() throws IOException {
+ testLinearBitsImpl(false /* msbFirst */);
+ }
+ void testLinearBitsImpl(final boolean msbFirst) throws IOException {
+ testLinearBitsImpl(msbFirst, 0, 0, 1);
+ testLinearBitsImpl(msbFirst, 0, 0, 3);
+ testLinearBitsImpl(msbFirst, 0, 0, 8);
+ testLinearBitsImpl(msbFirst, 0, 0, 10);
+ testLinearBitsImpl(msbFirst, 0, 0, 30);
+ testLinearBitsImpl(msbFirst, 0, 0, 32);
+
+ testLinearBitsImpl(msbFirst, 3, 0, 3);
+ testLinearBitsImpl(msbFirst, 8, 0, 3);
+ testLinearBitsImpl(msbFirst, 9, 0, 3);
+
+ testLinearBitsImpl(msbFirst, 0, 1, 1);
+ testLinearBitsImpl(msbFirst, 0, 1, 3);
+ testLinearBitsImpl(msbFirst, 0, 2, 8);
+ testLinearBitsImpl(msbFirst, 0, 8, 10);
+ testLinearBitsImpl(msbFirst, 0, 12, 20);
+ testLinearBitsImpl(msbFirst, 0, 23, 9);
+
+ testLinearBitsImpl(msbFirst, 1, 1, 1);
+ testLinearBitsImpl(msbFirst, 2, 1, 3);
+ testLinearBitsImpl(msbFirst, 7, 2, 8);
+ testLinearBitsImpl(msbFirst, 8, 8, 8);
+ testLinearBitsImpl(msbFirst, 15, 12, 5);
+ testLinearBitsImpl(msbFirst, 16, 11, 5);
+ }
+
+ String readBits(final boolean msbFirst, final Bitstream<?> copy, final Bitstream<?> input, final int preCount, final int count) throws IOException {
+ final StringBuilder sbRead = new StringBuilder();
+ int i = 0;
+ while( i < count ) {
+ final int bit = input.readBit(msbFirst);
+ if( Bitstream.EOS == bit ) {
+ System.err.printf(" EOS");
+ break;
+ } else {
+ sbRead.append( ( 0 != bit ) ? '1' : '0' );
+ i++;
+ Assert.assertEquals(i+preCount, input.position());
+ if( null != copy ) {
+ copy.writeBit(msbFirst, bit);
+ Assert.assertEquals(i+preCount, copy.position());
+ }
+ }
+ }
+ Assert.assertEquals(i+preCount, input.position());
+ if( null != copy ) {
+ Assert.assertEquals(i+preCount, copy.position());
+ }
+ return sbRead.toString();
+ }
+
+ void testLinearBitsImpl(final boolean msbFirst, int preBits, int skipBits, final int postBits) throws IOException {
+ final int totalBits = preBits+skipBits+postBits;
+ System.err.println("XXX TestLinearBits: msbFirst "+msbFirst+", preBits "+preBits+", skipBits "+skipBits+", postBits "+postBits+", totalBits "+totalBits);
+
+ // prepare bitstream
+ System.err.println("Prepare bitstream");
+ final Bitstream<ByteBuffer> bsTest = getTestStream(msbFirst, preBits, skipBits, postBits);
+ dumpData("Test", bsTest.getSubStream(), 0, bsTest.getSubStream().limit());
+ final String sTest = getTestStreamResultAsString(msbFirst, preBits, skipBits, postBits);
+
+ // init copy-bitstream
+ final int byteCount = ( totalBits + 7 ) / 8;
+ final ByteBuffer bbCopy = ByteBuffer.allocate(byteCount);
+ final Bitstream.ByteBufferStream bbsCopy = new Bitstream.ByteBufferStream(bbCopy);
+ final Bitstream<ByteBuffer> bsCopy = new Bitstream<ByteBuffer>(bbsCopy, true /* outputMode */);
+
+ // read-bitstream .. and copy bits while reading
+ System.err.println("Reading bitstream: "+bsTest);
+ {
+ final String sReadPre = readBits(msbFirst, bsCopy, bsTest, 0, preBits);
+ {
+ final int skippedBits = (int) bsTest.skip(skipBits);
+ Assert.assertEquals(skipBits, skippedBits);
+ }
+ {
+ final int skippedBits = (int) bsCopy.skip(skipBits);
+ Assert.assertEquals(skipBits, skippedBits);
+ }
+ final String sReadPost = readBits(msbFirst, bsCopy, bsTest, preBits+skipBits, postBits);
+ final String sRead = sReadPre + sReadPost;
+ System.err.println("Read.Test: <"+sReadPre+"> + <"+sReadPost+"> = <"+sRead+">");
+ Assert.assertEquals(sTest, sRead);
+ Assert.assertEquals(totalBits, bsTest.position());
+ Assert.assertEquals(totalBits, bsCopy.position());
+ }
+
+ // read copy ..
+ bsCopy.setStream(bsCopy.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+ dumpData("Copy", bbCopy, 0, bbCopy.limit());
+ System.err.println("Reading copy-bitstream: "+bsCopy);
+ bsCopy.mark(0); // mark at beginning
+ Assert.assertEquals(0, bsCopy.position());
+ {
+ final String sReadPre1 = readBits(msbFirst, null, bsCopy, 0, preBits);
+ {
+ final int skippedBits = (int) bsCopy.skip(skipBits);
+ Assert.assertEquals(skipBits, skippedBits);
+ }
+ final String sReadPost1 = readBits(msbFirst, null, bsCopy, preBits+skipBits, postBits);
+ final String sRead1 = sReadPre1 + sReadPost1;
+ System.err.println("Read.Copy.1: <"+sReadPre1+"> + <"+sReadPost1+"> = <"+sRead1+">");
+ Assert.assertEquals(sTest, sRead1);
+
+ bsCopy.reset();
+ final String sReadPre2 = readBits(msbFirst, null, bsCopy, 0, preBits);
+ Assert.assertEquals(sReadPre1, sReadPre2);
+ {
+ final int skippedBits = (int) bsCopy.skip(skipBits);
+ Assert.assertEquals(skipBits, skippedBits);
+ }
+ final String sReadPost2 = readBits(msbFirst, null, bsCopy, preBits+skipBits, postBits);
+ Assert.assertEquals(sReadPost1, sReadPost2);
+ final String sRead2 = sReadPre2 + sReadPost2;
+ System.err.println("Read.Copy.2: <"+sReadPre2+"> + <"+sReadPost2+"> = <"+sRead2+">");
+ Assert.assertEquals(sTest, sRead2);
+ Assert.assertEquals(totalBits, bsCopy.position());
+ }
+ }
+
+ @Test
+ public void test03BulkBitsMSBFirst() throws IOException {
+ testBulkBitsImpl(true);
+ }
+ @Test
+ public void test04BulkBitsLSBFirst() throws IOException {
+ testBulkBitsImpl(false);
+ }
+ void testBulkBitsImpl(final boolean msbFirst) throws IOException {
+ testBulkBitsImpl(msbFirst, 0, 0, 1);
+ testBulkBitsImpl(msbFirst, 0, 0, 3);
+ testBulkBitsImpl(msbFirst, 0, 0, 8);
+ testBulkBitsImpl(msbFirst, 0, 0, 10);
+ testBulkBitsImpl(msbFirst, 0, 0, 30);
+ testBulkBitsImpl(msbFirst, 0, 0, 31);
+
+ testBulkBitsImpl(msbFirst, 3, 0, 3);
+ testBulkBitsImpl(msbFirst, 8, 0, 3);
+ testBulkBitsImpl(msbFirst, 9, 0, 3);
+
+ testBulkBitsImpl(msbFirst, 0, 1, 1);
+ testBulkBitsImpl(msbFirst, 0, 1, 3);
+ testBulkBitsImpl(msbFirst, 0, 2, 8);
+ testBulkBitsImpl(msbFirst, 0, 8, 10);
+ testBulkBitsImpl(msbFirst, 0, 12, 20);
+ testBulkBitsImpl(msbFirst, 0, 23, 9);
+ testBulkBitsImpl(msbFirst, 0, 1, 31);
+
+ testBulkBitsImpl(msbFirst, 1, 1, 1);
+ testBulkBitsImpl(msbFirst, 2, 1, 3);
+ testBulkBitsImpl(msbFirst, 7, 2, 8);
+ testBulkBitsImpl(msbFirst, 8, 8, 8);
+ testBulkBitsImpl(msbFirst, 15, 12, 5);
+ testBulkBitsImpl(msbFirst, 16, 11, 5);
+ }
+
+ void testBulkBitsImpl(final boolean msbFirst, int preBits, final int skipBits, final int postBits) throws IOException {
+ final int totalBits = preBits+skipBits+postBits;
+ System.err.println("XXX TestBulkBits: msbFirst "+msbFirst+", preBits "+preBits+", skipBits "+skipBits+", postBits "+postBits+", totalBits "+totalBits);
+
+ // prepare bitstream
+ System.err.println("Prepare bitstream");
+ final Bitstream<ByteBuffer> bsTest = getTestStream(msbFirst, preBits, skipBits, postBits);
+ dumpData("Test", bsTest.getSubStream(), 0, bsTest.getSubStream().limit());
+ final String sTest = getTestStreamResultAsString(msbFirst, preBits, skipBits, postBits);
+
+ // init copy-bitstream
+ final int byteCount = ( totalBits + 7 ) / 8;
+ final ByteBuffer bbCopy = ByteBuffer.allocate(byteCount);
+ final Bitstream.ByteBufferStream bbsCopy = new Bitstream.ByteBufferStream(bbCopy);
+ final Bitstream<ByteBuffer> bsCopy = new Bitstream<ByteBuffer>(bbsCopy, true /* outputMode */);
+
+ // read-bitstream .. and copy bits while reading
+ System.err.println("Reading bitstream: "+bsTest);
+ {
+ final int readBitsPre = bsTest.readBits31(msbFirst, preBits);
+ Assert.assertEquals(readBitsPre, bsCopy.writeBits31(msbFirst, preBits, readBitsPre));
+
+ final int skippedReadBits = (int) bsTest.skip(skipBits);
+ final int skippedBitsCopy = (int) bsCopy.skip(skipBits);
+
+ final int readBitsPost = bsTest.readBits31(msbFirst, postBits);
+ Assert.assertEquals(readBitsPost, bsCopy.writeBits31(msbFirst, postBits, readBitsPost));
+ final String sReadPre = toBinaryString(readBitsPre, preBits);
+ final String sReadPost = toBinaryString(readBitsPost, postBits);
+ final String sRead = sReadPre + sReadPost;
+ System.err.println("Read.Test: <"+sReadPre+"> + <"+sReadPost+"> = <"+sRead+">");
+
+ Assert.assertEquals(skipBits, skippedReadBits);
+ Assert.assertEquals(sTest, sRead);
+ Assert.assertEquals(totalBits, bsTest.position());
+ Assert.assertEquals(skipBits, skippedBitsCopy);
+ }
+
+ // read copy ..
+ bsCopy.setStream(bsCopy.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+ dumpData("Copy", bbCopy, 0, bbCopy.limit());
+ System.err.println("Reading copy-bitstream: "+bsCopy);
+ Assert.assertEquals(0, bsCopy.position());
+ {
+ final int copyBitsPre = bsCopy.readBits31(msbFirst, preBits);
+
+ final int skippedCopyBits = (int) bsCopy.skip(skipBits);
+
+ final int copyBitsPost = bsCopy.readBits31(msbFirst, postBits);
+ final String sCopyPre = toBinaryString(copyBitsPre, preBits);
+ final String sCopyPost = toBinaryString(copyBitsPost, postBits);
+ final String sCopy = sCopyPre + sCopyPost;
+ System.err.println("Copy.Test: <"+sCopyPre+"> + <"+sCopyPost+"> = <"+sCopy+">");
+
+ Assert.assertEquals(skipBits, skippedCopyBits);
+ Assert.assertEquals(sTest, sCopy);
+ Assert.assertEquals(totalBits, bsCopy.position());
+ }
+ }
+
+ @Test
+ public void test05ErrorHandling() throws IOException {
+ // prepare bitstream
+ final Bitstream<ByteBuffer> bsTest = getTestStream(false, 0, 0, 0);
+ System.err.println("01a: "+bsTest);
+ bsTest.close();
+ System.err.println("01b: "+bsTest);
+
+ try {
+ bsTest.readBit(false);
+ } catch (Exception e) {
+ Assert.assertNotNull(e);
+ }
+ try {
+ bsTest.writeBit(false, 1);
+ } catch (Exception e) {
+ Assert.assertNotNull(e);
+ }
+ }
+
+ public static void main(String args[]) throws IOException {
+ String tstname = TestBitstream01.class.getName();
+ org.junit.runner.JUnitCore.main(tstname);
+ }
+
+}
diff --git a/src/junit/com/jogamp/common/util/TestBitstream02.java b/src/junit/com/jogamp/common/util/TestBitstream02.java
new file mode 100644
index 0000000..dc7333c
--- /dev/null
+++ b/src/junit/com/jogamp/common/util/TestBitstream02.java
@@ -0,0 +1,133 @@
+/**
+ * Copyright 2014 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.common.util;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.jogamp.common.nio.Buffers;
+import com.jogamp.junit.util.JunitTracer;
+
+import static com.jogamp.common.util.BitstreamData.*;
+
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+/**
+ * Test {@link Bitstream} w/ int8 read/write access w/ semantics
+ * as well as with aligned and unaligned access.
+ * <ul>
+ * <li>{@link Bitstream#readInt8(boolean, boolean)}</li>
+ * <li>{@link Bitstream#writeInt8(boolean, boolean, byte)}</li>
+ * </ul>
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestBitstream02 extends JunitTracer {
+
+ @Test
+ public void test01Int8BitsAligned() throws IOException {
+ test01Int8BitsAlignedImpl((byte)0);
+ test01Int8BitsAlignedImpl((byte)1);
+ test01Int8BitsAlignedImpl((byte)7);
+ test01Int8BitsAlignedImpl(Byte.MIN_VALUE);
+ test01Int8BitsAlignedImpl(Byte.MAX_VALUE);
+ test01Int8BitsAlignedImpl((byte)0xff);
+ }
+ void test01Int8BitsAlignedImpl(byte val8) throws IOException {
+ // Test with buffer defined value
+ final ByteBuffer bb = ByteBuffer.allocate(Buffers.SIZEOF_BYTE);
+ System.err.println("XXX Test01Int8BitsAligned: value "+val8+", "+toHexBinaryString(val8, 8));
+ bb.put(0, val8);
+
+ final Bitstream.ByteBufferStream bbs = new Bitstream.ByteBufferStream(bb);
+ final Bitstream<ByteBuffer> bs = new Bitstream<ByteBuffer>(bbs, false /* outputMode */);
+ {
+ final byte r8 = (byte) bs.readInt8(true /* msbFirst */);
+ System.err.println("Read8.1 "+r8+", "+toHexBinaryString(r8, 8));
+ Assert.assertEquals(val8, r8);
+ }
+
+ // Test with written bitstream value
+ bs.setStream(bs.getSubStream(), true /* outputMode */);
+ bs.writeInt8(true /* msbFirst */, val8);
+ bs.setStream(bs.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+ {
+ final byte r8 = (byte) bs.readInt8(true /* msbFirst */);
+ System.err.println("Read8.2 "+r8+", "+toHexBinaryString(r8, 8));
+ Assert.assertEquals(val8, r8);
+ }
+ }
+
+ @Test
+ public void test02Int8BitsUnaligned() throws IOException {
+ test02Int8BitsUnalignedImpl(0);
+ test02Int8BitsUnalignedImpl(1);
+ test02Int8BitsUnalignedImpl(7);
+ test02Int8BitsUnalignedImpl(8);
+ test02Int8BitsUnalignedImpl(15);
+ test02Int8BitsUnalignedImpl(24);
+ test02Int8BitsUnalignedImpl(25);
+ }
+ void test02Int8BitsUnalignedImpl(final int preBits) throws IOException {
+ test02Int8BitsUnalignedImpl(preBits, (byte)0);
+ test02Int8BitsUnalignedImpl(preBits, (byte)1);
+ test02Int8BitsUnalignedImpl(preBits, (byte)7);
+ test02Int8BitsUnalignedImpl(preBits, Byte.MIN_VALUE);
+ test02Int8BitsUnalignedImpl(preBits, Byte.MAX_VALUE);
+ test02Int8BitsUnalignedImpl(preBits, (byte)0xff);
+ }
+ void test02Int8BitsUnalignedImpl(int preBits, byte val8) throws IOException {
+ final int preBytes = ( preBits + 7 ) >>> 3;
+ final int byteCount = preBytes + Buffers.SIZEOF_BYTE;
+ final ByteBuffer bb = ByteBuffer.allocate(byteCount);
+ System.err.println("XXX Test02Int8BitsUnaligned: preBits "+preBits+", value "+val8+", "+toHexBinaryString(val8, 8));
+
+ // Test with written bitstream value
+ final Bitstream.ByteBufferStream bbs = new Bitstream.ByteBufferStream(bb);
+ final Bitstream<ByteBuffer> bs = new Bitstream<ByteBuffer>(bbs, true /* outputMode */);
+ bs.writeBits31(true /* msbFirst */, preBits, 0);
+ bs.writeInt8(true /* msbFirst */, val8);
+ bs.setStream(bs.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+
+ final int rPre = (short) bs.readBits31(true /* msbFirst */, preBits);
+ final byte r8 = (byte) bs.readInt8(true /* msbFirst */);
+ System.err.println("ReadPre "+rPre+", "+toBinaryString(rPre, preBits));
+ System.err.println("Read8 "+r8+", "+toHexBinaryString(r8, 8));
+ Assert.assertEquals(val8, r8);
+ }
+
+ public static void main(String args[]) throws IOException {
+ String tstname = TestBitstream02.class.getName();
+ org.junit.runner.JUnitCore.main(tstname);
+ }
+
+}
diff --git a/src/junit/com/jogamp/common/util/TestBitstream03.java b/src/junit/com/jogamp/common/util/TestBitstream03.java
new file mode 100644
index 0000000..7eb89e7
--- /dev/null
+++ b/src/junit/com/jogamp/common/util/TestBitstream03.java
@@ -0,0 +1,154 @@
+/**
+ * Copyright 2014 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.common.util;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.jogamp.common.nio.Buffers;
+import com.jogamp.junit.util.JunitTracer;
+
+import static com.jogamp.common.util.BitstreamData.*;
+
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+/**
+ * Test {@link Bitstream} w/ int16 read/write access w/ semantics
+ * as well as with aligned and unaligned access.
+ * <ul>
+ * <li>{@link Bitstream#readInt16(boolean, boolean)}</li>
+ * <li>{@link Bitstream#writeInt16(boolean, boolean, short)}</li>
+ * </ul>
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestBitstream03 extends JunitTracer {
+
+ @Test
+ public void test01Int16BitsAligned() throws IOException {
+ test01Int16BitsImpl(null);
+ test01Int16BitsImpl(ByteOrder.BIG_ENDIAN);
+ test01Int16BitsImpl(ByteOrder.LITTLE_ENDIAN);
+ }
+ void test01Int16BitsImpl(ByteOrder byteOrder) throws IOException {
+ test01Int16BitsAlignedImpl(byteOrder, (short)0);
+ test01Int16BitsAlignedImpl(byteOrder, (short)1);
+ test01Int16BitsAlignedImpl(byteOrder, (short)7);
+ test01Int16BitsAlignedImpl(byteOrder, (short)0x0fff);
+ test01Int16BitsAlignedImpl(byteOrder, Short.MIN_VALUE);
+ test01Int16BitsAlignedImpl(byteOrder, Short.MAX_VALUE);
+ test01Int16BitsAlignedImpl(byteOrder, (short)0xffff);
+ }
+ void test01Int16BitsAlignedImpl(ByteOrder byteOrder, short val16) throws IOException {
+ // Test with buffer defined value
+ final ByteBuffer bb = ByteBuffer.allocate(Buffers.SIZEOF_SHORT);
+ if( null != byteOrder ) {
+ bb.order(byteOrder);
+ }
+ final boolean bigEndian = ByteOrder.BIG_ENDIAN == bb.order();
+ System.err.println("XXX Test01Int16BitsAligned: byteOrder "+byteOrder+" (bigEndian "+bigEndian+"), value "+val16+", "+toHexBinaryString(val16, 16));
+ bb.putShort(0, val16);
+
+ final Bitstream.ByteBufferStream bbs = new Bitstream.ByteBufferStream(bb);
+ final Bitstream<ByteBuffer> bs = new Bitstream<ByteBuffer>(bbs, false /* outputMode */);
+ {
+ final short r16 = (short) bs.readInt16(true /* msbFirst */, bigEndian);
+ System.err.println("Read16.1 "+r16+", "+toHexBinaryString(r16, 16));
+ Assert.assertEquals(val16, r16);
+ }
+
+ // Test with written bitstream value
+ bs.setStream(bs.getSubStream(), true /* outputMode */);
+ bs.writeInt16(true /* msbFirst */, bigEndian, val16);
+ bs.setStream(bs.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+ {
+ final short r16 = (short) bs.readInt16(true /* msbFirst */, bigEndian);
+ System.err.println("Read16.2 "+r16+", "+toHexBinaryString(r16, 16));
+ Assert.assertEquals(val16, r16);
+ }
+ }
+
+ @Test
+ public void test02Int16BitsUnaligned() throws IOException {
+ test02Int16BitsUnalignedImpl(null);
+ test02Int16BitsUnalignedImpl(ByteOrder.BIG_ENDIAN);
+ test02Int16BitsUnalignedImpl(ByteOrder.LITTLE_ENDIAN);
+ }
+ void test02Int16BitsUnalignedImpl(ByteOrder byteOrder) throws IOException {
+ test02Int16BitsUnalignedImpl(byteOrder, 0);
+ test02Int16BitsUnalignedImpl(byteOrder, 1);
+ test02Int16BitsUnalignedImpl(byteOrder, 7);
+ test02Int16BitsUnalignedImpl(byteOrder, 8);
+ test02Int16BitsUnalignedImpl(byteOrder, 15);
+ test02Int16BitsUnalignedImpl(byteOrder, 24);
+ test02Int16BitsUnalignedImpl(byteOrder, 25);
+ }
+ void test02Int16BitsUnalignedImpl(ByteOrder byteOrder, final int preBits) throws IOException {
+ test02Int16BitsUnalignedImpl(byteOrder, preBits, (short)0);
+ test02Int16BitsUnalignedImpl(byteOrder, preBits, (short)1);
+ test02Int16BitsUnalignedImpl(byteOrder, preBits, (short)7);
+ test02Int16BitsUnalignedImpl(byteOrder, preBits, (short)0x0fff);
+ test02Int16BitsUnalignedImpl(byteOrder, preBits, Short.MIN_VALUE);
+ test02Int16BitsUnalignedImpl(byteOrder, preBits, Short.MAX_VALUE);
+ test02Int16BitsUnalignedImpl(byteOrder, preBits, (short)0xffff);
+ }
+ void test02Int16BitsUnalignedImpl(ByteOrder byteOrder, int preBits, short val16) throws IOException {
+ final int preBytes = ( preBits + 7 ) >>> 3;
+ final int byteCount = preBytes + Buffers.SIZEOF_SHORT;
+ final ByteBuffer bb = ByteBuffer.allocate(byteCount);
+ if( null != byteOrder ) {
+ bb.order(byteOrder);
+ }
+ final boolean bigEndian = ByteOrder.BIG_ENDIAN == bb.order();
+ System.err.println("XXX Test02Int16BitsUnaligned: byteOrder "+byteOrder+" (bigEndian "+bigEndian+"), preBits "+preBits+", value "+val16+", "+toHexBinaryString(val16, 16));
+
+ // Test with written bitstream value
+ final Bitstream.ByteBufferStream bbs = new Bitstream.ByteBufferStream(bb);
+ final Bitstream<ByteBuffer> bs = new Bitstream<ByteBuffer>(bbs, true /* outputMode */);
+ bs.writeBits31(true /* msbFirst */, preBits, 0);
+ bs.writeInt16(true /* msbFirst */, bigEndian, val16);
+ bs.setStream(bs.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+
+ final int rPre = (short) bs.readBits31(true /* msbFirst */, preBits);
+ final short r16 = (short) bs.readInt16(true /* msbFirst */, bigEndian);
+ System.err.println("ReadPre "+rPre+", "+toBinaryString(rPre, preBits));
+ System.err.println("Read16 "+r16+", "+toHexBinaryString(r16, 16));
+ Assert.assertEquals(val16, r16);
+ }
+
+ public static void main(String args[]) throws IOException {
+ String tstname = TestBitstream03.class.getName();
+ org.junit.runner.JUnitCore.main(tstname);
+ }
+
+}
diff --git a/src/junit/com/jogamp/common/util/TestBitstream04.java b/src/junit/com/jogamp/common/util/TestBitstream04.java
new file mode 100644
index 0000000..dfc9c90
--- /dev/null
+++ b/src/junit/com/jogamp/common/util/TestBitstream04.java
@@ -0,0 +1,158 @@
+/**
+ * Copyright 2014 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.common.util;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.jogamp.common.nio.Buffers;
+import com.jogamp.junit.util.JunitTracer;
+
+import static com.jogamp.common.util.BitstreamData.*;
+
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+/**
+ * Test {@link Bitstream} w/ int32 read/write access w/ semantics
+ * as well as with aligned and unaligned access.
+ * <ul>
+ * <li>{@link Bitstream#readInt32(boolean, boolean)}</li>
+ * <li>{@link Bitstream#writeInt32(boolean, boolean, int)}</li>
+ * </ul>
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestBitstream04 extends JunitTracer {
+
+ @Test
+ public void test01Int32BitsAligned() throws IOException {
+ test01Int32BitsImpl(null);
+ test01Int32BitsImpl(ByteOrder.BIG_ENDIAN);
+ test01Int32BitsImpl(ByteOrder.LITTLE_ENDIAN);
+ }
+ void test01Int32BitsImpl(ByteOrder byteOrder) throws IOException {
+ test01Int32BitsAlignedImpl(byteOrder, 0);
+ test01Int32BitsAlignedImpl(byteOrder, 1);
+ test01Int32BitsAlignedImpl(byteOrder, -1);
+ test01Int32BitsAlignedImpl(byteOrder, 7);
+ test01Int32BitsAlignedImpl(byteOrder, 0x0fffffff);
+ test01Int32BitsAlignedImpl(byteOrder, Integer.MIN_VALUE);
+ test01Int32BitsAlignedImpl(byteOrder, Integer.MAX_VALUE);
+ test01Int32BitsAlignedImpl(byteOrder, 0xffffffff);
+ }
+ void test01Int32BitsAlignedImpl(ByteOrder byteOrder, int val32) throws IOException {
+ // Test with buffer defined value
+ final ByteBuffer bb = ByteBuffer.allocate(Buffers.SIZEOF_INT);
+ if( null != byteOrder ) {
+ bb.order(byteOrder);
+ }
+ final boolean bigEndian = ByteOrder.BIG_ENDIAN == bb.order();
+ System.err.println("XXX Test01Int32BitsAligned: byteOrder "+byteOrder+" (bigEndian "+bigEndian+"), value "+val32+", "+toHexBinaryString(val32, 32));
+ System.err.println("XXX Test01Int32BitsAligned: "+toUnsignedBinaryString(val32));
+ bb.putInt(0, val32);
+
+ final Bitstream.ByteBufferStream bbs = new Bitstream.ByteBufferStream(bb);
+ final Bitstream<ByteBuffer> bs = new Bitstream<ByteBuffer>(bbs, false /* outputMode */);
+ {
+ final int r32 = bs.readInt32(true /* msbFirst */, bigEndian);
+ System.err.println("Read32.1 "+r32+", "+toHexBinaryString(r32, 32)+", "+toUnsignedBinaryString(r32));
+ Assert.assertEquals(val32, r32);
+ }
+
+ // Test with written bitstream value
+ bs.setStream(bs.getSubStream(), true /* outputMode */);
+ bs.writeInt32(true /* msbFirst */, bigEndian, val32);
+ bs.setStream(bs.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+ {
+ final int r32 = bs.readInt32(true /* msbFirst */, bigEndian);
+ System.err.println("Read32.2 "+r32+", "+toHexBinaryString(r32, 32)+", "+toUnsignedBinaryString(r32));
+ Assert.assertEquals(val32, r32);
+ }
+ }
+
+ @Test
+ public void test02Int32BitsUnaligned() throws IOException {
+ test02Int32BitsUnalignedImpl(null);
+ test02Int32BitsUnalignedImpl(ByteOrder.BIG_ENDIAN);
+ test02Int32BitsUnalignedImpl(ByteOrder.LITTLE_ENDIAN);
+ }
+ void test02Int32BitsUnalignedImpl(ByteOrder byteOrder) throws IOException {
+ test02Int32BitsUnalignedImpl(byteOrder, 0);
+ test02Int32BitsUnalignedImpl(byteOrder, 1);
+ test02Int32BitsUnalignedImpl(byteOrder, 7);
+ test02Int32BitsUnalignedImpl(byteOrder, 8);
+ test02Int32BitsUnalignedImpl(byteOrder, 15);
+ test02Int32BitsUnalignedImpl(byteOrder, 24);
+ test02Int32BitsUnalignedImpl(byteOrder, 25);
+ }
+ void test02Int32BitsUnalignedImpl(ByteOrder byteOrder, final int preBits) throws IOException {
+ test02Int32BitsUnalignedImpl(byteOrder, preBits, 0);
+ test02Int32BitsUnalignedImpl(byteOrder, preBits, 1);
+ test02Int32BitsUnalignedImpl(byteOrder, preBits, -1);
+ test02Int32BitsUnalignedImpl(byteOrder, preBits, 7);
+ test02Int32BitsUnalignedImpl(byteOrder, preBits, 0x0fffffff);
+ test02Int32BitsUnalignedImpl(byteOrder, preBits, Integer.MIN_VALUE);
+ test02Int32BitsUnalignedImpl(byteOrder, preBits, Integer.MAX_VALUE);
+ test02Int32BitsUnalignedImpl(byteOrder, preBits, 0xffffffff);
+ }
+ void test02Int32BitsUnalignedImpl(ByteOrder byteOrder, int preBits, int val32) throws IOException {
+ final int preBytes = ( preBits + 7 ) >>> 3;
+ final int byteCount = preBytes + Buffers.SIZEOF_INT;
+ final ByteBuffer bb = ByteBuffer.allocate(byteCount);
+ if( null != byteOrder ) {
+ bb.order(byteOrder);
+ }
+ final boolean bigEndian = ByteOrder.BIG_ENDIAN == bb.order();
+ System.err.println("XXX Test02Int32BitsUnaligned: byteOrder "+byteOrder+" (bigEndian "+bigEndian+"), preBits "+preBits+", value "+val32+", "+toHexBinaryString(val32, 32));
+ System.err.println("XXX Test02Int32BitsUnaligned: "+toUnsignedBinaryString(val32));
+
+ // Test with written bitstream value
+ final Bitstream.ByteBufferStream bbs = new Bitstream.ByteBufferStream(bb);
+ final Bitstream<ByteBuffer> bs = new Bitstream<ByteBuffer>(bbs, true /* outputMode */);
+ bs.writeBits31(true /* msbFirst */, preBits, 0);
+ bs.writeInt32(true /* msbFirst */, bigEndian, val32);
+ bs.setStream(bs.getSubStream(), false /* outputMode */); // switch to input-mode, implies flush()
+
+ final int rPre = bs.readBits31(true /* msbFirst */, preBits);
+ final int r32 = bs.readInt32(true /* msbFirst */, bigEndian);
+ System.err.println("ReadPre "+rPre+", "+toBinaryString(rPre, preBits));
+ System.err.println("Read32 "+r32+", "+toHexBinaryString(r32, 32)+", "+toUnsignedBinaryString(r32));
+ Assert.assertEquals(val32, r32);
+ }
+
+ public static void main(String args[]) throws IOException {
+ String tstname = TestBitstream04.class.getName();
+ org.junit.runner.JUnitCore.main(tstname);
+ }
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-29 19:29:00 +0000