libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03
  10
  11 // <map>
  12
  13 // class map
  14
  15 // map(map&& m, const allocator_type& a);
  16
  17 #include <map>
  18 #include <cassert>
  19 #include <iterator>
  20
  21 #include "test_macros.h"
  22 #include "MoveOnly.h"
  23 #include "../../../test_compare.h"
  24 #include "test_allocator.h"
  25 #include "min_allocator.h"
  26 #include "Counter.h"
  27
  28 int main(int, char**)
  29 {
  30     {
  31         typedef std::pair<MoveOnly, MoveOnly> V;
  32         typedef std::pair<const MoveOnly, MoveOnly> VC;
  33         typedef test_less<MoveOnly> C;
  34         typedef test_allocator<VC> A;
  35         typedef std::map<MoveOnly, MoveOnly, C, A> M;
  36         typedef std::move_iterator<V*> I;
  37         V a1[] =
  38         {
  39             V(1, 1),
  40             V(1, 2),
  41             V(1, 3),
  42             V(2, 1),
  43             V(2, 2),
  44             V(2, 3),
  45             V(3, 1),
  46             V(3, 2),
  47             V(3, 3)
  48         };
  49         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
  50         V a2[] =
  51         {
  52             V(1, 1),
  53             V(1, 2),
  54             V(1, 3),
  55             V(2, 1),
  56             V(2, 2),
  57             V(2, 3),
  58             V(3, 1),
  59             V(3, 2),
  60             V(3, 3)
  61         };
  62         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
  63         M m3(std::move(m1), A(7));
  64         assert(m3 == m2);
  65         assert(m3.get_allocator() == A(7));
  66         assert(m3.key_comp() == C(5));
  67         LIBCPP_ASSERT(m1.empty());
  68     }
  69     {
  70         typedef std::pair<MoveOnly, MoveOnly> V;
  71         typedef std::pair<const MoveOnly, MoveOnly> VC;
  72         typedef test_less<MoveOnly> C;
  73         typedef test_allocator<VC> A;
  74         typedef std::map<MoveOnly, MoveOnly, C, A> M;
  75         typedef std::move_iterator<V*> I;
  76         V a1[] =
  77         {
  78             V(1, 1),
  79             V(1, 2),
  80             V(1, 3),
  81             V(2, 1),
  82             V(2, 2),
  83             V(2, 3),
  84             V(3, 1),
  85             V(3, 2),
  86             V(3, 3)
  87         };
  88         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
  89         V a2[] =
  90         {
  91             V(1, 1),
  92             V(1, 2),
  93             V(1, 3),
  94             V(2, 1),
  95             V(2, 2),
  96             V(2, 3),
  97             V(3, 1),
  98             V(3, 2),
  99             V(3, 3)
 100         };
 101         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
 102         M m3(std::move(m1), A(5));
 103         assert(m3 == m2);
 104         assert(m3.get_allocator() == A(5));
 105         assert(m3.key_comp() == C(5));
 106         LIBCPP_ASSERT(m1.empty());
 107     }
 108     {
 109         typedef std::pair<MoveOnly, MoveOnly> V;
 110         typedef std::pair<const MoveOnly, MoveOnly> VC;
 111         typedef test_less<MoveOnly> C;
 112         typedef other_allocator<VC> A;
 113         typedef std::map<MoveOnly, MoveOnly, C, A> M;
 114         typedef std::move_iterator<V*> I;
 115         V a1[] =
 116         {
 117             V(1, 1),
 118             V(1, 2),
 119             V(1, 3),
 120             V(2, 1),
 121             V(2, 2),
 122             V(2, 3),
 123             V(3, 1),
 124             V(3, 2),
 125             V(3, 3)
 126         };
 127         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
 128         V a2[] =
 129         {
 130             V(1, 1),
 131             V(1, 2),
 132             V(1, 3),
 133             V(2, 1),
 134             V(2, 2),
 135             V(2, 3),
 136             V(3, 1),
 137             V(3, 2),
 138             V(3, 3)
 139         };
 140         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
 141         M m3(std::move(m1), A(5));
 142         assert(m3 == m2);
 143         assert(m3.get_allocator() == A(5));
 144         assert(m3.key_comp() == C(5));
 145         LIBCPP_ASSERT(m1.empty());
 146     }
 147     {
 148         typedef Counter<int> T;
 149         typedef std::pair<int, T> V;
 150         typedef std::pair<const int, T> VC;
 151         typedef test_allocator<VC> A;
 152         typedef std::less<int> C;
 153         typedef std::map<const int, T, C, A> M;
 154         typedef V* I;
 155         Counter_base::gConstructed = 0;
 156         {
 157             V a1[] =
 158             {
 159                 V(1, 1),
 160                 V(1, 2),
 161                 V(1, 3),
 162                 V(2, 1),
 163                 V(2, 2),
 164                 V(2, 3),
 165                 V(3, 1),
 166                 V(3, 2),
 167                 V(3, 3)
 168             };
 169             const std::size_t num = sizeof(a1)/sizeof(a1[0]);
 170             assert(Counter_base::gConstructed == num);
 171
 172             M m1(I(a1), I(a1+num), C(), A());
 173             assert(Counter_base::gConstructed == num+3);
 174
 175             M m2(m1);
 176             assert(m2 == m1);
 177             assert(Counter_base::gConstructed == num+6);
 178
 179             M m3(std::move(m1), A());
 180             assert(m3 == m2);
 181             LIBCPP_ASSERT(m1.empty());
 182             assert(Counter_base::gConstructed >= (int)(num+6));
 183             assert(Counter_base::gConstructed <= (int)(num+6+m1.size()));
 184
 185             {
 186             M m4(std::move(m2), A(5));
 187             assert(Counter_base::gConstructed >= (int)(num+6));
 188             assert(Counter_base::gConstructed <= (int)(num+6+m1.size()+m2.size()));
 189             assert(m4 == m3);
 190             LIBCPP_ASSERT(m2.empty());
 191             }
 192             assert(Counter_base::gConstructed >= (int)(num+3));
 193             assert(Counter_base::gConstructed <= (int)(num+3+m1.size()+m2.size()));
 194         }
 195         assert(Counter_base::gConstructed == 0);
 196     }
 197     {
 198         typedef std::pair<MoveOnly, MoveOnly> V;
 199         typedef std::pair<const MoveOnly, MoveOnly> VC;
 200         typedef test_less<MoveOnly> C;
 201         typedef min_allocator<VC> A;
 202         typedef std::map<MoveOnly, MoveOnly, C, A> M;
 203         typedef std::move_iterator<V*> I;
 204         V a1[] =
 205         {
 206             V(1, 1),
 207             V(1, 2),
 208             V(1, 3),
 209             V(2, 1),
 210             V(2, 2),
 211             V(2, 3),
 212             V(3, 1),
 213             V(3, 2),
 214             V(3, 3)
 215         };
 216         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A());
 217         V a2[] =
 218         {
 219             V(1, 1),
 220             V(1, 2),
 221             V(1, 3),
 222             V(2, 1),
 223             V(2, 2),
 224             V(2, 3),
 225             V(3, 1),
 226             V(3, 2),
 227             V(3, 3)
 228         };
 229         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A());
 230         M m3(std::move(m1), A());
 231         assert(m3 == m2);
 232         assert(m3.get_allocator() == A());
 233         assert(m3.key_comp() == C(5));
 234         LIBCPP_ASSERT(m1.empty());
 235     }
 236     {
 237         typedef std::pair<MoveOnly, MoveOnly> V;
 238         typedef std::pair<const MoveOnly, MoveOnly> VC;
 239         typedef test_less<MoveOnly> C;
 240         typedef explicit_allocator<VC> A;
 241         typedef std::map<MoveOnly, MoveOnly, C, A> M;
 242         typedef std::move_iterator<V*> I;
 243         V a1[] =
 244         {
 245             V(1, 1),
 246             V(1, 2),
 247             V(1, 3),
 248             V(2, 1),
 249             V(2, 2),
 250             V(2, 3),
 251             V(3, 1),
 252             V(3, 2),
 253             V(3, 3)
 254         };
 255         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A{});
 256         V a2[] =
 257         {
 258             V(1, 1),
 259             V(1, 2),
 260             V(1, 3),
 261             V(2, 1),
 262             V(2, 2),
 263             V(2, 3),
 264             V(3, 1),
 265             V(3, 2),
 266             V(3, 3)
 267         };
 268         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A{});
 269         M m3(std::move(m1), A{});
 270         assert(m3 == m2);
 271         assert(m3.get_allocator() == A{});
 272         assert(m3.key_comp() == C(5));
 273         LIBCPP_ASSERT(m1.empty());
 274     }
 275
 276   return 0;
 277 }