go.uber.org/multierr v1.11.0: Combine, Append, AppendInto

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 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
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

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.

package sample

import (
	"errors"
	"testing"

	"go.uber.org/multierr"
)

type mockCloser struct {
	err error
}

func (m *mockCloser) Close() error {
	return m.err
}

func TestCombineErrors(t *testing.T) {
	// Combining nil errors produces nil
	if err := multierr.Combine(nil, nil); err != nil {
		t.Fatalf("expected nil when combining nil errors, got %v", err)
	}

	// Combining a single error returns that error
	singleErr := errors.New("single failure")
	if err := multierr.Combine(singleErr, nil); !errors.Is(err, singleErr) {
		t.Fatalf("expected single error preserved, got %v", err)
	}

	// Combining multiple errors merges them
	err1 := errors.New("first error")
	err2 := errors.New("second error")
	combined := multierr.Combine(err1, err2)
	if combined == nil {
		t.Fatal("expected combined error to be non-nil")
	}

	errList := multierr.Errors(combined)
	if len(errList) != 2 {
		t.Fatalf("expected 2 errors, got %d", len(errList))
	}
	if !errors.Is(errList[0], err1) || !errors.Is(errList[1], err2) {
		t.Fatalf("unexpected errors in combined list: %v", errList)
	}

	// Test ProcessBatch helper
	batchErr := ProcessBatch([]func() error{
		func() error { return nil },
		func() error { return errors.New("op1 failed") },
		func() error { return errors.New("op2 failed") },
	})
	if batchErr == nil {
		t.Fatal("expected batch error to be non-nil")
	}
	if len(multierr.Errors(batchErr)) != 2 {
		t.Fatalf("expected 2 errors from batch, got %d", len(multierr.Errors(batchErr)))
	}
}

func TestAppendErrors(t *testing.T) {
	var baseErr error

	// Appending nil to nil remains nil
	baseErr = multierr.Append(baseErr, nil)
	if baseErr != nil {
		t.Fatalf("expected nil error after appending nil, got %v", baseErr)
	}

	// Appending error to nil sets the error
	err1 := errors.New("step 1 failed")
	baseErr = multierr.Append(baseErr, err1)
	if !errors.Is(baseErr, err1) {
		t.Fatalf("expected baseErr to be err1, got %v", baseErr)
	}

	// Appending second error creates multierr
	err2 := errors.New("step 2 failed")
	baseErr = multierr.Append(baseErr, err2)
	if len(multierr.Errors(baseErr)) != 2 {
		t.Fatalf("expected 2 errors after append, got %d", len(multierr.Errors(baseErr)))
	}

	// Test Pipeline helper
	pipelineErr := Pipeline([]func() error{
		func() error { return errors.New("step A") },
		func() error { return nil },
		func() error { return errors.New("step B") },
	})
	if len(multierr.Errors(pipelineErr)) != 2 {
		t.Fatalf("expected 2 errors from pipeline, got %d", len(multierr.Errors(pipelineErr)))
	}
}

func TestAppendInto(t *testing.T) {
	var accumulated error

	// Appending nil returns false and does not change error
	appended := multierr.AppendInto(&accumulated, nil)
	if appended || accumulated != nil {
		t.Fatalf("expected false and nil error on nil append, got appended=%v, err=%v", appended, accumulated)
	}

	// Appending non-nil returns true and modifies pointer
	err1 := errors.New("validation failed")
	appended = multierr.AppendInto(&accumulated, err1)
	if !appended || !errors.Is(accumulated, err1) {
		t.Fatalf("expected true and err1, got appended=%v, err=%v", appended, accumulated)
	}

	// Appending another error modifies pointer to combined error
	err2 := errors.New("write failed")
	appended = multierr.AppendInto(&accumulated, err2)
	if !appended || len(multierr.Errors(accumulated)) != 2 {
		t.Fatalf("expected true and 2 errors, got appended=%v, count=%d", appended, len(multierr.Errors(accumulated)))
	}

	// Test CollectErrors helper
	var targetErr error
	hasErr := CollectErrors(&targetErr,
		func() error { return nil },
		func() error { return errors.New("action error") },
	)
	if !hasErr || targetErr == nil {
		t.Fatalf("expected hasErr=true and non-nil targetErr")
	}
}

func TestAppendFuncAndInvoke(t *testing.T) {
	var cleanupErr error

	// AppendFunc with non-nil error
	multierr.AppendFunc(&cleanupErr, func() error {
		return errors.New("deferred func error")
	})
	if cleanupErr == nil {
		t.Fatal("expected cleanupErr to contain func error")
	}

	// AppendInvoke with mock closer
	closer1 := &mockCloser{err: errors.New("close resource 1 failed")}
	closer2 := &mockCloser{err: nil}
	SafeCleanup(&cleanupErr, closer1, closer2)

	// AppendInvoke with Invoke helper
	DeferredCleanup(&cleanupErr, func() error {
		return errors.New("deferred action error")
	})

	errList := multierr.Errors(cleanupErr)
	if len(errList) != 3 {
		t.Fatalf("expected 3 accumulated cleanup errors, got %d: %v", len(errList), errList)
	}
}

func TestErrorsExtraction(t *testing.T) {
	// Inspect empty error
	if len(InspectErrors(nil)) != 0 {
		t.Fatal("expected 0 messages for nil error")
	}

	// Inspect single error
	single := errors.New("single error")
	msgs := InspectErrors(single)
	if len(msgs) != 1 || msgs[0] != "single error" {
		t.Fatalf("unexpected inspect result for single error: %v", msgs)
	}

	// Inspect combined errors
	combined := multierr.Combine(
		errors.New("err 1"),
		errors.New("err 2"),
		errors.New("err 3"),
	)
	msgs = InspectErrors(combined)
	if len(msgs) != 3 {
		t.Fatalf("expected 3 messages, got %d: %v", len(msgs), msgs)
	}
}

{"case":{"caseId":"case:sha256:2cef8aa7a06f81b7d3da049e6f2dddb416c97af787509fdcedf189e9afb97946","contract":["multierr.Combine merges multiple errors into a single error preserving all non-nil errors","multierr.Append appends a secondary error onto a primary error","multierr.AppendInto appends an error into a pointer destination and reports whether an error was added","multierr.AppendFunc and multierr.AppendInvoke safely capture deferred error-returning functions and closers","multierr.Errors inspects and extracts the underlying slice of errors from a combined error"],"goal":"verify pkg:golang/go.uber.org/multierr@v1.11.0","kind":"HOW","packages":["pkg:golang/go.uber.org/multierr@v1.11.0"],"schemaVersion":1,"symbols":["multierr.Combine","multierr.Append","multierr.AppendInto","multierr.AppendFunc","multierr.AppendInvoke","multierr.Errors","multierr.Close","multierr.Invoke"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","moduleSystem":"go.mod","os":"linux","osVersionBucket":"24","packageManager":"go","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":["multierr.Combine","multierr.Append","multierr.AppendInto","multierr.AppendFunc","multierr.AppendInvoke","multierr.Errors","multierr.Close","multierr.Invoke"],"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 (
	"io"

	"go.uber.org/multierr"
)

// ProcessBatch executes multiple operations and combines any returned errors into a single error.
func ProcessBatch(operations []func() error) error {
	var errs []error
	for _, op := range operations {
		if err := op(); err != nil {
			errs = append(errs, err)
		}
	}
	return multierr.Combine(errs...)
}

// Pipeline executes a sequence of steps, accumulating any errors encountered.
func Pipeline(steps []func() error) error {
	var combined error
	for _, step := range steps {
		if err := step(); err != nil {
			combined = multierr.Append(combined, err)
		}
	}
	return combined
}

// SafeCleanup runs cleanup on closers, safely appending any non-nil cleanup errors into target.
func SafeCleanup(target *error, closers ...io.Closer) {
	for _, c := range closers {
		if c != nil {
			multierr.AppendInvoke(target, multierr.Close(c))
		}
	}
}

// DeferredCleanup schedules an arbitrary action using multierr.Invoke.
func DeferredCleanup(target *error, fn func() error) {
	if fn != nil {
		multierr.AppendInvoke(target, multierr.Invoke(fn))
	}
}

// CollectErrors invokes actions and records errors directly into the accumulator.
func CollectErrors(target *error, actions ...func() error) bool {
	var hadError bool
	for _, action := range actions {
		if multierr.AppendInto(target, action()) {
			hadError = true
		}
	}
	return hadError
}

// InspectErrors returns all individual error messages from a potentially combined multierr.
func InspectErrors(err error) []string {
	var messages []string
	for _, subErr := range multierr.Errors(err) {
		if subErr != nil {
			messages = append(messages, subErr.Error())
		}
	}
	return messages
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/go.uber.org/multierr@v1.11.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/go.uber.org/multierr@v1.11.0"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}