github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2

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/dgryski/go-farm@v0.0.0-20190423205320-6a90982ecee2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/dgryski/go-farm@v0.0.0-20190423205320-6a90982ecee2

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:2df10d07637df67388baff7691845d98d3027fb4c6c347690b4512852247b859","contract":["farm.Hash32 computes a deterministic 32-bit FarmHash","farm.Hash32WithSeed computes deterministic hash for given seed and varies by seed","farm.Hash64 computes a deterministic 64-bit FarmHash","farm.Hash64WithSeed computes deterministic hash for given seed and varies by seed","farm.Hash128 computes a deterministic 128-bit FarmHash","farm.Fingerprint32 computes a deterministic 32-bit fingerprint","farm.Fingerprint64 computes a deterministic 64-bit fingerprint","farm.Fingerprint128 computes a deterministic 128-bit fingerprint"],"goal":"verify pkg:golang/github.com/dgryski/go-farm@v0.0.0-20190423205320-6a90982ecee2","kind":"HOW","packages":["pkg:golang/github.com/dgryski/go-farm@v0.0.0-20190423205320-6a90982ecee2"],"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/dgryski/go-farm@v0.0.0-20190423205320-6a90982ecee2"],"schemaVersion":1,"subject":"pkg:golang/github.com/dgryski/go-farm@v0.0.0-20190423205320-6a90982ecee2","verifierAdapter":"golang@1"}

module example.com/sample

go 1.22

require github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2

github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA=
github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=

package main

import (
	"fmt"

	farm "github.com/dgryski/go-farm"
)

func main() {
	data := []byte("Hello, FarmHash!")

	h32 := farm.Hash32(data)
	h32Seed := farm.Hash32WithSeed(data, 42)
	h64 := farm.Hash64(data)
	h64Seed := farm.Hash64WithSeed(data, 42)
	lo128, hi128 := farm.Hash128(data)
	fp32 := farm.Fingerprint32(data)
	fp64 := farm.Fingerprint64(data)
	fp128Lo, fp128Hi := farm.Fingerprint128(data)

	fmt.Printf("Hash32: 0x%08x\n", h32)
	fmt.Printf("Hash32WithSeed: 0x%08x\n", h32Seed)
	fmt.Printf("Hash64: 0x%016x\n", h64)
	fmt.Printf("Hash64WithSeed: 0x%016x\n", h64Seed)
	fmt.Printf("Hash128: 0x%016x%016x\n", hi128, lo128)
	fmt.Printf("Fingerprint32: 0x%08x\n", fp32)
	fmt.Printf("Fingerprint64: 0x%016x\n", fp64)
	fmt.Printf("Fingerprint128: 0x%016x%016x\n", fp128Hi, fp128Lo)
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/github.com/dgryski/go-farm@v0.0.0-20190423205320-6a90982ecee2",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/dgryski/go-farm@v0.0.0-20190423205320-6a90982ecee2"
  ]
}

package main

import (
	"fmt"
	"os"

	farm "github.com/dgryski/go-farm"
)

func main() {
	input1 := []byte("The quick brown fox jumps over the lazy dog.")
	input2 := []byte("The quick brown fox jumps over the lazy cog.")

	// Test 1: farm.Hash32 computes a deterministic 32-bit FarmHash
	h32_a := farm.Hash32(input1)
	h32_b := farm.Hash32(input1)
	if h32_a != h32_b {
		fmt.Fprintf(os.Stderr, "Hash32 is non-deterministic: %d != %d\n", h32_a, h32_b)
		os.Exit(1)
	}
	if h32_c := farm.Hash32(input2); h32_a == h32_c {
		fmt.Fprintf(os.Stderr, "Hash32 collision on distinct inputs: %d\n", h32_a)
		os.Exit(1)
	}

	// Test 2: farm.Hash32WithSeed computes deterministic hash for given seed and varies by seed
	h32_s1_a := farm.Hash32WithSeed(input1, 1337)
	h32_s1_b := farm.Hash32WithSeed(input1, 1337)
	h32_s2 := farm.Hash32WithSeed(input1, 2026)
	if h32_s1_a != h32_s1_b {
		fmt.Fprintf(os.Stderr, "Hash32WithSeed is non-deterministic: %d != %d\n", h32_s1_a, h32_s1_b)
		os.Exit(1)
	}
	if h32_s1_a == h32_s2 {
		fmt.Fprintf(os.Stderr, "Hash32WithSeed produced same hash for different seeds: %d\n", h32_s1_a)
		os.Exit(1)
	}

	// Test 3: farm.Hash64 computes a deterministic 64-bit FarmHash
	h64_a := farm.Hash64(input1)
	h64_b := farm.Hash64(input1)
	if h64_a != h64_b {
		fmt.Fprintf(os.Stderr, "Hash64 is non-deterministic: %d != %d\n", h64_a, h64_b)
		os.Exit(1)
	}
	if h64_c := farm.Hash64(input2); h64_a == h64_c {
		fmt.Fprintf(os.Stderr, "Hash64 collision on distinct inputs: %d\n", h64_a)
		os.Exit(1)
	}

	// Test 4: farm.Hash64WithSeed computes deterministic hash for given seed and varies by seed
	h64_s1_a := farm.Hash64WithSeed(input1, 1337)
	h64_s1_b := farm.Hash64WithSeed(input1, 1337)
	h64_s2 := farm.Hash64WithSeed(input1, 2026)
	if h64_s1_a != h64_s1_b {
		fmt.Fprintf(os.Stderr, "Hash64WithSeed is non-deterministic: %d != %d\n", h64_s1_a, h64_s1_b)
		os.Exit(1)
	}
	if h64_s1_a == h64_s2 {
		fmt.Fprintf(os.Stderr, "Hash64WithSeed produced same hash for different seeds: %d\n", h64_s1_a)
		os.Exit(1)
	}

	// Test 5: farm.Hash128 computes a deterministic 128-bit FarmHash
	lo_a, hi_a := farm.Hash128(input1)
	lo_b, hi_b := farm.Hash128(input1)
	if lo_a != lo_b || hi_a != hi_b {
		fmt.Fprintf(os.Stderr, "Hash128 is non-deterministic: (%d, %d) != (%d, %d)\n", lo_a, hi_a, lo_b, hi_b)
		os.Exit(1)
	}
	lo_c, hi_c := farm.Hash128(input2)
	if lo_a == lo_c && hi_a == hi_c {
		fmt.Fprintf(os.Stderr, "Hash128 collision on distinct inputs: (%d, %d)\n", lo_a, hi_a)
		os.Exit(1)
	}

	// Test 6: farm.Fingerprint32 computes a deterministic 32-bit fingerprint
	fp32_a := farm.Fingerprint32(input1)
	fp32_b := farm.Fingerprint32(input1)
	if fp32_a != fp32_b {
		fmt.Fprintf(os.Stderr, "Fingerprint32 is non-deterministic: %d != %d\n", fp32_a, fp32_b)
		os.Exit(1)
	}
	if fp32_c := farm.Fingerprint32(input2); fp32_a == fp32_c {
		fmt.Fprintf(os.Stderr, "Fingerprint32 collision on distinct inputs: %d\n", fp32_a)
		os.Exit(1)
	}

	// Test 7: farm.Fingerprint64 computes a deterministic 64-bit fingerprint
	fp64_a := farm.Fingerprint64(input1)
	fp64_b := farm.Fingerprint64(input1)
	if fp64_a != fp64_b {
		fmt.Fprintf(os.Stderr, "Fingerprint64 is non-deterministic: %d != %d\n", fp64_a, fp64_b)
		os.Exit(1)
	}
	if fp64_c := farm.Fingerprint64(input2); fp64_a == fp64_c {
		fmt.Fprintf(os.Stderr, "Fingerprint64 collision on distinct inputs: %d\n", fp64_a)
		os.Exit(1)
	}

	// Test 8: farm.Fingerprint128 computes a deterministic 128-bit fingerprint
	fp128_lo_a, fp128_hi_a := farm.Fingerprint128(input1)
	fp128_lo_b, fp128_hi_b := farm.Fingerprint128(input1)
	if fp128_lo_a != fp128_lo_b || fp128_hi_a != fp128_hi_b {
		fmt.Fprintf(os.Stderr, "Fingerprint128 is non-deterministic: (%d, %d) != (%d, %d)\n", fp128_lo_a, fp128_hi_a, fp128_lo_b, fp128_hi_b)
		os.Exit(1)
	}
	fp128_lo_c, fp128_hi_c := farm.Fingerprint128(input2)
	if fp128_lo_a == fp128_lo_c && fp128_hi_a == fp128_hi_c {
		fmt.Fprintf(os.Stderr, "Fingerprint128 collision on distinct inputs: (%d, %d)\n", fp128_lo_a, fp128_hi_a)
		os.Exit(1)
	}

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