github.com/hashicorp/golang-lru/v2 v2.0.7

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:golang/github.com/hashicorp/golang-lru/v2@v2.0.7
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/hashicorp/golang-lru/v2@v2.0.7

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:bf22622342718e8bf84a84db939671021646efb2f9ace6fe6e936b668601169a","contract":["New creates a fixed-size LRU cache and returns an error for non-positive capacities","Cache.Add stores key-value pairs and evicts the least recently used item when capacity is exceeded","Cache.Get retrieves entries and updates their recency in the LRU order","Cache.Remove removes an existing key from the cache and reports whether it was present","Cache.Len returns current item count and Cache.Purge clears all cached entries"],"goal":"verify pkg:golang/github.com/hashicorp/golang-lru/v2@v2.0.7","kind":"HOW","packages":["pkg:golang/github.com/hashicorp/golang-lru/v2@v2.0.7"],"schemaVersion":1},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/hashicorp/golang-lru/v2@v2.0.7"],"schemaVersion":1,"subject":"pkg:golang/github.com/hashicorp/golang-lru/v2@v2.0.7","verifierAdapter":"golang@1"}

module sample

go 1.22

require github.com/hashicorp/golang-lru/v2 v2.0.7

github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=

package main

import (
	"fmt"

	lru "github.com/hashicorp/golang-lru/v2"
)

func main() {
	// Create an LRU cache with capacity 2
	cache, err := lru.New[string, int](2)
	if err != nil {
		panic(err)
	}

	// Add entries
	cache.Add("alpha", 100)
	cache.Add("beta", 200)

	// Access "alpha" so "beta" becomes the least recently used
	if val, ok := cache.Get("alpha"); ok {
		fmt.Printf("Retrieved alpha: %d\n", val)
	}

	// Add "gamma", which should evict "beta"
	evicted := cache.Add("gamma", 300)
	fmt.Printf("Eviction occurred on adding gamma: %t\n", evicted)

	if cache.Contains("beta") {
		fmt.Println("beta is unexpectedly present")
	} else {
		fmt.Println("beta was evicted as least recently used")
	}

	// Cache len and purge
	fmt.Printf("Current cache len: %d\n", cache.Len())
	cache.Purge()
	fmt.Printf("Cache len after purge: %d\n", cache.Len())
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/github.com/hashicorp/golang-lru/v2@v2.0.7",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/hashicorp/golang-lru/v2@v2.0.7"
  ]
}

package main

import (
	"fmt"
	"os"

	lru "github.com/hashicorp/golang-lru/v2"
)

func main() {
	// Assertion 1: New creates a fixed-size LRU cache and returns an error for non-positive capacities
	{
		c, err := lru.New[string, int](5)
		if err != nil || c == nil {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: valid capacity should create cache without error: %v\n", err)
			os.Exit(1)
		}

		_, errZero := lru.New[string, int](0)
		if errZero == nil {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: capacity 0 should return an error\n")
			os.Exit(1)
		}

		_, errNeg := lru.New[string, int](-5)
		if errNeg == nil {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: negative capacity should return an error\n")
			os.Exit(1)
		}
	}

	// Assertion 2: Cache.Add stores key-value pairs and evicts the least recently used item when capacity is exceeded
	{
		c, err := lru.New[string, int](2)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 2 setup failed: %v\n", err)
			os.Exit(1)
		}

		if evicted := c.Add("k1", 1); evicted {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: adding k1 should not evict\n")
			os.Exit(1)
		}
		if evicted := c.Add("k2", 2); evicted {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: adding k2 should not evict\n")
			os.Exit(1)
		}

		// Adding third item exceeds capacity 2; least recently used item (k1) must be evicted
		if evicted := c.Add("k3", 3); !evicted {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: adding k3 should cause an eviction\n")
			os.Exit(1)
		}

		if c.Contains("k1") {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: k1 should have been evicted\n")
			os.Exit(1)
		}
		if !c.Contains("k2") || !c.Contains("k3") {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: k2 and k3 should still be in cache\n")
			os.Exit(1)
		}
	}

	// Assertion 3: Cache.Get retrieves entries and updates their recency in the LRU order
	{
		c, err := lru.New[string, int](2)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 setup failed: %v\n", err)
			os.Exit(1)
		}

		c.Add("x", 10)
		c.Add("y", 20)

		val, ok := c.Get("x")
		if !ok || val != 10 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: expected x=10, got %d (ok=%t)\n", val, ok)
			os.Exit(1)
		}

		if _, ok := c.Get("missing"); ok {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: Get for missing key should return ok=false\n")
			os.Exit(1)
		}

		// Since "x" was accessed via Get, "y" is now the oldest/least recently used item
		c.Add("z", 30)

		if c.Contains("y") {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: y should have been evicted as least recently used\n")
			os.Exit(1)
		}
		if !c.Contains("x") || !c.Contains("z") {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: x and z should both remain in cache\n")
			os.Exit(1)
		}
	}

	// Assertion 4: Cache.Remove removes an existing key from the cache and reports whether it was present
	{
		c, err := lru.New[string, int](3)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 setup failed: %v\n", err)
			os.Exit(1)
		}

		c.Add("item1", 100)
		c.Add("item2", 200)

		present := c.Remove("item1")
		if !present {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: Remove(item1) should return present=true\n")
			os.Exit(1)
		}
		if c.Contains("item1") {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: item1 should no longer exist after Remove\n")
			os.Exit(1)
		}
		if c.Len() != 1 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: expected cache len 1, got %d\n", c.Len())
			os.Exit(1)
		}

		// Removing non-existent key returns false
		if c.Remove("item1") {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: second Remove(item1) should return present=false\n")
			os.Exit(1)
		}
		if c.Remove("unknown") {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: Remove(unknown) should return present=false\n")
			os.Exit(1)
		}
	}

	// Assertion 5: Cache.Len returns current item count and Cache.Purge clears all cached entries
	{
		c, err := lru.New[string, int](5)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 5 setup failed: %v\n", err)
			os.Exit(1)
		}

		if c.Len() != 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: fresh cache should have Len=0, got %d\n", c.Len())
			os.Exit(1)
		}

		c.Add("a", 1)
		c.Add("b", 2)
		c.Add("c", 3)
		if c.Len() != 3 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: expected Len=3, got %d\n", c.Len())
			os.Exit(1)
		}

		c.Purge()
		if c.Len() != 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: cache Len should be 0 after Purge, got %d\n", c.Len())
			os.Exit(1)
		}
		if c.Contains("a") || c.Contains("b") || c.Contains("c") {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: purged keys should not be found in cache\n")
			os.Exit(1)
		}
	}

	fmt.Println("All contract assertions passed successfully.")
}