github.com/google/go-cmp v0.5.4: Equate nil and empty slices or maps using cmpopts.EquateEmpty

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: Equate nil and empty slices or maps using cmpopts.EquateEmpty
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/google/go-cmp@v0.5.4
Demonstrate these symbols/APIs:
  - cmpopts.EquateEmpty

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:9e2135ad56065cb54470f292a3e12e26a3ca139f0f379d66f2bd06c8f0ea6ba9","contract":["cmp.Equal reports false when comparing nil and empty slices without cmpopts.EquateEmpty","cmpopts.EquateEmpty enables cmp.Equal to report true for nil slice versus empty slice","cmpopts.EquateEmpty enables cmp.Equal to report true for nil map versus empty map","cmp.Diff with cmpopts.EquateEmpty produces empty diff for structs with nil versus empty fields","cmpopts.EquateEmpty detects differences when slices or maps contain non-empty differing elements"],"goal":"Equate nil and empty slices or maps using cmpopts.EquateEmpty","kind":"HOW","packages":["pkg:golang/github.com/google/go-cmp@v0.5.4"],"schemaVersion":1,"symbols":["cmpopts.EquateEmpty"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/google/go-cmp@v0.5.4"],"schemaVersion":1,"subject":"pkg:golang/github.com/google/go-cmp@v0.5.4","symbols":["cmpopts.EquateEmpty"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.20

require github.com/google/go-cmp v0.5.4

require golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 // indirect

github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

package sample

import (
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
)

// Collection holds slice and map data for comparison demonstrations.
type Collection struct {
	Tags     []string
	Metadata map[string]string
}

// CompareCollections compares two Collection instances using cmpopts.EquateEmpty.
func CompareCollections(a, b Collection) bool {
	return cmp.Equal(a, b, cmpopts.EquateEmpty())
}

// DiffCollections returns human-readable differences using cmpopts.EquateEmpty.
func DiffCollections(a, b Collection) string {
	return cmp.Diff(a, b, cmpopts.EquateEmpty())
}

// CompareSlices compares two string slices using cmpopts.EquateEmpty.
func CompareSlices(a, b []string) bool {
	return cmp.Equal(a, b, cmpopts.EquateEmpty())
}

// CompareMaps compares two string maps using cmpopts.EquateEmpty.
func CompareMaps(a, b map[string]string) bool {
	return cmp.Equal(a, b, cmpopts.EquateEmpty())
}

{
  "schemaVersion": 1,
  "goal": "Equate nil and empty slices or maps using cmpopts.EquateEmpty",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/google/go-cmp@v0.5.4"
  ],
  "symbols": [
    "cmpopts.EquateEmpty"
  ]
}

package main

import (
	"fmt"
	"os"
	"strings"

	"example.com/sample"
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
)

func main() {
	if err := runContractTests(); err != nil {
		fmt.Fprintf(os.Stderr, "Contract test failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("All contract tests passed successfully.")
}

func runContractTests() error {
	var nilSlice []string
	emptySlice := []string{}

	// 1. cmp.Equal reports false when comparing nil and empty slices without cmpopts.EquateEmpty
	if cmp.Equal(nilSlice, emptySlice) {
		return fmt.Errorf("expected cmp.Equal(nilSlice, emptySlice) to be false without EquateEmpty")
	}

	// 2. cmpopts.EquateEmpty enables cmp.Equal to report true for nil slice versus empty slice
	if !cmp.Equal(nilSlice, emptySlice, cmpopts.EquateEmpty()) {
		return fmt.Errorf("expected cmp.Equal(nilSlice, emptySlice, EquateEmpty) to be true")
	}

	// 3. cmpopts.EquateEmpty enables cmp.Equal to report true for nil map versus empty map
	var nilMap map[string]string
	emptyMap := map[string]string{}
	if !cmp.Equal(nilMap, emptyMap, cmpopts.EquateEmpty()) {
		return fmt.Errorf("expected cmp.Equal(nilMap, emptyMap, EquateEmpty) to be true")
	}

	// 4. cmp.Diff with cmpopts.EquateEmpty produces empty diff for structs with nil versus empty fields
	c1 := sample.Collection{Tags: nil, Metadata: nil}
	c2 := sample.Collection{Tags: []string{}, Metadata: map[string]string{}}
	if diff := cmp.Diff(c1, c2, cmpopts.EquateEmpty()); diff != "" {
		return fmt.Errorf("expected empty diff for nil vs empty struct fields, got: %s", diff)
	}

	// 5. cmpopts.EquateEmpty detects differences when slices or maps contain non-empty differing elements
	c3 := sample.Collection{Tags: []string{"alpha"}, Metadata: map[string]string{"env": "prod"}}
	if cmp.Equal(c1, c3, cmpopts.EquateEmpty()) {
		return fmt.Errorf("expected c1 and c3 to be unequal when fields differ")
	}
	diffNonEmpty := cmp.Diff(c1, c3, cmpopts.EquateEmpty())
	if diffNonEmpty == "" {
		return fmt.Errorf("expected non-empty diff for differing fields")
	}
	if !strings.Contains(diffNonEmpty, "alpha") {
		return fmt.Errorf("expected diff to contain 'alpha', got: %s", diffNonEmpty)
	}

	return nil
}