go.uber.org/multierr v1.11.0: Errors

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 go.uber.org/multierr.Errors in pkg:golang/go.uber.org/multierr@v1.11.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.uber.org/multierr@v1.11.0
Demonstrate these symbols/APIs:
  - go.uber.org/multierr.Errors

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:91cd179d33f8e22214ac1bad6cdbe7169c8955904c849bb090c476d28d5b0108","contract":["multierr.Errors returns nil slice with length zero when given nil error","multierr.Errors returns single element slice containing the error when given non-multierr error","multierr.Errors extracts all underlying errors in original order from combined multierr","multierr.Errors flattens nested multierr hierarchies into a single linear slice","multierr.Errors returns a decoupled slice whose modification does not affect subsequent calls","multierr.Errors unwraps standard joined errors implementing multipleErrors interface"],"goal":"verify go.uber.org/multierr.Errors in pkg:golang/go.uber.org/multierr@v1.11.0","kind":"HOW","packages":["pkg:golang/go.uber.org/multierr@v1.11.0"],"schemaVersion":1,"symbols":["go.uber.org/multierr.Errors"]},"contractCommand":["go","test","./..."],"environment":{"arch":"amd64","distro":"ubuntu","ecosystem":"golang","language":"go","languageVersion":"1.26.6","libc":"glibc","libcVersion":"2.39","moduleSystem":"go.mod","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/go.uber.org/multierr@v1.11.0"],"schemaVersion":1,"subject":"pkg:golang/go.uber.org/multierr@v1.11.0","symbols":["go.uber.org/multierr.Errors"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require go.uber.org/multierr v1.11.0

github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package sample

import (
	"go.uber.org/multierr"
)

// InspectErrors extracts the underlying slice of errors using multierr.Errors.
func InspectErrors(err error) []error {
	return multierr.Errors(err)
}

// ErrorCount returns the number of underlying errors using multierr.Errors.
func ErrorCount(err error) int {
	return len(multierr.Errors(err))
}

// FilterErrors extracts underlying errors via multierr.Errors and filters them with a predicate.
func FilterErrors(err error, predicate func(error) bool) []error {
	all := multierr.Errors(err)
	if len(all) == 0 {
		return nil
	}
	var matched []error
	for _, e := range all {
		if predicate != nil && predicate(e) {
			matched = append(matched, e)
		}
	}
	return matched
}

{
  "schemaVersion": 1,
  "goal": "verify go.uber.org/multierr.Errors in pkg:golang/go.uber.org/multierr@v1.11.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/go.uber.org/multierr@v1.11.0"
  ],
  "symbols": [
    "go.uber.org/multierr.Errors"
  ]
}

package test

import (
	"errors"
	"testing"

	"sample"

	"go.uber.org/multierr"
)

func TestMultierrErrorsNilAndSingleContract(t *testing.T) {
	// 1. multierr.Errors returns nil slice with length zero when given nil error
	nilResult := multierr.Errors(nil)
	if nilResult != nil {
		t.Fatalf("expected nil result for nil error, got %v", nilResult)
	}
	if len(nilResult) != 0 {
		t.Fatalf("expected len 0 for nil error, got %d", len(nilResult))
	}
	if cnt := sample.ErrorCount(nil); cnt != 0 {
		t.Fatalf("expected sample.ErrorCount(nil) == 0, got %d", cnt)
	}
	if inspected := sample.InspectErrors(nil); len(inspected) != 0 {
		t.Fatalf("expected len 0 for sample.InspectErrors(nil), got %d", len(inspected))
	}

	// 2. multierr.Errors returns single element slice containing the error when given non-multierr error
	errSingle := errors.New("single error")
	singleResult := multierr.Errors(errSingle)
	if len(singleResult) != 1 {
		t.Fatalf("expected slice of len 1, got %d", len(singleResult))
	}
	if singleResult[0] != errSingle {
		t.Fatalf("expected element %v, got %v", errSingle, singleResult[0])
	}
	if cnt := sample.ErrorCount(errSingle); cnt != 1 {
		t.Fatalf("expected ErrorCount 1, got %d", cnt)
	}
}

func TestMultierrErrorsCombinedAndFlattenContract(t *testing.T) {
	err1 := errors.New("first error")
	err2 := errors.New("second error")
	err3 := errors.New("third error")

	// 3. multierr.Errors extracts all underlying errors in original order from combined multierr
	combined := multierr.Combine(err1, err2, err3)
	errs := multierr.Errors(combined)
	if len(errs) != 3 {
		t.Fatalf("expected 3 errors, got %d", len(errs))
	}
	if errs[0] != err1 || errs[1] != err2 || errs[2] != err3 {
		t.Fatalf("order mismatch: got %v", errs)
	}

	// 4. multierr.Errors flattens nested multierr hierarchies into a single linear slice
	nestedLeft := multierr.Combine(err1, multierr.Combine(err2, err3))
	nestedErrs := multierr.Errors(nestedLeft)
	if len(nestedErrs) != 3 {
		t.Fatalf("expected 3 flattened errors, got %d", len(nestedErrs))
	}
	if nestedErrs[0] != err1 || nestedErrs[1] != err2 || nestedErrs[2] != err3 {
		t.Fatalf("nested flattening mismatch: got %v", nestedErrs)
	}

	appended := multierr.Append(multierr.Append(err1, err2), err3)
	appendedErrs := multierr.Errors(appended)
	if len(appendedErrs) != 3 {
		t.Fatalf("expected 3 appended errors, got %d", len(appendedErrs))
	}
	if appendedErrs[0] != err1 || appendedErrs[1] != err2 || appendedErrs[2] != err3 {
		t.Fatalf("appended flattening mismatch: got %v", appendedErrs)
	}
}

func TestMultierrErrorsSliceDecouplingContract(t *testing.T) {
	err1 := errors.New("error alpha")
	err2 := errors.New("error beta")
	combined := multierr.Combine(err1, err2)

	// 5. multierr.Errors returns a decoupled slice whose modification does not affect subsequent calls
	firstSlice := multierr.Errors(combined)
	if len(firstSlice) != 2 {
		t.Fatalf("expected len 2, got %d", len(firstSlice))
	}

	// Mutate the returned slice
	firstSlice[0] = errors.New("mutated error")
	firstSlice = append(firstSlice, errors.New("appended error"))

	// Subsequent call to Errors must still return original errors
	secondSlice := multierr.Errors(combined)
	if len(secondSlice) != 2 {
		t.Fatalf("expected len 2 on second call, got %d", len(secondSlice))
	}
	if secondSlice[0] != err1 || secondSlice[1] != err2 {
		t.Fatalf("underlying multierr was mutated: got %v", secondSlice)
	}
}

func TestMultierrErrorsStandardJoinedCompatibilityContract(t *testing.T) {
	// 6. multierr.Errors unwraps standard joined errors implementing multipleErrors interface
	errA := errors.New("err A")
	errB := errors.New("err B")
	joined := errors.Join(errA, errB)

	errs := multierr.Errors(joined)
	if len(errs) != 2 {
		t.Fatalf("expected 2 errors from errors.Join, got %d", len(errs))
	}
	if errs[0] != errA || errs[1] != errB {
		t.Fatalf("standard joined errors mismatch: got %v", errs)
	}

	// Test sample.FilterErrors
	filtered := sample.FilterErrors(joined, func(e error) bool {
		return e == errB
	})
	if len(filtered) != 1 || filtered[0] != errB {
		t.Fatalf("filter mismatch: got %v", filtered)
	}
}