cellular_operator_info_unittest.cc

// Copyright (c) 2013 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_operator_info.h"

#include <base/file_util.h>
#include <gtest/gtest.h>

using std::map;
using std::string;
using std::vector;

namespace shill {

namespace {

const char kTestInfoFileContent[] =
    "#\n"
    "# Comments\n"
    "#\n"
    "serviceproviders:3.0\n"
    "country:us\n"
    "\n"
    "# TestProvider1\n"
    "provider:1,1,0,1\n"
    "identifier:provider1identifier\n"
    "name:,TestProvider1\n"
    "mccmnc:000001,0,000002,0\n"
    "sid:1,0,2,0,3,0\n"
    "olp:POST,https://testurl,imei=${imei}&iccid=${iccid}\n"
    "apn:2,testprovider1apn,,\n"
    "name:en,Test Provider 1\n"
    "name:de,Testmobilfunkanbieter 1\n"
    "\n"
    "# TestProvider2\n"
    "provider:1,2,1,0\n"
    "identifier:provider2identifier\n"
    "name:,TestProviderTwo\n"
    "name:,TestProvider2\n"
    "mccmnc:100001,1,100002,0\n"
    "sid:4,0,5,1\n"
    "olp:,https://testurl2,\n"
    "olp:,https://testurl3,\n"
    "apn:1,testprovider2apn,,\n"
    "name:,Test Provider 2\n"
    "apn:1,testprovider2apn2,testusername,testpassword\n"
    "name:tr,Test Operatoru 2\n";

}  // namespace

class CellularOperatorInfoTest : public testing::Test {
 public:
  CellularOperatorInfoTest() {}

 protected:
  void SetUp() {
    ASSERT_TRUE(file_util::CreateTemporaryFile(&info_file_path_));
    ASSERT_EQ(arraysize(kTestInfoFileContent),
              file_util::WriteFile(info_file_path_, kTestInfoFileContent,
                                   arraysize(kTestInfoFileContent)));
  }

  void TearDown() {
    ASSERT_TRUE(file_util::Delete(info_file_path_, false));
  }

  GLib glib_;
  FilePath info_file_path_;
  CellularOperatorInfo info_;
};

TEST_F(CellularOperatorInfoTest, ParseSuccess) {
  EXPECT_TRUE(info_.Load(info_file_path_));
  EXPECT_EQ(info_.operators().size(), 2);

  const CellularOperatorInfo::CellularOperator *provider = info_.operators()[0];
  EXPECT_FALSE(provider->is_primary());
  EXPECT_TRUE(provider->requires_roaming());
  EXPECT_EQ(provider->country(), "us");
  EXPECT_EQ(provider->identifier(), "provider1identifier");
  EXPECT_EQ(provider->name_list().size(), 1);
  EXPECT_EQ(provider->name_list()[0].language, "");
  EXPECT_EQ(provider->name_list()[0].name, "TestProvider1");
  EXPECT_EQ(provider->mccmnc_list().size(), 2);
  EXPECT_EQ(provider->mccmnc_list()[0], "000001");
  EXPECT_EQ(provider->mccmnc_list()[1], "000002");
  EXPECT_EQ(provider->sid_list().size(), 3);
  EXPECT_EQ(provider->sid_list()[0], "1");
  EXPECT_EQ(provider->sid_list()[1], "2");
  EXPECT_EQ(provider->sid_list()[2], "3");
  EXPECT_EQ(provider->olp_list().size(), 1);
  EXPECT_EQ(provider->olp_list()[0]->GetURL(), "https://testurl");
  EXPECT_EQ(provider->olp_list()[0]->GetMethod(), "POST");
  EXPECT_EQ(provider->olp_list()[0]->GetPostData(),
            "imei=${imei}&iccid=${iccid}");
  EXPECT_EQ(provider->apn_list().size(), 1);
  EXPECT_EQ(provider->apn_list()[0]->apn(), "testprovider1apn");
  EXPECT_EQ(provider->apn_list()[0]->username(), "");
  EXPECT_EQ(provider->apn_list()[0]->password(), "");
  EXPECT_EQ(provider->apn_list()[0]->name_list().size(), 2);
  EXPECT_EQ(provider->apn_list()[0]->name_list()[0].language, "en");
  EXPECT_EQ(provider->apn_list()[0]->name_list()[0].name, "Test Provider 1");
  EXPECT_EQ(provider->apn_list()[0]->name_list()[1].language, "de");
  EXPECT_EQ(provider->apn_list()[0]->name_list()[1].name,
            "Testmobilfunkanbieter 1");

  const CellularOperatorInfo::CellularOperator *provider2 =
      info_.operators()[1];
  EXPECT_TRUE(provider2->is_primary());
  EXPECT_FALSE(provider2->requires_roaming());
  EXPECT_EQ(provider2->country(), "us");
  EXPECT_EQ(provider2->identifier(), "provider2identifier");
  EXPECT_EQ(provider2->name_list().size(), 2);
  EXPECT_EQ(provider2->name_list()[0].language, "");
  EXPECT_EQ(provider2->name_list()[0].name, "TestProviderTwo");
  EXPECT_EQ(provider2->name_list()[1].language, "");
  EXPECT_EQ(provider2->name_list()[1].name, "TestProvider2");
  EXPECT_EQ(provider2->mccmnc_list().size(), 2);
  EXPECT_EQ(provider2->mccmnc_list()[0], "100001");
  EXPECT_EQ(provider2->mccmnc_list()[1], "100002");
  EXPECT_EQ(provider2->sid_list().size(), 2);
  EXPECT_EQ(provider2->sid_list()[0], "4");
  EXPECT_EQ(provider2->sid_list()[1], "5");
  EXPECT_EQ(provider2->olp_list().size(), 2);
  EXPECT_EQ(provider2->olp_list()[0]->GetURL(), "https://testurl2");
  EXPECT_EQ(provider2->olp_list()[0]->GetMethod(), "");
  EXPECT_EQ(provider2->olp_list()[0]->GetPostData(), "");
  EXPECT_EQ(provider2->olp_list()[1]->GetURL(), "https://testurl3");
  EXPECT_EQ(provider2->olp_list()[1]->GetMethod(), "");
  EXPECT_EQ(provider2->olp_list()[1]->GetPostData(), "");
  EXPECT_EQ(provider2->apn_list().size(), 2);
  EXPECT_EQ(provider2->apn_list()[0]->apn(), "testprovider2apn");
  EXPECT_EQ(provider2->apn_list()[0]->username(), "");
  EXPECT_EQ(provider2->apn_list()[0]->password(), "");
  EXPECT_EQ(provider2->apn_list()[0]->name_list().size(), 1);
  EXPECT_EQ(provider2->apn_list()[0]->name_list()[0].language, "");
  EXPECT_EQ(provider2->apn_list()[0]->name_list()[0].name, "Test Provider 2");
  EXPECT_EQ(provider2->apn_list()[1]->apn(), "testprovider2apn2");
  EXPECT_EQ(provider2->apn_list()[1]->username(), "testusername");
  EXPECT_EQ(provider2->apn_list()[1]->password(), "testpassword");
  EXPECT_EQ(provider2->apn_list()[1]->name_list().size(), 1);
  EXPECT_EQ(provider2->apn_list()[1]->name_list()[0].language, "tr");
  EXPECT_EQ(provider2->apn_list()[1]->name_list()[0].name, "Test Operatoru 2");
}

TEST_F(CellularOperatorInfoTest, GetCellularOperatorByMCCMNC) {
  EXPECT_TRUE(info_.Load(info_file_path_));

  EXPECT_FALSE(info_.GetCellularOperatorByMCCMNC("1"));
  EXPECT_FALSE(info_.GetCellularOperatorByMCCMNC("000003"));
  EXPECT_FALSE(info_.GetCellularOperatorByMCCMNC("bananas"));
  EXPECT_FALSE(info_.GetCellularOperatorByMCCMNC("abcd"));

  const CellularOperatorInfo::CellularOperator *provider = NULL;
  EXPECT_TRUE((provider = info_.GetCellularOperatorByMCCMNC("000001")));
  EXPECT_EQ(provider, info_.operators()[0]);
  EXPECT_TRUE((provider = info_.GetCellularOperatorByMCCMNC("100001")));
  EXPECT_EQ(provider, info_.operators()[1]);
  EXPECT_TRUE((provider = info_.GetCellularOperatorByMCCMNC("000002")));
  EXPECT_EQ(provider, info_.operators()[0]);
  EXPECT_TRUE((provider = info_.GetCellularOperatorByMCCMNC("100002")));
  EXPECT_EQ(provider, info_.operators()[1]);
}

TEST_F(CellularOperatorInfoTest, GetCellularOperatorBySID) {
  EXPECT_TRUE(info_.Load(info_file_path_));

  EXPECT_FALSE(info_.GetCellularOperatorBySID("000001"));
  EXPECT_FALSE(info_.GetCellularOperatorBySID("000002"));
  EXPECT_FALSE(info_.GetCellularOperatorBySID("100001"));
  EXPECT_FALSE(info_.GetCellularOperatorBySID("100002"));
  EXPECT_FALSE(info_.GetCellularOperatorBySID("banana"));

  const CellularOperatorInfo::CellularOperator *provider = NULL;
  EXPECT_TRUE((provider = info_.GetCellularOperatorBySID("1")));
  EXPECT_EQ(provider, info_.operators()[0]);
  EXPECT_TRUE((provider = info_.GetCellularOperatorBySID("4")));
  EXPECT_EQ(provider, info_.operators()[1]);
  EXPECT_TRUE((provider = info_.GetCellularOperatorBySID("2")));
  EXPECT_EQ(provider, info_.operators()[0]);
  EXPECT_TRUE((provider = info_.GetCellularOperatorBySID("5")));
  EXPECT_EQ(provider, info_.operators()[1]);
  EXPECT_TRUE((provider = info_.GetCellularOperatorBySID("3")));
  EXPECT_EQ(provider, info_.operators()[0]);
}

TEST_F(CellularOperatorInfoTest, GetCellularOperatorsByName) {
  EXPECT_TRUE(info_.Load(info_file_path_));

  const vector<const CellularOperatorInfo::CellularOperator *> *list = NULL;
  EXPECT_FALSE(info_.GetCellularOperatorsByName("banana"));
  EXPECT_FALSE(info_.GetCellularOperatorsByName("TestProvider2"));

  EXPECT_TRUE((list = info_.GetCellularOperatorsByName("TestProvider1")));
  EXPECT_EQ(list->size(), 1);
  EXPECT_EQ((*list)[0]->apn_list()[0]->apn(), "testprovider1apn");

  EXPECT_FALSE(info_.GetCellularOperatorsByName("TestProvider2"));

  EXPECT_TRUE((list = info_.GetCellularOperatorsByName("TestProviderTwo")));
  EXPECT_EQ(list->size(), 1);
  EXPECT_EQ((*list)[0]->apn_list()[0]->apn(), "testprovider2apn");
}

TEST_F(CellularOperatorInfoTest, GetOLPByMCCMNC) {
  EXPECT_TRUE(info_.Load(info_file_path_));

  const CellularService::OLP *olp = NULL;
  EXPECT_TRUE((olp = info_.GetOLPByMCCMNC("000001")));
  EXPECT_EQ("https://testurl", olp->GetURL());
  EXPECT_EQ("POST", olp->GetMethod());
  EXPECT_EQ("imei=${imei}&iccid=${iccid}", olp->GetPostData());

  EXPECT_TRUE((olp = info_.GetOLPByMCCMNC("000002")));
  EXPECT_EQ("https://testurl", olp->GetURL());
  EXPECT_EQ("POST", olp->GetMethod());
  EXPECT_EQ("imei=${imei}&iccid=${iccid}", olp->GetPostData());

  EXPECT_TRUE((olp = info_.GetOLPByMCCMNC("100001")));
  EXPECT_EQ("https://testurl3", olp->GetURL());
  EXPECT_EQ("", olp->GetMethod());
  EXPECT_EQ("", olp->GetPostData());

  EXPECT_TRUE((olp = info_.GetOLPByMCCMNC("100002")));
  EXPECT_EQ("https://testurl2", olp->GetURL());
  EXPECT_EQ("", olp->GetMethod());
  EXPECT_EQ("", olp->GetPostData());

  EXPECT_FALSE(info_.GetOLPByMCCMNC("000003"));
  EXPECT_FALSE(info_.GetOLPByMCCMNC("000004"));
}

TEST_F(CellularOperatorInfoTest, GetOLPBySID) {
  EXPECT_TRUE(info_.Load(info_file_path_));

  const CellularService::OLP *olp = NULL;
  EXPECT_TRUE((olp = info_.GetOLPBySID("1")));
  EXPECT_EQ("https://testurl", olp->GetURL());
  EXPECT_EQ("POST", olp->GetMethod());
  EXPECT_EQ("imei=${imei}&iccid=${iccid}", olp->GetPostData());

  EXPECT_TRUE((olp = info_.GetOLPBySID("2")));
  EXPECT_EQ("https://testurl", olp->GetURL());
  EXPECT_EQ("POST", olp->GetMethod());
  EXPECT_EQ("imei=${imei}&iccid=${iccid}", olp->GetPostData());

  EXPECT_TRUE((olp = info_.GetOLPBySID("3")));
  EXPECT_EQ("https://testurl", olp->GetURL());
  EXPECT_EQ("POST", olp->GetMethod());
  EXPECT_EQ("imei=${imei}&iccid=${iccid}", olp->GetPostData());

  EXPECT_TRUE((olp = info_.GetOLPBySID("4")));
  EXPECT_EQ("https://testurl2", olp->GetURL());
  EXPECT_EQ("", olp->GetMethod());
  EXPECT_EQ("", olp->GetPostData());

  EXPECT_TRUE((olp = info_.GetOLPBySID("5")));
  EXPECT_EQ("https://testurl3", olp->GetURL());
  EXPECT_EQ("", olp->GetMethod());
  EXPECT_EQ("", olp->GetPostData());

  EXPECT_FALSE(info_.GetOLPBySID("6"));
  EXPECT_FALSE(info_.GetOLPBySID("7"));
}

TEST_F(CellularOperatorInfoTest, HandleProvider) {
  CellularOperatorInfo::ParserState state;
  EXPECT_FALSE(info_.HandleProvider(&state, "0,0,0"));
  EXPECT_FALSE(state.provider);
  EXPECT_EQ(info_.operators_.size(), 0);

  EXPECT_TRUE(info_.HandleProvider(&state, "0,0,0,0"));
  EXPECT_TRUE(state.provider);
  EXPECT_EQ(info_.operators_.size(), 1);
  EXPECT_FALSE(state.provider->is_primary());
  EXPECT_FALSE(state.provider->requires_roaming());

  EXPECT_TRUE(info_.HandleProvider(&state, "1,1,0,1"));
  EXPECT_EQ(info_.operators_.size(), 2);
  EXPECT_EQ(state.provider, info_.operators_[1]);
  EXPECT_FALSE(state.provider->is_primary());
  EXPECT_TRUE(state.provider->requires_roaming());
}

TEST_F(CellularOperatorInfoTest, HandleMCCMNC) {
  CellularOperatorInfo::ParserState state;
  EXPECT_FALSE(info_.HandleMCCMNC(&state, "1,1"));

  EXPECT_TRUE(info_.HandleProvider(&state, "1,1,0,0"));
  EXPECT_TRUE(state.provider);

  EXPECT_FALSE(info_.HandleMCCMNC(&state, ""));
  EXPECT_TRUE(state.provider->mccmnc_list().empty());
  EXPECT_TRUE(info_.mccmnc_to_operator_.empty());

  EXPECT_FALSE(info_.HandleMCCMNC(&state, "000001,0,000002"));
  EXPECT_TRUE(state.provider->mccmnc_list().empty());
  EXPECT_TRUE(info_.mccmnc_to_operator_.empty());

  EXPECT_TRUE(info_.HandleMCCMNC(&state, "000001,0,000002,3"));
  EXPECT_EQ(state.provider->mccmnc_list().size(), 2);
  EXPECT_EQ(info_.mccmnc_to_operator_.size(), 2);
  EXPECT_EQ(info_.mccmnc_to_operator_["000001"], state.provider);
  EXPECT_EQ(info_.mccmnc_to_operator_["000002"], state.provider);
  EXPECT_EQ(state.provider->mccmnc_list()[0], "000001");
  EXPECT_EQ(state.provider->mccmnc_list()[1], "000002");
  EXPECT_EQ(state.provider->mccmnc_to_olp_idx_.size(), 2);
  EXPECT_EQ(state.provider->mccmnc_to_olp_idx_["000001"], 0);
  EXPECT_EQ(state.provider->mccmnc_to_olp_idx_["000002"], 3);
}

TEST_F(CellularOperatorInfoTest, HandleName) {
  CellularOperatorInfo::ParserState state;
  EXPECT_FALSE(info_.HandleName(&state, ","));

  EXPECT_TRUE(info_.HandleProvider(&state, "1,1,0,0"));
  EXPECT_TRUE(state.provider);
  EXPECT_TRUE(state.provider->name_list().empty());

  EXPECT_FALSE(info_.HandleName(&state, ",,"));
  EXPECT_TRUE(state.provider->name_list().empty());

  EXPECT_TRUE(info_.HandleName(&state, "en,Test Name"));
  EXPECT_EQ(state.provider->name_list().size(), 1);

  const CellularOperatorInfo::LocalizedName &name =
      state.provider->name_list()[0];
  EXPECT_EQ(name.language, "en");
  EXPECT_EQ(name.name, "Test Name");

  EXPECT_TRUE(info_.HandleName(&state, ",Other Test Name"));
  EXPECT_EQ(state.provider->name_list().size(), 2);

  const CellularOperatorInfo::LocalizedName &name2 =
      state.provider->name_list()[1];
  EXPECT_EQ(name2.language, "");
  EXPECT_EQ(name2.name, "Other Test Name");
}

TEST_F(CellularOperatorInfoTest, HandleAPN) {
  CellularOperatorInfo::ParserState state;
  EXPECT_FALSE(info_.HandleAPN(&state, ",,,"));

  EXPECT_TRUE(info_.HandleProvider(&state, "1,1,0,0"));
  EXPECT_TRUE(state.provider);
  EXPECT_TRUE(state.provider->apn_list().empty());

  EXPECT_FALSE(info_.HandleAPN(&state, ","));
  EXPECT_TRUE(state.provider->apn_list().empty());

  EXPECT_FALSE(state.parsing_apn);

  EXPECT_TRUE(info_.HandleAPN(&state, "0,testapn,testusername,testpassword"));
  EXPECT_EQ(state.provider->apn_list().size(), 1);
  EXPECT_TRUE(state.parsing_apn);

  const CellularOperatorInfo::MobileAPN *apn = state.provider->apn_list()[0];
  EXPECT_EQ(apn->apn(), "testapn");
  EXPECT_EQ(apn->username(), "testusername");
  EXPECT_EQ(apn->password(), "testpassword");
}

TEST_F(CellularOperatorInfoTest, HandleAPNName) {
  CellularOperatorInfo::ParserState state;
  EXPECT_FALSE(info_.HandleAPNName(&state, ","));
  state.parsing_apn = true;
  EXPECT_FALSE(info_.HandleAPNName(&state, ","));
  state.parsing_apn = false;
  state.apn = (CellularOperatorInfo::MobileAPN *)1;
  EXPECT_FALSE(info_.HandleAPNName(&state, ","));

  EXPECT_TRUE(info_.HandleProvider(&state, "1,1,0,0"));
  EXPECT_TRUE(state.provider);
  EXPECT_TRUE(info_.HandleAPN(&state, ",,,"));
  EXPECT_TRUE(state.parsing_apn && state.apn);

  const CellularOperatorInfo::MobileAPN *apn = state.provider->apn_list()[0];

  EXPECT_FALSE(info_.HandleAPNName(&state, ",,"));
  EXPECT_EQ(apn->name_list().size(), 0);

  EXPECT_TRUE(info_.HandleAPNName(&state, "en,APN Name"));
  EXPECT_EQ(apn->name_list().size(), 1);

  const CellularOperatorInfo::LocalizedName &name = apn->name_list()[0];
  EXPECT_EQ(name.language, "en");
  EXPECT_EQ(name.name, "APN Name");

  EXPECT_TRUE(info_.HandleAPNName(&state, ",Other APN Name"));
  EXPECT_EQ(apn->name_list().size(), 2);

  const CellularOperatorInfo::LocalizedName &name2 = apn->name_list()[1];
  EXPECT_EQ(name2.language, "");
  EXPECT_EQ(name2.name, "Other APN Name");
}

TEST_F(CellularOperatorInfoTest, HandleSID) {
 CellularOperatorInfo::ParserState state;
 EXPECT_FALSE(info_.HandleSID(&state, "1,0"));

 EXPECT_TRUE(info_.HandleProvider(&state, "1,1,0,0"));
 EXPECT_TRUE(state.provider);

 EXPECT_FALSE(info_.HandleSID(&state, ""));
 EXPECT_TRUE(state.provider->sid_list().empty());
 EXPECT_TRUE(info_.sid_to_operator_.empty());

 EXPECT_FALSE(info_.HandleSID(&state, "1,2,3"));
 EXPECT_TRUE(state.provider->sid_list().empty());
 EXPECT_TRUE(info_.sid_to_operator_.empty());

 EXPECT_TRUE(info_.HandleSID(&state, "1,5,2,3,3,0"));
 EXPECT_EQ(state.provider->sid_list().size(), 3);
 EXPECT_EQ(info_.sid_to_operator_.size(), 3);
 EXPECT_EQ(info_.sid_to_operator_["1"], state.provider);
 EXPECT_EQ(info_.sid_to_operator_["2"], state.provider);
 EXPECT_EQ(info_.sid_to_operator_["3"], state.provider);
 EXPECT_EQ(state.provider->sid_list()[0], "1");
 EXPECT_EQ(state.provider->sid_list()[1], "2");
 EXPECT_EQ(state.provider->sid_list()[2], "3");
 EXPECT_EQ(state.provider->sid_to_olp_idx_.size(), 3);
 EXPECT_EQ(state.provider->sid_to_olp_idx_["1"], 5);
 EXPECT_EQ(state.provider->sid_to_olp_idx_["2"], 3);
 EXPECT_EQ(state.provider->sid_to_olp_idx_["3"], 0);
}

TEST_F(CellularOperatorInfoTest, HandleIdentifier) {
  CellularOperatorInfo::ParserState state;
  EXPECT_FALSE(info_.HandleIdentifier(&state, "testidentifier"));

  EXPECT_TRUE(info_.HandleProvider(&state, "1,1,0,0"));
  EXPECT_TRUE(state.provider);
  EXPECT_EQ("", state.provider->identifier());

  EXPECT_TRUE(info_.HandleIdentifier(&state, "testidentifier0"));
  EXPECT_EQ("testidentifier0", state.provider->identifier());
  EXPECT_TRUE(info_.HandleIdentifier(&state, "testidentifier1"));
  EXPECT_EQ("testidentifier1", state.provider->identifier());
  EXPECT_TRUE(info_.HandleIdentifier(&state, "testidentifier2"));
  EXPECT_EQ("testidentifier2", state.provider->identifier());
}

TEST_F(CellularOperatorInfoTest, HandleOLP) {
  CellularOperatorInfo::ParserState state;
  EXPECT_FALSE(info_.HandleOLP(&state, ",,"));

  EXPECT_TRUE(info_.HandleProvider(&state, "1,1,0,0"));
  EXPECT_TRUE(state.provider);
  EXPECT_EQ(0, state.provider->olp_list().size());

  EXPECT_FALSE(info_.HandleOLP(&state, ","));
  EXPECT_EQ(0, state.provider->olp_list().size());

  EXPECT_TRUE(info_.HandleOLP(&state, ",,"));
  EXPECT_EQ(1, state.provider->olp_list().size());
  EXPECT_EQ(state.provider->olp_list()[0]->GetURL(), "");
  EXPECT_EQ(state.provider->olp_list()[0]->GetMethod(), "");
  EXPECT_EQ(state.provider->olp_list()[0]->GetPostData(), "");

  EXPECT_TRUE(info_.HandleOLP(&state, "a,b,c"));
  EXPECT_EQ(2, state.provider->olp_list().size());
  EXPECT_EQ(state.provider->olp_list()[0]->GetURL(), "");
  EXPECT_EQ(state.provider->olp_list()[0]->GetMethod(), "");
  EXPECT_EQ(state.provider->olp_list()[0]->GetPostData(), "");
  EXPECT_EQ(state.provider->olp_list()[1]->GetMethod(), "a");
  EXPECT_EQ(state.provider->olp_list()[1]->GetURL(), "b");
  EXPECT_EQ(state.provider->olp_list()[1]->GetPostData(), "c");
}

TEST_F(CellularOperatorInfoTest, ParseNameLine) {
  CellularOperatorInfo::LocalizedName name;
  EXPECT_FALSE(info_.ParseNameLine(",,", &name));
  EXPECT_FALSE(info_.ParseNameLine("", &name));
  EXPECT_TRUE(info_.ParseNameLine("a,b", &name));
  EXPECT_EQ(name.language, "a");
  EXPECT_EQ(name.name, "b");
}

TEST_F(CellularOperatorInfoTest, ParseKeyValue) {
  string line = "key:value";
  string key, value;
  EXPECT_TRUE(CellularOperatorInfo::ParseKeyValue(line, ':', &key, &value));
  EXPECT_EQ("key", key);
  EXPECT_EQ("value", value);

  line = "key:::::";
  EXPECT_TRUE(CellularOperatorInfo::ParseKeyValue(line, ':', &key, &value));
  EXPECT_EQ("key", key);
  EXPECT_EQ("::::", value);

  line = ":";
  EXPECT_TRUE(CellularOperatorInfo::ParseKeyValue(line, ':', &key, &value));
  EXPECT_EQ("", key);
  EXPECT_EQ("", value);

  line = ":value";
  EXPECT_TRUE(CellularOperatorInfo::ParseKeyValue(line, ':', &key, &value));
  EXPECT_EQ("", key);
  EXPECT_EQ("value", value);

  line = "";
  EXPECT_FALSE(CellularOperatorInfo::ParseKeyValue(line, ':', &key, &value));
}

}  // namespace shill