Flesh out test case

test/unordered/transparent_tests.cpp

@@ -13,52 +13,83 @@
 
 #include <boost/container_hash/hash.hpp>
 
-struct key {
+struct key
-    int x_;
+{
-    static int count_;
+  int x_;
+  static int count_;
 
-    explicit key(int x) : x_(x) {
+  key(int x) : x_(x) { ++count_; }
-        ++count_;
+  key(key const& k) : x_(k.x_) { ++count_; }
-    }
+
+  key& operator=(key const& k)
+  {
+    x_ = k.x_;
+    ++count_;
+    return *this;
+  }
 };
 
 int key::count_;
 
-UNORDERED_AUTO_TEST(transparent_count) {
+struct transparent_hasher
-    key::count_ = 0;
+{
+  typedef void is_transparent;
 
-    struct hasher {
+  std::size_t operator()(key const& k) const
-        std::size_t operator()(key const& k) const {
+  {
-            return boost::hash<int>()(k.x_);
+    return boost::hash<int>()(k.x_);
-        }
+  }
 
-        std::size_t operator()(int const k) const {
+  std::size_t operator()(int const k) const { return boost::hash<int>()(k); }
-            return boost::hash<int>()(k);
+};
-        }
-    };
 
-    struct key_equal {
+struct transparent_key_equal
-        bool operator()(key const& k1, key const& k2) const {
+{
-            return k1.x_ == k2.x_;
+  typedef void is_transparent;
-        }
 
-        bool operator()(key const& k1, int const x) const {
+  static bool was_called_;
-            return k1.x_ == x;
-        }
 
-        bool operator()(int const x, key const& k1 ) const {
+  bool operator()(key const& k1, key const& k2) const { return k1.x_ == k2.x_; }
-            return k1.x_ == x;
+  bool operator()(int const x, key const& k1) const
-        }
+  {
-    };
+    was_called_ = true;
+    return k1.x_ == x;
+  }
+};
 
-    boost::unordered_map<key, int, hasher, key_equal> map;
+bool transparent_key_equal::was_called_;
-    map.insert({key(0), 1337});
-    BOOST_TEST(key::count_ == 1);
 
-    std::size_t const count = map.count(0);
+UNORDERED_AUTO_TEST (unordered_map_transparent_count) {
+  key::count_ = 0;
+  transparent_key_equal::was_called_ = false;
 
-    BOOST_TEST(count == 1);
+  boost::unordered_map<key, int, transparent_hasher, transparent_key_equal> map;
-    BOOST_TEST(key::count_ == 1);
+
+  // initial `key(0)` expression increases the count
+  // then copying into the `unordered_map` increments the count again thus we
+  // have 2
+  //
+  map[key(0)] = 1337;
+  BOOST_TEST(key::count_ == 2);
+
+  // now the number of `key` objects created should be a constant and never
+  // touched again
+  //
+  std::size_t count = 0;
+  count = map.count(0);
+
+  BOOST_TEST(count == 1);
+  BOOST_TEST(key::count_ == 2);
+  BOOST_TEST(map.key_eq().was_called_);
+
+  count = map.count(1);
+
+  BOOST_TEST(count == 0);
+  BOOST_TEST(key::count_ == 2);
+
+  count = map.count(key(0));
+  BOOST_TEST(count == 1);
+  BOOST_TEST(key::count_ > 2);
 }
 
 RUN_TESTS()