MORE LRUCacheUnitTests

Author: Erfan-Ahmadi

21_LRUCacheUnitTest/main.cpp

@@ -41,13 +41,21 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 			cache.insert(11, 'd');
 			cache.insert(12, 'e');
 			cache.insert(13, 'f');
-
+			cache.print(m_logger);
+			m_logger->log("We're Referencing `10:c`");
+			char returned = *(cache.get(10));
+			cache.print(m_logger);
+			m_logger->log("We're erasing `11:d`");
+			cache.erase(11);
+			assert(cache.get(11) == nullptr);
+			cache.print(m_logger);
+			m_logger->log("We're adding `11:d` again");
+			cache.insert(11, 'd');
 			cache.print(m_logger);
 
-			char returned = *(cache.get(11));
-			assert(returned == 'd');
-			returned = *(cache.get(10));
 			assert(returned == 'c');
+			returned = *(cache.get(11));
+			assert(returned == 'd');
 			returned = *(cache.get(13));
 			assert(returned == 'f');
 
@@ -105,6 +113,44 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 		#endif
 			m_logger->log("all good");
 
+			constexpr uint32_t InvalidIdx = ~0u;
+			struct TextureReference
+			{
+				uint32_t alloc_idx;
+				uint64_t lastUsedSemaphoreValue;
+
+				// copy ctor
+				TextureReference(const TextureReference& tref)
+				{
+					assert(false); // based on the code in this test, copy constuctor shouldn't be called
+				}
+				TextureReference(TextureReference&& tref) = default;
+				inline TextureReference& operator=(TextureReference&& tref) = default;
+
+				TextureReference(uint32_t alloc_idx, uint64_t semaphoreVal) : alloc_idx(alloc_idx), lastUsedSemaphoreValue(semaphoreVal) {}
+				TextureReference(uint64_t semaphoreVal) : TextureReference(InvalidIdx, semaphoreVal) {}
+				TextureReference() : TextureReference(InvalidIdx, ~0ull) {}
+
+				// In LRU Cache `insert` function, in case of cache hit, we need to assign semaphore value to TextureReference without changing `alloc_idx`
+				inline TextureReference& operator=(uint64_t semamphoreVal) { lastUsedSemaphoreValue = semamphoreVal; return *this;  }
+			};
+			using TextureLRUCache = LRUCache<uint32_t, TextureReference>;
+
+			TextureLRUCache textureCache = TextureLRUCache(3u);
+
+			static_assert(std::is_assignable_v<TextureReference, uint64_t>);
+			static_assert(std::is_constructible_v<TextureReference, uint64_t>);
+
+			textureCache.insert(91u, TextureReference{ ~0u, 69u });
+			textureCache.insert(92u, TextureReference{ 20u, 70u });
+			textureCache.insert(93u, TextureReference{ 10u, 71u });
+			auto t = textureCache.get(91u);
+			assert(t->lastUsedSemaphoreValue == 69u); // make 91 jump to front, now 92 is the LRU
+			// next insertion will evict because capacity is 3
+			auto insertion = textureCache.insert(99u, 6999ull, [](const TextureReference& evictedTextureRef) -> void { assert(evictedTextureRef.alloc_idx == 20u); });
+			assert(insertion->alloc_idx == InvalidIdx);
+			assert(insertion->lastUsedSemaphoreValue == 6999ull);
+
 			return true;
 		}