github.com/stretchr/testify v1.7.0: assert.Never

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

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

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:149f57f65a65d9f78999ed34d1e11d7629c0d578e173cf05b2283230563ae137","contract":["assert.Never returns true and logs no errors when the condition evaluates to false throughout the waitFor duration","assert.Never returns false and records an error via TestingT when the condition evaluates to true before the timeout","assert.Never formats and records custom failure messages when the condition evaluates to true","assert.New(t).Never provides struct-bound assertion with identical verification behavior"],"goal":"verify github.com/stretchr/testify/assert.Never in pkg:golang/github.com/stretchr/testify@v1.7.0","kind":"HOW","packages":["pkg:golang/github.com/stretchr/testify@v1.7.0"],"schemaVersion":1,"symbols":["github.com/stretchr/testify/assert.Never"]},"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/stretchr/testify@v1.7.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/stretchr/testify@v1.7.0","symbols":["github.com/stretchr/testify/assert.Never"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require github.com/stretchr/testify v1.7.0

require (
	github.com/davecgh/go-spew v1.1.0 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // 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.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
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 h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package main

import (
	"fmt"
	"sync/atomic"
	"time"

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

// SimpleReporter records testing failures.
type SimpleReporter struct {
	errors []string
}

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

// CircuitBreaker maintains error state to trip when a failure is recorded.
type CircuitBreaker struct {
	tripped int32
}

func (c *CircuitBreaker) RecordFailure() {
	atomic.StoreInt32(&c.tripped, 1)
}

func (c *CircuitBreaker) IsTripped() bool {
	return atomic.LoadInt32(&c.tripped) == 1
}

func main() {
	reporter := &SimpleReporter{}
	breaker := &CircuitBreaker{}

	// Verify that breaker is never tripped during a stable window of 100ms
	neverTripped := assert.Never(
		reporter,
		func() bool {
			return breaker.IsTripped()
		},
		100*time.Millisecond,
		20*time.Millisecond,
		"breaker should never trip during stable period",
	)

	if !neverTripped || len(reporter.errors) > 0 {
		fmt.Printf("unexpected failure: %v\n", reporter.errors)
		return
	}

	fmt.Println("assert.Never demonstration completed successfully: condition remained false as expected.")
}

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

package main

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

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

type contractTestingT struct {
	errors []string
}

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

func main() {
	// Assertion 1: assert.Never returns true and logs no errors when the condition evaluates to false throughout the waitFor duration
	{
		mockT := &contractTestingT{}
		checkCount := int32(0)

		passed := assert.Never(
			mockT,
			func() bool {
				atomic.AddInt32(&checkCount, 1)
				return false
			},
			60*time.Millisecond,
			15*time.Millisecond,
		)

		if !passed {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Never returned false, expected true\n")
			os.Exit(1)
		}
		if len(mockT.errors) > 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: mockT recorded unexpected errors: %v\n", mockT.errors)
			os.Exit(1)
		}
		if atomic.LoadInt32(&checkCount) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: condition function was never invoked\n")
			os.Exit(1)
		}
	}

	// Assertion 2: assert.Never returns false and records an error via TestingT when the condition evaluates to true before the timeout
	{
		mockT := &contractTestingT{}
		callCount := int32(0)

		passed := assert.Never(
			mockT,
			func() bool {
				count := atomic.AddInt32(&callCount, 1)
				// Return true on the second check
				return count >= 2
			},
			100*time.Millisecond,
			15*time.Millisecond,
		)

		if passed {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Never returned true when condition became true, expected false\n")
			os.Exit(1)
		}
		if len(mockT.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: mockT did not record any error upon failure\n")
			os.Exit(1)
		}
	}

	// Assertion 3: assert.Never formats and records custom failure messages when the condition evaluates to true
	{
		mockT := &contractTestingT{}
		customMsg := "metric invariant violation"

		passed := assert.Never(
			mockT,
			func() bool {
				return true
			},
			50*time.Millisecond,
			10*time.Millisecond,
			"custom failure details: %s", customMsg,
		)

		if passed {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.Never returned true for always-true condition\n")
			os.Exit(1)
		}
		if len(mockT.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: mockT recorded no error message\n")
			os.Exit(1)
		}
		foundCustomMsg := false
		for _, errMsg := range mockT.errors {
			if strings.Contains(errMsg, customMsg) {
				foundCustomMsg = true
				break
			}
		}
		if !foundCustomMsg {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: custom message %q not found in errors: %v\n", customMsg, mockT.errors)
			os.Exit(1)
		}
	}

	// Assertion 4: assert.New(t).Never provides struct-bound assertion with identical verification behavior
	{
		mockT := &contractTestingT{}
		assertions := assert.New(mockT)

		success := assertions.Never(
			func() bool {
				return false
			},
			60*time.Millisecond,
			15*time.Millisecond,
		)

		if !success || len(mockT.errors) > 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assertions.Never failed for always-false condition: %v\n", mockT.errors)
			os.Exit(1)
		}

		failMockT := &contractTestingT{}
		failAssertions := assert.New(failMockT)

		failureHandled := failAssertions.Never(
			func() bool {
				return true
			},
			50*time.Millisecond,
			10*time.Millisecond,
		)

		if failureHandled {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assertions.Never returned true for always-true condition\n")
			os.Exit(1)
		}
		if len(failMockT.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: failMockT recorded no error for failed assertions.Never\n")
			os.Exit(1)
		}
	}

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