--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/cppstdlib/stl/test/unit/hash_test.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,1192 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <vector>
+#include <algorithm>
+#include <e32std.h>
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <hash_map>
+# include <hash_set>
+# include <rope>
+# endif
+
+#include <string>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if defined (__MVS__)
+const char star = 92;
+#else
+const char star = 42;
+#endif
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class HashTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(HashTest);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(hmap1);
+ CPPUNIT_TEST(hmmap1);
+ CPPUNIT_TEST(hmset1);
+ CPPUNIT_TEST(hset2);
+ CPPUNIT_TEST(insert_erase);
+ CPPUNIT_TEST(allocator_with_state);
+ CPPUNIT_TEST(hash_map_cov1);
+ CPPUNIT_TEST(hash_map_cov2);
+ CPPUNIT_TEST(hash_map_cov3);
+ CPPUNIT_TEST(hash_map_cov4);
+ CPPUNIT_TEST(hash_map_cov5);
+ CPPUNIT_TEST(hash_map_cov6);
+ CPPUNIT_TEST(hash_multimap_cov1);
+ CPPUNIT_TEST(hash_multimap_cov2);
+ CPPUNIT_TEST(hash_multimap_cov3);
+ CPPUNIT_TEST(hash_set_cov1);
+ CPPUNIT_TEST(hash_set_cov2);
+ CPPUNIT_TEST(hash_set_cov3);
+ CPPUNIT_TEST(hash_set_cov4);
+ CPPUNIT_TEST(hash_set_cov5);
+ CPPUNIT_TEST(hash_set_cov6);
+ CPPUNIT_TEST(hash_multiset_cov1);
+ CPPUNIT_TEST(hash_multiset_cov2);
+ CPPUNIT_TEST(hash_multiset_cov3);
+ //CPPUNIT_TEST(equality);
+ CPPUNIT_TEST_SUITE_END();
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_multiset<char, hash<char>, equal_to<char> > hmset;
+#endif
+
+protected:
+ void hmap1();
+ void hmmap1();
+ void hmset1();
+ void hset2();
+ void insert_erase();
+ void hash_map_cov1();
+ void hash_map_cov2();
+ void hash_map_cov3();
+ void hash_map_cov4();
+ void hash_map_cov5();
+ void hash_map_cov6();
+ void hash_multimap_cov1();
+ void hash_multimap_cov2();
+ void hash_multimap_cov3();
+ void hash_set_cov1();
+ void hash_set_cov2();
+ void hash_set_cov3();
+ void hash_set_cov4();
+ void hash_set_cov5();
+ void hash_set_cov6();
+ void hash_multiset_cov1();
+ void hash_multiset_cov2();
+ void hash_multiset_cov3();
+ //void equality();
+ void allocator_with_state();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(HashTest);
+
+//
+// tests implementation
+//
+void HashTest::hmap1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_map<char, crope, hash<char>, equal_to<char> > maptype;
+ maptype m;
+ // Store mappings between roman numerals and decimals.
+ m['l'] = "50";
+ m['x'] = "20"; // Deliberate mistake.
+ m['v'] = "5";
+ m['i'] = "1";
+ CPPUNIT_ASSERT( !strcmp(m['x'].c_str(),"20") );
+ m['x'] = "10"; // Correct mistake.
+ CPPUNIT_ASSERT( !strcmp(m['x'].c_str(),"10") );
+
+ CPPUNIT_ASSERT( !strcmp(m['z'].c_str(),"") );
+
+ CPPUNIT_ASSERT( m.count('z')==1 );
+ pair<maptype::iterator, bool> p = m.insert(pair<const char, crope>('c', crope("100")));
+
+ CPPUNIT_ASSERT(p.second);
+
+ p = m.insert(pair<const char, crope>('c', crope("100")));
+ CPPUNIT_ASSERT(!p.second);
+
+ //Some iterators compare check, really compile time checks
+ maptype::iterator ite(m.begin());
+ maptype::const_iterator cite(m.begin());
+ cite = m.begin();
+ maptype const& cm = m;
+ cite = cm.begin();
+ CPPUNIT_ASSERT( ite == cite );
+ CPPUNIT_ASSERT( !(ite != cite) );
+ CPPUNIT_ASSERT( cite == ite );
+ CPPUNIT_ASSERT( !(cite != ite) );
+#endif
+}
+
+void HashTest::hmmap1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_multimap<char, int, hash<char>,equal_to<char> > mmap;
+ mmap m;
+ CPPUNIT_ASSERT(m.count('X')==0);
+ m.insert(pair<const char,int>('X', 10)); // Standard way.
+ CPPUNIT_ASSERT(m.count('X')==1);
+// m.insert('X', 20); // Non-standard, but very convenient!
+ m.insert(pair<const char,int>('X', 20)); // jbuck: standard way
+ CPPUNIT_ASSERT(m.count('X')==2);
+// m.insert('Y', 32);
+ m.insert(pair<const char,int>('Y', 32)); // jbuck: standard way
+ mmap::iterator i = m.find('X'); // Find first match.
+
+ CPPUNIT_ASSERT((*i).first=='X');
+ CPPUNIT_ASSERT((*i).second==10);
+ i++;
+ CPPUNIT_ASSERT((*i).first=='X');
+ CPPUNIT_ASSERT((*i).second==20);
+ i++;
+ CPPUNIT_ASSERT((*i).first=='Y');
+ CPPUNIT_ASSERT((*i).second==32);
+ i++;
+ CPPUNIT_ASSERT(i==m.end());
+
+ size_t count = m.erase('X');
+ CPPUNIT_ASSERT(count==2);
+
+ //Some iterators compare check, really compile time checks
+ mmap::iterator ite(m.begin());
+ mmap::const_iterator cite(m.begin());
+ CPPUNIT_ASSERT( ite == cite );
+ CPPUNIT_ASSERT( !(ite != cite) );
+ CPPUNIT_ASSERT( cite == ite );
+ CPPUNIT_ASSERT( !(cite != ite) );
+
+ typedef hash_multimap<size_t, size_t> HMapType;
+ HMapType hmap;
+
+ //We fill the map to implicitely start a rehash.
+ for (size_t counter = 0; counter < 3077; ++counter)
+ hmap.insert(HMapType::value_type(1, counter));
+
+ hmap.insert(HMapType::value_type(12325, 1));
+ hmap.insert(HMapType::value_type(12325, 2));
+
+ CPPUNIT_ASSERT( hmap.count(12325) == 2 );
+
+ //At this point 23 goes to the same bucket as 12325, it used to reveal a bug.
+ hmap.insert(HMapType::value_type(23, 0));
+
+ CPPUNIT_ASSERT( hmap.count(12325) == 2 );
+#endif
+}
+
+void HashTest::hmset1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ hmset s;
+ CPPUNIT_ASSERT( s.count(star) == 0 );
+ s.insert(star);
+ CPPUNIT_ASSERT( s.count(star) == 1 );
+ s.insert(star);
+ CPPUNIT_ASSERT( s.count(star) == 2 );
+ hmset::iterator i = s.find(char(40));
+ CPPUNIT_ASSERT( i == s.end() );
+
+ i = s.find(star);
+ CPPUNIT_ASSERT( i != s.end() )
+ CPPUNIT_ASSERT( *i == '*' );
+ CPPUNIT_ASSERT( s.erase(star) == 2 );
+#endif
+}
+void HashTest::hset2()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ hash_set<int, hash<int>, equal_to<int> > s;
+ pair<hash_set<int, hash<int>, equal_to<int> >::iterator, bool> p = s.insert(42);
+ CPPUNIT_ASSERT( p.second );
+ CPPUNIT_ASSERT( *(p.first) == 42 );
+
+ p = s.insert(42);
+ CPPUNIT_ASSERT( !p.second );
+#endif
+}
+
+void HashTest::insert_erase()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_map<string, size_t, hash<string>, equal_to<string> > hmap;
+ typedef hmap::value_type val_type;
+ {
+ hmap values;
+ CPPUNIT_ASSERT( values.insert(val_type("foo", 0)).second );
+ CPPUNIT_ASSERT( values.insert(val_type("bar", 0)).second );
+ CPPUNIT_ASSERT( values.insert(val_type("abc", 0)).second );
+
+ CPPUNIT_ASSERT( values.erase("foo") == 1 );
+ CPPUNIT_ASSERT( values.erase("bar") == 1 );
+ CPPUNIT_ASSERT( values.erase("abc") == 1 );
+ }
+
+ {
+ hmap values;
+ CPPUNIT_ASSERT( values.insert(val_type("foo", 0)).second );
+ CPPUNIT_ASSERT( values.insert(val_type("bar", 0)).second );
+ CPPUNIT_ASSERT( values.insert(val_type("abc", 0)).second );
+
+ CPPUNIT_ASSERT( values.erase("abc") == 1 );
+ CPPUNIT_ASSERT( values.erase("bar") == 1 );
+ CPPUNIT_ASSERT( values.erase("foo") == 1 );
+ }
+#endif
+}
+
+/*
+ * Here is the test showing why equality operator on hash containers
+ * has no meaning:
+
+struct equality_hash_func {
+ size_t operator () (size_t val) const {
+ return val % 10;
+ }
+};
+
+void HashTest::equality()
+{
+ hash_set<size_t, equality_hash_func, equal_to<size_t> > s1, s2;
+
+ s1.insert(10);
+ s1.insert(20);
+
+ s2.insert(20);
+ s2.insert(10);
+
+ //s1 and s2 contains both 10 and 20:
+ CPPUNIT_ASSERT( s1 == s2 );
+}
+*/
+
+void HashTest::allocator_with_state()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ char buf1[2048];
+ StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[2048];
+ StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
+
+ {
+ typedef hash_set<int, hash<int>, equal_to<int>, StackAllocator<int> > HashSetInt;
+ HashSetInt hint1(10, hash<int>(), equal_to<int>(), stack1);
+
+ int i;
+ for (i = 0; i < 5; ++i)
+ hint1.insert(i);
+ HashSetInt hint1Cpy(hint1);
+
+ HashSetInt hint2(10, hash<int>(), equal_to<int>(), stack2);
+ for (; i < 10; ++i)
+ hint2.insert(i);
+ HashSetInt hint2Cpy(hint2);
+
+ hint1.swap(hint2);
+
+ CPPUNIT_ASSERT( hint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( hint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( hint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( hint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+#endif
+}
+void HashTest::hash_map_cov1()
+ {
+ __UHEAP_MARK;
+ {
+ hash_map <int, int> hm1, hm2;
+ hash_map <int, int>::iterator hm1_Iter;
+ hash_map <int, int>::const_iterator hm1_cIter;
+ typedef pair <int, int> Int_Pair;
+
+ hm1.insert ( Int_Pair ( 1, 10 ) );
+ hm1.insert ( Int_Pair ( 2, 20 ) );
+ hm1.insert ( Int_Pair ( 3, 30 ) );
+ hm2.insert ( Int_Pair ( 30, 300 ) );
+
+ hm1.swap( hm2 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( hm1_Iter -> second == 300);
+ hm1_Iter = hm1.end( );
+
+ hm1_cIter = hm1.end( );
+ hm1.clear();
+ CPPUNIT_ASSERT( hm1.size() == 0 );
+ CPPUNIT_ASSERT( hm1.empty() == true );
+ }
+ {
+ hash_map <int, int> hm1, hm2;
+ hash_map <int, int>::iterator hm1_Iter;
+ hash_map <int, int>::const_iterator hm1_cIter;
+ typedef pair <int, int> Int_Pair;
+
+ hm1.insert ( Int_Pair ( 1, 10 ) );
+ hm1.insert ( Int_Pair ( 2, 20 ) );
+ hm1.insert ( Int_Pair ( 3, 30 ) );
+ hm2.insert ( Int_Pair ( 30, 300 ) );
+
+ swap( hm1,hm2 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( hm1_Iter -> second == 300);
+ hm1_Iter = hm1.end( );
+
+ hm1_cIter = hm1.end( );
+ hm1.clear();
+ CPPUNIT_ASSERT( hm1.size() == 0 );
+ CPPUNIT_ASSERT( hm1.empty() == true );
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_map_cov2()
+ {
+ __UHEAP_MARK;
+ {
+ hash_map <int, int> hm1;
+ int i,bcount;
+ typedef pair <int, int> Int_Pair;
+
+ hm1.insert ( Int_Pair ( 1, 1 ) );
+ i = hm1.size( );
+ CPPUNIT_ASSERT( i == 1);
+
+ i = hm1.max_size(); // for covering the api
+
+ hm1.insert ( Int_Pair ( 2, 4 ) );
+ i = hm1.size( );
+ CPPUNIT_ASSERT( i == 2);
+ hm1.resize(10);
+ bcount = hm1.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 10);
+ hm1.elems_in_bucket(1);
+ }
+ {
+ typedef hash_multimap<int, int> mmap;
+ mmap m;
+
+ typedef pair <int, int> Int_Pair;
+ m.insert ( Int_Pair ( 1, 10 ) );
+ m.insert ( Int_Pair ( 2, 20 ) );
+ m.insert ( Int_Pair ( 3, 30 ) );
+
+ std::pair<mmap::iterator, mmap::iterator> pair1 = m.equal_range(2);
+ CPPUNIT_ASSERT( pair1.first->first == 2);
+ CPPUNIT_ASSERT( pair1.first->second == 20);
+ std::pair<mmap::const_iterator, mmap::const_iterator> pair2 = m.equal_range(1);
+ CPPUNIT_ASSERT( pair2.first->first == 1);
+ CPPUNIT_ASSERT( pair2.first->second == 10);
+ }
+ {
+ typedef hash_multimap<int, int> mmap;
+ mmap m;
+
+ typedef pair <int, int> Int_Pair;
+ m.insert ( Int_Pair ( 1, 10 ) );
+ m.insert ( Int_Pair ( 2, 20 ) );
+ m.insert ( Int_Pair ( 3, 30 ) );
+
+ m.erase(m.begin());
+ mmap::iterator i1 = m.begin();
+ CPPUNIT_ASSERT( i1 -> second == 20);
+ CPPUNIT_ASSERT( m.size() == 2 );
+ m.erase(m.begin(),m.end());
+ CPPUNIT_ASSERT( m.size() == 0 );
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_map_cov3()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_multimap<int, int> mmap;
+ mmap m;
+
+ typedef pair <int, int> Int_Pair;
+ m.insert ( Int_Pair ( 1, 10 ) );
+ m.insert ( Int_Pair ( 2, 20 ) );
+ m.insert ( Int_Pair ( 3, 30 ) );
+
+ mmap::iterator i1 = m.find(1);
+ CPPUNIT_ASSERT( i1 -> second == 10);
+ mmap::const_iterator i2 = m.find(3);
+ CPPUNIT_ASSERT( i2 -> second == 30);
+
+ // negative test case where the element to find is not present in the
+ // hash , so it returns the successive element of the last element.
+ mmap::iterator i3 = m.find(4);
+ mmap::iterator i4 = m.end();
+ CPPUNIT_ASSERT( i3 == i4);
+ }
+ {
+ typedef hash_multimap<int, int> mmap;
+ typedef allocator<std::pair<int, int> > Myalloc;
+ mmap m;
+
+ mmap::allocator_type al = m.get_allocator();
+ CPPUNIT_ASSERT ((al == Myalloc()) == true);
+
+ mmap::hasher hfn = m.hash_funct(); // returns the hasher function
+ }
+ {
+ typedef hash_multimap<int, int> mmap;
+ mmap m1,m2;
+
+ typedef pair <int, int> Int_Pair;
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+
+ m2.insert ( m1.begin(),m1.end());
+ mmap::iterator i1 = m2.begin();
+ CPPUNIT_ASSERT( i1 -> second == 10);
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_map_cov4()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_map<int, int> mmap;
+ mmap m;
+ typedef pair <int, int> Int_Pair;
+ m.insert ( Int_Pair ( 1, 10 ) );
+ m.insert ( Int_Pair ( 2, 20 ) );
+ m.insert ( Int_Pair ( 3, 30 ) );
+
+ std::pair<mmap::iterator, mmap::iterator> pair1 = m.equal_range(2);
+ CPPUNIT_ASSERT( pair1.first->first == 2);
+ CPPUNIT_ASSERT( pair1.first->second == 20);
+ std::pair<mmap::const_iterator, mmap::const_iterator> pair2 = m.equal_range(1);
+ CPPUNIT_ASSERT( pair2.first->first == 1);
+ CPPUNIT_ASSERT( pair2.first->second == 10);
+ }
+ {
+ typedef hash_map<int, int> mmap;
+ mmap m;
+ typedef pair <int, int> Int_Pair;
+ m.insert ( Int_Pair ( 1, 10 ) );
+ m.insert ( Int_Pair ( 2, 20 ) );
+ m.insert ( Int_Pair ( 3, 30 ) );
+
+ m.erase(m.begin());
+ mmap::iterator i1 = m.begin();
+ CPPUNIT_ASSERT( i1 -> second == 20);
+ CPPUNIT_ASSERT( m.size() == 2 );
+ m.erase(m.begin(),m.end());
+ CPPUNIT_ASSERT( m.size() == 0 );
+ }
+ {
+ typedef hash_map<int, int> mmap;
+ mmap m;
+
+ typedef pair <int, int> Int_Pair;
+ m.insert ( Int_Pair ( 1, 10 ) );
+ m.insert ( Int_Pair ( 2, 20 ) );
+ m.insert ( Int_Pair ( 3, 30 ) );
+
+ mmap::iterator i1 = m.find(1);
+ CPPUNIT_ASSERT( i1 -> second == 10);
+ mmap::const_iterator i2 = m.find(3);
+ CPPUNIT_ASSERT( i2 -> second == 30);
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_map_cov5()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_map<int, int> mmap;
+ typedef allocator<std::pair<int, int> > Myalloc;
+ mmap m;
+ mmap::allocator_type al = m.get_allocator();
+ CPPUNIT_ASSERT ((al == Myalloc()) == true);
+
+ mmap::hasher hfn = m.hash_funct(); // returns the hasher function
+ }
+ {
+ typedef hash_map<int, int> mmap;
+ mmap m1,m2;
+
+ typedef pair <int, int> Int_Pair;
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+
+ m2.insert ( m1.begin(),m1.end());
+ mmap::iterator i1 = m2.begin();
+ CPPUNIT_ASSERT( i1 -> second == 10);
+ }
+ {
+ typedef hash_map<char, int> mmap;
+ mmap c1;
+ mmap::key_equal cmpfn = c1.key_eq();
+ CPPUNIT_ASSERT( cmpfn('a','a') == true);
+
+ c1.max_bucket_count(); // for covering the api
+ }
+ {
+ typedef hash_map<int, int> mmap;
+ mmap m1;
+ typedef pair <int, int> Int_Pair;
+ m1.insert_noresize ( Int_Pair ( 1, 10 ) );
+ m1.insert_noresize ( Int_Pair ( 2, 20 ) );
+ m1.insert_noresize ( Int_Pair ( 3, 30 ) );
+
+ mmap::iterator i1 = m1.begin();
+ CPPUNIT_ASSERT( i1 -> second == 10);
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_map_cov6()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_map<int, int> mmap;
+ mmap m1;
+ int bcount;
+
+ typedef pair <int, int> Int_Pair;
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+
+ mmap m2(m1);
+ mmap::iterator i1 = m2.begin();
+ CPPUNIT_ASSERT( i1 -> second == 10);
+
+ mmap m3(10);
+ bcount = m3.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 10);
+
+ mmap::hasher hfn = m1.hash_funct();
+ mmap m4(20,hfn);
+ bcount = m4.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 20);
+
+ mmap m5(m1.begin(),m2.end());
+ CPPUNIT_ASSERT( m5.size() == 3);
+
+ mmap m6(m1.begin(),m2.end(),30);
+ CPPUNIT_ASSERT( m6.size() == 3);
+ bcount = m6.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 30);
+
+ mmap m7(m1.begin(),m2.end(),30,hfn);
+ CPPUNIT_ASSERT( m7.size() == 3);
+ bcount = m7.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 30);
+
+ mmap::key_equal cmpfn;// = c1.key_eq();
+ mmap m8(m1.begin(),m2.end(),30,hfn,cmpfn);
+
+ mmap m9(30,hfn,cmpfn);
+ }
+ __UHEAP_MARKEND;
+ }
+
+void HashTest::hash_multimap_cov1()
+ {
+ __UHEAP_MARK;
+ {
+ hash_multimap <int, int> hm1, hm2;
+ hash_multimap <int, int>::iterator hm1_Iter;
+ hash_multimap <int, int>::const_iterator hm1_cIter;
+ typedef pair <int, int> Int_Pair;
+
+ hm1.insert ( Int_Pair ( 1, 10 ) );
+ hm1.insert ( Int_Pair ( 2, 20 ) );
+ hm1.insert ( Int_Pair ( 3, 30 ) );
+ hm2.insert ( Int_Pair ( 30, 300 ) );
+
+ hm1.swap( hm2 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( hm1_Iter -> second == 300);
+ hm1_Iter = hm1.end( );
+ hm1_cIter = hm1.end( );
+ hm1.clear();
+ CPPUNIT_ASSERT( hm1.size() == 0 );
+ CPPUNIT_ASSERT( hm1.empty() == true );
+ }
+ {
+ hash_multimap <int, int> hm1, hm2;
+ hash_multimap <int, int>::iterator hm1_Iter;
+ hash_multimap <int, int>::const_iterator hm1_cIter;
+ typedef pair <int, int> Int_Pair;
+
+ hm1.insert ( Int_Pair ( 1, 10 ) );
+ hm1.insert ( Int_Pair ( 2, 20 ) );
+ hm1.insert ( Int_Pair ( 3, 30 ) );
+ hm2.insert ( Int_Pair ( 30, 300 ) );
+
+ swap( hm1,hm2 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( hm1_Iter -> second == 300);
+ hm1_Iter = hm1.end( );
+ hm1_cIter = hm1.end( );
+ hm1.clear();
+ CPPUNIT_ASSERT( hm1.size() == 0 );
+ CPPUNIT_ASSERT( hm1.empty() == true );
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_multimap_cov2()
+ {
+ __UHEAP_MARK;
+ {
+ hash_multimap <int, int> hm1;
+ int i,bcount;
+ typedef pair <int, int> Int_Pair;
+
+ hm1.insert ( Int_Pair ( 1, 1 ) );
+ i = hm1.size( );
+ CPPUNIT_ASSERT( i == 1);
+
+ i = hm1.max_size(); // for covering the api
+
+ hm1.insert ( Int_Pair ( 2, 4 ) );
+ i = hm1.size( );
+ CPPUNIT_ASSERT( i == 2);
+ hm1.resize(10);
+ bcount = hm1.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 10);
+ hm1.elems_in_bucket(1);
+ }
+ {
+ typedef hash_multimap<int, int> mmap;
+ mmap m1;
+
+ typedef pair <int, int> Int_Pair;
+ m1.insert_noresize ( Int_Pair ( 1, 10 ) );
+ m1.insert_noresize ( Int_Pair ( 2, 20 ) );
+ m1.insert_noresize ( Int_Pair ( 3, 30 ) );
+
+ mmap::iterator i1 = m1.begin();
+ CPPUNIT_ASSERT( i1 -> second == 10);
+ }
+ {
+ typedef hash_multimap<char, int> mmap;
+ mmap c1;
+ mmap::key_equal cmpfn = c1.key_eq();
+ CPPUNIT_ASSERT( cmpfn('a','a') == true);
+
+ c1.max_bucket_count(); // for covering the api
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_multimap_cov3()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_multimap<int, int> mmap;
+ mmap m1;
+ int bcount;
+
+ typedef pair <int, int> Int_Pair;
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+
+ mmap m2(m1);
+ mmap::iterator i1 = m2.begin();
+ CPPUNIT_ASSERT( i1 -> second == 10);
+
+ mmap m3(10);
+ bcount = m3.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 10);
+
+ mmap::hasher hfn = m1.hash_funct();
+ mmap m4(20,hfn);
+ bcount = m4.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 20);
+
+ mmap m5(m1.begin(),m2.end());
+ CPPUNIT_ASSERT( m5.size() == 3);
+
+ mmap m6(m1.begin(),m2.end(),30);
+ CPPUNIT_ASSERT( m6.size() == 3);
+ bcount = m6.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 30);
+
+ mmap m7(m1.begin(),m2.end(),30,hfn);
+ CPPUNIT_ASSERT( m7.size() == 3);
+ bcount = m7.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 30);
+
+ mmap::key_equal cmpfn;
+ mmap m8(m1.begin(),m2.end(),30,hfn,cmpfn);
+
+ mmap m9(30,hfn,cmpfn);
+ }
+ __UHEAP_MARKEND;
+ }
+
+void HashTest::hash_set_cov1()
+ {
+ __UHEAP_MARK;
+ {
+ hash_set <int> hm1, hm2;
+ hash_set <int>::iterator hm1_Iter;
+ hash_set <int>::const_iterator hm1_cIter;
+
+ hm1.insert ( 10 );
+ hm1.insert ( 20 );
+ hm1.insert ( 30 );
+ hm2.insert ( 300 );
+
+ hm1.swap( hm2 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( *hm1_Iter == 300);
+ hm1_Iter = hm1.end( );
+ hm1_cIter = hm1.end( );
+ hm1.clear();
+ CPPUNIT_ASSERT( hm1.size() == 0 );
+ CPPUNIT_ASSERT( hm1.empty() == true );
+ }
+ {
+ hash_set <int> hm1, hm2;
+ hash_set <int>::iterator hm1_Iter;
+ hash_set <int>::const_iterator hm1_cIter;
+
+ hm1.insert ( 10 );
+ hm1.insert ( 20 );
+ hm1.insert ( 30 );
+ hm2.insert ( 300 );
+
+ swap( hm1,hm2 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( *hm1_Iter == 300);
+ hm1_Iter = hm1.end( );
+ hm1_cIter = hm1.end( );
+ hm1.clear();
+ CPPUNIT_ASSERT( hm1.size() == 0 );
+ CPPUNIT_ASSERT( hm1.empty() == true );
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_set_cov2()
+ {
+ __UHEAP_MARK;
+ {
+ hash_set <int> hm1;
+ int i,bcount;
+
+ hm1.insert ( 1 );
+ i = hm1.size( );
+ CPPUNIT_ASSERT( i == 1);
+
+ i = hm1.max_size(); // for covering the api
+
+ hm1.insert ( 4 );
+ i = hm1.size( );
+ CPPUNIT_ASSERT( i == 2);
+ hm1.resize(10);
+ bcount = hm1.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 10);
+ hm1.elems_in_bucket(1);
+ }
+ {
+ typedef hash_multiset<int> mmap;
+ mmap m;
+
+ m.insert ( 10 );
+ m.insert ( 20 );
+ m.insert ( 30 );
+
+ std::pair<mmap::iterator, mmap::iterator> pair1 = m.equal_range(20);
+ CPPUNIT_ASSERT( *(pair1.first) == 20);
+ CPPUNIT_ASSERT( *(pair1.second) == 30);
+ // negative test case for equal_range where the key value is not present.
+ std::pair<mmap::const_iterator, mmap::const_iterator> pair2 = m.equal_range(40);
+ CPPUNIT_ASSERT( pair2.first == m.end());
+ CPPUNIT_ASSERT( pair2.second == m.end());
+ }
+ {
+ typedef hash_multiset<int> mmap;
+ mmap m;
+
+ m.insert ( 10 );
+ m.insert ( 20 );
+ m.insert ( 30 );
+
+ m.erase(m.begin());
+ mmap::iterator i1 = m.begin();
+ CPPUNIT_ASSERT( *i1 == 20);
+ CPPUNIT_ASSERT( m.size() == 2 );
+ m.erase(m.begin(),m.end());
+ CPPUNIT_ASSERT( m.size() == 0 );
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_set_cov3()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_multiset<int> mmap;
+ mmap m;
+
+ m.insert ( 10 );
+ m.insert ( 20 );
+ m.insert ( 30 );
+
+ mmap::iterator i1 = m.find(10);
+ CPPUNIT_ASSERT( *i1 == 10);
+ mmap::const_iterator i2 = m.find(30);
+ CPPUNIT_ASSERT( *i2 == 30);
+ }
+ {
+ typedef hash_multiset<int> mmap;
+ typedef allocator<std::pair<int, int> > Myalloc;
+ mmap m;
+
+ mmap::allocator_type al = m.get_allocator();
+ CPPUNIT_ASSERT ((al == Myalloc()) == true);
+
+ mmap::hasher hfn = m.hash_funct(); // returns the hasher function
+ }
+ {
+ typedef hash_multiset<int> mmap;
+ mmap m1,m2;
+
+ m1.insert ( 10 );
+ m1.insert ( 20 );
+ m1.insert ( 30 );
+
+ m2.insert ( m1.begin(),m1.end());
+ mmap::iterator i1 = m2.begin();
+ CPPUNIT_ASSERT( *i1 == 10);
+ }
+
+ {
+ typedef hash_set<int> mmap;
+ mmap m;
+
+ m.insert ( 10 );
+ m.insert ( 20 );
+ m.insert ( 30 );
+
+ std::pair<mmap::iterator, mmap::iterator> pair1 = m.equal_range(20);
+ CPPUNIT_ASSERT( *(pair1.first) == 20);
+ CPPUNIT_ASSERT( *(pair1.second) == 30);
+ // negative test case for equal_range where the key value is not present.
+ std::pair<mmap::const_iterator, mmap::const_iterator> pair2 = m.equal_range(40);
+ CPPUNIT_ASSERT( pair2.first == m.end());
+ CPPUNIT_ASSERT( pair2.second == m.end()); }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_set_cov4()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_set<int> mmap;
+ mmap m;
+
+ m.insert ( 10 );
+ m.insert ( 20 );
+ m.insert ( 30 );
+
+ m.erase(m.begin());
+ mmap::iterator i1 = m.begin();
+ CPPUNIT_ASSERT( *i1 == 20);
+ CPPUNIT_ASSERT( m.size() == 2 );
+ m.erase(m.begin(),m.end());
+ CPPUNIT_ASSERT( m.size() == 0 );
+ }
+ {
+ typedef hash_set<int> mmap;
+ mmap m;
+
+ m.insert ( 10 );
+ m.insert ( 20 );
+ m.insert ( 30 );
+
+ mmap::iterator i1 = m.find(10);
+ CPPUNIT_ASSERT( *i1 == 10);
+ mmap::const_iterator i2 = m.find(30);
+ CPPUNIT_ASSERT( *i2 == 30);
+ }
+ {
+ typedef hash_set<int> mmap;
+ typedef allocator<std::pair<int, int> > Myalloc;
+ mmap m;
+
+ mmap::allocator_type al = m.get_allocator();
+ CPPUNIT_ASSERT ((al == Myalloc()) == true);
+
+ mmap::hasher hfn = m.hash_funct(); // returns the hasher function
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_set_cov5()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_set<int> mmap;
+ mmap m1,m2;
+
+ m1.insert ( 10 );
+ m1.insert ( 20 );
+ m1.insert ( 30 );
+
+ m2.insert ( m1.begin(),m1.end());
+ mmap::iterator i1 = m2.begin();
+ CPPUNIT_ASSERT( *i1 == 10);
+ }
+ {
+ typedef hash_set<char> mmap;
+ mmap c1;
+ mmap::key_equal cmpfn = c1.key_eq();
+ CPPUNIT_ASSERT( cmpfn('a','a') == true);
+
+ c1.max_bucket_count(); // for covering the api
+ }
+ {
+ typedef hash_set<int> mmap;
+ mmap m1;
+
+ m1.insert_noresize ( 10 );
+ m1.insert_noresize ( 20 );
+ m1.insert_noresize ( 30 );
+
+ mmap::iterator i1 = m1.begin();
+ CPPUNIT_ASSERT( *i1 == 10);
+ }
+ {
+ typedef hash_set<int> mmap;
+ mmap m1;
+ int bcount;
+
+ m1.insert ( 10 );
+ m1.insert ( 20 );
+ m1.insert ( 30 );
+
+ mmap m2(m1);
+ mmap::iterator i1 = m2.begin();
+ CPPUNIT_ASSERT( *i1 == 10);
+
+ mmap m3(10);
+ bcount = m3.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 10);
+
+ mmap::hasher hfn = m1.hash_funct();
+ mmap m4(20,hfn);
+ bcount = m4.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 20);
+
+ mmap m5(m1.begin(),m2.end());
+ CPPUNIT_ASSERT( m5.size() == 3);
+
+ mmap m6(m1.begin(),m2.end(),30);
+ CPPUNIT_ASSERT( m6.size() == 3);
+ bcount = m6.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 30);
+
+ mmap m7(m1.begin(),m2.end(),30,hfn);
+ CPPUNIT_ASSERT( m7.size() == 3);
+ bcount = m7.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 30);
+
+ mmap::key_equal cmpfn;// = c1.key_eq();
+ mmap m8(m1.begin(),m2.end(),30,hfn,cmpfn);
+
+ mmap m9(30,hfn,cmpfn);
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_set_cov6()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_set<int> mmap;
+ mmap m1;
+
+ m1.insert ( 10 );
+ m1.insert ( 20 );
+ m1.insert ( 30 );
+
+ CPPUNIT_ASSERT( m1.count(10) == 1);
+ CPPUNIT_ASSERT( m1.erase(10) == 1);
+ CPPUNIT_ASSERT( m1.count(10) == 0);
+ }
+ {
+ hash_set <int> hm1;
+ hash_set <int>::iterator hm1_Iter;
+ hm1.insert ( 10 );
+ hm1.insert ( 20 );
+ hm1.insert ( 30 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( *hm1_Iter == 10);
+ hm1_Iter ++ ;
+ CPPUNIT_ASSERT( *hm1_Iter == 20);
+ hm1_Iter ++ ;
+ CPPUNIT_ASSERT( *hm1_Iter == 30);
+
+ }
+ __UHEAP_MARKEND;
+ }
+
+void HashTest::hash_multiset_cov1()
+ {
+ __UHEAP_MARK;
+ {
+ hash_multiset <int> hm1, hm2;
+ hash_multiset <int>::iterator hm1_Iter;
+ hash_multiset <int>::const_iterator hm1_cIter;
+
+ hm1.insert ( 10 );
+ hm1.insert ( 20 );
+ hm1.insert ( 30 );
+ hm2.insert ( 300 );
+
+ hm1.swap( hm2 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( *hm1_Iter== 300);
+ hm1_Iter = hm1.end( );
+ hm1_cIter = hm1.end( );
+ hm1.clear();
+ CPPUNIT_ASSERT( hm1.size() == 0 );
+ CPPUNIT_ASSERT( hm1.empty() == true );
+ }
+ {
+ hash_multiset <int> hm1, hm2;
+ hash_multiset <int>::iterator hm1_Iter;
+ hash_multiset <int>::const_iterator hm1_cIter;
+
+ hm1.insert ( 10 );
+ hm1.insert ( 20 );
+ hm1.insert ( 30 );
+ hm2.insert ( 300 );
+
+ swap( hm1,hm2 );
+ hm1_Iter = hm1.begin( );
+ CPPUNIT_ASSERT( *hm1_Iter== 300);
+ hm1_Iter = hm1.end( );
+ hm1_cIter = hm1.end( );
+ hm1.clear();
+ CPPUNIT_ASSERT( hm1.size() == 0 );
+ CPPUNIT_ASSERT( hm1.empty() == true );
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_multiset_cov2()
+ {
+ __UHEAP_MARK;
+ {
+ hash_multiset <int> hm1;
+ int i,bcount;
+
+ hm1.insert ( 1 );
+ i = hm1.size( );
+ CPPUNIT_ASSERT( i == 1);
+
+ i = hm1.max_size(); // for covering the api
+
+ hm1.insert ( 4 );
+ i = hm1.size( );
+ CPPUNIT_ASSERT( i == 2);
+ hm1.resize(10);
+ bcount = hm1.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 10);
+ hm1.elems_in_bucket(1);
+ }
+ {
+ typedef hash_multiset<int> mmap;
+ mmap m1;
+
+ m1.insert_noresize ( 10 );
+ m1.insert_noresize ( 20 );
+ m1.insert_noresize ( 30 );
+
+ mmap::iterator i1 = m1.begin();
+ CPPUNIT_ASSERT( *i1 == 10);
+ }
+ {
+ typedef hash_multiset<char> mmap;
+ mmap c1;
+ mmap::key_equal cmpfn = c1.key_eq();
+ CPPUNIT_ASSERT( cmpfn('a','a') == true);
+
+ c1.max_bucket_count(); // for covering the api
+ }
+ __UHEAP_MARKEND;
+ }
+void HashTest::hash_multiset_cov3()
+ {
+ __UHEAP_MARK;
+ {
+ typedef hash_multiset<int> mmap;
+ mmap m1;
+ int bcount;
+
+ m1.insert ( 10 );
+ m1.insert ( 20 );
+ m1.insert ( 30 );
+
+ mmap m2(m1);
+ mmap::iterator i1 = m2.begin();
+ CPPUNIT_ASSERT( *i1 == 10);
+
+ mmap m3(10);
+ bcount = m3.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 10);
+
+ mmap::hasher hfn = m1.hash_funct();
+ mmap m4(20,hfn);
+ bcount = m4.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 20);
+
+ mmap m5(m1.begin(),m2.end());
+ CPPUNIT_ASSERT( m5.size() == 3);
+
+ mmap m6(m1.begin(),m2.end(),30);
+ CPPUNIT_ASSERT( m6.size() == 3);
+ bcount = m6.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 30);
+
+ mmap m7(m1.begin(),m2.end(),30,hfn);
+ CPPUNIT_ASSERT( m7.size() == 3);
+ bcount = m7.bucket_count();
+ CPPUNIT_ASSERT( bcount >= 30);
+
+ mmap::key_equal cmpfn;// = c1.key_eq();
+ mmap m8(m1.begin(),m2.end(),30,hfn,cmpfn);
+
+ mmap m9(30,hfn,cmpfn);
+ }
+ __UHEAP_MARKEND;
+ }