github.com/google/go-cmp v0.5.7: cmpopts.IgnoreUnexported

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

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

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:22226ba742ff82c08a636a162fbd05a54409a088605a31d1776f34110082715f","contract":["cmpopts.IgnoreUnexported(StructType{}) returns a cmp.Option that ignores immediate unexported fields of the specified struct types during cmp.Equal and cmp.Diff comparisons","nested struct fields with unexported fields are ignored when each containing struct type is passed to cmpopts.IgnoreUnexported","exported fields on the compared structs continue to be compared normally"],"goal":"verify github.com/google/go-cmp/cmp/cmpopts.IgnoreUnexported in pkg:golang/github.com/google/go-cmp@v0.5.7","kind":"HOW","packages":["pkg:golang/github.com/google/go-cmp@v0.5.7"],"schemaVersion":1,"symbols":["github.com/google/go-cmp/cmp/cmpopts.IgnoreUnexported"]},"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.5.7"],"schemaVersion":1,"subject":"pkg:golang/github.com/google/go-cmp@v0.5.7","symbols":["github.com/google/go-cmp/cmp/cmpopts.IgnoreUnexported"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.18

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

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

github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
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"
)

type AuditMeta struct {
	Tag      string
	revision int
}

type Record struct {
	ID       int
	Name     string
	Meta     AuditMeta
	internal string
	counter  int
}

func NewRecord(id int, name, tag string, revision int, internal string, counter int) Record {
	return Record{
		ID:       id,
		Name:     name,
		Meta:     AuditMeta{Tag: tag, revision: revision},
		internal: internal,
		counter:  counter,
	}
}

func EqualIgnoringRecordUnexported(a, b Record) bool {
	opt := cmpopts.IgnoreUnexported(Record{}, AuditMeta{})
	return cmp.Equal(a, b, opt)
}

func DiffIgnoringRecordUnexported(a, b Record) string {
	opt := cmpopts.IgnoreUnexported(Record{}, AuditMeta{})
	return cmp.Diff(a, b, opt)
}

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

package main

import (
	"fmt"
	"os"

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

type simpleItem struct {
	Label  string
	secret string
}

func mustPanicWithoutOption(a, b simpleItem) (panicked bool) {
	defer func() {
		if r := recover(); r != nil {
			panicked = true
		}
	}()
	_ = cmp.Equal(a, b)
	return false
}

func main() {
	// 1. Verify that comparing structs with unexported fields panics without IgnoreUnexported,
	// and succeeds when cmpopts.IgnoreUnexported is passed for that struct type.
	s1 := simpleItem{Label: "alpha", secret: "one"}
	s2 := simpleItem{Label: "alpha", secret: "two"}
	if !mustPanicWithoutOption(s1, s2) {
		fmt.Fprintln(os.Stderr, "expected cmp.Equal without IgnoreUnexported to panic on unexported fields")
		os.Exit(1)
	}
	if !cmp.Equal(s1, s2, cmpopts.IgnoreUnexported(simpleItem{})) {
		fmt.Fprintln(os.Stderr, "expected cmp.Equal with IgnoreUnexported(simpleItem{}) to return true when exported fields match")
		os.Exit(1)
	}

	// 2. Verify nested structs: IgnoreUnexported ignores immediate unexported fields of each listed struct type.
	r1 := sample.NewRecord(10, "item-a", "v1", 1, "priv-1", 100)
	r2 := sample.NewRecord(10, "item-a", "v1", 999, "priv-2", 200)
	if !sample.EqualIgnoringRecordUnexported(r1, r2) {
		fmt.Fprintln(os.Stderr, "expected EqualIgnoringRecordUnexported to return true when only unexported fields differ")
		os.Exit(1)
	}
	if diff := sample.DiffIgnoringRecordUnexported(r1, r2); diff != "" {
		fmt.Fprintf(os.Stderr, "expected empty diff when only unexported fields differ, got: %s\n", diff)
		os.Exit(1)
	}

	// 3. Verify that differences in exported fields are still detected.
	r3 := sample.NewRecord(10, "item-b", "v1", 1, "priv-1", 100)
	if sample.EqualIgnoringRecordUnexported(r1, r3) {
		fmt.Fprintln(os.Stderr, "expected EqualIgnoringRecordUnexported to return false when exported field Name differs")
		os.Exit(1)
	}
	if diff := sample.DiffIgnoringRecordUnexported(r1, r3); diff == "" {
		fmt.Fprintln(os.Stderr, "expected non-empty diff when exported field Name differs")
		os.Exit(1)
	}
}