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

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.Error 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.Error

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:94697e9e7e71f1de913680f9362ee3a9ee08bac3a987ff4f0da209cc2279ffd4","contract":["assert.Error returns true and records no failure when given a non-nil error","assert.Error returns false and records test failure when given a nil error","assert.Error accepts formatted error messages with variadic arguments on assertion failure","assert.Error returns true and records no failure for wrapped errors","assert.Error returns true and records no failure for custom error types implementing the error interface"],"goal":"verify github.com/stretchr/testify/assert.Error 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.Error"]},"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.8.1"],"schemaVersion":1,"subject":"pkg:golang/github.com/stretchr/testify@v1.8.1","symbols":["github.com/stretchr/testify/assert.Error"],"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 (
	"errors"
	"fmt"

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

// ValidationError represents an error during payload validation.
type ValidationError struct {
	Field  string
	Reason string
}

func (e *ValidationError) Error() string {
	return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Reason)
}

// ValidationSummary tracks assertion outcomes for demonstration.
type ValidationSummary struct {
	Errors []string
	Passed int
	Failed int
}

func (v *ValidationSummary) Errorf(format string, args ...interface{}) {
	v.Errors = append(v.Errors, fmt.Sprintf(format, args...))
	v.Failed++
}

// ProcessInput validates an input string and returns an error if invalid.
func ProcessInput(input string) error {
	if input == "" {
		return errors.New("input string cannot be empty")
	}
	if len(input) < 3 {
		return &ValidationError{Field: "input", Reason: "minimum length is 3 characters"}
	}
	return nil
}

func main() {
	summary := &ValidationSummary{}

	// Case 1: assert.Error succeeds when standard error is returned
	errEmpty := ProcessInput("")
	if assert.Error(summary, errEmpty, "empty input should produce an error") {
		summary.Passed++
	}

	// Case 2: assert.Error succeeds when custom ValidationError is returned
	errShort := ProcessInput("ab")
	if assert.Error(summary, errShort, "short input should produce a ValidationError") {
		summary.Passed++
	}

	// Case 3: valid input returns nil, assert.Error correctly returns false
	errValid := ProcessInput("valid-input")
	nilTracker := &ValidationSummary{}
	if !assert.Error(nilTracker, errValid) {
		summary.Passed++
	}

	fmt.Printf("Demonstration finished: %d assertions passed, %d failures recorded\n", summary.Passed, summary.Failed)
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/stretchr/testify/assert.Error 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.Error"
  ]
}

package main

import (
	"errors"
	"fmt"
	"os"
	"strings"

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

// contractTestingT implements assert.TestingT for offline verification.
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...))
}

// customErrorType implements the error interface.
type customErrorType struct {
	code    int
	message string
}

func (e *customErrorType) Error() string {
	return fmt.Sprintf("error [%d]: %s", e.code, e.message)
}

func main() {
	// Assertion 1: assert.Error returns true and records no failure when given a non-nil error
	{
		t := &contractTestingT{}
		stdErr := errors.New("standard error occurred")
		if !assert.Error(t, stdErr) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Error should return true and record no failure on non-nil error\n")
			os.Exit(1)
		}
	}

	// Assertion 2: assert.Error returns false and records test failure when given a nil error
	{
		t := &contractTestingT{}
		if assert.Error(t, nil) || !t.failed || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Error should return false and record failure on nil error\n")
			os.Exit(1)
		}
	}

	// Assertion 3: assert.Error accepts formatted error messages with variadic arguments on assertion failure
	{
		t := &contractTestingT{}
		expectedFormatArg := "operation-timeout"
		if assert.Error(t, nil, "expected failure for %s code %d", expectedFormatArg, 504) || !t.failed || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.Error should return false when given nil error\n")
			os.Exit(1)
		}
		foundFormattedMsg := false
		for _, errStr := range t.errors {
			if strings.Contains(errStr, "expected failure for operation-timeout code 504") {
				foundFormattedMsg = true
				break
			}
		}
		if !foundFormattedMsg {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: formatted error message not found in recorded errors\n")
			os.Exit(1)
		}
	}

	// Assertion 4: assert.Error returns true and records no failure for wrapped errors
	{
		t := &contractTestingT{}
		rootErr := errors.New("root failure")
		wrappedErr := fmt.Errorf("wrapped context: %w", rootErr)
		if !assert.Error(t, wrappedErr) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.Error should return true for wrapped errors\n")
			os.Exit(1)
		}
	}

	// Assertion 5: assert.Error returns true and records no failure for custom error types implementing the error interface
	{
		t := &contractTestingT{}
		custErr := &customErrorType{code: 403, message: "forbidden action"}
		if !assert.Error(t, custErr) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.Error should return true for custom error type\n")
			os.Exit(1)
		}
	}

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