github.com/stretchr/testify v1.3.0: assert.Equal, assert.NotEqual

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.3.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/stretchr/testify@v1.3.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:563a63a986fdf38cdcb434e9ff624cf94eb69d79871ebf55ae251606e60c8a48","contract":["assert.Equal returns true and records no error on identical primitive values","assert.Equal returns false and reports 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 true when comparing untyped nil values and false when comparing nil with non-nil","assert.NotEqual returns true and records no error when comparing different primitive values","assert.NotEqual returns false and records an error when comparing identical values","assert.Equal and assert.NotEqual format and include custom message arguments when an assertion fails"],"goal":"verify 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.Equal","github.com/stretchr/testify/assert.NotEqual"]},"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.3.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/stretchr/testify@v1.3.0","symbols":["github.com/stretchr/testify/assert.Equal","github.com/stretchr/testify/assert.NotEqual"],"verifierAdapter":"golang@1"}

module sample

go 1.22

require github.com/stretchr/testify v1.3.0

require (
	github.com/davecgh/go-spew v1.1.0 // indirect
	github.com/pmezard/go-difflib v1.0.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/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 (
	"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)
	}

	// Example 3: Verify inequality between different values
	initialToken := "token-alpha"
	updatedToken := "token-beta"
	if assert.NotEqual(capture, initialToken, updatedToken, "tokens must rotate") {
		fmt.Println("Token rotation verified: tokens are not equal.")
	}

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

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

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

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 reports error when primitive values differ
	{
		t := &contractTestingT{}
		if assert.Equal(t, "expected", "actual") || !t.failed || len(t.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
	{
		t := &contractTestingT{}
		if assert.Equal(t, int(100), int64(100)) || !t.failed || len(t.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
	{
		t := &contractTestingT{}
		slice1 := []string{"apple", "banana"}
		slice2 := []string{"apple", "banana"}
		if !assert.Equal(t, slice1, slice2) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.Equal should return true on matching slices\n")
			os.Exit(1)
		}

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

		tDiff := &contractTestingT{}
		slice3 := []string{"apple", "orange"}
		if assert.Equal(tDiff, slice1, slice3) || !tDiff.failed || len(tDiff.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.Equal should return false on mismatched slices\n")
			os.Exit(1)
		}
	}

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

	// Assertion 6: assert.NotEqual returns true and records no error when comparing different primitive values
	{
		t := &contractTestingT{}
		if !assert.NotEqual(t, "alpha", "beta") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: assert.NotEqual should return true for distinct strings\n")
			os.Exit(1)
		}

		if !assert.NotEqual(t, 100, 200) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: assert.NotEqual should return true for distinct ints\n")
			os.Exit(1)
		}

		if !assert.NotEqual(t, int(100), int64(100)) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: assert.NotEqual should return true for different numeric types\n")
			os.Exit(1)
		}
	}

	// Assertion 7: assert.NotEqual returns false and records an error when comparing identical values
	{
		t := &contractTestingT{}
		if assert.NotEqual(t, "identical", "identical") || !t.failed || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 7 failed: assert.NotEqual should return false for identical strings\n")
			os.Exit(1)
		}

		tSlice := &contractTestingT{}
		sl1 := []int{1, 2, 3}
		sl2 := []int{1, 2, 3}
		if assert.NotEqual(tSlice, sl1, sl2) || !tSlice.failed || len(tSlice.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 7 failed: assert.NotEqual should return false for identical slices\n")
			os.Exit(1)
		}
	}

	// Assertion 8: assert.Equal and assert.NotEqual format and include custom message arguments when an assertion fails
	{
		tEqual := &contractTestingT{}
		assert.Equal(tEqual, "foo", "bar", "check parameter %s code %d", "status", 404)
		if !tEqual.failed || len(tEqual.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 8 failed: expected failure on assert.Equal\n")
			os.Exit(1)
		}
		if !strings.Contains(tEqual.errors[0], "check parameter status code 404") {
			fmt.Fprintf(os.Stderr, "assertion 8 failed: custom message not formatted in assert.Equal: %s\n", tEqual.errors[0])
			os.Exit(1)
		}

		tNotEqual := &contractTestingT{}
		assert.NotEqual(tNotEqual, "same", "same", "check token %s id %d", "auth", 99)
		if !tNotEqual.failed || len(tNotEqual.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 8 failed: expected failure on assert.NotEqual\n")
			os.Exit(1)
		}
		if !strings.Contains(tNotEqual.errors[0], "check token auth id 99") {
			fmt.Fprintf(os.Stderr, "assertion 8 failed: custom message not formatted in assert.NotEqual: %s\n", tNotEqual.errors[0])
			os.Exit(1)
		}
	}

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