github.com/mitchellh/copystructure v1.0.0: Copy

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 copystructure.Copy in pkg:golang/github.com/mitchellh/copystructure@v1.0.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/mitchellh/copystructure@v1.0.0
Demonstrate these symbols/APIs:
  - copystructure.Copy
Required runtime conditions:
  - ecosystem: golang
  - language: go
  - packageManager: go@1.26.6
  - runtime: go@1.26.6

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:a693e30f49370dc124c202560cf32783722421b8f918f926e0002ff8d718de4e","contract":["copystructure.Copy produces an independent deep copy of nested slices and maps","copystructure.Copy deep copies struct pointer fields into distinct addresses","copystructure.Copy handles primitive types and nil pointers correctly","copystructure.Copy supports custom type copying registered in Copiers","copystructure.Must unwraps successful copy results without error"],"goal":"verify copystructure.Copy in pkg:golang/github.com/mitchellh/copystructure@v1.0.0","kind":"HOW","packages":["pkg:golang/github.com/mitchellh/copystructure@v1.0.0"],"schemaVersion":1,"symbols":["copystructure.Copy"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/mitchellh/copystructure@v1.0.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/mitchellh/copystructure@v1.0.0","symbols":["copystructure.Copy"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/mitchellh/copystructure v1.0.0

require github.com/mitchellh/reflectwalk v1.0.0 // indirect

github.com/mitchellh/copystructure v1.0.0 h1:Laisrj+bAB6b/yJwB5Bt3ITZhGJdqmxquMKeZ+mmkFQ=
github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw=
github.com/mitchellh/reflectwalk v1.0.0 h1:9D+8oIskB4VJBN5SFlmc27fSlIBZaov1Wpk/IfikLNY=
github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=

package main

import (
	"fmt"

	"github.com/mitchellh/copystructure"
)

// Config holds sample nested structured configuration data.
type Config struct {
	Name     string
	Tags     []string
	Settings map[string]string
}

func main() {
	original := Config{
		Name:     "default",
		Tags:     []string{"alpha", "beta"},
		Settings: map[string]string{"env": "staging", "region": "us-east"},
	}

	copiedRaw, err := copystructure.Copy(original)
	if err != nil {
		fmt.Printf("copy failed: %v\n", err)
		return
	}

	copied := copiedRaw.(Config)
	copied.Tags[0] = "gamma"
	copied.Settings["env"] = "production"

	fmt.Printf("Original: Tags=%v, Settings=%v\n", original.Tags, original.Settings)
	fmt.Printf("Copied:   Tags=%v, Settings=%v\n", copied.Tags, copied.Settings)
}

{
  "schemaVersion": 1,
  "goal": "verify copystructure.Copy in pkg:golang/github.com/mitchellh/copystructure@v1.0.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/mitchellh/copystructure@v1.0.0"
  ],
  "symbols": [
    "copystructure.Copy"
  ],
  "runtimeConditions": {
    "ecosystem": "golang",
    "language": "go",
    "packageManager": "go@1.26.6",
    "runtime": "go@1.26.6"
  }
}

package main

import (
	"fmt"
	"os"
	"reflect"

	"github.com/mitchellh/copystructure"
)

func main() {
	// Assertion 1: copystructure.Copy produces an independent deep copy of nested slices and maps
	{
		orig := map[string][]string{
			"languages": {"go", "python"},
			"tools":     {"compiler", "linker"},
		}

		copiedRaw, err := copystructure.Copy(orig)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: error during copy: %v\n", err)
			os.Exit(1)
		}

		copied, ok := copiedRaw.(map[string][]string)
		if !ok {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: type assertion failed\n")
			os.Exit(1)
		}

		copied["languages"][0] = "rust"
		copied["tools"] = append(copied["tools"], "debugger")

		if orig["languages"][0] != "go" {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: original slice modified: %s\n", orig["languages"][0])
			os.Exit(1)
		}
		if len(orig["tools"]) != 2 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: original tools slice length modified\n")
			os.Exit(1)
		}
		if copied["languages"][0] != "rust" || len(copied["tools"]) != 3 {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: copy does not reflect mutations\n")
			os.Exit(1)
		}
	}

	// Assertion 2: copystructure.Copy deep copies struct pointer fields into distinct addresses
	{
		type Data struct {
			ID    int
			Count *int
		}

		val := 42
		orig := Data{
			ID:    1,
			Count: &val,
		}

		copiedRaw, err := copystructure.Copy(orig)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: copy error: %v\n", err)
			os.Exit(1)
		}

		copied, ok := copiedRaw.(Data)
		if !ok {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: type assertion failed\n")
			os.Exit(1)
		}

		if copied.Count == orig.Count {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: pointer addresses are identical\n")
			os.Exit(1)
		}
		if *copied.Count != 42 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: expected dereferenced value 42, got %d\n", *copied.Count)
			os.Exit(1)
		}

		*copied.Count = 99
		if *orig.Count != 42 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: mutating copy mutated original pointer value\n")
			os.Exit(1)
		}
	}

	// Assertion 3: copystructure.Copy handles primitive types and nil pointers correctly
	{
		str := "hello-sample"
		cpStrRaw, err := copystructure.Copy(str)
		if err != nil || cpStrRaw.(string) != str {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: string copy failed\n")
			os.Exit(1)
		}

		num := 12345
		cpNumRaw, err := copystructure.Copy(num)
		if err != nil || cpNumRaw.(int) != num {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: int copy failed\n")
			os.Exit(1)
		}

		var nilPtr *int
		cpNilRaw, err := copystructure.Copy(nilPtr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: nil pointer copy errored: %v\n", err)
			os.Exit(1)
		}
		if cpNil, ok := cpNilRaw.(*int); !ok || cpNil != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: expected nil pointer, got %v\n", cpNilRaw)
			os.Exit(1)
		}
	}

	// Assertion 4: copystructure.Copy supports custom type copying registered in Copiers
	{
		type CustomSecret struct {
			Secret string
		}

		copystructure.Copiers[reflect.TypeOf(CustomSecret{})] = func(v interface{}) (interface{}, error) {
			cs := v.(CustomSecret)
			return CustomSecret{Secret: "redacted-" + cs.Secret}, nil
		}

		input := CustomSecret{Secret: "top-secret"}
		copiedRaw, err := copystructure.Copy(input)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: custom copier error: %v\n", err)
			os.Exit(1)
		}

		copied, ok := copiedRaw.(CustomSecret)
		if !ok || copied.Secret != "redacted-top-secret" {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: unexpected custom copy result: %+v\n", copiedRaw)
			os.Exit(1)
		}
	}

	// Assertion 5: copystructure.Must unwraps successful copy results without error
	{
		input := []string{"item1", "item2"}
		result := copystructure.Must(copystructure.Copy(input))
		copied, ok := result.([]string)
		if !ok || len(copied) != 2 || copied[0] != "item1" || copied[1] != "item2" {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: Must unwrap mismatch\n")
			os.Exit(1)
		}
	}

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