test/std/containers/associative/map/map.cons/copy_assign.pass.cpp

   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 // <map>
  11
  12 // class map
  13
  14 // map& operator=(const map& m);
  15
  16 #include <map>
  17 #include <cassert>
  18 #include <vector>
  19 #include <algorithm>
  20 #include <iterator>
  21
  22 #include <iostream>
  23
  24 #include "../../../test_compare.h"
  25 #include "test_allocator.h"
  26 #include "min_allocator.h"
  27
  28 #if TEST_STD_VER >= 11
  29 std::vector<int> ca_allocs;
  30 std::vector<int> ca_deallocs;
  31
  32 template <class T>
  33 class counting_allocatorT {
  34 public:
  35     typedef T value_type;
  36     int foo{0};
  37     counting_allocatorT(int f) noexcept : foo(f) {}
  38
  39     using propagate_on_container_copy_assignment = std::true_type;
  40     template <class U> counting_allocatorT(const counting_allocatorT<U>& other) noexcept {foo = other.foo;}
  41     template <class U> bool operator==(const counting_allocatorT<U>& other) const noexcept { return foo == other.foo; }
  42     template <class U> bool operator!=(const counting_allocatorT<U>& other) const noexcept { return foo != other.foo; }
  43
  44     T * allocate(const size_t n) const {
  45         ca_allocs.push_back(foo);
  46         void * const pv = ::malloc(n * sizeof(T));
  47         return static_cast<T *>(pv);
  48     }
  49     void deallocate(T * const p, size_t) const noexcept {
  50         ca_deallocs.push_back(foo);
  51         free(p);
  52     }
  53 };
  54
  55 template <class T>
  56 class counting_allocatorF {
  57 public:
  58     typedef T value_type;
  59     int foo{0};
  60     counting_allocatorF(int f) noexcept : foo(f) {}
  61
  62     using propagate_on_container_copy_assignment = std::false_type;
  63     template <class U> counting_allocatorF(const counting_allocatorF<U>& other) noexcept {foo = other.foo;}
  64     template <class U> bool operator==(const counting_allocatorF<U>& other) const noexcept { return foo == other.foo; }
  65     template <class U> bool operator!=(const counting_allocatorF<U>& other) const noexcept { return foo != other.foo; }
  66
  67     T * allocate(const size_t n) const {
  68         ca_allocs.push_back(foo);
  69         void * const pv = ::malloc(n * sizeof(T));
  70         return static_cast<T *>(pv);
  71     }
  72     void deallocate(T * const p, size_t) const noexcept {
  73         ca_deallocs.push_back(foo);
  74         free(p);
  75     }
  76 };
  77
  78 bool balanced_allocs() {
  79     std::vector<int> temp1, temp2;
  80
  81     std::cout << "Allocations = " << ca_allocs.size() << ", deallocatons = " << ca_deallocs.size() << std::endl;
  82     if (ca_allocs.size() != ca_deallocs.size())
  83         return false;
  84
  85     temp1 = ca_allocs;
  86     std::sort(temp1.begin(), temp1.end());
  87     temp2.clear();
  88     std::unique_copy(temp1.begin(), temp1.end(), std::back_inserter<std::vector<int>>(temp2));
  89     std::cout << "There were " << temp2.size() << " different allocators\n";
  90
  91     for (std::vector<int>::const_iterator it = temp2.begin(); it != temp2.end(); ++it ) {
  92         std::cout << *it << ": " << std::count(ca_allocs.begin(), ca_allocs.end(), *it) << " vs " << std::count(ca_deallocs.begin(), ca_deallocs.end(), *it) << std::endl;
  93         if ( std::count(ca_allocs.begin(), ca_allocs.end(), *it) != std::count(ca_deallocs.begin(), ca_deallocs.end(), *it))
  94             return false;
  95         }
  96
  97     temp1 = ca_allocs;
  98     std::sort(temp1.begin(), temp1.end());
  99     temp2.clear();
 100     std::unique_copy(temp1.begin(), temp1.end(), std::back_inserter<std::vector<int>>(temp2));
 101     std::cout << "There were " << temp2.size() << " different (de)allocators\n";
 102     for (std::vector<int>::const_iterator it = ca_deallocs.begin(); it != ca_deallocs.end(); ++it ) {
 103         std::cout << *it << ": " << std::count(ca_allocs.begin(), ca_allocs.end(), *it) << " vs " << std::count(ca_deallocs.begin(), ca_deallocs.end(), *it) << std::endl;
 104         if ( std::count(ca_allocs.begin(), ca_allocs.end(), *it) != std::count(ca_deallocs.begin(), ca_deallocs.end(), *it))
 105             return false;
 106         }
 107
 108     return true;
 109     }
 110 #endif
 111
 112 int main()
 113 {
 114     {
 115         typedef std::pair<const int, double> V;
 116         V ar[] =
 117         {
 118             V(1, 1),
 119             V(1, 1.5),
 120             V(1, 2),
 121             V(2, 1),
 122             V(2, 1.5),
 123             V(2, 2),
 124             V(3, 1),
 125             V(3, 1.5),
 126             V(3, 2)
 127         };
 128         typedef test_compare<std::less<int> > C;
 129         typedef test_allocator<V> A;
 130         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
 131         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
 132         m = mo;
 133         assert(m.get_allocator() == A(7));
 134         assert(m.key_comp() == C(5));
 135         assert(m.size() == 3);
 136         assert(distance(m.begin(), m.end()) == 3);
 137         assert(*m.begin() == V(1, 1));
 138         assert(*next(m.begin()) == V(2, 1));
 139         assert(*next(m.begin(), 2) == V(3, 1));
 140
 141         assert(mo.get_allocator() == A(2));
 142         assert(mo.key_comp() == C(5));
 143         assert(mo.size() == 3);
 144         assert(distance(mo.begin(), mo.end()) == 3);
 145         assert(*mo.begin() == V(1, 1));
 146         assert(*next(mo.begin()) == V(2, 1));
 147         assert(*next(mo.begin(), 2) == V(3, 1));
 148     }
 149     {
 150         typedef std::pair<const int, double> V;
 151         const V ar[] =
 152         {
 153             V(1, 1),
 154             V(2, 1),
 155             V(3, 1),
 156         };
 157         std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 158         std::map<int, double> *p = &m;
 159         m = *p;
 160
 161         assert(m.size() == 3);
 162         assert(std::equal(m.begin(), m.end(), ar));
 163     }
 164     {
 165         typedef std::pair<const int, double> V;
 166         V ar[] =
 167         {
 168             V(1, 1),
 169             V(1, 1.5),
 170             V(1, 2),
 171             V(2, 1),
 172             V(2, 1.5),
 173             V(2, 2),
 174             V(3, 1),
 175             V(3, 1.5),
 176             V(3, 2)
 177         };
 178         typedef test_compare<std::less<int> > C;
 179         typedef other_allocator<V> A;
 180         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
 181         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
 182         m = mo;
 183         assert(m.get_allocator() == A(2));
 184         assert(m.key_comp() == C(5));
 185         assert(m.size() == 3);
 186         assert(distance(m.begin(), m.end()) == 3);
 187         assert(*m.begin() == V(1, 1));
 188         assert(*next(m.begin()) == V(2, 1));
 189         assert(*next(m.begin(), 2) == V(3, 1));
 190
 191         assert(mo.get_allocator() == A(2));
 192         assert(mo.key_comp() == C(5));
 193         assert(mo.size() == 3);
 194         assert(distance(mo.begin(), mo.end()) == 3);
 195         assert(*mo.begin() == V(1, 1));
 196         assert(*next(mo.begin()) == V(2, 1));
 197         assert(*next(mo.begin(), 2) == V(3, 1));
 198     }
 199 #if TEST_STD_VER >= 11
 200     {
 201         typedef std::pair<const int, double> V;
 202         V ar[] =
 203         {
 204             V(1, 1),
 205             V(1, 1.5),
 206             V(1, 2),
 207             V(2, 1),
 208             V(2, 1.5),
 209             V(2, 2),
 210             V(3, 1),
 211             V(3, 1.5),
 212             V(3, 2)
 213         };
 214         typedef test_compare<std::less<int> > C;
 215         typedef min_allocator<V> A;
 216         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
 217         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
 218         m = mo;
 219         assert(m.get_allocator() == A());
 220         assert(m.key_comp() == C(5));
 221         assert(m.size() == 3);
 222         assert(distance(m.begin(), m.end()) == 3);
 223         assert(*m.begin() == V(1, 1));
 224         assert(*next(m.begin()) == V(2, 1));
 225         assert(*next(m.begin(), 2) == V(3, 1));
 226
 227         assert(mo.get_allocator() == A());
 228         assert(mo.key_comp() == C(5));
 229         assert(mo.size() == 3);
 230         assert(distance(mo.begin(), mo.end()) == 3);
 231         assert(*mo.begin() == V(1, 1));
 232         assert(*next(mo.begin()) == V(2, 1));
 233         assert(*next(mo.begin(), 2) == V(3, 1));
 234     }
 235     {
 236         typedef std::pair<const int, double> V;
 237         V ar[] =
 238         {
 239             V(1, 1),
 240             V(1, 1.5),
 241             V(1, 2),
 242             V(2, 1),
 243             V(2, 1.5),
 244             V(2, 2),
 245             V(3, 1),
 246             V(3, 1.5),
 247             V(3, 2)
 248         };
 249         typedef test_compare<std::less<int> > C;
 250         typedef min_allocator<V> A;
 251         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
 252         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
 253         m = mo;
 254         assert(m.get_allocator() == A());
 255         assert(m.key_comp() == C(5));
 256         assert(m.size() == 3);
 257         assert(distance(m.begin(), m.end()) == 3);
 258         assert(*m.begin() == V(1, 1));
 259         assert(*next(m.begin()) == V(2, 1));
 260         assert(*next(m.begin(), 2) == V(3, 1));
 261
 262         assert(mo.get_allocator() == A());
 263         assert(mo.key_comp() == C(5));
 264         assert(mo.size() == 3);
 265         assert(distance(mo.begin(), mo.end()) == 3);
 266         assert(*mo.begin() == V(1, 1));
 267         assert(*next(mo.begin()) == V(2, 1));
 268         assert(*next(mo.begin(), 2) == V(3, 1));
 269     }
 270
 271     assert(balanced_allocs());
 272     {
 273         typedef std::pair<const int, double> V;
 274         V ar[] =
 275         {
 276             V(1, 1),
 277             V(1, 1.5),
 278             V(1, 2),
 279             V(2, 1),
 280             V(2, 1.5),
 281             V(2, 2),
 282             V(3, 1),
 283             V(3, 1.5),
 284             V(3, 2)
 285         };
 286         typedef test_compare<std::less<int> > C;
 287         typedef counting_allocatorT<V> A;
 288         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(1));
 289         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(2));
 290         m = mo;
 291         assert(m.key_comp() == C(5));
 292         assert(m.size() == 3);
 293         assert(distance(m.begin(), m.end()) == 3);
 294         assert(*m.begin() == V(1, 1));
 295         assert(*next(m.begin()) == V(2, 1));
 296         assert(*next(m.begin(), 2) == V(3, 1));
 297
 298         assert(mo.key_comp() == C(5));
 299         assert(mo.size() == 3);
 300         assert(distance(mo.begin(), mo.end()) == 3);
 301         assert(*mo.begin() == V(1, 1));
 302         assert(*next(mo.begin()) == V(2, 1));
 303         assert(*next(mo.begin(), 2) == V(3, 1));
 304     }
 305     assert(balanced_allocs());
 306     {
 307         typedef std::pair<const int, double> V;
 308         V ar[] =
 309         {
 310             V(1, 1),
 311             V(1, 1.5),
 312             V(1, 2),
 313             V(2, 1),
 314             V(2, 1.5),
 315             V(2, 2),
 316             V(3, 1),
 317             V(3, 1.5),
 318             V(3, 2)
 319         };
 320         typedef test_compare<std::less<int> > C;
 321         typedef counting_allocatorF<V> A;
 322         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(100));
 323         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(200));
 324         m = mo;
 325         assert(m.key_comp() == C(5));
 326         assert(m.size() == 3);
 327         assert(distance(m.begin(), m.end()) == 3);
 328         assert(*m.begin() == V(1, 1));
 329         assert(*next(m.begin()) == V(2, 1));
 330         assert(*next(m.begin(), 2) == V(3, 1));
 331
 332         assert(mo.key_comp() == C(5));
 333         assert(mo.size() == 3);
 334         assert(distance(mo.begin(), mo.end()) == 3);
 335         assert(*mo.begin() == V(1, 1));
 336         assert(*next(mo.begin()) == V(2, 1));
 337         assert(*next(mo.begin(), 2) == V(3, 1));
 338     }
 339     assert(balanced_allocs());
 340 #endif
 341 }