github.com/google/go-cmp v0.7.0: cmpopts.SortSlices

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

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

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:594ed3164054f449c1350cc35dc60c03586d71646e2a63c3ec67be8e82283d36","contract":["cmpopts.SortSlices sorts slices of comparable elements using a less function before comparison with cmp.Diff and cmp.Equal","cmpopts.SortSlices sorts slices using a three-way compare function before comparison","cmpopts.SortSlices treats struct slices with elements in different orders as equal when sorted order matches","cmpopts.SortSlices detects differences when elements or counts in slices do not match","cmpopts.SortSlices panics when given an invalid less or compare function signature"],"goal":"verify github.com/google/go-cmp/cmp/cmpopts.SortSlices in pkg:golang/github.com/google/go-cmp@v0.7.0","kind":"HOW","packages":["pkg:golang/github.com/google/go-cmp@v0.7.0"],"schemaVersion":1,"symbols":["github.com/google/go-cmp/cmp/cmpopts.SortSlices"]},"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.7.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/google/go-cmp@v0.7.0","symbols":["github.com/google/go-cmp/cmp/cmpopts.SortSlices"],"verifierAdapter":"golang@1"}

module sample

go 1.23

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

github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=

package sample

import (
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
)

// EqualSlicesWithLess compares two slices for equality after sorting elements using a less function.
func EqualSlicesWithLess[T any](x, y []T, less func(T, T) bool) bool {
	return cmp.Equal(x, y, cmpopts.SortSlices(less))
}

// DiffSlicesWithLess returns a human-readable difference of two slices after sorting elements using a less function.
func DiffSlicesWithLess[T any](x, y []T, less func(T, T) bool) string {
	return cmp.Diff(x, y, cmpopts.SortSlices(less))
}

// EqualSlicesWithCompare compares two slices for equality after sorting elements using a three-way compare function.
func EqualSlicesWithCompare[T any](x, y []T, compare func(T, T) int) bool {
	return cmp.Equal(x, y, cmpopts.SortSlices(compare))
}

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

package main

import (
	"fmt"
	"os"

	"sample"

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

// Item represents a test struct with exported fields for comparison.
type Item struct {
	ID   int
	Name string
}

func main() {
	// 1. cmpopts.SortSlices sorts slices of comparable elements using a less function before comparison with cmp.Diff and cmp.Equal
	s1 := []int{5, 2, 8, 1, 9}
	s2 := []int{1, 2, 5, 8, 9}
	intLess := func(a, b int) bool { return a < b }

	if cmp.Equal(s1, s2) {
		fmt.Fprintf(os.Stderr, "contract failed: unsorted slices should not be equal without SortSlices\n")
		os.Exit(1)
	}

	optLess := cmpopts.SortSlices(intLess)
	if !cmp.Equal(s1, s2, optLess) {
		fmt.Fprintf(os.Stderr, "contract failed: slices with same elements should be equal with SortSlices\n")
		os.Exit(1)
	}
	if diff := cmp.Diff(s1, s2, optLess); diff != "" {
		fmt.Fprintf(os.Stderr, "contract failed: expected empty diff, got %s\n", diff)
		os.Exit(1)
	}

	// 2. cmpopts.SortSlices sorts slices using a three-way compare function before comparison
	str1 := []string{"cherry", "apple", "banana"}
	str2 := []string{"banana", "apple", "cherry"}
	strCompare := func(a, b string) int {
		if a < b {
			return -1
		} else if a > b {
			return 1
		}
		return 0
	}

	optCompare := cmpopts.SortSlices(strCompare)
	if !cmp.Equal(str1, str2, optCompare) {
		fmt.Fprintf(os.Stderr, "contract failed: slices with same strings should be equal with SortSlices compare func\n")
		os.Exit(1)
	}

	// 3. cmpopts.SortSlices treats struct slices with elements in different orders as equal when sorted order matches
	items1 := []Item{{ID: 3, Name: "c"}, {ID: 1, Name: "a"}, {ID: 2, Name: "b"}}
	items2 := []Item{{ID: 1, Name: "a"}, {ID: 2, Name: "b"}, {ID: 3, Name: "c"}}
	itemLess := func(a, b Item) bool { return a.ID < b.ID }

	if !cmp.Equal(items1, items2, cmpopts.SortSlices(itemLess)) {
		fmt.Fprintf(os.Stderr, "contract failed: struct slices should be equal with SortSlices\n")
		os.Exit(1)
	}

	// 4. cmpopts.SortSlices detects differences when elements or counts in slices do not match
	diffItems := []Item{{ID: 1, Name: "a"}, {ID: 2, Name: "b"}, {ID: 4, Name: "d"}}
	if cmp.Equal(items1, diffItems, cmpopts.SortSlices(itemLess)) {
		fmt.Fprintf(os.Stderr, "contract failed: slices with different elements should not be equal\n")
		os.Exit(1)
	}
	if diff := cmp.Diff(items1, diffItems, cmpopts.SortSlices(itemLess)); diff == "" {
		fmt.Fprintf(os.Stderr, "contract failed: expected non-empty diff for differing slices\n")
		os.Exit(1)
	}

	// 5. cmpopts.SortSlices panics when given an invalid less or compare function signature
	func() {
		defer func() {
			r := recover()
			if r == nil {
				fmt.Fprintf(os.Stderr, "contract failed: expected panic for invalid function signature\n")
				os.Exit(1)
			}
		}()
		cmpopts.SortSlices("not-a-function")
	}()

	// 6. Verify helper functions in package sample work
	if !sample.EqualSlicesWithLess(s1, s2, intLess) {
		fmt.Fprintf(os.Stderr, "contract failed: sample.EqualSlicesWithLess failed\n")
		os.Exit(1)
	}
	if diff := sample.DiffSlicesWithLess(s1, s2, intLess); diff != "" {
		fmt.Fprintf(os.Stderr, "contract failed: sample.DiffSlicesWithLess returned non-empty diff: %s\n", diff)
		os.Exit(1)
	}
	if !sample.EqualSlicesWithCompare(str1, str2, strCompare) {
		fmt.Fprintf(os.Stderr, "contract failed: sample.EqualSlicesWithCompare failed\n")
		os.Exit(1)
	}

	fmt.Println("PASS")
}