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
123
124
125
|
package repr
import (
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
type anotherStruct struct {
A []int
}
type testStruct struct {
S string
I *int
A anotherStruct
}
func TestReprEmptyArray(t *testing.T) {
assert.Equal(t, "[]string{}", String([]string{}, OmitEmpty(false)))
}
func TestReprStringArray(t *testing.T) {
assert.Equal(t, "[]string{\"a\", \"b\"}", String([]string{"a", "b"}))
}
func TestReprIntArray(t *testing.T) {
assert.Equal(t, "[]int{1, 2}", String([]int{1, 2}))
}
func TestReprPointerToInt(t *testing.T) {
pi := new(int)
*pi = 13
assert.Equal(t, `&13`, String(pi))
}
func TestReprChannel(t *testing.T) {
ch := make(<-chan map[string]*testStruct, 1)
assert.Equal(t, `make(<-chan map[string]*repr.testStruct, 1)`, String(ch))
}
func TestReprEmptyMap(t *testing.T) {
assert.Equal(t, "map[string]bool{}", String(map[string]bool{}))
}
func TestReprMap(t *testing.T) {
m := map[string]int{"a": 1}
assert.Equal(t, "map[string]int{\"a\": 1}", String(m))
}
func TestReprStructWithIndent(t *testing.T) {
pi := new(int)
*pi = 13
s := &testStruct{
S: "String",
I: pi,
A: anotherStruct{
A: []int{1, 2, 3},
},
}
assert.Equal(t, `&repr.testStruct{
S: "String",
I: &13,
A: repr.anotherStruct{
A: []int{
1,
2,
3,
},
},
}`, String(s, Indent(" ")))
}
func TestReprByteArray(t *testing.T) {
b := []byte{1, 2, 3}
assert.Equal(t, "[]byte(\"\\x01\\x02\\x03\")", String(b))
}
type privateTestStruct struct {
a string
}
func TestReprPrivateField(t *testing.T) {
s := privateTestStruct{"hello"}
assert.Equal(t, `repr.privateTestStruct{a: "hello"}`, String(s))
}
func TestReprNilAlone(t *testing.T) {
var err error
s := String(err)
assert.Equal(t, "nil", s)
}
func TestReprNilInsideArray(t *testing.T) {
arr := []*privateTestStruct{{"hello"}, nil}
s := String(arr)
assert.Equal(t, "[]*repr.privateTestStruct{&repr.privateTestStruct{a: \"hello\"}, nil}", s)
}
type Enum int
func (e Enum) String() string {
return "Value"
}
func TestEnum(t *testing.T) {
v := Enum(1)
s := String(v)
assert.Equal(t, "repr.Enum(Value)", s)
}
func TestShowType(t *testing.T) {
a := map[string]privateTestStruct{"foo": {"bar"}}
s := String(a, AlwaysIncludeType(), Indent(" "))
t.Log(s)
assert.Equal(t, strings.TrimSpace(`
map[string]repr.privateTestStruct{
string("foo"): repr.privateTestStruct{
a: string("bar"),
},
}
`), s)
}
|
