golang.org/x/exp v0.0.0-20260824195058-e88cd73687aa: rand.New

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 golang.org/x/exp/rand.New in pkg:golang/golang.org/x/exp@v0.0.0-20260824195058-e88cd73687aa
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/exp@v0.0.0-20260824195058-e88cd73687aa
Demonstrate these symbols/APIs:
  - golang.org/x/exp/rand.New

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:e9ca182fa3931666acfb9331a3354141939a5ed400549a07b802cdb1ecee60d8","contract":["rand.New returns a non-nil *rand.Rand instance initialized with a rand.Source","rand.New produces deterministic pseudo-random sequences for identical seeds across uint64, intn, and float64","rand.New instances maintain independent state without cross-generator interference","rand.New operates with custom implementations satisfying the rand.Source interface","rand.New instances reseed deterministically via Seed method to reproduce sequences"],"goal":"verify golang.org/x/exp/rand.New in pkg:golang/golang.org/x/exp@v0.0.0-20260824195058-e88cd73687aa","kind":"HOW","packages":["pkg:golang/golang.org/x/exp@v0.0.0-20260824195058-e88cd73687aa"],"schemaVersion":1,"symbols":["golang.org/x/exp/rand.New"]},"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/golang.org/x/exp@v0.0.0-20260824195058-e88cd73687aa"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/exp@v0.0.0-20260824195058-e88cd73687aa","symbols":["golang.org/x/exp/rand.New"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require golang.org/x/exp v0.0.0-20260824195058-e88cd73687aa

golang.org/x/exp v0.0.0-20260824195058-e88cd73687aa h1:QSyA8ishJCyT21kER9KwNt0b7BM3iRK4x9QXhjN5Fdk=
golang.org/x/exp v0.0.0-20260824195058-e88cd73687aa/go.mod h1:zeBbvyFKDaLwa7CH/zI8KXt7gTl14SF7sO08Pl5jBCM=

package sample

import (
	"golang.org/x/exp/rand"
)

// NewGenerator creates a new *rand.Rand instance initialized with rand.New and rand.NewSource.
func NewGenerator(seed uint64) *rand.Rand {
	src := rand.NewSource(seed)
	return rand.New(src)
}

// NewGeneratorWithSource creates a new *rand.Rand instance using any provided rand.Source.
func NewGeneratorWithSource(src rand.Source) *rand.Rand {
	return rand.New(src)
}

// SequenceSource implements rand.Source providing a predictable sequence of values.
type SequenceSource struct {
	values []uint64
	pos    int
}

// NewSequenceSource constructs a SequenceSource wrapping a sequence of uint64 values.
func NewSequenceSource(values []uint64) *SequenceSource {
	vals := make([]uint64, len(values))
	copy(vals, values)
	return &SequenceSource{
		values: vals,
		pos:    0,
	}
}

// Uint64 returns the next uint64 from the fixed sequence, cycling when exhausted.
func (s *SequenceSource) Uint64() uint64 {
	if len(s.values) == 0 {
		return 0
	}
	val := s.values[s.pos%len(s.values)]
	s.pos++
	return val
}

// Seed resets the source position and replaces the first element with seed.
func (s *SequenceSource) Seed(seed uint64) {
	s.pos = 0
	if len(s.values) > 0 {
		s.values[0] = seed
	}
}

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/exp/rand.New in pkg:golang/golang.org/x/exp@v0.0.0-20260824195058-e88cd73687aa",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/exp@v0.0.0-20260824195058-e88cd73687aa"
  ],
  "symbols": [
    "golang.org/x/exp/rand.New"
  ]
}

package main

import (
	"fmt"
	"os"

	"golang.org/x/exp/rand"
	"sample"
)

func main() {
	// Assertion 1: rand.New returns a non-nil *rand.Rand instance from a rand.Source
	src := rand.NewSource(12345)
	r := rand.New(src)
	if r == nil {
		fmt.Fprintf(os.Stderr, "FAIL: rand.New returned nil\n")
		os.Exit(1)
	}

	// Assertion 2: rand.New produces deterministic sequences for identical seeds across uint64, intn, and float64
	r1 := sample.NewGenerator(42)
	r2 := sample.NewGenerator(42)
	for i := 0; i < 100; i++ {
		u1, u2 := r1.Uint64(), r2.Uint64()
		if u1 != u2 {
			fmt.Fprintf(os.Stderr, "FAIL: Uint64 mismatch at step %d: %d != %d\n", i, u1, u2)
			os.Exit(1)
		}
		in1, in2 := r1.Intn(100), r2.Intn(100)
		if in1 != in2 {
			fmt.Fprintf(os.Stderr, "FAIL: Intn mismatch at step %d: %d != %d\n", i, in1, in2)
			os.Exit(1)
		}
		f1, f2 := r1.Float64(), r2.Float64()
		if f1 != f2 {
			fmt.Fprintf(os.Stderr, "FAIL: Float64 mismatch at step %d: %f != %f\n", i, f1, f2)
			os.Exit(1)
		}
	}

	// Assertion 3: rand.New instances maintain independent state without cross-generator interference
	genA := sample.NewGenerator(100)
	genB := sample.NewGenerator(100)
	genC := sample.NewGenerator(100)

	for i := 0; i < 50; i++ {
		_ = genA.Uint64()
	}
	valB := genB.Uint64()
	valC := genC.Uint64()
	if valB != valC {
		fmt.Fprintf(os.Stderr, "FAIL: independent generators genB and genC diverged: %d != %d\n", valB, valC)
		os.Exit(1)
	}

	// Assertion 4: rand.New operates with custom rand.Source implementations fulfilling the interface
	seq := []uint64{10, 20, 30, 40, 50}
	customSrc := sample.NewSequenceSource(seq)
	customRand := sample.NewGeneratorWithSource(customSrc)
	for i := 0; i < len(seq)*2; i++ {
		expected := seq[i%len(seq)]
		got := customRand.Uint64()
		if got != expected {
			fmt.Fprintf(os.Stderr, "FAIL: custom source returned %d, expected %d\n", got, expected)
			os.Exit(1)
		}
	}

	// Assertion 5: rand.New instances reseed deterministically via Seed method
	rRe := sample.NewGenerator(777)
	firstBatch := make([]uint64, 20)
	for i := 0; i < 20; i++ {
		firstBatch[i] = rRe.Uint64()
	}
	rRe.Seed(777)
	for i := 0; i < 20; i++ {
		val := rRe.Uint64()
		if val != firstBatch[i] {
			fmt.Fprintf(os.Stderr, "FAIL: value after re-seed mismatch at step %d: %d != %d\n", i, val, firstBatch[i])
			os.Exit(1)
		}
	}

	fmt.Println("PASS: golang.org/x/exp/rand.New contract verified")
}