From ff7f50d911b23f9ced3fd72f86e6b78f763a99aa Mon Sep 17 00:00:00 2001 From: konsoletyper Date: Fri, 21 Mar 2014 01:42:35 +0400 Subject: [PATCH] Adds java.util.BitSet implementation --- .../org/teavm/classlib/java/util/TBitSet.java | 239 +++ .../teavm/classlib/java/util/BitSetTest.java | 1422 +++++++++++++++++ 2 files changed, 1661 insertions(+) create mode 100644 teavm-classlib/src/main/java/org/teavm/classlib/java/util/TBitSet.java create mode 100644 teavm-classlib/src/test/java/org/teavm/classlib/java/util/BitSetTest.java diff --git a/teavm-classlib/src/main/java/org/teavm/classlib/java/util/TBitSet.java b/teavm-classlib/src/main/java/org/teavm/classlib/java/util/TBitSet.java new file mode 100644 index 000000000..b3a94244f --- /dev/null +++ b/teavm-classlib/src/main/java/org/teavm/classlib/java/util/TBitSet.java @@ -0,0 +1,239 @@ +/* + * Copyright 2014 Alexey Andreev. + * + * Licensed 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.teavm.classlib.java.util; + +import org.teavm.classlib.java.io.TSerializable; +import org.teavm.classlib.java.lang.*; + +/** + * + * @author Alexey Andreev + */ +public class TBitSet extends TObject implements TCloneable, TSerializable { + private int[] data; + private int length; + + private TBitSet(int[] data) { + this.data = data; + length = data.length * Integer.SIZE; + recalculateLength(); + } + + public TBitSet() { + data = new int[0]; + } + + public TBitSet(int nbits) { + data = new int[TMath.max(1, (nbits + TInteger.SIZE - 1) / TInteger.SIZE)]; + } + + public static TBitSet valueOf(long[] longs) { + int[] ints = new int[longs.length * 2]; + for (int i = 0; i < longs.length; ++i) { + ints[i * 2 + 1] = (int)longs[i]; + ints[i * 2 + 1] = (int)(longs[i] >>> TInteger.SIZE); + } + return new TBitSet(ints); + } + + public static TBitSet valueOf(byte[] bytes) { + int[] ints = new int[(bytes.length + 3) / 4]; + int fullInts = bytes.length / 4; + for (int i = 0; i < fullInts; ++i) { + ints[i] = bytes[i * 4] | (bytes[i * 4 + 1] << 8) | (bytes[i * 4 + 2] << 16) | (bytes[i * 4 + 3] << 24); + } + int lastInt = ints.length - 1; + int lastByte = bytes[lastInt * 4]; + switch (bytes.length % 4) { + case 3: + ints[lastInt] = bytes[lastByte] | (bytes[lastByte + 1] << 8) | (bytes[lastByte + 2] << 16); + break; + case 2: + ints[lastInt] = bytes[lastByte] | (bytes[lastByte + 1] << 8); + break; + case 1: + ints[lastInt] = bytes[lastByte]; + break; + } + return new TBitSet(ints); + } + + public byte[] toByteArray() { + byte[] bytes = new byte[(length + 7) / 8]; + int fullInts = length / TInteger.SIZE; + int j = 0; + int i = 0; + for (; i < fullInts; i += 4) { + bytes[j++] = (byte)data[i]; + bytes[j++] = (byte)(data[i] >>> 8); + bytes[j++] = (byte)(data[i] >>> 16); + bytes[j++] = (byte)(data[i] >>> 24); + } + switch (bytes.length % 4) { + case 3: + bytes[j++] = (byte)data[i]; + bytes[j++] = (byte)(data[i] >>> 8); + bytes[j++] = (byte)(data[i] >>> 16); + break; + case 2: + bytes[j++] = (byte)data[i]; + bytes[j++] = (byte)(data[i] >>> 8); + break; + case 1: + bytes[j++] = (byte)data[i]; + break; + } + return bytes; + } + + public long[] toLongArray() { + long[] longs = new long[(length + 63) / 64]; + int fullLongs = length / 64; + int i = 0; + for (; i < fullLongs; ++i) { + longs[i] = data[i * 2] | (data[i * 2 + 1] << 32); + } + if ((length / 32) % 2 == 1) { + longs[i] = data[i * 2]; + } + return longs; + } + + public void flip(int bitIndex) { + if (get(bitIndex)) { + clear(bitIndex); + } else { + set(bitIndex); + } + } + + public void set(int bitIndex) { + int index = bitIndex / 32; + if (bitIndex >= length) { + ensureCapacity(index + 1); + length = bitIndex + 1; + } + data[index] |= 1 << (bitIndex % 32); + } + + public void set(int bitIndex, boolean value) { + if (value) { + set(bitIndex); + } else { + clear(bitIndex); + } + } + + public void set(int fromIndex, int toIndex) { + if (fromIndex > toIndex) { + throw new TIndexOutOfBoundsException(); + } + int fromDataIndex = fromIndex / 32; + int toDataIndex = toIndex / 32; + if (toIndex > length) { + ensureCapacity(toDataIndex + 1); + length = toIndex; + } + if (fromDataIndex == toDataIndex) { + data[fromDataIndex] |= (0xFFFFFFFF << (fromIndex % 32)) & (0xFFFFFFFF >>> (32 - toIndex % 32)); + } else { + data[fromDataIndex] |= 0xFFFFFFFF << (fromIndex % 32); + for (int i = fromDataIndex + 1; i < toDataIndex; ++i) { + data[i] = 0xFFFFFFFF; + } + data[toDataIndex] |= 0xFFFFFFFF >>> (32 - toIndex % 32); + } + } + + public void set(int fromIndex, int toIndex, boolean value) { + if (value) { + set(fromIndex, toIndex); + } else { + clear(fromIndex, toIndex); + } + } + + public void clear(int bitIndex) { + int index = bitIndex / 32; + if (index < data.length) { + data[index] &= TInteger.rotateLeft(bitIndex, 0xFFFFFFFE); + recalculateLength(); + } + } + + public void clear(int fromIndex, int toIndex) { + if (fromIndex > toIndex) { + throw new TIndexOutOfBoundsException(); + } + if (fromIndex >= length) { + return; + } + toIndex = TMath.min(length, toIndex); + int fromDataIndex = fromIndex / 32; + int toDataIndex = toIndex / 32; + if (fromDataIndex == toDataIndex) { + data[fromDataIndex] &= (0xFFFFFFFF >>> (32 - fromIndex % 32)) | (0xFFFFFFFF << (toIndex % 32)); + } else { + data[fromDataIndex] &= 0xFFFFFFFF >>> (32 - fromIndex % 32); + for (int i = fromDataIndex + 1; i < toDataIndex; ++i) { + data[i] = 0; + } + data[toDataIndex] &= 0xFFFFFFFF << (toIndex % 32); + } + recalculateLength(); + } + + public boolean get(int bitIndex) { + int index = bitIndex / 32; + return index < data.length && (data[index] & (1 << (bitIndex % 32))) != 0; + } + + public void clear() { + length = 0; + TArrays.fill(data, 0); + } + + private void ensureCapacity(int capacity) { + if (data.length >= capacity) { + return; + } + int newArrayLength = TMath.max(capacity * 3 / 2, data.length * 2 + 1); + data = TArrays.copyOf(data, newArrayLength); + } + + private void recalculateLength() { + length = (1 + length / 32) * 32; + for (int i = data.length - 1; i >= 0; --i, length -= TInteger.SIZE) { + int sz = TInteger.numberOfLeadingZeros(data[i]); + if (sz < TInteger.SIZE) { + length -= sz; + break; + } + } + } + + public int length() { + return length; + } + + public boolean isEmpty() { + return length == 0; + } + + public int size() { + return data.length * 32; + } +} diff --git a/teavm-classlib/src/test/java/org/teavm/classlib/java/util/BitSetTest.java b/teavm-classlib/src/test/java/org/teavm/classlib/java/util/BitSetTest.java new file mode 100644 index 000000000..81ed2f731 --- /dev/null +++ b/teavm-classlib/src/test/java/org/teavm/classlib/java/util/BitSetTest.java @@ -0,0 +1,1422 @@ +/* + * Copyright 2014 Alexey Andreev. + * + * Licensed 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. + */ +/* + * 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.teavm.classlib.java.util; + +import static org.junit.Assert.*; +import java.util.BitSet; +import org.junit.Test; + +public class BitSetTest { + + BitSet eightbs; + + public BitSetTest() { + eightbs = new BitSet(); + for (int i = 0; i < 8; i++) { + eightbs.set(i); + } + } + + /** + * @tests java.util.BitSet#BitSet() + */ + @Test + public void constructor() { + BitSet bs = new BitSet(); + assertEquals("Create BitSet of incorrect size", 64, bs.size()); + assertEquals("New BitSet had invalid string representation", "{}", + bs.toString()); + } + + /** + * @tests java.util.BitSet#BitSet(int) + */ + @Test + public void constructorI() { + BitSet bs = new BitSet(128); + assertEquals("Create BitSet of incorrect size", 128, bs.size()); + assertEquals("New BitSet had invalid string representation: " + + bs.toString(), "{}", bs.toString()); + // All BitSets are created with elements of multiples of 64 + bs = new BitSet(89); + assertEquals("Failed to round BitSet element size", 128, bs.size()); + + try { + bs = new BitSet(-9); + fail("Failed to throw exception when creating a new BitSet with negative element value"); + } catch (NegativeArraySizeException e) { + // Correct behaviour + } + } + + /** + * tests java.util.BitSet#clone() + */ + @Test + public void clonePerformed() { + BitSet bs; + bs = (BitSet) eightbs.clone(); + assertEquals("clone failed to return equal BitSet", bs, eightbs); + } + + /** + * @tests java.util.BitSet#equals(java.lang.Object) + */ + @Test + public void equalityComputed() { + BitSet bs; + bs = (BitSet) eightbs.clone(); + assertEquals("Same BitSet returned false", eightbs, eightbs); + assertEquals("Identical BitSet returned false", bs, eightbs); + bs.clear(6); + assertFalse("Different BitSets returned true", eightbs.equals(bs)); + + bs = (BitSet) eightbs.clone(); + bs.set(128); + assertFalse("Different sized BitSet with higher bit set returned true", + eightbs.equals(bs)); + bs.clear(128); + assertTrue( + "Different sized BitSet with higher bits not set returned false", + eightbs.equals(bs)); + } + + /** + * @tests java.util.BitSet#hashCode() + */ + @Test + public void hashCodeComputed() { + // Test for method int java.util.BitSet.hashCode() + BitSet bs = (BitSet) eightbs.clone(); + bs.clear(2); + bs.clear(6); + assertEquals("BitSet returns wrong hash value", 1129, bs.hashCode()); + bs.set(10); + bs.clear(3); + assertEquals("BitSet returns wrong hash value", 97, bs.hashCode()); + } + + /** + * @tests java.util.BitSet#clear() + */ + @Test + public void clear() { + eightbs.clear(); + for (int i = 0; i < 8; i++) { + assertFalse("Clear didn't clear bit " + i, eightbs.get(i)); + } + assertEquals("Test1: Wrong length", 0, eightbs.length()); + + BitSet bs = new BitSet(3400); + bs.set(0, bs.size() - 1); // ensure all bits are 1's + bs.set(bs.size() - 1); + bs.clear(); + assertEquals("Test2: Wrong length", 0, bs.length()); + assertTrue("Test2: isEmpty() returned incorrect value", bs.isEmpty()); + assertEquals("Test2: cardinality() returned incorrect value", 0, bs + .cardinality()); + } + + /** + * @tests java.util.BitSet#clear(int) + */ + @Test + public void clearI() { + // Test for method void java.util.BitSet.clear(int) + + eightbs.clear(7); + assertFalse("Failed to clear bit", eightbs.get(7)); + + // Check to see all other bits are still set + for (int i = 0; i < 7; i++) + assertTrue("Clear cleared incorrect bits", eightbs.get(i)); + + eightbs.clear(165); + assertFalse("Failed to clear bit", eightbs.get(165)); + // Try out of range + try { + eightbs.clear(-1); + fail("Failed to throw out of bounds exception"); + } catch (IndexOutOfBoundsException e) { + // Correct behaviour + } + + BitSet bs = new BitSet(0); + assertEquals("Test1: Wrong length,", 0, bs.length()); + assertEquals("Test1: Wrong size,", 0, bs.size()); + + bs.clear(0); + assertEquals("Test2: Wrong length,", 0, bs.length()); + assertEquals("Test2: Wrong size,", 0, bs.size()); + + bs.clear(60); + assertEquals("Test3: Wrong length,", 0, bs.length()); + assertEquals("Test3: Wrong size,", 0, bs.size()); + + bs.clear(120); + assertEquals("Test4: Wrong size,", 0, bs.size()); + assertEquals("Test4: Wrong length,", 0, bs.length()); + + bs.set(25); + assertEquals("Test5: Wrong size,", 64, bs.size()); + assertEquals("Test5: Wrong length,", 26, bs.length()); + + bs.clear(80); + assertEquals("Test6: Wrong size,", 64, bs.size()); + assertEquals("Test6: Wrong length,", 26, bs.length()); + + bs.clear(25); + assertEquals("Test7: Wrong size,", 64, bs.size()); + assertEquals("Test7: Wrong length,", 0, bs.length()); + } + + /** + * @tests java.util.BitSet#clear(int, int) + */ + @Test + public void clearII() throws IndexOutOfBoundsException { + // Regression for HARMONY-98 + BitSet bitset = new BitSet(); + for (int i = 0; i < 20; i++) { + bitset.set(i); + } + bitset.clear(10, 10); + + // Test for method void java.util.BitSet.clear(int, int) + // pos1 and pos2 are in the same bitset element + BitSet bs = new BitSet(16); + int initialSize = bs.size(); + bs.set(0, initialSize); + bs.clear(5); + bs.clear(15); + bs.clear(7, 11); + for (int i = 0; i < 7; i++) { + if (i == 5) + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertTrue("Shouldn't have cleared bit " + i, bs.get(i)); + } + for (int i = 7; i < 11; i++) + assertFalse("Failed to clear bit " + i, bs.get(i)); + + for (int i = 11; i < initialSize; i++) { + if (i == 15) + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertTrue("Shouldn't have cleared bit " + i, bs.get(i)); + } + + for (int i = initialSize; i < bs.size(); i++) { + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + } + + // pos1 and pos2 is in the same bitset element, boundry testing + bs = new BitSet(16); + initialSize = bs.size(); + bs.set(0, initialSize); + bs.clear(7, 64); + assertEquals("Failed to grow BitSet", 64, bs.size()); + for (int i = 0; i < 7; i++) + assertTrue("Shouldn't have cleared bit " + i, bs.get(i)); + for (int i = 7; i < 64; i++) + assertFalse("Failed to clear bit " + i, bs.get(i)); + for (int i = 64; i < bs.size(); i++) { + assertTrue("Shouldn't have flipped bit " + i, !bs.get(i)); + } + // more boundary testing + bs = new BitSet(32); + initialSize = bs.size(); + bs.set(0, initialSize); + bs.clear(0, 64); + for (int i = 0; i < 64; i++) + assertFalse("Failed to clear bit " + i, bs.get(i)); + for (int i = 64; i < bs.size(); i++) { + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + } + + bs = new BitSet(32); + initialSize = bs.size(); + bs.set(0, initialSize); + bs.clear(0, 65); + for (int i = 0; i < 65; i++) + assertFalse("Failed to clear bit " + i, bs.get(i)); + for (int i = 65; i < bs.size(); i++) { + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + } + + // pos1 and pos2 are in two sequential bitset elements + bs = new BitSet(128); + initialSize = bs.size(); + bs.set(0, initialSize); + bs.clear(7); + bs.clear(110); + bs.clear(9, 74); + for (int i = 0; i < 9; i++) { + if (i == 7) + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertTrue("Shouldn't have cleared bit " + i, bs.get(i)); + } + for (int i = 9; i < 74; i++) + assertFalse("Failed to clear bit " + i, bs.get(i)); + for (int i = 74; i < initialSize; i++) { + if (i == 110) + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertTrue("Shouldn't have cleared bit " + i, bs.get(i)); + } + for (int i = initialSize; i < bs.size(); i++) { + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + } + + // pos1 and pos2 are in two non-sequential bitset elements + bs = new BitSet(256); + bs.set(0, 256); + bs.clear(7); + bs.clear(255); + bs.clear(9, 219); + for (int i = 0; i < 9; i++) { + if (i == 7) + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertTrue("Shouldn't have cleared bit " + i, bs.get(i)); + } + + for (int i = 9; i < 219; i++) + assertFalse("failed to clear bit " + i, bs.get(i)); + + for (int i = 219; i < 255; i++) + assertTrue("Shouldn't have cleared bit " + i, bs.get(i)); + + for (int i = 255; i < bs.size(); i++) + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + + // test illegal args + bs = new BitSet(10); + try { + bs.clear(-1, 3); + fail("Test1: Attempt to flip with negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // excepted + } + + try { + bs.clear(2, -1); + fail("Test2: Attempt to flip with negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // excepted + } + + bs.set(2, 4); + bs.clear(2, 2); + assertTrue("Bit got cleared incorrectly ", bs.get(2)); + + try { + bs.clear(4, 2); + fail("Test4: Attempt to flip with illegal args failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // excepted + } + + bs = new BitSet(0); + assertEquals("Test1: Wrong length,", 0, bs.length()); + assertEquals("Test1: Wrong size,", 0, bs.size()); + + bs.clear(0, 2); + assertEquals("Test2: Wrong length,", 0, bs.length()); + assertEquals("Test2: Wrong size,", 0, bs.size()); + + bs.clear(60, 64); + assertEquals("Test3: Wrong length,", 0, bs.length()); + assertEquals("Test3: Wrong size,", 0, bs.size()); + + bs.clear(64, 120); + assertEquals("Test4: Wrong length,", 0, bs.length()); + assertEquals("Test4: Wrong size,", 0, bs.size()); + + bs.set(25); + assertEquals("Test5: Wrong length,", 26, bs.length()); + assertEquals("Test5: Wrong size,", 64, bs.size()); + + bs.clear(60, 64); + assertEquals("Test6: Wrong length,", 26, bs.length()); + assertEquals("Test6: Wrong size,", 64, bs.size()); + + bs.clear(64, 120); + assertEquals("Test7: Wrong size,", 64, bs.size()); + assertEquals("Test7: Wrong length,", 26, bs.length()); + + bs.clear(80); + assertEquals("Test8: Wrong size,", 64, bs.size()); + assertEquals("Test8: Wrong length,", 26, bs.length()); + + bs.clear(25); + assertEquals("Test9: Wrong size,", 64, bs.size()); + assertEquals("Test9: Wrong length,", 0, bs.length()); + } + + /** + * @tests java.util.BitSet#get(int) + */ + @Test + public void getI() { + // Test for method boolean java.util.BitSet.get(int) + + BitSet bs = new BitSet(); + bs.set(8); + assertFalse("Get returned true for index out of range", eightbs.get(99)); + assertTrue("Get returned false for set value", eightbs.get(3)); + assertFalse("Get returned true for a non set value", bs.get(0)); + + try { + bs.get(-1); + fail("Attempt to get at negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // Correct behaviour + } + + bs = new BitSet(1); + assertFalse("Access greater than size", bs.get(64)); + + bs = new BitSet(); + bs.set(63); + assertTrue("Test highest bit", bs.get(63)); + + bs = new BitSet(0); + assertEquals("Test1: Wrong length,", 0, bs.length()); + assertEquals("Test1: Wrong size,", 0, bs.size()); + + bs.get(2); + assertEquals("Test2: Wrong length,", 0, bs.length()); + assertEquals("Test2: Wrong size,", 0, bs.size()); + + bs.get(70); + assertEquals("Test3: Wrong length,", 0, bs.length()); + assertEquals("Test3: Wrong size,", 0, bs.size()); + + } + + /** + * @tests java.util.BitSet#get(int, int) + */ + @Test + public void getII() { + BitSet bitset = new BitSet(30); + bitset.get(3, 3); + + // Test for method boolean java.util.BitSet.get(int, int) + BitSet bs, resultbs, correctbs; + bs = new BitSet(512); + bs.set(3, 9); + bs.set(10, 20); + bs.set(60, 75); + bs.set(121); + bs.set(130, 140); + + // pos1 and pos2 are in the same bitset element, at index0 + resultbs = bs.get(3, 6); + correctbs = new BitSet(3); + correctbs.set(0, 3); + assertEquals("Test1: Returned incorrect BitSet", correctbs, resultbs); + + // pos1 and pos2 are in the same bitset element, at index 1 + resultbs = bs.get(100, 125); + correctbs = new BitSet(25); + correctbs.set(21); + assertEquals("Test2: Returned incorrect BitSet", correctbs, resultbs); + + // pos1 in bitset element at index 0, and pos2 in bitset element at + // index 1 + resultbs = bs.get(15, 125); + correctbs = new BitSet(25); + correctbs.set(0, 5); + correctbs.set(45, 60); + correctbs.set(121 - 15); + assertEquals("Test3: Returned incorrect BitSet", correctbs, resultbs); + + // pos1 in bitset element at index 1, and pos2 in bitset element at + // index 2 + resultbs = bs.get(70, 145); + correctbs = new BitSet(75); + correctbs.set(0, 5); + correctbs.set(51); + correctbs.set(60, 70); + assertEquals("Test4: Returned incorrect BitSet", correctbs, resultbs); + + // pos1 in bitset element at index 0, and pos2 in bitset element at + // index 2 + resultbs = bs.get(5, 145); + correctbs = new BitSet(140); + correctbs.set(0, 4); + correctbs.set(5, 15); + correctbs.set(55, 70); + correctbs.set(116); + correctbs.set(125, 135); + assertEquals("Test5: Returned incorrect BitSet", correctbs, resultbs); + + // pos1 in bitset element at index 0, and pos2 in bitset element at + // index 3 + resultbs = bs.get(5, 250); + correctbs = new BitSet(200); + correctbs.set(0, 4); + correctbs.set(5, 15); + correctbs.set(55, 70); + correctbs.set(116); + correctbs.set(125, 135); + assertEquals("Test6: Returned incorrect BitSet", correctbs, resultbs); + + assertEquals("equality principle 1 ", bs.get(0, bs.size()), bs); + + // more tests + BitSet bs2 = new BitSet(129); + bs2.set(0, 20); + bs2.set(62, 65); + bs2.set(121, 123); + resultbs = bs2.get(1, 124); + correctbs = new BitSet(129); + correctbs.set(0, 19); + correctbs.set(61, 64); + correctbs.set(120, 122); + assertEquals("Test7: Returned incorrect BitSet", correctbs, resultbs); + + // equality principle with some boundary conditions + bs2 = new BitSet(128); + bs2.set(2, 20); + bs2.set(62); + bs2.set(121, 123); + bs2.set(127); + resultbs = bs2.get(0, bs2.size()); + assertEquals("equality principle 2 ", resultbs, bs2); + + bs2 = new BitSet(128); + bs2.set(2, 20); + bs2.set(62); + bs2.set(121, 123); + bs2.set(127); + bs2.flip(0, 128); + resultbs = bs2.get(0, bs.size()); + assertEquals("equality principle 3 ", resultbs, bs2); + + bs = new BitSet(0); + assertEquals("Test1: Wrong length,", 0, bs.length()); + assertEquals("Test1: Wrong size,", 0, bs.size()); + + bs.get(0, 2); + assertEquals("Test2: Wrong length,", 0, bs.length()); + assertEquals("Test2: Wrong size,", 0, bs.size()); + + bs.get(60, 64); + assertEquals("Test3: Wrong length,", 0, bs.length()); + assertEquals("Test3: Wrong size,", 0, bs.size()); + + bs.get(64, 120); + assertEquals("Test4: Wrong length,", 0, bs.length()); + assertEquals("Test4: Wrong size,", 0, bs.size()); + + bs.set(25); + assertEquals("Test5: Wrong length,", 26, bs.length()); + assertEquals("Test5: Wrong size,", 64, bs.size()); + + bs.get(60, 64); + assertEquals("Test6: Wrong length,", 26, bs.length()); + assertEquals("Test6: Wrong size,", 64, bs.size()); + + bs.get(64, 120); + assertEquals("Test7: Wrong size,", 64, bs.size()); + assertEquals("Test7: Wrong length,", 26, bs.length()); + + bs.get(80); + assertEquals("Test8: Wrong size,", 64, bs.size()); + assertEquals("Test8: Wrong length,", 26, bs.length()); + + bs.get(25); + assertEquals("Test9: Wrong size,", 64, bs.size()); + assertEquals("Test9: Wrong length,", 26, bs.length()); + + } + + /** + * @tests java.util.BitSet#flip(int) + */ + @Test + public void flipI() { + // Test for method void java.util.BitSet.flip(int) + BitSet bs = new BitSet(); + bs.clear(8); + bs.clear(9); + bs.set(10); + bs.flip(9); + assertFalse("Failed to flip bit", bs.get(8)); + assertTrue("Failed to flip bit", bs.get(9)); + assertTrue("Failed to flip bit", bs.get(10)); + + bs.set(8); + bs.set(9); + bs.clear(10); + bs.flip(9); + assertTrue("Failed to flip bit", bs.get(8)); + assertFalse("Failed to flip bit", bs.get(9)); + assertFalse("Failed to flip bit", bs.get(10)); + + try { + bs.flip(-1); + fail("Attempt to flip at negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // Correct behaviour + } + + // Try setting a bit on a 64 boundary + bs.flip(128); + assertEquals("Failed to grow BitSet", 192, bs.size()); + assertTrue("Failed to flip bit", bs.get(128)); + + bs = new BitSet(64); + for (int i = bs.size(); --i >= 0;) { + bs.flip(i); + assertTrue("Test1: Incorrectly flipped bit" + i, bs.get(i)); + assertEquals("Incorrect length", i+1, bs.length()); + for (int j = bs.size(); --j > i;) { + assertTrue("Test2: Incorrectly flipped bit" + j, !bs.get(j)); + } + for (int j = i; --j >= 0;) { + assertTrue("Test3: Incorrectly flipped bit" + j, !bs.get(j)); + } + bs.flip(i); + } + + BitSet bs0 = new BitSet(0); + assertEquals("Test1: Wrong size", 0, bs0.size()); + assertEquals("Test1: Wrong length", 0, bs0.length()); + + bs0.flip(0); + assertEquals("Test2: Wrong size", 64, bs0.size()); + assertEquals("Test2: Wrong length", 1, bs0.length()); + + bs0.flip(63); + assertEquals("Test3: Wrong size", 64, bs0.size()); + assertEquals("Test3: Wrong length", 64, bs0.length()); + + eightbs.flip(7); + assertTrue("Failed to flip bit 7", !eightbs.get(7)); + + // Check to see all other bits are still set + for (int i = 0; i < 7; i++) + assertTrue("Flip flipped incorrect bits", eightbs.get(i)); + + eightbs.flip(127); + assertTrue("Failed to flip bit 127", eightbs.get(127)); + + eightbs.flip(127); + assertTrue("Failed to flip bit 127", !eightbs.get(127)); + } + + /** + * @tests java.util.BitSet#clear(int, int) + */ + @Test + public void flipII() { + BitSet bitset = new BitSet(); + for (int i = 0; i < 20; i++) { + bitset.set(i); + } + bitset.flip(10, 10); + + // Test for method void java.util.BitSet.flip(int, int) + // pos1 and pos2 are in the same bitset element + BitSet bs = new BitSet(16); + bs.set(7); + bs.set(10); + bs.flip(7, 11); + for (int i = 0; i < 7; i++) { + assertTrue("Shouldn't have flipped bit " + i, !bs.get(i)); + } + assertFalse("Failed to flip bit 7", bs.get(7)); + assertTrue("Failed to flip bit 8", bs.get(8)); + assertTrue("Failed to flip bit 9", bs.get(9)); + assertFalse("Failed to flip bit 10", bs.get(10)); + for (int i = 11; i < bs.size(); i++) { + assertTrue("Shouldn't have flipped bit " + i, !bs.get(i)); + } + + // pos1 and pos2 is in the same bitset element, boundry testing + bs = new BitSet(16); + bs.set(7); + bs.set(10); + bs.flip(7, 64); + assertEquals("Failed to grow BitSet", 64, bs.size()); + for (int i = 0; i < 7; i++) { + assertTrue("Shouldn't have flipped bit " + i, !bs.get(i)); + } + assertFalse("Failed to flip bit 7", bs.get(7)); + assertTrue("Failed to flip bit 8", bs.get(8)); + assertTrue("Failed to flip bit 9", bs.get(9)); + assertFalse("Failed to flip bit 10", bs.get(10)); + for (int i = 11; i < 64; i++) { + assertTrue("failed to flip bit " + i, bs.get(i)); + } + assertFalse("Shouldn't have flipped bit 64", bs.get(64)); + + // more boundary testing + bs = new BitSet(32); + bs.flip(0, 64); + for (int i = 0; i < 64; i++) { + assertTrue("Failed to flip bit " + i, bs.get(i)); + } + assertFalse("Shouldn't have flipped bit 64", bs.get(64)); + + bs = new BitSet(32); + bs.flip(0, 65); + for (int i = 0; i < 65; i++) { + assertTrue("Failed to flip bit " + i, bs.get(i)); + } + assertFalse("Shouldn't have flipped bit 65", bs.get(65)); + + // pos1 and pos2 are in two sequential bitset elements + bs = new BitSet(128); + bs.set(7); + bs.set(10); + bs.set(72); + bs.set(110); + bs.flip(9, 74); + for (int i = 0; i < 7; i++) { + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + } + assertTrue("Shouldn't have flipped bit 7", bs.get(7)); + assertFalse("Shouldn't have flipped bit 8", bs.get(8)); + assertTrue("Failed to flip bit 9", bs.get(9)); + assertFalse("Failed to flip bit 10", bs.get(10)); + for (int i = 11; i < 72; i++) { + assertTrue("failed to flip bit " + i, bs.get(i)); + } + assertFalse("Failed to flip bit 72", bs.get(72)); + assertTrue("Failed to flip bit 73", bs.get(73)); + for (int i = 74; i < 110; i++) { + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + } + assertTrue("Shouldn't have flipped bit 110", bs.get(110)); + for (int i = 111; i < bs.size(); i++) { + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + } + + // pos1 and pos2 are in two non-sequential bitset elements + bs = new BitSet(256); + bs.set(7); + bs.set(10); + bs.set(72); + bs.set(110); + bs.set(181); + bs.set(220); + bs.flip(9, 219); + for (int i = 0; i < 7; i++) { + assertFalse("Shouldn't have flipped bit " + i, bs.get(i)); + } + assertTrue("Shouldn't have flipped bit 7", bs.get(7)); + assertFalse("Shouldn't have flipped bit 8", bs.get(8)); + assertTrue("Failed to flip bit 9", bs.get(9)); + assertFalse("Failed to flip bit 10", bs.get(10)); + for (int i = 11; i < 72; i++) { + assertTrue("failed to flip bit " + i, bs.get(i)); + } + assertFalse("Failed to flip bit 72", bs.get(72)); + for (int i = 73; i < 110; i++) { + assertTrue("failed to flip bit " + i, bs.get(i)); + } + assertFalse("Failed to flip bit 110", bs.get(110)); + for (int i = 111; i < 181; i++) { + assertTrue("failed to flip bit " + i, bs.get(i)); + } + assertFalse("Failed to flip bit 181", bs.get(181)); + for (int i = 182; i < 219; i++) { + assertTrue("failed to flip bit " + i, bs.get(i)); + } + assertFalse("Shouldn't have flipped bit 219", bs.get(219)); + assertTrue("Shouldn't have flipped bit 220", bs.get(220)); + for (int i = 221; i < bs.size(); i++) { + assertTrue("Shouldn't have flipped bit " + i, !bs.get(i)); + } + + // test illegal args + bs = new BitSet(10); + try { + bs.flip(-1, 3); + fail("Test1: Attempt to flip with negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // correct behavior + } + + try { + bs.flip(2, -1); + fail("Test2: Attempt to flip with negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // correct behavior + } + + try { + bs.flip(4, 2); + fail("Test4: Attempt to flip with illegal args failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // correct behavior + } + } + + /** + * @tests java.util.BitSet#set(int) + */ + @Test + public void setI() { + // Test for method void java.util.BitSet.set(int) + + BitSet bs = new BitSet(); + bs.set(8); + assertTrue("Failed to set bit", bs.get(8)); + + try { + bs.set(-1); + fail("Attempt to set at negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // Correct behaviour + } + + // Try setting a bit on a 64 boundary + bs.set(128); + assertEquals("Failed to grow BitSet", 192, bs.size()); + assertTrue("Failed to set bit", bs.get(128)); + + bs = new BitSet(64); + for (int i = bs.size(); --i >= 0;) { + bs.set(i); + assertTrue("Incorrectly set", bs.get(i)); + assertEquals("Incorrect length", i+1, bs.length()); + for (int j = bs.size(); --j > i;) + assertFalse("Incorrectly set bit " + j, bs.get(j)); + for (int j = i; --j >= 0;) + assertFalse("Incorrectly set bit " + j, bs.get(j)); + bs.clear(i); + } + + bs = new BitSet(0); + assertEquals("Test1: Wrong length", 0, bs.length()); + bs.set(0); + assertEquals("Test2: Wrong length", 1, bs.length()); + } + + /** + * @tests java.util.BitSet#set(int, boolean) + */ + @Test + public void setIZ() { + // Test for method void java.util.BitSet.set(int, boolean) + eightbs.set(5, false); + assertFalse("Should have set bit 5 to true", eightbs.get(5)); + + eightbs.set(5, true); + assertTrue("Should have set bit 5 to false", eightbs.get(5)); + } + + /** + * @tests java.util.BitSet#set(int, int) + */ + @Test + public void setII() throws IndexOutOfBoundsException { + BitSet bitset = new BitSet(30); + bitset.set(29, 29); + + // Test for method void java.util.BitSet.set(int, int) + // pos1 and pos2 are in the same bitset element + BitSet bs = new BitSet(16); + bs.set(5); + bs.set(15); + bs.set(7, 11); + for (int i = 0; i < 7; i++) { + if (i == 5) + assertTrue("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertFalse("Shouldn't have set bit " + i, bs.get(i)); + } + for (int i = 7; i < 11; i++) + assertTrue("Failed to set bit " + i, bs.get(i)); + for (int i = 11; i < bs.size(); i++) { + if (i == 15) + assertTrue("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertFalse("Shouldn't have set bit " + i, bs.get(i)); + } + + // pos1 and pos2 is in the same bitset element, boundry testing + bs = new BitSet(16); + bs.set(7, 64); + assertEquals("Failed to grow BitSet", 64, bs.size()); + for (int i = 0; i < 7; i++) { + assertFalse("Shouldn't have set bit " + i, bs.get(i)); + } + for (int i = 7; i < 64; i++) { + assertTrue("Failed to set bit " + i, bs.get(i)); + } + assertFalse("Shouldn't have set bit 64", bs.get(64)); + + // more boundary testing + bs = new BitSet(32); + bs.set(0, 64); + for (int i = 0; i < 64; i++) { + assertTrue("Failed to set bit " + i, bs.get(i)); + } + assertFalse("Shouldn't have set bit 64", bs.get(64)); + + bs = new BitSet(32); + bs.set(0, 65); + for (int i = 0; i < 65; i++) { + assertTrue("Failed to set bit " + i, bs.get(i)); + } + assertFalse("Shouldn't have set bit 65", bs.get(65)); + + // pos1 and pos2 are in two sequential bitset elements + bs = new BitSet(128); + bs.set(7); + bs.set(110); + bs.set(9, 74); + for (int i = 0; i < 9; i++) { + if (i == 7) + assertTrue("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertFalse("Shouldn't have set bit " + i, bs.get(i)); + } + for (int i = 9; i < 74; i++) { + assertTrue("Failed to set bit " + i, bs.get(i)); + } + for (int i = 74; i < bs.size(); i++) { + if (i == 110) + assertTrue("Shouldn't have flipped bit " + i, bs.get(i)); + else + assertFalse("Shouldn't have set bit " + i, bs.get(i)); + } + + // pos1 and pos2 are in two non-sequential bitset elements + bs = new BitSet(256); + bs.set(7); + bs.set(255); + bs.set(9, 219); + for (int i = 0; i < 9; i++) { + if (i == 7) + assertTrue("Shouldn't have set flipped " + i, bs.get(i)); + else + assertFalse("Shouldn't have set bit " + i, bs.get(i)); + } + + for (int i = 9; i < 219; i++) { + assertTrue("failed to set bit " + i, bs.get(i)); + } + + for (int i = 219; i < 255; i++) { + assertFalse("Shouldn't have set bit " + i, bs.get(i)); + } + + assertTrue("Shouldn't have flipped bit 255", bs.get(255)); + + // test illegal args + bs = new BitSet(10); + try { + bs.set(-1, 3); + fail("Test1: Attempt to flip with negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // Correct behavior + } + + try { + bs.set(2, -1); + fail("Test2: Attempt to flip with negative index failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // Correct behavior + } + + bs.set(2, 2); + assertFalse("Bit got set incorrectly ", bs.get(2)); + + try { + bs.set(4, 2); + fail("Test4: Attempt to flip with illegal args failed to generate exception"); + } catch (IndexOutOfBoundsException e) { + // Correct behavior + } + } + + /** + * @tests java.util.BitSet#set(int, int, boolean) + */ + @Test + public void setIIZ() { + // Test for method void java.util.BitSet.set(int, int, boolean) + eightbs.set(3, 6, false); + assertTrue("Should have set bits 3, 4, and 5 to false", !eightbs.get(3) + && !eightbs.get(4) && !eightbs.get(5)); + + eightbs.set(3, 6, true); + assertTrue("Should have set bits 3, 4, and 5 to true", eightbs.get(3) + && eightbs.get(4) && eightbs.get(5)); + + } + + /** + * @tests java.util.BitSet#intersects(java.util.BitSet) + */ + @Test + public void intersects() { + // Test for method boolean java.util.BitSet.intersects(java.util.BitSet) + BitSet bs = new BitSet(500); + bs.set(5); + bs.set(63); + bs.set(64); + bs.set(71, 110); + bs.set(127, 130); + bs.set(192); + bs.set(450); + + BitSet bs2 = new BitSet(8); + assertFalse("Test1: intersects() returned incorrect value", bs + .intersects(bs2)); + assertFalse("Test1: intersects() returned incorrect value", bs2 + .intersects(bs)); + + bs2.set(4); + assertFalse("Test2: intersects() returned incorrect value", bs + .intersects(bs2)); + assertFalse("Test2: intersects() returned incorrect value", bs2 + .intersects(bs)); + + bs2.clear(); + bs2.set(5); + assertTrue("Test3: intersects() returned incorrect value", bs + .intersects(bs2)); + assertTrue("Test3: intersects() returned incorrect value", bs2 + .intersects(bs)); + + bs2.clear(); + bs2.set(63); + assertTrue("Test4: intersects() returned incorrect value", bs + .intersects(bs2)); + assertTrue("Test4: intersects() returned incorrect value", bs2 + .intersects(bs)); + + bs2.clear(); + bs2.set(80); + assertTrue("Test5: intersects() returned incorrect value", bs + .intersects(bs2)); + assertTrue("Test5: intersects() returned incorrect value", bs2 + .intersects(bs)); + + bs2.clear(); + bs2.set(127); + assertTrue("Test6: intersects() returned incorrect value", bs + .intersects(bs2)); + assertTrue("Test6: intersects() returned incorrect value", bs2 + .intersects(bs)); + + bs2.clear(); + bs2.set(192); + assertTrue("Test7: intersects() returned incorrect value", bs + .intersects(bs2)); + assertTrue("Test7: intersects() returned incorrect value", bs2 + .intersects(bs)); + + bs2.clear(); + bs2.set(450); + assertTrue("Test8: intersects() returned incorrect value", bs + .intersects(bs2)); + assertTrue("Test8: intersects() returned incorrect value", bs2 + .intersects(bs)); + + bs2.clear(); + bs2.set(500); + assertFalse("Test9: intersects() returned incorrect value", bs + .intersects(bs2)); + assertFalse("Test9: intersects() returned incorrect value", bs2 + .intersects(bs)); + } + + /** + * @tests java.util.BitSet#and(java.util.BitSet) + */ + @Test + public void and() { + // Test for method void java.util.BitSet.and(java.util.BitSet) + BitSet bs = new BitSet(128); + // Initialize the bottom half of the BitSet + + for (int i = 64; i < 128; i++) + bs.set(i); + eightbs.and(bs); + assertFalse("AND failed to clear bits", eightbs.equals(bs)); + eightbs.set(3); + bs.set(3); + eightbs.and(bs); + assertTrue("AND failed to maintain set bits", bs.get(3)); + bs.and(eightbs); + for (int i = 64; i < 128; i++) { + assertFalse("Failed to clear extra bits in the receiver BitSet", bs + .get(i)); + } + } + + /** + * @tests java.util.BitSet#andNot(java.util.BitSet) + */ + @Test + public void test() { + BitSet bs = (BitSet) eightbs.clone(); + bs.clear(5); + BitSet bs2 = new BitSet(); + bs2.set(2); + bs2.set(3); + bs.andNot(bs2); + assertEquals("Incorrect bitset after andNot", + "{0, 1, 4, 6, 7}", bs.toString()); + + bs = new BitSet(0); + bs.andNot(bs2); + assertEquals("Incorrect size", 0, bs.size()); + } + + /** + * @tests java.util.BitSet#or(java.util.BitSet) + */ + public void test_orLjava_util_BitSet() { + // Test for method void java.util.BitSet.or(java.util.BitSet) + BitSet bs = new BitSet(128); + bs.or(eightbs); + for (int i = 0; i < 8; i++) { + assertTrue("OR failed to set bits", bs.get(i)); + } + + bs = new BitSet(0); + bs.or(eightbs); + for (int i = 0; i < 8; i++) { + assertTrue("OR(0) failed to set bits", bs.get(i)); + } + + eightbs.clear(5); + bs = new BitSet(128); + bs.or(eightbs); + assertFalse("OR set a bit which should be off", bs.get(5)); + } + + /** + * @tests java.util.BitSet#xor(java.util.BitSet) + */ + public void test_xorLjava_util_BitSet() { + // Test for method void java.util.BitSet.xor(java.util.BitSet) + + BitSet bs = (BitSet) eightbs.clone(); + bs.xor(eightbs); + for (int i = 0; i < 8; i++) { + assertFalse("XOR failed to clear bits", bs.get(i)); + } + + bs.xor(eightbs); + for (int i = 0; i < 8; i++) { + assertTrue("XOR failed to set bits", bs.get(i)); + } + + bs = new BitSet(0); + bs.xor(eightbs); + for (int i = 0; i < 8; i++) { + assertTrue("XOR(0) failed to set bits", bs.get(i)); + } + + bs = new BitSet(); + bs.set(63); + assertEquals("Test highest bit", "{63}", bs.toString()); + } + + /** + * @tests java.util.BitSet#toString() + */ + public void test_toString() { + // Test for method java.lang.String java.util.BitSet.toString() + assertEquals("Returned incorrect string representation", + "{0, 1, 2, 3, 4, 5, 6, 7}", eightbs.toString()); + eightbs.clear(2); + assertEquals("Returned incorrect string representation", + "{0, 1, 3, 4, 5, 6, 7}", eightbs.toString()); + } + + /** + * @tests java.util.BitSet#length() + */ + @Test + public void length() { + BitSet bs = new BitSet(); + assertEquals("BitSet returned wrong length", 0, bs.length()); + bs.set(5); + assertEquals("BitSet returned wrong length", 6, bs.length()); + bs.set(10); + assertEquals("BitSet returned wrong length", 11, bs.length()); + bs.set(432); + assertEquals("BitSet returned wrong length", 433, bs.length()); + bs.set(300); + assertEquals("BitSet returned wrong length", 433, bs.length()); + } + + /** + * @tests java.util.BitSet#nextSetBit(int) + */ + @Test + public void nextSetBitI() { + // Test for method int java.util.BitSet.nextSetBit() + BitSet bs = new BitSet(500); + bs.set(5); + bs.set(32); + bs.set(63); + bs.set(64); + bs.set(71, 110); + bs.set(127, 130); + bs.set(193); + bs.set(450); + try { + bs.nextSetBit(-1); + fail("Expected IndexOutOfBoundsException for negative index"); + } catch (IndexOutOfBoundsException e) { + // correct behavior + } + assertEquals("nextSetBit() returned the wrong value", 5, bs + .nextSetBit(0)); + assertEquals("nextSetBit() returned the wrong value", 5, bs + .nextSetBit(5)); + assertEquals("nextSetBit() returned the wrong value", 32, bs + .nextSetBit(6)); + assertEquals("nextSetBit() returned the wrong value", 32, bs + .nextSetBit(32)); + assertEquals("nextSetBit() returned the wrong value", 63, bs + .nextSetBit(33)); + + // boundary tests + assertEquals("nextSetBit() returned the wrong value", 63, bs + .nextSetBit(63)); + assertEquals("nextSetBit() returned the wrong value", 64, bs + .nextSetBit(64)); + + // at bitset element 1 + assertEquals("nextSetBit() returned the wrong value", 71, bs + .nextSetBit(65)); + assertEquals("nextSetBit() returned the wrong value", 71, bs + .nextSetBit(71)); + assertEquals("nextSetBit() returned the wrong value", 72, bs + .nextSetBit(72)); + assertEquals("nextSetBit() returned the wrong value", 127, bs + .nextSetBit(110)); + + // boundary tests + assertEquals("nextSetBit() returned the wrong value", 127, bs + .nextSetBit(127)); + assertEquals("nextSetBit() returned the wrong value", 128, bs + .nextSetBit(128)); + + // at bitset element 2 + assertEquals("nextSetBit() returned the wrong value", 193, bs + .nextSetBit(130)); + + assertEquals("nextSetBit() returned the wrong value", 193, bs + .nextSetBit(191)); + assertEquals("nextSetBit() returned the wrong value", 193, bs + .nextSetBit(192)); + assertEquals("nextSetBit() returned the wrong value", 193, bs + .nextSetBit(193)); + assertEquals("nextSetBit() returned the wrong value", 450, bs + .nextSetBit(194)); + assertEquals("nextSetBit() returned the wrong value", 450, bs + .nextSetBit(255)); + assertEquals("nextSetBit() returned the wrong value", 450, bs + .nextSetBit(256)); + assertEquals("nextSetBit() returned the wrong value", 450, bs + .nextSetBit(450)); + + assertEquals("nextSetBit() returned the wrong value", -1, bs + .nextSetBit(451)); + assertEquals("nextSetBit() returned the wrong value", -1, bs + .nextSetBit(511)); + assertEquals("nextSetBit() returned the wrong value", -1, bs + .nextSetBit(512)); + assertEquals("nextSetBit() returned the wrong value", -1, bs + .nextSetBit(800)); + } + + /** + * @tests java.util.BitSet#nextClearBit(int) + */ + public void test_nextClearBitI() { + // Test for method int java.util.BitSet.nextSetBit() + BitSet bs = new BitSet(500); + bs.set(0, bs.size() - 1); // ensure all the bits from 0 to bs.size() + // -1 + bs.set(bs.size() - 1); // are set to true + bs.clear(5); + bs.clear(32); + bs.clear(63); + bs.clear(64); + bs.clear(71, 110); + bs.clear(127, 130); + bs.clear(193); + bs.clear(450); + try { + bs.nextClearBit(-1); + fail("Expected IndexOutOfBoundsException for negative index"); + } catch (IndexOutOfBoundsException e) { + // correct behavior + } + assertEquals("nextClearBit() returned the wrong value", 5, bs + .nextClearBit(0)); + assertEquals("nextClearBit() returned the wrong value", 5, bs + .nextClearBit(5)); + assertEquals("nextClearBit() returned the wrong value", 32, bs + .nextClearBit(6)); + assertEquals("nextClearBit() returned the wrong value", 32, bs + .nextClearBit(32)); + assertEquals("nextClearBit() returned the wrong value", 63, bs + .nextClearBit(33)); + + // boundary tests + assertEquals("nextClearBit() returned the wrong value", 63, bs + .nextClearBit(63)); + assertEquals("nextClearBit() returned the wrong value", 64, bs + .nextClearBit(64)); + + // at bitset element 1 + assertEquals("nextClearBit() returned the wrong value", 71, bs + .nextClearBit(65)); + assertEquals("nextClearBit() returned the wrong value", 71, bs + .nextClearBit(71)); + assertEquals("nextClearBit() returned the wrong value", 72, bs + .nextClearBit(72)); + assertEquals("nextClearBit() returned the wrong value", 127, bs + .nextClearBit(110)); + + // boundary tests + assertEquals("nextClearBit() returned the wrong value", 127, bs + .nextClearBit(127)); + assertEquals("nextClearBit() returned the wrong value", 128, bs + .nextClearBit(128)); + + // at bitset element 2 + assertEquals("nextClearBit() returned the wrong value", 193, bs + .nextClearBit(130)); + assertEquals("nextClearBit() returned the wrong value", 193, bs + .nextClearBit(191)); + + assertEquals("nextClearBit() returned the wrong value", 193, bs + .nextClearBit(192)); + assertEquals("nextClearBit() returned the wrong value", 193, bs + .nextClearBit(193)); + assertEquals("nextClearBit() returned the wrong value", 450, bs + .nextClearBit(194)); + assertEquals("nextClearBit() returned the wrong value", 450, bs + .nextClearBit(255)); + assertEquals("nextClearBit() returned the wrong value", 450, bs + .nextClearBit(256)); + assertEquals("nextClearBit() returned the wrong value", 450, bs + .nextClearBit(450)); + + // bitset has 1 still the end of bs.size() -1, but calling nextClearBit + // with any index value + // after the last true bit should return bs.size(), + assertEquals("nextClearBit() returned the wrong value", 512, bs + .nextClearBit(451)); + assertEquals("nextClearBit() returned the wrong value", 512, bs + .nextClearBit(511)); + assertEquals("nextClearBit() returned the wrong value", 512, bs + .nextClearBit(512)); + + // if the index is larger than bs.size(), nextClearBit should return + // index; + assertEquals("nextClearBit() returned the wrong value", 513, bs + .nextClearBit(513)); + assertEquals("nextClearBit() returned the wrong value", 800, bs + .nextClearBit(800)); + } + + /** + * @tests java.util.BitSet#isEmpty() + */ + public void test_isEmpty() { + BitSet bs = new BitSet(500); + assertTrue("Test: isEmpty() returned wrong value", bs.isEmpty()); + + // at bitset element 0 + bs.set(3); + assertFalse("Test0: isEmpty() returned wrong value", bs.isEmpty()); + + // at bitset element 1 + bs.clear(); + bs.set(12); + assertFalse("Test1: isEmpty() returned wrong value", bs.isEmpty()); + + // at bitset element 2 + bs.clear(); + bs.set(128); + assertFalse("Test2: isEmpty() returned wrong value", bs.isEmpty()); + + // boundary testing + bs.clear(); + bs.set(459); + assertFalse("Test3: isEmpty() returned wrong value", bs.isEmpty()); + + bs.clear(); + bs.set(511); + assertFalse("Test4: isEmpty() returned wrong value", bs.isEmpty()); + } + + /** + * @tests java.util.BitSet#cardinality() + */ + public void test_cardinality() { + // test for method int java.util.BitSet.cardinality() + BitSet bs = new BitSet(500); + bs.set(5); + bs.set(32); + bs.set(63); + bs.set(64); + bs.set(71, 110); + bs.set(127, 130); + bs.set(193); + bs.set(450); + assertEquals("cardinality() returned wrong value", 48, bs.cardinality()); + + bs.flip(0, 500); + assertEquals("cardinality() returned wrong value", 452, bs + .cardinality()); + + bs.clear(); + assertEquals("cardinality() returned wrong value", 0, bs.cardinality()); + + bs.set(0, 500); + assertEquals("cardinality() returned wrong value", 500, bs + .cardinality()); + } +}