Home | History | Annotate | Download | only in set.cons
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 // <set>
     11 
     12 // class set
     13 
     14 // set& operator=(const set& s);
     15 
     16 #include <set>
     17 #include <cassert>
     18 
     19 #include "../../../test_compare.h"
     20 #include "test_allocator.h"
     21 
     22 int main()
     23 {
     24     {
     25         typedef int V;
     26         V ar[] =
     27         {
     28             1,
     29             1,
     30             1,
     31             2,
     32             2,
     33             2,
     34             3,
     35             3,
     36             3
     37         };
     38         typedef test_compare<std::less<int> > C;
     39         typedef test_allocator<V> A;
     40         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
     41         std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
     42         m = mo;
     43         assert(m.get_allocator() == A(7));
     44         assert(m.key_comp() == C(5));
     45         assert(m.size() == 3);
     46         assert(distance(m.begin(), m.end()) == 3);
     47         assert(*m.begin() == 1);
     48         assert(*next(m.begin()) == 2);
     49         assert(*next(m.begin(), 2) == 3);
     50 
     51         assert(mo.get_allocator() == A(2));
     52         assert(mo.key_comp() == C(5));
     53         assert(mo.size() == 3);
     54         assert(distance(mo.begin(), mo.end()) == 3);
     55         assert(*mo.begin() == 1);
     56         assert(*next(mo.begin()) == 2);
     57         assert(*next(mo.begin(), 2) == 3);
     58     }
     59     {
     60         typedef int V;
     61         const V ar[] =
     62         {
     63             1,
     64             2,
     65             3
     66         };
     67         std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
     68         std::set<int> *p = &m;
     69         m = *p;
     70 
     71         assert(m.size() == 3);
     72         assert(std::equal(m.begin(), m.end(), ar));
     73     }
     74     {
     75         typedef int V;
     76         V ar[] =
     77         {
     78             1,
     79             1,
     80             1,
     81             2,
     82             2,
     83             2,
     84             3,
     85             3,
     86             3
     87         };
     88         typedef test_compare<std::less<int> > C;
     89         typedef other_allocator<V> A;
     90         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
     91         std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
     92         m = mo;
     93         assert(m.get_allocator() == A(2));
     94         assert(m.key_comp() == C(5));
     95         assert(m.size() == 3);
     96         assert(distance(m.begin(), m.end()) == 3);
     97         assert(*m.begin() == 1);
     98         assert(*next(m.begin()) == 2);
     99         assert(*next(m.begin(), 2) == 3);
    100 
    101         assert(mo.get_allocator() == A(2));
    102         assert(mo.key_comp() == C(5));
    103         assert(mo.size() == 3);
    104         assert(distance(mo.begin(), mo.end()) == 3);
    105         assert(*mo.begin() == 1);
    106         assert(*next(mo.begin()) == 2);
    107         assert(*next(mo.begin(), 2) == 3);
    108     }
    109 }
    110