libcxx/test/std/containers/associative/map/map.special/non_member_swap.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 // template <class Key, class T, class Compare, class Allocator>
  14 //   void
  15 //   swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y);
  16
  17 #include <map>
  18 #include <cassert>
  19 #include "test_macros.h"
  20 #include "test_allocator.h"
  21 #include "../../../test_compare.h"
  22 #include "min_allocator.h"
  23
  24 int main(int, char**)
  25 {
  26     typedef std::pair<const int, double> V;
  27     {
  28     typedef std::map<int, double> M;
  29     {
  30         M m1;
  31         M m2;
  32         M m1_save = m1;
  33         M m2_save = m2;
  34         swap(m1, m2);
  35         assert(m1 == m2_save);
  36         assert(m2 == m1_save);
  37     }
  38     {
  39         V ar2[] =
  40         {
  41             V(5, 5),
  42             V(6, 6),
  43             V(7, 7),
  44             V(8, 8),
  45             V(9, 9),
  46             V(10, 10),
  47             V(11, 11),
  48             V(12, 12)
  49         };
  50         M m1;
  51         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
  52         M m1_save = m1;
  53         M m2_save = m2;
  54         swap(m1, m2);
  55         assert(m1 == m2_save);
  56         assert(m2 == m1_save);
  57     }
  58     {
  59         V ar1[] =
  60         {
  61             V(1, 1),
  62             V(2, 2),
  63             V(3, 3),
  64             V(4, 4)
  65         };
  66         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
  67         M m2;
  68         M m1_save = m1;
  69         M m2_save = m2;
  70         swap(m1, m2);
  71         assert(m1 == m2_save);
  72         assert(m2 == m1_save);
  73     }
  74     {
  75         V ar1[] =
  76         {
  77             V(1, 1),
  78             V(2, 2),
  79             V(3, 3),
  80             V(4, 4)
  81         };
  82         V ar2[] =
  83         {
  84             V(5, 5),
  85             V(6, 6),
  86             V(7, 7),
  87             V(8, 8),
  88             V(9, 9),
  89             V(10, 10),
  90             V(11, 11),
  91             V(12, 12)
  92         };
  93         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
  94         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
  95         M m1_save = m1;
  96         M m2_save = m2;
  97         swap(m1, m2);
  98         assert(m1 == m2_save);
  99         assert(m2 == m1_save);
 100     }
 101     }
 102     {
 103         typedef test_allocator<V> A;
 104         typedef test_less<int> C;
 105         typedef std::map<int, double, C, A> M;
 106         V ar1[] =
 107         {
 108             V(1, 1),
 109             V(2, 2),
 110             V(3, 3),
 111             V(4, 4)
 112         };
 113         V ar2[] =
 114         {
 115             V(5, 5),
 116             V(6, 6),
 117             V(7, 7),
 118             V(8, 8),
 119             V(9, 9),
 120             V(10, 10),
 121             V(11, 11),
 122             V(12, 12)
 123         };
 124         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1, 1));
 125         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(1, 2));
 126         M m1_save = m1;
 127         M m2_save = m2;
 128         swap(m1, m2);
 129         assert(m1 == m2_save);
 130         assert(m2 == m1_save);
 131         assert(m1.key_comp() == C(2));
 132         assert(m1.get_allocator().get_id() == 1); // not swapped
 133         assert(m2.key_comp() == C(1));
 134         assert(m2.get_allocator().get_id() == 2);
 135     }
 136     {
 137         typedef other_allocator<V> A;
 138         typedef test_less<int> C;
 139         typedef std::map<int, double, C, A> M;
 140         V ar1[] =
 141         {
 142             V(1, 1),
 143             V(2, 2),
 144             V(3, 3),
 145             V(4, 4)
 146         };
 147         V ar2[] =
 148         {
 149             V(5, 5),
 150             V(6, 6),
 151             V(7, 7),
 152             V(8, 8),
 153             V(9, 9),
 154             V(10, 10),
 155             V(11, 11),
 156             V(12, 12)
 157         };
 158         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1));
 159         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(2));
 160         M m1_save = m1;
 161         M m2_save = m2;
 162         swap(m1, m2);
 163         assert(m1 == m2_save);
 164         assert(m2 == m1_save);
 165         assert(m1.key_comp() == C(2));
 166         assert(m1.get_allocator() == A(2));
 167         assert(m2.key_comp() == C(1));
 168         assert(m2.get_allocator() == A(1));
 169     }
 170 #if TEST_STD_VER >= 11
 171     {
 172     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
 173     {
 174         M m1;
 175         M m2;
 176         M m1_save = m1;
 177         M m2_save = m2;
 178         swap(m1, m2);
 179         assert(m1 == m2_save);
 180         assert(m2 == m1_save);
 181     }
 182     {
 183         V ar2[] =
 184         {
 185             V(5, 5),
 186             V(6, 6),
 187             V(7, 7),
 188             V(8, 8),
 189             V(9, 9),
 190             V(10, 10),
 191             V(11, 11),
 192             V(12, 12)
 193         };
 194         M m1;
 195         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
 196         M m1_save = m1;
 197         M m2_save = m2;
 198         swap(m1, m2);
 199         assert(m1 == m2_save);
 200         assert(m2 == m1_save);
 201     }
 202     {
 203         V ar1[] =
 204         {
 205             V(1, 1),
 206             V(2, 2),
 207             V(3, 3),
 208             V(4, 4)
 209         };
 210         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
 211         M m2;
 212         M m1_save = m1;
 213         M m2_save = m2;
 214         swap(m1, m2);
 215         assert(m1 == m2_save);
 216         assert(m2 == m1_save);
 217     }
 218     {
 219         V ar1[] =
 220         {
 221             V(1, 1),
 222             V(2, 2),
 223             V(3, 3),
 224             V(4, 4)
 225         };
 226         V ar2[] =
 227         {
 228             V(5, 5),
 229             V(6, 6),
 230             V(7, 7),
 231             V(8, 8),
 232             V(9, 9),
 233             V(10, 10),
 234             V(11, 11),
 235             V(12, 12)
 236         };
 237         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
 238         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
 239         M m1_save = m1;
 240         M m2_save = m2;
 241         swap(m1, m2);
 242         assert(m1 == m2_save);
 243         assert(m2 == m1_save);
 244     }
 245     }
 246     {
 247         typedef min_allocator<V> A;
 248         typedef test_less<int> C;
 249         typedef std::map<int, double, C, A> M;
 250         V ar1[] =
 251         {
 252             V(1, 1),
 253             V(2, 2),
 254             V(3, 3),
 255             V(4, 4)
 256         };
 257         V ar2[] =
 258         {
 259             V(5, 5),
 260             V(6, 6),
 261             V(7, 7),
 262             V(8, 8),
 263             V(9, 9),
 264             V(10, 10),
 265             V(11, 11),
 266             V(12, 12)
 267         };
 268         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A());
 269         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A());
 270         M m1_save = m1;
 271         M m2_save = m2;
 272         swap(m1, m2);
 273         assert(m1 == m2_save);
 274         assert(m2 == m1_save);
 275         assert(m1.key_comp() == C(2));
 276         assert(m1.get_allocator() == A());
 277         assert(m2.key_comp() == C(1));
 278         assert(m2.get_allocator() == A());
 279     }
 280 #endif
 281
 282   return 0;
 283 }