1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
package blackmagic_test
import (
"errors"
"fmt"
"testing"
"github.com/lestrrat-go/blackmagic"
"github.com/stretchr/testify/require"
)
func TestAssignment(t *testing.T) {
const val = 42
t.Run("to interface{}", func(t *testing.T) {
var dst interface{}
require.NoError(t, blackmagic.AssignIfCompatible(&dst, val), `blackmagic.AssignIfCompatible should succeed`)
require.Equal(t, val, dst, `dst should be equal to src`)
})
t.Run("to int", func(t *testing.T) {
var dst int
require.NoError(t, blackmagic.AssignIfCompatible(&dst, val), `blackmagic.AssignIfCompatible should succeed`)
require.Equal(t, val, dst, `dst should be equal to src`)
})
t.Run("to string (should fail)", func(t *testing.T) {
var dst string
err := blackmagic.AssignIfCompatible(&dst, val)
require.Error(t, err, `blackmagic.AssignIfCompatible should fail`)
})
}
func TestAssignmentEdgeCases(t *testing.T) {
testcases := []struct {
Name string
Error bool
ErrorCheck func(error) error
Value interface{}
Destination func() interface{}
}{
{
Name: `empty struct`,
Error: false,
Value: struct{}{},
Destination: func() interface{} {
var v interface{}
return &v
},
},
{
Name: `non pointer destination`,
Error: true,
Value: &struct{}{},
},
{
Name: `assign empty struct to int`,
Error: true,
Value: &struct{}{},
Destination: func() interface{} {
var v int
return &v
},
},
{
Name: `source is nil`,
Error: true,
Value: nil,
Destination: func() interface{} {
var v interface{}
return &v
},
ErrorCheck: func(err error) error {
if !errors.Is(err, blackmagic.InvalidValueError()) {
return fmt.Errorf(`error should be InvalidValueError, but got %v`, err)
}
return nil
},
},
}
for _, tc := range testcases {
tc := tc
t.Run(tc.Name, func(t *testing.T) {
var dst interface{}
if dstFunc := tc.Destination; dstFunc != nil {
dst = dstFunc()
}
err := blackmagic.AssignIfCompatible(dst, tc.Value)
if tc.Error {
require.Error(t, err, `blackmagic.AssignIfCompatible should fail`)
if check := tc.ErrorCheck; check != nil {
if checkErr := check(err); checkErr != nil {
require.NoError(t, checkErr, `check function should succeed`)
}
}
} else {
require.NoError(t, err, `blackmagic.AssignIfCompatible should succeed`)
}
})
}
}
func TestAssignOptionalField(t *testing.T) {
var f struct {
Foo *string
Bar *int
}
require.NoError(t, blackmagic.AssignOptionalField(&f.Foo, "Hello"), `blackmagic.AssignOptionalField should succeed`)
require.Equal(t, *(f.Foo), "Hello")
require.NoError(t, blackmagic.AssignOptionalField(&f.Bar, 1), `blackmagic.AssignOptionalField should succeed`)
require.Equal(t, *(f.Bar), 1)
}
func TestAssignPointer(t *testing.T) {
var src int
var dst *int
require.NoError(t, blackmagic.AssignIfCompatible(&dst, &src), `blackmagic.AssignIfCompatible should succeed`)
src = 42
require.Equal(t, 42, *dst, `dst should be updated to point to the value of src`)
}
|
