cellular_capability_gsm_unittest.cc - platform/system/connectivity/shill - Gitiles

 // Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "shill/cellular_capability_gsm.h"

 #include <chromeos/dbus/service_constants.h>
 #include <gtest/gtest.h>
 #include <mm/mm-modem.h>
 #include <mobile_provider.h>

 #include "shill/cellular.h"
 #include "shill/cellular_service.h"
 #include "shill/error.h"
 #include "shill/event_dispatcher.h"
 #include "shill/mock_modem_gsm_card_proxy.h"
 #include "shill/mock_modem_gsm_network_proxy.h"
 #include "shill/nice_mock_control.h"

 using testing::Return;

 namespace shill {

 class CellularCapabilityGSMTest : public testing::Test {
  public:
   CellularCapabilityGSMTest()
       : cellular_(new Cellular(&control_,
                                &dispatcher_,
                                NULL,
                                "",
                                "",
                                0,
                                Cellular::kTypeGSM,
                                "",
                                "",
                                NULL)),
         card_proxy_(new MockModemGSMCardProxy()),
         network_proxy_(new MockModemGSMNetworkProxy()),
         capability_(cellular_.get()),
         provider_db_(NULL) {}

   virtual ~CellularCapabilityGSMTest() {
     cellular_->service_ = NULL;
     mobile_provider_close_db(provider_db_);
     provider_db_ = NULL;
   }

  protected:
   static const char kTestMobileProviderDBPath[];
   static const char kTestCarrier[];
   static const char kPIN[];
   static const char kPUK[];
   static const char kIMEI[];
   static const char kIMSI[];
   static const char kMSISDN[];

   void SetCardProxy() {
     capability_.card_proxy_.reset(card_proxy_.release());
   }

   void SetNetworkProxy() {
     cellular_->set_modem_gsm_network_proxy(network_proxy_.release());
   }

   void SetAccessTechnology(uint32 technology) {
     cellular_->gsm_.access_technology = technology;
   }

   void SetRegistrationState(uint32 state) {
     cellular_->gsm_.registration_state = state;
   }

   void SetService() {
     cellular_->service_ = new CellularService(
         &control_, &dispatcher_, NULL, cellular_);
   }

   void InitProviderDB() {
     provider_db_ = mobile_provider_open_db(kTestMobileProviderDBPath);
     ASSERT_TRUE(provider_db_);
     cellular_->provider_db_ = provider_db_;
   }

   NiceMockControl control_;
   EventDispatcher dispatcher_;
   CellularRefPtr cellular_;
   scoped_ptr<MockModemGSMCardProxy> card_proxy_;
   scoped_ptr<MockModemGSMNetworkProxy> network_proxy_;
   CellularCapabilityGSM capability_;
   mobile_provider_db *provider_db_;
 };

 const char CellularCapabilityGSMTest::kTestMobileProviderDBPath[] =
     "provider_db_unittest.bfd";
 const char CellularCapabilityGSMTest::kTestCarrier[] = "The Cellular Carrier";
 const char CellularCapabilityGSMTest::kPIN[] = "9876";
 const char CellularCapabilityGSMTest::kPUK[] = "8765";
 const char CellularCapabilityGSMTest::kIMEI[] = "987654321098765";
 const char CellularCapabilityGSMTest::kIMSI[] = "123456789012345";
 const char CellularCapabilityGSMTest::kMSISDN[] = "12345678901";

 TEST_F(CellularCapabilityGSMTest, GetIdentifiers) {
   EXPECT_CALL(*card_proxy_, GetIMEI()).WillOnce(Return(kIMEI));
   EXPECT_CALL(*card_proxy_, GetIMSI()).WillOnce(Return(kIMSI));
   EXPECT_CALL(*card_proxy_, GetSPN()).WillOnce(Return(kTestCarrier));
   EXPECT_CALL(*card_proxy_, GetMSISDN()).WillOnce(Return(kMSISDN));
   SetCardProxy();
   capability_.GetIdentifiers();
   EXPECT_EQ(kIMEI, cellular_->imei());
   EXPECT_EQ(kIMSI, cellular_->imsi());
   EXPECT_EQ(kTestCarrier, cellular_->spn());
   EXPECT_EQ(kMSISDN, cellular_->mdn());
   capability_.GetIdentifiers();
   EXPECT_EQ(kIMEI, cellular_->imei());
   EXPECT_EQ(kIMSI, cellular_->imsi());
   EXPECT_EQ(kTestCarrier, cellular_->spn());
   EXPECT_EQ(kMSISDN, cellular_->mdn());
 }

 TEST_F(CellularCapabilityGSMTest, GetSignalQuality) {
   const int kStrength = 80;
   EXPECT_CALL(*network_proxy_, GetSignalQuality()).WillOnce(Return(kStrength));
   SetNetworkProxy();
   SetService();
   EXPECT_EQ(0, cellular_->service()->strength());
   capability_.GetSignalQuality();
   EXPECT_EQ(kStrength, cellular_->service()->strength());
 }

 TEST_F(CellularCapabilityGSMTest, RequirePIN) {
   Error error;
   EXPECT_CALL(*card_proxy_, EnablePIN(kPIN, true)).Times(1);
   capability_.RequirePIN(kPIN, true, &error);
   EXPECT_TRUE(error.IsSuccess());
   SetCardProxy();
   dispatcher_.DispatchPendingEvents();
 }

 TEST_F(CellularCapabilityGSMTest, EnterPIN) {
   Error error;
   EXPECT_CALL(*card_proxy_, SendPIN(kPIN)).Times(1);
   capability_.EnterPIN(kPIN, &error);
   EXPECT_TRUE(error.IsSuccess());
   SetCardProxy();
   dispatcher_.DispatchPendingEvents();
 }

 TEST_F(CellularCapabilityGSMTest, UnblockPIN) {
   Error error;
   EXPECT_CALL(*card_proxy_, SendPUK(kPUK, kPIN)).Times(1);
   capability_.UnblockPIN(kPUK, kPIN, &error);
   EXPECT_TRUE(error.IsSuccess());
   SetCardProxy();
   dispatcher_.DispatchPendingEvents();
 }

 TEST_F(CellularCapabilityGSMTest, ChangePIN) {
   static const char kOldPIN[] = "1111";
   Error error;
   EXPECT_CALL(*card_proxy_, ChangePIN(kOldPIN, kPIN)).Times(1);
   capability_.ChangePIN(kOldPIN, kPIN, &error);
   EXPECT_TRUE(error.IsSuccess());
   SetCardProxy();
   dispatcher_.DispatchPendingEvents();
 }

 TEST_F(CellularCapabilityGSMTest, Scan) {
   static const char kID0[] = "123";
   static const char kID1[] = "456";
   Error error;
   capability_.Scan(&error);
   EXPECT_TRUE(error.IsSuccess());
   ModemGSMNetworkProxyInterface::ScanResults results;
   results.push_back(ModemGSMNetworkProxyInterface::ScanResult());
   results[0][CellularCapabilityGSM::kNetworkPropertyID] = kID0;
   results.push_back(ModemGSMNetworkProxyInterface::ScanResult());
   results[1][CellularCapabilityGSM::kNetworkPropertyID] = kID1;
   EXPECT_CALL(*network_proxy_, Scan()).WillOnce(Return(results));
   SetNetworkProxy();
   capability_.found_networks_.resize(3, Stringmap());
   dispatcher_.DispatchPendingEvents();
   EXPECT_EQ(2, capability_.found_networks_.size());
   EXPECT_EQ(kID0, capability_.found_networks_[0][flimflam::kNetworkIdProperty]);
   EXPECT_EQ(kID1, capability_.found_networks_[1][flimflam::kNetworkIdProperty]);
 }

 TEST_F(CellularCapabilityGSMTest, ParseScanResult) {
   static const char kID[] = "123";
   static const char kLongName[] = "long name";
   static const char kShortName[] = "short name";
   ModemGSMNetworkProxyInterface::ScanResult result;
   result[CellularCapabilityGSM::kNetworkPropertyStatus] = "1";
   result[CellularCapabilityGSM::kNetworkPropertyID] = kID;
   result[CellularCapabilityGSM::kNetworkPropertyLongName] = kLongName;
   result[CellularCapabilityGSM::kNetworkPropertyShortName] = kShortName;
   result[CellularCapabilityGSM::kNetworkPropertyAccessTechnology] = "3";
   result["unknown property"] = "random value";
   Stringmap parsed = capability_.ParseScanResult(result);
   EXPECT_EQ(5, parsed.size());
   EXPECT_EQ("available", parsed[flimflam::kStatusProperty]);
   EXPECT_EQ(kID, parsed[flimflam::kNetworkIdProperty]);
   EXPECT_EQ(kLongName, parsed[flimflam::kLongNameProperty]);
   EXPECT_EQ(kShortName, parsed[flimflam::kShortNameProperty]);
   EXPECT_EQ(flimflam::kNetworkTechnologyEdge,
             parsed[flimflam::kTechnologyProperty]);
 }

 TEST_F(CellularCapabilityGSMTest, ParseScanResultProviderLookup) {
   InitProviderDB();
   static const char kID[] = "310210";
   ModemGSMNetworkProxyInterface::ScanResult result;
   result[CellularCapabilityGSM::kNetworkPropertyID] = kID;
   Stringmap parsed = capability_.ParseScanResult(result);
   EXPECT_EQ(2, parsed.size());
   EXPECT_EQ(kID, parsed[flimflam::kNetworkIdProperty]);
   EXPECT_EQ("T-Mobile", parsed[flimflam::kLongNameProperty]);
 }

 TEST_F(CellularCapabilityGSMTest, GetNetworkTechnologyString) {
   EXPECT_EQ("", capability_.GetNetworkTechnologyString());
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GSM);
   EXPECT_EQ("", capability_.GetNetworkTechnologyString());
   SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_HOME);
   EXPECT_EQ(flimflam::kNetworkTechnologyGsm,
             capability_.GetNetworkTechnologyString());
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GSM_COMPACT);
   EXPECT_EQ(flimflam::kNetworkTechnologyGsm,
             capability_.GetNetworkTechnologyString());
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GPRS);
   EXPECT_EQ(flimflam::kNetworkTechnologyGprs,
             capability_.GetNetworkTechnologyString());
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_EDGE);
   EXPECT_EQ(flimflam::kNetworkTechnologyEdge,
             capability_.GetNetworkTechnologyString());
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_UMTS);
   EXPECT_EQ(flimflam::kNetworkTechnologyUmts,
             capability_.GetNetworkTechnologyString());
   SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_ROAMING);
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSDPA);
   EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
             capability_.GetNetworkTechnologyString());
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSUPA);
   EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
             capability_.GetNetworkTechnologyString());
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSPA);
   EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
             capability_.GetNetworkTechnologyString());
   SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSPA_PLUS);
   EXPECT_EQ(flimflam::kNetworkTechnologyHspaPlus,
             capability_.GetNetworkTechnologyString());
 }

 TEST_F(CellularCapabilityGSMTest, GetRoamingStateString) {
   EXPECT_EQ(flimflam::kRoamingStateUnknown,
             capability_.GetRoamingStateString());
   SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_HOME);
   EXPECT_EQ(flimflam::kRoamingStateHome,
             capability_.GetRoamingStateString());
   SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_ROAMING);
   EXPECT_EQ(flimflam::kRoamingStateRoaming,
             capability_.GetRoamingStateString());
   SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_SEARCHING);
   EXPECT_EQ(flimflam::kRoamingStateUnknown,
             capability_.GetRoamingStateString());
   SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_DENIED);
   EXPECT_EQ(flimflam::kRoamingStateUnknown,
             capability_.GetRoamingStateString());
   SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_IDLE);
   EXPECT_EQ(flimflam::kRoamingStateUnknown,
             capability_.GetRoamingStateString());
 }

 }  // namespace shill
	// Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "shill/cellular_capability_gsm.h"

	#include <chromeos/dbus/service_constants.h>
	#include <gtest/gtest.h>
	#include <mm/mm-modem.h>
	#include <mobile_provider.h>

	#include "shill/cellular.h"
	#include "shill/cellular_service.h"
	#include "shill/error.h"
	#include "shill/event_dispatcher.h"
	#include "shill/mock_modem_gsm_card_proxy.h"
	#include "shill/mock_modem_gsm_network_proxy.h"
	#include "shill/nice_mock_control.h"

	using testing::Return;

	namespace shill {

	class CellularCapabilityGSMTest : public testing::Test {
	public:
	CellularCapabilityGSMTest()
	: cellular_(new Cellular(&control_,
	&dispatcher_,
	NULL,
	"",
	"",
	0,
	Cellular::kTypeGSM,
	"",
	"",
	NULL)),
	card_proxy_(new MockModemGSMCardProxy()),
	network_proxy_(new MockModemGSMNetworkProxy()),
	capability_(cellular_.get()),
	provider_db_(NULL) {}

	virtual ~CellularCapabilityGSMTest() {
	cellular_->service_ = NULL;
	mobile_provider_close_db(provider_db_);
	provider_db_ = NULL;
	}

	protected:
	static const char kTestMobileProviderDBPath[];
	static const char kTestCarrier[];
	static const char kPIN[];
	static const char kPUK[];
	static const char kIMEI[];
	static const char kIMSI[];
	static const char kMSISDN[];

	void SetCardProxy() {
	capability_.card_proxy_.reset(card_proxy_.release());
	}

	void SetNetworkProxy() {
	cellular_->set_modem_gsm_network_proxy(network_proxy_.release());
	}

	void SetAccessTechnology(uint32 technology) {
	cellular_->gsm_.access_technology = technology;
	}

	void SetRegistrationState(uint32 state) {
	cellular_->gsm_.registration_state = state;
	}

	void SetService() {
	cellular_->service_ = new CellularService(
	&control_, &dispatcher_, NULL, cellular_);
	}

	void InitProviderDB() {
	provider_db_ = mobile_provider_open_db(kTestMobileProviderDBPath);
	ASSERT_TRUE(provider_db_);
	cellular_->provider_db_ = provider_db_;
	}

	NiceMockControl control_;
	EventDispatcher dispatcher_;
	CellularRefPtr cellular_;
	scoped_ptr<MockModemGSMCardProxy> card_proxy_;
	scoped_ptr<MockModemGSMNetworkProxy> network_proxy_;
	CellularCapabilityGSM capability_;
	mobile_provider_db *provider_db_;
	};

	const char CellularCapabilityGSMTest::kTestMobileProviderDBPath[] =
	"provider_db_unittest.bfd";
	const char CellularCapabilityGSMTest::kTestCarrier[] = "The Cellular Carrier";
	const char CellularCapabilityGSMTest::kPIN[] = "9876";
	const char CellularCapabilityGSMTest::kPUK[] = "8765";
	const char CellularCapabilityGSMTest::kIMEI[] = "987654321098765";
	const char CellularCapabilityGSMTest::kIMSI[] = "123456789012345";
	const char CellularCapabilityGSMTest::kMSISDN[] = "12345678901";

	TEST_F(CellularCapabilityGSMTest, GetIdentifiers) {
	EXPECT_CALL(*card_proxy_, GetIMEI()).WillOnce(Return(kIMEI));
	EXPECT_CALL(*card_proxy_, GetIMSI()).WillOnce(Return(kIMSI));
	EXPECT_CALL(*card_proxy_, GetSPN()).WillOnce(Return(kTestCarrier));
	EXPECT_CALL(*card_proxy_, GetMSISDN()).WillOnce(Return(kMSISDN));
	SetCardProxy();
	capability_.GetIdentifiers();
	EXPECT_EQ(kIMEI, cellular_->imei());
	EXPECT_EQ(kIMSI, cellular_->imsi());
	EXPECT_EQ(kTestCarrier, cellular_->spn());
	EXPECT_EQ(kMSISDN, cellular_->mdn());
	capability_.GetIdentifiers();
	EXPECT_EQ(kIMEI, cellular_->imei());
	EXPECT_EQ(kIMSI, cellular_->imsi());
	EXPECT_EQ(kTestCarrier, cellular_->spn());
	EXPECT_EQ(kMSISDN, cellular_->mdn());
	}

	TEST_F(CellularCapabilityGSMTest, GetSignalQuality) {
	const int kStrength = 80;
	EXPECT_CALL(*network_proxy_, GetSignalQuality()).WillOnce(Return(kStrength));
	SetNetworkProxy();
	SetService();
	EXPECT_EQ(0, cellular_->service()->strength());
	capability_.GetSignalQuality();
	EXPECT_EQ(kStrength, cellular_->service()->strength());
	}

	TEST_F(CellularCapabilityGSMTest, RequirePIN) {
	Error error;
	EXPECT_CALL(*card_proxy_, EnablePIN(kPIN, true)).Times(1);
	capability_.RequirePIN(kPIN, true, &error);
	EXPECT_TRUE(error.IsSuccess());
	SetCardProxy();
	dispatcher_.DispatchPendingEvents();
	}

	TEST_F(CellularCapabilityGSMTest, EnterPIN) {
	Error error;
	EXPECT_CALL(*card_proxy_, SendPIN(kPIN)).Times(1);
	capability_.EnterPIN(kPIN, &error);
	EXPECT_TRUE(error.IsSuccess());
	SetCardProxy();
	dispatcher_.DispatchPendingEvents();
	}

	TEST_F(CellularCapabilityGSMTest, UnblockPIN) {
	Error error;
	EXPECT_CALL(*card_proxy_, SendPUK(kPUK, kPIN)).Times(1);
	capability_.UnblockPIN(kPUK, kPIN, &error);
	EXPECT_TRUE(error.IsSuccess());
	SetCardProxy();
	dispatcher_.DispatchPendingEvents();
	}

	TEST_F(CellularCapabilityGSMTest, ChangePIN) {
	static const char kOldPIN[] = "1111";
	Error error;
	EXPECT_CALL(*card_proxy_, ChangePIN(kOldPIN, kPIN)).Times(1);
	capability_.ChangePIN(kOldPIN, kPIN, &error);
	EXPECT_TRUE(error.IsSuccess());
	SetCardProxy();
	dispatcher_.DispatchPendingEvents();
	}

	TEST_F(CellularCapabilityGSMTest, Scan) {
	static const char kID0[] = "123";
	static const char kID1[] = "456";
	Error error;
	capability_.Scan(&error);
	EXPECT_TRUE(error.IsSuccess());
	ModemGSMNetworkProxyInterface::ScanResults results;
	results.push_back(ModemGSMNetworkProxyInterface::ScanResult());
	results[0][CellularCapabilityGSM::kNetworkPropertyID] = kID0;
	results.push_back(ModemGSMNetworkProxyInterface::ScanResult());
	results[1][CellularCapabilityGSM::kNetworkPropertyID] = kID1;
	EXPECT_CALL(*network_proxy_, Scan()).WillOnce(Return(results));
	SetNetworkProxy();
	capability_.found_networks_.resize(3, Stringmap());
	dispatcher_.DispatchPendingEvents();
	EXPECT_EQ(2, capability_.found_networks_.size());
	EXPECT_EQ(kID0, capability_.found_networks_[0][flimflam::kNetworkIdProperty]);
	EXPECT_EQ(kID1, capability_.found_networks_[1][flimflam::kNetworkIdProperty]);
	}

	TEST_F(CellularCapabilityGSMTest, ParseScanResult) {
	static const char kID[] = "123";
	static const char kLongName[] = "long name";
	static const char kShortName[] = "short name";
	ModemGSMNetworkProxyInterface::ScanResult result;
	result[CellularCapabilityGSM::kNetworkPropertyStatus] = "1";
	result[CellularCapabilityGSM::kNetworkPropertyID] = kID;
	result[CellularCapabilityGSM::kNetworkPropertyLongName] = kLongName;
	result[CellularCapabilityGSM::kNetworkPropertyShortName] = kShortName;
	result[CellularCapabilityGSM::kNetworkPropertyAccessTechnology] = "3";
	result["unknown property"] = "random value";
	Stringmap parsed = capability_.ParseScanResult(result);
	EXPECT_EQ(5, parsed.size());
	EXPECT_EQ("available", parsed[flimflam::kStatusProperty]);
	EXPECT_EQ(kID, parsed[flimflam::kNetworkIdProperty]);
	EXPECT_EQ(kLongName, parsed[flimflam::kLongNameProperty]);
	EXPECT_EQ(kShortName, parsed[flimflam::kShortNameProperty]);
	EXPECT_EQ(flimflam::kNetworkTechnologyEdge,
	parsed[flimflam::kTechnologyProperty]);
	}

	TEST_F(CellularCapabilityGSMTest, ParseScanResultProviderLookup) {
	InitProviderDB();
	static const char kID[] = "310210";
	ModemGSMNetworkProxyInterface::ScanResult result;
	result[CellularCapabilityGSM::kNetworkPropertyID] = kID;
	Stringmap parsed = capability_.ParseScanResult(result);
	EXPECT_EQ(2, parsed.size());
	EXPECT_EQ(kID, parsed[flimflam::kNetworkIdProperty]);
	EXPECT_EQ("T-Mobile", parsed[flimflam::kLongNameProperty]);
	}

	TEST_F(CellularCapabilityGSMTest, GetNetworkTechnologyString) {
	EXPECT_EQ("", capability_.GetNetworkTechnologyString());
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GSM);
	EXPECT_EQ("", capability_.GetNetworkTechnologyString());
	SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_HOME);
	EXPECT_EQ(flimflam::kNetworkTechnologyGsm,
	capability_.GetNetworkTechnologyString());
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GSM_COMPACT);
	EXPECT_EQ(flimflam::kNetworkTechnologyGsm,
	capability_.GetNetworkTechnologyString());
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GPRS);
	EXPECT_EQ(flimflam::kNetworkTechnologyGprs,
	capability_.GetNetworkTechnologyString());
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_EDGE);
	EXPECT_EQ(flimflam::kNetworkTechnologyEdge,
	capability_.GetNetworkTechnologyString());
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_UMTS);
	EXPECT_EQ(flimflam::kNetworkTechnologyUmts,
	capability_.GetNetworkTechnologyString());
	SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_ROAMING);
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSDPA);
	EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
	capability_.GetNetworkTechnologyString());
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSUPA);
	EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
	capability_.GetNetworkTechnologyString());
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSPA);
	EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
	capability_.GetNetworkTechnologyString());
	SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSPA_PLUS);
	EXPECT_EQ(flimflam::kNetworkTechnologyHspaPlus,
	capability_.GetNetworkTechnologyString());
	}

	TEST_F(CellularCapabilityGSMTest, GetRoamingStateString) {
	EXPECT_EQ(flimflam::kRoamingStateUnknown,
	capability_.GetRoamingStateString());
	SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_HOME);
	EXPECT_EQ(flimflam::kRoamingStateHome,
	capability_.GetRoamingStateString());
	SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_ROAMING);
	EXPECT_EQ(flimflam::kRoamingStateRoaming,
	capability_.GetRoamingStateString());
	SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_SEARCHING);
	EXPECT_EQ(flimflam::kRoamingStateUnknown,
	capability_.GetRoamingStateString());
	SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_DENIED);
	EXPECT_EQ(flimflam::kRoamingStateUnknown,
	capability_.GetRoamingStateString());
	SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_IDLE);
	EXPECT_EQ(flimflam::kRoamingStateUnknown,
	capability_.GetRoamingStateString());
	}

	} // namespace shill