1 package dbus
2
3 import (
4 "bytes"
5 "encoding/binary"
6 "reflect"
7 "testing"
8 )
9
10 func TestEncodeArrayOfMaps(t *testing.T) {
11 tests := []struct {
12 name string
13 vs []interface{}
14 }{
15 {
16 "aligned at 8 at start of array",
17 []interface{}{
18 "12345",
19 []map[string]Variant{
20 {
21 "abcdefg": MakeVariant("foo"),
22 "cdef": MakeVariant(uint32(2)),
23 },
24 },
25 },
26 },
27 {
28 "not aligned at 8 for start of array",
29 []interface{}{
30 "1234567890",
31 []map[string]Variant{
32 {
33 "abcdefg": MakeVariant("foo"),
34 "cdef": MakeVariant(uint32(2)),
35 },
36 },
37 },
38 },
39 }
40 for _, order := range []binary.ByteOrder{binary.LittleEndian, binary.BigEndian} {
41 for _, tt := range tests {
42 buf := new(bytes.Buffer)
43 fds := make([]int, 0)
44 enc := newEncoder(buf, order, fds)
45 enc.Encode(tt.vs...)
46
47 dec := newDecoder(buf, order, enc.fds)
48 v, err := dec.Decode(SignatureOf(tt.vs...))
49 if err != nil {
50 t.Errorf("%q: decode (%v) failed: %v", tt.name, order, err)
51 continue
52 }
53 if !reflect.DeepEqual(v, tt.vs) {
54 t.Errorf("%q: (%v) not equal: got '%v', want '%v'", tt.name, order, v, tt.vs)
55 continue
56 }
57 }
58 }
59 }
60
61 func TestEncodeMapStringInterface(t *testing.T) {
62 val := map[string]interface{}{"foo": "bar"}
63 buf := new(bytes.Buffer)
64 fds := make([]int, 0)
65 order := binary.LittleEndian
66 enc := newEncoder(buf, binary.LittleEndian, fds)
67 err := enc.Encode(val)
68 if err != nil {
69 t.Fatal(err)
70 }
71
72 dec := newDecoder(buf, order, enc.fds)
73 v, err := dec.Decode(SignatureOf(val))
74 if err != nil {
75 t.Fatal(err)
76 }
77 out := map[string]interface{}{}
78 Store(v, &out)
79 if !reflect.DeepEqual(out, val) {
80 t.Errorf("not equal: got '%v', want '%v'",
81 out, val)
82 }
83 }
84
85 type empty interface{}
86
87 func TestEncodeMapStringNamedInterface(t *testing.T) {
88 val := map[string]empty{"foo": "bar"}
89 buf := new(bytes.Buffer)
90 fds := make([]int, 0)
91 order := binary.LittleEndian
92 enc := newEncoder(buf, binary.LittleEndian, fds)
93 err := enc.Encode(val)
94 if err != nil {
95 t.Fatal(err)
96 }
97
98 dec := newDecoder(buf, order, enc.fds)
99 v, err := dec.Decode(SignatureOf(val))
100 if err != nil {
101 t.Fatal(err)
102 }
103 out := map[string]empty{}
104 Store(v, &out)
105 if !reflect.DeepEqual(out, val) {
106 t.Errorf("not equal: got '%v', want '%v'",
107 out, val)
108 }
109 }
110
111 type fooer interface {
112 Foo()
113 }
114
115 type fooimpl string
116
117 func (fooimpl) Foo() {}
118
119 func TestEncodeMapStringNonEmptyInterface(t *testing.T) {
120 val := map[string]fooer{"foo": fooimpl("bar")}
121 buf := new(bytes.Buffer)
122 fds := make([]int, 0)
123 order := binary.LittleEndian
124 enc := newEncoder(buf, binary.LittleEndian, fds)
125 err := enc.Encode(val)
126 if err != nil {
127 t.Fatal(err)
128 }
129
130 dec := newDecoder(buf, order, enc.fds)
131 v, err := dec.Decode(SignatureOf(val))
132 if err != nil {
133 t.Fatal(err)
134 }
135 out := map[string]fooer{}
136 err = Store(v, &out)
137 if err == nil {
138 t.Fatal("Shouldn't be able to convert to non empty interfaces")
139 }
140 }
141
142 func TestEncodeSliceInterface(t *testing.T) {
143 val := []interface{}{"foo", "bar"}
144 buf := new(bytes.Buffer)
145 fds := make([]int, 0)
146 order := binary.LittleEndian
147 enc := newEncoder(buf, binary.LittleEndian, fds)
148 err := enc.Encode(val)
149 if err != nil {
150 t.Fatal(err)
151 }
152
153 dec := newDecoder(buf, order, enc.fds)
154 v, err := dec.Decode(SignatureOf(val))
155 if err != nil {
156 t.Fatal(err)
157 }
158 out := []interface{}{}
159 Store(v, &out)
160 if !reflect.DeepEqual(out, val) {
161 t.Errorf("not equal: got '%v', want '%v'",
162 out, val)
163 }
164 }
165
166 func TestEncodeSliceNamedInterface(t *testing.T) {
167 val := []empty{"foo", "bar"}
168 buf := new(bytes.Buffer)
169 fds := make([]int, 0)
170 order := binary.LittleEndian
171 enc := newEncoder(buf, binary.LittleEndian, fds)
172 err := enc.Encode(val)
173 if err != nil {
174 t.Fatal(err)
175 }
176
177 dec := newDecoder(buf, order, enc.fds)
178 v, err := dec.Decode(SignatureOf(val))
179 if err != nil {
180 t.Fatal(err)
181 }
182 out := []empty{}
183 Store(v, &out)
184 if !reflect.DeepEqual(out, val) {
185 t.Errorf("not equal: got '%v', want '%v'",
186 out, val)
187 }
188 }
189
190 func TestEncodeNestedInterface(t *testing.T) {
191 val := map[string]interface{}{
192 "foo": []interface{}{"1", "2", "3", "5",
193 map[string]interface{}{
194 "bar": "baz",
195 },
196 },
197 "bar": map[string]interface{}{
198 "baz": "quux",
199 "quux": "quuz",
200 },
201 }
202 buf := new(bytes.Buffer)
203 fds := make([]int, 0)
204 order := binary.LittleEndian
205 enc := newEncoder(buf, binary.LittleEndian, fds)
206 err := enc.Encode(val)
207 if err != nil {
208 t.Fatal(err)
209 }
210
211 dec := newDecoder(buf, order, enc.fds)
212 v, err := dec.Decode(SignatureOf(val))
213 if err != nil {
214 t.Fatal(err)
215 }
216 out := map[string]interface{}{}
217 Store(v, &out)
218 if !reflect.DeepEqual(out, val) {
219 t.Errorf("not equal: got '%#v', want '%#v'",
220 out, val)
221 }
222 }
223
224 func TestEncodeInt(t *testing.T) {
225 val := 10
226 buf := new(bytes.Buffer)
227 fds := make([]int, 0)
228 order := binary.LittleEndian
229 enc := newEncoder(buf, binary.LittleEndian, fds)
230 err := enc.Encode(val)
231 if err != nil {
232 t.Fatal(err)
233 }
234
235 dec := newDecoder(buf, order, enc.fds)
236 v, err := dec.Decode(SignatureOf(val))
237 if err != nil {
238 t.Fatal(err)
239 }
240 var out int
241 Store(v, &out)
242 if !reflect.DeepEqual(out, val) {
243 t.Errorf("not equal: got '%v', want '%v'",
244 out, val)
245 }
246 }
247
248 func TestEncodeIntToNonCovertible(t *testing.T) {
249 val := 150
250 buf := new(bytes.Buffer)
251 fds := make([]int, 0)
252 order := binary.LittleEndian
253 enc := newEncoder(buf, binary.LittleEndian, fds)
254 err := enc.Encode(val)
255 if err != nil {
256 t.Fatal(err)
257 }
258
259 dec := newDecoder(buf, order, enc.fds)
260 v, err := dec.Decode(SignatureOf(val))
261 if err != nil {
262 t.Fatal(err)
263 }
264 var out bool
265 err = Store(v, &out)
266 if err == nil {
267 t.Logf("%t\n", out)
268 t.Fatal("Type mismatch should have occurred")
269 }
270 }
271
272 func TestEncodeUint(t *testing.T) {
273 val := uint(10)
274 buf := new(bytes.Buffer)
275 fds := make([]int, 0)
276 order := binary.LittleEndian
277 enc := newEncoder(buf, binary.LittleEndian, fds)
278 err := enc.Encode(val)
279 if err != nil {
280 t.Fatal(err)
281 }
282
283 dec := newDecoder(buf, order, enc.fds)
284 v, err := dec.Decode(SignatureOf(val))
285 if err != nil {
286 t.Fatal(err)
287 }
288 var out uint
289 Store(v, &out)
290 if !reflect.DeepEqual(out, val) {
291 t.Errorf("not equal: got '%v', want '%v'",
292 out, val)
293 }
294 }
295
296 func TestEncodeUintToNonCovertible(t *testing.T) {
297 val := uint(10)
298 buf := new(bytes.Buffer)
299 fds := make([]int, 0)
300 order := binary.LittleEndian
301 enc := newEncoder(buf, binary.LittleEndian, fds)
302 err := enc.Encode(val)
303 if err != nil {
304 t.Fatal(err)
305 }
306
307 dec := newDecoder(buf, order, enc.fds)
308 v, err := dec.Decode(SignatureOf(val))
309 if err != nil {
310 t.Fatal(err)
311 }
312 var out bool
313 err = Store(v, &out)
314 if err == nil {
315 t.Fatal("Type mismatch should have occurred")
316 }
317 }
318
319 type boolean bool
320
321 func TestEncodeOfAssignableType(t *testing.T) {
322 val := boolean(true)
323 buf := new(bytes.Buffer)
324 fds := make([]int, 0)
325 order := binary.LittleEndian
326 enc := newEncoder(buf, binary.LittleEndian, fds)
327 err := enc.Encode(val)
328 if err != nil {
329 t.Fatal(err)
330 }
331
332 dec := newDecoder(buf, order, enc.fds)
333 v, err := dec.Decode(SignatureOf(val))
334 if err != nil {
335 t.Fatal(err)
336 }
337 var out boolean
338 err = Store(v, &out)
339 if err != nil {
340 t.Fatal(err)
341 }
342 if !reflect.DeepEqual(out, val) {
343 t.Errorf("not equal: got '%v', want '%v'",
344 out, val)
345 }
346 }
347
348 func TestEncodeVariant(t *testing.T) {
349 var res map[ObjectPath]map[string]map[string]Variant
350 var src = map[ObjectPath]map[string]map[string]Variant{
351 ObjectPath("/foo/bar"): {
352 "foo": {
353 "bar": MakeVariant(10),
354 "baz": MakeVariant("20"),
355 },
356 },
357 }
358 buf := new(bytes.Buffer)
359 fds := make([]int, 0)
360 order := binary.LittleEndian
361 enc := newEncoder(buf, binary.LittleEndian, fds)
362 err := enc.Encode(src)
363 if err != nil {
364 t.Fatal(err)
365 }
366
367 dec := newDecoder(buf, order, enc.fds)
368 v, err := dec.Decode(SignatureOf(src))
369 if err != nil {
370 t.Fatal(err)
371 }
372 err = Store(v, &res)
373 if err != nil {
374 t.Fatal(err)
375 }
376 _ = res[ObjectPath("/foo/bar")]["foo"]["baz"].Value().(string)
377 }
378
379 func TestEncodeVariantToList(t *testing.T) {
380 var res map[string]Variant
381 var src = map[string]interface{}{
382 "foo": []interface{}{"a", "b", "c"},
383 }
384 buf := new(bytes.Buffer)
385 fds := make([]int, 0)
386 order := binary.LittleEndian
387 enc := newEncoder(buf, binary.LittleEndian, fds)
388 err := enc.Encode(src)
389 if err != nil {
390 t.Fatal(err)
391 }
392
393 dec := newDecoder(buf, order, enc.fds)
394 v, err := dec.Decode(SignatureOf(src))
395 if err != nil {
396 t.Fatal(err)
397 }
398 err = Store(v, &res)
399 if err != nil {
400 t.Fatal(err)
401 }
402 _ = res["foo"].Value().([]Variant)
403 }
404
405 func TestEncodeVariantToUint64(t *testing.T) {
406 var res map[string]Variant
407 var src = map[string]interface{}{
408 "foo": uint64(10),
409 }
410 buf := new(bytes.Buffer)
411 fds := make([]int, 0)
412 order := binary.LittleEndian
413 enc := newEncoder(buf, binary.LittleEndian, fds)
414 err := enc.Encode(src)
415 if err != nil {
416 t.Fatal(err)
417 }
418
419 dec := newDecoder(buf, order, enc.fds)
420 v, err := dec.Decode(SignatureOf(src))
421 if err != nil {
422 t.Fatal(err)
423 }
424 err = Store(v, &res)
425 if err != nil {
426 t.Fatal(err)
427 }
428 _ = res["foo"].Value().(uint64)
429 }
430
View as plain text