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

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.Config 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:
  - github.com/mitchellh/copystructure.Config

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:68a112e6a14912d10e6e1f1359d255c13762b95c442c15b7fc7c9f58fe6754ed","contract":["copystructure.Config.Copy creates deep copies of nested structs, slices, and maps without mutating the original","copystructure.Config.Copy duplicates pointer values into distinct memory addresses while preserving underlying contents","copystructure.Config.Lock acquires locks on sync.Locker pointer types during traversal and enforces pointer arguments"],"goal":"verify github.com/mitchellh/copystructure.Config 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":["github.com/mitchellh/copystructure.Config"]},"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.0.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/mitchellh/copystructure@v1.0.0","symbols":["github.com/mitchellh/copystructure.Config"],"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"
	"sync"

	"github.com/mitchellh/copystructure"
)

type ConfigNode struct {
	Name    string
	Tags    []string
	Options map[string]string
}

type SafeResource struct {
	sync.Mutex
	Data string
}

func main() {
	// Demonstrate Config.Copy on nested structures
	cfg := copystructure.Config{}
	orig := ConfigNode{
		Name:    "worker",
		Tags:    []string{"primary", "v1"},
		Options: map[string]string{"timeout": "30s"},
	}

	copiedRaw, err := cfg.Copy(orig)
	if err != nil {
		panic(err)
	}

	copied := copiedRaw.(ConfigNode)
	copied.Tags[0] = "secondary"
	fmt.Printf("Original tag: %s, Copied tag: %s\n", orig.Tags[0], copied.Tags[0])

	// Demonstrate Config.Lock on thread-safe structs
	cfgLock := copystructure.Config{Lock: true}
	res := &SafeResource{Data: "protected-data"}
	copiedResRaw, err := cfgLock.Copy(res)
	if err != nil {
		panic(err)
	}
	copiedRes := copiedResRaw.(*SafeResource)
	fmt.Printf("Copied resource data: %s\n", copiedRes.Data)
}

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

package main

import (
	"fmt"
	"os"
	"sync"
	"time"

	"github.com/mitchellh/copystructure"
)

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

type NestedData struct {
	Label    string
	Items    []string
	Metadata map[string]int
	Child    *NestedData
}

type ProtectedStruct struct {
	sync.Mutex
	Counter int
}

func runContract() error {
	// Assertion 1: copystructure.Config.Copy creates deep copies of nested structs, slices, and maps without mutating the original
	cfgDefault := copystructure.Config{}
	originalData := NestedData{
		Label:    "root",
		Items:    []string{"item-a", "item-b"},
		Metadata: map[string]int{"k1": 100},
		Child: &NestedData{
			Label: "child-node",
		},
	}

	copiedRaw, err := cfgDefault.Copy(originalData)
	if err != nil {
		return fmt.Errorf("Config.Copy failed: %w", err)
	}
	copiedData, ok := copiedRaw.(NestedData)
	if !ok {
		return fmt.Errorf("expected copied result of type NestedData, got %T", copiedRaw)
	}

	// Mutate copied slices, maps, and nested struct fields to ensure independence
	copiedData.Items[0] = "mutated-a"
	copiedData.Metadata["k1"] = 999
	copiedData.Child.Label = "mutated-child"

	if originalData.Items[0] != "item-a" {
		return fmt.Errorf("deep copy mutation leaked into original slice: expected 'item-a', got %q", originalData.Items[0])
	}
	if originalData.Metadata["k1"] != 100 {
		return fmt.Errorf("deep copy mutation leaked into original map: expected 100, got %d", originalData.Metadata["k1"])
	}
	if originalData.Child.Label != "child-node" {
		return fmt.Errorf("deep copy mutation leaked into original pointer field: expected 'child-node', got %q", originalData.Child.Label)
	}

	// Assertion 2: copystructure.Config.Copy duplicates pointer values into distinct memory addresses while preserving underlying contents
	intVal := 42
	ptrOrig := &intVal
	copiedPtrRaw, err := cfgDefault.Copy(ptrOrig)
	if err != nil {
		return fmt.Errorf("Config.Copy on pointer failed: %w", err)
	}
	copiedPtr, ok := copiedPtrRaw.(*int)
	if !ok {
		return fmt.Errorf("expected *int result, got %T", copiedPtrRaw)
	}
	if copiedPtr == ptrOrig {
		return fmt.Errorf("expected distinct pointer address, but got same pointer %p", copiedPtr)
	}
	if *copiedPtr != 42 {
		return fmt.Errorf("expected pointed value 42, got %d", *copiedPtr)
	}
	*copiedPtr = 99
	if *ptrOrig != 42 {
		return fmt.Errorf("mutating copied pointer target affected original: expected 42, got %d", *ptrOrig)
	}

	// Assertion 3: copystructure.Config.Lock acquires locks on sync.Locker pointer types during traversal and enforces pointer arguments
	cfgLock := copystructure.Config{Lock: true}

	// 3a: Enforce pointer requirement when Lock is true
	nonPointerProtected := ProtectedStruct{Counter: 1}
	if _, err := cfgLock.Copy(nonPointerProtected); err == nil {
		return fmt.Errorf("expected error when passing non-pointer with Config.Lock=true, got nil")
	}

	// 3b: Lock acquisition during copy
	protectedTarget := &ProtectedStruct{Counter: 42}
	protectedTarget.Lock() // Hold lock initially

	copyFinished := make(chan bool)
	go func() {
		_, copyErr := cfgLock.Copy(protectedTarget)
		if copyErr != nil {
			panic(copyErr)
		}
		close(copyFinished)
	}()

	select {
	case <-copyFinished:
		return fmt.Errorf("Config.Copy with Lock=true proceeded while target was locked")
	case <-time.After(50 * time.Millisecond):
		// Target was properly blocked by Lock; release now
		protectedTarget.Unlock()
	}

	<-copyFinished

	return nil
}