1 package dbus
2
3 import "reflect"
4 import "testing"
5
6 var variantFormatTests = []struct {
7 v interface{}
8 s string
9 }{
10 {int32(1), `1`},
11 {"foo", `"foo"`},
12 {ObjectPath("/org/foo"), `@o "/org/foo"`},
13 {Signature{"i"}, `@g "i"`},
14 {[]byte{}, `@ay []`},
15 {[]int32{1, 2}, `[1, 2]`},
16 {[]int64{1, 2}, `@ax [1, 2]`},
17 {[][]int32{{3, 4}, {5, 6}}, `[[3, 4], [5, 6]]`},
18 {[]Variant{MakeVariant(int32(1)), MakeVariant(1.0)}, `[<1>, <@d 1>]`},
19 {map[string]int32{"one": 1, "two": 2}, `{"one": 1, "two": 2}`},
20 {map[int32]ObjectPath{1: "/org/foo"}, `@a{io} {1: "/org/foo"}`},
21 {map[string]Variant{}, `@a{sv} {}`},
22 }
23
24 func TestFormatVariant(t *testing.T) {
25 for i, v := range variantFormatTests {
26 if s := MakeVariant(v.v).String(); s != v.s {
27 t.Errorf("test %d: got %q, wanted %q", i+1, s, v.s)
28 }
29 }
30 }
31
32 var variantParseTests = []struct {
33 s string
34 v interface{}
35 }{
36 {"1", int32(1)},
37 {"true", true},
38 {"false", false},
39 {"1.0", float64(1.0)},
40 {"0x10", int32(16)},
41 {"1e1", float64(10)},
42 {`"foo"`, "foo"},
43 {`"\a\b\f\n\r\t"`, "\x07\x08\x0c\n\r\t"},
44 {`"\u00e4\U0001f603"`, "\u00e4\U0001f603"},
45 {"[1]", []int32{1}},
46 {"[1, 2, 3]", []int32{1, 2, 3}},
47 {"@ai []", []int32{}},
48 {"[1, 5.0]", []float64{1, 5.0}},
49 {"[[1, 2], [3, 4.0]]", [][]float64{{1, 2}, {3, 4}}},
50 {`[@o "/org/foo", "/org/bar"]`, []ObjectPath{"/org/foo", "/org/bar"}},
51 {"<1>", MakeVariant(int32(1))},
52 {"[<1>, <2.0>]", []Variant{MakeVariant(int32(1)), MakeVariant(2.0)}},
53 {`[[], [""]]`, [][]string{{}, {""}}},
54 {`@a{ss} {}`, map[string]string{}},
55 {`{"foo": 1}`, map[string]int32{"foo": 1}},
56 {`[{}, {"foo": "bar"}]`, []map[string]string{{}, {"foo": "bar"}}},
57 {`{"a": <1>, "b": <"foo">}`,
58 map[string]Variant{"a": MakeVariant(int32(1)), "b": MakeVariant("foo")}},
59 {`b''`, []byte{0}},
60 {`b"abc"`, []byte{'a', 'b', 'c', 0}},
61 {`b"\x01\0002\a\b\f\n\r\t"`, []byte{1, 2, 0x7, 0x8, 0xc, '\n', '\r', '\t', 0}},
62 {`[[0], b""]`, [][]byte{{0}, {0}}},
63 {"int16 0", int16(0)},
64 {"byte 0", byte(0)},
65 }
66
67 func TestParseVariant(t *testing.T) {
68 for i, v := range variantParseTests {
69 nv, err := ParseVariant(v.s, Signature{})
70 if err != nil {
71 t.Errorf("test %d: parsing failed: %s", i+1, err)
72 continue
73 }
74 if !reflect.DeepEqual(nv.value, v.v) {
75 t.Errorf("test %d: got %q, wanted %q", i+1, nv, v.v)
76 }
77 }
78 }
79
80 func TestVariantStore(t *testing.T) {
81 str := "foo bar"
82 v := MakeVariant(str)
83 var result string
84 err := v.Store(&result)
85 if err != nil {
86 t.Fatal(err)
87 }
88 if result != str {
89 t.Fatalf("expected %s, got %s\n", str, result)
90 }
91
92 }
93
View as plain text