← Back to branch summary

~nskaggs/+junk/juju-packaging-test

« back to all changes in this revision

Viewing changes to src/github.com/godbus/dbus/conn_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-27 20:23:11 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161027202311-sux4jk2o73p1d6rg
Re-add src

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/godbus/dbus/conn_test.go
 
1
package dbus
 
2
 
 
3
import "testing"
 
4
 
 
5
func TestSessionBus(t *testing.T) {
 
6
        _, err := SessionBus()
 
7
        if err != nil {
 
8
                t.Error(err)
 
9
        }
 
10
}
 
11
 
 
12
func TestSystemBus(t *testing.T) {
 
13
        _, err := SystemBus()
 
14
        if err != nil {
 
15
                t.Error(err)
 
16
        }
 
17
}
 
18
 
 
19
func TestSend(t *testing.T) {
 
20
        bus, err := SessionBus()
 
21
        if err != nil {
 
22
                t.Error(err)
 
23
        }
 
24
        ch := make(chan *Call, 1)
 
25
        msg := &Message{
 
26
                Type:  TypeMethodCall,
 
27
                Flags: 0,
 
28
                Headers: map[HeaderField]Variant{
 
29
                        FieldDestination: MakeVariant(bus.Names()[0]),
 
30
                        FieldPath:        MakeVariant(ObjectPath("/org/freedesktop/DBus")),
 
31
                        FieldInterface:   MakeVariant("org.freedesktop.DBus.Peer"),
 
32
                        FieldMember:      MakeVariant("Ping"),
 
33
                },
 
34
        }
 
35
        call := bus.Send(msg, ch)
 
36
        <-ch
 
37
        if call.Err != nil {
 
38
                t.Error(call.Err)
 
39
        }
 
40
}
 
41
 
 
42
type server struct{}
 
43
 
 
44
func (server) Double(i int64) (int64, *Error) {
 
45
        return 2 * i, nil
 
46
}
 
47
 
 
48
func BenchmarkCall(b *testing.B) {
 
49
        b.StopTimer()
 
50
        var s string
 
51
        bus, err := SessionBus()
 
52
        if err != nil {
 
53
                b.Fatal(err)
 
54
        }
 
55
        name := bus.Names()[0]
 
56
        obj := bus.BusObject()
 
57
        b.StartTimer()
 
58
        for i := 0; i < b.N; i++ {
 
59
                err := obj.Call("org.freedesktop.DBus.GetNameOwner", 0, name).Store(&s)
 
60
                if err != nil {
 
61
                        b.Fatal(err)
 
62
                }
 
63
                if s != name {
 
64
                        b.Errorf("got %s, wanted %s", s, name)
 
65
                }
 
66
        }
 
67
}
 
68
 
 
69
func BenchmarkCallAsync(b *testing.B) {
 
70
        b.StopTimer()
 
71
        bus, err := SessionBus()
 
72
        if err != nil {
 
73
                b.Fatal(err)
 
74
        }
 
75
        name := bus.Names()[0]
 
76
        obj := bus.BusObject()
 
77
        c := make(chan *Call, 50)
 
78
        done := make(chan struct{})
 
79
        go func() {
 
80
                for i := 0; i < b.N; i++ {
 
81
                        v := <-c
 
82
                        if v.Err != nil {
 
83
                                b.Error(v.Err)
 
84
                        }
 
85
                        s := v.Body[0].(string)
 
86
                        if s != name {
 
87
                                b.Errorf("got %s, wanted %s", s, name)
 
88
                        }
 
89
                }
 
90
                close(done)
 
91
        }()
 
92
        b.StartTimer()
 
93
        for i := 0; i < b.N; i++ {
 
94
                obj.Go("org.freedesktop.DBus.GetNameOwner", 0, c, name)
 
95
        }
 
96
        <-done
 
97
}
 
98
 
 
99
func BenchmarkServe(b *testing.B) {
 
100
        b.StopTimer()
 
101
        srv, err := SessionBus()
 
102
        if err != nil {
 
103
                b.Fatal(err)
 
104
        }
 
105
        cli, err := SessionBusPrivate()
 
106
        if err != nil {
 
107
                b.Fatal(err)
 
108
        }
 
109
        if err = cli.Auth(nil); err != nil {
 
110
                b.Fatal(err)
 
111
        }
 
112
        if err = cli.Hello(); err != nil {
 
113
                b.Fatal(err)
 
114
        }
 
115
        benchmarkServe(b, srv, cli)
 
116
}
 
117
 
 
118
func BenchmarkServeAsync(b *testing.B) {
 
119
        b.StopTimer()
 
120
        srv, err := SessionBus()
 
121
        if err != nil {
 
122
                b.Fatal(err)
 
123
        }
 
124
        cli, err := SessionBusPrivate()
 
125
        if err != nil {
 
126
                b.Fatal(err)
 
127
        }
 
128
        if err = cli.Auth(nil); err != nil {
 
129
                b.Fatal(err)
 
130
        }
 
131
        if err = cli.Hello(); err != nil {
 
132
                b.Fatal(err)
 
133
        }
 
134
        benchmarkServeAsync(b, srv, cli)
 
135
}
 
136
 
 
137
func BenchmarkServeSameConn(b *testing.B) {
 
138
        b.StopTimer()
 
139
        bus, err := SessionBus()
 
140
        if err != nil {
 
141
                b.Fatal(err)
 
142
        }
 
143
 
 
144
        benchmarkServe(b, bus, bus)
 
145
}
 
146
 
 
147
func BenchmarkServeSameConnAsync(b *testing.B) {
 
148
        b.StopTimer()
 
149
        bus, err := SessionBus()
 
150
        if err != nil {
 
151
                b.Fatal(err)
 
152
        }
 
153
 
 
154
        benchmarkServeAsync(b, bus, bus)
 
155
}
 
156
 
 
157
func benchmarkServe(b *testing.B, srv, cli *Conn) {
 
158
        var r int64
 
159
        var err error
 
160
        dest := srv.Names()[0]
 
161
        srv.Export(server{}, "/org/guelfey/DBus/Test", "org.guelfey.DBus.Test")
 
162
        obj := cli.Object(dest, "/org/guelfey/DBus/Test")
 
163
        b.StartTimer()
 
164
        for i := 0; i < b.N; i++ {
 
165
                err = obj.Call("org.guelfey.DBus.Test.Double", 0, int64(i)).Store(&r)
 
166
                if err != nil {
 
167
                        b.Fatal(err)
 
168
                }
 
169
                if r != 2*int64(i) {
 
170
                        b.Errorf("got %d, wanted %d", r, 2*int64(i))
 
171
                }
 
172
        }
 
173
}
 
174
 
 
175
func benchmarkServeAsync(b *testing.B, srv, cli *Conn) {
 
176
        dest := srv.Names()[0]
 
177
        srv.Export(server{}, "/org/guelfey/DBus/Test", "org.guelfey.DBus.Test")
 
178
        obj := cli.Object(dest, "/org/guelfey/DBus/Test")
 
179
        c := make(chan *Call, 50)
 
180
        done := make(chan struct{})
 
181
        go func() {
 
182
                for i := 0; i < b.N; i++ {
 
183
                        v := <-c
 
184
                        if v.Err != nil {
 
185
                                b.Fatal(v.Err)
 
186
                        }
 
187
                        i, r := v.Args[0].(int64), v.Body[0].(int64)
 
188
                        if 2*i != r {
 
189
                                b.Errorf("got %d, wanted %d", r, 2*i)
 
190
                        }
 
191
                }
 
192
                close(done)
 
193
        }()
 
194
        b.StartTimer()
 
195
        for i := 0; i < b.N; i++ {
 
196
                obj.Go("org.guelfey.DBus.Test.Double", 0, c, int64(i))
 
197
        }
 
198
        <-done
 
199
}