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

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.Close 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.Close

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 (
	"io"

	"go.uber.org/multierr"
)

// CloserFunc adapts an ordinary function returning an error to the io.Closer interface.
type CloserFunc func() error

// Close implements io.Closer by calling the underlying function.
func (f CloserFunc) Close() error {
	return f()
}

// Resource represents a closable entity that tracks whether it was closed.
type Resource struct {
	Closed   bool
	CloseErr error
}

// Close marks the resource as closed and returns its configured error.
func (r *Resource) Close() error {
	r.Closed = true
	return r.CloseErr
}

// CloseResource uses multierr.Close to create an Invoker and invokes it immediately.
func CloseResource(c io.Closer) error {
	return multierr.Close(c).Invoke()
}

// CloseAll closes each provided closer, aggregating any encountered errors into a single error.
func CloseAll(closers ...io.Closer) error {
	var err error
	for _, c := range closers {
		if c != nil {
			multierr.AppendInvoke(&err, multierr.Close(c))
		}
	}
	return err
}

// ExecuteWithCloser executes a task while ensuring the resource is closed upon completion.
// Any error from closing the resource is appended to the returned error using multierr.AppendInvoke.
func ExecuteWithCloser(c io.Closer, task func() error) (err error) {
	if c != nil {
		defer multierr.AppendInvoke(&err, multierr.Close(c))
	}
	return task()
}

package sample

import (
	"errors"
	"io"
	"testing"

	"go.uber.org/multierr"
)

func TestCloseContract(t *testing.T) {
	// Contract 1: multierr.Close wraps an io.Closer into an Invoker whose Invoke calls Close and returns nil on success
	t.Run("successful close returns nil", func(t *testing.T) {
		res := &Resource{Closed: false, CloseErr: nil}
		invoker := multierr.Close(res)
		if invoker == nil {
			t.Fatalf("expected non-nil Invoker from multierr.Close")
		}
		err := invoker.Invoke()
		if err != nil {
			t.Errorf("expected Invoke() to return nil on success, got: %v", err)
		}
		if !res.Closed {
			t.Errorf("expected resource to be closed after Invoke()")
		}
	})

	// Contract 2: multierr.Close returns an Invoker whose Invoke method returns the underlying error when Close fails
	t.Run("failing close returns underlying error", func(t *testing.T) {
		expectedErr := errors.New("underlying close failed")
		res := &Resource{Closed: false, CloseErr: expectedErr}
		invoker := multierr.Close(res)
		err := invoker.Invoke()
		if !errors.Is(err, expectedErr) {
			t.Errorf("expected %v, got %v", expectedErr, err)
		}
		if !res.Closed {
			t.Errorf("expected resource to be closed after Invoke()")
		}
	})

	// Contract 3: multierr.AppendInvoke with multierr.Close leaves target unchanged when close succeeds
	t.Run("AppendInvoke with succeeding Close leaves target unchanged", func(t *testing.T) {
		var target error
		res := &Resource{Closed: false, CloseErr: nil}
		multierr.AppendInvoke(&target, multierr.Close(res))
		if target != nil {
			t.Errorf("expected target to remain nil, got: %v", target)
		}
		if !res.Closed {
			t.Errorf("expected resource to be closed")
		}

		initialErr := errors.New("initial error")
		target = initialErr
		res2 := &Resource{Closed: false, CloseErr: nil}
		multierr.AppendInvoke(&target, multierr.Close(res2))
		if !errors.Is(target, initialErr) {
			t.Errorf("expected target to remain initialErr, got: %v", target)
		}
	})

	// Contract 4: multierr.AppendInvoke with multierr.Close captures close error into target when target is nil
	t.Run("AppendInvoke with failing Close sets target when nil", func(t *testing.T) {
		var target error
		closeErr := errors.New("disk write close error")
		res := &Resource{Closed: false, CloseErr: closeErr}
		multierr.AppendInvoke(&target, multierr.Close(res))
		if !errors.Is(target, closeErr) {
			t.Errorf("expected target to be closeErr, got: %v", target)
		}
	})

	// Contract 5: multierr.AppendInvoke with multierr.Close combines existing error and close error when both fail
	t.Run("AppendInvoke with failing Close combines errors", func(t *testing.T) {
		initialErr := errors.New("primary action failed")
		target := initialErr
		closeErr := errors.New("deferred cleanup failed")
		res := &Resource{Closed: false, CloseErr: closeErr}
		multierr.AppendInvoke(&target, multierr.Close(res))
		errs := multierr.Errors(target)
		if len(errs) != 2 {
			t.Fatalf("expected 2 errors in multierr, got %d: %v", len(errs), errs)
		}
		if !errors.Is(errs[0], initialErr) || !errors.Is(errs[1], closeErr) {
			t.Errorf("unexpected error chain: %v", errs)
		}
	})

	// Contract 6: multierr.Close deferred execution captures close errors into named return errors
	t.Run("deferred execution captures close error into named return", func(t *testing.T) {
		closeErr := errors.New("stream flush failed")
		res := &Resource{Closed: false, CloseErr: closeErr}

		err := ExecuteWithCloser(res, func() error {
			return nil
		})
		if !errors.Is(err, closeErr) {
			t.Errorf("expected deferred close error to be returned, got: %v", err)
		}
		if !res.Closed {
			t.Errorf("expected resource to be closed")
		}

		primaryErr := errors.New("business logic failed")
		res2 := &Resource{Closed: false, CloseErr: closeErr}
		err = ExecuteWithCloser(res2, func() error {
			return primaryErr
		})
		errs := multierr.Errors(err)
		if len(errs) != 2 {
			t.Fatalf("expected 2 errors combined, got %d", len(errs))
		}
		if !errors.Is(errs[0], primaryErr) || !errors.Is(errs[1], closeErr) {
			t.Errorf("unexpected error list: %v", errs)
		}
	})

	// Contract 7: multierr.Close panics when closer is nil
	t.Run("nil closer panics", func(t *testing.T) {
		defer func() {
			r := recover()
			if r == nil {
				t.Fatalf("expected panic when closer is nil, but did not panic")
			}
		}()
		var nilCloser io.Closer
		_ = multierr.Close(nilCloser)
	})
}

func TestSampleHelpers(t *testing.T) {
	t.Run("CloseResource helper", func(t *testing.T) {
		res := &Resource{CloseErr: nil}
		if err := CloseResource(res); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
		if !res.Closed {
			t.Errorf("expected resource to be closed")
		}
	})

	t.Run("CloseAll helper with multiple resources", func(t *testing.T) {
		err1 := errors.New("first closer failed")
		err2 := errors.New("second closer failed")
		r1 := &Resource{CloseErr: err1}
		r2 := &Resource{CloseErr: nil}
		r3 := &Resource{CloseErr: err2}

		combinedErr := CloseAll(r1, r2, r3)
		if combinedErr == nil {
			t.Fatalf("expected error from CloseAll, got nil")
		}
		errs := multierr.Errors(combinedErr)
		if len(errs) != 2 {
			t.Fatalf("expected 2 errors, got %d: %v", len(errs), errs)
		}
		if !errors.Is(errs[0], err1) || !errors.Is(errs[1], err2) {
			t.Errorf("unexpected errors in combined: %v", errs)
		}
		if !r1.Closed || !r2.Closed || !r3.Closed {
			t.Errorf("all resources should have been closed")
		}
	})

	t.Run("CloserFunc adapter", func(t *testing.T) {
		var called bool
		cf := CloserFunc(func() error {
			called = true
			return nil
		})
		err := multierr.Close(cf).Invoke()
		if err != nil {
			t.Errorf("unexpected error: %v", err)
		}
		if !called {
			t.Errorf("expected CloserFunc to be called")
		}
	})
}

{"case":{"caseId":"case:sha256:2098f638ca5da40617c188cc23318c2b1225f0e9a84d006801bd55c1b738cdb4","contract":["multierr.Close wraps an io.Closer into an Invoker whose Invoke calls Close and returns nil on success","multierr.Close returns an Invoker whose Invoke method returns the underlying error when Close fails","multierr.AppendInvoke with multierr.Close leaves target unchanged when close succeeds","multierr.AppendInvoke with multierr.Close captures close error into target when target is nil","multierr.AppendInvoke with multierr.Close combines existing error and close error when both fail","multierr.Close deferred execution captures close errors into named return errors","multierr.Close panics when closer is nil"],"goal":"verify go.uber.org/multierr.Close 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.Close"]},"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.Close"],"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.Close 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.Close"
  ]
}