Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 5 | #include "shill/dbus_adaptor.h" |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 6 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 7 | #include <map> |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 8 | #include <string> |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 9 | #include <vector> |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 10 | |
| 11 | #include <dbus-c++/dbus.h> |
| 12 | #include <gtest/gtest.h> |
| 13 | #include <gmock/gmock.h> |
| 14 | |
Paul Stewart | 26b327e | 2011-10-19 11:38:09 -0700 | [diff] [blame] | 15 | #include "shill/event_dispatcher.h" |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 16 | #include "shill/key_value_store.h" |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 17 | #include "shill/manager.h" |
| 18 | #include "shill/mock_control.h" |
| 19 | #include "shill/mock_device.h" |
Chris Masone | 7aa5f90 | 2011-07-11 11:13:35 -0700 | [diff] [blame] | 20 | #include "shill/mock_glib.h" |
| 21 | #include "shill/mock_profile.h" |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 22 | #include "shill/mock_property_store.h" |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 23 | #include "shill/mock_service.h" |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 24 | #include "shill/property_store_unittest.h" |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 25 | |
| 26 | using std::map; |
| 27 | using std::string; |
| 28 | using std::vector; |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 29 | using ::testing::_; |
mukesh agrawal | 8abd2f6 | 2012-01-30 14:56:14 -0800 | [diff] [blame] | 30 | using ::testing::DoAll; |
| 31 | using ::testing::Invoke; |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 32 | using ::testing::Return; |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 33 | using ::testing::StrEq; |
| 34 | using ::testing::Test; |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 35 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 36 | namespace shill { |
| 37 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 38 | class DBusAdaptorTest : public PropertyStoreTest { |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 39 | public: |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 40 | DBusAdaptorTest() |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 41 | : ex_bool_(true), |
| 42 | ex_byte_(0xff), |
| 43 | ex_uint16_(65535), |
| 44 | ex_uint32_(2000000), |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 45 | ex_uint64_(8589934591LL), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 46 | ex_int16_(-32768), |
| 47 | ex_int32_(-65536), |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 48 | ex_path_("/"), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 49 | ex_string_("something"), |
| 50 | ex_strings_(1, ex_string_), |
| 51 | bool_v_(DBusAdaptor::BoolToVariant(ex_bool_)), |
| 52 | byte_v_(DBusAdaptor::ByteToVariant(ex_byte_)), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 53 | int16_v_(DBusAdaptor::Int16ToVariant(ex_int16_)), |
| 54 | int32_v_(DBusAdaptor::Int32ToVariant(ex_int32_)), |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 55 | path_v_(DBusAdaptor::PathToVariant(ex_path_)), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 56 | string_v_(DBusAdaptor::StringToVariant(ex_string_)), |
| 57 | strings_v_(DBusAdaptor::StringsToVariant(ex_strings_)), |
mukesh agrawal | f60e406 | 2011-05-27 13:13:41 -0700 | [diff] [blame] | 58 | uint16_v_(DBusAdaptor::Uint16ToVariant(ex_uint16_)), |
| 59 | uint32_v_(DBusAdaptor::Uint32ToVariant(ex_uint32_)), |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 60 | uint64_v_(DBusAdaptor::Uint64ToVariant(ex_uint64_)), |
Chris Masone | 2176a88 | 2011-09-14 22:29:15 -0700 | [diff] [blame] | 61 | device_(new MockDevice(control_interface(), |
| 62 | dispatcher(), |
Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 63 | metrics(), |
Chris Masone | 9d77993 | 2011-08-25 16:33:41 -0700 | [diff] [blame] | 64 | manager(), |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 65 | "mock", |
Chris Masone | 626719f | 2011-08-18 16:58:48 -0700 | [diff] [blame] | 66 | "addr0", |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 67 | 0)), |
Chris Masone | 2176a88 | 2011-09-14 22:29:15 -0700 | [diff] [blame] | 68 | service_(new MockService(control_interface(), |
| 69 | dispatcher(), |
Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 70 | metrics(), |
Chris Masone | 9d77993 | 2011-08-25 16:33:41 -0700 | [diff] [blame] | 71 | manager())) { |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 72 | ex_bytearrays_.push_back(ByteArray()); |
| 73 | bytearrays_v_ = DBusAdaptor::ByteArraysToVariant(ex_bytearrays_); |
| 74 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 75 | ex_stringmap_[ex_string_] = ex_string_; |
| 76 | stringmap_v_ = DBusAdaptor::StringmapToVariant(ex_stringmap_); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 77 | |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 78 | ex_paths_.push_back(ex_path_); |
| 79 | paths_v_ = DBusAdaptor::PathsToVariant(ex_paths_); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 80 | } |
| 81 | |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 82 | virtual ~DBusAdaptorTest() {} |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 83 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 84 | protected: |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 85 | bool ex_bool_; |
| 86 | uint8 ex_byte_; |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 87 | ByteArrays ex_bytearrays_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 88 | uint16 ex_uint16_; |
| 89 | uint32 ex_uint32_; |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 90 | uint64 ex_uint64_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 91 | int16 ex_int16_; |
| 92 | int32 ex_int32_; |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 93 | ::DBus::Path ex_path_; |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 94 | vector< ::DBus::Path> ex_paths_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 95 | string ex_string_; |
| 96 | map<string, string> ex_stringmap_; |
| 97 | vector<map<string, string> > ex_stringmaps_; |
| 98 | vector<string> ex_strings_; |
| 99 | |
| 100 | ::DBus::Variant bool_v_; |
| 101 | ::DBus::Variant byte_v_; |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 102 | ::DBus::Variant bytearrays_v_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 103 | ::DBus::Variant int16_v_; |
| 104 | ::DBus::Variant int32_v_; |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 105 | ::DBus::Variant path_v_; |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 106 | ::DBus::Variant paths_v_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 107 | ::DBus::Variant string_v_; |
| 108 | ::DBus::Variant stringmap_v_; |
| 109 | ::DBus::Variant stringmaps_v_; |
| 110 | ::DBus::Variant strings_v_; |
| 111 | ::DBus::Variant uint16_v_; |
| 112 | ::DBus::Variant uint32_v_; |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 113 | ::DBus::Variant uint64_v_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 114 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 115 | DeviceRefPtr device_; |
| 116 | ServiceRefPtr service_; |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 117 | }; |
| 118 | |
| 119 | TEST_F(DBusAdaptorTest, Conversions) { |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 120 | EXPECT_EQ(0, PropertyStoreTest::kBoolV.reader().get_bool()); |
| 121 | EXPECT_EQ(ex_bool_, bool_v_.reader().get_bool()); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 122 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 123 | EXPECT_EQ(0, PropertyStoreTest::kByteV.reader().get_byte()); |
| 124 | EXPECT_EQ(ex_byte_, byte_v_.reader().get_byte()); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 125 | |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 126 | EXPECT_TRUE(ex_bytearrays_ == bytearrays_v_.operator ByteArrays()); |
| 127 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 128 | EXPECT_EQ(0, PropertyStoreTest::kUint16V.reader().get_uint16()); |
| 129 | EXPECT_EQ(ex_uint16_, uint16_v_.reader().get_uint16()); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 130 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 131 | EXPECT_EQ(0, PropertyStoreTest::kInt16V.reader().get_int16()); |
| 132 | EXPECT_EQ(ex_int16_, int16_v_.reader().get_int16()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 133 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 134 | EXPECT_EQ(0, PropertyStoreTest::kUint32V.reader().get_uint32()); |
| 135 | EXPECT_EQ(ex_uint32_, uint32_v_.reader().get_uint32()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 136 | |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 137 | EXPECT_EQ(0, PropertyStoreTest::kUint64V.reader().get_uint64()); |
| 138 | EXPECT_EQ(ex_uint64_, uint64_v_.reader().get_uint64()); |
| 139 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 140 | EXPECT_EQ(0, PropertyStoreTest::kInt32V.reader().get_int32()); |
| 141 | EXPECT_EQ(ex_int32_, int32_v_.reader().get_int32()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 142 | |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 143 | EXPECT_EQ(ex_path_, path_v_.reader().get_path()); |
| 144 | |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 145 | EXPECT_EQ(ex_path_, paths_v_.operator vector< ::DBus::Path>()[0]); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 146 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 147 | EXPECT_EQ(string(""), PropertyStoreTest::kStringV.reader().get_string()); |
| 148 | EXPECT_EQ(ex_string_, string_v_.reader().get_string()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 149 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 150 | EXPECT_EQ(ex_stringmap_[ex_string_], |
| 151 | (stringmap_v_.operator map<string, string>()[ex_string_])); |
| 152 | EXPECT_EQ(ex_strings_[0], strings_v_.operator vector<string>()[0]); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 153 | } |
| 154 | |
| 155 | TEST_F(DBusAdaptorTest, Signatures) { |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 156 | EXPECT_TRUE(DBusAdaptor::IsBool(bool_v_.signature())); |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 157 | EXPECT_TRUE(DBusAdaptor::IsByteArrays(bytearrays_v_.signature())); |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 158 | EXPECT_TRUE(DBusAdaptor::IsByte(byte_v_.signature())); |
| 159 | EXPECT_TRUE(DBusAdaptor::IsInt16(int16_v_.signature())); |
| 160 | EXPECT_TRUE(DBusAdaptor::IsInt32(int32_v_.signature())); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 161 | EXPECT_TRUE(DBusAdaptor::IsPath(path_v_.signature())); |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 162 | EXPECT_TRUE(DBusAdaptor::IsPaths(paths_v_.signature())); |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 163 | EXPECT_TRUE(DBusAdaptor::IsString(string_v_.signature())); |
| 164 | EXPECT_TRUE(DBusAdaptor::IsStringmap(stringmap_v_.signature())); |
| 165 | EXPECT_TRUE(DBusAdaptor::IsStrings(strings_v_.signature())); |
| 166 | EXPECT_TRUE(DBusAdaptor::IsUint16(uint16_v_.signature())); |
| 167 | EXPECT_TRUE(DBusAdaptor::IsUint32(uint32_v_.signature())); |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 168 | EXPECT_TRUE(DBusAdaptor::IsUint64(uint64_v_.signature())); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 169 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 170 | EXPECT_FALSE(DBusAdaptor::IsBool(byte_v_.signature())); |
| 171 | EXPECT_FALSE(DBusAdaptor::IsStrings(string_v_.signature())); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 172 | } |
| 173 | |
mukesh agrawal | 6bb9e7c | 2012-01-30 14:57:54 -0800 | [diff] [blame] | 174 | TEST_F(DBusAdaptorTest, SetProperty) { |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 175 | MockPropertyStore store; |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 176 | ::DBus::Error e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11; |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 177 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 178 | EXPECT_CALL(store, Contains(_)).WillRepeatedly(Return(true)); |
| 179 | EXPECT_CALL(store, SetBoolProperty("", _, _)).WillOnce(Return(true)); |
| 180 | EXPECT_CALL(store, SetInt16Property("", _, _)).WillOnce(Return(true)); |
| 181 | EXPECT_CALL(store, SetInt32Property("", _, _)).WillOnce(Return(true)); |
| 182 | EXPECT_CALL(store, SetStringProperty("", _, _)) |
| 183 | .WillOnce(Return(true)); |
| 184 | EXPECT_CALL(store, SetStringmapProperty("", _, _)) |
| 185 | .WillOnce(Return(true)); |
| 186 | EXPECT_CALL(store, SetStringsProperty("", _, _)) |
| 187 | .WillOnce(Return(true)); |
| 188 | EXPECT_CALL(store, SetUint8Property("", _, _)).WillOnce(Return(true)); |
| 189 | EXPECT_CALL(store, SetUint16Property("", _, _)).WillOnce(Return(true)); |
| 190 | EXPECT_CALL(store, SetUint32Property("", _, _)).WillOnce(Return(true)); |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 191 | EXPECT_CALL(store, SetUint64Property("", _, _)).WillOnce(Return(true)); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 192 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 193 | string string_path("/false/path"); |
| 194 | ::DBus::Path path(string_path); |
| 195 | ::DBus::Variant path_v = DBusAdaptor::PathToVariant(path); |
| 196 | EXPECT_CALL(store, SetStringProperty("", StrEq(string_path), _)) |
| 197 | .WillOnce(Return(true)); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 198 | |
mukesh agrawal | 6bb9e7c | 2012-01-30 14:57:54 -0800 | [diff] [blame] | 199 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", bool_v_, &e1)); |
| 200 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", path_v, &e2)); |
| 201 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", string_v_, &e3)); |
| 202 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", strings_v_, &e4)); |
| 203 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", int16_v_, &e5)); |
| 204 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", int32_v_, &e6)); |
| 205 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", uint16_v_, &e7)); |
| 206 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", uint32_v_, &e8)); |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 207 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", uint64_v_, &e9)); |
| 208 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", stringmap_v_, &e10)); |
| 209 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", byte_v_, &e11)); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 210 | } |
| 211 | |
mukesh agrawal | 8abd2f6 | 2012-01-30 14:56:14 -0800 | [diff] [blame] | 212 | void SetError(const string &/*name*/, Error *error) { |
| 213 | error->Populate(Error::kInvalidProperty); |
| 214 | } |
| 215 | |
| 216 | TEST_F(DBusAdaptorTest, ClearProperty) { |
| 217 | MockPropertyStore store; |
| 218 | ::DBus::Error e1, e2; |
| 219 | |
| 220 | EXPECT_CALL(store, ClearProperty("valid property", _)). |
| 221 | WillOnce(Return(true)); |
| 222 | EXPECT_CALL(store, ClearProperty("invalid property", _)). |
| 223 | WillOnce(DoAll(Invoke(SetError), |
| 224 | Return(false))); |
| 225 | EXPECT_TRUE(DBusAdaptor::ClearProperty(&store, "valid property", &e1)); |
| 226 | EXPECT_FALSE(DBusAdaptor::ClearProperty(&store, "invalid property", &e2)); |
| 227 | |
| 228 | } |
| 229 | |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 230 | TEST_F(DBusAdaptorTest, ArgsToKeyValueStore) { |
Darin Petkov | 25665aa | 2012-05-21 14:08:12 +0200 | [diff] [blame] | 231 | map<string, ::DBus::Variant> args; |
| 232 | KeyValueStore args_kv; |
| 233 | Error error; |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 234 | |
Darin Petkov | 25665aa | 2012-05-21 14:08:12 +0200 | [diff] [blame] | 235 | args["string_arg"].writer().append_string("string"); |
| 236 | args["bool_arg"].writer().append_bool(true); |
| 237 | DBusAdaptor::ArgsToKeyValueStore(args, &args_kv, &error); |
| 238 | EXPECT_TRUE(error.IsSuccess()); |
| 239 | EXPECT_EQ("string", args_kv.GetString("string_arg")); |
| 240 | EXPECT_EQ(true, args_kv.GetBool("bool_arg")); |
| 241 | } |
| 242 | |
| 243 | TEST_F(DBusAdaptorTest, KeyValueStoreToVariant) { |
| 244 | static const char kStringKey[] = "StringKey"; |
| 245 | static const char kStringValue[] = "StringValue"; |
| 246 | static const char kBoolKey[] = "BoolKey"; |
| 247 | const bool kBoolValue = true; |
| 248 | KeyValueStore store; |
| 249 | store.SetString(kStringKey, kStringValue); |
| 250 | store.SetBool(kBoolKey, kBoolValue); |
| 251 | DBus::Variant var = DBusAdaptor::KeyValueStoreToVariant(store); |
| 252 | ASSERT_TRUE(DBusAdaptor::IsKeyValueStore(var.signature())); |
| 253 | DBusPropertiesMap props = var.operator DBusPropertiesMap(); |
| 254 | // Sanity test the result. |
| 255 | EXPECT_EQ(2, props.size()); |
| 256 | string string_value; |
| 257 | EXPECT_TRUE(DBusProperties::GetString(props, kStringKey, &string_value)); |
| 258 | EXPECT_EQ(kStringValue, string_value); |
| 259 | bool bool_value = !kBoolValue; |
| 260 | EXPECT_TRUE(DBusProperties::GetBool(props, kBoolKey, &bool_value)); |
| 261 | EXPECT_EQ(kBoolValue, bool_value); |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 262 | } |
| 263 | |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 264 | } // namespace shill |