libcxx/test/std/containers/associative/set/set.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 // <set>
  10
  11 // class set
  12
  13 // void swap(set& m);
  14
  15 #include <set>
  16 #include <cassert>
  17 #include "test_macros.h"
  18 #include "test_allocator.h"
  19 #include "../../../test_compare.h"
  20
  21 int main(int, char**)
  22 {
  23     typedef int V;
  24     {
  25     typedef std::set<int> M;
  26     {
  27         M m1;
  28         M m2;
  29         M m1_save = m1;
  30         M m2_save = m2;
  31         swap(m1, m2);
  32         assert(m1 == m2_save);
  33         assert(m2 == m1_save);
  34     }
  35     {
  36         V ar2[] =
  37         {
  38             5,
  39             6,
  40             7,
  41             8,
  42             9,
  43             10,
  44             11,
  45             12
  46         };
  47         M m1;
  48         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
  49         M m1_save = m1;
  50         M m2_save = m2;
  51         swap(m1, m2);
  52         assert(m1 == m2_save);
  53         assert(m2 == m1_save);
  54     }
  55     {
  56         V ar1[] =
  57         {
  58             1,
  59             2,
  60             3,
  61             4
  62         };
  63         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
  64         M m2;
  65         M m1_save = m1;
  66         M m2_save = m2;
  67         swap(m1, m2);
  68         assert(m1 == m2_save);
  69         assert(m2 == m1_save);
  70     }
  71     {
  72         V ar1[] =
  73         {
  74             1,
  75             2,
  76             3,
  77             4
  78         };
  79         V ar2[] =
  80         {
  81             5,
  82             6,
  83             7,
  84             8,
  85             9,
  86             10,
  87             11,
  88             12
  89         };
  90         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
  91         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
  92         M m1_save = m1;
  93         M m2_save = m2;
  94         swap(m1, m2);
  95         assert(m1 == m2_save);
  96         assert(m2 == m1_save);
  97     }
  98     }
  99     {
 100         typedef test_allocator<V> A;
 101         typedef test_less<int> C;
 102         typedef std::set<int, C, A> M;
 103         V ar1[] =
 104         {
 105             1,
 106             2,
 107             3,
 108             4
 109         };
 110         V ar2[] =
 111         {
 112             5,
 113             6,
 114             7,
 115             8,
 116             9,
 117             10,
 118             11,
 119             12
 120         };
 121         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1, 1));
 122         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(1, 2));
 123         M m1_save = m1;
 124         M m2_save = m2;
 125         swap(m1, m2);
 126         assert(m1 == m2_save);
 127         assert(m2 == m1_save);
 128         assert(m1.key_comp() == C(2));
 129         assert(m1.get_allocator().get_id() == 1);
 130         assert(m2.key_comp() == C(1));
 131         assert(m2.get_allocator().get_id() == 2);
 132     }
 133     {
 134         typedef other_allocator<V> A;
 135         typedef test_less<int> C;
 136         typedef std::set<int, C, A> M;
 137         V ar1[] =
 138         {
 139             1,
 140             2,
 141             3,
 142             4
 143         };
 144         V ar2[] =
 145         {
 146             5,
 147             6,
 148             7,
 149             8,
 150             9,
 151             10,
 152             11,
 153             12
 154         };
 155         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1));
 156         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(2));
 157         M m1_save = m1;
 158         M m2_save = m2;
 159         swap(m1, m2);
 160         assert(m1 == m2_save);
 161         assert(m2 == m1_save);
 162         assert(m1.key_comp() == C(2));
 163         assert(m1.get_allocator() == A(2));
 164         assert(m2.key_comp() == C(1));
 165         assert(m2.get_allocator() == A(1));
 166     }
 167
 168   return 0;
 169 }