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 //
16
17 #include "shill/cellular/cellular_capability_cdma.h"
18
19 #include <base/bind.h>
20 #if defined(__ANDROID__)
21 #include <dbus/service_constants.h>
22 #else
23 #include <chromeos/dbus/service_constants.h>
24 #endif // __ANDROID__
25 #include <gtest/gtest.h>
26 #include <mm/mm-modem.h>
27
28 #include "shill/cellular/cellular.h"
29 #include "shill/cellular/cellular_service.h"
30 #include "shill/cellular/mock_cellular.h"
31 #include "shill/cellular/mock_modem_cdma_proxy.h"
32 #include "shill/cellular/mock_modem_info.h"
33 #include "shill/cellular/mock_modem_proxy.h"
34 #include "shill/error.h"
35 #include "shill/mock_adaptors.h"
36 #include "shill/test_event_dispatcher.h"
37
38 using base::Bind;
39 using base::Unretained;
40 using std::string;
41 using testing::_;
42 using testing::InSequence;
43 using testing::Invoke;
44 using testing::Return;
45 using testing::StrEq;
46
47 namespace shill {
48
49 class CellularCapabilityCDMATest : public testing::Test {
50 public:
CellularCapabilityCDMATest()51 CellularCapabilityCDMATest()
52 : modem_info_(nullptr, &dispatcher_, nullptr, nullptr),
53 cellular_(new MockCellular(&modem_info_,
54 "",
55 "",
56 0,
57 Cellular::kTypeCDMA,
58 "",
59 "")),
60 classic_proxy_(new MockModemProxy()),
61 proxy_(new MockModemCDMAProxy()),
62 capability_(nullptr) {
63 modem_info_.metrics()->RegisterDevice(cellular_->interface_index(),
64 Technology::kCellular);
65 }
66
~CellularCapabilityCDMATest()67 virtual ~CellularCapabilityCDMATest() {
68 cellular_->service_ = nullptr;
69 capability_ = nullptr;
70 }
71
SetUp()72 virtual void SetUp() {
73 capability_ =
74 static_cast<CellularCapabilityCDMA*>(cellular_->capability_.get());
75 }
76
InvokeActivate(const string & carrier,Error * error,const ActivationResultCallback & callback,int timeout)77 void InvokeActivate(const string& carrier, Error* error,
78 const ActivationResultCallback& callback,
79 int timeout) {
80 callback.Run(MM_MODEM_CDMA_ACTIVATION_ERROR_NO_ERROR, Error());
81 }
InvokeActivateError(const string & carrier,Error * error,const ActivationResultCallback & callback,int timeout)82 void InvokeActivateError(const string& carrier, Error* error,
83 const ActivationResultCallback& callback,
84 int timeout) {
85 callback.Run(MM_MODEM_CDMA_ACTIVATION_ERROR_NO_SIGNAL, Error());
86 }
InvokeDisconnect(Error * error,const ResultCallback & callback,int timeout)87 void InvokeDisconnect(Error* error,
88 const ResultCallback& callback,
89 int timeout) {
90 callback.Run(Error());
91 }
InvokeDisconnectError(Error * error,const ResultCallback & callback,int timeout)92 void InvokeDisconnectError(Error* error,
93 const ResultCallback& callback,
94 int timeout) {
95 Error err(Error::kOperationFailed);
96 callback.Run(err);
97 }
InvokeGetSignalQuality(Error * error,const SignalQualityCallback & callback,int timeout)98 void InvokeGetSignalQuality(Error* error,
99 const SignalQualityCallback& callback,
100 int timeout) {
101 callback.Run(kStrength, Error());
102 }
InvokeGetRegistrationState(Error * error,const RegistrationStateCallback & callback,int timeout)103 void InvokeGetRegistrationState(Error* error,
104 const RegistrationStateCallback& callback,
105 int timeout) {
106 callback.Run(MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED,
107 MM_MODEM_CDMA_REGISTRATION_STATE_HOME,
108 Error());
109 }
110
111 MOCK_METHOD1(TestCallback, void(const Error& error));
112
113 protected:
114 static const char kMEID[];
115 static const char kTestCarrier[];
116 static const unsigned int kStrength;
117
IsActivationStarting() const118 bool IsActivationStarting() const {
119 return capability_->activation_starting_;
120 }
121
SetRegistrationStateEVDO(uint32_t state)122 void SetRegistrationStateEVDO(uint32_t state) {
123 capability_->registration_state_evdo_ = state;
124 }
125
SetRegistrationState1x(uint32_t state)126 void SetRegistrationState1x(uint32_t state) {
127 capability_->registration_state_1x_ = state;
128 }
129
SetProxy()130 void SetProxy() {
131 capability_->proxy_.reset(proxy_.release());
132 capability_->CellularCapabilityClassic::proxy_.reset(
133 classic_proxy_.release());
134 }
135
SetService()136 void SetService() {
137 cellular_->service_ = new CellularService(&modem_info_, cellular_);
138 }
139
SetDeviceState(Cellular::State state)140 void SetDeviceState(Cellular::State state) {
141 cellular_->state_ = state;
142 }
143
144 EventDispatcherForTest dispatcher_;
145 MockModemInfo modem_info_;
146 scoped_refptr<MockCellular> cellular_;
147 std::unique_ptr<MockModemProxy> classic_proxy_;
148 std::unique_ptr<MockModemCDMAProxy> proxy_;
149 CellularCapabilityCDMA* capability_; // Owned by |cellular_|.
150 };
151
152 const char CellularCapabilityCDMATest::kMEID[] = "D1234567EF8901";
153 const char CellularCapabilityCDMATest::kTestCarrier[] = "The Cellular Carrier";
154 const unsigned int CellularCapabilityCDMATest::kStrength = 90;
155
TEST_F(CellularCapabilityCDMATest,PropertyStore)156 TEST_F(CellularCapabilityCDMATest, PropertyStore) {
157 EXPECT_TRUE(cellular_->store().Contains(kPRLVersionProperty));
158 }
159
TEST_F(CellularCapabilityCDMATest,Activate)160 TEST_F(CellularCapabilityCDMATest, Activate) {
161 SetDeviceState(Cellular::kStateEnabled);
162 EXPECT_CALL(*proxy_, Activate(kTestCarrier, _, _,
163 CellularCapability::kTimeoutActivate))
164 .WillOnce(Invoke(this,
165 &CellularCapabilityCDMATest::InvokeActivate));
166 EXPECT_CALL(*this, TestCallback(_));
167 SetProxy();
168 SetService();
169 capability_->Activate(kTestCarrier, nullptr,
170 Bind(&CellularCapabilityCDMATest::TestCallback, Unretained(this)));
171 EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING,
172 capability_->activation_state());
173 EXPECT_EQ(kActivationStateActivating,
174 cellular_->service()->activation_state());
175 EXPECT_EQ("", cellular_->service()->error());
176 }
177
TEST_F(CellularCapabilityCDMATest,ActivateWhileConnected)178 TEST_F(CellularCapabilityCDMATest, ActivateWhileConnected) {
179 SetDeviceState(Cellular::kStateConnected);
180 {
181 InSequence dummy;
182
183 EXPECT_CALL(*cellular_, Disconnect(_, StrEq("Activate")));
184 EXPECT_CALL(*proxy_, Activate(kTestCarrier, _, _,
185 CellularCapability::kTimeoutActivate))
186 .WillOnce(Invoke(this,
187 &CellularCapabilityCDMATest::InvokeActivate));
188 EXPECT_CALL(*this, TestCallback(_));
189 }
190 SetProxy();
191 SetService();
192 Error error;
193 capability_->Activate(kTestCarrier, &error,
194 Bind(&CellularCapabilityCDMATest::TestCallback, Unretained(this)));
195 // So now we should be "activating" while we wait for a disconnect.
196 EXPECT_TRUE(IsActivationStarting());
197 EXPECT_TRUE(capability_->IsActivating());
198 EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED,
199 capability_->activation_state());
200 // Simulate a disconnect.
201 SetDeviceState(Cellular::kStateRegistered);
202 capability_->DisconnectCleanup();
203 // Now the modem is actually activating.
204 EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING,
205 capability_->activation_state());
206 EXPECT_EQ(kActivationStateActivating,
207 cellular_->service()->activation_state());
208 EXPECT_EQ("", cellular_->service()->error());
209 EXPECT_FALSE(IsActivationStarting());
210 EXPECT_TRUE(capability_->IsActivating());
211 }
212
TEST_F(CellularCapabilityCDMATest,ActivateWhileConnectedButFail)213 TEST_F(CellularCapabilityCDMATest, ActivateWhileConnectedButFail) {
214 SetDeviceState(Cellular::kStateConnected);
215 {
216 InSequence dummy;
217
218 EXPECT_CALL(*cellular_, Disconnect(_, StrEq("Activate")));
219 EXPECT_CALL(*proxy_, Activate(kTestCarrier, _, _,
220 CellularCapability::kTimeoutActivate))
221 .Times(0);
222 }
223 SetProxy();
224 SetService();
225 Error error;
226 capability_->Activate(kTestCarrier, &error,
227 Bind(&CellularCapabilityCDMATest::TestCallback, Unretained(this)));
228 // So now we should be "activating" while we wait for a disconnect.
229 EXPECT_TRUE(IsActivationStarting());
230 EXPECT_TRUE(capability_->IsActivating());
231 EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED,
232 capability_->activation_state());
233 // Similulate a failed disconnect (the modem is still connected!).
234 capability_->DisconnectCleanup();
235 EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED,
236 capability_->activation_state());
237 EXPECT_EQ(kActivationStateNotActivated,
238 cellular_->service()->activation_state());
239 EXPECT_EQ(kErrorActivationFailed, cellular_->service()->error());
240 EXPECT_FALSE(IsActivationStarting());
241 EXPECT_FALSE(capability_->IsActivating());
242 }
243
TEST_F(CellularCapabilityCDMATest,ActivateError)244 TEST_F(CellularCapabilityCDMATest, ActivateError) {
245 SetDeviceState(Cellular::kStateEnabled);
246 EXPECT_CALL(*proxy_, Activate(kTestCarrier, _, _,
247 CellularCapability::kTimeoutActivate))
248 .WillOnce(Invoke(this,
249 &CellularCapabilityCDMATest::InvokeActivateError));
250 EXPECT_CALL(*this, TestCallback(_));
251 SetProxy();
252 SetService();
253 capability_->Activate(kTestCarrier, nullptr,
254 Bind(&CellularCapabilityCDMATest::TestCallback, Unretained(this)));
255 EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED,
256 capability_->activation_state());
257 EXPECT_EQ(kActivationStateNotActivated,
258 cellular_->service()->activation_state());
259 EXPECT_EQ(kErrorActivationFailed,
260 cellular_->service()->error());
261 }
262
TEST_F(CellularCapabilityCDMATest,GetActivationStateString)263 TEST_F(CellularCapabilityCDMATest, GetActivationStateString) {
264 EXPECT_EQ(kActivationStateActivated,
265 CellularCapabilityCDMA::GetActivationStateString(
266 MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED));
267 EXPECT_EQ(kActivationStateActivating,
268 CellularCapabilityCDMA::GetActivationStateString(
269 MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING));
270 EXPECT_EQ(kActivationStateNotActivated,
271 CellularCapabilityCDMA::GetActivationStateString(
272 MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED));
273 EXPECT_EQ(kActivationStatePartiallyActivated,
274 CellularCapabilityCDMA::GetActivationStateString(
275 MM_MODEM_CDMA_ACTIVATION_STATE_PARTIALLY_ACTIVATED));
276 EXPECT_EQ(kActivationStateUnknown,
277 CellularCapabilityCDMA::GetActivationStateString(123));
278 }
279
TEST_F(CellularCapabilityCDMATest,GetActivationErrorString)280 TEST_F(CellularCapabilityCDMATest, GetActivationErrorString) {
281 EXPECT_EQ(kErrorNeedEvdo,
282 CellularCapabilityCDMA::GetActivationErrorString(
283 MM_MODEM_CDMA_ACTIVATION_ERROR_WRONG_RADIO_INTERFACE));
284 EXPECT_EQ(kErrorNeedHomeNetwork,
285 CellularCapabilityCDMA::GetActivationErrorString(
286 MM_MODEM_CDMA_ACTIVATION_ERROR_ROAMING));
287 EXPECT_EQ(kErrorOtaspFailed,
288 CellularCapabilityCDMA::GetActivationErrorString(
289 MM_MODEM_CDMA_ACTIVATION_ERROR_COULD_NOT_CONNECT));
290 EXPECT_EQ(kErrorOtaspFailed,
291 CellularCapabilityCDMA::GetActivationErrorString(
292 MM_MODEM_CDMA_ACTIVATION_ERROR_SECURITY_AUTHENTICATION_FAILED));
293 EXPECT_EQ(kErrorOtaspFailed,
294 CellularCapabilityCDMA::GetActivationErrorString(
295 MM_MODEM_CDMA_ACTIVATION_ERROR_PROVISIONING_FAILED));
296 EXPECT_EQ("",
297 CellularCapabilityCDMA::GetActivationErrorString(
298 MM_MODEM_CDMA_ACTIVATION_ERROR_NO_ERROR));
299 EXPECT_EQ(kErrorActivationFailed,
300 CellularCapabilityCDMA::GetActivationErrorString(
301 MM_MODEM_CDMA_ACTIVATION_ERROR_NO_SIGNAL));
302 EXPECT_EQ(kErrorActivationFailed,
303 CellularCapabilityCDMA::GetActivationErrorString(1234));
304 }
305
TEST_F(CellularCapabilityCDMATest,IsRegisteredEVDO)306 TEST_F(CellularCapabilityCDMATest, IsRegisteredEVDO) {
307 EXPECT_FALSE(capability_->IsRegistered());
308 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN);
309 EXPECT_FALSE(capability_->IsRegistered());
310 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED);
311 EXPECT_TRUE(capability_->IsRegistered());
312 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
313 EXPECT_TRUE(capability_->IsRegistered());
314 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING);
315 EXPECT_TRUE(capability_->IsRegistered());
316 }
317
TEST_F(CellularCapabilityCDMATest,IsRegistered1x)318 TEST_F(CellularCapabilityCDMATest, IsRegistered1x) {
319 EXPECT_FALSE(capability_->IsRegistered());
320 SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN);
321 EXPECT_FALSE(capability_->IsRegistered());
322 SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED);
323 EXPECT_TRUE(capability_->IsRegistered());
324 SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
325 EXPECT_TRUE(capability_->IsRegistered());
326 SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING);
327 EXPECT_TRUE(capability_->IsRegistered());
328 }
329
TEST_F(CellularCapabilityCDMATest,GetNetworkTechnologyString)330 TEST_F(CellularCapabilityCDMATest, GetNetworkTechnologyString) {
331 EXPECT_EQ("", capability_->GetNetworkTechnologyString());
332 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
333 EXPECT_EQ(kNetworkTechnologyEvdo,
334 capability_->GetNetworkTechnologyString());
335 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN);
336 SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
337 EXPECT_EQ(kNetworkTechnology1Xrtt,
338 capability_->GetNetworkTechnologyString());
339 }
340
TEST_F(CellularCapabilityCDMATest,GetRoamingStateString)341 TEST_F(CellularCapabilityCDMATest, GetRoamingStateString) {
342 EXPECT_EQ(kRoamingStateUnknown,
343 capability_->GetRoamingStateString());
344 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED);
345 EXPECT_EQ(kRoamingStateUnknown,
346 capability_->GetRoamingStateString());
347 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
348 EXPECT_EQ(kRoamingStateHome, capability_->GetRoamingStateString());
349 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING);
350 EXPECT_EQ(kRoamingStateRoaming,
351 capability_->GetRoamingStateString());
352 SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN);
353 SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED);
354 EXPECT_EQ(kRoamingStateUnknown,
355 capability_->GetRoamingStateString());
356 SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
357 EXPECT_EQ(kRoamingStateHome, capability_->GetRoamingStateString());
358 SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING);
359 EXPECT_EQ(kRoamingStateRoaming,
360 capability_->GetRoamingStateString());
361 }
362
TEST_F(CellularCapabilityCDMATest,GetSignalQuality)363 TEST_F(CellularCapabilityCDMATest, GetSignalQuality) {
364 EXPECT_CALL(*proxy_,
365 GetSignalQuality(nullptr, _, CellularCapability::kTimeoutDefault))
366 .WillOnce(Invoke(this,
367 &CellularCapabilityCDMATest::InvokeGetSignalQuality));
368 SetProxy();
369 SetService();
370 EXPECT_EQ(0, cellular_->service()->strength());
371 capability_->GetSignalQuality();
372 EXPECT_EQ(kStrength, cellular_->service()->strength());
373 }
374
TEST_F(CellularCapabilityCDMATest,GetRegistrationState)375 TEST_F(CellularCapabilityCDMATest, GetRegistrationState) {
376 EXPECT_FALSE(cellular_->service().get());
377 EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
378 capability_->registration_state_1x());
379 EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
380 capability_->registration_state_evdo());
381 EXPECT_CALL(*proxy_,
382 GetRegistrationState(nullptr, _,
383 CellularCapability::kTimeoutDefault))
384 .WillOnce(Invoke(
385 this,
386 &CellularCapabilityCDMATest::InvokeGetRegistrationState));
387 SetProxy();
388 cellular_->state_ = Cellular::kStateEnabled;
389 EXPECT_CALL(*modem_info_.mock_manager(), RegisterService(_));
390 capability_->GetRegistrationState();
391 dispatcher_.DispatchPendingEvents();
392 EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED,
393 capability_->registration_state_1x());
394 EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_HOME,
395 capability_->registration_state_evdo());
396 EXPECT_TRUE(cellular_->service().get());
397 }
398
399 } // namespace shill
400