Peter Qiu | c0beca5 | 2015-09-03 11:25:46 -0700 | [diff] [blame] | 1 | // |
| 2 | // Copyright (C) 2012 The Android Open Source Project |
| 3 | // |
| 4 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | // you may not use this file except in compliance with the License. |
| 6 | // You may obtain a copy of the License at |
| 7 | // |
| 8 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | // |
| 10 | // Unless required by applicable law or agreed to in writing, software |
| 11 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | // See the License for the specific language governing permissions and |
| 14 | // limitations under the License. |
| 15 | // |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 16 | |
Ben Chan | c54afe5 | 2014-11-05 10:28:08 -0800 | [diff] [blame] | 17 | #include "shill/cellular/modem_manager.h" |
Alex Deymo | cddd2d0 | 2014-11-10 19:55:35 -0800 | [diff] [blame] | 18 | |
Eric Shienbrood | 3e20a23 | 2012-02-16 11:35:56 -0500 | [diff] [blame] | 19 | #include <base/stl_util.h> |
Ben Chan | 5c853ef | 2012-10-05 00:05:37 -0700 | [diff] [blame] | 20 | #include <ModemManager/ModemManager.h> |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 21 | |
Ben Chan | c54afe5 | 2014-11-05 10:28:08 -0800 | [diff] [blame] | 22 | #include "shill/cellular/mock_dbus_objectmanager_proxy.h" |
| 23 | #include "shill/cellular/mock_modem.h" |
| 24 | #include "shill/cellular/mock_modem_info.h" |
| 25 | #include "shill/cellular/mock_modem_manager_proxy.h" |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 26 | #include "shill/manager.h" |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 27 | #include "shill/mock_control.h" |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 28 | #include "shill/mock_manager.h" |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 29 | #include "shill/test_event_dispatcher.h" |
Ben Chan | 1e2ba23 | 2014-01-27 16:35:45 -0800 | [diff] [blame] | 30 | #include "shill/testing.h" |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 31 | |
Darin Petkov | c90fe52 | 2011-07-15 13:59:47 -0700 | [diff] [blame] | 32 | using std::string; |
Alex Vakulenko | 8a53229 | 2014-06-16 17:18:44 -0700 | [diff] [blame] | 33 | using std::shared_ptr; |
Darin Petkov | 5c97ac5 | 2011-07-19 16:30:49 -0700 | [diff] [blame] | 34 | using std::vector; |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 35 | using testing::_; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 36 | using testing::Invoke; |
David Rochberg | b6b6ccb | 2012-03-16 13:40:36 -0400 | [diff] [blame] | 37 | using testing::Pointee; |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 38 | using testing::Return; |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 39 | using testing::SaveArg; |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 40 | using testing::StrEq; |
| 41 | using testing::Test; |
| 42 | |
| 43 | namespace shill { |
| 44 | |
| 45 | class ModemManagerTest : public Test { |
| 46 | public: |
| 47 | ModemManagerTest() |
mukesh agrawal | bad1c10 | 2015-09-18 16:15:08 -0700 | [diff] [blame] | 48 | : manager_(&control_, &dispatcher_, nullptr), |
| 49 | modem_info_(&control_, &dispatcher_, nullptr, &manager_) {} |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 50 | |
| 51 | virtual void SetUp() { |
Peter Qiu | 608ec29 | 2015-07-30 15:46:16 -0700 | [diff] [blame] | 52 | modem_.reset( |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 53 | new StrictModem(kService, kModemPath, &modem_info_, &control_)); |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 54 | } |
Ben Chan | 62028b2 | 2012-11-05 11:20:02 -0800 | [diff] [blame] | 55 | |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 56 | protected: |
| 57 | static const char kService[]; |
| 58 | static const char kPath[]; |
Darin Petkov | 5c97ac5 | 2011-07-19 16:30:49 -0700 | [diff] [blame] | 59 | static const char kModemPath[]; |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 60 | |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 61 | shared_ptr<StrictModem> modem_; |
| 62 | |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 63 | EventDispatcherForTest dispatcher_; |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 64 | MockControl control_; |
| 65 | MockManager manager_; |
Prathmesh Prabhu | 27526f1 | 2013-03-25 19:42:18 -0700 | [diff] [blame] | 66 | MockModemInfo modem_info_; |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 67 | }; |
| 68 | |
Darin Petkov | 5c97ac5 | 2011-07-19 16:30:49 -0700 | [diff] [blame] | 69 | const char ModemManagerTest::kService[] = "org.chromium.ModemManager"; |
| 70 | const char ModemManagerTest::kPath[] = "/org/chromium/ModemManager"; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 71 | const char ModemManagerTest::kModemPath[] = "/org/blah/Modem/blah/0"; |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 72 | |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 73 | class ModemManagerForTest : public ModemManager { |
| 74 | public: |
| 75 | ModemManagerForTest(ControlInterface* control_interface, |
| 76 | const string& service, |
| 77 | const string& path, |
| 78 | ModemInfo* modem_info) |
| 79 | : ModemManager(control_interface, service, path, modem_info) {} |
| 80 | |
| 81 | MOCK_METHOD0(Start, void()); |
| 82 | MOCK_METHOD0(Stop, void()); |
| 83 | }; |
| 84 | |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 85 | class ModemManagerCoreTest : public ModemManagerTest { |
| 86 | public: |
| 87 | ModemManagerCoreTest() |
| 88 | : ModemManagerTest(), |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 89 | modem_manager_(&control_, kService, kPath, &modem_info_) {} |
Darin Petkov | ab565bb | 2011-10-06 02:55:51 -0700 | [diff] [blame] | 90 | |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 91 | protected: |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 92 | ModemManagerForTest modem_manager_; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 93 | }; |
| 94 | |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 95 | TEST_F(ModemManagerCoreTest, ConnectDisconnect) { |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 96 | EXPECT_FALSE(modem_manager_.service_connected_); |
| 97 | modem_manager_.Connect(); |
| 98 | EXPECT_TRUE(modem_manager_.service_connected_); |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 99 | |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 100 | modem_manager_.RecordAddedModem(modem_); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 101 | EXPECT_EQ(1, modem_manager_.modems_.size()); |
| 102 | |
| 103 | modem_manager_.ModemManager::Disconnect(); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 104 | EXPECT_EQ(0, modem_manager_.modems_.size()); |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 105 | EXPECT_FALSE(modem_manager_.service_connected_); |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 106 | } |
| 107 | |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 108 | TEST_F(ModemManagerCoreTest, AddRemoveModem) { |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 109 | modem_manager_.Connect(); |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 110 | EXPECT_FALSE(modem_manager_.ModemExists(kModemPath)); |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 111 | |
| 112 | // Remove non-existent modem path. |
| 113 | modem_manager_.RemoveModem(kModemPath); |
| 114 | EXPECT_FALSE(modem_manager_.ModemExists(kModemPath)); |
| 115 | |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 116 | modem_manager_.RecordAddedModem(modem_); |
| 117 | EXPECT_TRUE(modem_manager_.ModemExists(kModemPath)); |
Ben Chan | 66174a1 | 2014-01-08 21:27:00 -0800 | [diff] [blame] | 118 | |
| 119 | // Add an already added modem. |
| 120 | modem_manager_.RecordAddedModem(modem_); |
| 121 | EXPECT_TRUE(modem_manager_.ModemExists(kModemPath)); |
| 122 | |
| 123 | modem_manager_.RemoveModem(kModemPath); |
| 124 | EXPECT_FALSE(modem_manager_.ModemExists(kModemPath)); |
| 125 | |
| 126 | // Remove an already removed modem path. |
| 127 | modem_manager_.RemoveModem(kModemPath); |
| 128 | EXPECT_FALSE(modem_manager_.ModemExists(kModemPath)); |
Darin Petkov | 5c97ac5 | 2011-07-19 16:30:49 -0700 | [diff] [blame] | 129 | } |
| 130 | |
David Rochberg | b6b6ccb | 2012-03-16 13:40:36 -0400 | [diff] [blame] | 131 | class ModemManagerClassicMockInit : public ModemManagerClassic { |
| 132 | public: |
Peter Qiu | 608ec29 | 2015-07-30 15:46:16 -0700 | [diff] [blame] | 133 | ModemManagerClassicMockInit(ControlInterface* control_interface, |
| 134 | const string& service, |
Paul Stewart | 2f6c789 | 2015-06-16 13:13:10 -0700 | [diff] [blame] | 135 | const string& path, |
| 136 | ModemInfo* modem_info_) : |
Peter Qiu | 608ec29 | 2015-07-30 15:46:16 -0700 | [diff] [blame] | 137 | ModemManagerClassic(control_interface, service, path, modem_info_) {} |
Prathmesh Prabhu | 27526f1 | 2013-03-25 19:42:18 -0700 | [diff] [blame] | 138 | |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 139 | MOCK_METHOD1(InitModemClassic, void(shared_ptr<ModemClassic>)); |
David Rochberg | b6b6ccb | 2012-03-16 13:40:36 -0400 | [diff] [blame] | 140 | }; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 141 | |
| 142 | class ModemManagerClassicTest : public ModemManagerTest { |
| 143 | public: |
| 144 | ModemManagerClassicTest() |
| 145 | : ModemManagerTest(), |
Peter Qiu | 608ec29 | 2015-07-30 15:46:16 -0700 | [diff] [blame] | 146 | modem_manager_(&control_, kService, kPath, &modem_info_), |
Ben Chan | 1e2ba23 | 2014-01-27 16:35:45 -0800 | [diff] [blame] | 147 | proxy_(new MockModemManagerProxy()) {} |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 148 | |
| 149 | protected: |
David Rochberg | b6b6ccb | 2012-03-16 13:40:36 -0400 | [diff] [blame] | 150 | ModemManagerClassicMockInit modem_manager_; |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 151 | MockModemManagerProxy* proxy_; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 152 | }; |
| 153 | |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 154 | TEST_F(ModemManagerClassicTest, StartStop) { |
| 155 | EXPECT_EQ(nullptr, modem_manager_.proxy_.get()); |
| 156 | |
| 157 | EXPECT_CALL(control_, CreateModemManagerProxy(_, kPath, kService, _, _)) |
| 158 | .WillOnce(Return(proxy_)); |
| 159 | modem_manager_.Start(); |
| 160 | EXPECT_NE(nullptr, modem_manager_.proxy_.get()); |
| 161 | |
| 162 | modem_manager_.Stop(); |
| 163 | EXPECT_EQ(nullptr, modem_manager_.proxy_.get()); |
| 164 | } |
| 165 | |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 166 | TEST_F(ModemManagerClassicTest, Connect) { |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 167 | // Setup proxy. |
| 168 | modem_manager_.proxy_.reset(proxy_); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 169 | |
| 170 | EXPECT_CALL(*proxy_, EnumerateDevices()) |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 171 | .WillOnce(Return(vector<string>(1, kModemPath))); |
David Rochberg | b6b6ccb | 2012-03-16 13:40:36 -0400 | [diff] [blame] | 172 | EXPECT_CALL(modem_manager_, |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 173 | InitModemClassic( |
| 174 | Pointee(Field(&Modem::path_, StrEq(kModemPath))))); |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 175 | modem_manager_.Connect(); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 176 | EXPECT_EQ(1, modem_manager_.modems_.size()); |
| 177 | ASSERT_TRUE(ContainsKey(modem_manager_.modems_, kModemPath)); |
| 178 | } |
| 179 | |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 180 | class ModemManager1MockInit : public ModemManager1 { |
| 181 | public: |
Peter Qiu | 608ec29 | 2015-07-30 15:46:16 -0700 | [diff] [blame] | 182 | ModemManager1MockInit(ControlInterface* control_interface, |
| 183 | const string& service, |
Paul Stewart | 2f6c789 | 2015-06-16 13:13:10 -0700 | [diff] [blame] | 184 | const string& path, |
| 185 | ModemInfo* modem_info_) : |
Peter Qiu | 608ec29 | 2015-07-30 15:46:16 -0700 | [diff] [blame] | 186 | ModemManager1(control_interface, service, path, modem_info_) {} |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 187 | MOCK_METHOD2(InitModem1, void(shared_ptr<Modem1>, |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 188 | const InterfaceToProperties&)); |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 189 | }; |
| 190 | |
| 191 | |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 192 | class ModemManager1Test : public ModemManagerTest { |
| 193 | public: |
| 194 | ModemManager1Test() |
| 195 | : ModemManagerTest(), |
Peter Qiu | 608ec29 | 2015-07-30 15:46:16 -0700 | [diff] [blame] | 196 | modem_manager_(&control_, kService, kPath, &modem_info_), |
Ben Chan | 1e2ba23 | 2014-01-27 16:35:45 -0800 | [diff] [blame] | 197 | proxy_(new MockDBusObjectManagerProxy()) {} |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 198 | |
| 199 | protected: |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 200 | virtual void SetUp() { |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 201 | proxy_->IgnoreSetCallbacks(); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 202 | } |
| 203 | |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 204 | void Connect(const ObjectsWithProperties& expected_objects) { |
Ben Chan | 1e2ba23 | 2014-01-27 16:35:45 -0800 | [diff] [blame] | 205 | ManagedObjectsCallback get_managed_objects_callback; |
| 206 | EXPECT_CALL(*proxy_, GetManagedObjects(_, _, _)) |
| 207 | .WillOnce(SaveArg<1>(&get_managed_objects_callback)); |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 208 | modem_manager_.Connect(); |
Ben Chan | 1e2ba23 | 2014-01-27 16:35:45 -0800 | [diff] [blame] | 209 | get_managed_objects_callback.Run(expected_objects, Error()); |
| 210 | } |
| 211 | |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 212 | static ObjectsWithProperties GetModemWithProperties() { |
| 213 | KeyValueStore o_fd_mm1_modem; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 214 | |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 215 | InterfaceToProperties properties; |
Ben Chan | 876efd3 | 2012-09-28 15:25:13 -0700 | [diff] [blame] | 216 | properties[MM_DBUS_INTERFACE_MODEM] = o_fd_mm1_modem; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 217 | |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 218 | ObjectsWithProperties objects_with_properties; |
Ben Chan | 876efd3 | 2012-09-28 15:25:13 -0700 | [diff] [blame] | 219 | objects_with_properties[kModemPath] = properties; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 220 | |
| 221 | return objects_with_properties; |
| 222 | } |
| 223 | |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 224 | ModemManager1MockInit modem_manager_; |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 225 | MockDBusObjectManagerProxy* proxy_; |
Peter Qiu | 608ec29 | 2015-07-30 15:46:16 -0700 | [diff] [blame] | 226 | MockControl control_; |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 227 | }; |
| 228 | |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 229 | TEST_F(ModemManager1Test, StartStop) { |
| 230 | EXPECT_EQ(nullptr, modem_manager_.proxy_.get()); |
| 231 | |
| 232 | EXPECT_CALL(control_, CreateDBusObjectManagerProxy(kPath, kService, _, _)) |
| 233 | .WillOnce(Return(proxy_)); |
| 234 | EXPECT_CALL(*proxy_, set_interfaces_added_callback(_)); |
| 235 | EXPECT_CALL(*proxy_, set_interfaces_removed_callback(_)); |
| 236 | modem_manager_.Start(); |
| 237 | EXPECT_NE(nullptr, modem_manager_.proxy_.get()); |
| 238 | |
| 239 | modem_manager_.Stop(); |
| 240 | EXPECT_EQ(nullptr, modem_manager_.proxy_.get()); |
| 241 | } |
| 242 | |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 243 | TEST_F(ModemManager1Test, Connect) { |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 244 | // Setup proxy. |
| 245 | modem_manager_.proxy_.reset(proxy_); |
| 246 | |
Ben Chan | 1e2ba23 | 2014-01-27 16:35:45 -0800 | [diff] [blame] | 247 | Connect(GetModemWithProperties()); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 248 | EXPECT_EQ(1, modem_manager_.modems_.size()); |
| 249 | EXPECT_TRUE(ContainsKey(modem_manager_.modems_, kModemPath)); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | TEST_F(ModemManager1Test, AddRemoveInterfaces) { |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 253 | // Setup proxy. |
| 254 | modem_manager_.proxy_.reset(proxy_); |
| 255 | |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 256 | // Have nothing come back from GetManagedObjects |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 257 | Connect(ObjectsWithProperties()); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 258 | EXPECT_EQ(0, modem_manager_.modems_.size()); |
| 259 | |
| 260 | // Add an object that doesn't have a modem interface. Nothing should be added |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 261 | EXPECT_CALL(modem_manager_, InitModem1(_, _)).Times(0); |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 262 | modem_manager_.OnInterfacesAddedSignal(kModemPath, |
Peter Qiu | 05d87e3 | 2015-08-14 23:46:21 -0700 | [diff] [blame] | 263 | InterfaceToProperties()); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 264 | EXPECT_EQ(0, modem_manager_.modems_.size()); |
| 265 | |
| 266 | // Actually add a modem |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 267 | EXPECT_CALL(modem_manager_, InitModem1(_, _)).Times(1); |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 268 | modem_manager_.OnInterfacesAddedSignal(kModemPath, |
| 269 | GetModemWithProperties()[kModemPath]); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 270 | EXPECT_EQ(1, modem_manager_.modems_.size()); |
| 271 | |
| 272 | // Remove an irrelevant interface |
| 273 | vector<string> not_including_modem_interface; |
| 274 | not_including_modem_interface.push_back("not.a.modem.interface"); |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 275 | modem_manager_.OnInterfacesRemovedSignal(kModemPath, |
| 276 | not_including_modem_interface); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 277 | EXPECT_EQ(1, modem_manager_.modems_.size()); |
| 278 | |
| 279 | // Remove the modem |
| 280 | vector<string> with_modem_interface; |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 281 | with_modem_interface.push_back(MM_DBUS_INTERFACE_MODEM); |
Ben Chan | 1e2ba23 | 2014-01-27 16:35:45 -0800 | [diff] [blame] | 282 | modem_manager_.OnInterfacesRemovedSignal(kModemPath, with_modem_interface); |
David Rochberg | 7cb06f6 | 2012-03-05 11:23:44 -0500 | [diff] [blame] | 283 | EXPECT_EQ(0, modem_manager_.modems_.size()); |
| 284 | } |
David Rochberg | fa1d31d | 2012-03-20 10:38:07 -0400 | [diff] [blame] | 285 | |
Darin Petkov | 887f298 | 2011-07-14 16:10:17 -0700 | [diff] [blame] | 286 | } // namespace shill |