Upload Tests, Update README.md and Fix Typo in Hashmap Documentation

Author: wolgemoth

CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION ${CMAKE_VERSION})
+project(cpp_hashmap_tests)
+
+set(CMAKE_CXX_STANDARD 17)
+
+include_directories(.)
+include_directories(tests)
+
+remove_executable(cpp_hashmap)
+
+add_executable(basic_test
+        Hashmap.hpp
+        tests/basic.cpp
+)
+
+add_executable(advanced_test
+        Hashmap.hpp
+        tests/advanced.cpp
+)
+
+add_executable(extreme_test
+        Hashmap.hpp
+        tests/extreme.cpp
+)

Hashmap.hpp

@@ -31,15 +31,16 @@
 #include <cstddef>
 #include <functional>
 #include <initializer_list>
+#include <iostream>
+#include <mutex>
 #include <optional>
 #include <stdexcept>
 #include <vector>
-#include <mutex>
 
 namespace LouiEriksson {
 
 	/**
-	 * @mainpage Version 2.0.0
+	 * @mainpage Version 2.0.1
 	 * @details Custom Hashmap implementation accepting a customisable key and value type.
 	 *          This implementation requires that your "key" type is compatible with std::hash and that the stored data types are copyable.
 	 * @see Wang, Q. (Harry) (2020). Implementing Your Own HashMap (Explanation + Code). YouTube.
@@ -102,10 +103,10 @@ namespace LouiEriksson {
 		size_t m_Size;
 
 		/**
-		 * @brief Calculate the hashcode of a given object using std::fnv1a.
-		 * @param[in] _item Item to calculate fnv1a of.
+		 * @brief Calculate the hashcode of a given object using std::hash.
+		 * @param[in] _item Item to calculate hash of.
 		 * @return Hashcode of _item.
-		 * @throw std::exception If the type of _item is not supported by std::fnv1a.
+		 * @throw std::exception If the type of _item is not supported by std::hash.
 		 */
 		static constexpr size_t GetHashcode(const Tk& _item) {
 			return std::hash<Tk>()(_item);

README.md

@@ -1,4 +1,4 @@
-# C++ Hashmap (2.0.0)
+# C++ Hashmap (2.0.1)
 
 ## Table of Contents
 
@@ -29,17 +29,17 @@ Simply include it in your project and you are ready to start!
 
     #include <string>
 
-    #include "Hashmap.h"
+    #include "Hashmap.hpp"
 
-    Hashmap<std::string, float> hashmap {
+    LouiEriksson::Hashmap<std::string, float> hashmap {
         { "key1", 1.0f },
         { "key2", 2.0f },
         { "key3", 3.0f },
     }
 
     int main() {
 
-        if (const auto item = hashmap.Get("key3", item)) {
+        if (const auto item = hashmap.Get("key3")) {
             std::cout << "Value: " << item.value() << '\n';
         }
         else {
@@ -57,10 +57,11 @@ The hashmap was written in C++17 and utilises the following standard headers:
 #### &lt;cstddef&gt;
 #### &lt;functional&gt;
 #### &lt;initializer_list&gt;
+#### &lt;iostream&gt;
+#### &lt;mutex&gt;
 #### &lt;optional&gt;
 #### &lt;stdexcept&gt;
 #### &lt;vector&gt;
-#### &lt;mutex&gt;
 
 ### Why not use &lt;unordered_set&gt;?
 

tests/advanced.cpp

@@ -0,0 +1,136 @@
+#include "../Hashmap.hpp"
+
+#include <iostream>
+#include <cassert>
+#include <string>
+#include <thread>
+
+/**
+ * @file advanced.cpp
+ * @brief Advanced tests for the functionality of the hashmap.
+ */
+int main([[maybe_unused]] int _argc, [[maybe_unused]] char* _argv[]) {
+	
+	LouiEriksson::Hashmap<int, std::string> hashmap;
+
+	std::cout << "~ ADVANCED TESTS ~\n";
+	
+	// Test 1: Large volume of data
+	{
+		std::cout << "Test 1: Large volume of data..." << std::flush;
+		
+		static constexpr int iterations = 2000000;
+		
+		for (int i = 0; i < iterations; ++i) {
+			hashmap.Add(i, std::to_string(i));
+		}
+		assert(hashmap.size() == iterations);
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 2: Duplicate keys
+	{
+		std::cout << "Test 2: Duplicate keys..." << std::flush;
+		
+		const auto controlSize = hashmap.size();
+		
+		for (int i = 0; i < controlSize; ++i) {
+			hashmap.Add(i, "Duplicate");
+			
+			assert((hashmap.Get(i).value() != "Duplicate") &&     "Duplicate found.");
+			assert((hashmap.size() == controlSize)         && "Erroneous insertion.");
+		}
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 3: Key collision
+	{
+		std::cout << "Test 3: Key collision..." << std::flush;
+		
+		static constexpr int iterations = 2000000;
+		
+		for (int i = 1; i < iterations; ++i) {
+			hashmap.Add(-i, "Negative");
+			
+			assert(hashmap.Get(-i).value() == "Negative");
+		}
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 4: High churn
+	{
+		std::cout << "Test 4: High churn..." << std::flush;
+		
+		hashmap.Clear();
+		
+		static constexpr int iterations = 2000000;
+		
+		for (int i = iterations; i < iterations * 2; ++i) {
+			hashmap.Add(i, std::to_string(i));
+			hashmap.Remove(i - iterations);
+		}
+		assert(hashmap.size() == iterations);
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 5: Concurrency
+	{
+		std::cout << "Test 5: Concurrency..." << std::flush;
+		
+		hashmap.Clear();
+		
+		static constexpr int iterations = 2000000;
+		
+		std::exception_ptr writerException = nullptr;
+		std::exception_ptr readerException = nullptr;
+		
+		std::thread writer([&hashmap, &writerException]() {
+			
+			try {
+				for (int i = 0; i < iterations; ++i) {
+					hashmap.Add(i, std::to_string(i));
+				}
+			}
+			catch (...) {
+				writerException = std::current_exception();
+			}
+		});
+		
+		std::thread reader([&hashmap, &readerException]() {
+			
+			try {
+				int last_size = 0;
+				
+				while (last_size < iterations) {
+					if (hashmap.size() > last_size) {
+						for (int i = last_size; i < hashmap.size(); ++i) {
+							assert((hashmap.Get(i).value() == std::to_string(i)));
+						}
+						last_size = hashmap.size();
+					}
+				}
+			}
+			catch (...) {
+				readerException = std::current_exception();
+			}
+		});
+		
+		writer.join();
+		reader.join();
+		
+		if (writerException) { std::rethrow_exception(writerException); }
+		if (readerException) { std::rethrow_exception(readerException); }
+
+		assert(hashmap.size() == iterations);
+		
+		std::cout << "Done.\n";
+	}
+	
+	std::cout << "All tests passed!" << std::endl;
+	
+	return 0;
+}

tests/basic.cpp

@@ -0,0 +1,92 @@
+#include "../Hashmap.hpp"
+
+#include <iostream>
+#include <cassert>
+#include <string>
+
+/**
+ * @file basic.cpp
+ * @brief Basic tests for the functionality of the hashmap.
+ */
+int main([[maybe_unused]] int _argc, [[maybe_unused]] char* _argv[]) {
+	
+	LouiEriksson::Hashmap<int, std::string> hashmap;
+	
+	std::cout << "~ BASIC TESTS ~\n";
+	
+	// Test 1: Insertion
+	{
+		std::cout << "Test 1: Insertion..." << std::flush;
+		
+		hashmap.Add(1, "One");
+		hashmap.Add(2, "Two");
+		hashmap.Add(3, "Three");
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 2: Existence check
+	{
+		std::cout << "Test 2: Existence check..." << std::flush;
+		
+		assert(hashmap.ContainsKey(1) && "Failed on key 1.");
+		assert(hashmap.ContainsKey(2) && "Failed on key 2.");
+		assert(hashmap.ContainsKey(3) && "Failed on key 3.");
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 3: Value retrieval
+	{
+		std::cout << "Test 3: Value retrieval..." << std::flush;
+		
+		auto item1 = hashmap.Get(1);
+		auto item2 = hashmap.Get(2);
+		auto item3 = hashmap.Get(3);
+		
+		assert((item1.value() == "One"  ) && "Failed on key 1.");
+		assert((item2.value() == "Two"  ) && "Failed on key 2.");
+		assert((item3.value() == "Three") && "Failed on key 3.");
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 4: Overwriting
+	{
+		std::cout << "Test 4: Overwriting..." << std::flush;
+		
+		hashmap.Assign(1, "New One");
+		
+		auto item1 = hashmap.Get(1);
+		
+		assert((item1.value() == "New One") && "Failed on key 1.");
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 5: Deletion
+	{
+		std::cout << "Test 5: Deletion..." << std::flush;
+	
+		hashmap.Remove(1);
+		
+		assert(!hashmap.ContainsKey(1) && "Failed on key 1.");
+		
+		std::cout << "Done.\n";
+	}
+	
+	// Test 6: Clearing
+	{
+		std::cout << "Test 5: Clearing..." << std::flush;
+		
+		hashmap.Clear();
+		
+		assert(hashmap.size() == 0 && "Failed on key 1.");
+		
+		std::cout << "Done.\n";
+	}
+	
+	std::cout << "All tests passed!\n";
+	
+	return 0;
+}