activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r1360895 [2/2] - in /activemq/activemq-cpp/trunk/activemq-cpp/src: main/ main/decaf/lang/exceptions/ main/decaf/util/ test/ test/decaf/util/
Date Thu, 12 Jul 2012 19:59:02 GMT
Added: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.cpp?rev=1360895&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.cpp (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.cpp Thu Jul 12 19:59:01 2012
@@ -0,0 +1,1423 @@
+/*
+ * 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.
+ */
+
+#include "BitSetTest.h"
+
+#include <decaf/util/BitSet.h>
+#include <decaf/lang/Thread.h>
+#include <decaf/lang/Integer.h>
+#include <decaf/lang/System.h>
+
+#include <decaf/lang/exceptions/OutOfMemoryError.h>
+#include <decaf/lang/exceptions/NegativeArraySizeException.h>
+#include <decaf/lang/exceptions/IndexOutOfBoundsException.h>
+
+using namespace std;
+using namespace decaf;
+using namespace decaf::util;
+using namespace decaf::lang;
+using namespace decaf::lang::exceptions;
+
+////////////////////////////////////////////////////////////////////////////////
+namespace {
+
+    BitSet eightbs;
+
+    void printBitset(const BitSet& bs) {
+        std::cout << std::endl;
+        for (int i = bs.size() - 1; i >= 0; i--) {
+            if (bs.get(i)) {
+                std::cout << "1";
+            } else {
+                std::cout << "0";
+            }
+        }
+    }
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSetTest::BitSetTest() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSetTest::~BitSetTest() {
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::setUp() {
+
+	eightbs = BitSet(1);
+
+    for (int i = 0; i < 8; i++) {
+        eightbs.set(i);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testConstructor() {
+
+    BitSet bs;
+
+    // Default size for a BitSet should be 64 elements;
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Created BitSet of incorrect size", 64, bs.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("New BitSet had invalid string representation",
+                                 std::string("{}"), bs.toString());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testConstructorI() {
+
+    BitSet bs(128);
+    // Default size for a BitSet should be 64 elements;
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Created BitSet of incorrect size", 128, bs.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("New BitSet had invalid string representation: " + bs.toString(),
+                                 std::string("{}"), bs.toString());
+
+    // All BitSets are created with elements of multiples of 64
+
+    BitSet bs1(89);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to round BitSet element size", 128, bs1.size());
+
+    try {
+        BitSet bs(-9);
+        CPPUNIT_FAIL("Failed to throw exception when creating a new BitSet with negative elements value");
+    } catch (NegativeArraySizeException& e) {
+        // Correct behavior
+    }
+
+    // Regression test for HARMONY-4147
+    try {
+        BitSet bs(Integer::MAX_VALUE);
+    } catch (OutOfMemoryError& e) {
+        // Ignore if no room for this size.
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testCopy() {
+    BitSet bs(eightbs);
+    CPPUNIT_ASSERT_MESSAGE("copy failed to return equal BitSet", bs.equals(eightbs));
+
+    BitSet assigned;
+    assigned = eightbs;
+    CPPUNIT_ASSERT_MESSAGE("copy failed to return equal BitSet", assigned.equals(eightbs));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testEquals() {
+    BitSet bs = eightbs;
+
+    CPPUNIT_ASSERT_MESSAGE("Same BitSet returned false", eightbs.equals(eightbs));
+    CPPUNIT_ASSERT_MESSAGE("Identical BitSet returned false", bs.equals(eightbs));
+    bs.clear(6);
+    CPPUNIT_ASSERT_MESSAGE("Different BitSets returned true", !eightbs.equals(bs));
+    // Grow the BitSet
+    bs = eightbs;
+    bs.set(128);
+    CPPUNIT_ASSERT_MESSAGE("Different sized BitSet with higher bit set returned true",
+                           !eightbs.equals(bs));
+    bs.clear(128);
+    CPPUNIT_ASSERT_MESSAGE("Different sized BitSet with higher bits not set returned false",
+                           eightbs.equals(bs));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testClear() {
+    eightbs.clear();
+    for (int i = 0; i < 8; i++) {
+        CPPUNIT_ASSERT_MESSAGE("Clear didn't clear bit " + i, !eightbs.get(i));
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong length", 0, eightbs.length());
+
+    BitSet bs(3400);
+    bs.set(0, bs.size() - 1); // ensure all bits are 1's
+    bs.set(bs.size() - 1);
+    bs.clear();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong length", 0, bs.length());
+    CPPUNIT_ASSERT_MESSAGE("Test2: isEmpty() returned incorrect value", bs.isEmpty());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: cardinality() returned incorrect value", 0,
+                                 bs.cardinality());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testClearI() {
+
+    eightbs.clear(7);
+    CPPUNIT_ASSERT_MESSAGE("Failed to clear bit", !eightbs.get(7));
+
+    // Check to see all other bits are still set
+    for (int i = 0; i < 7; i++) {
+        CPPUNIT_ASSERT_MESSAGE("Clear cleared incorrect bits", eightbs.get(i));
+    }
+
+    eightbs.clear(165);
+    CPPUNIT_ASSERT_MESSAGE("Failed to clear bit", !eightbs.get(165));
+
+    // Try out of range
+    try {
+        eightbs.clear(-1);
+        CPPUNIT_FAIL("Failed to throw expected out of bounds exception");
+    } catch (IndexOutOfBoundsException& e) {
+        // Correct behaviour
+    }
+
+    BitSet bs(0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong length,", 0, bs.length());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong size,", 0, bs.size());
+    bs.clear(0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong length,", 0, bs.length());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong size,", 0, bs.size());
+
+    bs.clear(60);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong length,", 0, bs.length());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong size,", 0, bs.size());
+
+    bs.clear(120);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test4: Wrong size,", 0, bs.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test4: Wrong length,", 0, bs.length());
+
+    bs.set(25);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test5: Wrong size,", 64, bs.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test5: Wrong length,", 26, bs.length());
+
+    bs.clear(80);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test6: Wrong size,", 64, bs.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test6: Wrong length,", 26, bs.length());
+
+    bs.clear(25);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test7: Wrong size,", 64, bs.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test7: Wrong length,", 0, bs.length());
+
+    BitSet bs1;
+    try {
+        bs1.clear(-1);
+        CPPUNIT_FAIL("Should throw IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException& e) {
+        // expected
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testClearII() {
+    BitSet bitset;
+    for (int i = 0; i < 20; i++) {
+        bitset.set(i);
+    }
+    bitset.clear(10, 10);
+
+    // pos1 and pos2 are in the same bitset element
+    BitSet bs(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) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        } else {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have cleared bit " + Integer::toString(i), bs.get(i));
+        }
+    }
+    for (int i = 7; i < 11; i++) {
+        CPPUNIT_ASSERT_MESSAGE("Failed to clear bit " + Integer::toString(i), !bs.get(i));
+    }
+
+    for (int i = 11; i < initialSize; i++) {
+        if (i == 15) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        } else {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have cleared bit " + Integer::toString(i), bs.get(i));
+        }
+    }
+
+    for (int i = initialSize; i < bs.size(); i++) {
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + i, !bs.get(i));
+    }
+
+    // pos1 and pos2 is in the same bitset element, boundary testing
+    {
+        BitSet bs(16);
+        initialSize = bs.size();
+        bs.set(0, initialSize);
+        bs.clear(7, 64);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to grow BitSet", 64, bs.size());
+        for (int i = 0; i < 7; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have cleared bit " + Integer::toString(i), bs.get(i));
+        }
+        for (int i = 7; i < 64; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to clear bit " + Integer::toString(i), !bs.get(i));
+        }
+        for (int i = 64; i < bs.size(); i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+    }
+    {
+        // more boundary testing
+        BitSet bs(32);
+        initialSize = bs.size();
+        bs.set(0, initialSize);
+        bs.clear(0, 64);
+        for (int i = 0; i < 64; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to clear bit " + Integer::toString(i), !bs.get(i));
+        }
+        for (int i = 64; i < bs.size(); i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+    }
+    {
+        BitSet bs(32);
+        initialSize = bs.size();
+        bs.set(0, initialSize);
+        bs.clear(0, 65);
+        for (int i = 0; i < 65; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to clear bit " + i, !bs.get(i));
+        }
+        for (int i = 65; i < bs.size(); i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+    }
+    {
+        // pos1 and pos2 are in two sequential bitset elements
+        BitSet bs(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) {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+            } else {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have cleared bit " + Integer::toString(i), bs.get(i));
+            }
+        }
+        for (int i = 9; i < 74; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to clear bit " + i, !bs.get(i));
+        }
+        for (int i = 74; i < initialSize; i++) {
+            if (i == 110) {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+            } else {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have cleared bit " + Integer::toString(i), bs.get(i));
+            }
+        }
+        for (int i = initialSize; i < bs.size(); i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+    }
+    {
+        // pos1 and pos2 are in two non-sequential bitset elements
+        BitSet bs(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) {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+            } else {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have cleared bit " + Integer::toString(i), bs.get(i));
+            }
+        }
+
+        for (int i = 9; i < 219; i++) {
+            CPPUNIT_ASSERT_MESSAGE("CPPUNIT_FAILed to clear bit " + i, !bs.get(i));
+        }
+
+        for (int i = 219; i < 255; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have cleared bit " + i, bs.get(i));
+        }
+
+        for (int i = 255; i < bs.size(); i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + i, !bs.get(i));
+        }
+    }
+    {
+        // test illegal args
+        BitSet bs(10);
+        try {
+            bs.clear(-1, 3);
+            CPPUNIT_FAIL("Test1: Attempt to flip with  negative index CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // excepted
+        }
+
+        try {
+            bs.clear(2, -1);
+            CPPUNIT_FAIL("Test2: Attempt to flip with negative index CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // excepted
+        }
+
+        bs.set(2, 4);
+        bs.clear(2, 2);
+        CPPUNIT_ASSERT_MESSAGE("Bit got cleared incorrectly ", bs.get(2));
+        try {
+            bs.clear(4, 2);
+            CPPUNIT_FAIL("Test4: Attempt to flip with illegal args CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // excepted
+        }
+    }
+    {
+        BitSet bs(0);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong length,", 0, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong size,", 0, bs.size());
+
+        bs.clear(0, 2);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong length,", 0, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong size,", 0, bs.size());
+
+        bs.clear(60, 64);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong length,", 0, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong size,", 0, bs.size());
+
+        bs.clear(64, 120);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test4: Wrong length,", 0, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test4: Wrong size,", 0, bs.size());
+
+        bs.set(25);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test5: Wrong length,", 26, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test5: Wrong size,", 64, bs.size());
+
+        bs.clear(60, 64);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test6: Wrong length,", 26, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test6: Wrong size,", 64, bs.size());
+
+        bs.clear(64, 120);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test7: Wrong size,", 64, bs.size());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test7: Wrong length,", 26, bs.length());
+
+        bs.clear(80);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test8: Wrong size,", 64, bs.size());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test8: Wrong length,", 26, bs.length());
+
+        bs.clear(25);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test9: Wrong size,", 64, bs.size());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test9: Wrong length,", 0, bs.length());
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testGetI() {
+
+    BitSet bs;
+    bs.set(8);
+    CPPUNIT_ASSERT_MESSAGE("Get returned true for index out of range", !eightbs.get(99));
+    CPPUNIT_ASSERT_MESSAGE("Get returned false for set value", eightbs.get(3));
+    CPPUNIT_ASSERT_MESSAGE("Get returned true for a non set value", !bs.get(0));
+
+    try {
+        bs.get(-1);
+        CPPUNIT_FAIL("Attempt to get at negative index CPPUNIT_FAILed to generate exception");
+    } catch (IndexOutOfBoundsException& e) {
+        // Correct behaviour
+    }
+
+    BitSet bs1;
+    CPPUNIT_ASSERT_MESSAGE("Access greater than size", !bs1.get(64));
+
+    BitSet bs2;
+    bs2.set(63);
+    CPPUNIT_ASSERT_MESSAGE("Test highest bit", bs2.get(63));
+
+    BitSet bs3(0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong length,", 0, bs3.length());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong size,", 0, bs3.size());
+
+    bs3.get(2);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong length,", 0, bs3.length());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong size,", 0, bs3.size());
+
+    bs3.get(70);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong length,", 0, bs3.length());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong size,", 0, bs3.size());
+
+    BitSet bs4;
+    try {
+        bs4.get(Integer::MIN_VALUE);
+        CPPUNIT_FAIL("Should throw IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException& e) {
+        // expected
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testGetII() {
+
+    BitSet bitset(30);
+    bitset.get(3, 3);
+
+    BitSet bs(512);
+    BitSet resultbs;
+
+    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);
+        BitSet correctbs(3);
+        correctbs.set(0, 3);
+        CPPUNIT_ASSERT_MESSAGE("Test1: Returned incorrect BitSet", correctbs.equals(resultbs));
+    }
+    {
+        // pos1 and pos2 are in the same bitset element, at index 1
+        resultbs = bs.get(100, 125);
+        BitSet correctbs(25);
+        correctbs.set(21);
+        CPPUNIT_ASSERT_MESSAGE("Test2: Returned incorrect BitSet", correctbs.equals(resultbs));
+    }
+    {
+        // pos1 in bitset element at index 0, and pos2 in bitset element at index 1
+        resultbs = bs.get(15, 125);
+        BitSet correctbs(25);
+        correctbs.set(0, 5);
+        correctbs.set(45, 60);
+        correctbs.set(121 - 15);
+        CPPUNIT_ASSERT_MESSAGE("Test3: Returned incorrect BitSet", correctbs.equals(resultbs));
+    }
+    {
+        // pos1 in bitset element at index 1, and pos2 in bitset element at index 2
+        resultbs = bs.get(70, 145);
+        BitSet correctbs(75);
+        correctbs.set(0, 5);
+        correctbs.set(51);
+        correctbs.set(60, 70);
+        CPPUNIT_ASSERT_MESSAGE("Test4: Returned incorrect BitSet", correctbs.equals(resultbs));
+    }
+    {
+        // pos1 in bitset element at index 0, and pos2 in bitset element at index 2
+        resultbs = bs.get(5, 145);
+        BitSet correctbs(140);
+        correctbs.set(0, 4);
+        correctbs.set(5, 15);
+        correctbs.set(55, 70);
+        correctbs.set(116);
+        correctbs.set(125, 135);
+        CPPUNIT_ASSERT_MESSAGE("Test5: Returned incorrect BitSet", correctbs.equals(resultbs));
+    }
+    {
+        // pos1 in bitset element at index 0, and pos2 in bitset element at index 3
+        resultbs = bs.get(5, 250);
+        BitSet correctbs(200);
+        correctbs.set(0, 4);
+        correctbs.set(5, 15);
+        correctbs.set(55, 70);
+        correctbs.set(116);
+        correctbs.set(125, 135);
+        CPPUNIT_ASSERT_MESSAGE("Test5: Returned incorrect BitSet", correctbs.equals(resultbs));
+
+        CPPUNIT_ASSERT_MESSAGE("equality principle 1 ", bs.get(0, bs.size()).equals(bs));
+    }
+    {
+        // more tests
+        BitSet bs2(129);
+        bs2.set(0, 20);
+        bs2.set(62, 65);
+        bs2.set(121, 123);
+        resultbs = bs2.get(1, 124);
+        BitSet correctbs(129);
+        correctbs.set(0, 19);
+        correctbs.set(61, 64);
+        correctbs.set(120, 122);
+        CPPUNIT_ASSERT_MESSAGE("Test7: Returned incorrect BitSet", correctbs.equals(resultbs));
+    }
+    {
+        // equality principle with some boundary conditions
+        BitSet bs2(128);
+        bs2.set(2, 20);
+        bs2.set(62);
+        bs2.set(121, 123);
+        bs2.set(127);
+        resultbs = bs2.get(0, bs2.size());
+        CPPUNIT_ASSERT_MESSAGE("equality principle", bs2.equals(resultbs));
+    }
+    {
+        BitSet bs2(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());
+        CPPUNIT_ASSERT_MESSAGE("equality principle 3 ", resultbs.equals(bs2));
+    }
+    {
+        BitSet bs(0);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong length,", 0, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong size,", 0, bs.size());
+
+        bs.get(0, 2);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong length,", 0, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong size,", 0, bs.size());
+
+        bs.get(60, 64);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong length,", 0, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong size,", 0, bs.size());
+
+        bs.get(64, 120);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test4: Wrong length,", 0, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test4: Wrong size,", 0, bs.size());
+
+        bs.set(25);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test5: Wrong length,", 26, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test5: Wrong size,", 64, bs.size());
+
+        bs.get(60, 64);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test6: Wrong length,", 26, bs.length());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test6: Wrong size,", 64, bs.size());
+
+        bs.get(64, 120);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test7: Wrong size,", 64, bs.size());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test7: Wrong length,", 26, bs.length());
+
+        bs.get(80);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test8: Wrong size,", 64, bs.size());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test8: Wrong length,", 26, bs.length());
+
+        bs.get(25);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test9: Wrong size,", 64, bs.size());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test9: Wrong length,", 26, bs.length());
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testFlipI() {
+    BitSet bs;
+    bs.clear(8);
+    bs.clear(9);
+    bs.set(10);
+    bs.flip(9);
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit", !bs.get(8));
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit", bs.get(9));
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit", bs.get(10));
+
+    bs.set(8);
+    bs.set(9);
+    bs.clear(10);
+    bs.flip(9);
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit", bs.get(8));
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit", !bs.get(9));
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit", !bs.get(10));
+
+    try {
+        bs.flip(-1);
+        CPPUNIT_FAIL("Attempt to flip at negative index CPPUNIT_FAILed to generate exception");
+    } catch (IndexOutOfBoundsException& e) {
+        // Correct behaviour
+    }
+
+    // Try setting a bit on a 64 boundary
+    bs.flip(128);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to grow BitSet", 192, bs.size());
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit", bs.get(128));
+
+    BitSet bs1(64);
+    for (int i = bs1.size(); --i >= 0;) {
+        bs1.flip(i);
+        CPPUNIT_ASSERT_MESSAGE("Test1: Incorrectly flipped bit" + Integer::toString(i), bs1.get(i));
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect length", i+1, bs1.length());
+        for (int j = bs1.size(); --j > i;) {
+            CPPUNIT_ASSERT_MESSAGE("Test2: Incorrectly flipped bit" + Integer::toString(j), !bs1.get(j));
+        }
+        for (int j = i; --j >= 0;) {
+            CPPUNIT_ASSERT_MESSAGE("Test3: Incorrectly flipped bit" + Integer::toString(j), !bs1.get(j));
+        }
+        bs1.flip(i);
+    }
+
+    BitSet bs0(0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong size", 0, bs0.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong length", 0, bs0.length());
+
+    bs0.flip(0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong size", 64, bs0.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong length", 1, bs0.length());
+
+    bs0.flip(63);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong size", 64, bs0.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test3: Wrong length", 64, bs0.length());
+
+    eightbs.flip(7);
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 7", !eightbs.get(7));
+
+    // Check to see all other bits are still set
+    for (int i = 0; i < 7; i++) {
+        CPPUNIT_ASSERT_MESSAGE("Flip flipped incorrect bits", eightbs.get(i));
+    }
+
+    eightbs.flip(127);
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 127", eightbs.get(127));
+
+    eightbs.flip(127);
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 127", !eightbs.get(127));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testFlipII() {
+    BitSet bitset;
+    for (int i = 0; i < 20; i++) {
+        bitset.set(i);
+    }
+    bitset.flip(10, 10);
+
+    // Test for method void java.util.BitSet.flip(int, int)
+    // pos1 and pos2 are in the same bitset element
+    BitSet bs(16);
+    bs.set(7);
+    bs.set(10);
+    bs.flip(7, 11);
+    for (int i = 0; i < 7; i++) {
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + i, !bs.get(i));
+    }
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 7", !bs.get(7));
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 8", bs.get(8));
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 9", bs.get(9));
+    CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 10", !bs.get(10));
+    for (int i = 11; i < bs.size(); i++) {
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+    }
+
+    {
+        // pos1 and pos2 is in the same bitset element, boundry testing
+        BitSet bs(16);
+        bs.set(7);
+        bs.set(10);
+        bs.flip(7, 64);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to grow BitSet", 64, bs.size());
+        for (int i = 0; i < 7; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 7", !bs.get(7));
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 8", bs.get(8));
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 9", bs.get(9));
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 10", !bs.get(10));
+        for (int i = 11; i < 64; i++) {
+            CPPUNIT_ASSERT_MESSAGE("CPPUNIT_FAILed to flip bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 64", !bs.get(64));
+    }
+    {
+        // more boundary testing
+        BitSet bs(32);
+        bs.flip(0, 64);
+        for (int i = 0; i < 64; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to flip bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 64", !bs.get(64));
+    }
+    {
+        BitSet bs(32);
+        bs.flip(0, 65);
+        for (int i = 0; i < 65; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to flip bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 65", !bs.get(65));
+    }
+    {
+        // pos1 and pos2 are in two sequential bitset elements
+        BitSet bs(128);
+        bs.set(7);
+        bs.set(10);
+        bs.set(72);
+        bs.set(110);
+        bs.flip(9, 74);
+        for (int i = 0; i < 7; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 7", bs.get(7));
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 8", !bs.get(8));
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 9", bs.get(9));
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 10", !bs.get(10));
+        for (int i = 11; i < 72; i++) {
+            CPPUNIT_ASSERT_MESSAGE("CPPUNIT_FAILed to flip bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 72", !bs.get(72));
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 73", bs.get(73));
+        for (int i = 74; i < 110; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 110", bs.get(110));
+        for (int i = 111; i < bs.size(); i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+    }
+    {
+        // pos1 and pos2 are in two non-sequential bitset elements
+        BitSet bs(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++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 7", bs.get(7));
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 8", !bs.get(8));
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 9", bs.get(9));
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 10", !bs.get(10));
+        for (int i = 11; i < 72; i++) {
+            CPPUNIT_ASSERT_MESSAGE("CPPUNIT_FAILed to flip bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 72", !bs.get(72));
+        for (int i = 73; i < 110; i++) {
+            CPPUNIT_ASSERT_MESSAGE("CPPUNIT_FAILed to flip bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 110", !bs.get(110));
+        for (int i = 111; i < 181; i++) {
+            CPPUNIT_ASSERT_MESSAGE("CPPUNIT_FAILed to flip bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Failed to flip bit 181", !bs.get(181));
+        for (int i = 182; i < 219; i++) {
+            CPPUNIT_ASSERT_MESSAGE("CPPUNIT_FAILed to flip bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 219", !bs.get(219));
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 220", bs.get(220));
+        for (int i = 221; i < bs.size(); i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), !bs.get(i));
+        }
+    }
+    {
+        // test illegal args
+        BitSet bs(10);
+        try {
+            bs.flip(-1, 3);
+            CPPUNIT_FAIL("Test1: Attempt to flip with  negative index CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // correct behavior
+        }
+
+        try {
+            bs.flip(2, -1);
+            CPPUNIT_FAIL("Test2: Attempt to flip with negative index CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // correct behavior
+        }
+
+        try {
+            bs.flip(4, 2);
+            CPPUNIT_FAIL("Test4: Attempt to flip with illegal args CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // correct behavior
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testSetI() {
+
+    BitSet bs;
+    bs.set(8);
+    CPPUNIT_ASSERT_MESSAGE("Failed to set bit", bs.get(8));
+
+    try {
+        bs.set(-1);
+        CPPUNIT_FAIL("Attempt to set at negative index CPPUNIT_FAILed to generate exception");
+    } catch (IndexOutOfBoundsException& e) {
+        // Correct behavior
+    }
+
+    {
+        // Try setting a bit on a 64 boundary
+        bs.set(128);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to grow BitSet", 192, bs.size());
+        CPPUNIT_ASSERT_MESSAGE("Failed to set bit", bs.get(128));
+    }
+    {
+        BitSet bs(64);
+        for (int i = bs.size(); --i >= 0;) {
+            bs.set(i);
+            CPPUNIT_ASSERT_MESSAGE("Incorrectly set", bs.get(i));
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect length", i+1, bs.length());
+            for (int j = bs.size(); --j > i;)
+                CPPUNIT_ASSERT_MESSAGE("Incorrectly set bit " + Integer::toString(j), !bs.get(j));
+            for (int j = i; --j >= 0;)
+                CPPUNIT_ASSERT_MESSAGE("Incorrectly set bit " + Integer::toString(j), !bs.get(j));
+            bs.clear(i);
+        }
+    }
+    {
+        BitSet bs(0);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test1: Wrong length", 0, bs.length());
+        bs.set(0);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test2: Wrong length", 1, bs.length());
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testSetIB() {
+    eightbs.set(5, false);
+    CPPUNIT_ASSERT_MESSAGE("Should have set bit 5 to true", !eightbs.get(5));
+
+    eightbs.set(5, true);
+    CPPUNIT_ASSERT_MESSAGE("Should have set bit 5 to false", eightbs.get(5));
+
+    try {
+        BitSet bs;
+        bs.set(-2147483648, false);
+        CPPUNIT_FAIL("Should throw IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException& e) {
+        // expected
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testSetII() {
+
+    BitSet bitset(30);
+    bitset.set(29, 29);
+
+    {
+        // Test for method void java.util.BitSet.set(int, int)
+        // pos1 and pos2 are in the same bitset element
+        BitSet bs(16);
+        bs.set(5);
+        bs.set(15);
+        bs.set(7, 11);
+        for (int i = 0; i < 7; i++) {
+            if (i == 5)
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), bs.get(i));
+            else
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have set bit " + Integer::toString(i), !bs.get(i));
+        }
+        for (int i = 7; i < 11; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to set bit " + Integer::toString(i), bs.get(i));
+        }
+        for (int i = 11; i < bs.size(); i++) {
+            if (i == 15) {
+                CPPUNIT_ASSERT_MESSAGE(
+                    std::string("Shouldn't have flipped bit ") + Integer::toString(i), bs.get(i));
+            } else {
+                CPPUNIT_ASSERT_MESSAGE(
+                    std::string("Shouldn't have set bit ") + Integer::toString(i), !bs.get(i));
+            }
+        }
+    }
+    {
+        // pos1 and pos2 is in the same bitset element, boundary testing
+        BitSet bs(16);
+        bs.set(7, 64);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to grow BitSet", 64, bs.size());
+        for (int i = 0; i < 7; i++) {
+            CPPUNIT_ASSERT_MESSAGE(
+                std::string("Shouldn't have set bit ") + Integer::toString(i), !bs.get(i));
+        }
+        for (int i = 7; i < 64; i++) {
+            CPPUNIT_ASSERT_MESSAGE(
+                std::string("Failed to set bit ") + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have set bit 64", !bs.get(64));
+    }
+    {
+        // more boundary testing
+        BitSet bs(32);
+        bs.set(0, 64);
+        for (int i = 0; i < 64; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to set bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have set bit 64", !bs.get(64));
+    }
+    {
+        BitSet bs(32);
+        bs.set(0, 65);
+        for (int i = 0; i < 65; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to set bit " + Integer::toString(i), bs.get(i));
+        }
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have set bit 65", !bs.get(65));
+    }
+    {
+        // pos1 and pos2 are in two sequential bitset elements
+        BitSet bs(128);
+        bs.set(7);
+        bs.set(110);
+        bs.set(9, 74);
+        for (int i = 0; i < 9; i++) {
+            if (i == 7) {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), bs.get(i));
+            } else {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have set bit " + Integer::toString(i), !bs.get(i));
+            }
+        }
+        for (int i = 9; i < 74; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Failed to set bit " + Integer::toString(i), bs.get(i));
+        }
+        for (int i = 74; i < bs.size(); i++) {
+            if (i == 110) {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit " + Integer::toString(i), bs.get(i));
+            } else {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have set bit " + Integer::toString(i), !bs.get(i));
+            }
+        }
+    }
+    {
+        // pos1 and pos2 are in two non-sequential bitset elements
+        BitSet bs(256);
+        bs.set(7);
+        bs.set(255);
+        bs.set(9, 219);
+        for (int i = 0; i < 9; i++) {
+            if (i == 7) {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have set flipped " + Integer::toString(i), bs.get(i));
+            } else {
+                CPPUNIT_ASSERT_MESSAGE("Shouldn't have set bit " + Integer::toString(i), !bs.get(i));
+            }
+        }
+
+        for (int i = 9; i < 219; i++) {
+            CPPUNIT_ASSERT_MESSAGE("CPPUNIT_FAILed to set bit " + Integer::toString(i), bs.get(i));
+        }
+
+        for (int i = 219; i < 255; i++) {
+            CPPUNIT_ASSERT_MESSAGE("Shouldn't have set bit " + Integer::toString(i), !bs.get(i));
+        }
+
+        CPPUNIT_ASSERT_MESSAGE("Shouldn't have flipped bit 255", bs.get(255));
+    }
+    {
+        // test illegal args
+        BitSet bs(10);
+        try {
+            bs.set(-1, 3);
+            CPPUNIT_FAIL("Test1: Attempt to flip with  negative index CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // Correct behavior
+        }
+
+        try {
+            bs.set(2, -1);
+            CPPUNIT_FAIL("Test2: Attempt to flip with negative index CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // Correct behavior
+        }
+
+        bs.set(2, 2);
+        CPPUNIT_ASSERT_MESSAGE("Bit got set incorrectly ", !bs.get(2));
+
+        try {
+            bs.set(4, 2);
+            CPPUNIT_FAIL("Test4: Attempt to flip with illegal args CPPUNIT_FAILed to generate exception");
+        } catch (IndexOutOfBoundsException& e) {
+            // Correct behavior
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testSetIIB() {
+    eightbs.set(3, 6, false);
+    CPPUNIT_ASSERT_MESSAGE("Should have set bits 3, 4, and 5 to false",
+                           !eightbs.get(3) && !eightbs.get(4) && !eightbs.get(5));
+
+    eightbs.set(3, 6, true);
+    CPPUNIT_ASSERT_MESSAGE("Should have set bits 3, 4, and 5 to true",
+                           eightbs.get(3) && eightbs.get(4) && eightbs.get(5));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testNotModified() {
+    // 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);
+        CPPUNIT_ASSERT_MESSAGE("Bit got flipped incorrectly ", eightbs.get(0));
+
+        BitSet bsnew = eightbs.get(2, 2);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("BitSet retrieved incorrectly ", 0, bsnew.cardinality());
+
+        eightbs.set(10, 10);
+        CPPUNIT_ASSERT_MESSAGE("Bit got set incorrectly ", !eightbs.get(10));
+
+        eightbs.clear(3, 3);
+        CPPUNIT_ASSERT_MESSAGE("Bit cleared incorrectly ", eightbs.get(3));
+    } catch (IndexOutOfBoundsException& e) {
+        CPPUNIT_FAIL("Unexpected IndexOutOfBoundsException when pos1 ==pos2");
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testIntersects() {
+    BitSet bs(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(8);
+    CPPUNIT_ASSERT_MESSAGE("Test1: intersects() returned incorrect value", !bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test1: intersects() returned incorrect value", !bs2.intersects(bs));
+
+    bs2.set(4);
+    CPPUNIT_ASSERT_MESSAGE("Test2: intersects() returned incorrect value", !bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test2: intersects() returned incorrect value", !bs2.intersects(bs));
+
+    bs2.clear();
+    bs2.set(5);
+    CPPUNIT_ASSERT_MESSAGE("Test3: intersects() returned incorrect value", bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test3: intersects() returned incorrect value", bs2.intersects(bs));
+
+    bs2.clear();
+    bs2.set(63);
+    CPPUNIT_ASSERT_MESSAGE("Test4: intersects() returned incorrect value", bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test4: intersects() returned incorrect value", bs2.intersects(bs));
+
+    bs2.clear();
+    bs2.set(80);
+    CPPUNIT_ASSERT_MESSAGE("Test5: intersects() returned incorrect value", bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test5: intersects() returned incorrect value", bs2.intersects(bs));
+
+    bs2.clear();
+    bs2.set(127);
+    CPPUNIT_ASSERT_MESSAGE("Test6: intersects() returned incorrect value", bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test6: intersects() returned incorrect value", bs2.intersects(bs));
+
+    bs2.clear();
+    bs2.set(192);
+    CPPUNIT_ASSERT_MESSAGE("Test7: intersects() returned incorrect value", bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test7: intersects() returned incorrect value", bs2.intersects(bs));
+
+    bs2.clear();
+    bs2.set(450);
+    CPPUNIT_ASSERT_MESSAGE("Test8: intersects() returned incorrect value", bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test8: intersects() returned incorrect value", bs2.intersects(bs));
+
+    bs2.clear();
+    bs2.set(500);
+    CPPUNIT_ASSERT_MESSAGE("Test9: intersects() returned incorrect value", !bs.intersects(bs2));
+    CPPUNIT_ASSERT_MESSAGE("Test9: intersects() returned incorrect value", !bs2.intersects(bs));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testAnd() {
+    BitSet bs(128);
+
+    // Initialize the bottom half of the BitSet
+    for (int i = 64; i < 128; i++) {
+        bs.set(i);
+    }
+
+    eightbs.AND(bs);
+    CPPUNIT_ASSERT_MESSAGE("AND CPPUNIT_FAILed to clear bits", !eightbs.equals(bs));
+    eightbs.set(3);
+    bs.set(3);
+    eightbs.AND(bs);
+    CPPUNIT_ASSERT_MESSAGE("AND CPPUNIT_FAILed to maintain set bits", bs.get(3));
+    bs.AND(eightbs);
+
+    for (int i = 64; i < 128; i++) {
+        CPPUNIT_ASSERT_MESSAGE("Failed to clear extra bits in the receiver BitSet", !bs.get(i));
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testAndNot() {
+
+    BitSet bs = eightbs;
+    bs.clear(5);
+    BitSet bs2;
+    bs2.set(2);
+    bs2.set(3);
+    bs.andNot(bs2);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect bitset after andNot",
+                                 std::string("{0, 1, 4, 6, 7}"), bs.toString());
+
+    BitSet bs3(0);
+    bs3.andNot(bs2);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect size", 0, bs3.size());
+
+    {
+        BitSet bs(256);
+        BitSet bs2(256);
+        bs.set(97);
+        bs2.set(37);
+        bs.andNot(bs2);
+        CPPUNIT_ASSERT_MESSAGE("Incorrect value at 97 pos", bs.get(97));
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testOR() {
+    {
+        BitSet bs(128);
+        bs.OR(eightbs);
+        for (int i = 0; i < 8; i++) {
+            CPPUNIT_ASSERT_MESSAGE("OR CPPUNIT_FAILed to set bits", bs.get(i));
+        }
+    }
+    {
+        BitSet bs(0);
+        bs.OR(eightbs);
+        for (int i = 0; i < 8; i++) {
+            CPPUNIT_ASSERT_MESSAGE("OR(0) CPPUNIT_FAILed to set bits", bs.get(i));
+        }
+    }
+    {
+        eightbs.clear(5);
+        BitSet bs(128);
+        bs.OR(eightbs);
+        CPPUNIT_ASSERT_MESSAGE("OR set a bit which should be off", !bs.get(5));
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testXOR() {
+
+    {
+        BitSet bs = eightbs;
+        bs.XOR(eightbs);
+        for (int i = 0; i < 8; i++) {
+            CPPUNIT_ASSERT_MESSAGE("XOR CPPUNIT_FAILed to clear bits", !bs.get(i));
+        }
+
+        bs.XOR(eightbs);
+        for (int i = 0; i < 8; i++) {
+            CPPUNIT_ASSERT_MESSAGE("XOR CPPUNIT_FAILed to set bits", bs.get(i));
+        }
+    }
+    {
+        BitSet bs(0);
+        bs.XOR(eightbs);
+        for (int i = 0; i < 8; i++) {
+            CPPUNIT_ASSERT_MESSAGE("XOR(0) CPPUNIT_FAILed to set bits", bs.get(i));
+        }
+    }
+    {
+        BitSet bs;
+        bs.set(63);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Test highest bit", std::string("{63}"), bs.toString());
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testSize() {
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect size", 64, eightbs.size());
+    eightbs.set(129);
+    CPPUNIT_ASSERT_MESSAGE("Returned incorrect size", eightbs.size() >= 129);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testToString() {
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect string representation",
+                                 std::string("{0, 1, 2, 3, 4, 5, 6, 7}"), eightbs.toString());
+    eightbs.clear(2);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect string representation",
+                                 std::string("{0, 1, 3, 4, 5, 6, 7}"), eightbs.toString());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testLength() {
+    BitSet bs;
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("BitSet returned wrong length", 0, bs.length());
+    bs.set(5);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("BitSet returned wrong length", 6, bs.length());
+    bs.set(10);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("BitSet returned wrong length", 11, bs.length());
+    bs.set(432);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("BitSet returned wrong length", 433, bs.length());
+    bs.set(300);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("BitSet returned wrong length", 433, bs.length());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testNextSetBitI() {
+    BitSet bs(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);
+        CPPUNIT_FAIL("Expected IndexOutOfBoundsException for negative index");
+    } catch (IndexOutOfBoundsException& e) {
+        // correct behavior
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 5, bs.nextSetBit(0));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 5, bs.nextSetBit(5));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 32, bs.nextSetBit(6));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 32, bs.nextSetBit(32));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 63, bs.nextSetBit(33));
+
+    // boundary tests
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 63, bs.nextSetBit(63));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 64, bs.nextSetBit(64));
+
+    // at bitset element 1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 71, bs.nextSetBit(65));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 71, bs.nextSetBit(71));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 72, bs.nextSetBit(72));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 127, bs.nextSetBit(110));
+
+    // boundary tests
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 127, bs.nextSetBit(127));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 128, bs.nextSetBit(128));
+
+    // at bitset element 2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 193, bs.nextSetBit(130));
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 193, bs.nextSetBit(191));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 193, bs.nextSetBit(192));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 193, bs.nextSetBit(193));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 450, bs.nextSetBit(194));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 450, bs.nextSetBit(255));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 450, bs.nextSetBit(256));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", 450, bs.nextSetBit(450));
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", -1, bs.nextSetBit(451));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", -1, bs.nextSetBit(511));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", -1, bs.nextSetBit(512));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextSetBit() returned the wrong value", -1, bs.nextSetBit(800));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testNextClearBitI() {
+    BitSet bs(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);
+        CPPUNIT_FAIL("Expected IndexOutOfBoundsException for negative index");
+    } catch (IndexOutOfBoundsException& e) {
+        // correct behavior
+    }
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 5, bs.nextClearBit(0));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 5, bs.nextClearBit(5));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 32, bs.nextClearBit(6));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 32, bs.nextClearBit(32));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 63, bs.nextClearBit(33));
+
+    // boundary tests
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 63, bs .nextClearBit(63));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 64, bs .nextClearBit(64));
+
+    // at bitset element 1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 71, bs .nextClearBit(65));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 71, bs .nextClearBit(71));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 72, bs .nextClearBit(72));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 127, bs .nextClearBit(110));
+
+    // boundary tests
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 127, bs .nextClearBit(127));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 128, bs .nextClearBit(128));
+
+    // at bitset element 2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 193, bs .nextClearBit(130));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 193, bs .nextClearBit(191));
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 193, bs .nextClearBit(192));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 193, bs .nextClearBit(193));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 450, bs .nextClearBit(194));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 450, bs .nextClearBit(255));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 450, bs .nextClearBit(256));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("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()
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 512, bs .nextClearBit(451));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 512, bs .nextClearBit(511));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 512, bs .nextClearBit(512));
+
+    // if the index is larger than bs.size(), nextClearBit should return index
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 513, bs .nextClearBit(513));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("nextClearBit() returned the wrong value", 800, bs .nextClearBit(800));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testIsEmpty() {
+    BitSet bs(500);
+    CPPUNIT_ASSERT_MESSAGE("Test: isEmpty() returned wrong value", bs.isEmpty());
+
+    // at bitset element 0
+    bs.set(3);
+    CPPUNIT_ASSERT_MESSAGE("Test0: isEmpty() returned wrong value", !bs.isEmpty());
+
+    // at bitset element 1
+    bs.clear();
+    bs.set(12);
+    CPPUNIT_ASSERT_MESSAGE("Test1: isEmpty() returned wrong value", !bs.isEmpty());
+
+    // at bitset element 2
+    bs.clear();
+    bs.set(128);
+    CPPUNIT_ASSERT_MESSAGE("Test2: isEmpty() returned wrong value", !bs.isEmpty());
+
+    // boundary testing
+    bs.clear();
+    bs.set(459);
+    CPPUNIT_ASSERT_MESSAGE("Test3: isEmpty() returned wrong value", !bs.isEmpty());
+
+    bs.clear();
+    bs.set(511);
+    CPPUNIT_ASSERT_MESSAGE("Test4: isEmpty() returned wrong value", !bs.isEmpty());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSetTest::testCardinality() {
+
+    BitSet bs(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);
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("cardinality() returned wrong value", 48, bs.cardinality());
+
+    bs.flip(0, 500);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("cardinality() returned wrong value", 452, bs.cardinality());
+
+    bs.clear();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("cardinality() returned wrong value", 0, bs.cardinality());
+
+    bs.set(0, 500);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("cardinality() returned wrong value", 500, bs.cardinality());
+
+    bs.clear();
+    bs.set(0, 64);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("cardinality() returned wrong value", 64, bs.cardinality());
+}

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.h?rev=1360895&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.h Thu Jul 12 19:59:01 2012
@@ -0,0 +1,100 @@
+/*
+ * 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.
+ */
+
+#ifndef _DECAF_UTIL_BITSETTEST_H_
+#define _DECAF_UTIL_BITSETTEST_H_
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+namespace decaf {
+namespace util {
+
+    class BitSetTest : public CppUnit::TestFixture {
+
+        CPPUNIT_TEST_SUITE( BitSetTest );
+        CPPUNIT_TEST( testConstructor );
+        CPPUNIT_TEST( testConstructorI );
+        CPPUNIT_TEST( testCopy );
+        CPPUNIT_TEST( testCardinality );
+        CPPUNIT_TEST( testEquals );
+        CPPUNIT_TEST( testClear );
+        CPPUNIT_TEST( testClearI );
+        CPPUNIT_TEST( testClearII );
+        CPPUNIT_TEST( testGetI );
+        CPPUNIT_TEST( testGetII );
+        CPPUNIT_TEST( testFlipI );
+        CPPUNIT_TEST( testFlipII );
+        CPPUNIT_TEST( testSetI );
+        CPPUNIT_TEST( testSetIB );
+        CPPUNIT_TEST( testSetII );
+        CPPUNIT_TEST( testSetIIB );
+        CPPUNIT_TEST( testIsEmpty );
+        CPPUNIT_TEST( testIntersects );
+        CPPUNIT_TEST( testAnd );
+        CPPUNIT_TEST( testAndNot );
+        CPPUNIT_TEST( testOR );
+        CPPUNIT_TEST( testXOR );
+        CPPUNIT_TEST( testSize );
+        CPPUNIT_TEST( testLength );
+        CPPUNIT_TEST( testToString );
+        CPPUNIT_TEST( testNextSetBitI );
+        CPPUNIT_TEST( testNextClearBitI );
+        CPPUNIT_TEST( testNotModified );
+        CPPUNIT_TEST_SUITE_END();
+
+    public:
+
+        BitSetTest();
+        virtual ~BitSetTest();
+
+        virtual void setUp();
+
+        void testConstructor();
+        void testConstructorI();
+        void testCopy();
+        void testEquals();
+        void testCardinality();
+        void testClear();
+        void testClearI();
+        void testClearII();
+        void testGetI();
+        void testGetII();
+        void testFlipI();
+        void testFlipII();
+        void testSetI();
+        void testSetIB();
+        void testSetII();
+        void testSetIIB();
+        void testIsEmpty();
+        void testIntersects();
+        void testAnd();
+        void testAndNot();
+        void testOR();
+        void testXOR();
+        void testSize();
+        void testToString();
+        void testLength();
+        void testNextSetBitI();
+        void testNextClearBitI();
+        void testNotModified();
+
+    };
+
+}}
+
+#endif /* _DECAF_UTIL_BITSETTEST_H_ */

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp?rev=1360895&r1=1360894&r2=1360895&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp Thu Jul 12 19:59:01 2012
@@ -316,6 +316,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION( decaf::
 CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::AbstractListTest );
 #include <decaf/util/AbstractSequentialListTest.h>
 CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::AbstractSequentialListTest );
+#include <decaf/util/BitSetTest.h>
+CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::BitSetTest );
 #include <decaf/util/DateTest.h>
 CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::DateTest );
 #include <decaf/util/UUIDTest.h>



Mime
View raw message