github.com/stretchr/testify v1.8.1: assert.NotEmpty

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

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

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:e914a62581a8288598239d40f17dbea643c3414b91f93774d505ef7435ab6c4d","contract":["assert.NotEmpty returns true and does not record an error for non-empty string, and returns false with an error for empty string or nil","assert.NotEmpty returns true for populated slices, maps, and channels, and returns false when their length is zero","assert.NotEmpty evaluates non-zero primitive numbers and true boolean as not empty, and zero values as empty","assert.NotEmpty dereferences non-nil pointers recursively and treats nil pointers or pointers to empty values as empty","assert.NotEmpty returns true for structs with non-zero fields and false for zero-initialized structs"],"goal":"verify github.com/stretchr/testify/assert.NotEmpty in pkg:golang/github.com/stretchr/testify@v1.8.1","kind":"HOW","packages":["pkg:golang/github.com/stretchr/testify@v1.8.1"],"schemaVersion":1,"symbols":["github.com/stretchr/testify/assert.NotEmpty"]},"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.8.1"],"schemaVersion":1,"subject":"pkg:golang/github.com/stretchr/testify@v1.8.1","symbols":["github.com/stretchr/testify/assert.NotEmpty"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/stretchr/testify v1.8.1

require (
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
	gopkg.in/yaml.v3 v3.0.1 // indirect
)

github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/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/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package main

import (
	"fmt"

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

// Reporter implements assert.TestingT to record assertion failures.
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 application configuration settings.
type Config struct {
	Host string
	Port int
}

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

	// Example 1: Verifying non-empty string and slice
	serviceName := "order-processing"
	endpoints := []string{"/health", "/orders", "/metrics"}

	if assert.NotEmpty(reporter, serviceName, "service name must not be empty") {
		fmt.Printf("Valid service name: %s\n", serviceName)
	}

	if assert.NotEmpty(reporter, endpoints, "endpoints slice must not be empty") {
		fmt.Printf("Configured endpoints count: %d\n", len(endpoints))
	}

	// Example 2: Verifying non-empty map and channel
	headers := map[string]string{"Content-Type": "application/json"}
	ch := make(chan int, 1)
	ch <- 100

	if assert.NotEmpty(reporter, headers, "headers map must not be empty") {
		fmt.Printf("Header configured: %s\n", headers["Content-Type"])
	}

	if assert.NotEmpty(reporter, ch, "channel must have buffered items") {
		fmt.Println("Channel has items ready for processing.")
	}

	// Example 3: Verifying non-empty struct and primitive values
	cfg := Config{Host: "localhost", Port: 8080}
	if assert.NotEmpty(reporter, cfg, "config struct must not be zero-initialized") {
		fmt.Printf("Server address: %s:%d\n", cfg.Host, cfg.Port)
	}

	if !reporter.failed {
		fmt.Println("All assert.NotEmpty demonstrations completed successfully.")
	}
}

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

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...))
}

func main() {
	// Assertion 1: assert.NotEmpty returns true and does not record an error for non-empty string, and returns false with an error for empty string or nil
	{
		tSuccess := &contractTestingT{}
		if !assert.NotEmpty(tSuccess, "hello world") || tSuccess.failed || len(tSuccess.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: NotEmpty should succeed for non-empty string\n")
			os.Exit(1)
		}

		tEmptyStr := &contractTestingT{}
		if assert.NotEmpty(tEmptyStr, "") || !tEmptyStr.failed || len(tEmptyStr.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: NotEmpty should fail for empty string\n")
			os.Exit(1)
		}

		tNil := &contractTestingT{}
		if assert.NotEmpty(tNil, nil) || !tNil.failed || len(tNil.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: NotEmpty should fail for nil\n")
			os.Exit(1)
		}
	}

	// Assertion 2: assert.NotEmpty returns true for populated slices, maps, and channels, and returns false when their length is zero
	{
		tSuccess := &contractTestingT{}
		sliceVal := []string{"alpha", "beta"}
		mapVal := map[string]int{"count": 1}
		chVal := make(chan int, 2)
		chVal <- 42

		if !assert.NotEmpty(tSuccess, sliceVal) || !assert.NotEmpty(tSuccess, mapVal) || !assert.NotEmpty(tSuccess, chVal) || tSuccess.failed || len(tSuccess.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: NotEmpty should succeed for non-empty collections\n")
			os.Exit(1)
		}

		tEmptySlice := &contractTestingT{}
		if assert.NotEmpty(tEmptySlice, []int{}) || !tEmptySlice.failed || len(tEmptySlice.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: NotEmpty should fail for empty slice\n")
			os.Exit(1)
		}

		tEmptyMap := &contractTestingT{}
		if assert.NotEmpty(tEmptyMap, map[string]int{}) || !tEmptyMap.failed || len(tEmptyMap.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: NotEmpty should fail for empty map\n")
			os.Exit(1)
		}

		tEmptyChan := &contractTestingT{}
		emptyCh := make(chan int, 2)
		if assert.NotEmpty(tEmptyChan, emptyCh) || !tEmptyChan.failed || len(tEmptyChan.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: NotEmpty should fail for channel with len 0\n")
			os.Exit(1)
		}
	}

	// Assertion 3: assert.NotEmpty evaluates non-zero primitive numbers and true boolean as not empty, and zero values as empty
	{
		tSuccess := &contractTestingT{}
		if !assert.NotEmpty(tSuccess, 42) || !assert.NotEmpty(tSuccess, 3.14) || !assert.NotEmpty(tSuccess, true) || tSuccess.failed || len(tSuccess.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: NotEmpty should succeed for non-zero primitives and true\n")
			os.Exit(1)
		}

		tZeroInt := &contractTestingT{}
		if assert.NotEmpty(tZeroInt, 0) || !tZeroInt.failed || len(tZeroInt.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: NotEmpty should fail for integer 0\n")
			os.Exit(1)
		}

		tFalse := &contractTestingT{}
		if assert.NotEmpty(tFalse, false) || !tFalse.failed || len(tFalse.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: NotEmpty should fail for false\n")
			os.Exit(1)
		}
	}

	// Assertion 4: assert.NotEmpty dereferences non-nil pointers recursively and treats nil pointers or pointers to empty values as empty
	{
		tSuccess := &contractTestingT{}
		nonEmptyStr := "test"
		ptrSuccess := &nonEmptyStr
		ptrToPtr := &ptrSuccess
		if !assert.NotEmpty(tSuccess, ptrSuccess) || !assert.NotEmpty(tSuccess, ptrToPtr) || tSuccess.failed || len(tSuccess.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: NotEmpty should succeed for pointers to non-empty values\n")
			os.Exit(1)
		}

		tNilPtr := &contractTestingT{}
		var nilPtr *string
		if assert.NotEmpty(tNilPtr, nilPtr) || !tNilPtr.failed || len(tNilPtr.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: NotEmpty should fail for nil pointer\n")
			os.Exit(1)
		}

		tPtrToEmpty := &contractTestingT{}
		emptyStr := ""
		if assert.NotEmpty(tPtrToEmpty, &emptyStr) || !tPtrToEmpty.failed || len(tPtrToEmpty.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: NotEmpty should fail for pointer to empty string\n")
			os.Exit(1)
		}
	}

	// Assertion 5: assert.NotEmpty returns true for structs with non-zero fields and false for zero-initialized structs
	{
		type customItem struct {
			ID   int
			Name string
		}

		tSuccess := &contractTestingT{}
		nonEmptyItem := customItem{ID: 1, Name: "item"}
		if !assert.NotEmpty(tSuccess, nonEmptyItem) || tSuccess.failed || len(tSuccess.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: NotEmpty should succeed for struct with non-zero fields\n")
			os.Exit(1)
		}

		tZeroStruct := &contractTestingT{}
		zeroItem := customItem{}
		if assert.NotEmpty(tZeroStruct, zeroItem) || !tZeroStruct.failed || len(tZeroStruct.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: NotEmpty should fail for zero-initialized struct\n")
			os.Exit(1)
		}
	}

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