src/third_party/libc++/trunk/test/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 other_allocator<std::pair<const int, std::string> > A;
  91         typedef std::unordered_multimap<int, std::string,
  92                                    test_hash<std::hash<int> >,
  93                                    test_compare<std::equal_to<int> >,
  94                                    A
  95                                    > C;
  96         typedef std::pair<int, std::string> P;
  97         P a[] =
  98         {
  99             P(1, "one"),
 100             P(2, "two"),
 101             P(3, "three"),
 102             P(4, "four"),
 103             P(1, "four"),
 104             P(2, "four"),
 105         };
 106         C c0(a, a + sizeof(a)/sizeof(a[0]),
 107             7,
 108             test_hash<std::hash<int> >(8),
 109             test_compare<std::equal_to<int> >(9),
 110             A(10)
 111            );
 112         C c(a, a + 2,
 113             7,
 114             test_hash<std::hash<int> >(2),
 115             test_compare<std::equal_to<int> >(3),
 116             A(4)
 117            );
 118         c = c0;
 119         assert(c.bucket_count() >= 7);
 120         assert(c.size() == 6);
 121         C::const_iterator i = c.cbegin();
 122         assert(i->first == 1);
 123         assert(i->second == "one");
 124         ++i;
 125         assert(i->first == 1);
 126         assert(i->second == "four");
 127         ++i;
 128         assert(i->first == 2);
 129         assert(i->second == "two");
 130         ++i;
 131         assert(i->first == 2);
 132         assert(i->second == "four");
 133         ++i;
 134         assert(i->first == 3);
 135         assert(i->second == "three");
 136         ++i;
 137         assert(i->first == 4);
 138         assert(i->second == "four");
 139         assert(c.hash_function() == test_hash<std::hash<int> >(8));
 140         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
 141         assert(c.get_allocator() == A(10));
 142         assert(!c.empty());
 143         assert(std::distance(c.begin(), c.end()) == c.size());
 144         assert(std::distance(c.cbegin(), c.cend()) == c.size());
 145         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 146         assert(c.max_load_factor() == 1);
 147     }
 148 #if __cplusplus >= 201103L
 149     {
 150         typedef min_allocator<std::pair<const int, std::string> > A;
 151         typedef std::unordered_multimap<int, std::string,
 152                                    test_hash<std::hash<int> >,
 153                                    test_compare<std::equal_to<int> >,
 154                                    A
 155                                    > C;
 156         typedef std::pair<int, std::string> P;
 157         P a[] =
 158         {
 159             P(1, "one"),
 160             P(2, "two"),
 161             P(3, "three"),
 162             P(4, "four"),
 163             P(1, "four"),
 164             P(2, "four"),
 165         };
 166         C c0(a, a + sizeof(a)/sizeof(a[0]),
 167             7,
 168             test_hash<std::hash<int> >(8),
 169             test_compare<std::equal_to<int> >(9),
 170             A()
 171            );
 172         C c(a, a + 2,
 173             7,
 174             test_hash<std::hash<int> >(2),
 175             test_compare<std::equal_to<int> >(3),
 176             A()
 177            );
 178         c = c0;
 179         assert(c.bucket_count() == 7);
 180         assert(c.size() == 6);
 181         C::const_iterator i = c.cbegin();
 182         assert(i->first == 1);
 183         assert(i->second == "one");
 184         ++i;
 185         assert(i->first == 1);
 186         assert(i->second == "four");
 187         ++i;
 188         assert(i->first == 2);
 189         assert(i->second == "two");
 190         ++i;
 191         assert(i->first == 2);
 192         assert(i->second == "four");
 193         ++i;
 194         assert(i->first == 3);
 195         assert(i->second == "three");
 196         ++i;
 197         assert(i->first == 4);
 198         assert(i->second == "four");
 199         assert(c.hash_function() == test_hash<std::hash<int> >(8));
 200         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
 201         assert(c.get_allocator() == A());
 202         assert(!c.empty());
 203         assert(std::distance(c.begin(), c.end()) == c.size());
 204         assert(std::distance(c.cbegin(), c.cend()) == c.size());
 205         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 206         assert(c.max_load_factor() == 1);
 207     }
 208 #endif
 209 }