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

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

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:bc0a6f419ee9d7b08dfb6dd9a50d2c13927b7b544ae8d72377e43dec6b8586cb","contract":["assert.Equal returns true and records no error on equal values, and returns false reporting error on inequality","assert.True and assert.False correctly validate boolean values and report errors on inverted conditions","assert.Nil and assert.NotNil correctly differentiate nil and non-nil pointers and interfaces","assert.NoError and assert.Error validate nil and non-nil errors and record appropriate failures","assert.Contains verifies substring and element membership in collections","assert.New creates an Assertions helper that successfully binds to TestingT and executes assertions"],"goal":"verify github.com/stretchr/testify/assert 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"]},"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"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require (
	github.com/davecgh/go-spew v1.1.0 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
	github.com/stretchr/objx v0.1.0 // indirect
	github.com/stretchr/testify v1.3.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 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
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 (
	"errors"
	"fmt"

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

// Reporter implements assert.TestingT to record assertion results.
type Reporter struct {
	Errors []string
	Passed int
	Failed int
}

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

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

	// Verify equality
	if assert.Equal(reporter, "expected_value", "expected_value") {
		reporter.Passed++
	}

	// Verify boolean predicates
	if assert.True(reporter, 10 > 5) {
		reporter.Passed++
	}
	if assert.False(reporter, 5 > 10) {
		reporter.Passed++
	}

	// Verify nil vs non-nil
	if assert.Nil(reporter, nil) {
		reporter.Passed++
	}
	if assert.NotNil(reporter, &Reporter{}) {
		reporter.Passed++
	}

	// Verify error checking
	if assert.NoError(reporter, nil) {
		reporter.Passed++
	}
	testErr := errors.New("operation failed")
	if assert.Error(reporter, testErr) {
		reporter.Passed++
	}

	// Verify contains
	if assert.Contains(reporter, "hello world", "world") {
		reporter.Passed++
	}

	// Verify assertion wrapper
	assertions := assert.New(reporter)
	if assertions.Equal(42, 42) {
		reporter.Passed++
	}

	fmt.Printf("Evaluation complete: %d passed, %d failed\n", reporter.Passed, reporter.Failed)
}

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

package main

import (
	"errors"
	"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.Equal returns true and records no error on equal values, and returns false reporting error on inequality
	{
		t := &contractTestingT{}
		if !assert.Equal(t, "alpha", "alpha") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Equal should return true for equal strings\n")
			os.Exit(1)
		}
		if !assert.Equal(t, 42, 42) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Equal should return true for equal integers\n")
			os.Exit(1)
		}

		tFail := &contractTestingT{}
		if assert.Equal(tFail, "alpha", "beta") || !tFail.failed || len(tFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Equal should return false and record error for unequal values\n")
			os.Exit(1)
		}
	}

	// Assertion 2: assert.True and assert.False correctly validate boolean values and report errors on inverted conditions
	{
		t := &contractTestingT{}
		if !assert.True(t, true) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.True should return true for true condition\n")
			os.Exit(1)
		}
		if !assert.False(t, false) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.False should return true for false condition\n")
			os.Exit(1)
		}

		tTrueFail := &contractTestingT{}
		if assert.True(tTrueFail, false) || !tTrueFail.failed || len(tTrueFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.True should return false and record error on false\n")
			os.Exit(1)
		}

		tFalseFail := &contractTestingT{}
		if assert.False(tFalseFail, true) || !tFalseFail.failed || len(tFalseFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.False should return false and record error on true\n")
			os.Exit(1)
		}
	}

	// Assertion 3: assert.Nil and assert.NotNil correctly differentiate nil and non-nil pointers and interfaces
	{
		t := &contractTestingT{}
		var ptr *int
		if !assert.Nil(t, ptr) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.Nil should return true for nil pointer\n")
			os.Exit(1)
		}
		val := 10
		if !assert.NotNil(t, &val) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.NotNil should return true for non-nil pointer\n")
			os.Exit(1)
		}

		tNilFail := &contractTestingT{}
		if assert.Nil(tNilFail, &val) || !tNilFail.failed || len(tNilFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.Nil should return false and record error for non-nil\n")
			os.Exit(1)
		}

		tNotNilFail := &contractTestingT{}
		if assert.NotNil(tNotNilFail, ptr) || !tNotNilFail.failed || len(tNotNilFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.NotNil should return false and record error for nil\n")
			os.Exit(1)
		}
	}

	// Assertion 4: assert.NoError and assert.Error validate nil and non-nil errors and record appropriate failures
	{
		t := &contractTestingT{}
		if !assert.NoError(t, nil) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.NoError should return true for nil error\n")
			os.Exit(1)
		}
		err := errors.New("sample error")
		if !assert.Error(t, err) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.Error should return true for non-nil error\n")
			os.Exit(1)
		}

		tNoErrorFail := &contractTestingT{}
		if assert.NoError(tNoErrorFail, err) || !tNoErrorFail.failed || len(tNoErrorFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.NoError should return false and record error for non-nil error\n")
			os.Exit(1)
		}

		tErrorFail := &contractTestingT{}
		if assert.Error(tErrorFail, nil) || !tErrorFail.failed || len(tErrorFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.Error should return false and record error for nil error\n")
			os.Exit(1)
		}
	}

	// Assertion 5: assert.Contains verifies substring and element membership in collections
	{
		t := &contractTestingT{}
		if !assert.Contains(t, "golang testify library", "testify") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.Contains should return true for matching substring\n")
			os.Exit(1)
		}
		slice := []string{"red", "green", "blue"}
		if !assert.Contains(t, slice, "green") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.Contains should return true for slice containing element\n")
			os.Exit(1)
		}

		tFail := &contractTestingT{}
		if assert.Contains(tFail, "golang testify library", "python") || !tFail.failed || len(tFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.Contains should return false and record error for missing substring\n")
			os.Exit(1)
		}
	}

	// Assertion 6: assert.New creates an Assertions helper that successfully binds to TestingT and executes assertions
	{
		t := &contractTestingT{}
		assertions := assert.New(t)
		if !assertions.Equal("same", "same") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: assertions.Equal should return true for equal values\n")
			os.Exit(1)
		}
		if !assertions.True(len("hello") == 5) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: assertions.True should return true for true condition\n")
			os.Exit(1)
		}

		if assertions.Equal("same", "different") || !t.failed || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: assertions.Equal should return false and record error for mismatch\n")
			os.Exit(1)
		}
	}

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