diff options
Diffstat (limited to 'src/junit/com/jogamp')
| -rw-r--r-- | src/junit/com/jogamp/common/util/BitstreamData.java | 119 | ||||
| -rw-r--r-- | src/junit/com/jogamp/common/util/TestBitstream00.java | 115 | ||||
| -rw-r--r-- | src/junit/com/jogamp/common/util/TestBitstream01.java | 342 | ||||
| -rw-r--r-- | src/junit/com/jogamp/common/util/TestBitstream02.java | 133 | ||||
| -rw-r--r-- | src/junit/com/jogamp/common/util/TestBitstream03.java | 154 | ||||
| -rw-r--r-- | src/junit/com/jogamp/common/util/TestBitstream04.java | 158 |
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); + } + +} |