/*

   Derby - Class org.apache.derbyTesting.unitTests.junit.FormatableBitSet

   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to you under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

 */

package org.apache.derbyTesting.unitTests.junit;

import org.apache.derbyTesting.junit.BaseTestCase;
import junit.framework.*;

import org.apache.derby.iapi.services.io.FormatableBitSet;

import org.apache.derby.shared.common.sanity.SanityManager;
import org.apache.derby.shared.common.sanity.AssertFailure;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;


/**
 * This class is used to test the FormatableBitSet implementation.
 */
public class FormatableBitSetTest extends BaseTestCase {
    private byte[] bits24;
    private byte[] bits24C;

    private FormatableBitSet empty;
    private FormatableBitSet bitset18;
    private FormatableBitSet bitset18C;

    /**
     * <code>Integer.bitCount</code> method. Only available in JDK 1.5 or
     * later.
     */
    private final static Method bitCount;
    static {
        Method m = null;
        try {
            m = Integer.class.getMethod("bitCount", new Class[]{Integer.TYPE});
        } catch (Throwable t) {}
        bitCount = m;
    }

    /**
     * Create a test with the given name.
     *
     * @param name name of the test.
     */
    public FormatableBitSetTest(String name) {
        super(name);
    }

    /**
     *
     */
    public void setUp() {
        //1100 1110 0011 1100 0000
        bits24  = new byte[] { (byte)0xce, (byte)0x3c, 0x0 };

        // 0011 0001 1100 0011 1100
        bits24C = new byte[] { (byte)0x31, (byte)0xc3, (byte)0xc0 };

        empty = new FormatableBitSet();
        bitset18 = new FormatableBitSet(bits24);
        bitset18.shrink(18);
        bitset18C = new FormatableBitSet(bits24C);
        bitset18C.shrink(18);
    }

    /**
     * Release the resources that are used in this test
     *
     * @throws Exception
     */
    public void tearDown() throws Exception {
        empty = null;
        bits24 = null;
        bits24C = null;
        bitset18 = null;
        bitset18C = null;
        super.tearDown();
    }
    /**
     * Return a suite with all tests in this class (default suite)
     *
     * @throws Exception
     */
    public static Test suite() {
        TestSuite ts = new TestSuite(FormatableBitSetTest.class,
                             "FormatableBitSetTest suite");

        if (bitCount != null) {
            ts.addTest(new FormatableBitSetTest("numBitsSetInOneByte"));
            ts.addTest(new FormatableBitSetTest("numBitsSetInTwoBytes"));
        }

        return ts;
    }

    /**
     * Test case that does a sanity check of the setup
     */
    public void testSetup() {
        assertEquals(0,empty.getLength());
        assertEquals(0,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(0,empty.getByteArray().length);

        assertEquals(18,bitset18.getLength());
        assertEquals(3,bitset18.getLengthInBytes());
        assertEquals(9,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(bits24,bitset18.getByteArray());

        assertEquals(18,bitset18C.getLength());
        assertEquals(3,bitset18C.getLengthInBytes());
        assertEquals(9,bitset18C.getNumBitsSet());
        assertTrue(bitset18C.invariantHolds());
        assertEquals(bits24C,bitset18C.getByteArray());
    }

    // Test cases for single arg constructor
    public void testIntCtor0() {
        FormatableBitSet zeroBits = new FormatableBitSet(0);
        assertEquals(0,zeroBits.getLength());
        assertEquals(0,zeroBits.getLengthInBytes());
        assertEquals(0,zeroBits.getNumBitsSet());
        assertTrue(zeroBits.invariantHolds());
        assertEquals(0,zeroBits.getByteArray().length);
    }
    public void testIntCtor1() {
        FormatableBitSet oneBit = new FormatableBitSet(1);
        assertEquals(1,oneBit.getLength());
        assertEquals(1,oneBit.getLengthInBytes());
        assertEquals(0,oneBit.getNumBitsSet());
        assertTrue(oneBit.invariantHolds());
        assertEquals(1,oneBit.getByteArray().length);
    }
    public void testIntCtor8() {
        FormatableBitSet eightBits = new FormatableBitSet(8);
        assertEquals(8,eightBits.getLength());
        assertEquals(1,eightBits.getLengthInBytes());
        assertEquals(0,eightBits.getNumBitsSet());
        assertTrue(eightBits.invariantHolds());
        assertEquals(1,eightBits.getByteArray().length);
    }
    public void testIntCtor9() {
        FormatableBitSet nineBits = new FormatableBitSet(9);
        assertEquals(9,nineBits.getLength());
        assertEquals(2,nineBits.getLengthInBytes());
        assertEquals(0,nineBits.getNumBitsSet());
        assertTrue(nineBits.invariantHolds());
        assertEquals(2,nineBits.getByteArray().length);
    }
    public void testIntCtorNeg() {
        try { FormatableBitSet negBits = new FormatableBitSet(-1); fail(); }
        catch(IllegalArgumentException iae) {}
    }

    // Test cases for the copy constructor
    public void testEmptyCpyCtor() {
        FormatableBitSet emptyCpy = new FormatableBitSet(empty);
        assertEquals(0,emptyCpy.getLength());
        assertEquals(0,emptyCpy.getLengthInBytes());
        assertEquals(0,emptyCpy.getNumBitsSet());
        assertTrue(emptyCpy.invariantHolds());
    }
    public void testCpyCtor() {
        FormatableBitSet cpy = new FormatableBitSet(bitset18);
        assertEquals(18,cpy.getLength());
        assertEquals(3,cpy.getLengthInBytes());
        assertEquals(9,cpy.getNumBitsSet());
        assertEquals(0,cpy.compare(bitset18));
        assertTrue(cpy.equals(bitset18));
        assertTrue(cpy.invariantHolds());
        assertEquals(3,cpy.getByteArray().length);
    }

    // Test cases for grow(int)
    public void testGrowEmpty() {
        empty.grow(18);
        assertEquals(18,empty.getLength());
        assertEquals(3,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(3,empty.getByteArray().length);
    }
    public void testGrow() {
        bitset18.grow(25);
        assertEquals(25,bitset18.getLength());
        assertEquals(4,bitset18.getLengthInBytes());
        assertEquals(9,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(4,bitset18.getByteArray().length);
    }
    public void testGrowSmaller() {
        bitset18.grow(9);
        assertEquals(18,bitset18.getLength());
        assertEquals(3,bitset18.getLengthInBytes());
        assertEquals(9,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(3,bitset18.getByteArray().length);
    }
    public void testGrowNeg() {
        try { bitset18.grow(-9); fail(); }
        catch (IllegalArgumentException iae) {}
    }
    public void testGrow0() {
        empty.grow(0);
        assertEquals(0,empty.getLength());
        assertEquals(0,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(0,empty.getByteArray().length);
    }
    public void testGrow1() {
        empty.grow(1);
        assertEquals(1,empty.getLength());
        assertEquals(1,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(1,empty.getByteArray().length);
    }
    public void testGrow2() {
        empty.grow(2);
        assertEquals(2,empty.getLength());
        assertEquals(1,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(1,empty.getByteArray().length);
    }
    public void testGrow3() {
        empty.grow(3);
        assertEquals(3,empty.getLength());
        assertEquals(1,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(1,empty.getByteArray().length);
    }
    public void testGrow4() {
        empty.grow(4);
        assertEquals(4,empty.getLength());
        assertEquals(1,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(1,empty.getByteArray().length);
    }
    public void testGrow5() {
        empty.grow(5);
        assertEquals(5,empty.getLength());
        assertEquals(1,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(1,empty.getByteArray().length);
    }
    public void testGrow6() {
        empty.grow(6);
        assertEquals(6,empty.getLength());
        assertEquals(1,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(1,empty.getByteArray().length);
    }
    public void testGrow7() {
        empty.grow(7);
        assertEquals(7,empty.getLength());
        assertEquals(1,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(1,empty.getByteArray().length);
    }
    public void testGrow8() {
        empty.grow(8);
        assertEquals(8,empty.getLength());
        assertEquals(1,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(1,empty.getByteArray().length);
    }
    public void testGrow9() {
        empty.grow(9);
        assertEquals(9,empty.getLength());
        assertEquals(2,empty.getByteArray().length);
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(2,empty.getLengthInBytes());
    }

    // Test cases for shrink(int)
    public void testShrinkEmpty() {
        empty.shrink(0);
        assertEquals(0,empty.getLength());
        assertEquals(0,empty.getLengthInBytes());
        assertEquals(0,empty.getNumBitsSet());
        assertTrue(empty.invariantHolds());
        assertEquals(0,empty.getByteArray().length);
    }
    public void testShrink() {
        bitset18.shrink(9);
        assertEquals(9,bitset18.getLength());
        assertEquals(2,bitset18.getLengthInBytes());
        assertEquals(5,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(2,bitset18.getByteArray().length);
    }
    public void testShrinkLarger() {
        try { bitset18.shrink(25); fail(); }
        catch (IllegalArgumentException iae) {}
    }
    public void testShrinkNeg() {
        try {
            bitset18.shrink(-9);
            fail();
        } catch (IllegalArgumentException iae) {}
    }
    public void testShrink0() {
        bitset18.shrink(0);
        assertEquals(0,bitset18.getLength());
        assertEquals(0,bitset18.getLengthInBytes());
        assertTrue(bitset18.invariantHolds());
        assertEquals(0,bitset18.getNumBitsSet());
        assertEquals(0,bitset18.getByteArray().length);
    }
    public void testShrink1() {
        bitset18.shrink(1);
        assertEquals(1,bitset18.getLength());
        assertEquals(1,bitset18.getLengthInBytes());
        assertEquals(1,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(1,bitset18.getByteArray().length);
    }
    public void testShrink2() {
        bitset18.shrink(2);
        assertEquals(2,bitset18.getLength());
        assertEquals(1,bitset18.getLengthInBytes());
        assertEquals(2,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(1,bitset18.getByteArray().length);
    }
    public void testShrink3() {
        bitset18.shrink(3);
        assertEquals(3,bitset18.getLength());
        assertEquals(1,bitset18.getLengthInBytes());
        assertEquals(2,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(1,bitset18.getByteArray().length);
    }
    public void testShrink4() {
        bitset18.shrink(4);
        assertEquals(4,bitset18.getLength());
        assertEquals(1,bitset18.getLengthInBytes());
        assertEquals(2,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(1,bitset18.getByteArray().length);
    }
    public void testShrink5() {
        bitset18.shrink(5);
        assertEquals(5,bitset18.getLength());
        assertEquals(1,bitset18.getLengthInBytes());
        assertEquals(3,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(1,bitset18.getByteArray().length);
    }
    public void testShrink6() {
        bitset18.shrink(6);
        assertEquals(6,bitset18.getLength());
        assertEquals(1,bitset18.getLengthInBytes());
        assertEquals(4,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(1,bitset18.getByteArray().length);
    }
    public void testShrink7() {
        bitset18.shrink(7);
        assertEquals(7,bitset18.getLength());
        assertEquals(1,bitset18.getLengthInBytes());
        assertEquals(5,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(1,bitset18.getByteArray().length);
    }
    public void testShrink8() {
        bitset18.shrink(8);
        assertEquals(8,bitset18.getLength());
        assertEquals(1,bitset18.getLengthInBytes());
        assertEquals(5,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(1,bitset18.getByteArray().length);
    }
    public void testShrink9() {
        bitset18.shrink(9);
        assertEquals(9,bitset18.getLength());
        assertEquals(2,bitset18.getLengthInBytes());
        assertEquals(5,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(2,bitset18.getByteArray().length);
    }
    public void testShrink10() {
        bitset18.shrink(10);
        assertEquals(10,bitset18.getLength());
        assertEquals(2,bitset18.getLengthInBytes());
        assertEquals(5,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(2,bitset18.getByteArray().length);
    }

    // Test cases for compare(FormatableBitSet)
    public void testCompareSameEmpty() {
        assertEquals(0,empty.compare(empty));
    }
    public void testCompareAnotherEmpty() {
        assertEquals(0,empty.compare(new FormatableBitSet()));
    }
    public void testCompare18Empty() {
        // Would expect -1 since empty is smaller than bitset18 (based
        //on documentation)
        //assertEquals(-1,bitset18.compare(new FormatableBitSet()));
        assertEquals(1,bitset18.compare(new FormatableBitSet()));
    }
    public void testCompareEmpty18() {
        // Would expect 1 since empty is smaller than bitset18 (based
        //on documentation)
        //assertEquals(1,empty.compare(bitset18));
        assertEquals(-1,empty.compare(bitset18));
    }
    public void testCompareToComplement() {
        assertEquals(1, bitset18.compare(bitset18C));
    }
    public void testCompareDifferentArray() {
        FormatableBitSet small = new FormatableBitSet(bitset18);
        small.shrink(9);
        assertTrue(small.invariantHolds());
        FormatableBitSet large = new FormatableBitSet(bitset18);
        large.grow(100);
        assertTrue(large.invariantHolds());
        large.shrink(9);
        assertTrue(large.invariantHolds());
        assertEquals(0,small.compare(large));
    }

    // Test cases for isSet(int)
    public void testIsSetEmpty() {
        try { empty.isSet(-8); fail(); } catch (IllegalArgumentException iae) {}
        try { empty.isSet(-1); fail(); } catch (IllegalArgumentException iae) {}
        try { empty.isSet(0); fail(); } catch (IllegalArgumentException iae) {}
    }
    public void testIsSet() {
        try { bitset18C.isSet(-8); fail(); }
        catch (IllegalArgumentException iae) {}

        try { bitset18C.isSet(-1); fail(); }
        catch (IllegalArgumentException iae) {}

        assertFalse(bitset18C.isSet(0));
        assertFalse(bitset18C.isSet(1));
        assertTrue(bitset18C.isSet(2));
        assertTrue(bitset18C.isSet(3));
        assertFalse(bitset18C.isSet(4));
        assertFalse(bitset18C.isSet(5));
        assertFalse(bitset18C.isSet(6));
        assertTrue(bitset18C.isSet(7));
        assertTrue(bitset18C.isSet(8));
        assertTrue(bitset18C.isSet(9));
        assertFalse(bitset18C.isSet(10));
        assertFalse(bitset18C.isSet(11));
        assertFalse(bitset18C.isSet(12));
        assertFalse(bitset18C.isSet(13));
        assertTrue(bitset18C.isSet(14));
        assertTrue(bitset18C.isSet(15));
        assertTrue(bitset18C.isSet(16));
        assertTrue(bitset18C.isSet(17));
        try { bitset18C.isSet(18); fail(); }
        catch (IllegalArgumentException iae) {}
    }

    // Test cases for set(int)
    public void testSetEmpty() {
        try { empty.set(-8); fail(); } catch (IllegalArgumentException iae) {}
        try { empty.set(-1); fail(); } catch (IllegalArgumentException iae) {}
        try { empty.set(0); fail(); } catch (IllegalArgumentException iae) {}
    }
    public void testSet() {
        try { bitset18.set(-8); fail(); }
        catch (IllegalArgumentException iae) {}
        try { bitset18.set(-1); fail(); }
        catch (IllegalArgumentException iae) {}
        bitset18.set(0);
        assertTrue(bitset18.invariantHolds());
        bitset18.set(1);
        assertTrue(bitset18.invariantHolds());
        try { bitset18.set(18); fail(); }
        catch (IllegalArgumentException iae) {}
    }

    // Test cases for clear(int)
    public void testClearEmpty() {
        try { empty.clear(-8); fail(); } catch (IllegalArgumentException iae) {}
        try { empty.clear(-1); fail(); } catch (IllegalArgumentException iae) {}
        try { empty.clear(0); fail(); } catch (IllegalArgumentException iae) {}
    }
    public void testClear() {
        try { bitset18.clear(-8); fail(); }
        catch (IllegalArgumentException iae) {}
        try { bitset18.clear(-1); fail(); }
        catch (IllegalArgumentException iae) {}
        bitset18.clear(0);
        assertTrue(bitset18.invariantHolds());
        bitset18.clear(1);
        assertTrue(bitset18.invariantHolds());
        try { bitset18.clear(18); fail(); }
        catch (IllegalArgumentException iae) {}
    }

    // Test cases for anySetBit()
    public void testAnySetBitEmpty() {
        assertEquals(empty.anySetBit(),-1);
    }
    public void testAnySetBit() {
        assertEquals(2,bitset18C.anySetBit());
        bitset18C.clear(2);
        assertEquals(3,bitset18C.anySetBit());
    }

    // Test cases for anySetBit(int)
    public void testAnySetBitBeyondBit() {
        assertEquals(4,bitset18.anySetBit(1));
    }
    public void testAnySetBitBeyondBitNeg() {
        assertEquals(1,bitset18.anySetBit(0));
        assertEquals(0,bitset18.anySetBit(-1));
        try { bitset18.anySetBit(-2); fail(); }
        catch (ArrayIndexOutOfBoundsException e) {}
        try { bitset18.anySetBit(-3); fail(); }
        catch (ArrayIndexOutOfBoundsException e) {}
    }
    public void testAnySetBitBeyondBitPastEnd() {
        assertEquals(-1, bitset18.anySetBit(18));
    }

    // Test cases for or(FormatableBitSet)
    public void testORWithNull() {
        FormatableBitSet cpy = new FormatableBitSet(bitset18);
        assertTrue(cpy.invariantHolds());
        bitset18.or(null);
        assertEquals(9,bitset18.getNumBitsSet());
        assertTrue(cpy.equals(bitset18));
    }
    public void testORWithEmpty() {
        FormatableBitSet cpy = new FormatableBitSet(bitset18);
        bitset18.or(empty);
        assertEquals(9,bitset18.getNumBitsSet());
        assertTrue(cpy.equals(bitset18));
        assertTrue(bitset18.invariantHolds());
    }
    public void testORWithComplement() {
        bitset18.or(bitset18C);
        assertEquals(bitset18.getNumBitsSet(),18);
        assertTrue(bitset18.invariantHolds());
    }
    public void testORWithSmaller() {
        bitset18C.shrink(9);
        bitset18.or(bitset18C);
        assertEquals(13,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
    }
    public void testORWithLarger() {
        bitset18.shrink(9);
        bitset18.or(bitset18C);
        assertEquals(14,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
    }

    // Test cases for and(FormatableBitSet)
    public void testANDWithNull() {
        bitset18.and(null);
        assertEquals(18,bitset18.getLength());
        assertEquals(3,bitset18.getLengthInBytes());
        assertEquals(3,bitset18.getByteArray().length);
        assertEquals(0,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
    }
    public void testANDWithEmpty() {
        bitset18.and(new FormatableBitSet());
        assertEquals(0,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
    }
    public void testANDWithComplement() {
        bitset18.and(bitset18C);
        assertEquals(0,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
    }
    public void testANDWithSmaller() {
        bitset18C.shrink(9);
        bitset18.and(bitset18C);
        assertEquals(0,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
    }
    public void testANDWithLarger() {
        bitset18.shrink(9);
        bitset18.and(bitset18C);
        assertEquals(0,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
    }

    // Test cases for xor(FormatableBitSet)
    public void testXORWithNull() {
        FormatableBitSet cpy = new FormatableBitSet(bitset18);
        bitset18.xor(null);
        assertEquals(9,bitset18.getNumBitsSet());
        assertTrue(cpy.equals(bitset18));
        assertTrue(bitset18.invariantHolds());
    }
    public void testXORWithEmpty() {
        FormatableBitSet cpy = new FormatableBitSet(bitset18);
        bitset18.xor(empty);
        assertEquals(18,bitset18.getLength());
        assertEquals(3,bitset18.getLengthInBytes());
        assertEquals(9,bitset18.getNumBitsSet());
        assertTrue(cpy.equals(bitset18));
        assertTrue(bitset18.invariantHolds());
        assertEquals(3,bitset18.getByteArray().length);
    }
    public void testXORWithComplement() {
        bitset18.set(2);
        bitset18.set(3);
        bitset18.xor(bitset18C);
        assertEquals(16,bitset18.getNumBitsSet());
        assertFalse(bitset18.isSet(2));
        assertFalse(bitset18.isSet(3));
        assertTrue(bitset18.invariantHolds());
    }
    public void testXORWithSmaller() {
        bitset18C.shrink(9);
        bitset18.xor(bitset18C);
        assertEquals(18,bitset18.getLength());
        assertEquals(3,bitset18.getLengthInBytes());
        assertEquals(13,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
        assertEquals(3,bitset18.getByteArray().length);
    }
    public void testXORWithLarger() {
        bitset18.shrink(9);
        bitset18.xor(bitset18C);
        assertEquals(14,bitset18.getNumBitsSet());
        assertTrue(bitset18.invariantHolds());
    }

    // count one-bits in a byte with Integer.bitCount()
    private static int bitsInByte(byte b) throws Exception {
        Integer arg = new Integer(b & 0xff);
        Integer ret = (Integer) bitCount.invoke(null, new Object[] { arg });
        return ret.intValue();
    }

    // test getNumBitsSet() for a one-byte bit set
    public void numBitsSetInOneByte() throws Exception {
        for (int i = Byte.MIN_VALUE; i <= Byte.MAX_VALUE; ++i) {
            final byte b = (byte) i;
            FormatableBitSet bs = new FormatableBitSet(new byte[] { b });
            assertEquals("invalid bit count for b=" + b,
                         bitsInByte(b), bs.getNumBitsSet());
        }
    }

    // test getNumBitsSet() for a two-byte bit set
    public void numBitsSetInTwoBytes() throws Exception {
        for (int i = Byte.MIN_VALUE; i <= Byte.MAX_VALUE; ++i) {
            final byte b1 = (byte) i;
            final int bits1 = bitsInByte(b1);
            for (int j = Byte.MIN_VALUE; j <= Byte.MAX_VALUE; ++j) {
                final byte b2 = (byte) j;
                FormatableBitSet bs =
                    new FormatableBitSet(new byte[] { b1, b2 });
                assertEquals(
                    "invalid bit count for b1=" + b1 + " and b2=" + b2,
                    bits1 + bitsInByte(b2), bs.getNumBitsSet());
            }
        }
    }

    // Test case for writeExternal(ObjectOut) and readExternal(ObjectOut)
    public void testExternal() throws IOException {
        ByteArrayOutputStream buf = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(buf);
        bitset18.writeExternal(oos);
        oos.flush();

        empty.readExternal
            (new ObjectInputStream(new ByteArrayInputStream
                                   (buf.toByteArray())));
        assertTrue(empty.equals(bitset18));
        assertTrue(empty.invariantHolds());
    }
}
