github.com/stretchr/testify v1.8.1: assert.Contains

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.Contains in 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:
  - github.com/stretchr/testify/assert.Contains

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:84e6808f3095c9b659d5dd319d8f0afd0d45295df0d6bb47e8c977f8cd44f9b9","contract":["assert.Contains returns true and does not record an error when a string contains a substring","assert.Contains returns true and does not record an error when a slice or array contains an element","assert.Contains returns true and does not record an error when a map contains the specified key","assert.Contains returns false and records an error when the collection or string does not contain the target","assert.Contains returns false and records an error when passed nil or an unsupported type"],"goal":"verify github.com/stretchr/testify/assert.Contains in pkg:golang/github.com/stretchr/testify@v1.8.1","kind":"HOW","packages":["pkg:golang/github.com/stretchr/testify@v1.8.1"],"schemaVersion":1,"symbols":["github.com/stretchr/testify/assert.Contains"]},"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.8.1"],"schemaVersion":1,"subject":"pkg:golang/github.com/stretchr/testify@v1.8.1","symbols":["github.com/stretchr/testify/assert.Contains"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

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 (
	"fmt"

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

// Reporter implements assert.TestingT to capture assertion results.
type Reporter struct {
	errors []string
	failed bool
}

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

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

	// Example 1: Verify that a string contains a specified substring
	logMessage := "service started successfully on port 8080"
	if assert.Contains(reporter, logMessage, "successfully") {
		fmt.Println("Log message contains expected keyword.")
	}

	// Example 2: Verify that a slice contains a specified element
	activeRoles := []string{"viewer", "editor", "admin"}
	if assert.Contains(reporter, activeRoles, "admin") {
		fmt.Println("Role list contains expected role.")
	}

	// Example 3: Verify that a map contains a specified key
	config := map[string]int{"maxRetries": 3, "timeoutSeconds": 30}
	if assert.Contains(reporter, config, "maxRetries") {
		fmt.Println("Config map contains expected configuration key.")
	}

	if !reporter.failed {
		fmt.Println("All assert.Contains demonstrations passed successfully.")
	}
}

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

package main

import (
	"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.Contains returns true and does not record an error when a string contains a substring
	{
		t := &contractTestingT{}
		str := "verified code sample demonstration"
		if !assert.Contains(t, str, "sample") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: Contains should find substring in string\n")
			os.Exit(1)
		}
	}

	// Assertion 2: assert.Contains returns true and does not record an error when a slice or array contains an element
	{
		tSlice := &contractTestingT{}
		slice := []string{"alpha", "beta", "gamma"}
		if !assert.Contains(tSlice, slice, "beta") || tSlice.failed || len(tSlice.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: Contains should find element in slice\n")
			os.Exit(1)
		}

		tArr := &contractTestingT{}
		arr := [3]int{10, 20, 30}
		if !assert.Contains(tArr, arr, 20) || tArr.failed || len(tArr.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: Contains should find element in array\n")
			os.Exit(1)
		}
	}

	// Assertion 3: assert.Contains returns true and does not record an error when a map contains the specified key
	{
		t := &contractTestingT{}
		m := map[string]int{"status": 200, "count": 5}
		if !assert.Contains(t, m, "status") || t.failed || len(t.errors) != 0 {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: Contains should find key in map\n")
			os.Exit(1)
		}
	}

	// Assertion 4: assert.Contains returns false and records an error when the collection or string does not contain the target
	{
		tStr := &contractTestingT{}
		if assert.Contains(tStr, "hello world", "missing") || !tStr.failed || len(tStr.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: Contains should fail when substring is absent\n")
			os.Exit(1)
		}

		tSlice := &contractTestingT{}
		if assert.Contains(tSlice, []int{1, 2, 3}, 99) || !tSlice.failed || len(tSlice.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: Contains should fail when element is absent from slice\n")
			os.Exit(1)
		}

		tMap := &contractTestingT{}
		if assert.Contains(tMap, map[string]int{"status": 200}, "missing") || !tMap.failed || len(tMap.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: Contains should fail when key is absent from map\n")
			os.Exit(1)
		}
	}

	// Assertion 5: assert.Contains returns false and records an error when passed nil or an unsupported type
	{
		tNil := &contractTestingT{}
		if assert.Contains(tNil, nil, "any") || !tNil.failed || len(tNil.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: Contains should fail when container is nil\n")
			os.Exit(1)
		}

		tInt := &contractTestingT{}
		if assert.Contains(tInt, 12345, 2) || !tInt.failed || len(tInt.errors) == 0 {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: Contains should fail when container cannot be measured with len\n")
			os.Exit(1)
		}
	}

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