1 package cbor
2
3 import (
4 "bytes"
5 "encoding/hex"
6 "testing"
7 "time"
8 )
9
10 func TestDecodeInteger(t *testing.T) {
11 for _, tc := range integerTestCases {
12 gotv := decodeInteger(getReader(tc.binary))
13 if gotv != int64(tc.val) {
14 t.Errorf("decodeInteger(0x%s)=0x%d, want: 0x%d",
15 hex.EncodeToString([]byte(tc.binary)), gotv, tc.val)
16 }
17 }
18 }
19
20 func TestDecodeString(t *testing.T) {
21 for _, tt := range encodeStringTests {
22 got := decodeUTF8String(getReader(tt.binary))
23 if string(got) != "\""+tt.json+"\"" {
24 t.Errorf("DecodeString(0x%s)=%s, want:\"%s\"\n", hex.EncodeToString([]byte(tt.binary)), string(got),
25 hex.EncodeToString([]byte(tt.json)))
26 }
27 }
28 }
29
30 func TestDecodeArray(t *testing.T) {
31 for _, tc := range integerArrayTestCases {
32 buf := bytes.NewBuffer([]byte{})
33 array2Json(getReader(tc.binary), buf)
34 if buf.String() != tc.json {
35 t.Errorf("array2Json(0x%s)=%s, want: %s", hex.EncodeToString([]byte(tc.binary)), buf.String(), tc.json)
36 }
37 }
38
39 var infiniteArrayTestCases = []struct {
40 in string
41 out string
42 }{
43 {"\x9f\x20\x00\x18\xc8\x14\xff", "[-1,0,200,20]"},
44 {"\x9f\x38\xc7\x29\x18\xc8\x19\x01\x90\xff", "[-200,-10,200,400]"},
45 {"\x9f\x01\x02\x03\xff", "[1,2,3]"},
46 {"\x9f\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x18\x18\x19\xff",
47 "[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]"},
48 }
49 for _, tc := range infiniteArrayTestCases {
50 buf := bytes.NewBuffer([]byte{})
51 array2Json(getReader(tc.in), buf)
52 if buf.String() != tc.out {
53 t.Errorf("array2Json(0x%s)=%s, want: %s", hex.EncodeToString([]byte(tc.out)), buf.String(), tc.out)
54 }
55 }
56 for _, tc := range booleanArrayTestCases {
57 buf := bytes.NewBuffer([]byte{})
58 array2Json(getReader(tc.binary), buf)
59 if buf.String() != tc.json {
60 t.Errorf("array2Json(0x%s)=%s, want: %s", hex.EncodeToString([]byte(tc.binary)), buf.String(), tc.json)
61 }
62 }
63
64 }
65
66 var infiniteMapDecodeTestCases = []struct {
67 bin []byte
68 json string
69 }{
70 {[]byte("\xbf\x64IETF\x20\xff"), "{\"IETF\":-1}"},
71 {[]byte("\xbf\x65Array\x84\x20\x00\x18\xc8\x14\xff"), "{\"Array\":[-1,0,200,20]}"},
72 }
73
74 var mapDecodeTestCases = []struct {
75 bin []byte
76 json string
77 }{
78 {[]byte("\xa2\x64IETF\x20"), "{\"IETF\":-1}"},
79 {[]byte("\xa2\x65Array\x84\x20\x00\x18\xc8\x14"), "{\"Array\":[-1,0,200,20]}"},
80 }
81
82 func TestDecodeMap(t *testing.T) {
83 for _, tc := range mapDecodeTestCases {
84 buf := bytes.NewBuffer([]byte{})
85 map2Json(getReader(string(tc.bin)), buf)
86 if buf.String() != tc.json {
87 t.Errorf("map2Json(0x%s)=%s, want: %s", hex.EncodeToString(tc.bin), buf.String(), tc.json)
88 }
89 }
90 for _, tc := range infiniteMapDecodeTestCases {
91 buf := bytes.NewBuffer([]byte{})
92 map2Json(getReader(string(tc.bin)), buf)
93 if buf.String() != tc.json {
94 t.Errorf("map2Json(0x%s)=%s, want: %s", hex.EncodeToString(tc.bin), buf.String(), tc.json)
95 }
96 }
97 }
98
99 func TestDecodeBool(t *testing.T) {
100 for _, tc := range booleanTestCases {
101 got := decodeSimpleFloat(getReader(tc.binary))
102 if string(got) != tc.json {
103 t.Errorf("decodeSimpleFloat(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), string(got), tc.json)
104 }
105 }
106 }
107
108 func TestDecodeFloat(t *testing.T) {
109 for _, tc := range float32TestCases {
110 got, _ := decodeFloat(getReader(tc.binary))
111 if got != float64(tc.val) {
112 t.Errorf("decodeFloat(0x%s)=%f, want:%f", hex.EncodeToString([]byte(tc.binary)), got, tc.val)
113 }
114 }
115 }
116
117 func TestDecodeTimestamp(t *testing.T) {
118 decodeTimeZone, _ = time.LoadLocation("UTC")
119 for _, tc := range timeIntegerTestcases {
120 tm := decodeTagData(getReader(tc.binary))
121 if string(tm) != "\""+tc.rfcStr+"\"" {
122 t.Errorf("decodeFloat(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), tm, tc.rfcStr)
123 }
124 }
125 for _, tc := range timeFloatTestcases {
126 tm := decodeTagData(getReader(tc.out))
127
128
129
130
131 got, _ := time.Parse(string(tm), string(tm))
132 want, _ := time.Parse(tc.rfcStr, tc.rfcStr)
133 if got.Sub(want) > time.Microsecond {
134 t.Errorf("decodeFloat(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.out)), tm, tc.rfcStr)
135 }
136 }
137 }
138
139 func TestDecodeNetworkAddr(t *testing.T) {
140 for _, tc := range ipAddrTestCases {
141 d1 := decodeTagData(getReader(tc.binary))
142 if string(d1) != tc.text {
143 t.Errorf("decodeNetworkAddr(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), d1, tc.text)
144 }
145 }
146 }
147
148 func TestDecodeMACAddr(t *testing.T) {
149 for _, tc := range macAddrTestCases {
150 d1 := decodeTagData(getReader(tc.binary))
151 if string(d1) != tc.text {
152 t.Errorf("decodeNetworkAddr(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), d1, tc.text)
153 }
154 }
155 }
156
157 func TestDecodeIPPrefix(t *testing.T) {
158 for _, tc := range IPPrefixTestCases {
159 d1 := decodeTagData(getReader(tc.binary))
160 if string(d1) != tc.text {
161 t.Errorf("decodeIPPrefix(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), d1, tc.text)
162 }
163 }
164 }
165
166 var compositeCborTestCases = []struct {
167 binary []byte
168 json string
169 }{
170 {[]byte("\xbf\x64IETF\x20\x65Array\x9f\x20\x00\x18\xc8\x14\xff\xff"), "{\"IETF\":-1,\"Array\":[-1,0,200,20]}\n"},
171 {[]byte("\xbf\x64IETF\x64YES!\x65Array\x9f\x20\x00\x18\xc8\x14\xff\xff"), "{\"IETF\":\"YES!\",\"Array\":[-1,0,200,20]}\n"},
172 }
173
174 func TestDecodeCbor2Json(t *testing.T) {
175 for _, tc := range compositeCborTestCases {
176 buf := bytes.NewBuffer([]byte{})
177 err := Cbor2JsonManyObjects(getReader(string(tc.binary)), buf)
178 if buf.String() != tc.json || err != nil {
179 t.Errorf("cbor2JsonManyObjects(0x%s)=%s, want: %s, err:%s", hex.EncodeToString(tc.binary), buf.String(), tc.json, err.Error())
180 }
181 }
182 }
183
184 var negativeCborTestCases = []struct {
185 binary []byte
186 errStr string
187 }{
188 {[]byte("\xb9\x64IETF\x20\x65Array\x9f\x20\x00\x18\xc8\x14"), "Tried to Read 18 Bytes.. But hit end of file"},
189 {[]byte("\xbf\x64IETF\x20\x65Array\x9f\x20\x00\x18\xc8\x14"), "EOF"},
190 {[]byte("\xbf\x14IETF\x20\x65Array\x9f\x20\x00\x18\xc8\x14"), "Tried to Read 40736 Bytes.. But hit end of file"},
191 {[]byte("\xbf\x64IETF"), "EOF"},
192 {[]byte("\xbf\x64IETF\x20\x65Array\x9f\x20\x00\x18\xc8\xff\xff\xff"), "Invalid Additional Type: 31 in decodeSimpleFloat"},
193 {[]byte("\xbf\x64IETF\x20\x65Array"), "EOF"},
194 {[]byte("\xbf\x64"), "Tried to Read 4 Bytes.. But hit end of file"},
195 }
196
197 func TestDecodeNegativeCbor2Json(t *testing.T) {
198 for _, tc := range negativeCborTestCases {
199 buf := bytes.NewBuffer([]byte{})
200 err := Cbor2JsonManyObjects(getReader(string(tc.binary)), buf)
201 if err == nil || err.Error() != tc.errStr {
202 t.Errorf("Expected error got:%s, want:%s", err, tc.errStr)
203 }
204 }
205 }
206
View as plain text