Home | History | Annotate | Download | only in set.special 
      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 // void swap(set& m);
     15 
     16 #include <set>
     17 #include <cassert>
     18 
     19 #include "min_allocator.h"
     20 
     21 int main()
     22 {
     23     {
     24     typedef int V;
     25     typedef std::set<int> M;
     26     {
     27         M m1;
     28         M m2;
     29         M m1_save = m1;
     30         M m2_save = m2;
     31         m1.swap(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         m1.swap(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         m1.swap(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         m1.swap(m2);
     95         assert(m1 == m2_save);
     96         assert(m2 == m1_save);
     97     }
     98     }
     99 #if TEST_STD_VER >= 11
    100     {
    101     typedef int V;
    102     typedef std::set<int, std::less<int>, min_allocator<int>> M;
    103     {
    104         M m1;
    105         M m2;
    106         M m1_save = m1;
    107         M m2_save = m2;
    108         m1.swap(m2);
    109         assert(m1 == m2_save);
    110         assert(m2 == m1_save);
    111     }
    112     {
    113         V ar2[] =
    114         {
    115             5,
    116             6,
    117             7,
    118             8,
    119             9,
    120             10,
    121             11,
    122             12
    123         };
    124         M m1;
    125         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
    126         M m1_save = m1;
    127         M m2_save = m2;
    128         m1.swap(m2);
    129         assert(m1 == m2_save);
    130         assert(m2 == m1_save);
    131     }
    132     {
    133         V ar1[] =
    134         {
    135             1,
    136             2,
    137             3,
    138             4
    139         };
    140         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
    141         M m2;
    142         M m1_save = m1;
    143         M m2_save = m2;
    144         m1.swap(m2);
    145         assert(m1 == m2_save);
    146         assert(m2 == m1_save);
    147     }
    148     {
    149         V ar1[] =
    150         {
    151             1,
    152             2,
    153             3,
    154             4
    155         };
    156         V ar2[] =
    157         {
    158             5,
    159             6,
    160             7,
    161             8,
    162             9,
    163             10,
    164             11,
    165             12
    166         };
    167         M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
    168         M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
    169         M m1_save = m1;
    170         M m2_save = m2;
    171         m1.swap(m2);
    172         assert(m1 == m2_save);
    173         assert(m2 == m1_save);
    174     }
    175     }
    176 #endif
    177 }
    178