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