activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r1365840 - in /activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent: ConcurrentStlMapTest.cpp ConcurrentStlMapTest.h
Date Wed, 25 Jul 2012 23:40:51 GMT
Author: tabish
Date: Wed Jul 25 23:40:51 2012
New Revision: 1365840

URL: http://svn.apache.org/viewvc?rev=1365840&view=rev
Log:
Add some additional test cases to the unit tests. 

Modified:
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.cpp
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.h

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.cpp?rev=1365840&r1=1365839&r2=1365840&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.cpp
(original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.cpp
Wed Jul 25 23:40:51 2012
@@ -18,11 +18,80 @@
 #include "ConcurrentStlMapTest.h"
 #include <string>
 #include <decaf/util/concurrent/ConcurrentStlMap.h>
+#include <decaf/util/HashMap.h>
+#include <decaf/util/StlMap.h>
+#include <decaf/util/ArrayList.h>
+#include <decaf/lang/Integer.h>
+#include <decaf/lang/exceptions/IllegalArgumentException.h>
 
 using namespace std;
 using namespace decaf;
 using namespace decaf::util;
 using namespace decaf::util::concurrent;
+using namespace decaf::lang;
+
+////////////////////////////////////////////////////////////////////////////////
+namespace {
+
+    const int MAP_SIZE = 1000;
+
+    void populateMap(StlMap<int, std::string>& map) {
+        for (int i = 0; i < MAP_SIZE; ++i) {
+            map.put(i, Integer::toString(i));
+        }
+    }
+
+    void populateMap(ConcurrentStlMap<int, std::string>& map) {
+        for (int i = 0; i < MAP_SIZE; ++i) {
+            map.put(i, Integer::toString(i));
+        }
+    }
+
+    void populateMap(HashMap<int, std::string>& map) {
+        for (int i = 0; i < MAP_SIZE; ++i) {
+            map.put(i, Integer::toString(i));
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testConstructor() {
+
+    ConcurrentStlMap<string, int> map1;
+    CPPUNIT_ASSERT( map1.isEmpty() );
+    CPPUNIT_ASSERT( map1.size() == 0 );
+
+    CPPUNIT_ASSERT_THROW_MESSAGE(
+        "Should Throw a NoSuchElementException",
+        map1.get( "TEST" ),
+        decaf::util::NoSuchElementException );
+
+    HashMap<string, int> srcMap;
+    srcMap.put( "A", 1 );
+    srcMap.put( "B", 1 );
+    srcMap.put( "C", 1 );
+
+    ConcurrentStlMap<string, int> destMap( srcMap );
+
+    CPPUNIT_ASSERT( srcMap.size() == 3 );
+    CPPUNIT_ASSERT( destMap.size() == 3 );
+    CPPUNIT_ASSERT( destMap.get( "B" ) == 1 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testConstructorMap() {
+
+    ConcurrentStlMap<int, int> myMap;
+    for (int counter = 0; counter < 125; counter++) {
+        myMap.put(counter, counter);
+    }
+
+    ConcurrentStlMap<int, int> map(myMap);
+    for (int counter = 0; counter < 125; counter++) {
+        CPPUNIT_ASSERT_MESSAGE("Failed to construct correct HashMap",
+            myMap.get(counter) == map.get(counter));
+    }
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 void ConcurrentStlMapTest::testContainsKey(){
@@ -46,6 +115,74 @@ void ConcurrentStlMapTest::testClear(){
     CPPUNIT_ASSERT(boolMap.size() == 2 );
     boolMap.clear();
     CPPUNIT_ASSERT(boolMap.size() == 0 );
+
+    {
+        ConcurrentStlMap<int, std::string> map;
+        map.put(1, "one");
+        map.put(3, "three");
+        map.put(2, "two");
+
+        map.clear();
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Clear failed to reset size", 0, map.size());
+        for (int i = 0; i < 125; i++) {
+            CPPUNIT_ASSERT_THROW_MESSAGE(
+                "Failed to clear all elements",
+                map.get(i),
+                NoSuchElementException);
+        }
+
+        // Check clear on a large loaded map of Integer keys
+        ConcurrentStlMap<int, std::string> map2;
+        for (int i = -32767; i < 32768; i++) {
+            map2.put(i, "foobar");
+        }
+        map2.clear();
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to reset size on large integer map", 0, map2.size());
+        for (int i = -32767; i < 32768; i++) {
+            CPPUNIT_ASSERT_THROW_MESSAGE(
+                "Failed to clear all elements",
+                map2.get(i),
+                NoSuchElementException);
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testCopy() {
+
+    ConcurrentStlMap<string, int> destMap;
+    HashMap<string, int> srcMap;
+    ConcurrentStlMap<string, int> srcMap2;
+
+    CPPUNIT_ASSERT( destMap.size() == 0 );
+
+    srcMap.put( "A", 1 );
+    srcMap.put( "B", 2 );
+    srcMap.put( "C", 3 );
+    srcMap.put( "D", 4 );
+    srcMap.put( "E", 5 );
+    srcMap.put( "F", 6 );
+
+    destMap.copy( srcMap );
+    CPPUNIT_ASSERT( destMap.size() == 6 );
+    CPPUNIT_ASSERT( destMap.get( "A" ) == 1 );
+    CPPUNIT_ASSERT( destMap.get( "B" ) == 2 );
+    CPPUNIT_ASSERT( destMap.get( "C" ) == 3 );
+    CPPUNIT_ASSERT( destMap.get( "D" ) == 4 );
+    CPPUNIT_ASSERT( destMap.get( "E" ) == 5 );
+    CPPUNIT_ASSERT( destMap.get( "F" ) == 6 );
+
+    destMap.copy( srcMap2 );
+    CPPUNIT_ASSERT( destMap.size() == 0 );
+
+    srcMap2.put( "A", 1 );
+    srcMap2.put( "B", 2 );
+    srcMap2.put( "C", 3 );
+    srcMap2.put( "D", 4 );
+    srcMap2.put( "E", 5 );
+
+    destMap.copy( srcMap2 );
+    CPPUNIT_ASSERT( destMap.size() == 5 );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -73,7 +210,67 @@ void ConcurrentStlMapTest::testSize(){
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ConcurrentStlMapTest::testValue(){
+void ConcurrentStlMapTest::testGet() {
+
+    ConcurrentStlMap<string, bool> boolMap;
+
+    boolMap.put( "fred", true );
+    CPPUNIT_ASSERT( boolMap.get("fred") == true );
+
+    boolMap.put( "bob", false );
+    CPPUNIT_ASSERT( boolMap.get("bob") == false );
+    CPPUNIT_ASSERT( boolMap.get("fred") == true );
+
+    try{
+        boolMap.get( "mike" );
+        CPPUNIT_ASSERT(false);
+    } catch( decaf::util::NoSuchElementException& e ){
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testPut() {
+
+    ConcurrentStlMap<string, bool> boolMap;
+
+    boolMap.put( "fred", true );
+    CPPUNIT_ASSERT( boolMap.get("fred") == true );
+
+    boolMap.put( "bob", false );
+    CPPUNIT_ASSERT( boolMap.get("bob") == false );
+    CPPUNIT_ASSERT( boolMap.get("fred") == true );
+
+    boolMap.put( "bob", true );
+    CPPUNIT_ASSERT( boolMap.get("bob") == true );
+    CPPUNIT_ASSERT( boolMap.get("fred") == true );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testPutAll() {
+
+    ConcurrentStlMap<string, int> destMap;
+    HashMap<string, int> srcMap;
+    HashMap<string, int> srcMap2;
+
+    srcMap.put( "A", 1 );
+    srcMap.put( "B", 1 );
+    srcMap.put( "C", 1 );
+
+    CPPUNIT_ASSERT( srcMap.size() == 3 );
+    CPPUNIT_ASSERT( destMap.size() == 0 );
+
+    srcMap.put( "D", 1 );
+    srcMap.put( "E", 1 );
+    srcMap.put( "F", 1 );
+
+    destMap.putAll( srcMap );
+    CPPUNIT_ASSERT( destMap.size() == 6 );
+    destMap.putAll( srcMap2 );
+    CPPUNIT_ASSERT( destMap.size() == 6 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testValue() {
 
     ConcurrentStlMap<string, bool> boolMap;
 
@@ -111,3 +308,114 @@ void ConcurrentStlMapTest::testContiansV
     boolMap.remove( "fred" );
     CPPUNIT_ASSERT( boolMap.containsValue(true) == false );
 }
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testEntrySet() {
+
+    ConcurrentStlMap<int, std::string> map;
+
+    for (int i = 0; i < 50; i++) {
+        map.put(i, Integer::toString(i));
+    }
+
+    Set<MapEntry<int, std::string> >& set = map.entrySet();
+    Pointer< Iterator<MapEntry<int, std::string> > > iterator(set.iterator());
+
+    CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size", map.size() == set.size());
+    while (iterator->hasNext()) {
+        MapEntry<int, std::string> entry = iterator->next();
+        CPPUNIT_ASSERT_MESSAGE("Returned incorrect entry set",
+                               map.containsKey(entry.getKey()) && map.containsValue(entry.getValue()));
+    }
+
+    iterator.reset(set.iterator());
+    set.remove(iterator->next());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Remove on set didn't take", 49, set.size());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testKeySet() {
+
+    ConcurrentStlMap<int, std::string> map;
+    populateMap(map);
+    Set<int>& set = map.keySet();
+    CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size()", set.size() == map.size());
+    for (int i = 0; i < MAP_SIZE; i++) {
+        CPPUNIT_ASSERT_MESSAGE("Returned set does not contain all keys", set.contains(i));
+    }
+
+    {
+        ConcurrentStlMap<int, std::string> localMap;
+        localMap.put(0, "test");
+        Set<int>& intSet = localMap.keySet();
+        CPPUNIT_ASSERT_MESSAGE("Failed with zero key", intSet.contains(0));
+    }
+    {
+        ConcurrentStlMap<int, std::string> localMap;
+        localMap.put(1, "1");
+        localMap.put(102, "102");
+        localMap.put(203, "203");
+
+        Set<int>& intSet = localMap.keySet();
+        Pointer< Iterator<int> > it(intSet.iterator());
+        int remove1 = it->next();
+        it->hasNext();
+        it->remove();
+        int remove2 = it->next();
+        it->remove();
+
+        ArrayList<int> list;
+        list.add(1);
+        list.add(102);
+        list.add(203);
+
+        list.remove(remove1);
+        list.remove(remove2);
+
+        CPPUNIT_ASSERT_MESSAGE("Wrong result", it->next() == list.get(0));
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong size", 1, localMap.size());
+        it.reset(intSet.iterator());
+        CPPUNIT_ASSERT_MESSAGE("Wrong contents", it->next() == list.get(0));
+    }
+    {
+        ConcurrentStlMap<int, std::string> map2;
+        map2.put(1, "1");
+        map2.put(4, "4");
+
+        Set<int>& intSet = map2.keySet();
+        Pointer< Iterator<int> > it2(intSet.iterator());
+
+        int remove3 = it2->next();
+        int next;
+
+        if (remove3 == 1) {
+            next = 4;
+        } else {
+            next = 1;
+        }
+        it2->hasNext();
+        it2->remove();
+        CPPUNIT_ASSERT_MESSAGE("Wrong result 2", it2->next() == next);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong size 2", 1, map2.size());
+        it2.reset(intSet.iterator());
+        CPPUNIT_ASSERT_MESSAGE("Wrong contents 2", it2->next() == next);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ConcurrentStlMapTest::testValues() {
+
+    ConcurrentStlMap<int, std::string> map;
+    populateMap(map);
+
+    Collection<std::string>& c = map.values();
+    CPPUNIT_ASSERT_MESSAGE("Returned collection of incorrect size()", c.size() == map.size());
+    for (int i = 0; i < MAP_SIZE; i++) {
+        CPPUNIT_ASSERT_MESSAGE("Returned collection does not contain all keys",
+                               c.contains(Integer::toString(i)));
+    }
+
+    c.remove("10");
+    CPPUNIT_ASSERT_MESSAGE("Removing from collection should alter Map",
+                           !map.containsKey(10));
+}

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.h?rev=1365840&r1=1365839&r2=1365840&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.h
(original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ConcurrentStlMapTest.h
Wed Jul 25 23:40:51 2012
@@ -28,13 +28,22 @@ namespace concurrent {
     class ConcurrentStlMapTest : public CppUnit::TestFixture
     {
         CPPUNIT_TEST_SUITE( ConcurrentStlMapTest );
+        CPPUNIT_TEST( testConstructor );
+        CPPUNIT_TEST( testConstructorMap );
         CPPUNIT_TEST( testContainsKey );
         CPPUNIT_TEST( testClear );
+        CPPUNIT_TEST( testCopy );
         CPPUNIT_TEST( testSize );
         CPPUNIT_TEST( testValue );
+        CPPUNIT_TEST( testGet );
+        CPPUNIT_TEST( testPut );
+        CPPUNIT_TEST( testPutAll );
         CPPUNIT_TEST( testRemove );
         CPPUNIT_TEST( testContiansValue );
         CPPUNIT_TEST( testIsEmpty );
+        CPPUNIT_TEST( testEntrySet );
+        CPPUNIT_TEST( testKeySet );
+        CPPUNIT_TEST( testValues );
         CPPUNIT_TEST_SUITE_END();
 
     public:
@@ -42,13 +51,22 @@ namespace concurrent {
         ConcurrentStlMapTest() {}
         virtual ~ConcurrentStlMapTest() {}
 
+        void testConstructor();
+        void testConstructorMap();
         void testContainsKey();
         void testClear();
+        void testCopy();
         void testSize();
         void testValue();
+        void testGet();
+        void testPut();
+        void testPutAll();
         void testRemove();
         void testContiansValue();
         void testIsEmpty();
+        void testEntrySet();
+        void testKeySet();
+        void testValues();
 
     };
 



Mime
View raw message