github.com/stretchr/testify v1.9.0: assert.Equal

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

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/stretchr/testify@v1.9.0

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:e87deef6536456e2e0f74929a3e20282410690dc942564c489b6e0432b5578bf","contract":["assert.Equal returns true and records no error on identical primitive values","assert.Equal returns false and records an error when primitive values differ","assert.Equal reports failure when numeric types differ even if values match","assert.Equal performs deep comparison of slices and maps and returns true on equivalence","assert.Equal returns false when comparing slices with different elements or order","assert.Equal performs deep comparison of structs and returns true on equivalence","assert.Equal returns true when comparing untyped nil values and false when comparing nil with non-nil","assert.Equal formats and includes custom message arguments when an assertion fails"],"goal":"verify pkg:golang/github.com/stretchr/testify@v1.9.0","kind":"HOW","packages":["pkg:golang/github.com/stretchr/testify@v1.9.0"],"schemaVersion":1,"symbols":["github.com/stretchr/testify/assert.Equal"]},"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.9.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/stretchr/testify@v1.9.0","symbols":["github.com/stretchr/testify/assert.Equal"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/stretchr/testify v1.9.0

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.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/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
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.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"
)

type OutputCapture struct {
	errors []string
	failed bool
}

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

type UserRecord struct {
	ID    int
	Name  string
	Roles []string
}

func main() {
	capture := &OutputCapture{}

	// Example 1: Verify identical primitive values
	expectedStatus := 200
	actualStatus := 200
	if assert.Equal(capture, expectedStatus, actualStatus, "status codes must match") {
		fmt.Println("Primitive values matched successfully.")
	}

	// Example 2: Verify deep equality on composite structs and slices
	expectedRecord := UserRecord{
		ID:    1,
		Name:  "guest",
		Roles: []string{"viewer"},
	}
	actualRecord := UserRecord{
		ID:    1,
		Name:  "guest",
		Roles: []string{"viewer"},
	}
	if assert.Equal(capture, expectedRecord, actualRecord, "user records must be identical") {
		fmt.Printf("User record matched: ID=%d Name=%s\n", actualRecord.ID, actualRecord.Name)
	}

	if !capture.failed {
		fmt.Println("All testify assert.Equal demonstrations completed successfully.")
	}
}

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

package main

import (
	"fmt"
	"os"
	"strings"

	"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 UserRecord struct {
	ID    int
	Name  string
	Roles []string
}

func main() {
	// Assertion 1: assert.Equal returns true and records no error on identical primitive values
	{
		t := &contractTestingT{}
		if !assert.Equal(t, "hello", "hello") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Equal should return true with no error on matching strings\n")
			os.Exit(1)
		}

		if !assert.Equal(t, 12345, 12345) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Equal should return true with no error on matching integers\n")
			os.Exit(1)
		}

		if !assert.Equal(t, true, true) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Equal should return true with no error on matching booleans\n")
			os.Exit(1)
		}
	}

	// Assertion 2: assert.Equal returns false and records an error when primitive values differ
	{
		tStr := &contractTestingT{}
		if assert.Equal(tStr, "expected", "actual") || !tStr.failed || len(tStr.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Equal should return false and report error on string mismatch\n")
			os.Exit(1)
		}

		tInt := &contractTestingT{}
		if assert.Equal(tInt, 10, 20) || !tInt.failed || len(tInt.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Equal should return false and report error on int mismatch\n")
			os.Exit(1)
		}
	}

	// Assertion 3: assert.Equal reports failure when numeric types differ even if values match
	{
		tInt64 := &contractTestingT{}
		if assert.Equal(tInt64, int(100), int64(100)) || !tInt64.failed || len(tInt64.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.Equal should return false on int vs int64 type mismatch\n")
			os.Exit(1)
		}

		tFloat := &contractTestingT{}
		if assert.Equal(tFloat, float32(1.5), float64(1.5)) || !tFloat.failed || len(tFloat.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.Equal should return false on float32 vs float64 type mismatch\n")
			os.Exit(1)
		}
	}

	// Assertion 4: assert.Equal performs deep comparison of slices and maps and returns true on equivalence
	{
		tSlice := &contractTestingT{}
		slice1 := []string{"apple", "banana"}
		slice2 := []string{"apple", "banana"}
		if !assert.Equal(tSlice, slice1, slice2) || tSlice.failed || len(tSlice.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.Equal should return true on matching slices\n")
			os.Exit(1)
		}

		tMap := &contractTestingT{}
		map1 := map[string]int{"one": 1, "two": 2}
		map2 := map[string]int{"one": 1, "two": 2}
		if !assert.Equal(tMap, map1, map2) || tMap.failed || len(tMap.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.Equal should return true on matching maps\n")
			os.Exit(1)
		}
	}

	// Assertion 5: assert.Equal returns false when comparing slices with different elements or order
	{
		tDiffElem := &contractTestingT{}
		slice1 := []string{"apple", "banana"}
		slice2 := []string{"apple", "orange"}
		if assert.Equal(tDiffElem, slice1, slice2) || !tDiffElem.failed || len(tDiffElem.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.Equal should return false on mismatched elements\n")
			os.Exit(1)
		}

		tDiffOrder := &contractTestingT{}
		slice3 := []string{"banana", "apple"}
		if assert.Equal(tDiffOrder, slice1, slice3) || !tDiffOrder.failed || len(tDiffOrder.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.Equal should return false when slice order differs\n")
			os.Exit(1)
		}
	}

	// Assertion 6: assert.Equal performs deep comparison of structs and returns true on equivalence
	{
		tStruct := &contractTestingT{}
		record1 := UserRecord{ID: 1, Name: "guest", Roles: []string{"viewer"}}
		record2 := UserRecord{ID: 1, Name: "guest", Roles: []string{"viewer"}}
		if !assert.Equal(tStruct, record1, record2) || tStruct.failed || len(tStruct.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: assert.Equal should return true on matching structs\n")
			os.Exit(1)
		}

		tStructDiff := &contractTestingT{}
		record3 := UserRecord{ID: 2, Name: "guest", Roles: []string{"viewer"}}
		if assert.Equal(tStructDiff, record1, record3) || !tStructDiff.failed || len(tStructDiff.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: assert.Equal should return false on differing structs\n")
			os.Exit(1)
		}
	}

	// Assertion 7: assert.Equal returns true when comparing untyped nil values and false when comparing nil with non-nil
	{
		tNil := &contractTestingT{}
		if !assert.Equal(tNil, nil, nil) || tNil.failed || len(tNil.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 7 failed: assert.Equal should return true on nil == nil\n")
			os.Exit(1)
		}

		tNilMismatch := &contractTestingT{}
		if assert.Equal(tNilMismatch, nil, "defined-value") || !tNilMismatch.failed || len(tNilMismatch.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 7 failed: assert.Equal should return false on nil vs non-nil\n")
			os.Exit(1)
		}
	}

	// Assertion 8: assert.Equal formats and includes custom message arguments when an assertion fails
	{
		tMsg := &contractTestingT{}
		assert.Equal(tMsg, "expected", "actual", "status check failed with code %d", 500)
		if !tMsg.failed || len(tMsg.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 8 failed: expected failure on assert.Equal\n")
			os.Exit(1)
		}
		if !strings.Contains(tMsg.errors[0], "status check failed with code 500") {
			fmt.Fprintf(os.Stderr, "assertion 8 failed: custom message not formatted in assert.Equal: %s\n", tMsg.errors[0])
			os.Exit(1)
		}
	}

	fmt.Println("All testify assert.Equal contract assertions passed.")
}