first commit

libraries/FastLED/tests/test_hashmap_lru.cpp

@@ -0,0 +1,151 @@
+// test.cpp
+// g++ --std=c++11 test.cpp -o test && ./test
+
+#include <vector>
+#include <set>
+#include <unordered_map>
+
+#include "fl/hash_map_lru.h"
+#include "fl/str.h"
+#include "test.h"
+
+using namespace fl;
+
+TEST_CASE("Test HashMapLRU") {
+    SUBCASE("Basic operations") {
+        HashMapLru<int, int> lru(3);
+        
+        // Test empty state
+        CHECK(lru.empty());
+        CHECK(lru.size() == 0);
+        CHECK(lru.capacity() == 3);
+        CHECK(lru.find_value(1) == nullptr);
+        
+        // Test insertion
+        lru.insert(1, 100);
+        CHECK(!lru.empty());
+        CHECK(lru.size() == 1);
+        CHECK(*lru.find_value(1) == 100);
+        
+        // Test operator[]
+        lru[2] = 200;
+        CHECK(lru.size() == 2);
+        CHECK(*lru.find_value(2) == 200);
+        
+        // Test update
+        lru[1] = 150;
+        CHECK(lru.size() == 2);
+        CHECK(*lru.find_value(1) == 150);
+        
+        // Test removal
+        CHECK(lru.remove(1));
+        CHECK(lru.size() == 1);
+        CHECK(lru.find_value(1) == nullptr);
+        CHECK(!lru.remove(1)); // Already removed
+        
+        // Test clear
+        lru.clear();
+        CHECK(lru.empty());
+        CHECK(lru.size() == 0);
+    }
+    
+    SUBCASE("LRU eviction") {
+        HashMapLru<int, int> lru(3);
+        
+        // Fill the cache
+        lru.insert(1, 100);
+        lru.insert(2, 200);
+        lru.insert(3, 300);
+        CHECK(lru.size() == 3);
+        
+        // Access key 1 to make it most recently used
+        CHECK(*lru.find_value(1) == 100);
+        
+        // Insert a new key, should evict key 2 (least recently used)
+        lru.insert(4, 400);
+        CHECK(lru.size() == 3);
+        CHECK(lru.find_value(2) == nullptr); // Key 2 should be evicted
+        CHECK(*lru.find_value(1) == 100);
+        CHECK(*lru.find_value(3) == 300);
+        CHECK(*lru.find_value(4) == 400);
+        
+        // Access key 3, then insert new key
+        CHECK(*lru.find_value(3) == 300);
+        lru.insert(5, 500);
+        CHECK(lru.size() == 3);
+        CHECK(lru.find_value(1) == nullptr); // Key 1 should be evicted
+        CHECK(*lru.find_value(3) == 300);
+        CHECK(*lru.find_value(4) == 400);
+        CHECK(*lru.find_value(5) == 500);
+    }
+    
+    SUBCASE("Operator[] LRU behavior") {
+        HashMapLru<int, int> lru(3);
+        
+        // Fill the cache using operator[]
+        lru[1] = 100;
+        lru[2] = 200;
+        lru[3] = 300;
+        
+        // Access key 1 to make it most recently used
+        int val = lru[1];
+        CHECK(val == 100);
+        
+        // Insert a new key, should evict key 2
+        lru[4] = 400;
+        CHECK(lru.size() == 3);
+        CHECK(lru.find_value(2) == nullptr);
+        CHECK(*lru.find_value(1) == 100);
+        CHECK(*lru.find_value(3) == 300);
+        CHECK(*lru.find_value(4) == 400);
+    }
+    
+    SUBCASE("Edge cases") {
+        // Test with capacity 1
+        HashMapLru<int, int> tiny_lru(1);
+        tiny_lru.insert(1, 100);
+        CHECK(*tiny_lru.find_value(1) == 100);
+        
+        tiny_lru.insert(2, 200);
+        CHECK(tiny_lru.size() == 1);
+        CHECK(tiny_lru.find_value(1) == nullptr);
+        CHECK(*tiny_lru.find_value(2) == 200);
+        
+        // Test with string keys
+        HashMapLru<fl::Str, int> str_lru(2);
+        str_lru.insert("one", 1);
+        str_lru.insert("two", 2);
+        CHECK(*str_lru.find_value("one") == 1);
+        CHECK(*str_lru.find_value("two") == 2);
+        
+        // This should evict "one" since it's least recently used
+        str_lru.insert("three", 3);
+        CHECK(str_lru.find_value("one") == nullptr);
+        CHECK(*str_lru.find_value("two") == 2);
+        CHECK(*str_lru.find_value("three") == 3);
+    }
+    
+    SUBCASE("Update existing key") {
+        HashMapLru<int, int> lru(3);
+        
+        // Fill the cache
+        lru.insert(1, 100);
+        lru.insert(2, 200);
+        lru.insert(3, 300);
+        
+        // Update an existing key
+        lru.insert(2, 250);
+        CHECK(lru.size() == 3);
+        CHECK(*lru.find_value(1) == 100);
+        CHECK(*lru.find_value(2) == 250);
+        CHECK(*lru.find_value(3) == 300);
+        
+        // Insert a new key, should evict key 1 (least recently used)
+        lru.insert(4, 400);
+        CHECK(lru.size() == 3);
+        CHECK(lru.find_value(1) == nullptr);
+        CHECK(*lru.find_value(2) == 250);
+        CHECK(*lru.find_value(3) == 300);
+        CHECK(*lru.find_value(4) == 400);
+    }
+}