libcxx/test/std/containers/associative/multiset/multiset.cons/move_assign.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& operator=(multiset&& s);
  16
  17 #include <set>
  18 #include <cassert>
  19
  20 #include "test_macros.h"
  21 #include "MoveOnly.h"
  22 #include "../../../test_compare.h"
  23 #include "test_allocator.h"
  24 #include "min_allocator.h"
  25
  26 int main(int, char**)
  27 {
  28     {
  29         typedef MoveOnly V;
  30         typedef test_less<MoveOnly> C;
  31         typedef test_allocator<V> A;
  32         typedef std::multiset<MoveOnly, C, A> M;
  33         typedef std::move_iterator<V*> I;
  34         V a1[] =
  35         {
  36             V(1),
  37             V(1),
  38             V(1),
  39             V(2),
  40             V(2),
  41             V(2),
  42             V(3),
  43             V(3),
  44             V(3)
  45         };
  46         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
  47         V a2[] =
  48         {
  49             V(1),
  50             V(1),
  51             V(1),
  52             V(2),
  53             V(2),
  54             V(2),
  55             V(3),
  56             V(3),
  57             V(3)
  58         };
  59         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
  60         M m3(C(3), A(7));
  61         m3 = std::move(m1);
  62         assert(m3 == m2);
  63         assert(m3.get_allocator() == A(7));
  64         assert(m3.key_comp() == C(5));
  65         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(C(3), A(5));
 100         m3 = std::move(m1);
 101         assert(m3 == m2);
 102         assert(m3.get_allocator() == A(5));
 103         assert(m3.key_comp() == C(5));
 104         LIBCPP_ASSERT(m1.empty());
 105     }
 106     {
 107         typedef MoveOnly V;
 108         typedef test_less<MoveOnly> C;
 109         typedef other_allocator<V> A;
 110         typedef std::multiset<MoveOnly, C, A> M;
 111         typedef std::move_iterator<V*> I;
 112         V a1[] =
 113         {
 114             V(1),
 115             V(1),
 116             V(1),
 117             V(2),
 118             V(2),
 119             V(2),
 120             V(3),
 121             V(3),
 122             V(3)
 123         };
 124         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
 125         V a2[] =
 126         {
 127             V(1),
 128             V(1),
 129             V(1),
 130             V(2),
 131             V(2),
 132             V(2),
 133             V(3),
 134             V(3),
 135             V(3)
 136         };
 137         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
 138         M m3(C(3), A(5));
 139         m3 = std::move(m1);
 140         assert(m3 == m2);
 141         assert(m3.get_allocator() == A(7));
 142         assert(m3.key_comp() == C(5));
 143         assert(m1.empty());
 144     }
 145     {
 146         typedef MoveOnly V;
 147         typedef test_less<MoveOnly> C;
 148         typedef min_allocator<V> A;
 149         typedef std::multiset<MoveOnly, C, A> M;
 150         typedef std::move_iterator<V*> I;
 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         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A());
 164         V a2[] =
 165         {
 166             V(1),
 167             V(1),
 168             V(1),
 169             V(2),
 170             V(2),
 171             V(2),
 172             V(3),
 173             V(3),
 174             V(3)
 175         };
 176         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A());
 177         M m3(C(3), A());
 178         m3 = std::move(m1);
 179         assert(m3 == m2);
 180         assert(m3.get_allocator() == A());
 181         assert(m3.key_comp() == C(5));
 182         assert(m1.empty());
 183     }
 184
 185   return 0;
 186 }