github.com/stretchr/testify v1.3.0: assert.Empty

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 github.com/stretchr/testify/assert.Empty in pkg:golang/github.com/stretchr/testify@v1.3.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/stretchr/testify@v1.3.0
Demonstrate these symbols/APIs:
  - github.com/stretchr/testify/assert.Empty

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:28641336bd8bf18a115aeb3b2ef7a1ce09aac5bdbe1a2dc8642de0d44eee0c8d","contract":["assert.Empty returns true and records no error for nil values and empty strings","assert.Empty returns true for zero-length slices, maps, and channels","assert.Empty returns true for zero values of basic types and structs","assert.Empty returns true for pointers referencing empty values or nil pointers","assert.Empty returns false and records an error when the value is non-empty"],"goal":"verify github.com/stretchr/testify/assert.Empty in pkg:golang/github.com/stretchr/testify@v1.3.0","kind":"HOW","packages":["pkg:golang/github.com/stretchr/testify@v1.3.0"],"schemaVersion":1,"symbols":["github.com/stretchr/testify/assert.Empty"]},"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/github.com/stretchr/testify@v1.3.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/stretchr/testify@v1.3.0","symbols":["github.com/stretchr/testify/assert.Empty"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/stretchr/testify v1.3.0

require (
	github.com/davecgh/go-spew v1.1.0 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
)

github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=

package main

import (
	"fmt"

	"github.com/stretchr/testify/assert"
)

// Reporter implements assert.TestingT to record assertion outcomes.
type Reporter struct {
	errors []string
	failed bool
}

func (r *Reporter) Errorf(format string, args ...interface{}) {
	r.failed = true
	r.errors = append(r.errors, fmt.Sprintf(format, args...))
}

// Config represents a sample configuration entity.
type Config struct {
	Port int
	Name string
}

func main() {
	reporter := &Reporter{}

	// Example 1: Verifying empty string and slice
	emptyStr := ""
	emptySlice := []string{}
	if assert.Empty(reporter, emptyStr) && assert.Empty(reporter, emptySlice) {
		fmt.Println("Empty string and slice verified.")
	}

	// Example 2: Verifying empty map and zero-value struct
	emptyMap := make(map[string]int)
	zeroConfig := Config{}
	if assert.Empty(reporter, emptyMap) && assert.Empty(reporter, zeroConfig) {
		fmt.Println("Empty map and zero struct verified.")
	}

	// Example 3: Verifying nil pointer
	var nilPtr *int = nil
	if assert.Empty(reporter, nilPtr) {
		fmt.Println("Nil pointer verified as empty.")
	}

	if !reporter.failed {
		fmt.Println("All assert.Empty demonstrations succeeded.")
	}
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/stretchr/testify/assert.Empty in pkg:golang/github.com/stretchr/testify@v1.3.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/stretchr/testify@v1.3.0"
  ],
  "symbols": [
    "github.com/stretchr/testify/assert.Empty"
  ]
}

package main

import (
	"fmt"
	"os"

	"github.com/stretchr/testify/assert"
)

type contractTestingT struct {
	errors []string
	failed bool
}

func (t *contractTestingT) Errorf(format string, args ...interface{}) {
	t.failed = true
	t.errors = append(t.errors, fmt.Sprintf(format, args...))
}

type sampleConfig struct {
	Timeout int
	Label   string
}

func main() {
	// Assertion 1: assert.Empty returns true and records no error for nil values and empty strings
	{
		t := &contractTestingT{}
		if !assert.Empty(t, nil) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: untyped nil should be empty\n")
			os.Exit(1)
		}
		if !assert.Empty(t, "") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: empty string should be empty\n")
			os.Exit(1)
		}
	}

	// Assertion 2: assert.Empty returns true for zero-length slices, maps, and channels
	{
		t := &contractTestingT{}
		var nilSlice []int
		emptySlice := []string{}
		emptyMap := map[string]int{}
		emptyChan := make(chan int, 1)

		if !assert.Empty(t, nilSlice) || !assert.Empty(t, emptySlice) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: nil or zero-length slices should be empty\n")
			os.Exit(1)
		}
		if !assert.Empty(t, emptyMap) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: empty map should be empty\n")
			os.Exit(1)
		}
		if !assert.Empty(t, emptyChan) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: empty buffered channel should be empty\n")
			os.Exit(1)
		}
	}

	// Assertion 3: assert.Empty returns true for zero values of basic types and structs
	{
		t := &contractTestingT{}
		zeroInt := 0
		zeroFloat := 0.0
		zeroBool := false
		zeroStruct := sampleConfig{}

		if !assert.Empty(t, zeroInt) || !assert.Empty(t, zeroFloat) || !assert.Empty(t, zeroBool) || !assert.Empty(t, zeroStruct) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: zero values of basic types and structs should be empty\n")
			os.Exit(1)
		}
	}

	// Assertion 4: assert.Empty returns true for pointers referencing empty values or nil pointers
	{
		t := &contractTestingT{}
		var nilPtr *sampleConfig
		emptyStr := ""
		ptrToEmptyStr := &emptyStr
		zeroVal := 0
		ptrToZeroVal := &zeroVal

		if !assert.Empty(t, nilPtr) || !assert.Empty(t, ptrToEmptyStr) || !assert.Empty(t, ptrToZeroVal) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: nil pointer or pointer to empty should be empty\n")
			os.Exit(1)
		}
	}

	// Assertion 5: assert.Empty returns false and records an error when the value is non-empty
	{
		tStr := &contractTestingT{}
		if assert.Empty(tStr, "hello") || !tStr.failed || len(tStr.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: non-empty string should not be empty\n")
			os.Exit(1)
		}

		tSlice := &contractTestingT{}
		if assert.Empty(tSlice, []int{1}) || !tSlice.failed || len(tSlice.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: non-empty slice should not be empty\n")
			os.Exit(1)
		}

		tMap := &contractTestingT{}
		if assert.Empty(tMap, map[string]int{"k": 1}) || !tMap.failed || len(tMap.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: non-empty map should not be empty\n")
			os.Exit(1)
		}

		tNum := &contractTestingT{}
		if assert.Empty(tNum, 42) || !tNum.failed || len(tNum.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: non-zero int should not be empty\n")
			os.Exit(1)
		}

		tStruct := &contractTestingT{}
		if assert.Empty(tStruct, sampleConfig{Timeout: 10}) || !tStruct.failed || len(tStruct.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: non-zero struct should not be empty\n")
			os.Exit(1)
		}
	}

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