chore: import upstream snapshot with attribution

internal/indexer/cpp_include_cache_test.go

@@ -0,0 +1,87 @@
+package indexer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewCppIncludeDirCache_EnvBudget(t *testing.T) {
+	t.Setenv("GORTEX_RESOLVER_CACHE_MAX_MB", "7")
+	assert.Equal(t, int64(7)<<20, newCppIncludeDirCache().maxBytes)
+
+	t.Setenv("GORTEX_RESOLVER_CACHE_MAX_MB", "")
+	assert.Equal(t, int64(0), newCppIncludeDirCache().maxBytes, "unset = unbounded")
+
+	t.Setenv("GORTEX_RESOLVER_CACHE_MAX_MB", "0")
+	assert.Equal(t, int64(0), newCppIncludeDirCache().maxBytes, "0 = unbounded")
+}
+
+// TestCppIncludeDirCache_Eviction pins that a tiny memory budget evicts the
+// least-recently-used per-repo include-dir set.
+func TestCppIncludeDirCache_Eviction(t *testing.T) {
+	c := newCppIncludeDirCache()
+	c.maxBytes = 200 // tiny budget; each entry below is ~89 bytes
+
+	mk := func(f string) map[string]cppTU {
+		return map[string]cppTU{f: {file: f, includeDirs: []string{"inc"}}}
+	}
+	c.put("repoA", mk("a.c"), 0)
+	c.put("repoB", mk("b.c"), 0)
+	c.put("repoC", mk("c.c"), 0)
+
+	_, okA := c.get("repoA", 0)
+	assert.False(t, okA, "least-recently-used repoA evicted under the budget")
+	_, okB := c.get("repoB", 0)
+	assert.True(t, okB, "repoB retained")
+	_, okC := c.get("repoC", 0)
+	assert.True(t, okC, "most-recently-used repoC retained")
+}
+
+// TestCppIncludeDirCache_GetPromotes pins that a get refreshes recency so the
+// promoted entry survives a later eviction.
+func TestCppIncludeDirCache_GetPromotes(t *testing.T) {
+	c := newCppIncludeDirCache()
+	c.maxBytes = 200
+
+	mk := func(f string) map[string]cppTU {
+		return map[string]cppTU{f: {file: f, includeDirs: []string{"inc"}}}
+	}
+	c.put("repoA", mk("a.c"), 0)
+	c.put("repoB", mk("b.c"), 0)
+	c.get("repoA", 0)            // promote A ahead of B
+	c.put("repoC", mk("c.c"), 0) // evicts the now-LRU repoB
+
+	_, okA := c.get("repoA", 0)
+	assert.True(t, okA, "promoted repoA survives")
+	_, okB := c.get("repoB", 0)
+	assert.False(t, okB, "repoB evicted as least-recently-used")
+}
+
+// TestCppIncludeDirCache_UnboundedKeepsAll pins that the default (no budget)
+// retains every entry.
+func TestCppIncludeDirCache_UnboundedKeepsAll(t *testing.T) {
+	c := newCppIncludeDirCache() // maxBytes 0
+	for _, r := range []string{"r1", "r2", "r3"} {
+		c.put(r, map[string]cppTU{r: {file: r}}, 0)
+	}
+	for _, r := range []string{"r1", "r2", "r3"} {
+		_, ok := c.get(r, 0)
+		assert.True(t, ok, "unbounded cache retains %s", r)
+	}
+}
+
+// TestCppIncludeDirCache_MtimeStaleMiss pins the freshness check: a get whose
+// disk modtime exceeds the entry's recorded mtime is a miss, while an equal or
+// older modtime is a hit.
+func TestCppIncludeDirCache_MtimeStaleMiss(t *testing.T) {
+	c := newCppIncludeDirCache()
+	c.put("repo", map[string]cppTU{"a.c": {file: "a.c"}}, 100)
+
+	_, ok := c.get("repo", 100)
+	assert.True(t, ok, "equal modtime is a hit")
+	_, ok = c.get("repo", 50)
+	assert.True(t, ok, "older modtime is a hit")
+	_, ok = c.get("repo", 200)
+	assert.False(t, ok, "newer modtime is a stale miss")
+}