test(core.utils): cover SQLiteProgramCache LRU eviction

Exercises the size-cap eviction path, confirms reads update accessed_at
(so a recently read entry is preserved when a newer write forces eviction),
and asserts that omitting the cap keeps the cache unbounded.

Part of issue #178.

Author: cpcloud

cuda_core/tests/test_program_cache.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
 
 import abc
+import time
 
 import pytest
 
@@ -376,3 +377,60 @@ def test_sqlite_cache_accepts_str_keys(tmp_path):
         assert "str-key" in cache
         # Same bytes representation so the corresponding bytes key also hits.
         assert b"str-key" in cache
+
+
+def test_sqlite_cache_rejects_negative_size_cap(tmp_path):
+    from cuda.core.utils import SQLiteProgramCache
+
+    with pytest.raises(ValueError, match="non-negative"):
+        SQLiteProgramCache(tmp_path / "cache.db", max_size_bytes=-1)
+
+
+# ---------------------------------------------------------------------------
+# SQLiteProgramCache -- LRU eviction
+# ---------------------------------------------------------------------------
+
+
+def test_sqlite_cache_evicts_under_size_cap(tmp_path):
+    from cuda.core.utils import SQLiteProgramCache
+
+    # Each payload pickles to > 2000 bytes; cap is 5000 so only ~2 fit.
+    cap = 5000
+    db = tmp_path / "cache.db"
+    with SQLiteProgramCache(db, max_size_bytes=cap) as cache:
+        cache[b"a"] = _fake_object_code(b"A" * 2000, name="a")
+        cache[b"b"] = _fake_object_code(b"B" * 2000, name="b")
+        cache[b"c"] = _fake_object_code(b"C" * 2000, name="c")
+        # Adding c must have evicted a (oldest by accessed_at).
+        assert b"a" not in cache
+        assert b"b" in cache
+        assert b"c" in cache
+
+
+def test_sqlite_cache_lru_order_respects_reads(tmp_path):
+    from cuda.core.utils import SQLiteProgramCache
+
+    cap = 5000
+    db = tmp_path / "cache.db"
+    with SQLiteProgramCache(db, max_size_bytes=cap) as cache:
+        cache[b"a"] = _fake_object_code(b"A" * 2000, name="a")
+        time.sleep(0.01)
+        cache[b"b"] = _fake_object_code(b"B" * 2000, name="b")
+        time.sleep(0.01)
+        # Touch 'a' so it becomes MRU; 'b' must be evicted when 'c' is added.
+        _ = cache[b"a"]
+        time.sleep(0.01)
+        cache[b"c"] = _fake_object_code(b"C" * 2000, name="c")
+        assert b"a" in cache
+        assert b"b" not in cache
+        assert b"c" in cache
+
+
+def test_sqlite_cache_unbounded_by_default(tmp_path):
+    from cuda.core.utils import SQLiteProgramCache
+
+    db = tmp_path / "cache.db"
+    with SQLiteProgramCache(db) as cache:
+        for i in range(25):
+            cache[f"k{i}".encode()] = _fake_object_code(b"X" * 1024, name=f"n{i}")
+        assert len(cache) == 25