diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericopenlibs/cppstdlib/stl/test/unit/map_test.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/genericopenlibs/cppstdlib/stl/test/unit/map_test.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,840 @@
+// 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 <map>
+#include <algorithm>
+#include <functional>
+#include <e32std.h>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MapTest : public CPPUNIT_NS::TestCase
+{
+  CPPUNIT_TEST_SUITE(MapTest);
+  CPPUNIT_TEST(map1);
+  CPPUNIT_TEST(mmap1);
+  CPPUNIT_TEST(mmap2);
+  CPPUNIT_TEST(iterators);
+  CPPUNIT_TEST(equal_range);
+  CPPUNIT_TEST(allocator_with_state);
+#if !defined (STLPORT) || !defined (_STLP_USE_CONTAINERS_EXTENSION)
+  CPPUNIT_IGNORE;
+#endif
+  CPPUNIT_TEST(template_methods);
+  CPPUNIT_TEST(map_cov1);
+  CPPUNIT_TEST(map_cov2);
+  CPPUNIT_TEST(map_cov3);
+  CPPUNIT_TEST(map_cov4);
+  CPPUNIT_TEST(multimap_cov1);
+  CPPUNIT_TEST(multimap_cov2);
+  CPPUNIT_TEST(multimap_cov3);
+  CPPUNIT_TEST(multimap_cov4);
+  CPPUNIT_TEST_SUITE_END();
+
+protected:
+  void map1();
+  void mmap1();
+  void mmap2();
+  void iterators();
+  void equal_range();
+  void allocator_with_state();
+  void template_methods();
+  void map_cov1();
+  void map_cov2();
+  void map_cov3();
+  void map_cov4();
+  void multimap_cov1();
+  void multimap_cov2();
+  void multimap_cov3();
+  void multimap_cov4();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MapTest);
+
+//
+// tests implementation
+//
+void MapTest::map1()
+{
+  typedef map<char, int, less<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;
+//  cout << "m['x'] = " << m['x'] << endl;
+  CPPUNIT_ASSERT( m['x']== 20 );
+  m['x'] = 10; // Correct mistake.
+  CPPUNIT_ASSERT( m['x']== 10 );
+  CPPUNIT_ASSERT( m['z']== 0 );
+  //cout << "m['z'] = " << m['z'] << endl; // Note default value is added.
+  CPPUNIT_ASSERT( m.count('z') == 1 );
+  //cout << "m.count('z') = " << m.count('z') << endl;
+  pair<maptype::iterator, bool> p = m.insert(pair<const char, int>('c', 100));
+  CPPUNIT_ASSERT( p.second );
+  CPPUNIT_ASSERT( p.first != m.end() );
+  CPPUNIT_ASSERT( (*p.first).first == 'c' );
+  CPPUNIT_ASSERT( (*p.first).second == 100 );
+
+  p = m.insert(pair<const char, int>('c', 100));
+  CPPUNIT_ASSERT( !p.second ); // already existing pair
+  CPPUNIT_ASSERT( p.first != m.end() );
+  CPPUNIT_ASSERT( (*p.first).first == 'c' );
+  CPPUNIT_ASSERT( (*p.first).second == 100 );
+}
+
+void MapTest::mmap1()
+{
+  typedef multimap<char, int, less<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(pair<const char, int>('X', 20)); // jbuck: standard way
+  CPPUNIT_ASSERT(m.count('X')==2);
+
+  m.insert(pair<const char, int>('Y', 32)); // jbuck: standard way
+  mmap::iterator i = m.find('X'); // Find first match.
+  pair<const char, int> p('X', 10);
+  CPPUNIT_ASSERT(*i == p);
+  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);
+}
+void MapTest::mmap2()
+{
+  typedef pair<const int, char> pair_type;
+
+  pair_type p1(3, 'c');
+  pair_type p2(6, 'f');
+  pair_type p3(1, 'a');
+  pair_type p4(2, 'b');
+  pair_type p5(3, 'x');
+  pair_type p6(6, 'f');
+
+  typedef multimap<int, char, less<int> > mmap;
+
+  pair_type array [] = {
+    p1,
+    p2,
+    p3,
+    p4,
+    p5,
+    p6
+  };
+
+  mmap m(array + 0, array + 6);
+  mmap::iterator i;
+  i = m.lower_bound(3);
+  CPPUNIT_ASSERT((*i).first==3);
+  CPPUNIT_ASSERT((*i).second=='c');
+
+  i = m.upper_bound(3);
+  CPPUNIT_ASSERT((*i).first==6);
+  CPPUNIT_ASSERT((*i).second=='f');
+}
+
+
+void MapTest::iterators()
+{
+  typedef map<int, char, less<int> > int_map;
+  int_map imap;
+  {
+    int_map::iterator ite(imap.begin());
+    int_map::const_iterator cite(imap.begin());
+    CPPUNIT_ASSERT( ite == cite );
+    CPPUNIT_ASSERT( !(ite != cite) );
+    CPPUNIT_ASSERT( cite == ite );
+    CPPUNIT_ASSERT( !(cite != ite) );
+  }
+
+  typedef multimap<int, char, less<int> > mmap;
+  typedef mmap::value_type pair_type;
+
+  pair_type p1(3, 'c');
+  pair_type p2(6, 'f');
+  pair_type p3(1, 'a');
+  pair_type p4(2, 'b');
+  pair_type p5(3, 'x');
+  pair_type p6(6, 'f');
+
+  pair_type array [] = {
+    p1,
+    p2,
+    p3,
+    p4,
+    p5,
+    p6
+  };
+
+  mmap m(array+0, array + 6);
+
+  {
+    mmap::iterator ite(m.begin());
+    mmap::const_iterator cite(m.begin());
+    //test compare between const_iterator and iterator
+    CPPUNIT_ASSERT( ite == cite );
+    CPPUNIT_ASSERT( !(ite != cite) );
+    CPPUNIT_ASSERT( cite == ite );
+    CPPUNIT_ASSERT( !(cite != ite) );
+  }
+
+#if 0
+  /*
+   * A check that map and multimap iterators are NOT comparable
+   * the following code should generate a compile time error
+   */
+  {
+    int_map::iterator mite(imap.begin());
+    int_map::const_iterator mcite(imap.begin());
+    mmap::iterator mmite(m.begin());
+    mmap::const_iterator mmcite(m.begin());
+    CPPUNIT_ASSERT( !(mite == mmite) );
+    CPPUNIT_ASSERT( !(mcite == mmcite) );
+    CPPUNIT_ASSERT( mite != mmite );
+    CPPUNIT_ASSERT( mcite != mmcite );
+    CPPUNIT_ASSERT( !(mite == mmcite) );
+    CPPUNIT_ASSERT( !(mite == mmcite) );
+    CPPUNIT_ASSERT( mite != mmcite );
+    CPPUNIT_ASSERT( mite != mmcite );
+  }
+
+#endif
+
+  mmap::reverse_iterator ri = m.rbegin();
+  CPPUNIT_ASSERT( ri != m.rend() );
+  CPPUNIT_ASSERT( ri == m.rbegin() );
+  CPPUNIT_ASSERT( (*ri).first == 6 );
+  CPPUNIT_ASSERT( (*ri++).second == 'f' );
+  CPPUNIT_ASSERT( (*ri).first == 6 );
+  CPPUNIT_ASSERT( (*ri).second == 'f' );
+
+  mmap const& cm = m;
+  mmap::const_reverse_iterator rci = cm.rbegin();
+  CPPUNIT_ASSERT( rci != cm.rend() );
+  CPPUNIT_ASSERT( (*rci).first == 6 );
+  CPPUNIT_ASSERT( (*rci++).second == 'f' );
+  CPPUNIT_ASSERT( (*rci).first == 6 );
+  CPPUNIT_ASSERT( (*rci).second == 'f' );
+}
+
+void MapTest::equal_range()
+{
+  typedef map<char, int, less<char> > maptype;
+  {
+    maptype m;
+    m['x'] = 10;
+
+    pair<maptype::iterator, maptype::iterator> ret;
+    ret = m.equal_range('x');
+    CPPUNIT_ASSERT( ret.first != ret.second );
+    CPPUNIT_ASSERT( (*(ret.first)).first == 'x' );
+    CPPUNIT_ASSERT( (*(ret.first)).second == 10 );
+    CPPUNIT_ASSERT( ++(ret.first) == ret.second );
+  }
+  {
+    {
+      maptype m;
+
+      maptype::iterator i = m.lower_bound( 'x' );
+      CPPUNIT_ASSERT( i == m.end() );
+
+      i = m.upper_bound( 'x' );
+      CPPUNIT_ASSERT( i == m.end() );
+
+      pair<maptype::iterator, maptype::iterator> ret;
+      ret = m.equal_range('x');
+      CPPUNIT_ASSERT( ret.first == ret.second );
+      CPPUNIT_ASSERT( ret.first == m.end() );
+    }
+
+    {
+      const maptype m;
+      pair<maptype::const_iterator, maptype::const_iterator> ret;
+      ret = m.equal_range('x');
+      CPPUNIT_ASSERT( ret.first == ret.second );
+      CPPUNIT_ASSERT( ret.first == m.end() );
+    }
+  }
+}
+
+void MapTest::allocator_with_state()
+{
+  char buf1[1024];
+  StackAllocator<pair<const int, int> > stack1(buf1, buf1 + sizeof(buf1));
+
+  char buf2[1024];
+  StackAllocator<pair<const int, int> > stack2(buf2, buf2 + sizeof(buf2));
+
+  {
+    typedef map<int, int, less<int>, StackAllocator<pair<const int, int> > > MapInt;
+    less<int> intLess;
+    MapInt mint1(intLess, stack1);
+    int i;
+    for (i = 0; i < 5; ++i)
+      mint1.insert(MapInt::value_type(i, i));
+    MapInt mint1Cpy(mint1);
+
+    MapInt mint2(intLess, stack2);
+    for (; i < 10; ++i)
+      mint2.insert(MapInt::value_type(i, i));
+    MapInt mint2Cpy(mint2);
+
+    mint1.swap(mint2);
+
+    CPPUNIT_ASSERT( mint1.get_allocator().swaped() );
+    CPPUNIT_ASSERT( mint2.get_allocator().swaped() );
+
+    CPPUNIT_ASSERT( mint1 == mint2Cpy );
+    CPPUNIT_ASSERT( mint2 == mint1Cpy );
+    CPPUNIT_ASSERT( mint1.get_allocator() == stack2 );
+    CPPUNIT_ASSERT( mint2.get_allocator() == stack1 );
+  }
+  CPPUNIT_ASSERT( stack1.ok() );
+  CPPUNIT_ASSERT( stack2.ok() );
+}
+
+struct Key
+{
+  Key() : m_data(0) {}
+  explicit Key(int data) : m_data(data) {}
+
+  int m_data;
+};
+
+struct KeyCmp
+{
+  bool operator () (Key lhs, Key rhs) const
+  { return lhs.m_data < rhs.m_data; }
+
+  bool operator () (Key lhs, int rhs) const
+  { return lhs.m_data < rhs; }
+
+  bool operator () (int lhs, Key rhs) const
+  { return lhs < rhs.m_data; }
+};
+
+struct KeyCmpPtr
+{
+  bool operator () (Key const volatile *lhs, Key const volatile *rhs) const
+  { return (*lhs).m_data < (*rhs).m_data; }
+
+  bool operator () (Key const volatile *lhs, int rhs) const
+  { return (*lhs).m_data < rhs; }
+
+  bool operator () (int lhs, Key const volatile *rhs) const
+  { return lhs < (*rhs).m_data; }
+};
+
+void MapTest::template_methods()
+{
+#if defined (STLPORT) && defined (_STLP_USE_CONTAINERS_EXTENSION)
+  {
+    typedef map<Key, int, KeyCmp> Container;
+    typedef Container::value_type value;
+    Container cont;
+    cont.insert(value(Key(1), 1));
+    cont.insert(value(Key(2), 2));
+    cont.insert(value(Key(3), 3));
+    cont.insert(value(Key(4), 4));
+
+    CPPUNIT_ASSERT( cont.count(Key(1)) == 1 );
+    CPPUNIT_ASSERT( cont.count(1) == 1 );
+    CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+    CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+    Container const& ccont = cont;
+    CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) );
+  }
+
+  {
+    typedef map<Key*, int, KeyCmpPtr> Container;
+    typedef Container::value_type value;
+    Container cont;
+    Key key1(1), key2(2), key3(3), key4(4);
+    cont.insert(value(&key1, 1));
+    cont.insert(value(&key2, 2));
+    cont.insert(value(&key3, 3));
+    cont.insert(value(&key4, 4));
+
+    CPPUNIT_ASSERT( cont.count(1) == 1 );
+    CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+    CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+    Container const& ccont = cont;
+    CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
+  }
+  {
+    typedef multimap<Key, int, KeyCmp> Container;
+    typedef Container::value_type value;
+    Container cont;
+    cont.insert(value(Key(1), 1));
+    cont.insert(value(Key(2), 2));
+    cont.insert(value(Key(3), 3));
+    cont.insert(value(Key(4), 4));
+
+    CPPUNIT_ASSERT( cont.count(Key(1)) == 1 );
+    CPPUNIT_ASSERT( cont.count(1) == 1 );
+    CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+    CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+    Container const& ccont = cont;
+    CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) );
+  }
+
+  {
+    typedef multimap<Key const volatile*, int, KeyCmpPtr> Container;
+    typedef Container::value_type value;
+    Container cont;
+    Key key1(1), key2(2), key3(3), key4(4);
+    cont.insert(value(&key1, 1));
+    cont.insert(value(&key2, 2));
+    cont.insert(value(&key3, 3));
+    cont.insert(value(&key4, 4));
+
+    CPPUNIT_ASSERT( cont.count(1) == 1 );
+    CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+    CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
+    CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+    Container const& ccont = cont;
+    CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
+    CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
+  }
+#endif
+}
+
+void MapTest::map_cov1()
+	{
+	  __UHEAP_MARK;
+		{
+		map<int, int> m1;
+	    map<int, int>::size_type i;
+	    typedef pair<int, int> Int_Pair;
+	    m1.insert(Int_Pair(1, 1));
+	    m1.insert(Int_Pair(2, 4));
+
+	    i = m1.size();
+	    CPPUNIT_ASSERT( i==2 );
+	    m1.clear();
+	    i = m1.size();
+	    CPPUNIT_ASSERT( i==0 );
+		}
+		{
+		map <int, int> m1, m2;
+		bool flag;
+		typedef pair <int, int> Int_Pair;
+		
+		m1.insert ( Int_Pair ( 1, 1 ) );
+		flag = m1.empty();
+		CPPUNIT_ASSERT( flag==false );
+		flag = m2.empty();
+		CPPUNIT_ASSERT( flag==true );
+		}
+		{
+		map <int, int> m1;
+		map <int, int> :: iterator m1_Iter;
+		map <int, int> :: reverse_iterator m1_rIter;
+		typedef pair <int, int> Int_Pair;
+		
+		m1.insert ( Int_Pair ( 1, 10 ) );
+ 	    m1.insert ( Int_Pair ( 2, 20 ) );
+		m1.insert ( Int_Pair ( 3, 30 ) );
+		m1_rIter = m1.rbegin( );
+		CPPUNIT_ASSERT( m1_rIter->first == 3 );
+		m1_rIter = m1.rend( );
+		m1_rIter--;
+		CPPUNIT_ASSERT( m1_rIter->first == 1 );
+		}	
+		  __UHEAP_MARKEND;
+	}
+void MapTest::map_cov2()
+	{
+	  __UHEAP_MARK;
+		{
+		map<int, int> m1, m2, m3;
+	    map<int, int>::iterator pIter, Iter1, Iter2;
+	    int i;
+	    typedef pair<int, int> Int_Pair;
+	    
+	    for (i = 1; i < 5; i++)
+	        {
+	        m1.insert(Int_Pair(i, i));
+	        m2.insert(Int_Pair(i, i*i));
+	        m3.insert(Int_Pair(i, i-1));
+	        }
+	    Iter1 = ++m1.begin();
+	    m1.erase(Iter1);
+
+	    pIter = m1.begin(); 
+	    CPPUNIT_ASSERT( pIter->second == 1 );
+	    pIter++;
+	    CPPUNIT_ASSERT( pIter->second == 3 );
+	    pIter++;
+	    CPPUNIT_ASSERT( pIter->second == 4 );
+	    
+	    Iter1 = ++m2.begin();
+	    Iter2 = --m2.end();
+	    m2.erase(Iter1, Iter2);
+	    pIter = m2.begin(); 
+	    CPPUNIT_ASSERT( pIter->second == 1 );
+	    pIter++;
+	    CPPUNIT_ASSERT( pIter->second == 16 );
+	    
+	    map<int, int>::size_type n = m3.erase(2);
+	    pIter = m3.begin(); 
+	    CPPUNIT_ASSERT( pIter->second == 0 );
+	    pIter++;
+	    CPPUNIT_ASSERT( pIter->second == 2 );
+	    pIter++;
+	    CPPUNIT_ASSERT( pIter->second == 3 );
+		}
+		{
+		map <int, int> m1;
+		m1.max_size( );
+		}
+		  __UHEAP_MARKEND;
+	}
+void MapTest::map_cov3()
+	{
+	  __UHEAP_MARK;
+		{
+		map <int, int> m1;
+
+		map <int, int> :: iterator m1_Iter;
+		map <int, int> :: reverse_iterator m1_rIter;
+		map <int, int> :: const_reverse_iterator m1_crIter;
+		typedef pair <int, int> Int_Pair;
+	
+		m1.insert ( Int_Pair ( 1, 10 ) );
+ 	    m1.insert ( Int_Pair ( 2, 20 ) );
+		m1.insert ( Int_Pair ( 3, 30 ) );
+		m1_crIter = m1.rbegin( );
+		CPPUNIT_ASSERT( m1_crIter->first == 3 );
+		m1_crIter = m1.rend( );
+		m1_crIter--;
+		CPPUNIT_ASSERT( m1_crIter->first == 1 );
+		}
+		{
+		map <int, int, less<int> > m1;
+		map <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
+		pair< map<int,int>::iterator, bool > pr1, pr2;
+		   
+		pr1= m1.insert ( map <int, int> :: value_type ( 1, 10 ) );
+		pr2= m1.insert ( map <int, int> :: value_type ( 2, 5 ) );
+
+		CPPUNIT_ASSERT( vc1( *pr1.first, *pr2.first ) == true );
+		}
+		{
+		map <int, int> m1, m2;
+		typedef pair <int, int> Int_Pair;
+		map <int, int>::iterator m2_Iter;
+		map<int, int>::size_type i;
+    	m1.insert ( Int_Pair ( 1, 10 ) );
+		m1.insert ( Int_Pair ( 2, 20 ) );
+		m1.insert ( Int_Pair ( 3, 30 ) );
+		m2=m1;
+		m2_Iter = m2.begin( ); 
+		CPPUNIT_ASSERT(m2_Iter -> second == 10);
+	    i = m2.size();
+		CPPUNIT_ASSERT(i == 3);			
+		}
+		  __UHEAP_MARKEND;
+	}
+void MapTest::map_cov4()
+	{
+	  __UHEAP_MARK;
+		{
+		map <int, int> m1, m3;
+		map <int, int>::iterator m1_Iter;
+		typedef pair <int, int> Int_Pair;
+
+		m1.insert ( Int_Pair ( 1, 10 ) );
+		m1.insert ( Int_Pair ( 2, 20 ) );
+		m1.insert ( Int_Pair ( 3, 30 ) );
+		m3.insert ( Int_Pair ( 30, 300 ) );
+		
+		swap(m1,m3);
+		m1_Iter = m1.begin();
+		
+		CPPUNIT_ASSERT(m1_Iter -> second == 300);
+		}
+		{
+		map <int, int> m1, m3;
+		typedef pair <int, int> Int_Pair;
+
+		m1.insert ( Int_Pair ( 1, 10 ) );
+		m3.insert ( Int_Pair ( 30, 300 ) );
+		
+		bool x = m1 < m3;
+		CPPUNIT_ASSERT(x == true);
+		}
+		  __UHEAP_MARKEND;
+	}
+
+void MapTest::multimap_cov1()
+	{
+	  __UHEAP_MARK;
+		{
+		multimap<int, int> m1;
+		multimap<int, int>::size_type i;
+		typedef pair<int, int> Int_Pair;
+
+		m1.insert(Int_Pair(1, 1));
+		m1.insert(Int_Pair(2, 4));
+
+		i = m1.size();
+	    CPPUNIT_ASSERT( i==2 );
+	    m1.clear();
+	    i = m1.size();
+	    CPPUNIT_ASSERT( i==0 );
+		}
+		{
+		multimap <int, int> m1, m2;
+		bool flag;
+		typedef pair <int, int> Int_Pair;
+		
+		m1.insert ( Int_Pair ( 1, 1 ) );
+		flag = m1.empty();
+		CPPUNIT_ASSERT( flag==false );
+		flag = m2.empty();
+		CPPUNIT_ASSERT( flag==true );
+		}
+		{
+		multimap <int, int>::allocator_type m1_Alloc;
+		multimap <int, int>::allocator_type m2_Alloc;
+		multimap <int, int>::allocator_type m4_Alloc;
+	
+		multimap <int, int> m1;
+		multimap <int, int, allocator<int> > m2;
+		m1_Alloc = m1.get_allocator( );
+		m2_Alloc = m2.get_allocator( );
+		map <int, int> m4( less<int>( ), m1_Alloc );
+		m4_Alloc = m4.get_allocator( );
+	
+		CPPUNIT_ASSERT( m1_Alloc == m4_Alloc );
+		}
+		  __UHEAP_MARKEND;
+	}
+void MapTest::multimap_cov2()
+	{
+	  __UHEAP_MARK;
+		{
+		multimap<int, int> m1, m2;
+		multimap<int, int>::iterator pIter, Iter1, Iter2;
+	    int i;
+	    typedef pair<int, int> Int_Pair;
+	    
+	    for (i = 1; i < 5; i++)
+	        {
+	        m1.insert(Int_Pair(i, i));
+	        m2.insert(Int_Pair(i, i*i));
+	        }
+	    Iter1 = ++m1.begin();
+	    m1.erase(Iter1);
+
+	    pIter = m1.begin(); 
+	    CPPUNIT_ASSERT( pIter->second == 1 );
+	    pIter++;
+	    CPPUNIT_ASSERT( pIter->second == 3 );
+	    pIter++;
+	    CPPUNIT_ASSERT( pIter->second == 4 );
+	    
+	    Iter1 = ++m2.begin();
+	    Iter2 = --m2.end();
+	    m2.erase(Iter1, Iter2);
+	    pIter = m2.begin(); 
+	    CPPUNIT_ASSERT( pIter->second == 1 );
+	    pIter++;
+	    CPPUNIT_ASSERT( pIter->second == 16 );
+		}
+		{
+		multimap <int, int>::iterator m1_pIter, m2_pIter;
+		multimap <int, int> :: reverse_iterator m1_rIter;
+		multimap <int, int> 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 ) );
+		m1.insert( --m1.end( ), Int_Pair ( 4, 40 )  );
+		
+		m1_rIter = m1.rbegin( );
+		CPPUNIT_ASSERT( m1_rIter->first == 4 );
+
+		m2.insert ( Int_Pair ( 10, 100 ) );
+		m2.insert( ++m1.begin( ), --m1.end( ) );
+		m2_pIter = m2.begin( ); 
+		CPPUNIT_ASSERT(m2_pIter -> first == 2);
+		}
+		{
+		multimap <int, int> m1;
+		m1.max_size( );
+		}
+		  __UHEAP_MARKEND;
+	}
+void MapTest::multimap_cov3()
+	{
+	  __UHEAP_MARK;
+		{
+		multimap <int, int, less<int> > m1;
+		multimap <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ;
+		bool result1 = kc1( 2, 3 ) ;
+		CPPUNIT_ASSERT(result1 == true);
+		
+		multimap <int, int, greater_equal<int> > m2;
+		multimap <int, int, greater_equal<int> >::key_compare kc2 = m2.key_comp( );
+		bool result2 = kc2( 3, 3 ) ;
+		CPPUNIT_ASSERT(result1 == true);
+		}
+		{
+	    multimap<int, int> m1, m2;
+	    multimap<int, int>::size_type i;
+	    typedef pair<int, int> Int_Pair;
+
+	    m1.insert(Int_Pair(1, 1));
+	    i = m1.size();
+		CPPUNIT_ASSERT(i == 1);			
+	    m1.insert(Int_Pair(2, 4));
+	    i = m1.size();
+		CPPUNIT_ASSERT(i == 2);			
+		}
+		{
+		multimap <int, int> m1, m2;
+		multimap <int, int>::iterator m1_Iter;
+		typedef pair <int, int> Int_Pair;
+	    multimap<int, int>::size_type i;
+	    
+    	m1.insert ( Int_Pair ( 1, 10 ) );
+		m1.insert ( Int_Pair ( 2, 20 ) );
+		m1.insert ( Int_Pair ( 3, 30 ) );
+		m2.insert ( Int_Pair ( 30, 300 ) );
+		m1.swap( m2 );
+		m1_Iter = m1.begin( ); 
+		CPPUNIT_ASSERT(m1_Iter -> second == 300);
+	    i = m1.size();
+		CPPUNIT_ASSERT(i == 1);			
+		}
+		  __UHEAP_MARKEND;
+	}
+void MapTest::multimap_cov4()
+	{
+	  __UHEAP_MARK;
+		{
+		multimap <int, int, less<int> > m1;
+		multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
+		multimap<int,int>::iterator Iter1, Iter2;
+
+		Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );
+		Iter2= m1.insert ( multimap <int, int> :: value_type ( 2, 5 ) );
+		CPPUNIT_ASSERT( vc1( *Iter1, *Iter2 ) == true );
+		}
+		{
+		multimap <int, int> m1, m2;
+		typedef pair <int, int> Int_Pair;
+		multimap <int, int>::iterator m2_Iter;
+	    multimap<int, int>::size_type i;
+	    
+    	m1.insert ( Int_Pair ( 1, 10 ) );
+		m1.insert ( Int_Pair ( 2, 20 ) );
+		m1.insert ( Int_Pair ( 3, 30 ) );
+		
+		m2=m1;
+		m2_Iter = m2.begin( ); 
+		CPPUNIT_ASSERT(m2_Iter -> second == 10);
+	    i = m2.size();
+		CPPUNIT_ASSERT(i == 3);			
+
+		}
+		{
+		multimap <int, int> m1, m2;
+		multimap <int, int>::iterator m1_Iter;
+		typedef pair <int, int> Int_Pair;
+	    multimap<int, int>::size_type i;
+	    
+    	m1.insert ( Int_Pair ( 1, 10 ) );
+		m1.insert ( Int_Pair ( 2, 20 ) );
+		m1.insert ( Int_Pair ( 3, 30 ) );
+		m2.insert ( Int_Pair ( 30, 300 ) );
+		swap( m1,m2 );
+		m1_Iter = m1.begin( ); 
+		CPPUNIT_ASSERT(m1_Iter -> second == 300);
+	    i = m1.size();
+		CPPUNIT_ASSERT(i == 1);			
+		}
+		{
+		multimap <int, int> m1, m2;
+		typedef pair <int, int> Int_Pair;
+	    
+    	m1.insert ( Int_Pair ( 1, 10 ) );
+		m2.insert ( Int_Pair ( 30, 300 ) );
+		
+		bool val = m1 < m2;
+		CPPUNIT_ASSERT(val == true);
+		val = (m1 == m2);
+		CPPUNIT_ASSERT(val == false);
+		}
+		  __UHEAP_MARKEND;
+	}