OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "device/battery/battery_status_manager_linux.h" | 5 #include "device/battery/battery_status_manager_linux.h" |
6 | 6 |
7 #include "base/values.h" | 7 #include <limits> |
8 #include <list> | |
9 #include <string> | |
10 | |
11 #include "base/bind.h" | |
12 #include "base/single_thread_task_runner.h" | |
13 #include "base/synchronization/waitable_event.h" | |
14 #include "base/threading/thread.h" | |
15 #include "dbus/mock_bus.h" | |
16 #include "dbus/mock_object_proxy.h" | |
17 #include "dbus/object_path.h" | |
18 #include "dbus/property.h" | |
19 #include "testing/gmock/include/gmock/gmock.h" | |
8 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
9 | 21 |
22 using testing::_; | |
23 using testing::Invoke; | |
24 using testing::NiceMock; | |
25 using testing::Return; | |
26 using testing::Unused; | |
27 | |
10 namespace device { | 28 namespace device { |
11 | 29 |
12 namespace { | 30 namespace { |
13 | 31 const char kUPowerInterfaceName[] = "org.freedesktop.UPower"; |
timvolodine
2016/06/16 16:12:24
A number of constants here duplicate similar const
markuso
2016/06/17 08:45:19
I could move them to the battery_status_manager_li
markuso
2016/06/17 10:01:17
Done.
| |
14 TEST(BatteryStatusManagerLinuxTest, EmptyDictionary) { | 32 const char kUPowerMethodEnumerateDevices[] = "EnumerateDevices"; |
15 base::DictionaryValue dictionary; | 33 const char kUPowerMethodGetDisplayDevice[] = "GetDisplayDevice"; |
34 const char kUPowerPath[] = "/org/freedesktop/UPower"; | |
35 const char kUPowerPropertyDaemonVersion[] = "DaemonVersion"; | |
36 const char kUPowerServiceName[] = "org.freedesktop.UPower"; | |
37 const char kUPowerSignalDeviceAdded[] = "DeviceAdded"; | |
38 const char kUPowerSignalDeviceRemoved[] = "DeviceRemoved"; | |
39 | |
40 const char kUPowerDeviceInterfaceName[] = "org.freedesktop.UPower.Device"; | |
41 const char kUPowerDevicePropertyIsPresent[] = "IsPresent"; | |
42 const char kUPowerDevicePropertyPercentage[] = "Percentage"; | |
43 const char kUPowerDevicePropertyState[] = "State"; | |
44 const char kUPowerDevicePropertyTimeToEmpty[] = "TimeToEmpty"; | |
45 const char kUPowerDevicePropertyTimeToFull[] = "TimeToFull"; | |
46 const char kUPowerDevicePropertyType[] = "Type"; | |
47 const char kUPowerDeviceSignalChanged[] = "Changed"; | |
48 const char kUPowerDeviceACLinePath[] = | |
49 "/org/freedesktop/UPower/devices/line_power_AC"; | |
50 const char kUPowerDeviceBattery0Path[] = | |
51 "/org/freedesktop/UPower/devices/battery_BAT0"; | |
52 const char kUPowerDeviceBattery1Path[] = | |
53 "/org/freedesktop/UPower/devices/battery_BAT1"; | |
54 const char kUPowerDisplayDevicePath[] = | |
55 "/org/freedesktop/UPower/devices/DisplayDevice"; | |
56 | |
57 class MockUPowerObject { | |
58 public: | |
59 MockUPowerObject() {} | |
60 void ConnectToSignal( | |
61 const std::string& interface_name, | |
62 const std::string& signal_name, | |
63 dbus::ObjectProxy::SignalCallback signal_callback, | |
64 dbus::ObjectProxy::OnConnectedCallback on_connected_callback); | |
65 dbus::Response* CreateCallMethodResponse(dbus::MethodCall* method_call, | |
66 Unused); | |
67 void SignalDeviceAdded(const std::string& added_device_path); | |
68 void SignalDeviceRemoved(const std::string& removed_device_path); | |
69 | |
70 scoped_refptr<dbus::MockObjectProxy> proxy; | |
71 dbus::ObjectProxy::SignalCallback signal_callback_device_added; | |
72 dbus::ObjectProxy::SignalCallback signal_callback_device_removed; | |
73 std::string daemon_version; | |
74 std::list<std::string> devices; | |
75 std::string display_device; | |
76 | |
77 private: | |
78 DISALLOW_COPY_AND_ASSIGN(MockUPowerObject); | |
79 }; | |
80 | |
81 void MockUPowerObject::ConnectToSignal( | |
82 const std::string& interface_name, | |
83 const std::string& signal_name, | |
84 dbus::ObjectProxy::SignalCallback signal_callback, | |
85 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) { | |
86 bool on_connected_success = true; | |
87 if (interface_name == kUPowerInterfaceName) { | |
88 if (signal_name == kUPowerSignalDeviceAdded) | |
89 signal_callback_device_added = signal_callback; | |
90 else if (signal_name == kUPowerSignalDeviceRemoved) | |
91 signal_callback_device_removed = signal_callback; | |
92 else | |
93 on_connected_success = false; | |
94 } else { | |
95 on_connected_success = false; | |
96 } | |
97 | |
98 if (!on_connected_success) { | |
99 LOG(WARNING) << "MockUPowerObject::" << __FUNCTION__ | |
100 << " Unexpected interface=" << interface_name | |
101 << ", signal=" << signal_name; | |
102 } | |
103 on_connected_callback.Run(interface_name, signal_name, on_connected_success); | |
104 } | |
105 | |
106 dbus::Response* MockUPowerObject::CreateCallMethodResponse( | |
107 dbus::MethodCall* method_call, | |
108 Unused) { | |
109 if (method_call->GetInterface() == kUPowerInterfaceName) { | |
110 if (method_call->GetMember() == kUPowerMethodEnumerateDevices) { | |
111 std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty(); | |
112 dbus::MessageWriter writer(response.get()); | |
113 dbus::MessageWriter array_writer(nullptr); | |
114 writer.OpenArray("o", &array_writer); | |
115 for (const auto& device : devices) | |
116 array_writer.AppendObjectPath(dbus::ObjectPath(device)); | |
117 writer.CloseContainer(&array_writer); | |
118 return response.release(); | |
119 } else if (method_call->GetMember() == kUPowerMethodGetDisplayDevice) { | |
120 std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty(); | |
121 if (!display_device.empty()) { | |
122 dbus::MessageWriter writer(response.get()); | |
123 writer.AppendObjectPath(dbus::ObjectPath(display_device)); | |
124 } | |
125 return response.release(); | |
126 } | |
127 } else if (method_call->GetInterface() == dbus::kPropertiesInterface) { | |
128 std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty(); | |
129 dbus::MessageWriter writer(response.get()); | |
130 if (method_call->GetMember() == dbus::kPropertiesGet) { | |
131 dbus::MessageReader reader(method_call); | |
132 std::string interface_name; | |
133 std::string property_name; | |
134 if (reader.PopString(&interface_name) && | |
135 reader.PopString(&property_name) && | |
136 property_name == kUPowerPropertyDaemonVersion) { | |
137 writer.AppendVariantOfString(daemon_version); | |
138 return response.release(); | |
139 } | |
140 } else if (method_call->GetMember() == dbus::kPropertiesGetAll) { | |
141 dbus::MessageWriter array_writer(nullptr); | |
142 dbus::MessageWriter dict_entry_writer(nullptr); | |
143 writer.OpenArray("{sv}", &array_writer); | |
144 array_writer.OpenDictEntry(&dict_entry_writer); | |
145 dict_entry_writer.AppendString(kUPowerPropertyDaemonVersion); | |
146 dict_entry_writer.AppendVariantOfString(daemon_version); | |
147 array_writer.CloseContainer(&dict_entry_writer); | |
148 writer.CloseContainer(&array_writer); | |
149 return response.release(); | |
150 } | |
151 } | |
152 | |
153 LOG(ERROR) << "Unexpected method call: " << method_call->ToString(); | |
timvolodine
2016/06/16 16:12:24
should this be a FAIL() <<.. ?
markuso
2016/06/17 08:45:19
I followed the guide of the Google Mock CookBook (
| |
154 return nullptr; | |
155 } | |
156 | |
157 void MockUPowerObject::SignalDeviceAdded(const std::string& added_device_path) { | |
158 dbus::Signal signal(kUPowerInterfaceName, kUPowerSignalDeviceAdded); | |
159 signal.SetPath(proxy->object_path()); | |
160 dbus::MessageWriter writer(&signal); | |
161 writer.AppendObjectPath(dbus::ObjectPath(added_device_path)); | |
162 signal_callback_device_added.Run(&signal); | |
163 } | |
164 | |
165 void MockUPowerObject::SignalDeviceRemoved( | |
166 const std::string& removed_device_path) { | |
167 dbus::Signal signal(kUPowerInterfaceName, kUPowerSignalDeviceRemoved); | |
168 signal.SetPath(proxy->object_path()); | |
169 dbus::MessageWriter writer(&signal); | |
170 writer.AppendObjectPath(dbus::ObjectPath(removed_device_path)); | |
171 signal_callback_device_removed.Run(&signal); | |
172 } | |
173 | |
174 struct MockBatteryProperties { | |
175 bool is_present = true; | |
176 double percentage = 100; | |
177 uint32_t state = UPowerDeviceState::UPOWER_DEVICE_STATE_UNKNOWN; | |
178 int64_t time_to_empty = 0; | |
179 int64_t time_to_full = 0; | |
180 uint32_t type = UPowerDeviceType::UPOWER_DEVICE_TYPE_BATTERY; | |
181 }; | |
182 | |
183 class MockBatteryObject { | |
184 public: | |
185 MockBatteryObject(dbus::Bus* bus, | |
186 const std::string& object_path, | |
187 MockBatteryProperties* properties); | |
188 void ConnectToSignal( | |
189 const std::string& interface_name, | |
190 const std::string& signal_name, | |
191 dbus::ObjectProxy::SignalCallback signal_callback, | |
192 dbus::ObjectProxy::OnConnectedCallback on_connected_callback); | |
193 dbus::Response* CreateCallMethodResponse(dbus::MethodCall* method_call, | |
194 Unused); | |
195 MockBatteryObject& ExpectConnectToSignalChanged(); | |
196 MockBatteryObject& ExpectConnectToSignalPropertyChanged(); | |
197 void SignalChanged(); | |
198 void SignalPropertyChanged(const std::string& property_name); | |
199 | |
200 scoped_refptr<dbus::MockObjectProxy> proxy; | |
201 MockBatteryProperties* properties; | |
202 dbus::ObjectProxy::SignalCallback signal_callback_changed; | |
203 dbus::ObjectProxy::SignalCallback signal_callback_properties_changed; | |
204 | |
205 private: | |
206 void AppendPropertyToWriter(dbus::MessageWriter* writer, | |
207 const std::string& property_name); | |
208 void AppendAllPropertiesToWriter(dbus::MessageWriter* writer); | |
209 | |
210 DISALLOW_COPY_AND_ASSIGN(MockBatteryObject); | |
211 }; | |
212 | |
213 MockBatteryObject::MockBatteryObject(dbus::Bus* bus, | |
214 const std::string& object_path, | |
215 MockBatteryProperties* properties) | |
216 : proxy(new NiceMock<dbus::MockObjectProxy>(bus, | |
217 kUPowerServiceName, | |
218 dbus::ObjectPath(object_path))), | |
219 properties(properties) {} | |
220 | |
221 void MockBatteryObject::ConnectToSignal( | |
222 const std::string& interface_name, | |
223 const std::string& signal_name, | |
224 dbus::ObjectProxy::SignalCallback signal_callback, | |
225 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) { | |
226 bool on_connected_success = true; | |
227 if (interface_name == kUPowerDeviceInterfaceName && | |
228 signal_name == kUPowerDeviceSignalChanged) | |
229 signal_callback_changed = signal_callback; | |
230 else if (interface_name == dbus::kPropertiesInterface && | |
231 signal_name == dbus::kPropertiesChanged) | |
232 signal_callback_properties_changed = signal_callback; | |
233 else | |
234 on_connected_success = false; | |
235 | |
236 if (!on_connected_success) { | |
237 LOG(WARNING) << "MockBatteryObject::" << __FUNCTION__ | |
238 << " Unexpected interface=" << interface_name | |
239 << ", signal=" << signal_name; | |
240 } | |
241 on_connected_callback.Run(interface_name, signal_name, on_connected_success); | |
242 } | |
243 | |
244 dbus::Response* MockBatteryObject::CreateCallMethodResponse( | |
245 dbus::MethodCall* method_call, | |
246 Unused) { | |
247 if (method_call->GetInterface() == dbus::kPropertiesInterface) { | |
248 if (method_call->GetMember() == dbus::kPropertiesGet) { | |
249 if (!properties) | |
250 return nullptr; | |
251 | |
252 dbus::MessageReader reader(method_call); | |
253 std::string interface_name; | |
254 std::string property_name; | |
255 if (reader.PopString(&interface_name) && | |
256 reader.PopString(&property_name)) { | |
257 std::unique_ptr<dbus::Response> response = | |
258 dbus::Response::CreateEmpty(); | |
259 dbus::MessageWriter writer(response.get()); | |
260 AppendPropertyToWriter(&writer, property_name); | |
261 return response.release(); | |
262 } | |
263 } else if (method_call->GetMember() == dbus::kPropertiesGetAll) { | |
264 if (!properties) | |
265 return nullptr; | |
266 | |
267 std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty(); | |
268 dbus::MessageWriter writer(response.get()); | |
269 AppendAllPropertiesToWriter(&writer); | |
270 return response.release(); | |
271 } | |
272 } | |
273 LOG(ERROR) << "Unexpected method call: " << method_call->ToString(); | |
timvolodine
2016/06/16 16:12:24
same question here
markuso
2016/06/17 08:45:19
Same answer
| |
274 return nullptr; | |
275 } | |
276 | |
277 MockBatteryObject& MockBatteryObject::ExpectConnectToSignalChanged() { | |
278 EXPECT_CALL(*proxy.get(), ConnectToSignal(kUPowerDeviceInterfaceName, | |
279 kUPowerDeviceSignalChanged, _, _)) | |
280 .WillOnce(Invoke(this, &MockBatteryObject::ConnectToSignal)); | |
281 return *this; | |
282 } | |
283 | |
284 MockBatteryObject& MockBatteryObject::ExpectConnectToSignalPropertyChanged() { | |
285 EXPECT_CALL(*proxy.get(), ConnectToSignal(dbus::kPropertiesInterface, | |
286 dbus::kPropertiesChanged, _, _)) | |
287 .WillOnce(Invoke(this, &MockBatteryObject::ConnectToSignal)); | |
288 return *this; | |
289 } | |
290 | |
291 void MockBatteryObject::SignalChanged() { | |
292 dbus::Signal signal(kUPowerInterfaceName, kUPowerDeviceSignalChanged); | |
293 signal.SetPath(proxy->object_path()); | |
294 dbus::MessageWriter writer(&signal); | |
295 writer.AppendString(kUPowerDeviceInterfaceName); | |
296 signal_callback_changed.Run(&signal); | |
297 } | |
298 | |
299 void MockBatteryObject::SignalPropertyChanged( | |
300 const std::string& property_name) { | |
301 dbus::Signal signal(dbus::kPropertiesInterface, dbus::kPropertiesChanged); | |
302 signal.SetPath(proxy->object_path()); | |
303 dbus::MessageWriter writer(&signal); | |
304 writer.AppendString(kUPowerDeviceInterfaceName); | |
305 | |
306 // Dictionary {sv} of property-name => new value: | |
307 dbus::MessageWriter array_writer(nullptr); | |
308 writer.OpenArray("{sv}", &array_writer); | |
309 writer.CloseContainer(&array_writer); | |
310 | |
311 // Array of invalidated properties: | |
312 writer.OpenArray("s", &array_writer); | |
313 array_writer.AppendString(property_name); | |
314 writer.CloseContainer(&array_writer); | |
315 | |
316 signal_callback_properties_changed.Run(&signal); | |
317 } | |
318 | |
319 void MockBatteryObject::AppendPropertyToWriter( | |
320 dbus::MessageWriter* writer, | |
321 const std::string& property_name) { | |
322 if (property_name == kUPowerDevicePropertyIsPresent) | |
323 writer->AppendVariantOfBool(properties->is_present); | |
324 else if (property_name == kUPowerDevicePropertyPercentage) | |
325 writer->AppendVariantOfDouble(properties->percentage); | |
326 else if (property_name == kUPowerDevicePropertyState) | |
327 writer->AppendVariantOfUint32(properties->state); | |
328 else if (property_name == kUPowerDevicePropertyTimeToEmpty) | |
329 writer->AppendVariantOfInt64(properties->time_to_empty); | |
330 else if (property_name == kUPowerDevicePropertyTimeToFull) | |
331 writer->AppendVariantOfInt64(properties->time_to_full); | |
332 else if (property_name == kUPowerDevicePropertyType) | |
333 writer->AppendVariantOfUint32(properties->type); | |
334 else | |
335 LOG(WARNING) << __FUNCTION__ << " unknown property: " << property_name; | |
336 } | |
337 | |
338 void MockBatteryObject::AppendAllPropertiesToWriter( | |
339 dbus::MessageWriter* writer) { | |
340 dbus::MessageWriter array_writer(nullptr); | |
341 dbus::MessageWriter dict_entry_writer(nullptr); | |
342 writer->OpenArray("{sv}", &array_writer); | |
343 for (auto property_name : | |
344 {kUPowerDevicePropertyIsPresent, kUPowerDevicePropertyState, | |
345 kUPowerDevicePropertyTimeToEmpty, kUPowerDevicePropertyTimeToFull, | |
346 kUPowerDevicePropertyType}) { | |
347 array_writer.OpenDictEntry(&dict_entry_writer); | |
348 dict_entry_writer.AppendString(property_name); | |
349 AppendPropertyToWriter(&dict_entry_writer, property_name); | |
350 array_writer.CloseContainer(&dict_entry_writer); | |
351 } | |
352 writer->CloseContainer(&array_writer); | |
353 } | |
354 | |
355 } // namespace | |
356 | |
357 class BatteryStatusManagerLinuxTest : public testing::Test { | |
358 public: | |
359 BatteryStatusManagerLinuxTest() {} | |
360 void SetUp() override; | |
361 | |
362 MockBatteryObject& SetUpDisplayDeviceProxy(MockBatteryProperties* properties); | |
363 void AddDevicePath(const std::string& object_path); | |
364 void PushFrontDevicePath(const std::string& object_path); | |
365 MockBatteryObject& AddDeviceProxy(const std::string& object_path, | |
366 MockBatteryProperties* properties); | |
367 MockBatteryObject& PushFrontDeviceProxy(const std::string& object_path, | |
368 MockBatteryProperties* properties); | |
369 void ExpectGetObjectProxy(const std::string& object_path, | |
370 MockBatteryObject* mock_object); | |
371 void ExpectGetObjectProxy(const std::string& object_path, | |
372 dbus::ObjectProxy* object_proxy); | |
373 | |
374 void DeviceSignalChanged(MockBatteryObject* device); | |
375 void DeviceSignalPropertyChanged(MockBatteryObject* device, | |
376 const std::string& property_name); | |
377 | |
378 void UPowerSignalDeviceAdded(const std::string& device_path); | |
379 void UPowerSignalDeviceRemoved(const std::string& device_path); | |
380 | |
381 void StartBatteryStatusManagerLinux(); | |
382 | |
383 int count_battery_updates() const { return count_battery_updates_; } | |
384 const BatteryStatus& last_battery_status() const { return last_status_; } | |
385 | |
386 protected: | |
387 scoped_refptr<dbus::MockBus> mock_bus_; | |
388 MockUPowerObject mock_upower_; | |
389 std::unique_ptr<MockBatteryObject> mock_display_device_; | |
390 std::list<std::unique_ptr<MockBatteryObject>> mock_battery_devices_; | |
391 | |
392 private: | |
393 std::unique_ptr<MockBatteryObject> CreateMockBatteryObject( | |
394 const std::string& object_path, | |
395 MockBatteryProperties* properties); | |
396 void BatteryUpdateCallback(const BatteryStatus& status); | |
397 void SyncWithNotifierThread(); | |
398 | |
399 std::unique_ptr<BatteryStatusManagerLinux> manager_; | |
400 int count_battery_updates_ = 0; | |
401 BatteryStatus last_status_; | |
402 | |
403 DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerLinuxTest); | |
404 }; | |
405 | |
406 void BatteryStatusManagerLinuxTest::SetUp() { | |
407 dbus::Bus::Options options; | |
408 options.bus_type = dbus::Bus::SYSTEM; | |
409 options.connection_type = dbus::Bus::PRIVATE; | |
410 mock_bus_ = new NiceMock<dbus::MockBus>(options); | |
411 | |
412 mock_upower_.proxy = new NiceMock<dbus::MockObjectProxy>( | |
413 mock_bus_.get(), kUPowerServiceName, dbus::ObjectPath(kUPowerPath)); | |
414 ExpectGetObjectProxy(kUPowerPath, mock_upower_.proxy.get()); | |
415 EXPECT_CALL(*mock_upower_.proxy.get(), MockCallMethodAndBlock(_, _)) | |
416 .WillRepeatedly( | |
417 Invoke(&mock_upower_, &MockUPowerObject::CreateCallMethodResponse)); | |
418 EXPECT_CALL( | |
419 *mock_upower_.proxy.get(), | |
420 ConnectToSignal(kUPowerInterfaceName, kUPowerSignalDeviceAdded, _, _)) | |
421 .WillOnce(Invoke(&mock_upower_, &MockUPowerObject::ConnectToSignal)); | |
422 EXPECT_CALL( | |
423 *mock_upower_.proxy.get(), | |
424 ConnectToSignal(kUPowerInterfaceName, kUPowerSignalDeviceRemoved, _, _)) | |
425 .WillOnce(Invoke(&mock_upower_, &MockUPowerObject::ConnectToSignal)); | |
426 } | |
427 | |
428 MockBatteryObject& BatteryStatusManagerLinuxTest::SetUpDisplayDeviceProxy( | |
429 MockBatteryProperties* properties) { | |
430 mock_upower_.display_device = kUPowerDisplayDevicePath; | |
431 mock_display_device_ = | |
432 CreateMockBatteryObject(mock_upower_.display_device, properties); | |
433 return *mock_display_device_.get(); | |
434 } | |
435 | |
436 void BatteryStatusManagerLinuxTest::AddDevicePath( | |
437 const std::string& object_path) { | |
438 mock_upower_.devices.push_back(object_path); | |
439 } | |
440 | |
441 void BatteryStatusManagerLinuxTest::PushFrontDevicePath( | |
442 const std::string& object_path) { | |
443 mock_upower_.devices.push_front(object_path); | |
444 } | |
445 | |
446 MockBatteryObject& BatteryStatusManagerLinuxTest::AddDeviceProxy( | |
447 const std::string& object_path, | |
448 MockBatteryProperties* properties) { | |
449 AddDevicePath(object_path); | |
450 mock_battery_devices_.push_back( | |
451 CreateMockBatteryObject(object_path, properties)); | |
452 return *mock_battery_devices_.back().get(); | |
453 } | |
454 | |
455 MockBatteryObject& BatteryStatusManagerLinuxTest::PushFrontDeviceProxy( | |
456 const std::string& object_path, | |
457 MockBatteryProperties* properties) { | |
458 PushFrontDevicePath(object_path); | |
459 mock_battery_devices_.push_front( | |
460 CreateMockBatteryObject(object_path, properties)); | |
461 return *mock_battery_devices_.front().get(); | |
462 } | |
463 | |
464 void BatteryStatusManagerLinuxTest::ExpectGetObjectProxy( | |
465 const std::string& object_path, | |
466 MockBatteryObject* mock_object) { | |
467 ExpectGetObjectProxy(object_path, mock_object->proxy.get()); | |
468 } | |
469 | |
470 void BatteryStatusManagerLinuxTest::ExpectGetObjectProxy( | |
471 const std::string& object_path, | |
472 dbus::ObjectProxy* object_proxy) { | |
473 EXPECT_CALL(*mock_bus_.get(), | |
474 GetObjectProxy(kUPowerServiceName, dbus::ObjectPath(object_path))) | |
475 .WillOnce(Return(object_proxy)); | |
476 } | |
477 | |
478 void BatteryStatusManagerLinuxTest::DeviceSignalChanged( | |
479 MockBatteryObject* device) { | |
480 manager_->GetNotifierThreadForTesting()->task_runner()->PostTask( | |
481 FROM_HERE, | |
482 base::Bind(&MockBatteryObject::SignalChanged, base::Unretained(device))); | |
483 SyncWithNotifierThread(); | |
484 } | |
485 | |
486 void BatteryStatusManagerLinuxTest::DeviceSignalPropertyChanged( | |
487 MockBatteryObject* device, | |
488 const std::string& property_name) { | |
489 manager_->GetNotifierThreadForTesting()->task_runner()->PostTask( | |
490 FROM_HERE, base::Bind(&MockBatteryObject::SignalPropertyChanged, | |
491 base::Unretained(device), property_name)); | |
492 SyncWithNotifierThread(); | |
493 } | |
494 | |
495 void BatteryStatusManagerLinuxTest::UPowerSignalDeviceAdded( | |
496 const std::string& device_path) { | |
497 ASSERT_FALSE(mock_upower_.signal_callback_device_added.is_null()); | |
498 manager_->GetNotifierThreadForTesting()->task_runner()->PostTask( | |
499 FROM_HERE, base::Bind(&MockUPowerObject::SignalDeviceAdded, | |
500 base::Unretained(&mock_upower_), device_path)); | |
501 SyncWithNotifierThread(); | |
502 } | |
503 | |
504 void BatteryStatusManagerLinuxTest::UPowerSignalDeviceRemoved( | |
505 const std::string& device_path) { | |
506 ASSERT_FALSE(mock_upower_.signal_callback_device_removed.is_null()); | |
507 manager_->GetNotifierThreadForTesting()->task_runner()->PostTask( | |
508 FROM_HERE, base::Bind(&MockUPowerObject::SignalDeviceRemoved, | |
509 base::Unretained(&mock_upower_), device_path)); | |
510 SyncWithNotifierThread(); | |
511 } | |
512 | |
513 void BatteryStatusManagerLinuxTest::StartBatteryStatusManagerLinux() { | |
514 manager_ = BatteryStatusManagerLinux::CreateForTesting( | |
515 base::Bind(&BatteryStatusManagerLinuxTest::BatteryUpdateCallback, | |
516 base::Unretained(this)), | |
517 mock_bus_.get()); | |
518 manager_->StartListeningBatteryChange(); | |
519 SyncWithNotifierThread(); | |
520 } | |
521 | |
522 std::unique_ptr<MockBatteryObject> | |
523 BatteryStatusManagerLinuxTest::CreateMockBatteryObject( | |
524 const std::string& object_path, | |
525 MockBatteryProperties* properties) { | |
526 std::unique_ptr<MockBatteryObject> mock_object( | |
527 new MockBatteryObject(mock_bus_.get(), object_path, properties)); | |
528 ExpectGetObjectProxy(object_path, mock_object.get()); | |
529 EXPECT_CALL(*mock_object->proxy.get(), MockCallMethodAndBlock(_, _)) | |
530 .WillRepeatedly(Invoke(mock_object.get(), | |
531 &MockBatteryObject::CreateCallMethodResponse)); | |
532 return mock_object; | |
533 } | |
534 | |
535 void BatteryStatusManagerLinuxTest::BatteryUpdateCallback( | |
536 const BatteryStatus& status) { | |
537 ++count_battery_updates_; | |
538 last_status_ = status; | |
539 } | |
540 | |
541 void BatteryStatusManagerLinuxTest::SyncWithNotifierThread() { | |
542 ASSERT_TRUE(manager_ != nullptr); | |
543 base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL, | |
544 base::WaitableEvent::InitialState::NOT_SIGNALED); | |
545 manager_->GetNotifierThreadForTesting()->task_runner()->PostTask( | |
546 FROM_HERE, | |
547 base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event))); | |
548 event.Wait(); | |
549 } | |
550 | |
551 TEST_F(BatteryStatusManagerLinuxTest, NoBattery) { | |
16 BatteryStatus default_status; | 552 BatteryStatus default_status; |
17 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 553 StartBatteryStatusManagerLinux(); |
554 BatteryStatus status = last_battery_status(); | |
555 EXPECT_LE(1, count_battery_updates()); | |
18 | 556 |
19 EXPECT_EQ(default_status.charging, status.charging); | 557 EXPECT_EQ(default_status.charging, status.charging); |
20 EXPECT_EQ(default_status.charging_time, status.charging_time); | 558 EXPECT_EQ(default_status.charging_time, status.charging_time); |
21 EXPECT_EQ(default_status.discharging_time, status.discharging_time); | 559 EXPECT_EQ(default_status.discharging_time, status.discharging_time); |
22 EXPECT_EQ(default_status.level, status.level); | 560 EXPECT_EQ(default_status.level, status.level); |
23 } | 561 } |
24 | 562 |
25 TEST(BatteryStatusManagerLinuxTest, ChargingHalfFull) { | 563 TEST_F(BatteryStatusManagerLinuxTest, ChargingHalfFull) { |
26 base::DictionaryValue dictionary; | 564 MockBatteryProperties battery_bat0_properties; |
27 dictionary.SetDouble("State", UPOWER_DEVICE_STATE_CHARGING); | 565 battery_bat0_properties.state = |
28 dictionary.SetDouble("TimeToFull", 0); | 566 UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING; |
29 dictionary.SetDouble("Percentage", 50); | 567 battery_bat0_properties.time_to_full = 0; |
568 battery_bat0_properties.percentage = 50; | |
569 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
570 .ExpectConnectToSignalPropertyChanged(); | |
30 | 571 |
31 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 572 StartBatteryStatusManagerLinux(); |
573 BatteryStatus status = last_battery_status(); | |
574 EXPECT_LE(1, count_battery_updates()); | |
32 | 575 |
33 EXPECT_TRUE(status.charging); | 576 EXPECT_TRUE(status.charging); |
34 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | 577 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); |
35 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | 578 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); |
36 EXPECT_EQ(0.5, status.level); | 579 EXPECT_EQ(0.5, status.level); |
37 } | 580 } |
38 | 581 |
39 TEST(BatteryStatusManagerLinuxTest, ChargingTimeToFull) { | 582 TEST_F(BatteryStatusManagerLinuxTest, ChargingTimeToFull) { |
40 base::DictionaryValue dictionary; | 583 MockBatteryProperties battery_bat0_properties; |
41 dictionary.SetDouble("State", UPOWER_DEVICE_STATE_CHARGING); | 584 battery_bat0_properties.state = |
42 dictionary.SetDouble("TimeToFull", 100.f); | 585 UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING; |
43 dictionary.SetDouble("Percentage", 1); | 586 battery_bat0_properties.time_to_full = 100; |
587 battery_bat0_properties.percentage = 1; | |
588 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
589 .ExpectConnectToSignalPropertyChanged(); | |
44 | 590 |
45 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 591 StartBatteryStatusManagerLinux(); |
592 BatteryStatus status = last_battery_status(); | |
593 EXPECT_LE(1, count_battery_updates()); | |
46 | 594 |
47 EXPECT_TRUE(status.charging); | 595 EXPECT_TRUE(status.charging); |
48 EXPECT_EQ(100, status.charging_time); | 596 EXPECT_EQ(100, status.charging_time); |
49 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | 597 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); |
50 EXPECT_EQ(.01, status.level); | 598 EXPECT_EQ(.01, status.level); |
51 } | 599 } |
52 | 600 |
53 TEST(BatteryStatusManagerLinuxTest, FullyCharged) { | 601 TEST_F(BatteryStatusManagerLinuxTest, FullyCharged) { |
54 base::DictionaryValue dictionary; | 602 MockBatteryProperties battery_bat0_properties; |
55 dictionary.SetDouble("State", UPOWER_DEVICE_STATE_FULL); | 603 battery_bat0_properties.state = UPowerDeviceState::UPOWER_DEVICE_STATE_FULL; |
56 dictionary.SetDouble("TimeToFull", 100); | 604 battery_bat0_properties.time_to_full = 100; |
57 dictionary.SetDouble("TimeToEmpty", 200); | 605 battery_bat0_properties.time_to_empty = 200; |
58 dictionary.SetDouble("Percentage", 100); | 606 battery_bat0_properties.percentage = 100; |
607 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
608 .ExpectConnectToSignalPropertyChanged(); | |
59 | 609 |
60 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 610 StartBatteryStatusManagerLinux(); |
611 BatteryStatus status = last_battery_status(); | |
612 EXPECT_LE(1, count_battery_updates()); | |
61 | 613 |
62 EXPECT_TRUE(status.charging); | 614 EXPECT_TRUE(status.charging); |
63 EXPECT_EQ(0, status.charging_time); | 615 EXPECT_EQ(0, status.charging_time); |
64 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | 616 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); |
65 EXPECT_EQ(1, status.level); | 617 EXPECT_EQ(1, status.level); |
66 } | 618 } |
67 | 619 |
68 TEST(BatteryStatusManagerLinuxTest, Discharging) { | 620 TEST_F(BatteryStatusManagerLinuxTest, Discharging) { |
69 base::DictionaryValue dictionary; | 621 MockBatteryProperties battery_bat0_properties; |
70 dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING); | 622 battery_bat0_properties.state = |
71 dictionary.SetDouble("TimeToFull", 0); | 623 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; |
72 dictionary.SetDouble("TimeToEmpty", 200); | 624 battery_bat0_properties.time_to_full = 0; |
73 dictionary.SetDouble("Percentage", 90); | 625 battery_bat0_properties.time_to_empty = 200; |
626 battery_bat0_properties.percentage = 90; | |
627 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
628 .ExpectConnectToSignalPropertyChanged(); | |
74 | 629 |
75 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 630 StartBatteryStatusManagerLinux(); |
631 BatteryStatus status = last_battery_status(); | |
632 EXPECT_LE(1, count_battery_updates()); | |
76 | 633 |
77 EXPECT_FALSE(status.charging); | 634 EXPECT_FALSE(status.charging); |
78 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | 635 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); |
79 EXPECT_EQ(200, status.discharging_time); | 636 EXPECT_EQ(200, status.discharging_time); |
80 EXPECT_EQ(.9, status.level); | 637 EXPECT_EQ(.9, status.level); |
81 } | 638 } |
82 | 639 |
83 TEST(BatteryStatusManagerLinuxTest, DischargingTimeToEmptyUnknown) { | 640 TEST_F(BatteryStatusManagerLinuxTest, DischargingTimeToEmptyUnknown) { |
84 base::DictionaryValue dictionary; | 641 MockBatteryProperties battery_bat0_properties; |
85 dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING); | 642 battery_bat0_properties.state = |
86 dictionary.SetDouble("TimeToFull", 0); | 643 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; |
87 dictionary.SetDouble("TimeToEmpty", 0); | 644 battery_bat0_properties.time_to_full = 0; |
88 dictionary.SetDouble("Percentage", 90); | 645 battery_bat0_properties.time_to_empty = 0; |
646 battery_bat0_properties.percentage = 90; | |
647 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
648 .ExpectConnectToSignalPropertyChanged(); | |
89 | 649 |
90 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 650 StartBatteryStatusManagerLinux(); |
651 BatteryStatus status = last_battery_status(); | |
652 EXPECT_LE(1, count_battery_updates()); | |
91 | 653 |
92 EXPECT_FALSE(status.charging); | 654 EXPECT_FALSE(status.charging); |
93 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | 655 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); |
94 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | 656 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); |
95 EXPECT_EQ(.9, status.level); | 657 EXPECT_EQ(.9, status.level); |
96 } | 658 } |
97 | 659 |
98 TEST(BatteryStatusManagerLinuxTest, DeviceStateUnknown) { | 660 TEST_F(BatteryStatusManagerLinuxTest, DeviceStateUnknown) { |
99 base::DictionaryValue dictionary; | 661 MockBatteryProperties battery_bat0_properties; |
100 dictionary.SetDouble("State", UPOWER_DEVICE_STATE_UNKNOWN); | 662 battery_bat0_properties.state = |
101 dictionary.SetDouble("TimeToFull", 0); | 663 UPowerDeviceState::UPOWER_DEVICE_STATE_UNKNOWN; |
102 dictionary.SetDouble("TimeToEmpty", 0); | 664 battery_bat0_properties.time_to_full = 0; |
103 dictionary.SetDouble("Percentage", 50); | 665 battery_bat0_properties.time_to_empty = 0; |
666 battery_bat0_properties.percentage = 50; | |
667 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
668 .ExpectConnectToSignalPropertyChanged(); | |
104 | 669 |
105 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 670 StartBatteryStatusManagerLinux(); |
671 BatteryStatus status = last_battery_status(); | |
672 EXPECT_LE(1, count_battery_updates()); | |
106 | 673 |
107 EXPECT_TRUE(status.charging); | 674 EXPECT_TRUE(status.charging); |
108 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | 675 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); |
109 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | 676 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); |
110 EXPECT_EQ(.5, status.level); | 677 EXPECT_EQ(.5, status.level); |
111 } | 678 } |
112 | 679 |
113 TEST(BatteryStatusManagerLinuxTest, DeviceStateEmpty) { | 680 TEST_F(BatteryStatusManagerLinuxTest, DeviceStateEmpty) { |
114 base::DictionaryValue dictionary; | 681 MockBatteryProperties battery_bat0_properties; |
115 dictionary.SetDouble("State", UPOWER_DEVICE_STATE_EMPTY); | 682 battery_bat0_properties.state = UPowerDeviceState::UPOWER_DEVICE_STATE_EMPTY; |
116 dictionary.SetDouble("TimeToFull", 0); | 683 battery_bat0_properties.time_to_full = 0; |
117 dictionary.SetDouble("TimeToEmpty", 0); | 684 battery_bat0_properties.time_to_empty = 0; |
118 dictionary.SetDouble("Percentage", 0); | 685 battery_bat0_properties.percentage = 0; |
686 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
687 .ExpectConnectToSignalPropertyChanged(); | |
119 | 688 |
120 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 689 StartBatteryStatusManagerLinux(); |
690 BatteryStatus status = last_battery_status(); | |
691 EXPECT_LE(1, count_battery_updates()); | |
121 | 692 |
122 EXPECT_FALSE(status.charging); | 693 EXPECT_FALSE(status.charging); |
123 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | 694 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); |
124 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | 695 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); |
125 EXPECT_EQ(0, status.level); | 696 EXPECT_EQ(0, status.level); |
126 } | 697 } |
127 | 698 |
128 TEST(BatteryStatusManagerLinuxTest, LevelRoundedToThreeSignificantDigits) { | 699 TEST_F(BatteryStatusManagerLinuxTest, LevelRoundedToThreeSignificantDigits) { |
129 base::DictionaryValue dictionary; | 700 MockBatteryProperties battery_bat0_properties; |
130 dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING); | 701 battery_bat0_properties.state = |
131 dictionary.SetDouble("Percentage", 14.56); | 702 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; |
703 battery_bat0_properties.percentage = 14.56; | |
704 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
705 .ExpectConnectToSignalPropertyChanged(); | |
132 | 706 |
133 BatteryStatus status = ComputeWebBatteryStatus(dictionary); | 707 StartBatteryStatusManagerLinux(); |
708 BatteryStatus status = last_battery_status(); | |
709 EXPECT_LE(1, count_battery_updates()); | |
134 | 710 |
135 EXPECT_FALSE(status.charging); | 711 EXPECT_FALSE(status.charging); |
136 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | 712 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); |
137 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | 713 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); |
138 EXPECT_EQ(0.15, status.level); | 714 EXPECT_EQ(0.15, status.level); |
139 } | 715 } |
140 | 716 |
141 } // namespace | 717 TEST_F(BatteryStatusManagerLinuxTest, UsingFirstBatteryDevice) { |
718 MockBatteryProperties battery_bat0_properties; | |
719 battery_bat0_properties.state = | |
720 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
721 battery_bat0_properties.time_to_full = 0; | |
722 battery_bat0_properties.time_to_empty = 200; | |
723 battery_bat0_properties.percentage = 70; | |
724 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
725 .ExpectConnectToSignalPropertyChanged(); | |
726 | |
727 MockBatteryProperties battery_bat1_properties; | |
728 battery_bat1_properties.state = | |
729 UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING; | |
730 battery_bat1_properties.time_to_full = 100; | |
731 battery_bat1_properties.time_to_empty = 0; | |
732 battery_bat1_properties.percentage = 80; | |
733 AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties); | |
734 | |
735 StartBatteryStatusManagerLinux(); | |
736 BatteryStatus status = last_battery_status(); | |
737 EXPECT_LE(1, count_battery_updates()); | |
738 | |
739 EXPECT_FALSE(status.charging); | |
740 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
741 EXPECT_EQ(200, status.discharging_time); | |
742 EXPECT_EQ(0.7, status.level); | |
743 } | |
744 | |
745 TEST_F(BatteryStatusManagerLinuxTest, SkipNonBatteryDevice) { | |
746 MockBatteryProperties line_power_AC_properties; | |
747 line_power_AC_properties.type = | |
748 UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER; | |
749 AddDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties); | |
750 | |
751 MockBatteryProperties battery_bat0_properties; | |
752 battery_bat0_properties.state = | |
753 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
754 battery_bat0_properties.time_to_full = 0; | |
755 battery_bat0_properties.time_to_empty = 200; | |
756 battery_bat0_properties.percentage = 70; | |
757 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
758 .ExpectConnectToSignalPropertyChanged(); | |
759 | |
760 StartBatteryStatusManagerLinux(); | |
761 BatteryStatus status = last_battery_status(); | |
762 EXPECT_LE(1, count_battery_updates()); | |
763 | |
764 EXPECT_FALSE(status.charging); | |
765 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
766 EXPECT_EQ(200, status.discharging_time); | |
767 EXPECT_EQ(0.7, status.level); | |
768 } | |
769 | |
770 TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyState) { | |
771 MockBatteryProperties battery_bat0_properties; | |
772 battery_bat0_properties.state = | |
773 UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING; | |
774 battery_bat0_properties.time_to_full = 100; | |
775 battery_bat0_properties.time_to_empty = 200; | |
776 battery_bat0_properties.percentage = 80; | |
777 MockBatteryObject& battery_bat0 = | |
778 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
779 .ExpectConnectToSignalPropertyChanged(); | |
780 | |
781 StartBatteryStatusManagerLinux(); | |
782 BatteryStatus status = last_battery_status(); | |
783 EXPECT_LE(1, count_battery_updates()); | |
784 | |
785 EXPECT_TRUE(status.charging); | |
786 EXPECT_EQ(100, status.charging_time); | |
787 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | |
788 EXPECT_EQ(.8, status.level); | |
789 | |
790 int last_count = count_battery_updates(); | |
791 battery_bat0_properties.state = | |
792 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
793 DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyState); | |
794 status = last_battery_status(); | |
795 | |
796 EXPECT_LT(last_count, count_battery_updates()); | |
797 EXPECT_FALSE(status.charging); | |
798 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
799 EXPECT_EQ(200, status.discharging_time); | |
800 EXPECT_EQ(.8, status.level); | |
801 } | |
802 | |
803 TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyPercentage) { | |
804 MockBatteryProperties battery_bat0_properties; | |
805 battery_bat0_properties.state = | |
806 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
807 battery_bat0_properties.time_to_full = 100; | |
808 battery_bat0_properties.time_to_empty = 200; | |
809 battery_bat0_properties.percentage = 80; | |
810 MockBatteryObject& battery_bat0 = | |
811 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
812 .ExpectConnectToSignalPropertyChanged(); | |
813 | |
814 StartBatteryStatusManagerLinux(); | |
815 BatteryStatus status = last_battery_status(); | |
816 EXPECT_LE(1, count_battery_updates()); | |
817 | |
818 EXPECT_FALSE(status.charging); | |
819 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
820 EXPECT_EQ(200, status.discharging_time); | |
821 EXPECT_EQ(.8, status.level); | |
822 | |
823 int last_count = count_battery_updates(); | |
824 battery_bat0_properties.percentage = 70; | |
825 DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyPercentage); | |
826 status = last_battery_status(); | |
827 | |
828 EXPECT_LT(last_count, count_battery_updates()); | |
829 EXPECT_FALSE(status.charging); | |
830 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
831 EXPECT_EQ(200, status.discharging_time); | |
832 EXPECT_EQ(.7, status.level); | |
833 } | |
834 | |
835 TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyTimeToEmpty) { | |
836 MockBatteryProperties battery_bat0_properties; | |
837 battery_bat0_properties.state = | |
838 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
839 battery_bat0_properties.time_to_full = 100; | |
840 battery_bat0_properties.time_to_empty = 200; | |
841 battery_bat0_properties.percentage = 80; | |
842 MockBatteryObject& battery_bat0 = | |
843 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
844 .ExpectConnectToSignalPropertyChanged(); | |
845 | |
846 StartBatteryStatusManagerLinux(); | |
847 BatteryStatus status = last_battery_status(); | |
848 EXPECT_LE(1, count_battery_updates()); | |
849 | |
850 EXPECT_FALSE(status.charging); | |
851 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
852 EXPECT_EQ(200, status.discharging_time); | |
853 EXPECT_EQ(.8, status.level); | |
854 | |
855 int last_count = count_battery_updates(); | |
856 battery_bat0_properties.time_to_empty = 150; | |
857 DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyTimeToEmpty); | |
858 status = last_battery_status(); | |
859 | |
860 EXPECT_LT(last_count, count_battery_updates()); | |
861 EXPECT_FALSE(status.charging); | |
862 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
863 EXPECT_EQ(150, status.discharging_time); | |
864 EXPECT_EQ(.8, status.level); | |
865 } | |
866 | |
867 TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyTimeToFull) { | |
868 MockBatteryProperties battery_bat0_properties; | |
869 battery_bat0_properties.state = | |
870 UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING; | |
871 battery_bat0_properties.time_to_full = 100; | |
872 battery_bat0_properties.time_to_empty = 200; | |
873 battery_bat0_properties.percentage = 80; | |
874 MockBatteryObject& battery_bat0 = | |
875 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
876 .ExpectConnectToSignalPropertyChanged(); | |
877 | |
878 StartBatteryStatusManagerLinux(); | |
879 BatteryStatus status = last_battery_status(); | |
880 EXPECT_LE(1, count_battery_updates()); | |
881 | |
882 EXPECT_TRUE(status.charging); | |
883 EXPECT_EQ(100, status.charging_time); | |
884 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | |
885 EXPECT_EQ(.8, status.level); | |
886 | |
887 int last_count = count_battery_updates(); | |
888 battery_bat0_properties.time_to_full = 50; | |
889 DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyTimeToFull); | |
890 status = last_battery_status(); | |
891 | |
892 EXPECT_LT(last_count, count_battery_updates()); | |
893 EXPECT_TRUE(status.charging); | |
894 EXPECT_EQ(50, status.charging_time); | |
895 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | |
896 EXPECT_EQ(.8, status.level); | |
897 } | |
898 | |
899 TEST_F(BatteryStatusManagerLinuxTest, OldDaemonDeviceChanged) { | |
900 mock_upower_.daemon_version = "0.9.23"; | |
901 MockBatteryProperties battery_bat0_properties; | |
902 battery_bat0_properties.state = | |
903 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
904 battery_bat0_properties.time_to_full = 100; | |
905 battery_bat0_properties.time_to_empty = 200; | |
906 battery_bat0_properties.percentage = 80; | |
907 MockBatteryObject& battery_bat0 = | |
908 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
909 .ExpectConnectToSignalChanged() | |
910 .ExpectConnectToSignalPropertyChanged(); | |
911 | |
912 StartBatteryStatusManagerLinux(); | |
913 BatteryStatus status = last_battery_status(); | |
914 EXPECT_LE(1, count_battery_updates()); | |
915 | |
916 EXPECT_FALSE(status.charging); | |
917 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
918 EXPECT_EQ(200, status.discharging_time); | |
919 EXPECT_EQ(.8, status.level); | |
920 | |
921 int last_count = count_battery_updates(); | |
922 battery_bat0_properties.percentage = 70; | |
923 DeviceSignalChanged(&battery_bat0); | |
924 status = last_battery_status(); | |
925 | |
926 EXPECT_LT(last_count, count_battery_updates()); | |
927 EXPECT_FALSE(status.charging); | |
928 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
929 EXPECT_EQ(200, status.discharging_time); | |
930 EXPECT_EQ(.7, status.level); | |
931 } | |
932 | |
933 TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceNoBattery) { | |
934 MockBatteryProperties display_device_properties; | |
935 display_device_properties.type = UPowerDeviceType::UPOWER_DEVICE_TYPE_UNKNOWN; | |
936 SetUpDisplayDeviceProxy(&display_device_properties); | |
937 | |
938 MockBatteryProperties battery_bat0_properties; | |
939 battery_bat0_properties.state = | |
940 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
941 battery_bat0_properties.time_to_full = 0; | |
942 battery_bat0_properties.time_to_empty = 200; | |
943 battery_bat0_properties.percentage = 90; | |
944 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
945 .ExpectConnectToSignalPropertyChanged(); | |
946 | |
947 StartBatteryStatusManagerLinux(); | |
948 BatteryStatus status = last_battery_status(); | |
949 EXPECT_LE(1, count_battery_updates()); | |
950 | |
951 EXPECT_FALSE(status.charging); | |
952 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
953 EXPECT_EQ(200, status.discharging_time); | |
954 EXPECT_EQ(0.9, status.level); | |
955 } | |
956 | |
957 TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceBattery) { | |
958 MockBatteryProperties display_device_properties; | |
959 display_device_properties.state = | |
960 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
961 display_device_properties.time_to_full = 0; | |
962 display_device_properties.time_to_empty = 200; | |
963 display_device_properties.percentage = 90; | |
964 SetUpDisplayDeviceProxy(&display_device_properties) | |
965 .ExpectConnectToSignalPropertyChanged(); | |
966 | |
967 StartBatteryStatusManagerLinux(); | |
968 BatteryStatus status = last_battery_status(); | |
969 EXPECT_LE(1, count_battery_updates()); | |
970 | |
971 EXPECT_FALSE(status.charging); | |
972 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
973 EXPECT_EQ(200, status.discharging_time); | |
974 EXPECT_EQ(.9, status.level); | |
975 } | |
976 | |
977 TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceBatterySkipsEnumerate) { | |
978 MockBatteryProperties display_device_properties; | |
979 display_device_properties.state = | |
980 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
981 display_device_properties.time_to_full = 0; | |
982 display_device_properties.time_to_empty = 200; | |
983 display_device_properties.percentage = 90; | |
984 SetUpDisplayDeviceProxy(&display_device_properties) | |
985 .ExpectConnectToSignalPropertyChanged(); | |
986 | |
987 AddDevicePath(kUPowerDeviceACLinePath); | |
988 AddDevicePath(kUPowerDeviceBattery0Path); | |
989 AddDevicePath(kUPowerDeviceBattery1Path); | |
990 | |
991 StartBatteryStatusManagerLinux(); | |
992 BatteryStatus status = last_battery_status(); | |
993 EXPECT_LE(1, count_battery_updates()); | |
994 | |
995 EXPECT_FALSE(status.charging); | |
996 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
997 EXPECT_EQ(200, status.discharging_time); | |
998 EXPECT_EQ(.9, status.level); | |
999 } | |
1000 | |
1001 // Adding a display-device will make the BatteryStatusManagerLinux switch to | |
1002 // the display-device. | |
1003 TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedDisplayDevice) { | |
1004 MockBatteryProperties battery_bat0_properties; | |
1005 battery_bat0_properties.state = | |
1006 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
1007 battery_bat0_properties.time_to_full = 0; | |
1008 battery_bat0_properties.time_to_empty = 200; | |
1009 battery_bat0_properties.percentage = 70; | |
1010 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
1011 .ExpectConnectToSignalPropertyChanged(); | |
1012 | |
1013 StartBatteryStatusManagerLinux(); | |
1014 BatteryStatus status = last_battery_status(); | |
1015 EXPECT_LE(1, count_battery_updates()); | |
1016 | |
1017 EXPECT_FALSE(status.charging); | |
1018 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1019 EXPECT_EQ(200, status.discharging_time); | |
1020 EXPECT_EQ(0.7, status.level); | |
1021 | |
1022 int last_count = count_battery_updates(); | |
1023 MockBatteryProperties display_device_properties; | |
1024 display_device_properties.state = | |
1025 UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING; | |
1026 display_device_properties.time_to_full = 100; | |
1027 display_device_properties.time_to_empty = 150; | |
1028 display_device_properties.percentage = 80; | |
1029 SetUpDisplayDeviceProxy(&display_device_properties) | |
1030 .ExpectConnectToSignalPropertyChanged(); | |
1031 | |
1032 UPowerSignalDeviceAdded(mock_upower_.display_device); | |
1033 status = last_battery_status(); | |
1034 EXPECT_LT(last_count, count_battery_updates()); | |
1035 | |
1036 EXPECT_TRUE(status.charging); | |
1037 EXPECT_EQ(100, status.charging_time); | |
1038 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | |
1039 EXPECT_EQ(0.8, status.level); | |
1040 } | |
1041 | |
1042 // Prepending a battery should switch to that battery. | |
1043 TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedBatteryAtFront) { | |
1044 MockBatteryProperties battery_bat1_properties; | |
1045 battery_bat1_properties.state = | |
1046 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
1047 battery_bat1_properties.time_to_full = 0; | |
1048 battery_bat1_properties.time_to_empty = 200; | |
1049 battery_bat1_properties.percentage = 70; | |
1050 AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties) | |
1051 .ExpectConnectToSignalPropertyChanged(); | |
1052 | |
1053 StartBatteryStatusManagerLinux(); | |
1054 BatteryStatus status = last_battery_status(); | |
1055 EXPECT_LE(1, count_battery_updates()); | |
1056 | |
1057 EXPECT_FALSE(status.charging); | |
1058 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1059 EXPECT_EQ(200, status.discharging_time); | |
1060 EXPECT_EQ(0.7, status.level); | |
1061 | |
1062 int last_count = count_battery_updates(); | |
1063 MockBatteryProperties battery_bat0_properties; | |
1064 battery_bat0_properties.state = | |
1065 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
1066 battery_bat0_properties.time_to_full = 0; | |
1067 battery_bat0_properties.time_to_empty = 150; | |
1068 battery_bat0_properties.percentage = 50; | |
1069 PushFrontDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
1070 .ExpectConnectToSignalPropertyChanged(); | |
1071 UPowerSignalDeviceAdded(kUPowerDeviceBattery0Path); | |
1072 status = last_battery_status(); | |
1073 EXPECT_LT(last_count, count_battery_updates()); | |
1074 | |
1075 EXPECT_FALSE(status.charging); | |
1076 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1077 EXPECT_EQ(150, status.discharging_time); | |
1078 EXPECT_EQ(0.5, status.level); | |
1079 } | |
1080 | |
1081 // Appending a battery should keep the current battery. | |
1082 TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedBatteryAtBack) { | |
1083 MockBatteryProperties battery_bat0_properties; | |
1084 battery_bat0_properties.state = | |
1085 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
1086 battery_bat0_properties.time_to_full = 0; | |
1087 battery_bat0_properties.time_to_empty = 150; | |
1088 battery_bat0_properties.percentage = 50; | |
1089 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
1090 .ExpectConnectToSignalPropertyChanged(); | |
1091 | |
1092 StartBatteryStatusManagerLinux(); | |
1093 BatteryStatus status = last_battery_status(); | |
1094 EXPECT_LE(1, count_battery_updates()); | |
1095 | |
1096 EXPECT_FALSE(status.charging); | |
1097 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1098 EXPECT_EQ(150, status.discharging_time); | |
1099 EXPECT_EQ(0.5, status.level); | |
1100 | |
1101 int last_count = count_battery_updates(); | |
1102 MockBatteryProperties battery_bat1_properties; | |
1103 battery_bat1_properties.state = | |
1104 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
1105 battery_bat1_properties.time_to_full = 0; | |
1106 battery_bat1_properties.time_to_empty = 200; | |
1107 battery_bat1_properties.percentage = 70; | |
1108 AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties); | |
1109 UPowerSignalDeviceAdded(kUPowerDeviceBattery1Path); | |
1110 status = last_battery_status(); | |
1111 EXPECT_LT(last_count, count_battery_updates()); | |
1112 | |
1113 EXPECT_FALSE(status.charging); | |
1114 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1115 EXPECT_EQ(150, status.discharging_time); | |
1116 EXPECT_EQ(0.5, status.level); | |
1117 } | |
1118 | |
1119 // Adding a device that is no battery should not change anything. | |
1120 TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedNoBattery) { | |
1121 MockBatteryProperties battery_bat0_properties; | |
1122 battery_bat0_properties.state = | |
1123 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
1124 battery_bat0_properties.time_to_full = 0; | |
1125 battery_bat0_properties.time_to_empty = 200; | |
1126 battery_bat0_properties.percentage = 70; | |
1127 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
1128 .ExpectConnectToSignalPropertyChanged(); | |
1129 | |
1130 StartBatteryStatusManagerLinux(); | |
1131 BatteryStatus status = last_battery_status(); | |
1132 EXPECT_LE(1, count_battery_updates()); | |
1133 | |
1134 EXPECT_FALSE(status.charging); | |
1135 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1136 EXPECT_EQ(200, status.discharging_time); | |
1137 EXPECT_EQ(0.7, status.level); | |
1138 | |
1139 int last_count = count_battery_updates(); | |
1140 MockBatteryProperties line_power_AC_properties; | |
1141 line_power_AC_properties.type = | |
1142 UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER; | |
1143 PushFrontDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties); | |
1144 UPowerSignalDeviceAdded(kUPowerDeviceACLinePath); | |
1145 status = last_battery_status(); | |
1146 EXPECT_LT(last_count, count_battery_updates()); | |
1147 | |
1148 EXPECT_FALSE(status.charging); | |
1149 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1150 EXPECT_EQ(200, status.discharging_time); | |
1151 EXPECT_EQ(0.7, status.level); | |
1152 } | |
1153 | |
1154 TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceRemovedBattery) { | |
1155 MockBatteryProperties battery_bat0_properties; | |
1156 battery_bat0_properties.state = | |
1157 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
1158 battery_bat0_properties.time_to_full = 0; | |
1159 battery_bat0_properties.time_to_empty = 200; | |
1160 battery_bat0_properties.percentage = 70; | |
1161 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
1162 .ExpectConnectToSignalPropertyChanged(); | |
1163 | |
1164 MockBatteryProperties battery_bat1_properties; | |
1165 battery_bat1_properties.state = | |
1166 UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING; | |
1167 battery_bat1_properties.time_to_full = 100; | |
1168 battery_bat1_properties.time_to_empty = 0; | |
1169 battery_bat1_properties.percentage = 80; | |
1170 MockBatteryObject& battery_bat1 = | |
1171 AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties); | |
1172 | |
1173 StartBatteryStatusManagerLinux(); | |
1174 BatteryStatus status = last_battery_status(); | |
1175 EXPECT_LE(1, count_battery_updates()); | |
1176 | |
1177 EXPECT_FALSE(status.charging); | |
1178 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1179 EXPECT_EQ(200, status.discharging_time); | |
1180 EXPECT_EQ(0.7, status.level); | |
1181 | |
1182 int last_count = count_battery_updates(); | |
1183 ExpectGetObjectProxy(kUPowerDeviceBattery1Path, &battery_bat1); | |
1184 battery_bat1.ExpectConnectToSignalPropertyChanged(); | |
1185 | |
1186 EXPECT_EQ(kUPowerDeviceBattery0Path, mock_upower_.devices.front()); | |
1187 mock_upower_.devices.pop_front(); | |
1188 UPowerSignalDeviceRemoved(kUPowerDeviceBattery0Path); | |
1189 status = last_battery_status(); | |
1190 EXPECT_LT(last_count, count_battery_updates()); | |
1191 | |
1192 EXPECT_TRUE(status.charging); | |
1193 EXPECT_EQ(100, status.charging_time); | |
1194 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time); | |
1195 EXPECT_EQ(0.8, status.level); | |
1196 } | |
1197 | |
1198 TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceRemovedOther) { | |
1199 MockBatteryProperties battery_bat0_properties; | |
1200 battery_bat0_properties.state = | |
1201 UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING; | |
1202 battery_bat0_properties.time_to_full = 0; | |
1203 battery_bat0_properties.time_to_empty = 200; | |
1204 battery_bat0_properties.percentage = 70; | |
1205 AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties) | |
1206 .ExpectConnectToSignalPropertyChanged(); | |
1207 | |
1208 MockBatteryProperties line_power_AC_properties; | |
1209 line_power_AC_properties.type = | |
1210 UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER; | |
1211 AddDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties); | |
1212 | |
1213 StartBatteryStatusManagerLinux(); | |
1214 BatteryStatus status = last_battery_status(); | |
1215 EXPECT_LE(1, count_battery_updates()); | |
1216 | |
1217 EXPECT_FALSE(status.charging); | |
1218 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1219 EXPECT_EQ(200, status.discharging_time); | |
1220 EXPECT_EQ(0.7, status.level); | |
1221 | |
1222 int last_count = count_battery_updates(); | |
1223 mock_upower_.devices.pop_back(); | |
1224 UPowerSignalDeviceRemoved(kUPowerDeviceACLinePath); | |
1225 status = last_battery_status(); | |
1226 EXPECT_EQ(last_count, count_battery_updates()); | |
1227 | |
1228 EXPECT_FALSE(status.charging); | |
1229 EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time); | |
1230 EXPECT_EQ(200, status.discharging_time); | |
1231 EXPECT_EQ(0.7, status.level); | |
1232 } | |
142 | 1233 |
timvolodine
2016/06/16 16:12:24
nit: maybe an idea for extra test (which doesn't s
markuso
2016/06/17 08:45:19
True, there is no test for that.
There is "NoBatt
markuso
2016/06/17 10:01:17
With the added test "OldDaemonSignalDeviceChanged"
timvolodine
2016/07/05 16:21:07
yes, thanks, just thought that the 'no battery' ca
| |
143 } // namespace device | 1234 } // namespace device |
OLD | NEW |