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