github.com/google/go-cmp v0.3.0: cmp.AllowUnexported

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

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

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:b2e59f19794175e3249af884b35245f4eb7dfe9e61f099463ff0e1f0dc4f842d","contract":["cmp.Equal panics when comparing structs with unexported fields without cmp.AllowUnexported","cmp.AllowUnexported enables comparing structs with unexported fields for equality","cmp.Diff with cmp.AllowUnexported reports differences in unexported fields","cmp.AllowUnexported allows comparing nested structs with unexported fields when both types are specified","cmp.AllowUnexported panics when passed a non-struct type or pointer to struct"],"goal":"verify github.com/google/go-cmp/cmp.AllowUnexported in pkg:golang/github.com/google/go-cmp@v0.3.0","kind":"HOW","packages":["pkg:golang/github.com/google/go-cmp@v0.3.0"],"schemaVersion":1,"symbols":["github.com/google/go-cmp/cmp.AllowUnexported"]},"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.3.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/google/go-cmp@v0.3.0","symbols":["github.com/google/go-cmp/cmp.AllowUnexported"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.22

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

github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=

package sample

import (
	"fmt"

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

// Record holds an exported label and an unexported revision counter.
type Record struct {
	Label    string
	revision int
}

// NewRecord constructs a Record with an unexported revision field.
func NewRecord(label string, revision int) Record {
	return Record{
		Label:    label,
		revision: revision,
	}
}

// Archive wraps an exported ID and an unexported Record.
type Archive struct {
	ID      int
	current Record
}

// NewArchive constructs an Archive containing an unexported Record.
func NewArchive(id int, current Record) Archive {
	return Archive{
		ID:      id,
		current: current,
	}
}

// EqualRecords compares two Record values using cmp.AllowUnexported.
func EqualRecords(a, b Record) bool {
	return cmp.Equal(a, b, cmp.AllowUnexported(Record{}))
}

// DiffRecords returns the diff between two Record values using cmp.AllowUnexported.
func DiffRecords(a, b Record) string {
	return cmp.Diff(a, b, cmp.AllowUnexported(Record{}))
}

// EqualArchives compares two Archive values allowing unexported fields on both Archive and Record.
func EqualArchives(a, b Archive) bool {
	return cmp.Equal(a, b, cmp.AllowUnexported(Archive{}, Record{}))
}

// TryEqualWithoutAllow compares two Record values without AllowUnexported and returns any panic text.
func TryEqualWithoutAllow(a, b Record) (panicMsg string) {
	defer func() {
		if r := recover(); r != nil {
			panicMsg = fmt.Sprint(r)
		}
	}()
	cmp.Equal(a, b)
	return ""
}

// TryAllowUnexported calls cmp.AllowUnexported and captures any panic text.
func TryAllowUnexported(types ...interface{}) (opt cmp.Option, panicMsg string) {
	defer func() {
		if r := recover(); r != nil {
			panicMsg = fmt.Sprint(r)
		}
	}()
	opt = cmp.AllowUnexported(types...)
	return opt, ""
}

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

package main

import (
	"fmt"
	"os"
	"strings"

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

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

func runContract() error {
	r1 := sample.NewRecord("item-a", 10)
	r2 := sample.NewRecord("item-a", 10)
	r3 := sample.NewRecord("item-a", 20)

	// 1. cmp.Equal panics when comparing structs with unexported fields without cmp.AllowUnexported
	panicNoAllow := sample.TryEqualWithoutAllow(r1, r2)
	if panicNoAllow == "" {
		return fmt.Errorf("expected panic when comparing structs with unexported fields without AllowUnexported")
	}
	if !strings.Contains(panicNoAllow, "cannot handle unexported field") {
		return fmt.Errorf("unexpected panic message without AllowUnexported: %s", panicNoAllow)
	}

	// 2. cmp.AllowUnexported enables comparing structs with unexported fields for equality
	opt := cmp.AllowUnexported(sample.Record{})
	if !cmp.Equal(r1, r2, opt) || !sample.EqualRecords(r1, r2) {
		return fmt.Errorf("expected identical records to be equal with AllowUnexported")
	}
	if cmp.Equal(r1, r3, opt) || sample.EqualRecords(r1, r3) {
		return fmt.Errorf("expected records with differing unexported fields to be unequal")
	}

	// 3. cmp.Diff with cmp.AllowUnexported reports differences in unexported fields
	if diff := sample.DiffRecords(r1, r2); diff != "" {
		return fmt.Errorf("expected empty diff for equal records, got: %s", diff)
	}
	diffMismatch := sample.DiffRecords(r1, r3)
	if diffMismatch == "" || !strings.Contains(diffMismatch, "revision") {
		return fmt.Errorf("expected diff to mention unexported field 'revision', got: %s", diffMismatch)
	}

	// 4. cmp.AllowUnexported allows comparing nested structs with unexported fields when both types are specified
	a1 := sample.NewArchive(1, r1)
	a2 := sample.NewArchive(1, r2)
	a3 := sample.NewArchive(1, r3)
	if !sample.EqualArchives(a1, a2) {
		return fmt.Errorf("expected identical archives to be equal when both types are passed to AllowUnexported")
	}
	if sample.EqualArchives(a1, a3) {
		return fmt.Errorf("expected archives with differing nested unexported field to be unequal")
	}

	// 5. cmp.AllowUnexported panics when passed a non-struct type or pointer to struct
	if _, panicPtr := sample.TryAllowUnexported(&sample.Record{}); !strings.Contains(panicPtr, "invalid struct type") {
		return fmt.Errorf("expected 'invalid struct type' panic for struct pointer, got: %s", panicPtr)
	}
	if _, panicNonStruct := sample.TryAllowUnexported(123); !strings.Contains(panicNonStruct, "invalid struct type") {
		return fmt.Errorf("expected 'invalid struct type' panic for non-struct, got: %s", panicNonStruct)
	}

	return nil
}