OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2011 The WebRTC Project Authors. All rights reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #ifdef HAVE_DBUS_GLIB | |
12 | |
13 #include <memory> | |
14 | |
15 #include "webrtc/base/dbus.h" | |
16 #include "webrtc/base/gunit.h" | |
17 #include "webrtc/base/thread.h" | |
18 | |
19 namespace rtc { | |
20 | |
21 #define SIG_NAME "NameAcquired" | |
22 | |
23 static const uint32_t kTimeoutMs = 5000U; | |
24 | |
25 class DBusSigFilterTest : public DBusSigFilter { | |
26 public: | |
27 // DBusSigFilterTest listens on DBus service itself for "NameAcquired" signal. | |
28 // This signal should be received when the application connects to DBus | |
29 // service and gains ownership of a name. | |
30 // http://dbus.freedesktop.org/doc/dbus-specification.html | |
31 DBusSigFilterTest() | |
32 : DBusSigFilter(GetFilter()), | |
33 message_received_(false) { | |
34 } | |
35 | |
36 bool MessageReceived() { | |
37 return message_received_; | |
38 } | |
39 | |
40 private: | |
41 static std::string GetFilter() { | |
42 return rtc::DBusSigFilter::BuildFilterString("", "", SIG_NAME); | |
43 } | |
44 | |
45 // Implement virtual method of DBusSigFilter. On caller thread. | |
46 virtual void ProcessSignal(DBusMessage *message) { | |
47 EXPECT_TRUE(message != NULL); | |
48 message_received_ = true; | |
49 } | |
50 | |
51 bool message_received_; | |
52 }; | |
53 | |
54 TEST(DBusMonitorTest, StartStopStartStop) { | |
55 DBusSigFilterTest filter; | |
56 std::unique_ptr<rtc::DBusMonitor> monitor; | |
57 monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM)); | |
58 if (monitor) { | |
59 EXPECT_TRUE(monitor->AddFilter(&filter)); | |
60 | |
61 EXPECT_TRUE(monitor->StopMonitoring()); | |
62 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_NOT_INITIALIZED); | |
63 | |
64 EXPECT_TRUE(monitor->StartMonitoring()); | |
65 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs); | |
66 EXPECT_TRUE(monitor->StopMonitoring()); | |
67 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED); | |
68 EXPECT_TRUE(monitor->StopMonitoring()); | |
69 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED); | |
70 | |
71 EXPECT_TRUE(monitor->StartMonitoring()); | |
72 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs); | |
73 EXPECT_TRUE(monitor->StartMonitoring()); | |
74 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_RUNNING); | |
75 EXPECT_TRUE(monitor->StopMonitoring()); | |
76 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED); | |
77 } else { | |
78 LOG(LS_WARNING) << "DBus Monitor not started. Skipping test."; | |
79 } | |
80 } | |
81 | |
82 // DBusMonitorTest listens on DBus service itself for "NameAcquired" signal. | |
83 // This signal should be received when the application connects to DBus | |
84 // service and gains ownership of a name. | |
85 // This test is to make sure that we capture the "NameAcquired" signal. | |
86 TEST(DBusMonitorTest, ReceivedNameAcquiredSignal) { | |
87 DBusSigFilterTest filter; | |
88 std::unique_ptr<rtc::DBusMonitor> monitor; | |
89 monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM)); | |
90 if (monitor) { | |
91 EXPECT_TRUE(monitor->AddFilter(&filter)); | |
92 | |
93 EXPECT_TRUE(monitor->StartMonitoring()); | |
94 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs); | |
95 EXPECT_TRUE_WAIT(filter.MessageReceived(), kTimeoutMs); | |
96 EXPECT_TRUE(monitor->StopMonitoring()); | |
97 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED); | |
98 } else { | |
99 LOG(LS_WARNING) << "DBus Monitor not started. Skipping test."; | |
100 } | |
101 } | |
102 | |
103 TEST(DBusMonitorTest, ConcurrentMonitors) { | |
104 DBusSigFilterTest filter1; | |
105 std::unique_ptr<rtc::DBusMonitor> monitor1; | |
106 monitor1.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM)); | |
107 if (monitor1) { | |
108 EXPECT_TRUE(monitor1->AddFilter(&filter1)); | |
109 DBusSigFilterTest filter2; | |
110 std::unique_ptr<rtc::DBusMonitor> monitor2; | |
111 monitor2.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM)); | |
112 EXPECT_TRUE(monitor2->AddFilter(&filter2)); | |
113 | |
114 EXPECT_TRUE(monitor1->StartMonitoring()); | |
115 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor1->GetStatus(), kTimeoutMs); | |
116 EXPECT_TRUE(monitor2->StartMonitoring()); | |
117 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor2->GetStatus(), kTimeoutMs); | |
118 | |
119 EXPECT_TRUE_WAIT(filter2.MessageReceived(), kTimeoutMs); | |
120 EXPECT_TRUE(monitor2->StopMonitoring()); | |
121 EXPECT_EQ(monitor2->GetStatus(), DBusMonitor::DMS_STOPPED); | |
122 | |
123 EXPECT_TRUE_WAIT(filter1.MessageReceived(), kTimeoutMs); | |
124 EXPECT_TRUE(monitor1->StopMonitoring()); | |
125 EXPECT_EQ(monitor1->GetStatus(), DBusMonitor::DMS_STOPPED); | |
126 } else { | |
127 LOG(LS_WARNING) << "DBus Monitor not started. Skipping test."; | |
128 } | |
129 } | |
130 | |
131 TEST(DBusMonitorTest, ConcurrentFilters) { | |
132 DBusSigFilterTest filter1; | |
133 DBusSigFilterTest filter2; | |
134 std::unique_ptr<rtc::DBusMonitor> monitor; | |
135 monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM)); | |
136 if (monitor) { | |
137 EXPECT_TRUE(monitor->AddFilter(&filter1)); | |
138 EXPECT_TRUE(monitor->AddFilter(&filter2)); | |
139 | |
140 EXPECT_TRUE(monitor->StartMonitoring()); | |
141 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs); | |
142 | |
143 EXPECT_TRUE_WAIT(filter1.MessageReceived(), kTimeoutMs); | |
144 EXPECT_TRUE_WAIT(filter2.MessageReceived(), kTimeoutMs); | |
145 | |
146 EXPECT_TRUE(monitor->StopMonitoring()); | |
147 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED); | |
148 } else { | |
149 LOG(LS_WARNING) << "DBus Monitor not started. Skipping test."; | |
150 } | |
151 } | |
152 | |
153 TEST(DBusMonitorTest, NoAddFilterIfRunning) { | |
154 DBusSigFilterTest filter1; | |
155 DBusSigFilterTest filter2; | |
156 std::unique_ptr<rtc::DBusMonitor> monitor; | |
157 monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM)); | |
158 if (monitor) { | |
159 EXPECT_TRUE(monitor->AddFilter(&filter1)); | |
160 | |
161 EXPECT_TRUE(monitor->StartMonitoring()); | |
162 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs); | |
163 EXPECT_FALSE(monitor->AddFilter(&filter2)); | |
164 | |
165 EXPECT_TRUE(monitor->StopMonitoring()); | |
166 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED); | |
167 } else { | |
168 LOG(LS_WARNING) << "DBus Monitor not started. Skipping test."; | |
169 } | |
170 } | |
171 | |
172 TEST(DBusMonitorTest, AddFilterAfterStop) { | |
173 DBusSigFilterTest filter1; | |
174 DBusSigFilterTest filter2; | |
175 std::unique_ptr<rtc::DBusMonitor> monitor; | |
176 monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM)); | |
177 if (monitor) { | |
178 EXPECT_TRUE(monitor->AddFilter(&filter1)); | |
179 EXPECT_TRUE(monitor->StartMonitoring()); | |
180 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs); | |
181 EXPECT_TRUE_WAIT(filter1.MessageReceived(), kTimeoutMs); | |
182 EXPECT_TRUE(monitor->StopMonitoring()); | |
183 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED); | |
184 | |
185 EXPECT_TRUE(monitor->AddFilter(&filter2)); | |
186 EXPECT_TRUE(monitor->StartMonitoring()); | |
187 EXPECT_EQ_WAIT(DBusMonitor::DMS_RUNNING, monitor->GetStatus(), kTimeoutMs); | |
188 EXPECT_TRUE_WAIT(filter1.MessageReceived(), kTimeoutMs); | |
189 EXPECT_TRUE_WAIT(filter2.MessageReceived(), kTimeoutMs); | |
190 EXPECT_TRUE(monitor->StopMonitoring()); | |
191 EXPECT_EQ(monitor->GetStatus(), DBusMonitor::DMS_STOPPED); | |
192 } else { | |
193 LOG(LS_WARNING) << "DBus Monitor not started. Skipping test."; | |
194 } | |
195 } | |
196 | |
197 TEST(DBusMonitorTest, StopRightAfterStart) { | |
198 DBusSigFilterTest filter; | |
199 std::unique_ptr<rtc::DBusMonitor> monitor; | |
200 monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM)); | |
201 if (monitor) { | |
202 EXPECT_TRUE(monitor->AddFilter(&filter)); | |
203 | |
204 EXPECT_TRUE(monitor->StartMonitoring()); | |
205 EXPECT_TRUE(monitor->StopMonitoring()); | |
206 | |
207 // Stop the monitoring thread right after it had been started. | |
208 // If the monitoring thread got a chance to receive a DBus signal, it would | |
209 // post a message to the main thread and signal the main thread wakeup. | |
210 // This message will be cleaned out automatically when the filter get | |
211 // destructed. Here we also consume the wakeup signal (if there is one) so | |
212 // that the testing (main) thread is reset to a clean state. | |
213 rtc::Thread::Current()->ProcessMessages(1); | |
214 } else { | |
215 LOG(LS_WARNING) << "DBus Monitor not started."; | |
216 } | |
217 } | |
218 | |
219 TEST(DBusSigFilter, BuildFilterString) { | |
220 EXPECT_EQ(DBusSigFilter::BuildFilterString("", "", ""), | |
221 (DBUS_TYPE "='" DBUS_SIGNAL "'")); | |
222 EXPECT_EQ(DBusSigFilter::BuildFilterString("p", "", ""), | |
223 (DBUS_TYPE "='" DBUS_SIGNAL "'," DBUS_PATH "='p'")); | |
224 EXPECT_EQ(DBusSigFilter::BuildFilterString("p","i", ""), | |
225 (DBUS_TYPE "='" DBUS_SIGNAL "'," DBUS_PATH "='p'," | |
226 DBUS_INTERFACE "='i'")); | |
227 EXPECT_EQ(DBusSigFilter::BuildFilterString("p","i","m"), | |
228 (DBUS_TYPE "='" DBUS_SIGNAL "'," DBUS_PATH "='p'," | |
229 DBUS_INTERFACE "='i'," DBUS_MEMBER "='m'")); | |
230 } | |
231 | |
232 } // namespace rtc | |
233 | |
234 #endif // HAVE_DBUS_GLIB | |
OLD | NEW |