libcxx/test/std/containers/associative/multiset/multiset.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 // <set>
  12
  13 // class multiset
  14
  15 // multiset(multiset&& s, const allocator_type& a);
  16
  17 #include <set>
  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 "Counter.h"
  26
  27 int main(int, char**)
  28 {
  29     {
  30         typedef MoveOnly V;
  31         typedef test_less<MoveOnly> C;
  32         typedef test_allocator<V> A;
  33         typedef std::multiset<MoveOnly, C, A> M;
  34         typedef std::move_iterator<V*> I;
  35         V a1[] =
  36         {
  37             V(1),
  38             V(1),
  39             V(1),
  40             V(2),
  41             V(2),
  42             V(2),
  43             V(3),
  44             V(3),
  45             V(3)
  46         };
  47         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
  48         V a2[] =
  49         {
  50             V(1),
  51             V(1),
  52             V(1),
  53             V(2),
  54             V(2),
  55             V(2),
  56             V(3),
  57             V(3),
  58             V(3)
  59         };
  60         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
  61         M m3(std::move(m1), A(7));
  62         assert(m3 == m2);
  63         assert(m3.get_allocator() == A(7));
  64         assert(m3.key_comp() == C(5));
  65         LIBCPP_ASSERT(m1.empty());
  66     }
  67     {
  68         typedef MoveOnly V;
  69         typedef test_less<MoveOnly> C;
  70         typedef test_allocator<V> A;
  71         typedef std::multiset<MoveOnly, C, A> M;
  72         typedef std::move_iterator<V*> I;
  73         V a1[] =
  74         {
  75             V(1),
  76             V(1),
  77             V(1),
  78             V(2),
  79             V(2),
  80             V(2),
  81             V(3),
  82             V(3),
  83             V(3)
  84         };
  85         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
  86         V a2[] =
  87         {
  88             V(1),
  89             V(1),
  90             V(1),
  91             V(2),
  92             V(2),
  93             V(2),
  94             V(3),
  95             V(3),
  96             V(3)
  97         };
  98         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
  99         M m3(std::move(m1), A(5));
 100         assert(m3 == m2);
 101         assert(m3.get_allocator() == A(5));
 102         assert(m3.key_comp() == C(5));
 103         LIBCPP_ASSERT(m1.empty());
 104     }
 105     {
 106         typedef MoveOnly V;
 107         typedef test_less<MoveOnly> C;
 108         typedef other_allocator<V> A;
 109         typedef std::multiset<MoveOnly, C, A> M;
 110         typedef std::move_iterator<V*> I;
 111         V a1[] =
 112         {
 113             V(1),
 114             V(1),
 115             V(1),
 116             V(2),
 117             V(2),
 118             V(2),
 119             V(3),
 120             V(3),
 121             V(3)
 122         };
 123         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
 124         V a2[] =
 125         {
 126             V(1),
 127             V(1),
 128             V(1),
 129             V(2),
 130             V(2),
 131             V(2),
 132             V(3),
 133             V(3),
 134             V(3)
 135         };
 136         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
 137         M m3(std::move(m1), A(5));
 138         assert(m3 == m2);
 139         assert(m3.get_allocator() == A(5));
 140         assert(m3.key_comp() == C(5));
 141         LIBCPP_ASSERT(m1.empty());
 142     }
 143     {
 144         typedef Counter<int> V;
 145         typedef std::less<V> C;
 146         typedef test_allocator<V> A;
 147         typedef std::multiset<V, C, A> M;
 148         typedef V* I;
 149         Counter_base::gConstructed = 0;
 150         {
 151             V a1[] =
 152             {
 153             V(1),
 154             V(1),
 155             V(1),
 156             V(2),
 157             V(2),
 158             V(2),
 159             V(3),
 160             V(3),
 161             V(3)
 162             };
 163             const std::size_t num = sizeof(a1)/sizeof(a1[0]);
 164             assert(Counter_base::gConstructed == num);
 165
 166             M m1(I(a1), I(a1+num), C(), A());
 167             assert(Counter_base::gConstructed == 2*num);
 168
 169             M m2(m1);
 170             assert(m2 == m1);
 171             assert(Counter_base::gConstructed == 3*num);
 172
 173             M m3(std::move(m1), A());
 174             assert(m3 == m2);
 175             LIBCPP_ASSERT(m1.empty());
 176             assert(Counter_base::gConstructed >= (int)(3*num));
 177             assert(Counter_base::gConstructed <= (int)(4*num));
 178
 179             {
 180             M m4(std::move(m2), A(5));
 181             assert(Counter_base::gConstructed >= (int)(3*num));
 182             assert(Counter_base::gConstructed <= (int)(5*num));
 183             assert(m4 == m3);
 184             LIBCPP_ASSERT(m2.empty());
 185             }
 186             assert(Counter_base::gConstructed >= (int)(2*num));
 187             assert(Counter_base::gConstructed <= (int)(4*num));
 188         }
 189         assert(Counter_base::gConstructed == 0);
 190     }
 191
 192   return 0;
 193 }