github.com/google/go-cmp v0.6.0: cmp.Comparer

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/google/go-cmp/cmp.Comparer in pkg:golang/github.com/google/go-cmp@v0.6.0
Kind: HOW

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

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:c8a2b0edfd56144b8abff9491b3344241db3891e01ef6ee1440879d1e9bfe33f","contract":["cmp.Comparer creates an Option defining custom equality predicate overriding default equality in cmp.Equal","cmp.Comparer custom equality applies transitively to struct fields","cmp.Comparer produces an empty diff in cmp.Diff when custom equality holds","cmp.Comparer produces a non-empty diff in cmp.Diff when custom equality does not hold","cmp.Comparer panics when argument is not a function","cmp.Comparer panics when function does not take exactly two arguments of identical type","cmp.Comparer panics when function return type is not a single boolean"],"goal":"verify github.com/google/go-cmp/cmp.Comparer in pkg:golang/github.com/google/go-cmp@v0.6.0","kind":"HOW","packages":["pkg:golang/github.com/google/go-cmp@v0.6.0"],"schemaVersion":1,"symbols":["github.com/google/go-cmp/cmp.Comparer"]},"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.6.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/google/go-cmp@v0.6.0","symbols":["github.com/google/go-cmp/cmp.Comparer"],"verifierAdapter":"golang@1"}

module sample

go 1.22

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

github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

{
  "schemaVersion": 1,
  "goal": "verify github.com/google/go-cmp/cmp.Comparer in pkg:golang/github.com/google/go-cmp@v0.6.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/google/go-cmp@v0.6.0"
  ],
  "symbols": [
    "github.com/google/go-cmp/cmp.Comparer"
  ]
}

package main

import (
	"fmt"
	"math"
	"os"

	"github.com/google/go-cmp/cmp"
)

type Metric struct {
	Name  string
	Value float64
}

func mustPanic(fn func()) (panicked bool) {
	defer func() {
		if r := recover(); r != nil {
			panicked = true
		}
	}()
	fn()
	return false
}

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 {
	approxEqual := cmp.Comparer(func(x, y float64) bool {
		return math.Abs(x-y) < 0.001
	})

	// 1. cmp.Comparer creates an Option defining custom equality predicate overriding default equality in cmp.Equal
	if cmp.Equal(1.0001, 1.0005) {
		return fmt.Errorf("expected default float comparison to be false for distinct values")
	}
	if !cmp.Equal(1.0001, 1.0005, approxEqual) {
		return fmt.Errorf("expected approxEqual comparer to evaluate 1.0001 and 1.0005 as equal")
	}
	if cmp.Equal(1.0, 2.0, approxEqual) {
		return fmt.Errorf("expected distinct values exceeding tolerance to be unequal")
	}

	// 2. cmp.Comparer custom equality applies transitively to struct fields
	m1 := Metric{Name: "cpu_usage", Value: 75.0001}
	m2 := Metric{Name: "cpu_usage", Value: 75.0004}
	m3 := Metric{Name: "cpu_usage", Value: 80.0}
	if cmp.Equal(m1, m2) {
		return fmt.Errorf("expected struct values to differ by default")
	}
	if !cmp.Equal(m1, m2, approxEqual) {
		return fmt.Errorf("expected struct values to match when field custom comparer is supplied")
	}
	if cmp.Equal(m1, m3, approxEqual) {
		return fmt.Errorf("expected struct values exceeding tolerance to differ")
	}

	// 3. cmp.Comparer produces an empty diff in cmp.Diff when custom equality holds
	diffEqual := cmp.Diff(1.0001, 1.0005, approxEqual)
	if diffEqual != "" {
		return fmt.Errorf("expected empty diff when custom equality holds, got: %s", diffEqual)
	}

	// 4. cmp.Comparer produces a non-empty diff in cmp.Diff when custom equality does not hold
	diffUnequal := cmp.Diff(1.0, 2.0, approxEqual)
	if diffUnequal == "" {
		return fmt.Errorf("expected non-empty diff when values differ under custom comparer")
	}

	// 5. cmp.Comparer panics when argument is not a function
	if !mustPanic(func() { cmp.Comparer("invalid") }) {
		return fmt.Errorf("expected panic when string is passed to cmp.Comparer")
	}
	if !mustPanic(func() { cmp.Comparer(123) }) {
		return fmt.Errorf("expected panic when int is passed to cmp.Comparer")
	}

	// 6. cmp.Comparer panics when function does not take exactly two arguments of identical type
	if !mustPanic(func() { cmp.Comparer(func(x float64) bool { return true }) }) {
		return fmt.Errorf("expected panic when function takes 1 argument")
	}
	if !mustPanic(func() { cmp.Comparer(func(x, y, z float64) bool { return true }) }) {
		return fmt.Errorf("expected panic when function takes 3 arguments")
	}
	if !mustPanic(func() { cmp.Comparer(func(x int, y string) bool { return true }) }) {
		return fmt.Errorf("expected panic when function argument types differ")
	}

	// 7. cmp.Comparer panics when function return type is not a single boolean
	if !mustPanic(func() { cmp.Comparer(func(x, y int) int { return 0 }) }) {
		return fmt.Errorf("expected panic when function return type is int")
	}
	if !mustPanic(func() { cmp.Comparer(func(x, y int) (bool, error) { return true, nil }) }) {
		return fmt.Errorf("expected panic when function returns multiple values")
	}
	if !mustPanic(func() { cmp.Comparer(func(x, y int) {}) }) {
		return fmt.Errorf("expected panic when function returns no values")
	}

	return nil
}