test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // <unordered_map>
  11
  12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
  13 //           class Alloc = allocator<pair<const Key, T>>>
  14 // class unordered_multimap
  15
  16 // unordered_multimap& operator=(const unordered_multimap& u);
  17
  18 #include <unordered_map>
  19 #include <string>
  20 #include <cassert>
  21 #include <cfloat>
  22
  23 #include "../../../test_compare.h"
  24 #include "../../../test_hash.h"
  25 #include "test_allocator.h"
  26 #include "min_allocator.h"
  27
  28 int main()
  29 {
  30     {
  31         typedef test_allocator<std::pair<const int, std::string> > A;
  32         typedef std::unordered_multimap<int, std::string,
  33                                    test_hash<std::hash<int> >,
  34                                    test_compare<std::equal_to<int> >,
  35                                    A
  36                                    > C;
  37         typedef std::pair<int, std::string> P;
  38         P a[] =
  39         {
  40             P(1, "one"),
  41             P(2, "two"),
  42             P(3, "three"),
  43             P(4, "four"),
  44             P(1, "four"),
  45             P(2, "four"),
  46         };
  47         C c0(a, a + sizeof(a)/sizeof(a[0]),
  48             7,
  49             test_hash<std::hash<int> >(8),
  50             test_compare<std::equal_to<int> >(9),
  51             A(10)
  52            );
  53         C c(a, a + 2,
  54             7,
  55             test_hash<std::hash<int> >(2),
  56             test_compare<std::equal_to<int> >(3),
  57             A(4)
  58            );
  59         c = c0;
  60         assert(c.bucket_count() == 7);
  61         assert(c.size() == 6);
  62         C::const_iterator i = c.cbegin();
  63         assert(i->first == 1);
  64         assert(i->second == "one");
  65         ++i;
  66         assert(i->first == 1);
  67         assert(i->second == "four");
  68         ++i;
  69         assert(i->first == 2);
  70         assert(i->second == "two");
  71         ++i;
  72         assert(i->first == 2);
  73         assert(i->second == "four");
  74         ++i;
  75         assert(i->first == 3);
  76         assert(i->second == "three");
  77         ++i;
  78         assert(i->first == 4);
  79         assert(i->second == "four");
  80         assert(c.hash_function() == test_hash<std::hash<int> >(8));
  81         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
  82         assert(c.get_allocator() == A(4));
  83         assert(!c.empty());
  84         assert(std::distance(c.begin(), c.end()) == c.size());
  85         assert(std::distance(c.cbegin(), c.cend()) == c.size());
  86         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
  87         assert(c.max_load_factor() == 1);
  88     }
  89     {
  90         typedef std::unordered_multimap<int, std::string> C;
  91         typedef std::pair<const int, std::string> P;
  92         const P a[] =
  93         {
  94             P(1, "one"),
  95             P(2, "two"),
  96             P(3, "three"),
  97             P(4, "four"),
  98             P(1, "four"),
  99             P(2, "four"),
 100         };
 101         C c(a, a+sizeof(a)/sizeof(a[0]));
 102         C *p = &c;
 103         c = *p;
 104         assert(c.size() == 6);
 105         assert(std::is_permutation(c.begin(), c.end(), a));
 106     }
 107     {
 108         typedef other_allocator<std::pair<const int, std::string> > A;
 109         typedef std::unordered_multimap<int, std::string,
 110                                    test_hash<std::hash<int> >,
 111                                    test_compare<std::equal_to<int> >,
 112                                    A
 113                                    > C;
 114         typedef std::pair<int, std::string> P;
 115         P a[] =
 116         {
 117             P(1, "one"),
 118             P(2, "two"),
 119             P(3, "three"),
 120             P(4, "four"),
 121             P(1, "four"),
 122             P(2, "four"),
 123         };
 124         C c0(a, a + sizeof(a)/sizeof(a[0]),
 125             7,
 126             test_hash<std::hash<int> >(8),
 127             test_compare<std::equal_to<int> >(9),
 128             A(10)
 129            );
 130         C c(a, a + 2,
 131             7,
 132             test_hash<std::hash<int> >(2),
 133             test_compare<std::equal_to<int> >(3),
 134             A(4)
 135            );
 136         c = c0;
 137         assert(c.bucket_count() >= 7);
 138         assert(c.size() == 6);
 139         C::const_iterator i = c.cbegin();
 140         assert(i->first == 1);
 141         assert(i->second == "one");
 142         ++i;
 143         assert(i->first == 1);
 144         assert(i->second == "four");
 145         ++i;
 146         assert(i->first == 2);
 147         assert(i->second == "two");
 148         ++i;
 149         assert(i->first == 2);
 150         assert(i->second == "four");
 151         ++i;
 152         assert(i->first == 3);
 153         assert(i->second == "three");
 154         ++i;
 155         assert(i->first == 4);
 156         assert(i->second == "four");
 157         assert(c.hash_function() == test_hash<std::hash<int> >(8));
 158         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
 159         assert(c.get_allocator() == A(10));
 160         assert(!c.empty());
 161         assert(std::distance(c.begin(), c.end()) == c.size());
 162         assert(std::distance(c.cbegin(), c.cend()) == c.size());
 163         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 164         assert(c.max_load_factor() == 1);
 165     }
 166 #if __cplusplus >= 201103L
 167     {
 168         typedef min_allocator<std::pair<const int, std::string> > A;
 169         typedef std::unordered_multimap<int, std::string,
 170                                    test_hash<std::hash<int> >,
 171                                    test_compare<std::equal_to<int> >,
 172                                    A
 173                                    > C;
 174         typedef std::pair<int, std::string> P;
 175         P a[] =
 176         {
 177             P(1, "one"),
 178             P(2, "two"),
 179             P(3, "three"),
 180             P(4, "four"),
 181             P(1, "four"),
 182             P(2, "four"),
 183         };
 184         C c0(a, a + sizeof(a)/sizeof(a[0]),
 185             7,
 186             test_hash<std::hash<int> >(8),
 187             test_compare<std::equal_to<int> >(9),
 188             A()
 189            );
 190         C c(a, a + 2,
 191             7,
 192             test_hash<std::hash<int> >(2),
 193             test_compare<std::equal_to<int> >(3),
 194             A()
 195            );
 196         c = c0;
 197         assert(c.bucket_count() == 7);
 198         assert(c.size() == 6);
 199         C::const_iterator i = c.cbegin();
 200         assert(i->first == 1);
 201         assert(i->second == "one");
 202         ++i;
 203         assert(i->first == 1);
 204         assert(i->second == "four");
 205         ++i;
 206         assert(i->first == 2);
 207         assert(i->second == "two");
 208         ++i;
 209         assert(i->first == 2);
 210         assert(i->second == "four");
 211         ++i;
 212         assert(i->first == 3);
 213         assert(i->second == "three");
 214         ++i;
 215         assert(i->first == 4);
 216         assert(i->second == "four");
 217         assert(c.hash_function() == test_hash<std::hash<int> >(8));
 218         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
 219         assert(c.get_allocator() == A());
 220         assert(!c.empty());
 221         assert(std::distance(c.begin(), c.end()) == c.size());
 222         assert(std::distance(c.cbegin(), c.cend()) == c.size());
 223         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 224         assert(c.max_load_factor() == 1);
 225     }
 226 #endif
 227 }