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

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/mitchellh/copystructure@v1.2.0
Demonstrate these symbols/APIs:
  - github.com/mitchellh/copystructure.Copy

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:fce1ee3143c0b63029f50e4a927745826e938055c2a3cf7a8f0998289aa4a369","contract":["copystructure.Copy creates a deep copy of nested map and slice structures where mutations to the copy do not affect the original","copystructure.Copy creates an independent deep copy of struct pointers and preserves field values","copystructure.Copy deep copies primitive values and returns nil error on valid inputs","copystructure.Copy properly copies nested pointer references creating new memory addresses for referenced fields"],"goal":"verify github.com/mitchellh/copystructure.Copy in pkg:golang/github.com/mitchellh/copystructure@v1.2.0","kind":"HOW","packages":["pkg:golang/github.com/mitchellh/copystructure@v1.2.0"],"schemaVersion":1,"symbols":["github.com/mitchellh/copystructure.Copy"]},"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/mitchellh/copystructure@v1.2.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/mitchellh/copystructure@v1.2.0","symbols":["github.com/mitchellh/copystructure.Copy"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/mitchellh/copystructure v1.2.0

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

github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=

package main

import (
	"fmt"

	"github.com/mitchellh/copystructure"
)

type Config struct {
	Name    string
	Tags    []string
	Options map[string]int
}

func main() {
	original := Config{
		Name:    "primary-service",
		Tags:    []string{"alpha", "beta"},
		Options: map[string]int{"timeout": 30, "retries": 3},
	}

	copied, err := copystructure.Copy(original)
	if err != nil {
		panic(err)
	}

	cloned := copied.(Config)
	cloned.Tags[0] = "gamma"
	cloned.Options["timeout"] = 60

	fmt.Printf("Original: tags=%v, options=%v\n", original.Tags, original.Options)
	fmt.Printf("Cloned:   tags=%v, options=%v\n", cloned.Tags, cloned.Options)
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/mitchellh/copystructure.Copy in pkg:golang/github.com/mitchellh/copystructure@v1.2.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/mitchellh/copystructure@v1.2.0"
  ],
  "symbols": [
    "github.com/mitchellh/copystructure.Copy"
  ]
}

package main

import (
	"fmt"
	"os"
	"reflect"

	"github.com/mitchellh/copystructure"
)

type NestedData struct {
	Count int
	Meta  *Metadata
}

type Metadata struct {
	ID    string
	Flags []bool
}

type ComplexStruct struct {
	Name    string
	Mapping map[string]int
	Items   []string
	Nested  *NestedData
}

func main() {
	if err := runContract(); err != nil {
		fmt.Fprintf(os.Stderr, "Contract verification failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("All copystructure.Copy contract assertions passed successfully.")
}

func runContract() error {
	// Assertion 1: copystructure.Copy creates a deep copy of nested map and slice structures where mutations to the copy do not affect the original
	origMap := map[string][]string{
		"env":  {"prod", "us-east"},
		"tier": {"web"},
	}
	copyMapVal, err := copystructure.Copy(origMap)
	if err != nil {
		return fmt.Errorf("unexpected error copying map: %w", err)
	}
	clonedMap, ok := copyMapVal.(map[string][]string)
	if !ok {
		return fmt.Errorf("expected map[string][]string, got %T", copyMapVal)
	}
	clonedMap["env"][0] = "dev"
	clonedMap["tier"] = append(clonedMap["tier"], "db")
	if origMap["env"][0] != "prod" {
		return fmt.Errorf("original map slice modified: expected 'prod', got %q", origMap["env"][0])
	}
	if len(origMap["tier"]) != 1 {
		return fmt.Errorf("original map slice length changed: expected 1, got %d", len(origMap["tier"]))
	}

	// Assertion 2: copystructure.Copy creates an independent deep copy of struct pointers and preserves field values
	meta := &Metadata{ID: "meta-01", Flags: []bool{true, false}}
	origStruct := &ComplexStruct{
		Name:    "service-config",
		Mapping: map[string]int{"port": 8080},
		Items:   []string{"first", "second"},
		Nested:  &NestedData{Count: 42, Meta: meta},
	}
	copyStructVal, err := copystructure.Copy(origStruct)
	if err != nil {
		return fmt.Errorf("unexpected error copying struct pointer: %w", err)
	}
	clonedStruct, ok := copyStructVal.(*ComplexStruct)
	if !ok {
		return fmt.Errorf("expected *ComplexStruct, got %T", copyStructVal)
	}
	if clonedStruct == origStruct {
		return fmt.Errorf("expected new struct pointer, got identical address")
	}
	if clonedStruct.Name != origStruct.Name {
		return fmt.Errorf("expected Name %q, got %q", origStruct.Name, clonedStruct.Name)
	}
	if !reflect.DeepEqual(clonedStruct.Items, origStruct.Items) {
		return fmt.Errorf("expected Items to match: %v vs %v", origStruct.Items, clonedStruct.Items)
	}

	// Assertion 3: copystructure.Copy deep copies primitive values and returns nil error on valid inputs
	num := 12345
	copiedNum, err := copystructure.Copy(num)
	if err != nil {
		return fmt.Errorf("unexpected error copying int: %w", err)
	}
	if copiedNum != 12345 {
		return fmt.Errorf("expected 12345, got %v", copiedNum)
	}

	str := "sample-string-value"
	copiedStr, err := copystructure.Copy(str)
	if err != nil {
		return fmt.Errorf("unexpected error copying string: %w", err)
	}
	if copiedStr != "sample-string-value" {
		return fmt.Errorf("expected 'sample-string-value', got %v", copiedStr)
	}

	// Assertion 4: copystructure.Copy properly copies nested pointer references creating new memory addresses for referenced fields
	clonedStruct.Nested.Meta.ID = "meta-updated"
	clonedStruct.Nested.Meta.Flags[0] = false
	if origStruct.Nested.Meta.ID != "meta-01" {
		return fmt.Errorf("nested pointer ID mutated on original: expected 'meta-01', got %q", origStruct.Nested.Meta.ID)
	}
	if origStruct.Nested.Meta.Flags[0] != true {
		return fmt.Errorf("nested slice in pointer mutated on original: expected true, got %v", origStruct.Nested.Meta.Flags[0])
	}
	if clonedStruct.Nested.Meta == origStruct.Nested.Meta {
		return fmt.Errorf("expected different pointer addresses for Nested.Meta")
	}

	return nil
}