Add tests and fix some bugs

Author: rigtorp

CMakeLists.txt

@@ -5,3 +5,7 @@ set(CMAKE_CXX_FLAGS "-std=c++14 -Wall")
 set(CMAKE_CXX_FLAGS_RELEASE "-O3")
 
 add_executable(benchmark benchmark.cpp)
+add_executable(tests tests.cpp)
+
+enable_testing()
+add_test(test tests)

HashMap.h

@@ -84,6 +84,9 @@ class HashMap {
   private:
     explicit hm_iterator(ContT *hm) : hm_(hm) { advance_past_empty(); }
     explicit hm_iterator(ContT *hm, size_type idx) : hm_(hm), idx_(idx) {}
+    template <typename OtherContT, typename OtherIterVal>
+    hm_iterator(const hm_iterator<OtherContT, OtherIterVal> &other)
+        : hm_(other.hm_), idx_(other.idx_) {}
 
     void advance_past_empty() {
       while (idx_ < hm_->buckets_.size() &&
@@ -132,9 +135,8 @@ class HashMap {
 
   // Modifiers
   void clear() {
-    for (auto it = begin(); it != end(); ++it) {
-      it->first = empty_key_;
-    }
+    HashMap other(bucket_count(), empty_key_);
+    swap(other);
   }
 
   std::pair<iterator, bool> insert(const value_type &value) {
@@ -193,15 +195,17 @@ class HashMap {
   }
 
   // Lookup
-  reference at(key_type key) {
+  mapped_type &at(key_type key) {
     iterator it = find(key);
     if (it != end()) {
       return it->second;
     }
-    throw std::out_of_range();
+    throw std::out_of_range("key not found");
   }
 
-  const_reference at(key_type key) const { return at(key); }
+  const mapped_type &at(key_type key) const { return at(key); }
+
+  mapped_type &operator[](key_type key) { return emplace(key).first->second; }
 
   size_type count(key_type key) const { return find(key) == end() ? 0 : 1; }
 
@@ -232,8 +236,7 @@ class HashMap {
 
   void reserve(size_type count) {
     if (count * 2 > buckets_.size()) {
-      HashMap other(*this, buckets_.size() * 2);
-      swap(other);
+      rehash(count * 2);
     }
   }
 

tests.cpp

@@ -0,0 +1,124 @@
+#include "HashMap.h"
+#include <cassert>
+
+int main(int argc, char *argv[]) {
+
+  {
+    HashMap<int, int> hm(16, 0);
+    assert(hm.empty());
+    assert(hm.size() == 0);
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    hm.insert({1, 1});
+    assert(!hm.empty());
+    assert(hm.size() == 1);
+    hm.clear();
+    assert(hm.empty());
+    assert(hm.size() == 0);
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    auto res = hm.insert({1, 1});
+    assert(res.second);
+    assert(!hm.empty());
+    assert(hm.size() == 1);
+    assert(res.first->first == 1);
+    assert(res.first->second == 1);
+    res = hm.insert({1, 2});
+    assert(!res.second);
+    assert(hm.size() == 1);
+    assert(res.first->first == 1);
+    assert(res.first->second == 1);
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    auto res = hm.emplace(1, 1);
+    assert(res.second);
+    assert(!hm.empty());
+    assert(hm.size() == 1);
+    assert(res.first->first == 1);
+    assert(res.first->second == 1);
+    res = hm.emplace(1, 2);
+    assert(!res.second);
+    assert(hm.size() == 1);
+    assert(res.first->first == 1);
+    assert(res.first->second == 1);
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    auto res = hm.emplace(1, 1);
+    assert(hm.size() == 1);
+    hm.erase(res.first);
+    assert(hm.size() == 0);
+    assert(hm.erase(1) == 0);
+    hm.emplace(1, 1);
+    assert(hm.erase(1) == 1);
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    hm.emplace(1, 1);
+    assert(hm.at(1) == 1);
+    hm.at(1) = 2;
+    assert(hm.at(1) == 2);
+    bool exception = false;
+    try {
+      hm.at(2);
+    } catch (std::out_of_range) {
+      exception = true;
+    }
+    assert(exception);
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    assert(hm[1] == 0);
+    hm[1] = 2;
+    assert(hm[1] == 2);
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    hm.emplace(1, 1);
+    assert(hm.count(1) == 1);
+    assert(hm.count(2) == 0);
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    hm.emplace(1, 1);
+    auto it = hm.find(1);
+    assert(it != hm.end());
+    assert(it->first == 1);
+    assert(it->second == 1);
+    it = hm.find(2);
+    assert(it == hm.end());
+  }
+
+  {
+    HashMap<int, int> hm(16, 0);
+    assert(hm.bucket_count() == 16);
+  }
+
+  {
+    HashMap<int, int> hm(2, 0);
+    hm.emplace(1, 1);
+    hm.emplace(2, 2);
+    assert(hm.bucket_count() == 4);
+    hm.rehash(2);
+    assert(hm.bucket_count() == 4);
+    hm.rehash(16);
+    assert(hm.bucket_count() == 16);
+    hm.reserve(2);
+    assert(hm.bucket_count() == 16);
+    hm.reserve(16);
+    assert(hm.bucket_count() == 32);
+  }
+
+  return 0;
+}