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