test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.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 // UNSUPPORTED: c++98, c++03
  11
  12 // <unordered_set>
  13
  14 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
  15 //           class Alloc = allocator<Value>>
  16 // class unordered_set
  17
  18 // unordered_set& operator=(unordered_set&& u);
  19
  20 #include <unordered_set>
  21 #include <cassert>
  22 #include <cfloat>
  23 #include <cmath>
  24 #include <cstddef>
  25
  26 #include "test_macros.h"
  27 #include "../../../test_compare.h"
  28 #include "../../../test_hash.h"
  29 #include "test_allocator.h"
  30 #include "min_allocator.h"
  31
  32 int main()
  33 {
  34     {
  35         typedef test_allocator<int> A;
  36         typedef std::unordered_set<int,
  37                                    test_hash<std::hash<int> >,
  38                                    test_compare<std::equal_to<int> >,
  39                                    A
  40                                    > C;
  41         typedef int P;
  42         P a[] =
  43         {
  44             P(1),
  45             P(2),
  46             P(3),
  47             P(4),
  48             P(1),
  49             P(2)
  50         };
  51         C c0(a, a + sizeof(a)/sizeof(a[0]),
  52             7,
  53             test_hash<std::hash<int> >(8),
  54             test_compare<std::equal_to<int> >(9),
  55             A(10)
  56            );
  57         C c(a, a + 2,
  58             7,
  59             test_hash<std::hash<int> >(2),
  60             test_compare<std::equal_to<int> >(3),
  61             A(4)
  62            );
  63         c = std::move(c0);
  64         LIBCPP_ASSERT(c.bucket_count() == 7);
  65         assert(c.size() == 4);
  66         assert(c.count(1) == 1);
  67         assert(c.count(2) == 1);
  68         assert(c.count(3) == 1);
  69         assert(c.count(4) == 1);
  70         assert(c.hash_function() == test_hash<std::hash<int> >(8));
  71         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
  72         assert(c.get_allocator() == A(4));
  73         assert(!c.empty());
  74         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
  75         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
  76         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
  77         assert(c.max_load_factor() == 1);
  78     }
  79     {
  80         typedef test_allocator<int> A;
  81         typedef std::unordered_set<int,
  82                                    test_hash<std::hash<int> >,
  83                                    test_compare<std::equal_to<int> >,
  84                                    A
  85                                    > C;
  86         typedef int P;
  87         P a[] =
  88         {
  89             P(1),
  90             P(2),
  91             P(3),
  92             P(4),
  93             P(1),
  94             P(2)
  95         };
  96         C c0(a, a + sizeof(a)/sizeof(a[0]),
  97             7,
  98             test_hash<std::hash<int> >(8),
  99             test_compare<std::equal_to<int> >(9),
 100             A(10)
 101            );
 102         C c(a, a + 2,
 103             7,
 104             test_hash<std::hash<int> >(2),
 105             test_compare<std::equal_to<int> >(3),
 106             A(10)
 107            );
 108         c = std::move(c0);
 109         LIBCPP_ASSERT(c.bucket_count() == 7);
 110         assert(c.size() == 4);
 111         assert(c.count(1) == 1);
 112         assert(c.count(2) == 1);
 113         assert(c.count(3) == 1);
 114         assert(c.count(4) == 1);
 115         assert(c.hash_function() == test_hash<std::hash<int> >(8));
 116         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
 117         assert(c.get_allocator() == A(10));
 118         assert(!c.empty());
 119         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 120         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 121         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 122         assert(c.max_load_factor() == 1);
 123     }
 124     {
 125         typedef other_allocator<int> A;
 126         typedef std::unordered_set<int,
 127                                    test_hash<std::hash<int> >,
 128                                    test_compare<std::equal_to<int> >,
 129                                    A
 130                                    > C;
 131         typedef int P;
 132         P a[] =
 133         {
 134             P(1),
 135             P(2),
 136             P(3),
 137             P(4),
 138             P(1),
 139             P(2)
 140         };
 141         C c0(a, a + sizeof(a)/sizeof(a[0]),
 142             7,
 143             test_hash<std::hash<int> >(8),
 144             test_compare<std::equal_to<int> >(9),
 145             A(10)
 146            );
 147         C c(a, a + 2,
 148             7,
 149             test_hash<std::hash<int> >(2),
 150             test_compare<std::equal_to<int> >(3),
 151             A(4)
 152            );
 153         c = std::move(c0);
 154         LIBCPP_ASSERT(c.bucket_count() == 7);
 155         assert(c.size() == 4);
 156         assert(c.count(1) == 1);
 157         assert(c.count(2) == 1);
 158         assert(c.count(3) == 1);
 159         assert(c.count(4) == 1);
 160         assert(c.hash_function() == test_hash<std::hash<int> >(8));
 161         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
 162         assert(c.get_allocator() == A(10));
 163         assert(!c.empty());
 164         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 165         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 166         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 167         assert(c.max_load_factor() == 1);
 168     }
 169     {
 170         typedef min_allocator<int> A;
 171         typedef std::unordered_set<int,
 172                                    test_hash<std::hash<int> >,
 173                                    test_compare<std::equal_to<int> >,
 174                                    A
 175                                    > C;
 176         typedef int P;
 177         P a[] =
 178         {
 179             P(1),
 180             P(2),
 181             P(3),
 182             P(4),
 183             P(1),
 184             P(2)
 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 = std::move(c0);
 199         LIBCPP_ASSERT(c.bucket_count() == 7);
 200         assert(c.size() == 4);
 201         assert(c.count(1) == 1);
 202         assert(c.count(2) == 1);
 203         assert(c.count(3) == 1);
 204         assert(c.count(4) == 1);
 205         assert(c.hash_function() == test_hash<std::hash<int> >(8));
 206         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
 207         assert(c.get_allocator() == A());
 208         assert(!c.empty());
 209         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 210         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 211         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 212         assert(c.max_load_factor() == 1);
 213     }
 214 }