ceph/src/boost/libs/unordered/test/unordered/contains_tests.cpp

   1 // Copyright 2021 Christian Mazakas.
   2 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   3 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   4
   5 // clang-format off
   6 #include "../helpers/prefix.hpp"
   7 #include <boost/unordered_set.hpp>
   8 #include <boost/unordered_map.hpp>
   9 #include "../helpers/postfix.hpp"
  10 // clang-format on
  11
  12 #include "../helpers/test.hpp"
  13
  14 struct key
  15 {
  16   int x_;
  17   static int count_;
  18
  19   key(int x) : x_(x) { ++count_; }
  20   key(key const& k) : x_(k.x_) { ++count_; }
  21 };
  22
  23 int key::count_;
  24
  25 std::ostream& operator<<(std::ostream& os, key const& k)
  26 {
  27   os << "key { x_: " << k.x_ << " }";
  28   return os;
  29 }
  30
  31 bool operator==(key const& k, int const x) { return k.x_ == x; }
  32 bool operator==(int const x, key const& k) { return k.x_ == x; }
  33
  34 struct transparent_hasher
  35 {
  36   typedef void is_transparent;
  37
  38   std::size_t operator()(key const& k) const
  39   {
  40     return boost::hash<int>()(k.x_);
  41   }
  42
  43   std::size_t operator()(int const k) const { return boost::hash<int>()(k); }
  44 };
  45
  46 struct transparent_key_equal
  47 {
  48   typedef void is_transparent;
  49
  50   bool operator()(key const& k1, key const& k2) const { return k1.x_ == k2.x_; }
  51   bool operator()(int const x, key const& k1) const { return k1 == x; }
  52   bool operator()(key const& k1, int const x) const { return k1 == x; }
  53 };
  54
  55 struct hasher
  56 {
  57   std::size_t operator()(key const& k) const
  58   {
  59     return boost::hash<int>()(k.x_);
  60   }
  61 };
  62
  63 struct key_equal
  64 {
  65   bool operator()(key const& k1, key const& k2) const { return k1.x_ == k2.x_; }
  66 };
  67
  68 void count_reset() { key::count_ = 0; }
  69
  70 template <class UnorderedMap> void test_map_transparent_contains()
  71 {
  72   count_reset();
  73
  74   UnorderedMap map;
  75   bool contains = map.contains(0);
  76   BOOST_TEST(!contains);
  77
  78   BOOST_TEST_EQ(key::count_, 0);
  79
  80   map.insert(std::make_pair(0, 1337));
  81   map.insert(std::make_pair(0, 1338));
  82   map.insert(std::make_pair(0, 1339));
  83   map.insert(std::make_pair(1, 1340));
  84
  85   int const expected_key_count = key::count_;
  86
  87   contains = map.contains(0);
  88   BOOST_TEST(contains);
  89
  90   contains = map.contains(1);
  91   BOOST_TEST(contains);
  92
  93   contains = map.contains(2);
  94   BOOST_TEST(!contains);
  95
  96   BOOST_TEST_EQ(key::count_, expected_key_count);
  97 }
  98
  99 template <class UnorderedMap> void test_map_non_transparent_contains()
 100 {
 101   count_reset();
 102
 103   UnorderedMap map;
 104   bool contains = map.contains(0);
 105   BOOST_TEST(!contains);
 106   BOOST_TEST_EQ(key::count_, 1);
 107
 108   map.insert(std::make_pair(0, 1337));
 109   map.insert(std::make_pair(0, 1338));
 110   map.insert(std::make_pair(0, 1339));
 111   map.insert(std::make_pair(1, 1340));
 112
 113   int key_count = key::count_;
 114
 115   contains = map.contains(0);
 116   ++key_count;
 117   BOOST_TEST(contains);
 118
 119   contains = map.contains(1);
 120   ++key_count;
 121   BOOST_TEST(contains);
 122
 123   contains = map.contains(2);
 124   ++key_count;
 125   BOOST_TEST(!contains);
 126
 127   BOOST_TEST_EQ(key::count_, key_count);
 128 }
 129
 130 void test_map()
 131 {
 132   typedef boost::unordered_map<key, int, transparent_hasher,
 133     transparent_key_equal>
 134     transparent_map;
 135
 136   typedef boost::unordered_map<key, int, transparent_hasher, key_equal>
 137     non_transparent_map1;
 138
 139   typedef boost::unordered_map<key, int, hasher, transparent_key_equal>
 140     non_transparent_map2;
 141
 142   typedef boost::unordered_map<key, int, hasher, key_equal>
 143     non_transparent_map3;
 144
 145   test_map_transparent_contains<transparent_map>();
 146   test_map_non_transparent_contains<non_transparent_map1>();
 147   test_map_non_transparent_contains<non_transparent_map2>();
 148   test_map_non_transparent_contains<non_transparent_map3>();
 149 }
 150
 151 void test_multimap()
 152 {
 153   typedef boost::unordered_multimap<key, int, transparent_hasher,
 154     transparent_key_equal>
 155     transparent_multimap;
 156
 157   typedef boost::unordered_multimap<key, int, transparent_hasher, key_equal>
 158     non_transparent_multimap1;
 159
 160   typedef boost::unordered_multimap<key, int, hasher, transparent_key_equal>
 161     non_transparent_multimap2;
 162
 163   typedef boost::unordered_multimap<key, int, hasher, key_equal>
 164     non_transparent_multimap3;
 165
 166   test_map_transparent_contains<transparent_multimap>();
 167   test_map_non_transparent_contains<non_transparent_multimap1>();
 168   test_map_non_transparent_contains<non_transparent_multimap2>();
 169   test_map_non_transparent_contains<non_transparent_multimap3>();
 170 }
 171
 172 template <class UnorderedSet> void test_set_transparent_contains()
 173 {
 174   count_reset();
 175
 176   UnorderedSet set;
 177   bool contains = set.contains(0);
 178   BOOST_TEST(!contains);
 179
 180   BOOST_TEST_EQ(key::count_, 0);
 181
 182   set.insert(0);
 183   set.insert(0);
 184   set.insert(0);
 185   set.insert(1);
 186
 187   int const expected_key_count = key::count_;
 188
 189   contains = set.contains(0);
 190   BOOST_TEST(contains);
 191
 192   contains = set.contains(1);
 193   BOOST_TEST(contains);
 194
 195   contains = set.contains(2);
 196   BOOST_TEST(!contains);
 197
 198   BOOST_TEST_EQ(key::count_, expected_key_count);
 199 }
 200
 201 template <class UnorderedSet> void test_set_non_transparent_contains()
 202 {
 203   count_reset();
 204
 205   UnorderedSet set;
 206   bool contains = set.contains(0);
 207   BOOST_TEST(!contains);
 208   BOOST_TEST_EQ(key::count_, 1);
 209
 210   set.insert(0);
 211   set.insert(0);
 212   set.insert(0);
 213   set.insert(1);
 214
 215   int key_count = key::count_;
 216
 217   contains = set.contains(0);
 218   ++key_count;
 219   BOOST_TEST(contains);
 220
 221   contains = set.contains(1);
 222   ++key_count;
 223   BOOST_TEST(contains);
 224
 225   contains = set.contains(2);
 226   ++key_count;
 227   BOOST_TEST(!contains);
 228
 229   BOOST_TEST_EQ(key::count_, key_count);
 230 }
 231
 232 void test_set()
 233 {
 234   typedef boost::unordered_set<key, transparent_hasher, transparent_key_equal>
 235     transparent_set;
 236
 237   typedef boost::unordered_set<key, transparent_hasher, key_equal>
 238     non_transparent_set1;
 239   typedef boost::unordered_set<key, hasher, transparent_key_equal>
 240     non_transparent_set2;
 241   typedef boost::unordered_set<key, hasher, key_equal> non_transparent_set3;
 242
 243   test_set_transparent_contains<transparent_set>();
 244   test_set_non_transparent_contains<non_transparent_set1>();
 245   test_set_non_transparent_contains<non_transparent_set2>();
 246   test_set_non_transparent_contains<non_transparent_set3>();
 247 }
 248
 249 void test_multiset()
 250 {
 251   typedef boost::unordered_multiset<key, transparent_hasher,
 252     transparent_key_equal>
 253     transparent_multiset;
 254
 255   typedef boost::unordered_multiset<key, transparent_hasher, key_equal>
 256     non_transparent_multiset1;
 257   typedef boost::unordered_multiset<key, hasher, transparent_key_equal>
 258     non_transparent_multiset2;
 259   typedef boost::unordered_multiset<key, hasher, key_equal>
 260     non_transparent_multiset3;
 261
 262   test_set_transparent_contains<transparent_multiset>();
 263   test_set_non_transparent_contains<non_transparent_multiset1>();
 264   test_set_non_transparent_contains<non_transparent_multiset2>();
 265   test_set_non_transparent_contains<non_transparent_multiset3>();
 266 }
 267
 268 UNORDERED_AUTO_TEST (contains_) { // avoid -Wshadow warning with `bool contains`
 269   test_map();
 270   test_multimap();
 271   test_set();
 272 }
 273
 274 RUN_TESTS()