github.com/pkg/errors v0.8.1

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/github.com/pkg/errors@v0.8.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/pkg/errors@v0.8.1

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:981b79c6152abc20eab1b289c9b595346e4cabf549f4c5354ca9a998168f36cd","contract":["errors.New creates an error with message","errors.Errorf creates a formatted error","errors.Wrap annotates an error with message and returns nil for a nil error","errors.Wrapf annotates an error with formatted message and returns nil for a nil error","errors.WithMessage adds context message and returns nil for a nil error","errors.WithStack attaches stack information while preserving error message and returns nil for a nil error","errors.Cause recursively unwraps nested errors to retrieve the underlying root cause"],"goal":"verify pkg:golang/github.com/pkg/errors@v0.8.1","kind":"HOW","packages":["pkg:golang/github.com/pkg/errors@v0.8.1"],"schemaVersion":1},"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/pkg/errors@v0.8.1"],"schemaVersion":1,"subject":"pkg:golang/github.com/pkg/errors@v0.8.1","verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require github.com/pkg/errors v0.8.1 // indirect

github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

package main

import (
	"fmt"

	"github.com/pkg/errors"
)

func main() {
	baseErr := errors.New("base error")
	wrappedErr := errors.Wrap(baseErr, "operation failed")
	formattedErr := errors.Wrapf(wrappedErr, "step %d error", 1)

	fmt.Printf("Full message: %v\n", formattedErr)
	fmt.Printf("Root cause: %v\n", errors.Cause(formattedErr))
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/github.com/pkg/errors@v0.8.1",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/pkg/errors@v0.8.1"
  ]
}

package main

import (
	"fmt"
	"os"

	"github.com/pkg/errors"
)

func main() {
	// 1. errors.New
	base := errors.New("initial failure")
	if base == nil || base.Error() != "initial failure" {
		fmt.Fprintf(os.Stderr, "errors.New failed: got %v\n", base)
		os.Exit(1)
	}

	// 2. errors.Errorf
	formatted := errors.Errorf("code %d: %s", 404, "not found")
	if formatted == nil || formatted.Error() != "code 404: not found" {
		fmt.Fprintf(os.Stderr, "errors.Errorf failed: got %v\n", formatted)
		os.Exit(1)
	}

	// 3. errors.Wrap & nil handling
	if wrappedNil := errors.Wrap(nil, "ignored"); wrappedNil != nil {
		fmt.Fprintf(os.Stderr, "errors.Wrap(nil) failed: expected nil, got %v\n", wrappedNil)
		os.Exit(1)
	}
	wrapped := errors.Wrap(base, "wrap layer")
	if wrapped.Error() != "wrap layer: initial failure" {
		fmt.Fprintf(os.Stderr, "errors.Wrap failed: got %q\n", wrapped.Error())
		os.Exit(1)
	}

	// 4. errors.Wrapf & nil handling
	if wrapfNil := errors.Wrapf(nil, "ignored %d", 1); wrapfNil != nil {
		fmt.Fprintf(os.Stderr, "errors.Wrapf(nil) failed: expected nil, got %v\n", wrapfNil)
		os.Exit(1)
	}
	wrapf := errors.Wrapf(wrapped, "wrapf step %d", 2)
	if wrapf.Error() != "wrapf step 2: wrap layer: initial failure" {
		fmt.Fprintf(os.Stderr, "errors.Wrapf failed: got %q\n", wrapf.Error())
		os.Exit(1)
	}

	// 5. errors.WithMessage & nil handling
	if withMsgNil := errors.WithMessage(nil, "ignored"); withMsgNil != nil {
		fmt.Fprintf(os.Stderr, "errors.WithMessage(nil) failed: expected nil, got %v\n", withMsgNil)
		os.Exit(1)
	}
	withMsg := errors.WithMessage(base, "message layer")
	if withMsg.Error() != "message layer: initial failure" {
		fmt.Fprintf(os.Stderr, "errors.WithMessage failed: got %q\n", withMsg.Error())
		os.Exit(1)
	}

	// 6. errors.WithStack & nil handling
	if withStackNil := errors.WithStack(nil); withStackNil != nil {
		fmt.Fprintf(os.Stderr, "errors.WithStack(nil) failed: expected nil, got %v\n", withStackNil)
		os.Exit(1)
	}
	withStack := errors.WithStack(base)
	if withStack.Error() != "initial failure" {
		fmt.Fprintf(os.Stderr, "errors.WithStack failed: got %q\n", withStack.Error())
		os.Exit(1)
	}

	// 7. errors.Cause
	nested := errors.WithMessage(errors.WithStack(errors.Wrap(base, "inner")), "outer")
	if cause := errors.Cause(nested); cause != base {
		fmt.Fprintf(os.Stderr, "errors.Cause failed: got %v, want %v\n", cause, base)
		os.Exit(1)
	}

	fmt.Println("All contract assertions passed.")
}