libcxx/test/std/containers/associative/map/map.modifiers/merge.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 // UNSUPPORTED: c++03, c++11, c++14
  10
  11 // <map>
  12
  13 // class map
  14
  15 // template <class C2>
  16 //   void merge(map<key_type, value_type, C2, allocator_type>& source);
  17 // template <class C2>
  18 //   void merge(map<key_type, value_type, C2, allocator_type>&& source);
  19 // template <class C2>
  20 //   void merge(multimap<key_type, value_type, C2, allocator_type>& source);
  21 // template <class C2>
  22 //   void merge(multimap<key_type, value_type, C2, allocator_type>&& source);
  23
  24 #include <map>
  25 #include <cassert>
  26 #include "test_macros.h"
  27 #include "Counter.h"
  28
  29 template <class Map>
  30 bool map_equal(const Map& map, Map other)
  31 {
  32     return map == other;
  33 }
  34
  35 #ifndef TEST_HAS_NO_EXCEPTIONS
  36 struct throw_comparator
  37 {
  38     bool& should_throw_;
  39
  40     throw_comparator(bool& should_throw) : should_throw_(should_throw) {}
  41
  42     template <class T>
  43     bool operator()(const T& lhs, const T& rhs) const
  44     {
  45         if (should_throw_)
  46             throw 0;
  47         return lhs < rhs;
  48     }
  49 };
  50 #endif
  51
  52 int main(int, char**)
  53 {
  54     {
  55         std::map<int, int> src{{1, 0}, {3, 0}, {5, 0}};
  56         std::map<int, int> dst{{2, 0}, {4, 0}, {5, 0}};
  57         dst.merge(src);
  58         assert(map_equal(src, {{5,0}}));
  59         assert(map_equal(dst, {{1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}}));
  60     }
  61
  62 #ifndef TEST_HAS_NO_EXCEPTIONS
  63     {
  64         bool do_throw = false;
  65         typedef std::map<Counter<int>, int, throw_comparator> map_type;
  66         map_type src({{1, 0}, {3, 0}, {5, 0}}, throw_comparator(do_throw));
  67         map_type dst({{2, 0}, {4, 0}, {5, 0}}, throw_comparator(do_throw));
  68
  69         assert(Counter_base::gConstructed == 6);
  70
  71         do_throw = true;
  72         try
  73         {
  74             dst.merge(src);
  75         }
  76         catch (int)
  77         {
  78             do_throw = false;
  79         }
  80         assert(!do_throw);
  81         assert(map_equal(src, map_type({{1, 0}, {3, 0}, {5, 0}}, throw_comparator(do_throw))));
  82         assert(map_equal(dst, map_type({{2, 0}, {4, 0}, {5, 0}}, throw_comparator(do_throw))));
  83     }
  84 #endif
  85     assert(Counter_base::gConstructed == 0);
  86     struct comparator
  87     {
  88         comparator() = default;
  89
  90         bool operator()(const Counter<int>& lhs, const Counter<int>& rhs) const
  91         {
  92             return lhs < rhs;
  93         }
  94     };
  95     {
  96         typedef std::map<Counter<int>, int, std::less<Counter<int>>> first_map_type;
  97         typedef std::map<Counter<int>, int, comparator> second_map_type;
  98         typedef std::multimap<Counter<int>, int, comparator> third_map_type;
  99
 100         {
 101             first_map_type first{{1, 0}, {2, 0}, {3, 0}};
 102             second_map_type second{{2, 0}, {3, 0}, {4, 0}};
 103             third_map_type third{{1, 0}, {3, 0}};
 104
 105             assert(Counter_base::gConstructed == 8);
 106
 107             first.merge(second);
 108             first.merge(third);
 109
 110             assert(map_equal(first, {{1, 0}, {2, 0}, {3, 0}, {4, 0}}));
 111             assert(map_equal(second, {{2, 0}, {3, 0}}));
 112             assert(map_equal(third, {{1, 0}, {3, 0}}));
 113
 114             assert(Counter_base::gConstructed == 8);
 115         }
 116         assert(Counter_base::gConstructed == 0);
 117         {
 118             first_map_type first{{1, 0}, {2, 0}, {3, 0}};
 119             second_map_type second{{2, 0}, {3, 0}, {4, 0}};
 120             third_map_type third{{1, 0}, {3, 0}};
 121
 122             assert(Counter_base::gConstructed == 8);
 123
 124             first.merge(std::move(second));
 125             first.merge(std::move(third));
 126
 127             assert(map_equal(first, {{1, 0}, {2, 0}, {3, 0}, {4, 0}}));
 128             assert(map_equal(second, {{2, 0}, {3, 0}}));
 129             assert(map_equal(third, {{1, 0}, {3, 0}}));
 130
 131             assert(Counter_base::gConstructed == 8);
 132         }
 133         assert(Counter_base::gConstructed == 0);
 134     }
 135     assert(Counter_base::gConstructed == 0);
 136     {
 137         std::map<int, int> first;
 138         {
 139             std::map<int, int> second;
 140             first.merge(second);
 141             first.merge(std::move(second));
 142         }
 143         {
 144             std::multimap<int, int> second;
 145             first.merge(second);
 146             first.merge(std::move(second));
 147         }
 148     }
 149     return 0;
 150 }