libcxx/test/std/containers/associative/multimap/multimap.cons/move.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 multimap
  14
  15 // multimap(multimap&& m);
  16
  17 #include <map>
  18 #include <cassert>
  19
  20 #include "test_macros.h"
  21 #include "../../../test_compare.h"
  22 #include "test_allocator.h"
  23 #include "min_allocator.h"
  24
  25 int main(int, char**)
  26 {
  27     typedef std::pair<const int, double> V;
  28     {
  29         typedef test_less<int> C;
  30         typedef test_allocator<V> A;
  31         std::multimap<int, double, C, A> mo(C(5), A(7));
  32         std::multimap<int, double, C, A> m = std::move(mo);
  33         assert(m.get_allocator() == A(7));
  34         assert(m.key_comp() == C(5));
  35         assert(m.size() == 0);
  36         assert(std::distance(m.begin(), m.end()) == 0);
  37
  38         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
  39         assert(mo.key_comp() == C(5));
  40         assert(mo.size() == 0);
  41         assert(std::distance(mo.begin(), mo.end()) == 0);
  42     }
  43     {
  44         V ar[] =
  45         {
  46             V(1, 1),
  47             V(1, 1.5),
  48             V(1, 2),
  49             V(2, 1),
  50             V(2, 1.5),
  51             V(2, 2),
  52             V(3, 1),
  53             V(3, 1.5),
  54             V(3, 2),
  55         };
  56         typedef test_less<int> C;
  57         typedef test_allocator<V> A;
  58         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
  59         std::multimap<int, double, C, A> m = std::move(mo);
  60         assert(m.get_allocator() == A(7));
  61         assert(m.key_comp() == C(5));
  62         assert(m.size() == 9);
  63         assert(std::distance(m.begin(), m.end()) == 9);
  64         assert(*m.begin() == V(1, 1));
  65         assert(*std::next(m.begin()) == V(1, 1.5));
  66         assert(*std::next(m.begin(), 2) == V(1, 2));
  67         assert(*std::next(m.begin(), 3) == V(2, 1));
  68         assert(*std::next(m.begin(), 4) == V(2, 1.5));
  69         assert(*std::next(m.begin(), 5) == V(2, 2));
  70         assert(*std::next(m.begin(), 6) == V(3, 1));
  71         assert(*std::next(m.begin(), 7) == V(3, 1.5));
  72         assert(*std::next(m.begin(), 8) == V(3, 2));
  73
  74         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
  75         assert(mo.key_comp() == C(5));
  76         assert(mo.size() == 0);
  77         assert(std::distance(mo.begin(), mo.end()) == 0);
  78     }
  79     {
  80         typedef test_less<int> C;
  81         typedef min_allocator<V> A;
  82         std::multimap<int, double, C, A> mo(C(5), A());
  83         std::multimap<int, double, C, A> m = std::move(mo);
  84         assert(m.get_allocator() == A());
  85         assert(m.key_comp() == C(5));
  86         assert(m.size() == 0);
  87         assert(std::distance(m.begin(), m.end()) == 0);
  88
  89         assert(mo.get_allocator() == A());
  90         assert(mo.key_comp() == C(5));
  91         assert(mo.size() == 0);
  92         assert(std::distance(mo.begin(), mo.end()) == 0);
  93     }
  94     {
  95         V ar[] =
  96         {
  97             V(1, 1),
  98             V(1, 1.5),
  99             V(1, 2),
 100             V(2, 1),
 101             V(2, 1.5),
 102             V(2, 2),
 103             V(3, 1),
 104             V(3, 1.5),
 105             V(3, 2),
 106         };
 107         typedef test_less<int> C;
 108         typedef min_allocator<V> A;
 109         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
 110         std::multimap<int, double, C, A> m = std::move(mo);
 111         assert(m.get_allocator() == A());
 112         assert(m.key_comp() == C(5));
 113         assert(m.size() == 9);
 114         assert(std::distance(m.begin(), m.end()) == 9);
 115         assert(*m.begin() == V(1, 1));
 116         assert(*std::next(m.begin()) == V(1, 1.5));
 117         assert(*std::next(m.begin(), 2) == V(1, 2));
 118         assert(*std::next(m.begin(), 3) == V(2, 1));
 119         assert(*std::next(m.begin(), 4) == V(2, 1.5));
 120         assert(*std::next(m.begin(), 5) == V(2, 2));
 121         assert(*std::next(m.begin(), 6) == V(3, 1));
 122         assert(*std::next(m.begin(), 7) == V(3, 1.5));
 123         assert(*std::next(m.begin(), 8) == V(3, 2));
 124
 125         assert(mo.get_allocator() == A());
 126         assert(mo.key_comp() == C(5));
 127         assert(mo.size() == 0);
 128         assert(std::distance(mo.begin(), mo.end()) == 0);
 129     }
 130
 131   return 0;
 132 }