1//
2// Copyright (C) 2013 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_universal_cdma.h"
18
19#include <string>
20#include <vector>
21
22#include <base/strings/string_number_conversions.h>
23#include <base/strings/string_util.h>
24#include <base/strings/stringprintf.h>
25#include <gmock/gmock.h>
26#include <gtest/gtest.h>
27#include <ModemManager/ModemManager.h>
28
29#include "shill/cellular/cellular.h"
30#include "shill/cellular/cellular_service.h"
31#include "shill/cellular/mock_cellular_service.h"
32#include "shill/cellular/mock_mm1_modem_modem3gpp_proxy.h"
33#include "shill/cellular/mock_mm1_modem_modemcdma_proxy.h"
34#include "shill/cellular/mock_mm1_modem_proxy.h"
35#include "shill/cellular/mock_mm1_modem_simple_proxy.h"
36#include "shill/cellular/mock_mm1_sim_proxy.h"
37#include "shill/cellular/mock_mobile_operator_info.h"
38#include "shill/cellular/mock_modem_info.h"
39#include "shill/mock_adaptors.h"
40#include "shill/mock_control.h"
41#include "shill/mock_dbus_properties_proxy.h"
42#include "shill/mock_manager.h"
43#include "shill/mock_metrics.h"
44#include "shill/mock_pending_activation_store.h"
45#include "shill/nice_mock_control.h"
46#include "shill/test_event_dispatcher.h"
47
48using base::StringPrintf;
49using base::UintToString;
50using std::string;
51using std::unique_ptr;
52using std::vector;
53using testing::Invoke;
54using testing::Mock;
55using testing::NiceMock;
56using testing::Return;
57using testing::SetArgumentPointee;
58using testing::_;
59
60namespace shill {
61
62class CellularCapabilityUniversalCDMATest : public testing::Test {
63 public:
64  explicit CellularCapabilityUniversalCDMATest(EventDispatcher* dispatcher)
65      : dispatcher_(dispatcher),
66        control_interface_(this),
67        capability_(nullptr),
68        device_adaptor_(nullptr),
69        modem_info_(&control_interface_, dispatcher, nullptr, nullptr),
70        modem_3gpp_proxy_(new mm1::MockModemModem3gppProxy()),
71        modem_cdma_proxy_(new mm1::MockModemModemCdmaProxy()),
72        modem_proxy_(new mm1::MockModemProxy()),
73        modem_simple_proxy_(new mm1::MockModemSimpleProxy()),
74        sim_proxy_(new mm1::MockSimProxy()),
75        properties_proxy_(new MockDBusPropertiesProxy()),
76        cellular_(new Cellular(&modem_info_,
77                               "",
78                               kMachineAddress,
79                               0,
80                               Cellular::kTypeUniversalCDMA,
81                               "",
82                               "")),
83        service_(new MockCellularService(&modem_info_,
84                                         cellular_)),
85        mock_home_provider_info_(nullptr),
86        mock_serving_operator_info_(nullptr) {}
87
88  virtual ~CellularCapabilityUniversalCDMATest() {
89    cellular_->service_ = nullptr;
90    capability_ = nullptr;
91    device_adaptor_ = nullptr;
92  }
93
94  virtual void SetUp() {
95    capability_ = static_cast<CellularCapabilityUniversalCDMA*>(
96        cellular_->capability_.get());
97    device_adaptor_ =
98        static_cast<NiceMock<DeviceMockAdaptor>*>(cellular_->adaptor());
99    cellular_->service_ = service_;
100  }
101
102  virtual void TearDown() {
103    capability_->control_interface_ = nullptr;
104  }
105
106  void SetService() {
107    cellular_->service_ = new CellularService(&modem_info_, cellular_);
108  }
109
110  void ClearService() {
111    cellular_->service_ = nullptr;
112  }
113
114  void ReleaseCapabilityProxies() {
115    capability_->ReleaseProxies();
116  }
117
118  void SetCdmaProxy() {
119    capability_->modem_cdma_proxy_.reset(modem_cdma_proxy_.release());
120  }
121
122  void SetSimpleProxy() {
123    capability_->modem_simple_proxy_.reset(modem_simple_proxy_.release());
124  }
125
126  void SetMockMobileOperatorInfoObjects() {
127    CHECK(!mock_home_provider_info_);
128    CHECK(!mock_serving_operator_info_);
129    mock_home_provider_info_ =
130        new MockMobileOperatorInfo(dispatcher_, "HomeProvider");
131    mock_serving_operator_info_ =
132        new MockMobileOperatorInfo(dispatcher_, "ServingOperator");
133    cellular_->set_home_provider_info(mock_home_provider_info_);
134    cellular_->set_serving_operator_info(mock_serving_operator_info_);
135  }
136
137 protected:
138  static const char kEsn[];
139  static const char kMachineAddress[];
140  static const char kMeid[];
141
142  class TestControl : public MockControl {
143   public:
144    explicit TestControl(CellularCapabilityUniversalCDMATest* test)
145        : test_(test) {}
146
147    // TODO(armansito): Some of these methods won't be necessary after 3GPP
148    // gets refactored out of CellularCapabilityUniversal.
149    virtual mm1::ModemModem3gppProxyInterface* CreateMM1ModemModem3gppProxy(
150        const std::string& /*path*/,
151        const std::string& /*service*/) {
152      return test_->modem_3gpp_proxy_.release();
153    }
154
155    virtual mm1::ModemModemCdmaProxyInterface* CreateMM1ModemModemCdmaProxy(
156        const std::string& /*path*/,
157        const std::string& /*service*/) {
158      return test_->modem_cdma_proxy_.release();
159    }
160
161    virtual mm1::ModemProxyInterface* CreateMM1ModemProxy(
162        const std::string& /*path*/,
163        const std::string& /*service*/) {
164      return test_->modem_proxy_.release();
165    }
166
167    virtual mm1::ModemSimpleProxyInterface* CreateMM1ModemSimpleProxy(
168        const std::string& /*path*/,
169        const std::string& /*service*/) {
170      return test_->modem_simple_proxy_.release();
171    }
172
173    virtual mm1::SimProxyInterface* CreateSimProxy(
174        const std::string& /*path*/,
175        const std::string& /*service*/) {
176      return test_->sim_proxy_.release();
177    }
178
179    virtual DBusPropertiesProxyInterface* CreateDBusPropertiesProxy(
180        const std::string& /*path*/,
181        const std::string& /*service*/) {
182      return test_->properties_proxy_.release();
183    }
184
185   private:
186    CellularCapabilityUniversalCDMATest* test_;
187  };
188
189  EventDispatcher* dispatcher_;
190  TestControl control_interface_;
191  CellularCapabilityUniversalCDMA* capability_;
192  NiceMock<DeviceMockAdaptor>* device_adaptor_;
193  MockModemInfo modem_info_;
194  // TODO(armansito): Remove |modem_3gpp_proxy_| after refactor.
195  unique_ptr<mm1::MockModemModem3gppProxy> modem_3gpp_proxy_;
196  unique_ptr<mm1::MockModemModemCdmaProxy> modem_cdma_proxy_;
197  unique_ptr<mm1::MockModemProxy> modem_proxy_;
198  unique_ptr<mm1::MockModemSimpleProxy> modem_simple_proxy_;
199  unique_ptr<mm1::MockSimProxy> sim_proxy_;
200  unique_ptr<MockDBusPropertiesProxy> properties_proxy_;
201  CellularRefPtr cellular_;
202  MockCellularService* service_;
203
204  // Set when required and passed to |cellular_|. Owned by |cellular_|.
205  MockMobileOperatorInfo* mock_home_provider_info_;
206  MockMobileOperatorInfo* mock_serving_operator_info_;
207};
208
209// static
210const char CellularCapabilityUniversalCDMATest::kEsn[] = "0000";
211// static
212const char CellularCapabilityUniversalCDMATest::kMachineAddress[] =
213    "TestMachineAddress";
214// static
215const char CellularCapabilityUniversalCDMATest::kMeid[] = "11111111111111";
216
217class CellularCapabilityUniversalCDMAMainTest
218    : public CellularCapabilityUniversalCDMATest {
219 public:
220  CellularCapabilityUniversalCDMAMainTest()
221      : CellularCapabilityUniversalCDMATest(&dispatcher_) {}
222
223 private:
224  EventDispatcherForTest dispatcher_;
225};
226
227class CellularCapabilityUniversalCDMADispatcherTest
228    : public CellularCapabilityUniversalCDMATest {
229 public:
230  CellularCapabilityUniversalCDMADispatcherTest()
231      : CellularCapabilityUniversalCDMATest(nullptr) {}
232};
233
234TEST_F(CellularCapabilityUniversalCDMAMainTest, PropertiesChanged) {
235  // Set up mock modem CDMA properties.
236  KeyValueStore modem_cdma_properties;
237  modem_cdma_properties.SetString(MM_MODEM_MODEMCDMA_PROPERTY_MEID, kMeid);
238  modem_cdma_properties.SetString(MM_MODEM_MODEMCDMA_PROPERTY_ESN, kEsn);
239
240  SetUp();
241
242  EXPECT_TRUE(cellular_->meid().empty());
243  EXPECT_TRUE(cellular_->esn().empty());
244
245  // Changing properties on wrong interface will not have an effect
246  capability_->OnPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
247                                   modem_cdma_properties,
248                                   vector<string>());
249  EXPECT_TRUE(cellular_->meid().empty());
250  EXPECT_TRUE(cellular_->esn().empty());
251
252  // Changing properties on the right interface gets reflected in the
253  // capabilities object
254  capability_->OnPropertiesChanged(MM_DBUS_INTERFACE_MODEM_MODEMCDMA,
255                                   modem_cdma_properties,
256                                   vector<string>());
257  EXPECT_EQ(kMeid, cellular_->meid());
258  EXPECT_EQ(kEsn, cellular_->esn());
259}
260
261TEST_F(CellularCapabilityUniversalCDMAMainTest, OnCDMARegistrationChanged) {
262  EXPECT_EQ(0, capability_->sid_);
263  EXPECT_EQ(0, capability_->nid_);
264  EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
265            capability_->cdma_1x_registration_state_);
266  EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
267            capability_->cdma_evdo_registration_state_);
268
269  const unsigned kSid = 2;
270  const unsigned kNid = 1;
271  SetMockMobileOperatorInfoObjects();
272  EXPECT_CALL(*mock_serving_operator_info_, UpdateSID(UintToString(kSid)));
273  EXPECT_CALL(*mock_serving_operator_info_, UpdateNID(UintToString(kNid)));
274  capability_->OnCDMARegistrationChanged(
275      MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
276      MM_MODEM_CDMA_REGISTRATION_STATE_HOME,
277      kSid,
278      kNid);
279  EXPECT_EQ(kSid, capability_->sid_);
280  EXPECT_EQ(kNid, capability_->nid_);
281  EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
282            capability_->cdma_1x_registration_state_);
283  EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_HOME,
284            capability_->cdma_evdo_registration_state_);
285
286  EXPECT_TRUE(capability_->IsRegistered());
287}
288
289TEST_F(CellularCapabilityUniversalCDMAMainTest, UpdateServiceOLP) {
290  const MobileOperatorInfo::OnlinePortal kOlp {
291      "http://testurl",
292      "POST",
293      "esn=${esn}&mdn=${mdn}&meid=${meid}"};
294  const vector<MobileOperatorInfo::OnlinePortal> kOlpList {kOlp};
295  const string kUuidVzw = "c83d6597-dc91-4d48-a3a7-d86b80123751";
296  const string kUuidFoo = "foo";
297
298  SetMockMobileOperatorInfoObjects();
299  cellular_->set_esn("0");
300  cellular_->set_mdn("10123456789");
301  cellular_->set_meid("4");
302
303
304  mock_serving_operator_info_->SetEmptyDefaultsForProperties();
305  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
306      .WillRepeatedly(Return(true));
307  EXPECT_CALL(*mock_serving_operator_info_, olp_list())
308      .WillRepeatedly(ReturnRef(kOlpList));
309  EXPECT_CALL(*mock_serving_operator_info_, uuid())
310      .WillOnce(ReturnRef(kUuidVzw));
311  SetService();
312  capability_->UpdateServiceOLP();
313  // Copy to simplify assertions below.
314  Stringmap vzw_olp = cellular_->service()->olp();
315  EXPECT_EQ("http://testurl", vzw_olp[kPaymentPortalURL]);
316  EXPECT_EQ("POST", vzw_olp[kPaymentPortalMethod]);
317  EXPECT_EQ("esn=0&mdn=0123456789&meid=4",
318            vzw_olp[kPaymentPortalPostData]);
319  Mock::VerifyAndClearExpectations(mock_serving_operator_info_);
320
321  mock_serving_operator_info_->SetEmptyDefaultsForProperties();
322  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
323      .WillRepeatedly(Return(true));
324  EXPECT_CALL(*mock_serving_operator_info_, olp_list())
325      .WillRepeatedly(ReturnRef(kOlpList));
326  EXPECT_CALL(*mock_serving_operator_info_, uuid())
327      .WillOnce(ReturnRef(kUuidFoo));
328  capability_->UpdateServiceOLP();
329  // Copy to simplify assertions below.
330  Stringmap olp = cellular_->service()->olp();
331  EXPECT_EQ("http://testurl", olp[kPaymentPortalURL]);
332  EXPECT_EQ("POST", olp[kPaymentPortalMethod]);
333  EXPECT_EQ("esn=0&mdn=10123456789&meid=4",
334            olp[kPaymentPortalPostData]);
335}
336
337TEST_F(CellularCapabilityUniversalCDMAMainTest, ActivateAutomatic) {
338  const string activation_code {"1234"};
339  SetMockMobileOperatorInfoObjects();
340
341  mm1::MockModemModemCdmaProxy* cdma_proxy = modem_cdma_proxy_.get();
342  SetUp();
343  capability_->InitProxies();
344
345  // Cases when activation fails because |activation_code| is not available.
346  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
347      .WillRepeatedly(Return(false));
348  EXPECT_CALL(*cdma_proxy, Activate(_, _, _, _)).Times(0);
349  capability_->ActivateAutomatic();
350  Mock::VerifyAndClearExpectations(mock_serving_operator_info_);
351  Mock::VerifyAndClearExpectations(modem_cdma_proxy_.get());
352  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
353      .WillRepeatedly(Return(true));
354  mock_serving_operator_info_->SetEmptyDefaultsForProperties();
355  EXPECT_CALL(*cdma_proxy, Activate(_, _, _, _)).Times(0);
356  capability_->ActivateAutomatic();
357  Mock::VerifyAndClearExpectations(mock_serving_operator_info_);
358  Mock::VerifyAndClearExpectations(modem_cdma_proxy_.get());
359
360  // These expectations hold for all subsequent tests.
361  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
362      .WillRepeatedly(Return(true));
363  EXPECT_CALL(*mock_serving_operator_info_, activation_code())
364      .WillRepeatedly(ReturnRef(activation_code));
365
366  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
367              GetActivationState(PendingActivationStore::kIdentifierMEID, _))
368      .WillOnce(Return(PendingActivationStore::kStatePending))
369      .WillOnce(Return(PendingActivationStore::kStateActivated));
370  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
371              SetActivationState(_, _, _))
372      .Times(0);
373  EXPECT_CALL(*cdma_proxy, Activate(_, _, _, _)).Times(0);
374  capability_->ActivateAutomatic();
375  capability_->ActivateAutomatic();
376  Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
377  Mock::VerifyAndClearExpectations(modem_cdma_proxy_.get());
378
379  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
380              GetActivationState(PendingActivationStore::kIdentifierMEID, _))
381      .WillOnce(Return(PendingActivationStore::kStateUnknown))
382      .WillOnce(Return(PendingActivationStore::kStateFailureRetry));
383  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
384              SetActivationState(_, _, PendingActivationStore::kStatePending))
385      .Times(2);
386  EXPECT_CALL(*cdma_proxy, Activate(_, _, _, _)).Times(2);
387  capability_->ActivateAutomatic();
388  capability_->ActivateAutomatic();
389  Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
390  Mock::VerifyAndClearExpectations(modem_cdma_proxy_.get());
391}
392
393TEST_F(CellularCapabilityUniversalCDMAMainTest, IsServiceActivationRequired) {
394  const vector<MobileOperatorInfo::OnlinePortal> empty_list;
395  const vector<MobileOperatorInfo::OnlinePortal> olp_list {
396    {"some@url", "some_method", "some_post_data"}
397  };
398  SetMockMobileOperatorInfoObjects();
399
400  capability_->activation_state_ =
401      MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
402  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
403      .WillRepeatedly(Return(false));
404  EXPECT_FALSE(capability_->IsServiceActivationRequired());
405  Mock::VerifyAndClearExpectations(mock_serving_operator_info_);
406
407  capability_->activation_state_ =
408      MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
409  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
410      .WillRepeatedly(Return(true));
411  EXPECT_CALL(*mock_serving_operator_info_, olp_list())
412      .WillRepeatedly(ReturnRef(empty_list));
413  EXPECT_FALSE(capability_->IsServiceActivationRequired());
414  Mock::VerifyAndClearExpectations(mock_serving_operator_info_);
415
416  // These expectations hold for all subsequent tests.
417  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
418      .WillRepeatedly(Return(true));
419  EXPECT_CALL(*mock_serving_operator_info_, olp_list())
420      .WillRepeatedly(ReturnRef(olp_list));
421
422  capability_->activation_state_ =
423      MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
424  EXPECT_TRUE(capability_->IsServiceActivationRequired());
425  capability_->activation_state_ =
426      MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
427  EXPECT_FALSE(capability_->IsServiceActivationRequired());
428  capability_->activation_state_ =
429      MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
430  EXPECT_FALSE(capability_->IsServiceActivationRequired());
431}
432
433TEST_F(CellularCapabilityUniversalCDMAMainTest,
434       UpdateServiceActivationStateProperty) {
435  const vector<MobileOperatorInfo::OnlinePortal> olp_list {
436    {"some@url", "some_method", "some_post_data"}
437  };
438  SetMockMobileOperatorInfoObjects();
439  EXPECT_CALL(*mock_serving_operator_info_, IsMobileNetworkOperatorKnown())
440      .WillRepeatedly(Return(true));
441  EXPECT_CALL(*mock_serving_operator_info_, olp_list())
442      .WillRepeatedly(ReturnRef(olp_list));
443
444  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
445              GetActivationState(_, _))
446      .WillOnce(Return(PendingActivationStore::kStatePending))
447      .WillRepeatedly(Return(PendingActivationStore::kStateUnknown));
448
449  capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
450  EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
451      .Times(1);
452  capability_->UpdateServiceActivationStateProperty();
453  Mock::VerifyAndClearExpectations(service_);
454
455  EXPECT_CALL(*service_, SetActivationState(kActivationStateNotActivated))
456      .Times(1);
457  capability_->UpdateServiceActivationStateProperty();
458  Mock::VerifyAndClearExpectations(service_);
459
460  capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
461  EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
462      .Times(1);
463  capability_->UpdateServiceActivationStateProperty();
464  Mock::VerifyAndClearExpectations(service_);
465
466  capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
467  EXPECT_CALL(*service_, SetActivationState(kActivationStateActivated))
468      .Times(1);
469  capability_->UpdateServiceActivationStateProperty();
470  Mock::VerifyAndClearExpectations(service_);
471  Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
472}
473
474TEST_F(CellularCapabilityUniversalCDMAMainTest, IsActivating) {
475  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
476              GetActivationState(_, _))
477      .WillOnce(Return(PendingActivationStore::kStatePending))
478      .WillOnce(Return(PendingActivationStore::kStatePending))
479      .WillOnce(Return(PendingActivationStore::kStateFailureRetry))
480      .WillRepeatedly(Return(PendingActivationStore::kStateUnknown));
481
482  capability_->activation_state_ =
483      MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
484  EXPECT_TRUE(capability_->IsActivating());
485  EXPECT_TRUE(capability_->IsActivating());
486  capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
487  EXPECT_TRUE(capability_->IsActivating());
488  EXPECT_TRUE(capability_->IsActivating());
489  capability_->activation_state_ =
490      MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
491  EXPECT_FALSE(capability_->IsActivating());
492}
493
494TEST_F(CellularCapabilityUniversalCDMAMainTest, IsRegistered) {
495  capability_->cdma_1x_registration_state_ =
496      MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
497  capability_->cdma_evdo_registration_state_ =
498      MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
499  EXPECT_FALSE(capability_->IsRegistered());
500
501  capability_->cdma_evdo_registration_state_ =
502      MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
503  EXPECT_TRUE(capability_->IsRegistered());
504
505  capability_->cdma_evdo_registration_state_ =
506      MM_MODEM_CDMA_REGISTRATION_STATE_HOME;
507  EXPECT_TRUE(capability_->IsRegistered());
508
509  capability_->cdma_evdo_registration_state_ =
510      MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING;
511  EXPECT_TRUE(capability_->IsRegistered());
512
513  capability_->cdma_1x_registration_state_ =
514      MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
515  capability_->cdma_evdo_registration_state_ =
516      MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
517  EXPECT_TRUE(capability_->IsRegistered());
518
519  capability_->cdma_evdo_registration_state_ =
520      MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
521  EXPECT_TRUE(capability_->IsRegistered());
522
523  capability_->cdma_evdo_registration_state_ =
524      MM_MODEM_CDMA_REGISTRATION_STATE_HOME;
525  EXPECT_TRUE(capability_->IsRegistered());
526
527  capability_->cdma_evdo_registration_state_ =
528      MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING;
529  EXPECT_TRUE(capability_->IsRegistered());
530
531  capability_->cdma_1x_registration_state_ =
532      MM_MODEM_CDMA_REGISTRATION_STATE_HOME;
533  capability_->cdma_evdo_registration_state_ =
534      MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
535  EXPECT_TRUE(capability_->IsRegistered());
536
537  capability_->cdma_evdo_registration_state_ =
538      MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
539  EXPECT_TRUE(capability_->IsRegistered());
540
541  capability_->cdma_evdo_registration_state_ =
542      MM_MODEM_CDMA_REGISTRATION_STATE_HOME;
543  EXPECT_TRUE(capability_->IsRegistered());
544
545  capability_->cdma_evdo_registration_state_ =
546      MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING;
547  EXPECT_TRUE(capability_->IsRegistered());
548
549  capability_->cdma_1x_registration_state_ =
550      MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING;
551  capability_->cdma_evdo_registration_state_ =
552      MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
553  EXPECT_TRUE(capability_->IsRegistered());
554
555  capability_->cdma_evdo_registration_state_ =
556      MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
557  EXPECT_TRUE(capability_->IsRegistered());
558
559  capability_->cdma_evdo_registration_state_ =
560      MM_MODEM_CDMA_REGISTRATION_STATE_HOME;
561  EXPECT_TRUE(capability_->IsRegistered());
562
563  capability_->cdma_evdo_registration_state_ =
564      MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING;
565  EXPECT_TRUE(capability_->IsRegistered());
566}
567
568TEST_F(CellularCapabilityUniversalCDMAMainTest, SetupConnectProperties) {
569  KeyValueStore map;
570  capability_->SetupConnectProperties(&map);
571  EXPECT_EQ(1, map.properties().size());
572  EXPECT_EQ("#777", map.GetString("number"));
573}
574
575TEST_F(CellularCapabilityUniversalCDMADispatcherTest,
576       UpdatePendingActivationState) {
577  capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
578  EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_, _))
579      .Times(1);
580  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
581              GetActivationState(_, _))
582      .Times(0);
583  EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(0);
584  capability_->UpdatePendingActivationState();
585  Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
586  Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
587
588  capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
589  EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_, _))
590      .Times(0);
591  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
592              GetActivationState(_, _))
593      .Times(2)
594      .WillRepeatedly(Return(PendingActivationStore::kStateUnknown));
595  EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(0);
596  capability_->UpdatePendingActivationState();
597  Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
598  Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
599
600  capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
601  EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_, _))
602      .Times(0);
603  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
604              GetActivationState(_, _))
605      .Times(2)
606      .WillRepeatedly(Return(PendingActivationStore::kStatePending));
607  EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(0);
608  capability_->UpdatePendingActivationState();
609  Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
610  Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
611
612  EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_, _))
613      .Times(0);
614  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
615              GetActivationState(_, _))
616      .Times(2)
617      .WillRepeatedly(Return(PendingActivationStore::kStateFailureRetry));
618  EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(1);
619  capability_->UpdatePendingActivationState();
620  Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
621  Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
622
623  EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_, _))
624      .Times(0);
625  EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
626              GetActivationState(_, _))
627      .Times(4)
628      .WillOnce(Return(PendingActivationStore::kStateActivated))
629      .WillOnce(Return(PendingActivationStore::kStateActivated))
630      .WillOnce(Return(PendingActivationStore::kStateUnknown))
631      .WillOnce(Return(PendingActivationStore::kStateUnknown));
632  EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(0);
633  capability_->UpdatePendingActivationState();
634  capability_->UpdatePendingActivationState();
635  Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
636  Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
637}
638
639}  // namespace shill
640