libcxx/test/std/containers/container.node/node_handle.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 #include <unordered_set>
  12 #include <unordered_map>
  13 #include <set>
  14 #include <map>
  15 #include "test_macros.h"
  16 #include "min_allocator.h"
  17
  18 // [container.node.overview] Table 83.
  19 template <class K, class T, class C1, class C2, class H1, class H2, class E1, class E2, class A_set, class A_map>
  20 struct node_compatibility_table
  21 {
  22     static constexpr bool value =
  23         std::is_same_v<typename std::map<K, T, C1, A_map>::node_type,               typename std::map<K, T, C2, A_map>::node_type> &&
  24         std::is_same_v<typename std::map<K, T, C1, A_map>::node_type,               typename std::multimap<K, T, C2, A_map>::node_type> &&
  25         std::is_same_v<typename std::set<K, C1, A_set>::node_type,                  typename std::set<K, C2, A_set>::node_type> &&
  26         std::is_same_v<typename std::set<K, C1, A_set>::node_type,                  typename std::multiset<K, C2, A_set>::node_type> &&
  27         std::is_same_v<typename std::unordered_map<K, T, H1, E1, A_map>::node_type, typename std::unordered_map<K, T, H2, E2, A_map>::node_type> &&
  28         std::is_same_v<typename std::unordered_map<K, T, H1, E1, A_map>::node_type, typename std::unordered_multimap<K, T, H2, E2, A_map>::node_type> &&
  29         std::is_same_v<typename std::unordered_set<K, H1, E1, A_set>::node_type,    typename std::unordered_set<K, H2, E2, A_set>::node_type> &&
  30         std::is_same_v<typename std::unordered_set<K, H1, E1, A_set>::node_type,    typename std::unordered_multiset<K, H2, E2, A_set>::node_type>;
  31 };
  32
  33 template <class T> struct my_hash
  34 {
  35     using argument_type = T;
  36     using result_type = std::size_t;
  37     my_hash() = default;
  38     std::size_t operator()(const T&) const {return 0;}
  39 };
  40
  41 template <class T> struct my_compare
  42 {
  43     my_compare() = default;
  44     bool operator()(const T&, const T&) const {return true;}
  45 };
  46
  47 template <class T> struct my_equal
  48 {
  49     my_equal() = default;
  50     bool operator()(const T&, const T&) const {return true;}
  51 };
  52
  53 struct Static
  54 {
  55     Static() = default;
  56     Static(const Static&) = delete;
  57     Static(Static&&) = delete;
  58     Static& operator=(const Static&) = delete;
  59     Static& operator=(Static&&) = delete;
  60 };
  61
  62 namespace std
  63 {
  64 template <> struct hash<Static>
  65 {
  66     using argument_type = Static;
  67     using result_type = std::size_t;
  68     hash() = default;
  69     std::size_t operator()(const Static&) const;
  70 };
  71 }
  72
  73 static_assert(node_compatibility_table<
  74                   int, int, std::less<int>, std::less<int>, std::hash<int>,
  75                   std::hash<int>, std::equal_to<int>, std::equal_to<int>,
  76                   std::allocator<int>,
  77                   std::allocator<std::pair<const int, int>>>::value,
  78               "");
  79
  80 static_assert(
  81     node_compatibility_table<int, int, std::less<int>, my_compare<int>,
  82                              std::hash<int>, my_hash<int>, std::equal_to<int>,
  83                              my_equal<int>, std::allocator<int>,
  84                              std::allocator<std::pair<const int, int>>>::value,
  85     "");
  86
  87 static_assert(node_compatibility_table<
  88                   Static, int, my_compare<Static>, std::less<Static>,
  89                   my_hash<Static>, std::hash<Static>, my_equal<Static>,
  90                   std::equal_to<Static>, min_allocator<Static>,
  91                   min_allocator<std::pair<const Static, int>>>::value,
  92               "");
  93
  94 template <class Container>
  95 void test_node_handle_operations()
  96 {
  97     Container c;
  98
  99     typename Container::node_type nt1, nt2 = c.extract(c.emplace().first);
 100     assert(nt2.get_allocator() == c.get_allocator());
 101     assert(!nt2.empty());
 102     assert(nt1.empty());
 103     std::swap(nt1, nt2);
 104     assert(nt1.get_allocator() == c.get_allocator());
 105     assert(nt2.empty());
 106 }
 107
 108 template <class Container>
 109 void test_node_handle_operations_multi()
 110 {
 111     Container c;
 112
 113     typename Container::node_type nt1, nt2 = c.extract(c.emplace());
 114     assert(nt2.get_allocator() == c.get_allocator());
 115     assert(!nt2.empty());
 116     assert(nt1.empty());
 117     std::swap(nt1, nt2);
 118     assert(nt1.get_allocator() == c.get_allocator());
 119     assert(nt2.empty());
 120 }
 121
 122 template <class> void test_typedef() {}
 123
 124 template <class Container>
 125 void test_insert_return_type()
 126 {
 127     test_typedef<typename Container::insert_return_type>();
 128 }
 129
 130 int main(int, char**)
 131 {
 132     test_node_handle_operations<std::map<int, int>>();
 133     test_node_handle_operations_multi<std::multimap<int, int>>();
 134     test_node_handle_operations<std::set<int>>();
 135     test_node_handle_operations_multi<std::multiset<int>>();
 136     test_node_handle_operations<std::unordered_map<int, int>>();
 137     test_node_handle_operations_multi<std::unordered_multimap<int, int>>();
 138     test_node_handle_operations<std::unordered_set<int>>();
 139     test_node_handle_operations_multi<std::unordered_multiset<int>>();
 140
 141     test_insert_return_type<std::map<int, int>>();
 142     test_insert_return_type<std::set<int>>();
 143     test_insert_return_type<std::unordered_map<int, int>>();
 144     test_insert_return_type<std::unordered_set<int>>();
 145
 146   return 0;
 147 }