1 package json
2
3 import (
4 "math"
5 "net"
6 "reflect"
7 "testing"
8 )
9
10 func TestAppendType(t *testing.T) {
11 w := map[string]func(interface{}) []byte{
12 "AppendInt": func(v interface{}) []byte { return enc.AppendInt([]byte{}, v.(int)) },
13 "AppendInt8": func(v interface{}) []byte { return enc.AppendInt8([]byte{}, v.(int8)) },
14 "AppendInt16": func(v interface{}) []byte { return enc.AppendInt16([]byte{}, v.(int16)) },
15 "AppendInt32": func(v interface{}) []byte { return enc.AppendInt32([]byte{}, v.(int32)) },
16 "AppendInt64": func(v interface{}) []byte { return enc.AppendInt64([]byte{}, v.(int64)) },
17 "AppendUint": func(v interface{}) []byte { return enc.AppendUint([]byte{}, v.(uint)) },
18 "AppendUint8": func(v interface{}) []byte { return enc.AppendUint8([]byte{}, v.(uint8)) },
19 "AppendUint16": func(v interface{}) []byte { return enc.AppendUint16([]byte{}, v.(uint16)) },
20 "AppendUint32": func(v interface{}) []byte { return enc.AppendUint32([]byte{}, v.(uint32)) },
21 "AppendUint64": func(v interface{}) []byte { return enc.AppendUint64([]byte{}, v.(uint64)) },
22 "AppendFloat32": func(v interface{}) []byte { return enc.AppendFloat32([]byte{}, v.(float32)) },
23 "AppendFloat64": func(v interface{}) []byte { return enc.AppendFloat64([]byte{}, v.(float64)) },
24 }
25 tests := []struct {
26 name string
27 fn string
28 input interface{}
29 want []byte
30 }{
31 {"AppendInt8(math.MaxInt8)", "AppendInt8", int8(math.MaxInt8), []byte("127")},
32 {"AppendInt16(math.MaxInt16)", "AppendInt16", int16(math.MaxInt16), []byte("32767")},
33 {"AppendInt32(math.MaxInt32)", "AppendInt32", int32(math.MaxInt32), []byte("2147483647")},
34 {"AppendInt64(math.MaxInt64)", "AppendInt64", int64(math.MaxInt64), []byte("9223372036854775807")},
35
36 {"AppendUint8(math.MaxUint8)", "AppendUint8", uint8(math.MaxUint8), []byte("255")},
37 {"AppendUint16(math.MaxUint16)", "AppendUint16", uint16(math.MaxUint16), []byte("65535")},
38 {"AppendUint32(math.MaxUint32)", "AppendUint32", uint32(math.MaxUint32), []byte("4294967295")},
39 {"AppendUint64(math.MaxUint64)", "AppendUint64", uint64(math.MaxUint64), []byte("18446744073709551615")},
40
41 {"AppendFloat32(-Inf)", "AppendFloat32", float32(math.Inf(-1)), []byte(`"-Inf"`)},
42 {"AppendFloat32(+Inf)", "AppendFloat32", float32(math.Inf(1)), []byte(`"+Inf"`)},
43 {"AppendFloat32(NaN)", "AppendFloat32", float32(math.NaN()), []byte(`"NaN"`)},
44 {"AppendFloat32(0)", "AppendFloat32", float32(0), []byte(`0`)},
45 {"AppendFloat32(-1.1)", "AppendFloat32", float32(-1.1), []byte(`-1.1`)},
46 {"AppendFloat32(1e20)", "AppendFloat32", float32(1e20), []byte(`100000000000000000000`)},
47 {"AppendFloat32(1e21)", "AppendFloat32", float32(1e21), []byte(`1000000000000000000000`)},
48
49 {"AppendFloat64(-Inf)", "AppendFloat64", float64(math.Inf(-1)), []byte(`"-Inf"`)},
50 {"AppendFloat64(+Inf)", "AppendFloat64", float64(math.Inf(1)), []byte(`"+Inf"`)},
51 {"AppendFloat64(NaN)", "AppendFloat64", float64(math.NaN()), []byte(`"NaN"`)},
52 {"AppendFloat64(0)", "AppendFloat64", float64(0), []byte(`0`)},
53 {"AppendFloat64(-1.1)", "AppendFloat64", float64(-1.1), []byte(`-1.1`)},
54 {"AppendFloat64(1e20)", "AppendFloat64", float64(1e20), []byte(`100000000000000000000`)},
55 {"AppendFloat64(1e21)", "AppendFloat64", float64(1e21), []byte(`1000000000000000000000`)},
56 }
57 for _, tt := range tests {
58 t.Run(tt.name, func(t *testing.T) {
59 if got := w[tt.fn](tt.input); !reflect.DeepEqual(got, tt.want) {
60 t.Errorf("got %s, want %s", got, tt.want)
61 }
62 })
63 }
64 }
65
66 func Test_appendMAC(t *testing.T) {
67 MACtests := []struct {
68 input string
69 want []byte
70 }{
71 {"01:23:45:67:89:ab", []byte(`"01:23:45:67:89:ab"`)},
72 {"cd:ef:11:22:33:44", []byte(`"cd:ef:11:22:33:44"`)},
73 }
74 for _, tt := range MACtests {
75 t.Run("MAC", func(t *testing.T) {
76 ha, _ := net.ParseMAC(tt.input)
77 if got := enc.AppendMACAddr([]byte{}, ha); !reflect.DeepEqual(got, tt.want) {
78 t.Errorf("appendMACAddr() = %s, want %s", got, tt.want)
79 }
80 })
81 }
82 }
83
84 func Test_appendIP(t *testing.T) {
85 IPv4tests := []struct {
86 input net.IP
87 want []byte
88 }{
89 {net.IP{0, 0, 0, 0}, []byte(`"0.0.0.0"`)},
90 {net.IP{192, 0, 2, 200}, []byte(`"192.0.2.200"`)},
91 }
92
93 for _, tt := range IPv4tests {
94 t.Run("IPv4", func(t *testing.T) {
95 if got := enc.AppendIPAddr([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
96 t.Errorf("appendIPAddr() = %s, want %s", got, tt.want)
97 }
98 })
99 }
100 IPv6tests := []struct {
101 input net.IP
102 want []byte
103 }{
104 {net.IPv6zero, []byte(`"::"`)},
105 {net.IPv6linklocalallnodes, []byte(`"ff02::1"`)},
106 {net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}, []byte(`"2001:db8:85a3::8a2e:370:7334"`)},
107 }
108 for _, tt := range IPv6tests {
109 t.Run("IPv6", func(t *testing.T) {
110 if got := enc.AppendIPAddr([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
111 t.Errorf("appendIPAddr() = %s, want %s", got, tt.want)
112 }
113 })
114 }
115 }
116
117 func Test_appendIPPrefix(t *testing.T) {
118 IPv4Prefixtests := []struct {
119 input net.IPNet
120 want []byte
121 }{
122 {net.IPNet{IP: net.IP{0, 0, 0, 0}, Mask: net.IPv4Mask(0, 0, 0, 0)}, []byte(`"0.0.0.0/0"`)},
123 {net.IPNet{IP: net.IP{192, 0, 2, 200}, Mask: net.IPv4Mask(255, 255, 255, 0)}, []byte(`"192.0.2.200/24"`)},
124 }
125 for _, tt := range IPv4Prefixtests {
126 t.Run("IPv4", func(t *testing.T) {
127 if got := enc.AppendIPPrefix([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
128 t.Errorf("appendIPPrefix() = %s, want %s", got, tt.want)
129 }
130 })
131 }
132 IPv6Prefixtests := []struct {
133 input net.IPNet
134 want []byte
135 }{
136 {net.IPNet{IP: net.IPv6zero, Mask: net.CIDRMask(0, 128)}, []byte(`"::/0"`)},
137 {net.IPNet{IP: net.IPv6linklocalallnodes, Mask: net.CIDRMask(128, 128)}, []byte(`"ff02::1/128"`)},
138 {net.IPNet{IP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34},
139 Mask: net.CIDRMask(64, 128)},
140 []byte(`"2001:db8:85a3::8a2e:370:7334/64"`)},
141 }
142 for _, tt := range IPv6Prefixtests {
143 t.Run("IPv6", func(t *testing.T) {
144 if got := enc.AppendIPPrefix([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
145 t.Errorf("appendIPPrefix() = %s, want %s", got, tt.want)
146 }
147 })
148 }
149 }
150
151 func Test_appendMac(t *testing.T) {
152 MACtests := []struct {
153 input net.HardwareAddr
154 want []byte
155 }{
156 {net.HardwareAddr{0x12, 0x34, 0x56, 0x78, 0x90, 0xab}, []byte(`"12:34:56:78:90:ab"`)},
157 {net.HardwareAddr{0x12, 0x34, 0x00, 0x00, 0x90, 0xab}, []byte(`"12:34:00:00:90:ab"`)},
158 }
159
160 for _, tt := range MACtests {
161 t.Run("MAC", func(t *testing.T) {
162 if got := enc.AppendMACAddr([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
163 t.Errorf("appendMAC() = %s, want %s", got, tt.want)
164 }
165 })
166 }
167 }
168
169 func Test_appendObjectData(t *testing.T) {
170 tests := []struct {
171 dst []byte
172 obj []byte
173 want []byte
174 }{
175 {[]byte{}, []byte(`{"foo":"bar"}`), []byte(`"foo":"bar"}`)},
176 {[]byte(`{"qux":"quz"`), []byte(`{"foo":"bar"}`), []byte(`{"qux":"quz","foo":"bar"}`)},
177 {[]byte{}, []byte(`"foo":"bar"`), []byte(`"foo":"bar"`)},
178 {[]byte(`{"qux":"quz"`), []byte(`"foo":"bar"`), []byte(`{"qux":"quz","foo":"bar"`)},
179 }
180 for _, tt := range tests {
181 t.Run("ObjectData", func(t *testing.T) {
182 if got := enc.AppendObjectData(tt.dst, tt.obj); !reflect.DeepEqual(got, tt.want) {
183 t.Errorf("appendObjectData() = %s, want %s", got, tt.want)
184 }
185 })
186 }
187 }
188
View as plain text