github.com/stretchr/testify v1.3.0: assert.Nil, assert.NotNil

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:fcf1c026441d693b288ffa3fd9705bba2b498544c8323c02efb8d132af99b0fc","contract":["assert.Nil returns true and records no error when passed untyped nil","assert.Nil returns true and records no error for typed nil pointers, slices, maps, channels, and functions","assert.Nil returns false and records an error when passed a non-nil object or primitive value","assert.NotNil returns true and records no error when passed a non-nil value","assert.NotNil returns false and records an error when passed untyped nil or typed nil values","assert.Nil and assert.NotNil 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.Nil","github.com/stretchr/testify/assert.NotNil"]},"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.Nil","github.com/stretchr/testify/assert.NotNil"],"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 UserSession struct {
	SessionID string
	UserID    int
}

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

	// Example 1: Verify uninitialized session pointer is nil
	var session *UserSession = nil
	if assert.Nil(capture, session, "newly declared session pointer must be nil") {
		fmt.Println("Initial session state is nil as expected.")
	}

	// Example 2: Verify active session instance is not nil
	activeSession := &UserSession{
		SessionID: "sess-1001",
		UserID:    42,
	}
	if assert.NotNil(capture, activeSession, "allocated session must not be nil") {
		fmt.Printf("Active session verified: UserID=%d\n", activeSession.UserID)
	}

	// Example 3: Verify map and slice nil states
	var pendingQueue []string = nil
	var cacheStore map[string]string = nil
	if assert.Nil(capture, pendingQueue) && assert.Nil(capture, cacheStore) {
		fmt.Println("Pending collections are nil before lazy initialization.")
	}

	if !capture.failed {
		fmt.Println("All testify assert.Nil and assert.NotNil 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.Nil returns true and records no error when passed untyped nil
	{
		t := &contractTestingT{}
		res := assert.Nil(t, nil)
		if !res || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: assert.Nil should return true and no error for untyped nil\n")
			os.Exit(1)
		}
	}

	// Assertion 2: assert.Nil returns true and records no error for typed nil pointers, slices, maps, channels, and functions
	{
		t := &contractTestingT{}
		var ptr *int = nil
		var sl []string = nil
		var m map[string]int = nil
		var ch chan int = nil
		var fn func() = nil

		if !assert.Nil(t, ptr) || t.failed {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Nil should return true for typed nil pointer\n")
			os.Exit(1)
		}
		if !assert.Nil(t, sl) || t.failed {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Nil should return true for typed nil slice\n")
			os.Exit(1)
		}
		if !assert.Nil(t, m) || t.failed {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Nil should return true for typed nil map\n")
			os.Exit(1)
		}
		if !assert.Nil(t, ch) || t.failed {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Nil should return true for typed nil channel\n")
			os.Exit(1)
		}
		if !assert.Nil(t, fn) || t.failed {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: assert.Nil should return true for typed nil func\n")
			os.Exit(1)
		}
		if len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: errors recorded for typed nil values\n")
			os.Exit(1)
		}
	}

	// Assertion 3: assert.Nil returns false and records an error when passed a non-nil object or primitive value
	{
		t := &contractTestingT{}
		val := 100
		if assert.Nil(t, &val) || !t.failed || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.Nil should return false and record error for non-nil pointer\n")
			os.Exit(1)
		}

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

		t3 := &contractTestingT{}
		if assert.Nil(t3, []int{1, 2, 3}) || !t3.failed || len(t3.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: assert.Nil should return false and record error for non-empty slice\n")
			os.Exit(1)
		}
	}

	// Assertion 4: assert.NotNil returns true and records no error when passed a non-nil value
	{
		t := &contractTestingT{}
		num := 42
		if !assert.NotNil(t, &num) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.NotNil should return true for pointer\n")
			os.Exit(1)
		}
		if !assert.NotNil(t, "hello") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.NotNil should return true for string\n")
			os.Exit(1)
		}
		if !assert.NotNil(t, []string{"alpha"}) || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: assert.NotNil should return true for slice\n")
			os.Exit(1)
		}
	}

	// Assertion 5: assert.NotNil returns false and records an error when passed untyped nil or typed nil values
	{
		t := &contractTestingT{}
		if assert.NotNil(t, nil) || !t.failed || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.NotNil should return false for untyped nil\n")
			os.Exit(1)
		}

		tPtr := &contractTestingT{}
		var ptr *string = nil
		if assert.NotNil(tPtr, ptr) || !tPtr.failed || len(tPtr.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.NotNil should return false for typed nil pointer\n")
			os.Exit(1)
		}

		tSlice := &contractTestingT{}
		var sl []int = nil
		if assert.NotNil(tSlice, sl) || !tSlice.failed || len(tSlice.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: assert.NotNil should return false for typed nil slice\n")
			os.Exit(1)
		}
	}

	// Assertion 6: assert.Nil and assert.NotNil format and include custom message arguments when an assertion fails
	{
		t := &contractTestingT{}
		assert.Nil(t, "unexpected", "check token %s id %d", "secret", 123)
		if !t.failed || len(t.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: expected failure on assert.Nil\n")
			os.Exit(1)
		}
		if !strings.Contains(t.errors[0], "check token secret id 123") {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: custom message not formatted properly in assert.Nil: %s\n", t.errors[0])
			os.Exit(1)
		}

		t2 := &contractTestingT{}
		assert.NotNil(t2, nil, "expected valid handle for %s port %d", "server", 8080)
		if !t2.failed || len(t2.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: expected failure on assert.NotNil\n")
			os.Exit(1)
		}
		if !strings.Contains(t2.errors[0], "expected valid handle for server port 8080") {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: custom message not formatted properly in assert.NotNil: %s\n", t2.errors[0])
			os.Exit(1)
		}
	}

	fmt.Println("All testify assert.Nil and assert.NotNil contract assertions passed.")
}