go.uber.org/goleak v1.2.0

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/go.uber.org/goleak@v1.2.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.uber.org/goleak@v1.2.0
Required runtime conditions:
  - ecosystem: golang
  - language: go
  - packageManager: go@1.26.6
  - runtime: go@1.26.6

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:1611d70ed06f61fa0d91c8f02d31c63f4be655bac5291756d605f29f00d2b209","contract":["goleak.VerifyNone passes without error when no background goroutines remain active","goleak.VerifyNone reports an error to TestingT when an unexpected goroutine leaks","goleak.VerifyNone ignores matched goroutines when configured with IgnoreTopFunction","goleak.Find returns nil when no background goroutines remain active","goleak.Find returns an error when an unexpected goroutine leaks"],"goal":"verify pkg:golang/go.uber.org/goleak@v1.2.0","kind":"HOW","packages":["pkg:golang/go.uber.org/goleak@v1.2.0"],"schemaVersion":1},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/go.uber.org/goleak@v1.2.0"],"schemaVersion":1,"subject":"pkg:golang/go.uber.org/goleak@v1.2.0","verifierAdapter":"golang@1"}

module example.com/goleak-sample

go 1.22.0

require go.uber.org/goleak v1.2.0

go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk=
go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo=

package sample

import (
	"go.uber.org/goleak"
)

// VerifyGoroutines checks that no unexpected goroutines are running.
func VerifyGoroutines(t goleak.TestingT, options ...goleak.Option) {
	goleak.VerifyNone(t, options...)
}

// FindLeakedGoroutines returns an error if any non-ignored goroutines are running.
func FindLeakedGoroutines(options ...goleak.Option) error {
	return goleak.Find(options...)
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/go.uber.org/goleak@v1.2.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/go.uber.org/goleak@v1.2.0"
  ],
  "runtimeConditions": {
    "ecosystem": "golang",
    "language": "go",
    "packageManager": "go@1.26.6",
    "runtime": "go@1.26.6"
  }
}

package main

import (
	"fmt"
	"os"
	"strings"
	"sync"
	"time"

	sample "example.com/goleak-sample"
	"go.uber.org/goleak"
)

type mockTestingT struct {
	errors []string
}

func (m *mockTestingT) Error(args ...interface{}) {
	var parts []string
	for _, a := range args {
		parts = append(parts, fmt.Sprint(a))
	}
	m.errors = append(m.errors, strings.Join(parts, " "))
}

func backgroundWorker(stop <-chan struct{}, ready *sync.WaitGroup) {
	ready.Done()
	<-stop
}

func main() {
	// Assertion 1: goleak.VerifyNone passes without error when no background goroutines remain active
	mockT1 := &mockTestingT{}
	stop1 := make(chan struct{})
	done1 := make(chan struct{})
	go func() {
		defer close(done1)
		<-stop1
	}()
	close(stop1)
	<-done1

	sample.VerifyGoroutines(mockT1)
	if len(mockT1.errors) > 0 {
		fmt.Fprintf(os.Stderr, "FAIL: expected 0 errors when clean, got: %v\n", mockT1.errors)
		os.Exit(1)
	}

	// Assertion 2: goleak.VerifyNone reports an error to TestingT when an unexpected goroutine leaks
	mockT2 := &mockTestingT{}
	stop2 := make(chan struct{})
	var wg2 sync.WaitGroup
	wg2.Add(1)
	go backgroundWorker(stop2, &wg2)
	wg2.Wait()

	sample.VerifyGoroutines(mockT2)
	if len(mockT2.errors) == 0 {
		fmt.Fprintf(os.Stderr, "FAIL: expected error reported for leaking goroutine, got 0\n")
		os.Exit(1)
	}
	if !strings.Contains(mockT2.errors[0], "found unexpected goroutines") {
		fmt.Fprintf(os.Stderr, "FAIL: expected leak error message, got: %s\n", mockT2.errors[0])
		os.Exit(1)
	}
	close(stop2)

	// Wait briefly for goroutine 2 to stop cleanly
	time.Sleep(50 * time.Millisecond)

	// Assertion 3: goleak.VerifyNone ignores matched goroutines when configured with IgnoreTopFunction
	mockT3 := &mockTestingT{}
	stop3 := make(chan struct{})
	var wg3 sync.WaitGroup
	wg3.Add(1)
	go backgroundWorker(stop3, &wg3)
	wg3.Wait()

	sample.VerifyGoroutines(mockT3, goleak.IgnoreTopFunction("main.backgroundWorker"))
	if len(mockT3.errors) > 0 {
		fmt.Fprintf(os.Stderr, "FAIL: expected IgnoreTopFunction to ignore worker, got error: %v\n", mockT3.errors)
		os.Exit(1)
	}
	close(stop3)

	time.Sleep(50 * time.Millisecond)

	// Assertion 4: goleak.Find returns nil when no background goroutines remain active
	if err := sample.FindLeakedGoroutines(); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: expected Find to return nil when clean, got: %v\n", err)
		os.Exit(1)
	}

	// Assertion 5: goleak.Find returns an error when an unexpected goroutine leaks
	stop5 := make(chan struct{})
	var wg5 sync.WaitGroup
	wg5.Add(1)
	go backgroundWorker(stop5, &wg5)
	wg5.Wait()

	if err := sample.FindLeakedGoroutines(); err == nil {
		fmt.Fprintf(os.Stderr, "FAIL: expected Find to return error when leaking goroutine, got nil\n")
		os.Exit(1)
	} else if !strings.Contains(err.Error(), "found unexpected goroutines") {
		fmt.Fprintf(os.Stderr, "FAIL: expected leak error message from Find, got: %v\n", err)
		os.Exit(1)
	}
	close(stop5)

	time.Sleep(50 * time.Millisecond)

	fmt.Println("PASS: pkg:golang/go.uber.org/goleak@v1.2.0 contract passed")
}