From 047e9adaf2a5f51f7acfa194a744c99b6bfadaea Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Sun, 2 Aug 2015 01:12:21 +0200 Subject: Bitfield: Refine API method names, add clearField(boolean), fix put32(..) and bitCount(), add unit test (passed) --- make/scripts/runtest.sh | 3 +- src/java/com/jogamp/common/util/Bitfield.java | 80 +++-- src/java/com/jogamp/common/util/IntBitfield.java | 6 +- .../jogamp/common/util/Int32ArrayBitfield.java | 39 ++- src/java/jogamp/common/util/Int32Bitfield.java | 23 +- src/java/jogamp/common/util/SyncedBitfield.java | 13 +- .../com/jogamp/common/util/TestBitfield00.java | 379 +++++++++++++++++++++ 7 files changed, 494 insertions(+), 49 deletions(-) create mode 100644 src/junit/com/jogamp/common/util/TestBitfield00.java diff --git a/make/scripts/runtest.sh b/make/scripts/runtest.sh index d5d6ff8..d389980 100755 --- a/make/scripts/runtest.sh +++ b/make/scripts/runtest.sh @@ -112,6 +112,7 @@ function onetest() { #onetest com.jogamp.common.util.TestValueConversion 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.TestSyncRingBuffer01 $* #onetest com.jogamp.common.util.TestLFRingBuffer01 $* +onetest com.jogamp.common.util.TestBitfield00 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.TestBitstream00 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.TestBitstream01 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.TestBitstream02 2>&1 | tee -a $LOG @@ -126,7 +127,7 @@ function onetest() { #onetest com.jogamp.common.net.AssetURLConnectionUnregisteredTest 2>&1 | tee -a $LOG #onetest com.jogamp.common.net.AssetURLConnectionRegisteredTest 2>&1 | tee -a $LOG #onetest com.jogamp.junit.sec.TestSecIOUtil01 2>&1 | tee -a $LOG -onetest com.jogamp.common.nio.BuffersTest 2>&1 | tee -a $LOG +#onetest com.jogamp.common.nio.BuffersTest 2>&1 | tee -a $LOG #onetest com.jogamp.common.nio.TestBuffersFloatDoubleConversion 2>&1 | tee -a $LOG #onetest com.jogamp.common.nio.TestPointerBufferEndian 2>&1 | tee -a $LOG #onetest com.jogamp.common.nio.TestStructAccessorEndian 2>&1 | tee -a $LOG diff --git a/src/java/com/jogamp/common/util/Bitfield.java b/src/java/com/jogamp/common/util/Bitfield.java index f7eaeb0..d7ada5a 100644 --- a/src/java/com/jogamp/common/util/Bitfield.java +++ b/src/java/com/jogamp/common/util/Bitfield.java @@ -34,26 +34,58 @@ import jogamp.common.util.SyncedBitfield; * @since 2.3.2 */ public interface Bitfield { + /** Maximum 32 bit Unsigned Integer Value: {@code 0xffffffff} == {@value}. */ + public static final int UNSIGNED_INT_MAX_VALUE = 0xffffffff; + /** * Bit operation utilities (static). */ public static class Util { + /** + * Returns the 32 bit mask of n-bits, i.e. n low order 1’s. + *

+ * Implementation handles n == 32. + *

+ * @throws IndexOutOfBoundsException if {@code b} is out of bounds, i.e. > 32 + */ + public static int getBitMask(final int n) { + if( 32 > n ) { + return ( 1 << n ) - 1; + } else if ( 32 == n ) { + return UNSIGNED_INT_MAX_VALUE; + } else { + throw new IndexOutOfBoundsException("n <= 32 expected, is "+n); + } + } + /** * Returns the number of set bits within given 32bit integer in O(1) - * using HAKEM Bit Count: + * using a HAKEM 169 Bit Count inspired implementation: * 
          *   http://www.inwap.com/pdp10/hbaker/hakmem/hakmem.html
          *   http://home.pipeline.com/~hbaker1/hakmem/hacks.html#item169
          *   http://tekpool.wordpress.com/category/bit-count/
+         *   http://www.hackersdelight.org/
          *
*/ - public static final int getBitCount(final int n) { + public static final int bitCount(int n) { // Note: Original used 'unsigned int', // hence we use the unsigned right-shift '>>>' - int c = n; - c -= (n >>> 1) & 033333333333; - c -= (n >>> 2) & 011111111111; - return ( (c + ( c >>> 3 ) ) & 030707070707 ) % 63; + /** + * Original does not work due to lack of 'unsigned' right-shift and modulo, + * we need 2-complementary solution, i.e. 'signed'. + int c = n; + c -= (n >>> 1) & 033333333333; + c -= (n >>> 2) & 011111111111; + return ( (c + ( c >>> 3 ) ) & 030707070707 ) & 0x3f; // % 63 + */ + // Hackers Delight, Figure 5-2, pop1 of pop.c.txt + n = n - ((n >>> 1) & 0x55555555); + n = (n & 0x33333333) + ((n >>> 2) & 0x33333333); + n = (n + (n >>> 4)) & 0x0f0f0f0f; + n = n + (n >>> 8); + n = n + (n >>> 16); + return n & 0x3f; } } /** @@ -84,12 +116,18 @@ public interface Bitfield { /** * Returns the storage size in bit units, e.g. 32 bit for implementations using one {@code int} field. */ - int getStorageBitSize(); + int size(); + + + /** + * Set all bits of this bitfield to the given value {@code bit}. + */ + void clearField(final boolean bit); /** * Returns {@code length} bits from this storage, * starting with the lowest bit from the storage position {@code lowBitnum}. - * @param lowBitnum storage bit position of the lowest bit, restricted to [0..{@link #getStorageBitSize()}-{@code length}]. + * @param lowBitnum storage bit position of the lowest bit, restricted to [0..{@link #size()}-{@code length}]. * @param length number of bits to read, constrained to [0..32]. * @throws IndexOutOfBoundsException if {@code rightBitnum} is out of bounds * @see #put32(int, int, int) @@ -99,8 +137,8 @@ public interface Bitfield { /** * Puts {@code length} bits of given {@code data} into this storage, * starting w/ the lowest bit to the storage position {@code lowBitnum}. - * @param lowBitnum storage bit position of the lowest bit, restricted to [0..{@link #getStorageBitSize()}-{@code length}]. - * @param length number of bits to read, constrained to [0..32]. + * @param lowBitnum storage bit position of the lowest bit, restricted to [0..{@link #size()}-{@code length}]. + * @param length number of bits to write, constrained to [0..32]. * @param data the actual bits to be put into this storage * @throws IndexOutOfBoundsException if {@code rightBitnum} is out of bounds * @see #get32(int, int) @@ -114,8 +152,8 @@ public interface Bitfield { * Implementation shall operate as if invoking {@link #get32(int, int)} * and then {@link #put32(int, int, int)} sequentially. *

- * @param srcLowBitnum source bit number, restricted to [0..{@link #getStorageBitSize()}-1]. - * @param dstLowBitnum destination bit number, restricted to [0..{@link #getStorageBitSize()}-1]. + * @param srcLowBitnum source bit number, restricted to [0..{@link #size()}-1]. + * @param dstLowBitnum destination bit number, restricted to [0..{@link #size()}-1]. * @throws IndexOutOfBoundsException if {@code bitnum} is out of bounds * @see #get32(int, int) * @see #put32(int, int, int) @@ -124,7 +162,7 @@ public interface Bitfield { /** * Return true if the bit at position bitnum is set, otherwise false. - * @param bitnum bit number, restricted to [0..{@link #getStorageBitSize()}-1]. + * @param bitnum bit number, restricted to [0..{@link #size()}-1]. * @throws IndexOutOfBoundsException if {@code bitnum} is out of bounds */ boolean get(final int bitnum) throws IndexOutOfBoundsException; @@ -132,21 +170,21 @@ public interface Bitfield { /** * Set or clear the bit at position bitnum according to bit * and return the previous value. - * @param bitnum bit number, restricted to [0..{@link #getStorageBitSize()}-1]. + * @param bitnum bit number, restricted to [0..{@link #size()}-1]. * @throws IndexOutOfBoundsException if {@code bitnum} is out of bounds */ void put(final int bitnum, final boolean bit) throws IndexOutOfBoundsException; /** * Set the bit at position bitnum according to bit. - * @param bitnum bit number, restricted to [0..{@link #getStorageBitSize()}-1]. + * @param bitnum bit number, restricted to [0..{@link #size()}-1]. * @throws IndexOutOfBoundsException if {@code bitnum} is out of bounds */ void set(final int bitnum) throws IndexOutOfBoundsException; /** * Clear the bit at position bitnum according to bit. - * @param bitnum bit number, restricted to [0..{@link #getStorageBitSize()}-1]. + * @param bitnum bit number, restricted to [0..{@link #size()}-1]. * @throws IndexOutOfBoundsException if {@code bitnum} is out of bounds */ void clear(final int bitnum) throws IndexOutOfBoundsException; @@ -154,17 +192,17 @@ public interface Bitfield { /** * Copies the bit at position {@code srcBitnum} to position {@code dstBitnum} * and returning true if the bit is set, otherwise false. - * @param srcBitnum source bit number, restricted to [0..{@link #getStorageBitSize()}-1]. - * @param dstBitnum destination bit number, restricted to [0..{@link #getStorageBitSize()}-1]. + * @param srcBitnum source bit number, restricted to [0..{@link #size()}-1]. + * @param dstBitnum destination bit number, restricted to [0..{@link #size()}-1]. * @throws IndexOutOfBoundsException if {@code bitnum} is out of bounds */ boolean copy(final int srcBitnum, final int dstBitnum) throws IndexOutOfBoundsException; /** - * Returns the number of set bits within this bitfield. + * Returns the number of one bits within this bitfield. *

- * Utilizes {#link {@link Bitfield.Util#getBitCount(int)}}. + * Utilizes {#link {@link Bitfield.Util#bitCount(int)}}. *

*/ - int getBitCount(); + int bitCount(); } diff --git a/src/java/com/jogamp/common/util/IntBitfield.java b/src/java/com/jogamp/common/util/IntBitfield.java index 3ef5bb7..e7a9d70 100644 --- a/src/java/com/jogamp/common/util/IntBitfield.java +++ b/src/java/com/jogamp/common/util/IntBitfield.java @@ -140,10 +140,10 @@ public class IntBitfield { return prev; } /** - * @deprecated Use {@link Bitfield.Util#getBitCount(int)}. + * @deprecated Use {@link Bitfield.Util#bitCount(int)}. */ public static final int getBitCount(final int n) { - return Bitfield.Util.getBitCount(n); + return Bitfield.Util.bitCount(n); } /** @@ -155,7 +155,7 @@ public class IntBitfield { public long getBitCount() { long c = 0; for(int i = storage.length-1; i>=0; i--) { - c += Bitfield.Util.getBitCount(storage[i]); + c += Bitfield.Util.bitCount(storage[i]); } return c; } diff --git a/src/java/jogamp/common/util/Int32ArrayBitfield.java b/src/java/jogamp/common/util/Int32ArrayBitfield.java index dd18b3d..3dcb9ae 100644 --- a/src/java/jogamp/common/util/Int32ArrayBitfield.java +++ b/src/java/jogamp/common/util/Int32ArrayBitfield.java @@ -44,16 +44,29 @@ public class Int32ArrayBitfield implements Bitfield { * @param storageBitSize */ public Int32ArrayBitfield(final int storageBitSize) { - final int units = Math.max(1, ( storageBitSize + 7 ) >>> UNIT_SHIFT); - this.storage = new int[units]; + final int units = Math.max(1, ( storageBitSize + 31 ) >>> UNIT_SHIFT); + this.storage = new int[units]; // initialized w/ default '0' this.bitSize = units << UNIT_SHIFT; } @Override - public int getStorageBitSize() { + public int size() { return bitSize; } + @Override + public final void clearField(final boolean bit) { + final int v; + if( bit ) { + v = Bitfield.UNSIGNED_INT_MAX_VALUE; + } else { + v = 0; + } + for(int i=storage.length-1; i>=0; i--) { + storage[i] = v; + } + } + private static final void check(final int size, final int bitnum) throws IndexOutOfBoundsException { if( 0 > bitnum || bitnum >= size ) { throw new IndexOutOfBoundsException("Bitnum should be within [0.."+(size-1)+"], but is "+bitnum); @@ -70,14 +83,14 @@ public class Int32ArrayBitfield implements Bitfield { final int left = 32 - ( lowBitnum - ( u << UNIT_SHIFT ) ); // remaining bits of first chunk storage if( 32 == left ) { // fast path - final int m = ( 1 << length ) - 1; + final int m = Util.getBitMask(length); // mask of chunk return m & storage[u]; } else { // slow path - final int l = Math.min(length, left); // length of first chunk + final int l = Math.min(length, left); // length of first chunk < 32 final int m = ( 1 << l ) - 1; // mask of first chunk final int d = m & ( storage[u] >>> lowBitnum ); - final int l2 = length - l; // length of last chunk + final int l2 = length - l; // length of last chunk < 32 if( l2 > 0 ) { final int m2 = ( 1 << l2 ) - 1; // mask of last chunk return d | ( ( m2 & storage[u+1] ) << l ); @@ -96,20 +109,20 @@ public class Int32ArrayBitfield implements Bitfield { final int left = 32 - ( lowBitnum - ( u << UNIT_SHIFT ) ); // remaining bits of first chunk storage if( 32 == left ) { // fast path - final int m = ( 1 << length ) - 1; // mask of chunk + final int m = Util.getBitMask(length); // mask of chunk storage[u] = ( ( ~m ) & storage[u] ) // keep non-written storage bits | ( m & data ); // overwrite storage w/ used data bits } else { // slow path - final int l = Math.min(length, left); // length of first chunk + final int l = Math.min(length, left); // length of first chunk < 32 final int m = ( 1 << l ) - 1; // mask of first chunk storage[u] = ( ( ~( m << lowBitnum ) ) & storage[u] ) // keep non-written storage bits | ( ( m & data ) << lowBitnum ); // overwrite storage w/ used data bits - final int l2 = length - l; // length of last chunk + final int l2 = length - l; // length of last chunk < 32 if( l2 > 0 ) { final int m2 = ( 1 << l2 ) - 1; // mask of last chunk - storage[u] = ( ( ~m2 ) & storage[u+1] ) // keep non-written storage bits - | ( m2 & ( data >>> l ) ); // overwrite storage w/ used data bits + storage[u+1] = ( ( ~m2 ) & storage[u+1] ) // keep non-written storage bits + | ( m2 & ( data >>> l ) ); // overwrite storage w/ used data bits } } } @@ -180,10 +193,10 @@ public class Int32ArrayBitfield implements Bitfield { } @Override - public int getBitCount() { + public int bitCount() { int c = 0; for(int i = storage.length-1; i>=0; i--) { - c += Bitfield.Util.getBitCount(storage[i]); + c += Bitfield.Util.bitCount(storage[i]); } return c; } diff --git a/src/java/jogamp/common/util/Int32Bitfield.java b/src/java/jogamp/common/util/Int32Bitfield.java index 6119a00..9bf2117 100644 --- a/src/java/jogamp/common/util/Int32Bitfield.java +++ b/src/java/jogamp/common/util/Int32Bitfield.java @@ -45,10 +45,19 @@ public class Int32Bitfield implements Bitfield { } @Override - public int getStorageBitSize() { + public int size() { return UNIT_SIZE; } + @Override + public final void clearField(final boolean bit) { + if( bit ) { + storage = Bitfield.UNSIGNED_INT_MAX_VALUE; + } else { + storage = 0; + } + } + private static final void check(final int size, final int bitnum) throws IndexOutOfBoundsException { if( 0 > bitnum || bitnum >= size ) { throw new IndexOutOfBoundsException("Bitnum should be within [0.."+(size-1)+"], but is "+bitnum); @@ -64,11 +73,11 @@ public class Int32Bitfield implements Bitfield { final int left = 32 - lowBitnum; // remaining bits of first chunk if( 32 == left ) { // fast path - final int m = ( 1 << length ) - 1; + final int m = Util.getBitMask(length); // mask of chunk return m & storage; } else { // slow path - final int l = Math.min(length, left); // length of first chunk + final int l = Math.min(length, left); // length of first chunk < 32 final int m = ( 1 << l ) - 1; // mask of first chunk return m & ( storage >>> lowBitnum ); } @@ -82,12 +91,12 @@ public class Int32Bitfield implements Bitfield { final int left = 32 - lowBitnum; // remaining bits of first chunk storage if( 32 == left ) { // fast path - final int m = ( 1 << length ) - 1; // mask of chunk + final int m = Util.getBitMask(length); // mask of chunk storage = ( ( ~m ) & storage ) // keep non-written storage bits | ( m & data ); // overwrite storage w/ used data bits } else { // slow path - final int l = Math.min(length, left); // length of first chunk + final int l = Math.min(length, left); // length of first chunk < 32 final int m = ( 1 << l ) - 1; // mask of first chunk storage = ( ( ~( m << lowBitnum ) ) & storage ) // keep non-written storage bits | ( ( m & data ) << lowBitnum ); // overwrite storage w/ used data bits @@ -144,7 +153,7 @@ public class Int32Bitfield implements Bitfield { } @Override - public int getBitCount() { - return Bitfield.Util.getBitCount(storage); + public int bitCount() { + return Bitfield.Util.bitCount(storage); } } diff --git a/src/java/jogamp/common/util/SyncedBitfield.java b/src/java/jogamp/common/util/SyncedBitfield.java index 783fb91..488be12 100644 --- a/src/java/jogamp/common/util/SyncedBitfield.java +++ b/src/java/jogamp/common/util/SyncedBitfield.java @@ -40,8 +40,13 @@ public class SyncedBitfield implements Bitfield { } @Override - public final synchronized int getStorageBitSize() { - return impl.getStorageBitSize(); + public final synchronized int size() { + return impl.size(); + } + + @Override + public final void clearField(final boolean bit) { + impl.clearField(bit); } @Override @@ -85,7 +90,7 @@ public class SyncedBitfield implements Bitfield { } @Override - public final synchronized int getBitCount() { - return impl.getBitCount(); + public final synchronized int bitCount() { + return impl.bitCount(); } } \ No newline at end of file diff --git a/src/junit/com/jogamp/common/util/TestBitfield00.java b/src/junit/com/jogamp/common/util/TestBitfield00.java new file mode 100644 index 0000000..7f2835a --- /dev/null +++ b/src/junit/com/jogamp/common/util/TestBitfield00.java @@ -0,0 +1,379 @@ +/** + * Copyright 2015 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 org.junit.Test; +import org.junit.Assert; + +import com.jogamp.junit.util.SingletonJunitCase; + +import org.junit.FixMethodOrder; +import org.junit.runners.MethodSorters; + +/** + * Test basic bitfield operations for {@link Bitfield} + */ +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class TestBitfield00 extends SingletonJunitCase { + + @Test + public void test01_BitCount32_One() { + final String[] pyramid32bit_one = BitDemoData.pyramid32bit_one; + for(int i=0; i=0x1FF; l++) { + test_BitCount32_Samples(l); + } + for(long l=MAX_half_minus; l<=MAX_half_plus; l++) { + test_BitCount32_Samples(l); + } + for(long l=MAX_minus; l<=MAX; l++) { + test_BitCount32_Samples(l); + } + } + static void test_BitCount32_Samples(final long l) { + final int oneBitCountL = Long.bitCount(l); + final int val0 = (int)l; + final int oneBitCountI = Integer.bitCount(val0); + final int oneBitCount1 = Bitfield.Util.bitCount(val0); + final String msg = String.format("Round 0x%08x, c %d / %d / %d%n", val0, + oneBitCountL, oneBitCountI, oneBitCount1); + Assert.assertEquals(msg, oneBitCountI, oneBitCountL); + Assert.assertEquals(msg, oneBitCountI, oneBitCount1); + } + + static int[] testDataOneBit = new int[] { + 0,0, 1,1, 2,1, 3,2, 4,1, 5,2, 6,2, 7,3, + 8,1, 9,2, 10,2, 11,3, 12,2, 13,3, 14,3, 15,4, 16,1, 17,2, + 0x3F,6, 0x40,1, 0x41,2, 0x7f,7, 0x80,1, 0x81,2, 0xfe,7, 0xff,8, + 0x4000,1, 0x4001,2, 0x7000,3, 0x7fff,15, + 0x0FFFFFF0,24, + 0x55555555,16, + 0x7F53F57B,23, 0xFEA7EAF6,23, /* << 1 */ + 0x80000000, 1, + 0xAAAAAAAA,16, + 0xC0C0C0C0, 8, + 0xFF000000, 8, + 0xFFFFFFFF,32 + }; + @Test + public void test03_BitCount32_Data() { + for(int i = 0; iL : 0x04030201: 00000100 00000011 00000010 00000001 + new TestDataBF(32, 0x04030201, "00000100000000110000001000000001"), + + // H->L : 0xAFFECAFE: 10101111 11111110 11001010 11111110 + new TestDataBF(32, 0xAFFECAFE, "10101111111111101100101011111110"), + // H->L : 0xDEADBEEF: 11011110 10101101 10111110 11101111 + new TestDataBF(32, 0xDEADBEEF, "11011110101011011011111011101111") + }; + static TestDataBF[] testDataBF16Bit = { + // H->L : 0x0201: 00000100 00000011 00000010 00000001 + new TestDataBF(16, 0x0201, "0000001000000001"), + // H->L : 0x0403: 00000100 00000011 + new TestDataBF(16, 0x0403, "0000010000000011"), + + // H->L : 0xAFFE: 10101111 11111110 + new TestDataBF(16, 0xAFFE, "1010111111111110"), + // H->L : 0xCAFE: 11001010 11111110 + new TestDataBF(16, 0xCAFE, "1100101011111110"), + + // H->L : 0xDEADBEEF: 11011110 10101101 10111110 11101111 + new TestDataBF(16, 0xDEAD, "1101111010101101"), + new TestDataBF(16, 0xBEEF, "1011111011101111") + }; + + @Test + public void test20_ValidateTestData() { + for(int i=0; i>> 5); + return units << 5; + } + static void test_Aligned32bit(final TestDataBF d) { + final int oneBitCount = Bitfield.Util.bitCount(d.val); + + final Bitfield bf1 = Bitfield.Factory.create(d.bitSize); + Assert.assertEquals(get32BitStorageSize(d.bitSize), bf1.size()); + final Bitfield bf2 = Bitfield.Factory.create(d.bitSize+128); + Assert.assertEquals(get32BitStorageSize(d.bitSize+128), bf2.size()); + + bf1.put32( 0, d.bitSize, d.val); + Assert.assertEquals(d.val, bf1.get32( 0, d.bitSize)); + Assert.assertEquals(oneBitCount, bf1.bitCount()); + assertEquals(bf1, 0, d.val, d.pattern, oneBitCount); + + bf2.put32( 0, d.bitSize, d.val); + Assert.assertEquals(d.val, bf2.get32( 0, d.bitSize)); + Assert.assertEquals(oneBitCount*1, bf2.bitCount()); + assertEquals(bf2, 0, d.val, d.pattern, oneBitCount); + bf2.put32(64, d.bitSize, d.val); + Assert.assertEquals(d.val, bf2.get32(64, d.bitSize)); + Assert.assertEquals(oneBitCount*2, bf2.bitCount()); + assertEquals(bf2, 64, d.val, d.pattern, oneBitCount); + + Assert.assertEquals(d.val, bf2.copy32(0, 96, d.bitSize)); + Assert.assertEquals(d.val, bf2.get32(96, d.bitSize)); + Assert.assertEquals(oneBitCount*3, bf2.bitCount()); + assertEquals(bf2, 96, d.val, d.pattern, oneBitCount); + } + + @Test + public void test21_Unaligned() { + for(int i=0; i lowBitnum+1 ) { + // copy bits 1 forward + // clear trailing orig bit + Assert.assertEquals(msg, d.val, bf.copy32(lowBitnum, lowBitnum+1, d.bitSize)); + bf.clear(lowBitnum); + Assert.assertEquals(msg, d.val, bf.get32( lowBitnum+1, d.bitSize)); + Assert.assertEquals(msg, oneBitCount, bf.bitCount()); + assertEquals(bf, lowBitnum+1, d.val, d.pattern, oneBitCount); + } + + // + // via put + // + bf.clearField(false); + for(int i=0; i lowBitnum+1 ) { + // copy bits 1 forward + // clear trailing orig bit + for(int i=d.bitSize-1; i>=0; i--) { + bf.copy(lowBitnum+i, lowBitnum+1+i); + } + bf.clear(lowBitnum); + Assert.assertEquals(msg, d.val, bf.get32( lowBitnum+1, d.bitSize)); + for(int i=0; i