harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r547591 [2/2] - /harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/BitSetTest.java
Date Fri, 15 Jun 2007 09:36:20 GMT

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/BitSetTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/BitSetTest.java?view=diff&rev=547591&r1=547590&r2=547591
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/BitSetTest.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/util/BitSetTest.java Fri Jun 15 02:36:19 2007
@@ -23,1323 +23,1358 @@
 
 public class BitSetTest extends junit.framework.TestCase {
 
-	BitSet eightbs;
+    BitSet eightbs;
 
-	/**
-	 * @tests java.util.BitSet#BitSet()
-	 */
-	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)
-	 */
-	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#BitSet()
+     */
+    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)
+     */
+    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
+        }
 
         // Regression test for HARMONY-4147
         try {
-          new BitSet(Integer.MAX_VALUE);
+            new BitSet(Integer.MAX_VALUE);
         } catch (OutOfMemoryError e) {
             // Ignore if no room for this size.
         }
-	}
+    }
+
+    /**
+     * @tests java.util.BitSet#clone()
+     */
+    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)
+     */
+    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()
+     */
+    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()
+     */
+    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)
+     */
+    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);
+
+        bs = new BitSet();
+        try {
+            bs.clear(-1);
+            fail("Should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.BitSet#clear(int, int)
+     */
+    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)
+     */
+    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));
 
-	/**
-	 * @tests java.util.BitSet#clone()
-	 */
-	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)
-	 */
-	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()
-	 */
-	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()
-	 */
-	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)
-	 */
-	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);
-		
-		bs = new BitSet();
-		try {
-			bs.clear(-1);
-			fail("Should throw IndexOutOfBoundsException");
-		} catch (IndexOutOfBoundsException e) {
-			// expected
-		}
-	}
-
-	/**
-	 * @tests java.util.BitSet#clear(int, int)
-	 */
-	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)
-	 */
-	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));
-		
-		bs = new BitSet();
-		try {
-			bs.get(Integer.MIN_VALUE);
-			fail("Should throw IndexOutOfBoundsException");
-		} catch (IndexOutOfBoundsException e) {
-			// expected
-		}
-	}
-
-	/**
-	 * @tests java.util.BitSet#get(int, int)
-	 */
-	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));
-	}
-
-	/**
-	 * @tests java.util.BitSet#set(int)
-	 */
-	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)
-	 */
-	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 {
+        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));
+
+        bs = new BitSet();
+        try {
+            bs.get(Integer.MIN_VALUE);
+            fail("Should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.BitSet#get(int, int)
+     */
+    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));
+    }
+
+    /**
+     * @tests java.util.BitSet#set(int)
+     */
+    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)
+     */
+    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 {
             BitSet bs = new BitSet();
             bs.set(-2147483648, false);
             fail("Should throw IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
-	}
+    }
+
+    /**
+     * @tests java.util.BitSet#set(int, int)
+     */
+    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)
+     */
+    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));
+
+    }
+
+    /**
+     * @tests java.util.BitSet#flip(int)
+     */
+    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)
+     */
+    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)
+     */
+
+    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)
+     */
+    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)
+     */
+    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));
+        }
+
+        bs = new BitSet(64);
+        try {
+            bs.and(null);
+            fail("Should throw NPE");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.util.BitSet#andNot(java.util.BitSet)
+     */
+    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());
+
+        bs = new BitSet(64);
+        try {
+            bs.andNot(null);
+            fail("Should throw NPE");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @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);
+        assertTrue("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++) {
+            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()
+     */
+    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()
+     */
+    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()
+     */
+    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)
+     */
+    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)
+     */
+    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()
+     */
+    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());
 
-	/**
-	 * @tests java.util.BitSet#set(int, int)
-	 */
-	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)
-	 */
-	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));
-
-	}
-
-	/**
-	 * @tests java.util.BitSet#flip(int)
-	 */
-	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)
-	 */
-	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)
-	 */
-
-	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)
-	 */
-	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)
-	 */
-	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));
-		
-		bs = new BitSet(64);
-		try {
-			bs.and(null);
-			fail("Should throw NPE");
-		} catch (NullPointerException e) {
-			// expected
-		}
-	}
-
-	/**
-	 * @tests java.util.BitSet#andNot(java.util.BitSet)
-	 */
-	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());
-		
-		bs = new BitSet(64);
-		try {
-			bs.andNot(null);
-			fail("Should throw NPE");
-		} catch (NullPointerException e) {
-			// expected
-		}
-	}
-
-	/**
-	 * @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);
-		assertTrue("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++)
-			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()
-	 */
-	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()
-	 */
-	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()
-	 */
-	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)
-	 */
-	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)
-	 */
-	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()
-	 */
-	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());
-        
-        
         bs.clear();
         bs.set(0, 64);
         assertEquals("cardinality() returned wrong value", 64, bs.cardinality());
-	}
-    
-	public void test_serialization() throws Exception{
+    }
+
+    public void test_serialization() throws Exception {
         BitSet bs = new BitSet(500);
         bs.set(5);
         bs.set(32);
@@ -1348,11 +1383,11 @@
         bs.set(71, 110);
         bs.set(127, 130);
         bs.set(193);
-        bs.set(450);        
-        SerializationTest.verifySelf(bs);   
+        bs.set(450);
+        SerializationTest.verifySelf(bs);
     }
-    
-    public void test_serializationCompatiblity() throws Exception{
+
+    public void test_serializationCompatiblity() throws Exception {
         BitSet bs = new BitSet(500);
         bs.set(5);
         bs.set(32);
@@ -1361,40 +1396,42 @@
         bs.set(71, 110);
         bs.set(127, 130);
         bs.set(193);
-        bs.set(450);        
+        bs.set(450);
         SerializationTest.verifyGolden(this, bs);
     }
-    
-	/**
-	 * 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() {
-	}
+
+    /**
+     * 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() {
+    }
 }



Mime
View raw message