package copystructure

import (
	"fmt"
	"reflect"
	"sync"
	"testing"
	"time"
	"unsafe"
)

func TestCopy_complex(t *testing.T) {
	v := map[string]interface{}{
		"foo": []string{"a", "b"},
		"bar": "baz",
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_interfacePointer(t *testing.T) {
	type Nested struct {
		Field string
	}

	type Test struct {
		Value *interface{}
	}

	ifacePtr := func(v interface{}) *interface{} {
		return &v
	}

	v := Test{
		Value: ifacePtr(Nested{Field: "111"}),
	}
	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_primitive(t *testing.T) {
	cases := []interface{}{
		42,
		"foo",
		1.2,
	}

	for _, tc := range cases {
		result, err := Copy(tc)
		if err != nil {
			t.Fatalf("err: %s", err)
		}
		if result != tc {
			t.Fatalf("bad: %#v", result)
		}
	}
}

func TestCopy_primitivePtr(t *testing.T) {
	i := 42
	s := "foo"
	f := 1.2
	cases := []interface{}{
		&i,
		&s,
		&f,
	}

	for i, tc := range cases {
		result, err := Copy(tc)
		if err != nil {
			t.Fatalf("err: %s", err)
		}

		if !reflect.DeepEqual(result, tc) {
			t.Fatalf("%d exptected: %#v\nbad: %#v", i, tc, result)
		}
	}
}

func TestCopy_map(t *testing.T) {
	v := map[string]interface{}{
		"bar": "baz",
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_array(t *testing.T) {
	v := [2]string{"bar", "baz"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_pointerToArray(t *testing.T) {
	v := &[2]string{"bar", "baz"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_slice(t *testing.T) {
	v := []string{"bar", "baz"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_pointerToSlice(t *testing.T) {
	v := &[]string{"bar", "baz"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_pointerToMap(t *testing.T) {
	v := &map[string]string{"bar": "baz"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_struct(t *testing.T) {
	type test struct {
		Value string
	}

	v := test{Value: "foo"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_structPtr(t *testing.T) {
	type test struct {
		Value string
	}

	v := &test{Value: "foo"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_structNil(t *testing.T) {
	type test struct {
		Value string
	}

	var v *test
	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}
	if v, ok := result.(*test); !ok {
		t.Fatalf("bad: %#v", result)
	} else if v != nil {
		t.Fatalf("bad: %#v", v)
	}
}

func TestCopy_structShallow(t *testing.T) {
	type test struct {
		Value  string
		Value2 *string `copy:"shallow"`
	}

	value2 := "bar"
	value2ptr := &value2
	v := test{Value: "foo", Value2: value2ptr}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}
	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}

	vcopy := result.(test)
	if vcopy.Value2 != v.Value2 {
		t.Fatal("should shallow copy the pointer")
	}
}

func TestCopy_structShallowWithUnsafe(t *testing.T) {
	type nested struct {
		v unsafe.Pointer
	}

	type test struct {
		Value  string
		Value2 *nested `copy:"shallow"`
	}

	value2 := &nested{}
	v := test{Value: "foo", Value2: value2}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}
	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}

	vcopy := result.(test)
	if vcopy.Value2 != v.Value2 {
		t.Fatal("should shallow copy the pointer")
	}
}

func TestCopy_structIgnore(t *testing.T) {
	type test struct {
		Value  string
		Value2 *string `copy:"ignore"`
	}

	value2 := "bar"
	value2ptr := &value2
	v := test{Value: "foo", Value2: value2ptr}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}
	vcopy := result.(test)
	if vcopy.Value2 != nil {
		t.Fatal("should be nil")
	}
}

func TestCopy_structNested(t *testing.T) {
	type TestInner struct{}

	type Test struct {
		Test *TestInner
	}

	v := Test{}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_structWithNestedArray(t *testing.T) {
	type TestInner struct {
		Value string
	}

	type Test struct {
		Value [2]TestInner
	}

	v := Test{
		Value: [2]TestInner{
			{Value: "bar"},
			{Value: "baz"},
		},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_structWithPointerToSliceField(t *testing.T) {
	type Test struct {
		Value *[]string
	}

	v := Test{
		Value: &[]string{"bar", "baz"},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_structWithPointerToArrayField(t *testing.T) {
	type Test struct {
		Value *[2]string
	}

	v := Test{
		Value: &[2]string{"bar", "baz"},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_structWithPointerToMapField(t *testing.T) {
	type Test struct {
		Value *map[string]string
	}

	v := Test{
		Value: &map[string]string{"bar": "baz"},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_structUnexported(t *testing.T) {
	type test struct {
		Value string

		private string
	}

	v := test{Value: "foo"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_structUnexportedMap(t *testing.T) {
	type Sub struct {
		Foo map[string]interface{}
	}

	type test struct {
		Value string

		private Sub
	}

	v := test{
		Value: "foo",
		private: Sub{
			Foo: map[string]interface{}{
				"yo": 42,
			},
		},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	// private should not be copied
	v.private = Sub{}
	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad:\n\n%#v\n\n%#v", result, v)
	}
}

func TestCopy_structUnexportedArray(t *testing.T) {
	type Sub struct {
		Foo [2]string
	}

	type test struct {
		Value string

		private Sub
	}

	v := test{
		Value: "foo",
		private: Sub{
			Foo: [2]string{"bar", "baz"},
		},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	// private should not be copied
	v.private = Sub{}
	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad:\n\n%#v\n\n%#v", result, v)
	}
}

// This is testing an unexported field containing a slice of pointers, which
// was a crashing case found in Terraform.
func TestCopy_structUnexportedPtrMap(t *testing.T) {
	type Foo interface{}

	type Sub struct {
		List []Foo
	}

	type test struct {
		Value string

		private *Sub
	}

	v := test{
		Value: "foo",
		private: &Sub{
			List: []Foo{&Sub{}},
		},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	// private should not be copied
	v.private = nil
	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad:\n\n%#v\n\n%#v", result, v)
	}
}

func TestCopy_nestedStructUnexported(t *testing.T) {
	type subTest struct {
		mine string
	}

	type test struct {
		Value   string
		private subTest
	}

	v := test{Value: "foo"}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_time(t *testing.T) {
	type test struct {
		Value time.Time
	}

	v := test{Value: time.Now().UTC()}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

func TestCopy_aliased(t *testing.T) {
	type (
		Int   int
		Str   string
		Map   map[Int]interface{}
		Slice []Str
	)

	v := Map{
		1: Map{10: 20},
		2: Map(nil),
		3: Slice{"a", "b"},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

type EmbeddedLocker struct {
	sync.Mutex
	Map map[int]int
}

func TestCopy_embeddedLocker(t *testing.T) {
	v := &EmbeddedLocker{
		Map: map[int]int{42: 111},
	}
	// start locked to prevent copying
	v.Lock()

	var result interface{}
	var err error

	copied := make(chan bool)

	go func() {
		result, err = Config{Lock: true}.Copy(v)
		close(copied)
	}()

	// pause slightly to make sure copying is blocked
	select {
	case <-copied:
		t.Fatal("copy completed while locked!")
	case <-time.After(100 * time.Millisecond):
		v.Unlock()
	}

	<-copied

	// test that the mutex is in the correct state
	result.(*EmbeddedLocker).Lock()
	result.(*EmbeddedLocker).Unlock()

	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

// this will trigger the race detector, and usually panic if the original
// struct isn't properly locked during Copy
func TestCopy_lockRace(t *testing.T) {
	v := &EmbeddedLocker{
		Map: map[int]int{},
	}

	var wg sync.WaitGroup
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for i := 0; i < 100; i++ {
				v.Lock()
				v.Map[i] = i
				v.Unlock()
			}
		}()
		wg.Add(1)
		go func() {
			defer wg.Done()
			Config{Lock: true}.Copy(v)
		}()
	}

	wg.Wait()
	result, err := Config{Lock: true}.Copy(v)

	// test that the mutex is in the correct state
	result.(*EmbeddedLocker).Lock()
	result.(*EmbeddedLocker).Unlock()

	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

type LockedField struct {
	String string
	Locker *EmbeddedLocker
	// this should not get locked or have its state copied
	Mutex    sync.Mutex
	nilMutex *sync.Mutex
}

func TestCopy_lockedField(t *testing.T) {
	v := &LockedField{
		String: "orig",
		Locker: &EmbeddedLocker{
			Map: map[int]int{42: 111},
		},
	}

	// start locked to prevent copying
	v.Locker.Lock()
	v.Mutex.Lock()

	var result interface{}
	var err error

	copied := make(chan bool)

	go func() {
		result, err = Config{Lock: true}.Copy(v)
		close(copied)
	}()

	// pause slightly to make sure copying is blocked
	select {
	case <-copied:
		t.Fatal("copy completed while locked!")
	case <-time.After(100 * time.Millisecond):
		v.Locker.Unlock()
	}

	<-copied

	// test that the mutexes are in the correct state
	result.(*LockedField).Locker.Lock()
	result.(*LockedField).Locker.Unlock()
	result.(*LockedField).Mutex.Lock()
	result.(*LockedField).Mutex.Unlock()

	// this wasn't  blocking, but should be unlocked for DeepEqual
	v.Mutex.Unlock()

	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("expected:\n%#v\nbad:\n%#v\n", v, result)
	}
}

// test something that doesn't contain a lock internally
type lockedMap map[int]int

var mapLock sync.Mutex

func (m lockedMap) Lock()   { mapLock.Lock() }
func (m lockedMap) Unlock() { mapLock.Unlock() }

func TestCopy_lockedMap(t *testing.T) {
	v := lockedMap{1: 2}
	v.Lock()

	var result interface{}
	var err error

	copied := make(chan bool)

	go func() {
		result, err = Config{Lock: true}.Copy(&v)
		close(copied)
	}()

	// pause slightly to make sure copying is blocked
	select {
	case <-copied:
		t.Fatal("copy completed while locked!")
	case <-time.After(100 * time.Millisecond):
		v.Unlock()
	}

	<-copied

	// test that the mutex is in the correct state
	result.(*lockedMap).Lock()
	result.(*lockedMap).Unlock()

	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, &v) {
		t.Fatalf("bad: %#v", result)
	}
}

// Use an RLock if available
type RLocker struct {
	sync.RWMutex
	Map map[int]int
}

func TestCopy_rLocker(t *testing.T) {
	v := &RLocker{
		Map: map[int]int{1: 2},
	}
	v.Lock()

	var result interface{}
	var err error

	copied := make(chan bool)

	go func() {
		result, err = Config{Lock: true}.Copy(v)
		close(copied)
	}()

	// pause slightly to make sure copying is blocked
	select {
	case <-copied:
		t.Fatal("copy completed while locked!")
	case <-time.After(100 * time.Millisecond):
		v.Unlock()
	}

	<-copied

	// test that the mutex is in the correct state
	vCopy := result.(*RLocker)
	vCopy.Lock()
	vCopy.Unlock()
	vCopy.RLock()
	vCopy.RUnlock()

	// now make sure we can copy during an RLock
	v.RLock()
	result, err = Config{Lock: true}.Copy(v)
	if err != nil {
		t.Fatal(err)
	}
	v.RUnlock()

	vCopy = result.(*RLocker)
	vCopy.Lock()
	vCopy.Unlock()
	vCopy.RLock()
	vCopy.RUnlock()

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("bad: %#v", result)
	}
}

// Test that we don't panic when encountering nil Lockers
func TestCopy_missingLockedField(t *testing.T) {
	v := &LockedField{
		String: "orig",
	}

	result, err := Config{Lock: true}.Copy(v)

	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("expected:\n%#v\nbad:\n%#v\n", v, result)
	}
}

type PointerLocker struct {
	Mu sync.Mutex
}

func (p *PointerLocker) Lock()   { p.Mu.Lock() }
func (p *PointerLocker) Unlock() { p.Mu.Unlock() }

func TestCopy_pointerLockerNil(t *testing.T) {
	v := struct {
		P *PointerLocker
	}{}

	_, err := Config{Lock: true}.Copy(&v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}
}

func TestCopy_sliceWithNil(t *testing.T) {
	v := [](*int){nil}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("expected:\n%#v\ngot:\n%#v", v, result)
	}
}

func TestCopy_mapWithNil(t *testing.T) {
	v := map[int](*int){0: nil}

	result, err := Copy(v)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	if !reflect.DeepEqual(result, v) {
		t.Fatalf("expected:\n%#v\ngot:\n%#v", v, result)
	}
}

// While this is safe to lock and copy directly, copystructure requires a
// pointer to reflect the value safely.
func TestCopy_valueWithLockPointer(t *testing.T) {
	v := struct {
		*sync.Mutex
		X int
	}{
		Mutex: &sync.Mutex{},
		X:     3,
	}

	_, err := Config{Lock: true}.Copy(v)

	if err != errPointerRequired {
		t.Fatalf("expected errPointerRequired, got: %v", err)
	}
}

func TestCopy_mapWithPointers(t *testing.T) {
	type T struct {
		S string
	}
	v := map[string]interface{}{
		"a": &T{S: "hello"},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatalf("%#v", result)
	}
}

func TestCopy_structWithMapWithPointers(t *testing.T) {
	type T struct {
		S string
		M map[string]interface{}
	}
	v := &T{
		S: "a",
		M: map[string]interface{}{
			"b": &T{
				S: "b",
			},
		},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatal(result)
	}
}

type testT struct {
	N   int
	Spp **string
	X   testX
	Xp  *testX
	Xpp **testX
}

type testX struct {
	Tp  *testT
	Tpp **testT
	Ip  *interface{}
	Ep  *error
	S   fmt.Stringer
}

type stringer struct{}

func (s *stringer) String() string {
	return "test string"
}

func TestCopy_structWithPointersAndInterfaces(t *testing.T) {
	// test that we can copy various nested and chained pointers and interfaces
	s := "val"
	sp := &s
	spp := &sp
	i := interface{}(11)

	tp := &testT{
		N: 2,
	}

	xp := &testX{
		Tp:  tp,
		Tpp: &tp,
		Ip:  &i,
		S:   &stringer{},
	}

	v := &testT{
		N:   1,
		Spp: spp,
		X:   testX{},
		Xp:  xp,
		Xpp: &xp,
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatal(result)
	}
}

func Test_pointerInterfacePointer(t *testing.T) {
	s := "hi"
	si := interface{}(&s)
	sip := &si

	result, err := Copy(sip)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(sip, result) {
		t.Fatalf("%#v != %#v\n", sip, result)
	}
}

func Test_pointerInterfacePointer2(t *testing.T) {
	type T struct {
		I *interface{}
		J **fmt.Stringer
	}

	x := 1
	y := &stringer{}

	i := interface{}(&x)
	j := fmt.Stringer(y)
	jp := &j

	v := &T{
		I: &i,
		J: &jp,
	}
	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatalf("%#v != %#v\n", v, result)
	}
}

// This test catches a bug that happened when unexported fields were
// first their subsequent fields wouldn't be copied.
func TestCopy_unexportedFieldFirst(t *testing.T) {
	type P struct {
		mu       sync.Mutex
		Old, New string
	}

	type T struct {
		M map[string]*P
	}

	v := &T{
		M: map[string]*P{
			"a": &P{Old: "", New: "2"},
		},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatalf("\n%#v\n\n%#v", v, result)
	}
}

func TestCopy_nilPointerInSlice(t *testing.T) {
	type T struct {
		Ps []*int
	}

	v := &T{
		Ps: []*int{nil},
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatalf("\n%#v\n\n%#v", v, result)
	}
}

//-------------------------------------------------------------------
// The tests below all tests various pointer cases around copying
// a structure that uses a defined Copier. This was originally raised
// around issue #26.

func TestCopy_timePointer(t *testing.T) {
	type T struct {
		Value *time.Time
	}

	now := time.Now()
	v := &T{
		Value: &now,
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatalf("\n%#v\n\n%#v", v, result)
	}
}

func TestCopy_timeNonPointer(t *testing.T) {
	type T struct {
		Value time.Time
	}

	v := &T{
		Value: time.Now(),
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatalf("\n%#v\n\n%#v", v, result)
	}
}

func TestCopy_timeDoublePointer(t *testing.T) {
	type T struct {
		Value **time.Time
	}

	now := time.Now()
	nowP := &now
	nowPP := &nowP
	v := &T{
		Value: nowPP,
	}

	result, err := Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(v, result) {
		t.Fatalf("\n%#v\n\n%#v", v, result)
	}
}

type nestedValue struct {
	v string
}

func TestCopy_customCopierConfig(t *testing.T) {
	type T struct {
		Val *nestedValue
	}

	v := &T{
		Val: &nestedValue{v: "original"},
	}

	cfg := Config{
		Copiers: map[reflect.Type]CopierFunc{
			reflect.TypeOf(nestedValue{}): customCopier,
		},
	}
	result, err := cfg.Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	copiedVal := result.(*T)

	if !reflect.DeepEqual(v.Val.v, copiedVal.Val.v) {
		t.Fatalf("\nexpected: %#v\ngiven: %#v", v.Val.v, copiedVal.Val.v)
	}
}

func customCopier(v interface{}) (interface{}, error) {
	return v.(nestedValue), nil
}

func TestCopy_customCopierShallowValue(t *testing.T) {
	type T struct{}
	v := &T{}

	cfg := Config{
		ShallowCopiers: map[reflect.Type]struct{}{
			reflect.TypeOf(T{}): struct{}{},
		},
	}
	result, err := cfg.Copy(v)
	if err != nil {
		t.Fatal(err)
	}

	copiedVal := result.(*T)

	if v != copiedVal {
		t.Fatal("value not shallow copied")
	}
}