github.com/stretchr/testify v1.8.1: require.Equal, require.NoError

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

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/stretchr/testify@v1.8.1
Demonstrate these symbols/APIs:
  - require.Equal
  - require.NoError

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:6cd3ab238e513699a8e4cca2374845e648ea91cbdbf67e452da07f89c2cbe587","contract":["require.Equal passes when expected and actual values are equal without triggering failure or FailNow","require.Equal invokes Errorf and FailNow to halt execution immediately when values differ","require.NoError passes without failure when given a nil error","require.NoError invokes Errorf and FailNow to halt execution immediately when given a non-nil error","require.NotNil passes for non-nil values and halts execution via FailNow when given nil"],"goal":"verify pkg:golang/github.com/stretchr/testify@v1.8.1","kind":"HOW","packages":["pkg:golang/github.com/stretchr/testify@v1.8.1"],"schemaVersion":1,"symbols":["require.Equal","require.NoError"]},"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":["require.Equal","require.NoError"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.20

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/require"
)

type customTestingT struct {
	failed        bool
	failNowCalled bool
	errors        []string
}

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

func (t *customTestingT) FailNow() {
	t.failNowCalled = true
	panic("FailNow called")
}

func main() {
	t := &customTestingT{}

	// Scenario 1: Successful assertions with require.NoError and require.Equal
	err := doOperation(true)
	require.NoError(t, err, "operation should succeed")

	val := computeValue()
	require.Equal(t, 42, val, "value should equal 42")

	require.NotNil(t, val, "value should not be nil")

	fmt.Println("Successful require assertions passed without halting.")

	// Scenario 2: Fail-fast behavior on error
	failedT := &customTestingT{}
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Println("require correctly halted execution via FailNow:", r)
			}
		}()
		badErr := doOperation(false)
		require.NoError(failedT, badErr, "expected error triggers fail-fast")
		fmt.Println("This line is never reached due to FailNow")
	}()

	if failedT.failNowCalled && failedT.failed {
		fmt.Println("require fail-fast contract demonstrated successfully.")
	}
}

func doOperation(success bool) error {
	if !success {
		return errors.New("operation failed")
	}
	return nil
}

func computeValue() int {
	return 42
}

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

package main

import (
	"errors"
	"fmt"
	"os"

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

type mockTestingT struct {
	failed        bool
	failNowCalled bool
	errors        []string
}

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

func (m *mockTestingT) FailNow() {
	m.failNowCalled = true
	panic("FailNow called")
}

func main() {
	// Assertion 1: require.Equal passes when expected and actual values are equal without triggering failure or FailNow
	{
		t := &mockTestingT{}
		require.Equal(t, "expected-value", "expected-value", "strings must match")
		require.Equal(t, 100, 100, "integers must match")

		if t.failed || t.failNowCalled || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: require.Equal reported failure for equal values\n")
			os.Exit(1)
		}
	}

	// Assertion 2: require.Equal invokes Errorf and FailNow to halt execution immediately when values differ
	{
		t := &mockTestingT{}
		unreachableReached := false

		func() {
			defer func() {
				_ = recover()
			}()
			require.Equal(t, "expected", "actual", "values differ")
			unreachableReached = true
		}()

		if unreachableReached {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: execution did not halt after require.Equal failure\n")
			os.Exit(1)
		}
		if !t.failed || !t.failNowCalled || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: require.Equal did not invoke Errorf and FailNow on mismatch\n")
			os.Exit(1)
		}
	}

	// Assertion 3: require.NoError passes without failure when given a nil error
	{
		t := &mockTestingT{}
		var err error = nil
		require.NoError(t, err, "nil error should pass")

		if t.failed || t.failNowCalled || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: require.NoError failed on nil error\n")
			os.Exit(1)
		}
	}

	// Assertion 4: require.NoError invokes Errorf and FailNow to halt execution immediately when given a non-nil error
	{
		t := &mockTestingT{}
		unreachableReached := false

		func() {
			defer func() {
				_ = recover()
			}()
			err := errors.New("synthetic error condition")
			require.NoError(t, err, "non-nil error must trigger failure")
			unreachableReached = true
		}()

		if unreachableReached {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: execution did not halt after require.NoError failure\n")
			os.Exit(1)
		}
		if !t.failed || !t.failNowCalled || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: require.NoError did not invoke Errorf and FailNow on non-nil error\n")
			os.Exit(1)
		}
	}

	// Assertion 5: require.NotNil passes for non-nil values and halts execution via FailNow when given nil
	{
		// 5a: non-nil passes
		tPass := &mockTestingT{}
		val := "valid-pointer"
		require.NotNil(tPass, &val, "pointer is not nil")

		if tPass.failed || tPass.failNowCalled || len(tPass.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: require.NotNil failed for non-nil value\n")
			os.Exit(1)
		}

		// 5b: nil fails and halts
		tFail := &mockTestingT{}
		unreachableReached := false

		func() {
			defer func() {
				_ = recover()
			}()
			var nilPtr *string = nil
			require.NotNil(tFail, nilPtr, "nil pointer must fail")
			unreachableReached = true
		}()

		if unreachableReached {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: execution did not halt after require.NotNil on nil\n")
			os.Exit(1)
		}
		if !tFail.failed || !tFail.failNowCalled || len(tFail.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: require.NotNil did not invoke Errorf and FailNow on nil\n")
			os.Exit(1)
		}
	}

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