/*
* 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 tests.api.java.util;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import java.util.BitSet;
@TestTargetClass(BitSet.class)
public class BitSetTest extends junit.framework.TestCase {
BitSet eightbs;
/**
* @tests java.util.BitSet#BitSet()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "BitSet",
args = {}
)
public void test_Constructor() {
// Test for method java.util.BitSet()
BitSet bs = new BitSet();
// Default size for a BitSet should be 64 elements;
assertEquals("Created BitSet of incorrect size", 64, bs.size());
assertEquals("New BitSet had invalid string representation", "{}", bs
.toString());
}
/**
* @tests java.util.BitSet#BitSet(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "BitSet",
args = {int.class}
)
public void test_ConstructorI() {
// Test for method java.util.BitSet(int)
BitSet bs = new BitSet(128);
// Default size for a BitSet should be 64 elements;
assertEquals("Created BitSet of incorrect size", 128, bs.size());
assertTrue("New BitSet had invalid string representation: "
+ bs.toString(), bs.toString().equals("{}"));
// 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 elements value");
} catch (NegativeArraySizeException e) {
// Correct behaviour
}
}
/**
* @tests java.util.BitSet#clone()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "clone",
args = {}
)
public void test_clone() {
// Test for method java.lang.Object java.util.BitSet.clone()
BitSet bs;
bs = (BitSet) eightbs.clone();
assertTrue("Clone failed to return equal BitSet", eightbs.equals(bs));
}
/**
* @tests java.util.BitSet#equals(java.lang.Object)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
public void test_equalsLjava_lang_Object() {
// Test for method boolean java.util.BitSet.equals(java.lang.Object)
BitSet bs;
bs = (BitSet) eightbs.clone();
assertTrue("Same BitSet returned false", eightbs.equals(eightbs));
assertTrue("Identical BitSets returned false", eightbs.equals(bs));
bs.clear(6);
assertTrue("Different BitSets returned true", !eightbs.equals(bs));
// Grow the BitSet
bs = (BitSet) eightbs.clone();
bs.set(128);
assertTrue("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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
public void test_hashCode() {
// Test for method int java.util.BitSet.hashCode()
BitSet bs = (BitSet) eightbs.clone();
bs.clear(2);
bs.clear(6);
assertTrue("BitSet returns wrong hash value: " + bs.hashCode(), bs
.hashCode() == 1129);
bs.set(10);
bs.clear(3);
assertTrue("BitSet returns wrong hash value: " + bs.hashCode(), bs
.hashCode() == 97);
}
/**
* @tests java.util.BitSet#clear()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "clear",
args = {}
)
public void test_clear() {
eightbs.clear();
for (int i = 0; i < 8; i++)
assertTrue("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)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "clear",
args = {int.class}
)
public void test_clearI() {
// Test for method void java.util.BitSet.clear(int)
eightbs.clear(7);
assertTrue("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);
assertTrue("Failed to clear bit", !eightbs.get(165));
// Try out of range
try {
eightbs.clear(-1);
fail("Failed to throw expected out of bounds exception");
} catch (IndexOutOfBoundsException e) {
// Correct behaviour
}
BitSet bs = new BitSet(0);
assertTrue("Test1: Wrong length, " + bs.size(), bs.length() == 0);
bs.clear(0);
assertTrue("Test2: Wrong length" + bs.size(), bs.length() == 0);
}
/**
* @tests java.util.BitSet#clear(int, int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "clear",
args = {int.class, int.class}
)
public void test_clearII() {
// 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)
assertTrue("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++)
assertTrue("Failed to clear bit " + i, !bs.get(i));
for (int i = 11; i < initialSize; i++) {
if (i == 15)
assertTrue("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++) {
assertTrue("Shouldn't have flipped bit " + i, !bs.get(i));
}
// pos1 and pos2 is in the same bitset element, boundary 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++)
assertTrue("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++)
assertTrue("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));
}
bs = new BitSet(32);
initialSize = bs.size();
bs.set(0, initialSize);
bs.clear(0, 65);
for (int i = 0; i < 65; i++)
assertTrue("Failed to clear bit " + i, !bs.get(i));
for (int i = 65; i < bs.size(); i++) {
assertTrue("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)
assertTrue("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++)
assertTrue("Failed to clear bit " + i, !bs.get(i));
for (int i = 74; i < initialSize; i++) {
if (i == 110)
assertTrue("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++) {
assertTrue("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)
assertTrue("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++)
assertTrue("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++)
assertTrue("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) {
}
try {
bs.clear(2, -1);
fail(
"Test2: Attempt to flip with negative index failed to generate exception");
} catch (IndexOutOfBoundsException e) {
}
try {
bs.clear(4, 2);
fail(
"Test4: Attempt to flip with illegal args failed to generate exception");
} catch (IndexOutOfBoundsException e) {
}
}
/**
* @tests java.util.BitSet#get(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "get",
args = {int.class}
)
public void test_getI() {
// Test for method boolean java.util.BitSet.get(int)
BitSet bs = new BitSet();
bs.set(8);
assertTrue("Get returned true for index out of range", !eightbs.get(99));
assertTrue("Get returned false for set value", eightbs.get(3));
assertTrue("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);
assertTrue("Access greater than size", !bs.get(64));
bs = new BitSet();
bs.set(63);
assertTrue("Test highest bit", bs.get(63));
}
/**
* @tests java.util.BitSet#get(int, int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "get",
args = {int.class, int.class}
)
public void test_getII() {
// 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);
assertTrue("Test1: Returned incorrect BitSet", resultbs
.equals(correctbs));
// pos1 and pos2 are in the same bitset element, at index 1
resultbs = bs.get(100, 125);
correctbs = new BitSet(25);
correctbs.set(21);
assertTrue("Test2: Returned incorrect BitSet", resultbs
.equals(correctbs));
// 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);
assertTrue("Test3: Returned incorrect BitSet", resultbs
.equals(correctbs));
// 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);
assertTrue("Test4: Returned incorrect BitSet", resultbs
.equals(correctbs));
// 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);
assertTrue("Test5: Returned incorrect BitSet", resultbs
.equals(correctbs));
// 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);
assertTrue("Test6: Returned incorrect BitSet", resultbs
.equals(correctbs));
assertTrue("equality principle", bs.equals(bs.get(0, bs.size())));
// 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);
assertTrue("Test6: Returned incorrect BitSet", resultbs
.equals(correctbs));
// 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());
assertTrue("equality principle", bs2.equals(resultbs));
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());
assertTrue("equality principle", bs2.equals(resultbs));
try {
bs2.get(-1, 0);
fail("IndexOutOfBoundsException expected");
} catch (IndexOutOfBoundsException e) {
//expected
}
try {
bs2.get(bs2.size()/2, 0);
fail("IndexOutOfBoundsException expected");
} catch (IndexOutOfBoundsException e) {
//expected
}
try {
bs2.get(bs2.size()/2, -1);
fail("IndexOutOfBoundsException expected");
} catch (IndexOutOfBoundsException e) {
//expected
}
}
/**
* @tests java.util.BitSet#set(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "set",
args = {int.class}
)
public void test_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));
assertTrue("Incorrect length", bs.length() == (i + 1));
for (int j = bs.size(); --j > i;)
assertTrue("Incorrectly set bit " + j, !bs.get(j));
for (int j = i; --j >= 0;)
assertTrue("Incorrectly set bit " + j, !bs.get(j));
bs.clear(i);
}
bs = new BitSet(0);
assertTrue("Test1: Wrong length, " + bs.size(), bs.length() == 0);
bs.set(0);
assertTrue("Test2: Wrong length" + bs.size(), bs.length() == 1);
}
/**
* @tests java.util.BitSet#set(int, boolean)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "set",
args = {int.class, boolean.class}
)
public void test_setIZ() {
// Test for method void java.util.BitSet.set(int, boolean)
eightbs.set(5, false);
assertTrue("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));
try {
eightbs.set(-5, false);
fail("IndexOutOfBoundsException expected");
} catch (IndexOutOfBoundsException e) {
//expected
}
}
/**
* @tests java.util.BitSet#set(int, int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "set",
args = {int.class, int.class}
)
public void test_setII() {
// 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
assertTrue("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
assertTrue("Shouldn't have set bit " + i, !bs.get(i));
}
// pos1 and pos2 is in the same bitset element, boundary testing
bs = new BitSet(16);
bs.set(7, 64);
assertEquals("Failed to grow BitSet", 64, bs.size());
for (int i = 0; i < 7; i++)
assertTrue("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));
assertTrue("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));
assertTrue("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));
assertTrue("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
assertTrue("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
assertTrue("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
assertTrue("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++)
assertTrue("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) {
}
try {
bs.set(2, -1);
fail(
"Test2: Attempt to flip with negative index failed to generate exception");
} catch (IndexOutOfBoundsException e) {
}
try {
bs.set(4, 2);
fail(
"Test4: Attempt to flip with illegal args failed to generate exception");
} catch (IndexOutOfBoundsException e) {
}
}
/**
* @tests java.util.BitSet#set(int, int, boolean)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "set",
args = {int.class, int.class, boolean.class}
)
public void test_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));
try {
eightbs.set(-3, 6, false);
fail("IndexOutOfBoundsException expected");
} catch (IndexOutOfBoundsException e) {
//expected
}
try {
eightbs.set(3, -6, false);
fail("IndexOutOfBoundsException expected");
} catch (IndexOutOfBoundsException e) {
//expected
}
try {
eightbs.set(6, 3, false);
fail("IndexOutOfBoundsException expected");
} catch (IndexOutOfBoundsException e) {
//expected
}
}
/**
* @tests java.util.BitSet#flip(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "flip",
args = {int.class}
)
public void test_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);
assertTrue("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));
assertTrue("Failed to flip bit", !bs.get(9));
assertTrue("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));
assertTrue("Incorrect length", bs.length() == (i + 1));
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#flip(int, int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "flip",
args = {int.class, int.class}
)
public void test_flipII() {
// 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));
assertTrue("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));
assertTrue("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, boundary 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));
assertTrue("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));
assertTrue("Failed to flip bit 10", !bs.get(10));
for (int i = 11; i < 64; i++)
assertTrue("failed to flip bit " + i, bs.get(i));
assertTrue("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));
assertTrue("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));
assertTrue("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++)
assertTrue("Shouldn't have flipped bit " + i, !bs.get(i));
assertTrue("Shouldn't have flipped bit 7", bs.get(7));
assertTrue("Shouldn't have flipped bit 8", !bs.get(8));
assertTrue("Failed to flip bit 9", bs.get(9));
assertTrue("Failed to flip bit 10", !bs.get(10));
for (int i = 11; i < 72; i++)
assertTrue("failed to flip bit " + i, bs.get(i));
assertTrue("Failed to flip bit 72", !bs.get(72));
assertTrue("Failed to flip bit 73", bs.get(73));
for (int i = 74; i < 110; i++)
assertTrue("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++)
assertTrue("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++)
assertTrue("Shouldn't have flipped bit " + i, !bs.get(i));
assertTrue("Shouldn't have flipped bit 7", bs.get(7));
assertTrue("Shouldn't have flipped bit 8", !bs.get(8));
assertTrue("Failed to flip bit 9", bs.get(9));
assertTrue("Failed to flip bit 10", !bs.get(10));
for (int i = 11; i < 72; i++)
assertTrue("failed to flip bit " + i, bs.get(i));
assertTrue("Failed to flip bit 72", !bs.get(72));
for (int i = 73; i < 110; i++)
assertTrue("failed to flip bit " + i, bs.get(i));
assertTrue("Failed to flip bit 110", !bs.get(110));
for (int i = 111; i < 181; i++)
assertTrue("failed to flip bit " + i, bs.get(i));
assertTrue("Failed to flip bit 181", !bs.get(181));
for (int i = 182; i < 219; i++)
assertTrue("failed to flip bit " + i, bs.get(i));
assertTrue("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) {
}
try {
bs.flip(2, -1);
fail(
"Test2: Attempt to flip with negative index failed to generate exception");
} catch (IndexOutOfBoundsException e) {
}
try {
bs.flip(4, 2);
fail(
"Test4: Attempt to flip with illegal args failed to generate exception");
} catch (IndexOutOfBoundsException e) {
}
}
/**
* @tests java.util.BitSet#set(int, int)
* @tests java.util.BitSet#cardinality()
* @tests java.util.BitSet#get(int)
* @tests java.util.BitSet#flip(int, int)
* @tests java.util.BitSet#clear(int,int)
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "flip",
args = {int.class, int.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "get",
args = {int.class, int.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "set",
args = {int.class, int.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "clear",
args = {int.class, int.class}
)
})
public void test_111478() {
// BitSet shouldn't be modified by any of the operations below,
// since the affected bits for these methods are defined as inclusive of
// pos1, exclusive of pos2.
try {
eightbs.flip(0, 0);
assertTrue("Bit got flipped incorrectly ", eightbs.get(0));
BitSet bsnew = eightbs.get(2, 2);
assertEquals("BitSet retrieved incorrectly ",
0, bsnew.cardinality());
eightbs.set(10, 10);
assertTrue("Bit got set incorrectly ", !eightbs.get(10));
eightbs.clear(3, 3);
assertTrue("Bit cleared incorrectly ", eightbs.get(3));
} catch (IndexOutOfBoundsException e) {
fail("Unexpected IndexOutOfBoundsException when pos1 ==pos2");
}
}
/**
* @tests java.util.BitSet#intersects(java.util.BitSet)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "intersects",
args = {java.util.BitSet.class}
)
public void test_intersectsLjava_util_BitSet() {
// 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)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "and",
args = {java.util.BitSet.class}
)
public void test_andLjava_util_BitSet() {
// 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);
assertTrue("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++)
assertTrue("Failed to clear extra bits in the receiver BitSet", !bs
.get(i));
}
/**
* @tests java.util.BitSet#andNot(java.util.BitSet)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "andNot",
args = {java.util.BitSet.class}
)
public void test_andNotLjava_util_BitSet() {
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)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "or",
args = {java.util.BitSet.class}
)
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);
assertTrue("OR set a bit which should be off", !bs.get(5));
}
/**
* @tests java.util.BitSet#xor(java.util.BitSet)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "xor",
args = {java.util.BitSet.class}
)
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++)
assertTrue("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#size()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "size",
args = {}
)
public void test_size() {
// Test for method int java.util.BitSet.size()
assertEquals("Returned incorrect size", 64, eightbs.size());
eightbs.set(129);
assertTrue("Returned incorrect size", eightbs.size() >= 129);
}
/**
* @tests java.util.BitSet#toString()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "length",
args = {}
)
public void test_length() {
BitSet bs = new BitSet();
assertTrue("BitSet returned wrong length--wanted 0, got: "
+ bs.length(), bs.length() == 0);
bs.set(5);
assertTrue("BitSet returned wrong length--wanted 6, got: "
+ bs.length(), bs.length() == 6);
bs.set(10);
assertTrue("BitSet returned wrong length--wanted 11, got: "
+ bs.length(), bs.length() == 11);
bs.set(432);
assertTrue("BitSet returned wrong length--wanted 433, got: "
+ bs.length(), bs.length() == 433);
bs.set(300);
assertTrue("BitSet returned wrong length--wanted 433 (again), got: "
+ bs.length(), bs.length() == 433);
}
/**
* @tests java.util.BitSet#nextSetBit(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "nextSetBit",
args = {int.class}
)
public void test_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) {
}
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)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "nextClearBit",
args = {int.class}
)
public void test_nextClearBitI() {
// Test for method int java.util.BitSet.nextSetBit()
BitSet bs = new BitSet(500);
// ensure all the bits from 0 to bs.size() - 1 are set to true
bs.set(0, bs.size() - 1);
bs.set(bs.size() - 1);
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) {
}
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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isEmpty",
args = {}
)
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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "cardinality",
args = {}
)
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());
}
/**
* helper method to display the contents of a bitset
*
*/
private static void printBitset(BitSet bs) {
System.out.println();
for (int i = bs.size() - 1; i >= 0; i--) {
if (bs.get(i))
System.out.print(1);
else
System.out.print(0);
}
}
/**
* Sets up the fixture, for example, open a network connection. This method
* is called before a test is executed.
*/
protected void setUp() {
eightbs = new BitSet();
for (int i = 0; i < 8; i++)
eightbs.set(i);
}
/**
* Tears down the fixture, for example, close a network connection. This
* method is called after a test is executed.
*/
protected void tearDown() {
}
}