github.com/google/go-cmp v0.4.0: 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: verify cmpopts.EquateEmpty in pkg:golang/github.com/google/go-cmp@v0.4.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/google/go-cmp@v0.4.0
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:3c1f4bc3a706ba3ed03e270d45109c0f71b991b30907f8f4a85074b540c025c4","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":"verify cmpopts.EquateEmpty in pkg:golang/github.com/google/go-cmp@v0.4.0","kind":"HOW","packages":["pkg:golang/github.com/google/go-cmp@v0.4.0"],"schemaVersion":1,"symbols":["cmpopts.EquateEmpty"]},"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/google/go-cmp@v0.4.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/google/go-cmp@v0.4.0","symbols":["cmpopts.EquateEmpty"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.20

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

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

github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
github.com/google/go-cmp v0.4.0/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"
)

// DataContainer holds slice and map fields for comparison.
type DataContainer struct {
	Items  []string
	Labels map[string]string
}

// CompareDataContainers compares two DataContainer values using cmpopts.EquateEmpty.
func CompareDataContainers(x, y DataContainer) bool {
	return cmp.Equal(x, y, cmpopts.EquateEmpty())
}

// DiffDataContainers computes human-readable diff using cmpopts.EquateEmpty.
func DiffDataContainers(x, y DataContainer) string {
	return cmp.Diff(x, y, cmpopts.EquateEmpty())
}

// CompareStringSlices compares two string slices treating nil and empty as equal.
func CompareStringSlices(x, y []string) bool {
	return cmp.Equal(x, y, cmpopts.EquateEmpty())
}

// CompareStringMaps compares two string maps treating nil and empty as equal.
func CompareStringMaps(x, y map[string]string) bool {
	return cmp.Equal(x, y, cmpopts.EquateEmpty())
}

{
  "schemaVersion": 1,
  "goal": "verify cmpopts.EquateEmpty in pkg:golang/github.com/google/go-cmp@v0.4.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/google/go-cmp@v0.4.0"
  ],
  "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")
	}
	if !sample.CompareStringSlices(nilSlice, emptySlice) {
		return fmt.Errorf("expected sample.CompareStringSlices(nilSlice, emptySlice) 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")
	}
	if !sample.CompareStringMaps(nilMap, emptyMap) {
		return fmt.Errorf("expected sample.CompareStringMaps(nilMap, emptyMap) to be true")
	}

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

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

	return nil
}