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::_; |
Gaurav Shah | b790aa2 | 2012-10-23 12:51:12 -0700 | [diff] [blame] | 30 | using ::testing::ContainerEq; |
mukesh agrawal | 8abd2f6 | 2012-01-30 14:56:14 -0800 | [diff] [blame] | 31 | using ::testing::DoAll; |
| 32 | using ::testing::Invoke; |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 33 | using ::testing::Return; |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 34 | using ::testing::StrEq; |
| 35 | using ::testing::Test; |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 36 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 37 | namespace shill { |
| 38 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 39 | class DBusAdaptorTest : public PropertyStoreTest { |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 40 | public: |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 41 | DBusAdaptorTest() |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 42 | : ex_bool_(true), |
| 43 | ex_byte_(0xff), |
| 44 | ex_uint16_(65535), |
| 45 | ex_uint32_(2000000), |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 46 | ex_uint64_(8589934591LL), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 47 | ex_int16_(-32768), |
| 48 | ex_int32_(-65536), |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 49 | ex_path_("/"), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 50 | ex_string_("something"), |
| 51 | ex_strings_(1, ex_string_), |
| 52 | bool_v_(DBusAdaptor::BoolToVariant(ex_bool_)), |
| 53 | byte_v_(DBusAdaptor::ByteToVariant(ex_byte_)), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 54 | int16_v_(DBusAdaptor::Int16ToVariant(ex_int16_)), |
| 55 | int32_v_(DBusAdaptor::Int32ToVariant(ex_int32_)), |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 56 | path_v_(DBusAdaptor::PathToVariant(ex_path_)), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 57 | string_v_(DBusAdaptor::StringToVariant(ex_string_)), |
| 58 | strings_v_(DBusAdaptor::StringsToVariant(ex_strings_)), |
mukesh agrawal | f60e406 | 2011-05-27 13:13:41 -0700 | [diff] [blame] | 59 | uint16_v_(DBusAdaptor::Uint16ToVariant(ex_uint16_)), |
| 60 | uint32_v_(DBusAdaptor::Uint32ToVariant(ex_uint32_)), |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 61 | uint64_v_(DBusAdaptor::Uint64ToVariant(ex_uint64_)), |
Chris Masone | 2176a88 | 2011-09-14 22:29:15 -0700 | [diff] [blame] | 62 | device_(new MockDevice(control_interface(), |
| 63 | dispatcher(), |
Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 64 | metrics(), |
Chris Masone | 9d77993 | 2011-08-25 16:33:41 -0700 | [diff] [blame] | 65 | manager(), |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 66 | "mock", |
Chris Masone | 626719f | 2011-08-18 16:58:48 -0700 | [diff] [blame] | 67 | "addr0", |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 68 | 0)), |
Chris Masone | 2176a88 | 2011-09-14 22:29:15 -0700 | [diff] [blame] | 69 | service_(new MockService(control_interface(), |
| 70 | dispatcher(), |
Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 71 | metrics(), |
Chris Masone | 9d77993 | 2011-08-25 16:33:41 -0700 | [diff] [blame] | 72 | manager())) { |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 73 | ex_bytearrays_.push_back(ByteArray()); |
| 74 | bytearrays_v_ = DBusAdaptor::ByteArraysToVariant(ex_bytearrays_); |
| 75 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 76 | ex_stringmap_[ex_string_] = ex_string_; |
| 77 | stringmap_v_ = DBusAdaptor::StringmapToVariant(ex_stringmap_); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 78 | |
Gaurav Shah | b790aa2 | 2012-10-23 12:51:12 -0700 | [diff] [blame] | 79 | ex_stringmaps_.push_back(ex_stringmap_); |
| 80 | stringmaps_v_ = DBusAdaptor::StringmapsToVariant(ex_stringmaps_); |
| 81 | |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 82 | ex_paths_.push_back(ex_path_); |
| 83 | paths_v_ = DBusAdaptor::PathsToVariant(ex_paths_); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 84 | } |
| 85 | |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 86 | virtual ~DBusAdaptorTest() {} |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 87 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 88 | protected: |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 89 | bool ex_bool_; |
| 90 | uint8 ex_byte_; |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 91 | ByteArrays ex_bytearrays_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 92 | uint16 ex_uint16_; |
| 93 | uint32 ex_uint32_; |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 94 | uint64 ex_uint64_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 95 | int16 ex_int16_; |
| 96 | int32 ex_int32_; |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 97 | ::DBus::Path ex_path_; |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 98 | vector< ::DBus::Path> ex_paths_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 99 | string ex_string_; |
| 100 | map<string, string> ex_stringmap_; |
| 101 | vector<map<string, string> > ex_stringmaps_; |
| 102 | vector<string> ex_strings_; |
| 103 | |
| 104 | ::DBus::Variant bool_v_; |
| 105 | ::DBus::Variant byte_v_; |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 106 | ::DBus::Variant bytearrays_v_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 107 | ::DBus::Variant int16_v_; |
| 108 | ::DBus::Variant int32_v_; |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 109 | ::DBus::Variant path_v_; |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 110 | ::DBus::Variant paths_v_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 111 | ::DBus::Variant string_v_; |
| 112 | ::DBus::Variant stringmap_v_; |
| 113 | ::DBus::Variant stringmaps_v_; |
| 114 | ::DBus::Variant strings_v_; |
| 115 | ::DBus::Variant uint16_v_; |
| 116 | ::DBus::Variant uint32_v_; |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 117 | ::DBus::Variant uint64_v_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 118 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 119 | DeviceRefPtr device_; |
| 120 | ServiceRefPtr service_; |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 121 | }; |
| 122 | |
| 123 | TEST_F(DBusAdaptorTest, Conversions) { |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 124 | EXPECT_EQ(0, PropertyStoreTest::kBoolV.reader().get_bool()); |
| 125 | EXPECT_EQ(ex_bool_, bool_v_.reader().get_bool()); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 126 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 127 | EXPECT_EQ(0, PropertyStoreTest::kByteV.reader().get_byte()); |
| 128 | EXPECT_EQ(ex_byte_, byte_v_.reader().get_byte()); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 129 | |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 130 | EXPECT_TRUE(ex_bytearrays_ == bytearrays_v_.operator ByteArrays()); |
| 131 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 132 | EXPECT_EQ(0, PropertyStoreTest::kUint16V.reader().get_uint16()); |
| 133 | EXPECT_EQ(ex_uint16_, uint16_v_.reader().get_uint16()); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 134 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 135 | EXPECT_EQ(0, PropertyStoreTest::kInt16V.reader().get_int16()); |
| 136 | EXPECT_EQ(ex_int16_, int16_v_.reader().get_int16()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 137 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 138 | EXPECT_EQ(0, PropertyStoreTest::kUint32V.reader().get_uint32()); |
| 139 | EXPECT_EQ(ex_uint32_, uint32_v_.reader().get_uint32()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 140 | |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 141 | EXPECT_EQ(0, PropertyStoreTest::kUint64V.reader().get_uint64()); |
| 142 | EXPECT_EQ(ex_uint64_, uint64_v_.reader().get_uint64()); |
| 143 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 144 | EXPECT_EQ(0, PropertyStoreTest::kInt32V.reader().get_int32()); |
| 145 | EXPECT_EQ(ex_int32_, int32_v_.reader().get_int32()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 146 | |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 147 | EXPECT_EQ(ex_path_, path_v_.reader().get_path()); |
| 148 | |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 149 | EXPECT_EQ(ex_path_, paths_v_.operator vector< ::DBus::Path>()[0]); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 150 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 151 | EXPECT_EQ(string(""), PropertyStoreTest::kStringV.reader().get_string()); |
| 152 | EXPECT_EQ(ex_string_, string_v_.reader().get_string()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 153 | |
Gaurav Shah | b790aa2 | 2012-10-23 12:51:12 -0700 | [diff] [blame] | 154 | EXPECT_THAT(ex_stringmap_, |
| 155 | ContainerEq(stringmap_v_.operator map<string, string>())); |
| 156 | EXPECT_THAT(ex_strings_, |
| 157 | ContainerEq(strings_v_.operator vector<string>())); |
| 158 | EXPECT_THAT( |
| 159 | ex_stringmaps_, |
| 160 | ContainerEq(stringmaps_v_.operator vector<map<string, string> >())); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 161 | } |
| 162 | |
| 163 | TEST_F(DBusAdaptorTest, Signatures) { |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 164 | EXPECT_TRUE(DBusAdaptor::IsBool(bool_v_.signature())); |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 165 | EXPECT_TRUE(DBusAdaptor::IsByteArrays(bytearrays_v_.signature())); |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 166 | EXPECT_TRUE(DBusAdaptor::IsByte(byte_v_.signature())); |
| 167 | EXPECT_TRUE(DBusAdaptor::IsInt16(int16_v_.signature())); |
| 168 | EXPECT_TRUE(DBusAdaptor::IsInt32(int32_v_.signature())); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 169 | EXPECT_TRUE(DBusAdaptor::IsPath(path_v_.signature())); |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 170 | EXPECT_TRUE(DBusAdaptor::IsPaths(paths_v_.signature())); |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 171 | EXPECT_TRUE(DBusAdaptor::IsString(string_v_.signature())); |
| 172 | EXPECT_TRUE(DBusAdaptor::IsStringmap(stringmap_v_.signature())); |
| 173 | EXPECT_TRUE(DBusAdaptor::IsStrings(strings_v_.signature())); |
| 174 | EXPECT_TRUE(DBusAdaptor::IsUint16(uint16_v_.signature())); |
| 175 | EXPECT_TRUE(DBusAdaptor::IsUint32(uint32_v_.signature())); |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 176 | EXPECT_TRUE(DBusAdaptor::IsUint64(uint64_v_.signature())); |
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_FALSE(DBusAdaptor::IsBool(byte_v_.signature())); |
| 179 | EXPECT_FALSE(DBusAdaptor::IsStrings(string_v_.signature())); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 180 | } |
| 181 | |
mukesh agrawal | 6bb9e7c | 2012-01-30 14:57:54 -0800 | [diff] [blame] | 182 | TEST_F(DBusAdaptorTest, SetProperty) { |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 183 | MockPropertyStore store; |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 184 | ::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] | 185 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 186 | EXPECT_CALL(store, Contains(_)).WillRepeatedly(Return(true)); |
| 187 | EXPECT_CALL(store, SetBoolProperty("", _, _)).WillOnce(Return(true)); |
| 188 | EXPECT_CALL(store, SetInt16Property("", _, _)).WillOnce(Return(true)); |
| 189 | EXPECT_CALL(store, SetInt32Property("", _, _)).WillOnce(Return(true)); |
| 190 | EXPECT_CALL(store, SetStringProperty("", _, _)) |
| 191 | .WillOnce(Return(true)); |
| 192 | EXPECT_CALL(store, SetStringmapProperty("", _, _)) |
| 193 | .WillOnce(Return(true)); |
| 194 | EXPECT_CALL(store, SetStringsProperty("", _, _)) |
| 195 | .WillOnce(Return(true)); |
| 196 | EXPECT_CALL(store, SetUint8Property("", _, _)).WillOnce(Return(true)); |
| 197 | EXPECT_CALL(store, SetUint16Property("", _, _)).WillOnce(Return(true)); |
| 198 | EXPECT_CALL(store, SetUint32Property("", _, _)).WillOnce(Return(true)); |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 199 | EXPECT_CALL(store, SetUint64Property("", _, _)).WillOnce(Return(true)); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 200 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 201 | string string_path("/false/path"); |
| 202 | ::DBus::Path path(string_path); |
| 203 | ::DBus::Variant path_v = DBusAdaptor::PathToVariant(path); |
| 204 | EXPECT_CALL(store, SetStringProperty("", StrEq(string_path), _)) |
| 205 | .WillOnce(Return(true)); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 206 | |
mukesh agrawal | 6bb9e7c | 2012-01-30 14:57:54 -0800 | [diff] [blame] | 207 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", bool_v_, &e1)); |
| 208 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", path_v, &e2)); |
| 209 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", string_v_, &e3)); |
| 210 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", strings_v_, &e4)); |
| 211 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", int16_v_, &e5)); |
| 212 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", int32_v_, &e6)); |
| 213 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", uint16_v_, &e7)); |
| 214 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", uint32_v_, &e8)); |
Paul Stewart | e18c33b | 2012-07-10 20:48:44 -0700 | [diff] [blame] | 215 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", uint64_v_, &e9)); |
| 216 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", stringmap_v_, &e10)); |
| 217 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", byte_v_, &e11)); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 218 | } |
| 219 | |
mukesh agrawal | bebf1b8 | 2013-04-23 15:06:33 -0700 | [diff] [blame] | 220 | // SetProperty method should propagate failures. This should happen |
| 221 | // even if error isn't set. (This is to accomodate the fact that, if |
| 222 | // the property already has the desired value, the store will return |
| 223 | // false, without setting an error.) |
| 224 | TEST_F(DBusAdaptorTest, SetPropertyFailure) { |
| 225 | MockPropertyStore store; |
| 226 | ::DBus::Error e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11; |
| 227 | |
| 228 | EXPECT_CALL(store, Contains(_)).WillRepeatedly(Return(false)); |
| 229 | EXPECT_CALL(store, SetBoolProperty("", _, _)).WillOnce(Return(false)); |
| 230 | EXPECT_CALL(store, SetInt16Property("", _, _)).WillOnce(Return(false)); |
| 231 | EXPECT_CALL(store, SetInt32Property("", _, _)).WillOnce(Return(false)); |
| 232 | EXPECT_CALL(store, SetStringProperty("", _, _)) |
| 233 | .WillOnce(Return(false)); |
| 234 | EXPECT_CALL(store, SetStringmapProperty("", _, _)) |
| 235 | .WillOnce(Return(false)); |
| 236 | EXPECT_CALL(store, SetStringsProperty("", _, _)) |
| 237 | .WillOnce(Return(false)); |
| 238 | EXPECT_CALL(store, SetUint8Property("", _, _)).WillOnce(Return(false)); |
| 239 | EXPECT_CALL(store, SetUint16Property("", _, _)).WillOnce(Return(false)); |
| 240 | EXPECT_CALL(store, SetUint32Property("", _, _)).WillOnce(Return(false)); |
| 241 | EXPECT_CALL(store, SetUint64Property("", _, _)).WillOnce(Return(false)); |
| 242 | |
| 243 | string string_path("/false/path"); |
| 244 | ::DBus::Path path(string_path); |
| 245 | ::DBus::Variant path_v = DBusAdaptor::PathToVariant(path); |
| 246 | EXPECT_CALL(store, SetStringProperty("", StrEq(string_path), _)) |
| 247 | .WillOnce(Return(false)); |
| 248 | |
| 249 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", bool_v_, &e1)); |
| 250 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", path_v, &e2)); |
| 251 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", string_v_, &e3)); |
| 252 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", strings_v_, &e4)); |
| 253 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", int16_v_, &e5)); |
| 254 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", int32_v_, &e6)); |
| 255 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", uint16_v_, &e7)); |
| 256 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", uint32_v_, &e8)); |
| 257 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", uint64_v_, &e9)); |
| 258 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", stringmap_v_, &e10)); |
| 259 | EXPECT_FALSE(DBusAdaptor::SetProperty(&store, "", byte_v_, &e11)); |
| 260 | } |
| 261 | |
mukesh agrawal | 8abd2f6 | 2012-01-30 14:56:14 -0800 | [diff] [blame] | 262 | void SetError(const string &/*name*/, Error *error) { |
| 263 | error->Populate(Error::kInvalidProperty); |
| 264 | } |
| 265 | |
| 266 | TEST_F(DBusAdaptorTest, ClearProperty) { |
| 267 | MockPropertyStore store; |
| 268 | ::DBus::Error e1, e2; |
| 269 | |
| 270 | EXPECT_CALL(store, ClearProperty("valid property", _)). |
| 271 | WillOnce(Return(true)); |
| 272 | EXPECT_CALL(store, ClearProperty("invalid property", _)). |
| 273 | WillOnce(DoAll(Invoke(SetError), |
| 274 | Return(false))); |
| 275 | EXPECT_TRUE(DBusAdaptor::ClearProperty(&store, "valid property", &e1)); |
| 276 | EXPECT_FALSE(DBusAdaptor::ClearProperty(&store, "invalid property", &e2)); |
| 277 | |
| 278 | } |
| 279 | |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 280 | TEST_F(DBusAdaptorTest, ArgsToKeyValueStore) { |
Darin Petkov | 25665aa | 2012-05-21 14:08:12 +0200 | [diff] [blame] | 281 | map<string, ::DBus::Variant> args; |
| 282 | KeyValueStore args_kv; |
| 283 | Error error; |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 284 | |
Darin Petkov | 25665aa | 2012-05-21 14:08:12 +0200 | [diff] [blame] | 285 | args["string_arg"].writer().append_string("string"); |
| 286 | args["bool_arg"].writer().append_bool(true); |
| 287 | DBusAdaptor::ArgsToKeyValueStore(args, &args_kv, &error); |
| 288 | EXPECT_TRUE(error.IsSuccess()); |
| 289 | EXPECT_EQ("string", args_kv.GetString("string_arg")); |
| 290 | EXPECT_EQ(true, args_kv.GetBool("bool_arg")); |
| 291 | } |
| 292 | |
| 293 | TEST_F(DBusAdaptorTest, KeyValueStoreToVariant) { |
| 294 | static const char kStringKey[] = "StringKey"; |
| 295 | static const char kStringValue[] = "StringValue"; |
| 296 | static const char kBoolKey[] = "BoolKey"; |
| 297 | const bool kBoolValue = true; |
| 298 | KeyValueStore store; |
| 299 | store.SetString(kStringKey, kStringValue); |
| 300 | store.SetBool(kBoolKey, kBoolValue); |
| 301 | DBus::Variant var = DBusAdaptor::KeyValueStoreToVariant(store); |
| 302 | ASSERT_TRUE(DBusAdaptor::IsKeyValueStore(var.signature())); |
| 303 | DBusPropertiesMap props = var.operator DBusPropertiesMap(); |
| 304 | // Sanity test the result. |
| 305 | EXPECT_EQ(2, props.size()); |
| 306 | string string_value; |
| 307 | EXPECT_TRUE(DBusProperties::GetString(props, kStringKey, &string_value)); |
| 308 | EXPECT_EQ(kStringValue, string_value); |
| 309 | bool bool_value = !kBoolValue; |
| 310 | EXPECT_TRUE(DBusProperties::GetBool(props, kBoolKey, &bool_value)); |
| 311 | EXPECT_EQ(kBoolValue, bool_value); |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 312 | } |
| 313 | |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 314 | } // namespace shill |