github.com/google/go-cmp v0.5.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.5.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/google/go-cmp@v0.5.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:8d64e28f1eb2cf44de13c5ae0bd852c26e102ef7a7b3eaa99d6154ad5af29597","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.5.0","kind":"HOW","packages":["pkg:golang/github.com/google/go-cmp@v0.5.0"],"schemaVersion":1,"symbols":["github.com/google/go-cmp/cmp.Comparer"]},"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.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/google/go-cmp@v0.5.0","symbols":["github.com/google/go-cmp/cmp.Comparer"],"verifierAdapter":"golang@1"}

module sample

go 1.22

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

github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w=
github.com/google/go-cmp v0.5.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=

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

package main

import (
	"fmt"
	"math"
	"os"

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

type Reading struct {
	Label string
	Score float64
}

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

func main() {
	if err := verifyComparer(); err != nil {
		fmt.Fprintf(os.Stderr, "contract check failed: %v\n", err)
		os.Exit(1)
	}
}

func verifyComparer() error {
	withinTolerance := cmp.Comparer(func(a, b float64) bool {
		return math.Abs(a-b) < 0.01
	})

	// 1. cmp.Comparer creates an Option defining a custom equality predicate for cmp.Equal
	if cmp.Equal(10.001, 10.005) {
		return fmt.Errorf("expected default float64 comparison to report inequality")
	}
	if !cmp.Equal(10.001, 10.005, withinTolerance) {
		return fmt.Errorf("expected custom comparer to treat 10.001 and 10.005 as equal")
	}
	if cmp.Equal(10.0, 11.0, withinTolerance) {
		return fmt.Errorf("expected custom comparer to treat 10.0 and 11.0 as unequal")
	}

	// 2. cmp.Comparer custom equality applies transitively to nested struct fields
	r1 := Reading{Label: "latency", Score: 42.001}
	r2 := Reading{Label: "latency", Score: 42.006}
	r3 := Reading{Label: "latency", Score: 45.0}
	if cmp.Equal(r1, r2) {
		return fmt.Errorf("expected default struct comparison to report inequality")
	}
	if !cmp.Equal(r1, r2, withinTolerance) {
		return fmt.Errorf("expected struct comparison with custom comparer to report equality")
	}
	if cmp.Equal(r1, r3, withinTolerance) {
		return fmt.Errorf("expected struct comparison outside tolerance to report inequality")
	}

	// 3. cmp.Comparer produces an empty diff in cmp.Diff when custom equality holds
	if diff := cmp.Diff(10.001, 10.005, withinTolerance); diff != "" {
		return fmt.Errorf("expected empty diff when custom equality holds, got %q", diff)
	}

	// 4. cmp.Comparer produces a non-empty diff in cmp.Diff when custom equality does not hold
	if diff := cmp.Diff(10.0, 11.0, withinTolerance); diff == "" {
		return fmt.Errorf("expected non-empty diff when custom equality does not hold")
	}

	// 5. cmp.Comparer panics when argument is not a function
	if !didPanic(func() { cmp.Comparer("not-a-func") }) {
		return fmt.Errorf("expected panic when passing non-function to cmp.Comparer")
	}

	// 6. cmp.Comparer panics when function does not take exactly two arguments of identical type
	if !didPanic(func() { cmp.Comparer(func(a float64) bool { return true }) }) {
		return fmt.Errorf("expected panic for 1-arg function")
	}
	if !didPanic(func() { cmp.Comparer(func(a, b, c float64) bool { return true }) }) {
		return fmt.Errorf("expected panic for 3-arg function")
	}
	if !didPanic(func() { cmp.Comparer(func(a int, b string) bool { return true }) }) {
		return fmt.Errorf("expected panic for mismatched parameter types")
	}

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

	return nil
}