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), |
| 45 | ex_int16_(-32768), |
| 46 | ex_int32_(-65536), |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 47 | ex_path_("/"), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 48 | ex_string_("something"), |
| 49 | ex_strings_(1, ex_string_), |
| 50 | bool_v_(DBusAdaptor::BoolToVariant(ex_bool_)), |
| 51 | byte_v_(DBusAdaptor::ByteToVariant(ex_byte_)), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 52 | int16_v_(DBusAdaptor::Int16ToVariant(ex_int16_)), |
| 53 | int32_v_(DBusAdaptor::Int32ToVariant(ex_int32_)), |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 54 | path_v_(DBusAdaptor::PathToVariant(ex_path_)), |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 55 | string_v_(DBusAdaptor::StringToVariant(ex_string_)), |
| 56 | strings_v_(DBusAdaptor::StringsToVariant(ex_strings_)), |
mukesh agrawal | f60e406 | 2011-05-27 13:13:41 -0700 | [diff] [blame] | 57 | uint16_v_(DBusAdaptor::Uint16ToVariant(ex_uint16_)), |
| 58 | uint32_v_(DBusAdaptor::Uint32ToVariant(ex_uint32_)), |
Chris Masone | 2176a88 | 2011-09-14 22:29:15 -0700 | [diff] [blame] | 59 | device_(new MockDevice(control_interface(), |
| 60 | dispatcher(), |
Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 61 | metrics(), |
Chris Masone | 9d77993 | 2011-08-25 16:33:41 -0700 | [diff] [blame] | 62 | manager(), |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 63 | "mock", |
Chris Masone | 626719f | 2011-08-18 16:58:48 -0700 | [diff] [blame] | 64 | "addr0", |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 65 | 0)), |
Chris Masone | 2176a88 | 2011-09-14 22:29:15 -0700 | [diff] [blame] | 66 | service_(new MockService(control_interface(), |
| 67 | dispatcher(), |
Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 68 | metrics(), |
Chris Masone | 9d77993 | 2011-08-25 16:33:41 -0700 | [diff] [blame] | 69 | manager())) { |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 70 | ex_bytearrays_.push_back(ByteArray()); |
| 71 | bytearrays_v_ = DBusAdaptor::ByteArraysToVariant(ex_bytearrays_); |
| 72 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 73 | ex_stringmap_[ex_string_] = ex_string_; |
| 74 | stringmap_v_ = DBusAdaptor::StringmapToVariant(ex_stringmap_); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 75 | |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 76 | ex_paths_.push_back(ex_path_); |
| 77 | paths_v_ = DBusAdaptor::PathsToVariant(ex_paths_); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 78 | } |
| 79 | |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 80 | virtual ~DBusAdaptorTest() {} |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 81 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 82 | protected: |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 83 | bool ex_bool_; |
| 84 | uint8 ex_byte_; |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 85 | ByteArrays ex_bytearrays_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 86 | uint16 ex_uint16_; |
| 87 | uint32 ex_uint32_; |
| 88 | int16 ex_int16_; |
| 89 | int32 ex_int32_; |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 90 | ::DBus::Path ex_path_; |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 91 | vector< ::DBus::Path> ex_paths_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 92 | string ex_string_; |
| 93 | map<string, string> ex_stringmap_; |
| 94 | vector<map<string, string> > ex_stringmaps_; |
| 95 | vector<string> ex_strings_; |
| 96 | |
| 97 | ::DBus::Variant bool_v_; |
| 98 | ::DBus::Variant byte_v_; |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 99 | ::DBus::Variant bytearrays_v_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 100 | ::DBus::Variant int16_v_; |
| 101 | ::DBus::Variant int32_v_; |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 102 | ::DBus::Variant path_v_; |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 103 | ::DBus::Variant paths_v_; |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 104 | ::DBus::Variant string_v_; |
| 105 | ::DBus::Variant stringmap_v_; |
| 106 | ::DBus::Variant stringmaps_v_; |
| 107 | ::DBus::Variant strings_v_; |
| 108 | ::DBus::Variant uint16_v_; |
| 109 | ::DBus::Variant uint32_v_; |
| 110 | |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 111 | DeviceRefPtr device_; |
| 112 | ServiceRefPtr service_; |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 113 | }; |
| 114 | |
| 115 | TEST_F(DBusAdaptorTest, Conversions) { |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 116 | EXPECT_EQ(0, PropertyStoreTest::kBoolV.reader().get_bool()); |
| 117 | EXPECT_EQ(ex_bool_, bool_v_.reader().get_bool()); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 118 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 119 | EXPECT_EQ(0, PropertyStoreTest::kByteV.reader().get_byte()); |
| 120 | EXPECT_EQ(ex_byte_, byte_v_.reader().get_byte()); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 121 | |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 122 | EXPECT_TRUE(ex_bytearrays_ == bytearrays_v_.operator ByteArrays()); |
| 123 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 124 | EXPECT_EQ(0, PropertyStoreTest::kUint16V.reader().get_uint16()); |
| 125 | EXPECT_EQ(ex_uint16_, uint16_v_.reader().get_uint16()); |
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::kInt16V.reader().get_int16()); |
| 128 | EXPECT_EQ(ex_int16_, int16_v_.reader().get_int16()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 129 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 130 | EXPECT_EQ(0, PropertyStoreTest::kUint32V.reader().get_uint32()); |
| 131 | EXPECT_EQ(ex_uint32_, uint32_v_.reader().get_uint32()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 132 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 133 | EXPECT_EQ(0, PropertyStoreTest::kInt32V.reader().get_int32()); |
| 134 | EXPECT_EQ(ex_int32_, int32_v_.reader().get_int32()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 135 | |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 136 | EXPECT_EQ(ex_path_, path_v_.reader().get_path()); |
| 137 | |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 138 | EXPECT_EQ(ex_path_, paths_v_.operator vector< ::DBus::Path>()[0]); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 139 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 140 | EXPECT_EQ(string(""), PropertyStoreTest::kStringV.reader().get_string()); |
| 141 | EXPECT_EQ(ex_string_, string_v_.reader().get_string()); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 142 | |
Chris Masone | b925cc8 | 2011-06-22 15:39:57 -0700 | [diff] [blame] | 143 | EXPECT_EQ(ex_stringmap_[ex_string_], |
| 144 | (stringmap_v_.operator map<string, string>()[ex_string_])); |
| 145 | EXPECT_EQ(ex_strings_[0], strings_v_.operator vector<string>()[0]); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 146 | } |
| 147 | |
| 148 | TEST_F(DBusAdaptorTest, Signatures) { |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 149 | EXPECT_TRUE(DBusAdaptor::IsBool(bool_v_.signature())); |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 150 | EXPECT_TRUE(DBusAdaptor::IsByteArrays(bytearrays_v_.signature())); |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 151 | EXPECT_TRUE(DBusAdaptor::IsByte(byte_v_.signature())); |
| 152 | EXPECT_TRUE(DBusAdaptor::IsInt16(int16_v_.signature())); |
| 153 | EXPECT_TRUE(DBusAdaptor::IsInt32(int32_v_.signature())); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 154 | EXPECT_TRUE(DBusAdaptor::IsPath(path_v_.signature())); |
mukesh agrawal | 2366eed | 2012-03-20 18:21:50 -0700 | [diff] [blame] | 155 | EXPECT_TRUE(DBusAdaptor::IsPaths(paths_v_.signature())); |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 156 | EXPECT_TRUE(DBusAdaptor::IsString(string_v_.signature())); |
| 157 | EXPECT_TRUE(DBusAdaptor::IsStringmap(stringmap_v_.signature())); |
| 158 | EXPECT_TRUE(DBusAdaptor::IsStrings(strings_v_.signature())); |
| 159 | EXPECT_TRUE(DBusAdaptor::IsUint16(uint16_v_.signature())); |
| 160 | EXPECT_TRUE(DBusAdaptor::IsUint32(uint32_v_.signature())); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 161 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 162 | EXPECT_FALSE(DBusAdaptor::IsBool(byte_v_.signature())); |
| 163 | EXPECT_FALSE(DBusAdaptor::IsStrings(string_v_.signature())); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 164 | } |
| 165 | |
mukesh agrawal | 6bb9e7c | 2012-01-30 14:57:54 -0800 | [diff] [blame] | 166 | TEST_F(DBusAdaptorTest, SetProperty) { |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 167 | MockPropertyStore store; |
mukesh agrawal | a903e41 | 2011-06-28 17:07:11 -0700 | [diff] [blame] | 168 | ::DBus::Error e1, e2, e3, e4, e5, e6, e7, e8, e9, e10; |
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_CALL(store, Contains(_)).WillRepeatedly(Return(true)); |
| 171 | EXPECT_CALL(store, SetBoolProperty("", _, _)).WillOnce(Return(true)); |
| 172 | EXPECT_CALL(store, SetInt16Property("", _, _)).WillOnce(Return(true)); |
| 173 | EXPECT_CALL(store, SetInt32Property("", _, _)).WillOnce(Return(true)); |
| 174 | EXPECT_CALL(store, SetStringProperty("", _, _)) |
| 175 | .WillOnce(Return(true)); |
| 176 | EXPECT_CALL(store, SetStringmapProperty("", _, _)) |
| 177 | .WillOnce(Return(true)); |
| 178 | EXPECT_CALL(store, SetStringsProperty("", _, _)) |
| 179 | .WillOnce(Return(true)); |
| 180 | EXPECT_CALL(store, SetUint8Property("", _, _)).WillOnce(Return(true)); |
| 181 | EXPECT_CALL(store, SetUint16Property("", _, _)).WillOnce(Return(true)); |
| 182 | EXPECT_CALL(store, SetUint32Property("", _, _)).WillOnce(Return(true)); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 183 | |
Chris Masone | 3bd3c8c | 2011-06-13 08:20:26 -0700 | [diff] [blame] | 184 | string string_path("/false/path"); |
| 185 | ::DBus::Path path(string_path); |
| 186 | ::DBus::Variant path_v = DBusAdaptor::PathToVariant(path); |
| 187 | EXPECT_CALL(store, SetStringProperty("", StrEq(string_path), _)) |
| 188 | .WillOnce(Return(true)); |
Chris Masone | 8fe2c7e | 2011-06-09 15:51:19 -0700 | [diff] [blame] | 189 | |
mukesh agrawal | 6bb9e7c | 2012-01-30 14:57:54 -0800 | [diff] [blame] | 190 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", bool_v_, &e1)); |
| 191 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", path_v, &e2)); |
| 192 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", string_v_, &e3)); |
| 193 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", strings_v_, &e4)); |
| 194 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", int16_v_, &e5)); |
| 195 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", int32_v_, &e6)); |
| 196 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", uint16_v_, &e7)); |
| 197 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", uint32_v_, &e8)); |
| 198 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", stringmap_v_, &e9)); |
| 199 | EXPECT_TRUE(DBusAdaptor::SetProperty(&store, "", byte_v_, &e10)); |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 200 | } |
| 201 | |
mukesh agrawal | 8abd2f6 | 2012-01-30 14:56:14 -0800 | [diff] [blame] | 202 | void SetError(const string &/*name*/, Error *error) { |
| 203 | error->Populate(Error::kInvalidProperty); |
| 204 | } |
| 205 | |
| 206 | TEST_F(DBusAdaptorTest, ClearProperty) { |
| 207 | MockPropertyStore store; |
| 208 | ::DBus::Error e1, e2; |
| 209 | |
| 210 | EXPECT_CALL(store, ClearProperty("valid property", _)). |
| 211 | WillOnce(Return(true)); |
| 212 | EXPECT_CALL(store, ClearProperty("invalid property", _)). |
| 213 | WillOnce(DoAll(Invoke(SetError), |
| 214 | Return(false))); |
| 215 | EXPECT_TRUE(DBusAdaptor::ClearProperty(&store, "valid property", &e1)); |
| 216 | EXPECT_FALSE(DBusAdaptor::ClearProperty(&store, "invalid property", &e2)); |
| 217 | |
| 218 | } |
| 219 | |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 220 | TEST_F(DBusAdaptorTest, ArgsToKeyValueStore) { |
| 221 | map<string, ::DBus::Variant> args; |
| 222 | KeyValueStore args_kv; |
| 223 | Error error; |
| 224 | |
| 225 | args["string_arg"].writer().append_string("string"); |
| 226 | args["bool_arg"].writer().append_bool(true); |
| 227 | DBusAdaptor::ArgsToKeyValueStore(args, &args_kv, &error); |
| 228 | EXPECT_TRUE(error.IsSuccess()); |
| 229 | EXPECT_EQ("string", args_kv.GetString("string_arg")); |
| 230 | EXPECT_EQ(true, args_kv.GetBool("bool_arg")); |
| 231 | } |
| 232 | |
Chris Masone | d0ceb8c | 2011-06-02 10:05:39 -0700 | [diff] [blame] | 233 | } // namespace shill |