go.uber.org/multierr v1.11.0: 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 go.uber.org/multierr.AppendInto 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.AppendInto

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 (
	"go.uber.org/multierr"
)

// Task represents an operation that may return an error.
type Task func() error

// RunTasks executes all given tasks and collects any errors into a single error
// using multierr.AppendInto. Returns true if any task produced an error.
func RunTasks(tasks []Task) (error, bool) {
	var accumulated error
	var hasError bool

	for _, task := range tasks {
		if task != nil {
			if multierr.AppendInto(&accumulated, task()) {
				hasError = true
			}
		}
	}

	return accumulated, hasError
}

// AppendStepError appends an error encountered during a step to the target error pointer.
// Returns true if an error was added, false if stepErr was nil.
func AppendStepError(target *error, stepErr error) bool {
	return multierr.AppendInto(target, stepErr)
}

package sample

import (
	"errors"
	"strings"
	"testing"

	"go.uber.org/multierr"
)

func TestAppendIntoContract(t *testing.T) {
	// Contract 1: multierr.AppendInto returns false and leaves target unchanged when err is nil
	t.Run("nil error append", func(t *testing.T) {
		var target error
		added := multierr.AppendInto(&target, nil)
		if added {
			t.Errorf("expected added=false when appending nil error, got true")
		}
		if target != nil {
			t.Errorf("expected target to remain nil, got %v", target)
		}

		existing := errors.New("initial error")
		target = existing
		added = multierr.AppendInto(&target, nil)
		if added {
			t.Errorf("expected added=false when appending nil error to non-nil target, got true")
		}
		if !errors.Is(target, existing) {
			t.Errorf("expected target to remain unchanged, got %v", target)
		}
	})

	// Contract 2: multierr.AppendInto returns true and assigns target when target is initially nil and err is non-nil
	t.Run("first non-nil error append", func(t *testing.T) {
		var target error
		err1 := errors.New("first error")
		added := multierr.AppendInto(&target, err1)
		if !added {
			t.Errorf("expected added=true when appending non-nil error, got false")
		}
		if !errors.Is(target, err1) {
			t.Errorf("expected target to equal err1, got %v", target)
		}
	})

	// Contract 3: multierr.AppendInto returns true and combines multiple non-nil errors into target
	t.Run("multiple errors accumulation", func(t *testing.T) {
		var target error
		err1 := errors.New("error one")
		err2 := errors.New("error two")
		err3 := errors.New("error three")

		if !multierr.AppendInto(&target, err1) {
			t.Errorf("expected added=true for err1")
		}
		if !multierr.AppendInto(&target, err2) {
			t.Errorf("expected added=true for err2")
		}
		if !multierr.AppendInto(&target, err3) {
			t.Errorf("expected added=true for err3")
		}

		errList := multierr.Errors(target)
		if len(errList) != 3 {
			t.Fatalf("expected 3 accumulated errors, got %d: %v", len(errList), errList)
		}
		if !errors.Is(errList[0], err1) || !errors.Is(errList[1], err2) || !errors.Is(errList[2], err3) {
			t.Errorf("unexpected error contents in accumulated multierr: %v", errList)
		}
	})

	// Contract 4: multierr.AppendInto panics when into pointer is nil
	t.Run("nil into pointer panic", func(t *testing.T) {
		defer func() {
			r := recover()
			if r == nil {
				t.Fatalf("expected panic when into pointer is nil, but did not panic")
			}
			msg, ok := r.(string)
			if !ok || !strings.Contains(msg, "into pointer must not be nil") {
				t.Errorf("expected misuse message in panic, got %v", r)
			}
		}()

		var nilPtr *error
		multierr.AppendInto(nilPtr, errors.New("some error"))
	})
}

func TestRunTasksHelper(t *testing.T) {
	err1 := errors.New("task 1 failure")
	err3 := errors.New("task 3 failure")

	tasks := []Task{
		func() error { return err1 },
		func() error { return nil },
		func() error { return err3 },
	}

	combined, hasErr := RunTasks(tasks)
	if !hasErr {
		t.Fatalf("expected hasErr=true, got false")
	}

	errList := multierr.Errors(combined)
	if len(errList) != 2 {
		t.Fatalf("expected 2 errors from RunTasks, got %d: %v", len(errList), errList)
	}
}

func TestAppendStepErrorHelper(t *testing.T) {
	var stepErr error
	if AppendStepError(&stepErr, nil) {
		t.Errorf("expected false on nil step error")
	}
	e := errors.New("step failed")
	if !AppendStepError(&stepErr, e) {
		t.Errorf("expected true on non-nil step error")
	}
	if !errors.Is(stepErr, e) {
		t.Errorf("expected stepErr to be %v, got %v", e, stepErr)
	}
}

{"case":{"caseId":"case:sha256:0404979f987189d6276c6c3255564af0a2c3fedddbebf42fd19c9dfbda172c32","contract":["multierr.AppendInto returns false and leaves target unchanged when err is nil","multierr.AppendInto returns true and assigns target when target is initially nil and err is non-nil","multierr.AppendInto returns true and combines multiple non-nil errors into target","multierr.AppendInto panics when into pointer is nil"],"goal":"verify go.uber.org/multierr.AppendInto 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.AppendInto"]},"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":["go.uber.org/multierr.AppendInto"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require go.uber.org/multierr v1.11.0

go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=

{
  "schemaVersion": 1,
  "goal": "verify go.uber.org/multierr.AppendInto 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.AppendInto"
  ]
}