cellular_service_unittest.cc

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

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

#include "shill/cellular_capability.h"
#include "shill/cellular_capability_cdma.h"
#include "shill/mock_adaptors.h"
#include "shill/mock_cellular.h"
#include "shill/mock_manager.h"
#include "shill/mock_metrics.h"
#include "shill/mock_modem_info.h"
#include "shill/mock_profile.h"
#include "shill/mock_store.h"
#include "shill/nice_mock_control.h"
#include "shill/proxy_factory.h"
#include "shill/service_property_change_test.h"

using std::string;
using testing::_;
using testing::InSequence;
using testing::Mock;
using testing::NiceMock;
using testing::Return;

namespace shill {

class CellularServiceTest : public testing::Test {
 public:
  CellularServiceTest()
      : modem_info_(NULL, &dispatcher_, NULL, NULL, NULL),
        device_(new MockCellular(&modem_info_,
                                 "usb0",
                                 kAddress,
                                 3,
                                 Cellular::kTypeCDMA,
                                 "",
                                 "",
                                 "",
                                 ProxyFactory::GetInstance())),
        service_(new CellularService(&modem_info_, device_)),
        adaptor_(NULL) {}

  virtual ~CellularServiceTest() {
    adaptor_ = NULL;
  }

  virtual void SetUp() {
    adaptor_ =
        dynamic_cast<ServiceMockAdaptor *>(service_->adaptor());
  }

  CellularCapabilityCDMA *GetCapabilityCDMA() {
    return dynamic_cast<CellularCapabilityCDMA *>(device_->capability_.get());
  }

 protected:
  static const char kAddress[];

  string GetFriendlyName() const { return service_->friendly_name(); }

  EventDispatcher dispatcher_;
  MockModemInfo modem_info_;
  scoped_refptr<MockCellular> device_;
  CellularServiceRefPtr service_;
  ServiceMockAdaptor *adaptor_;  // Owned by |service_|.
};

const char CellularServiceTest::kAddress[] = "000102030405";

TEST_F(CellularServiceTest, Constructor) {
  EXPECT_TRUE(service_->connectable());
}

TEST_F(CellularServiceTest, SetActivationState) {
  {
    InSequence call_sequence;
    EXPECT_CALL(*adaptor_, EmitStringChanged(
        flimflam::kActivationStateProperty,
        flimflam::kActivationStateNotActivated));
    EXPECT_CALL(*adaptor_, EmitBoolChanged(
        flimflam::kConnectableProperty, false));
    EXPECT_CALL(*adaptor_, EmitStringChanged(
        flimflam::kActivationStateProperty,
        flimflam::kActivationStateActivating));
    EXPECT_CALL(*adaptor_, EmitBoolChanged(
        flimflam::kConnectableProperty, true));
    EXPECT_CALL(*adaptor_, EmitStringChanged(
        flimflam::kActivationStateProperty,
        flimflam::kActivationStatePartiallyActivated));
    EXPECT_CALL(*adaptor_, EmitStringChanged(
        flimflam::kActivationStateProperty,
        flimflam::kActivationStateActivated));
    EXPECT_CALL(*adaptor_, EmitStringChanged(
        flimflam::kActivationStateProperty,
        flimflam::kActivationStateNotActivated));
    EXPECT_CALL(*adaptor_, EmitBoolChanged(
        flimflam::kConnectableProperty, false));
  }
  EXPECT_CALL(*modem_info_.mock_manager(), HasService(_))
      .WillRepeatedly(Return(false));

  EXPECT_TRUE(service_->activation_state().empty());
  EXPECT_TRUE(service_->connectable());

  service_->SetActivationState(flimflam::kActivationStateNotActivated);
  EXPECT_EQ(flimflam::kActivationStateNotActivated,
            service_->activation_state());
  EXPECT_FALSE(service_->connectable());

  service_->SetActivationState(flimflam::kActivationStateActivating);
  EXPECT_EQ(flimflam::kActivationStateActivating, service_->activation_state());
  EXPECT_TRUE(service_->connectable());

  service_->SetActivationState(flimflam::kActivationStatePartiallyActivated);
  EXPECT_EQ(flimflam::kActivationStatePartiallyActivated,
            service_->activation_state());
  EXPECT_TRUE(service_->connectable());

  service_->SetActivationState(flimflam::kActivationStateActivated);
  EXPECT_EQ(flimflam::kActivationStateActivated, service_->activation_state());
  EXPECT_TRUE(service_->connectable());

  service_->SetActivationState(flimflam::kActivationStateNotActivated);
  EXPECT_EQ(flimflam::kActivationStateNotActivated,
            service_->activation_state());
  EXPECT_FALSE(service_->connectable());
}

TEST_F(CellularServiceTest, SetNetworkTechnology) {
  EXPECT_CALL(*adaptor_, EmitStringChanged(flimflam::kNetworkTechnologyProperty,
                                           flimflam::kNetworkTechnologyUmts));
  EXPECT_TRUE(service_->network_technology().empty());
  service_->SetNetworkTechnology(flimflam::kNetworkTechnologyUmts);
  EXPECT_EQ(flimflam::kNetworkTechnologyUmts, service_->network_technology());
  service_->SetNetworkTechnology(flimflam::kNetworkTechnologyUmts);
}

TEST_F(CellularServiceTest, SetRoamingState) {
  EXPECT_CALL(*adaptor_, EmitStringChanged(flimflam::kRoamingStateProperty,
                                           flimflam::kRoamingStateHome));
  EXPECT_TRUE(service_->roaming_state().empty());
  service_->SetRoamingState(flimflam::kRoamingStateHome);
  EXPECT_EQ(flimflam::kRoamingStateHome, service_->roaming_state());
  service_->SetRoamingState(flimflam::kRoamingStateHome);
}

TEST_F(CellularServiceTest, FriendlyName) {
  static const char kCarrier[] = "Cellular Carrier";
  GetCapabilityCDMA()->carrier_ = kCarrier;
  service_ = new CellularService(&modem_info_, device_);
  EXPECT_EQ(kCarrier, GetFriendlyName());
}

TEST_F(CellularServiceTest, SetStorageIdentifier) {
  EXPECT_EQ(string(flimflam::kTypeCellular) + "_" +
            kAddress + "_" + GetFriendlyName(),
            service_->GetStorageIdentifier());
  service_->SetStorageIdentifier("a b c");
  EXPECT_EQ("a_b_c", service_->GetStorageIdentifier());
}

TEST_F(CellularServiceTest, SetServingOperator) {
  EXPECT_CALL(*adaptor_,
              EmitStringmapChanged(flimflam::kServingOperatorProperty, _));
  static const char kCode[] = "123456";
  static const char kName[] = "Some Cellular Operator";
  Cellular::Operator oper;
  service_->SetServingOperator(oper);
  oper.SetCode(kCode);
  oper.SetName(kName);
  service_->SetServingOperator(oper);
  EXPECT_EQ(kCode, service_->serving_operator().GetCode());
  EXPECT_EQ(kName, service_->serving_operator().GetName());
  service_->SetServingOperator(oper);
}

TEST_F(CellularServiceTest, SetOLP) {
  EXPECT_CALL(*adaptor_,
              EmitStringmapChanged(flimflam::kPaymentPortalProperty, _));
  static const char kURL[] = "payment.url";
  static const char kMethod[] = "GET";
  CellularService::OLP olp;
  service_->SetOLP(olp);
  olp.SetURL(kURL);
  olp.SetMethod(kMethod);
  service_->SetOLP(olp);
  EXPECT_EQ(kURL, service_->olp().GetURL());
  EXPECT_EQ(kMethod, service_->olp().GetMethod());
  service_->SetOLP(olp);
}

TEST_F(CellularServiceTest, SetUsageURL) {
  static const char kUsageURL[] = "usage.url";
  EXPECT_CALL(*adaptor_, EmitStringChanged(flimflam::kUsageURLProperty,
                                           kUsageURL));
  EXPECT_TRUE(service_->usage_url().empty());
  service_->SetUsageURL(kUsageURL);
  EXPECT_EQ(kUsageURL, service_->usage_url());
  service_->SetUsageURL(kUsageURL);
}

TEST_F(CellularServiceTest, SetApn) {
  static const char kApn[] = "TheAPN";
  static const char kUsername[] = "commander.data";
  ProfileRefPtr profile(new NiceMock<MockProfile>(
      modem_info_.control_interface(), modem_info_.metrics(),
      modem_info_.manager()));
  service_->set_profile(profile);
  Error error;
  Stringmap testapn;
  testapn[flimflam::kApnProperty] = kApn;
  testapn[flimflam::kApnUsernameProperty] = kUsername;
  {
    InSequence seq;
    EXPECT_CALL(*adaptor_,
                EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
                                     _));
    EXPECT_CALL(*adaptor_,
                EmitStringmapChanged(flimflam::kCellularApnProperty, _));
  }
  service_->SetApn(testapn, &error);
  EXPECT_TRUE(error.IsSuccess());
  Stringmap resultapn = service_->GetApn(&error);
  EXPECT_TRUE(error.IsSuccess());
  EXPECT_EQ(2, resultapn.size());
  Stringmap::const_iterator it = resultapn.find(flimflam::kApnProperty);
  EXPECT_TRUE(it != resultapn.end() && it->second == kApn);
  it = resultapn.find(flimflam::kApnUsernameProperty);
  EXPECT_TRUE(it != resultapn.end() && it->second == kUsername);
  EXPECT_FALSE(service_->GetUserSpecifiedApn() == NULL);
}

TEST_F(CellularServiceTest, ClearApn) {
  static const char kApn[] = "TheAPN";
  static const char kUsername[] = "commander.data";
  ProfileRefPtr profile(new NiceMock<MockProfile>(
      modem_info_.control_interface(), modem_info_.metrics(),
      modem_info_.manager()));
  service_->set_profile(profile);
  Error error;
  // Set up an APN to make sure that it later gets cleared.
  Stringmap testapn;
  testapn[flimflam::kApnProperty] = kApn;
  testapn[flimflam::kApnUsernameProperty] = kUsername;
  {
    InSequence seq;
    EXPECT_CALL(*adaptor_,
                EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
                                     _));
    EXPECT_CALL(*adaptor_,
                EmitStringmapChanged(flimflam::kCellularApnProperty, _));
  }
  service_->SetApn(testapn, &error);
  Stringmap resultapn = service_->GetApn(&error);
  ASSERT_TRUE(error.IsSuccess());
  ASSERT_EQ(2, service_->GetApn(&error).size());

  Stringmap emptyapn;
  EXPECT_CALL(*adaptor_,
              EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
                                   _)).Times(0);
  EXPECT_CALL(*adaptor_,
              EmitStringmapChanged(flimflam::kCellularApnProperty, _)).Times(1);
  service_->SetApn(emptyapn, &error);
  EXPECT_TRUE(error.IsSuccess());
  resultapn = service_->GetApn(&error);
  EXPECT_TRUE(resultapn.empty());
  EXPECT_TRUE(service_->GetUserSpecifiedApn() == NULL);
}

TEST_F(CellularServiceTest, LastGoodApn) {
  static const char kApn[] = "TheAPN";
  static const char kUsername[] = "commander.data";
  ProfileRefPtr profile(new NiceMock<MockProfile>(
      modem_info_.control_interface(), modem_info_.metrics(),
      modem_info_.manager()));
  service_->set_profile(profile);
  Stringmap testapn;
  testapn[flimflam::kApnProperty] = kApn;
  testapn[flimflam::kApnUsernameProperty] = kUsername;
  EXPECT_CALL(*adaptor_,
              EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty, _));
  service_->SetLastGoodApn(testapn);
  Stringmap *resultapn = service_->GetLastGoodApn();
  EXPECT_FALSE(resultapn == NULL);
  EXPECT_EQ(2, resultapn->size());
  Stringmap::const_iterator it = resultapn->find(flimflam::kApnProperty);
  EXPECT_TRUE(it != resultapn->end() && it->second == kApn);
  it = resultapn->find(flimflam::kApnUsernameProperty);
  EXPECT_TRUE(it != resultapn->end() && it->second == kUsername);
  // Now set the user-specified APN, and check that LastGoodApn got
  // cleared.
  Stringmap userapn;
  userapn[flimflam::kApnProperty] = kApn;
  userapn[flimflam::kApnUsernameProperty] = kUsername;
  {
    InSequence seq;
    EXPECT_CALL(*adaptor_,
                EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
                                     _));
    EXPECT_CALL(*adaptor_,
                EmitStringmapChanged(flimflam::kCellularApnProperty, _));
  }
  Error error;
  service_->SetApn(userapn, &error);
  EXPECT_TRUE(service_->GetLastGoodApn() == NULL);
}

TEST_F(CellularServiceTest, IsAutoConnectable) {
  const char *reason = NULL;

  // Auto-connect should be suppressed if the device is not running.
  device_->running_ = false;
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));
  EXPECT_STREQ(CellularService::kAutoConnDeviceDisabled, reason);

  device_->running_ = true;

  // If we're waiting on a disconnect before an activation, don't auto-connect.
  GetCapabilityCDMA()->activation_starting_ = true;
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));

  // If we're waiting on an activation, also don't auto-connect.
  GetCapabilityCDMA()->activation_starting_ = false;
  GetCapabilityCDMA()->activation_state_ =
      MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));

  GetCapabilityCDMA()->activation_state_ =
      MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;

  // Auto-connect should be suppressed if the we're undergoing an
  // out-of-credits detection.
  service_->out_of_credits_detection_in_progress_ = true;
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));
  EXPECT_STREQ(CellularService::kAutoConnOutOfCreditsDetectionInProgress,
               reason);

  // Auto-connect should be suppressed if we're out of credits.
  service_->out_of_credits_detection_in_progress_ = false;
  service_->out_of_credits_ = true;
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));
  EXPECT_STREQ(CellularService::kAutoConnOutOfCredits, reason);

  service_->out_of_credits_ = false;

  // But other activation states are fine.
  GetCapabilityCDMA()->activation_state_ =
      MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
  EXPECT_TRUE(service_->IsAutoConnectable(&reason));
  GetCapabilityCDMA()->activation_state_ =
      MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
  EXPECT_TRUE(service_->IsAutoConnectable(&reason));
  GetCapabilityCDMA()->activation_state_ =
      MM_MODEM_CDMA_ACTIVATION_STATE_PARTIALLY_ACTIVATED;
  EXPECT_TRUE(service_->IsAutoConnectable(&reason));

  // The following test cases are copied from ServiceTest.IsAutoConnectable

  service_->SetConnectable(true);
  EXPECT_TRUE(service_->IsAutoConnectable(&reason));

  // We should not auto-connect to a Service that a user has
  // deliberately disconnected.
  Error error;
  service_->UserInitiatedDisconnect(&error);
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));
  EXPECT_STREQ(Service::kAutoConnExplicitDisconnect, reason);

  // But if the Service is reloaded, it is eligible for auto-connect
  // again.
  NiceMock<MockStore> storage;
  EXPECT_CALL(storage, ContainsGroup(service_->GetStorageIdentifier()))
      .WillOnce(Return(true));
  EXPECT_TRUE(service_->Load(&storage));
  EXPECT_TRUE(service_->IsAutoConnectable(&reason));

  // A non-user initiated Disconnect doesn't change anything.
  service_->Disconnect(&error);
  EXPECT_TRUE(service_->IsAutoConnectable(&reason));

  // A resume also re-enables auto-connect.
  service_->UserInitiatedDisconnect(&error);
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));
  service_->OnAfterResume();
  EXPECT_TRUE(service_->IsAutoConnectable(&reason));

  service_->SetState(Service::kStateConnected);
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));
  EXPECT_STREQ(Service::kAutoConnConnected, reason);

  service_->SetState(Service::kStateAssociating);
  EXPECT_FALSE(service_->IsAutoConnectable(&reason));
  EXPECT_STREQ(Service::kAutoConnConnecting, reason);
}

TEST_F(CellularServiceTest, OutOfCreditsDetected) {
  service_->set_enforce_out_of_credits_detection(true);
  EXPECT_CALL(*device_, Connect(_)).Times(3);
  Error error;
  service_->Connect(&error, "in test");
  service_->SetState(Service::kStateAssociating);
  service_->SetState(Service::kStateFailure);
  EXPECT_TRUE(service_->out_of_credits_detection_in_progress_);
  dispatcher_.DispatchPendingEvents();
  service_->SetState(Service::kStateConfiguring);
  service_->SetState(Service::kStateIdle);
  EXPECT_TRUE(service_->out_of_credits_detection_in_progress_);
  dispatcher_.DispatchPendingEvents();
  service_->SetState(Service::kStateConnected);
  service_->SetState(Service::kStateIdle);
  EXPECT_TRUE(service_->out_of_credits_);
  EXPECT_FALSE(service_->out_of_credits_detection_in_progress_);
}

TEST_F(CellularServiceTest, OutOfCreditsDetectionNotSkippedAfterSlowResume) {
  service_->set_enforce_out_of_credits_detection(true);
  service_->OnAfterResume();
  service_->resume_start_time_ =
      base::Time::Now() -
      base::TimeDelta::FromSeconds(
          CellularService::kOutOfCreditsResumeIgnoreSeconds + 1);
  EXPECT_CALL(*device_, Connect(_)).Times(3);
  Error error;
  service_->Connect(&error, "in test");
  service_->SetState(Service::kStateAssociating);
  service_->SetState(Service::kStateFailure);
  EXPECT_TRUE(service_->out_of_credits_detection_in_progress_);
  dispatcher_.DispatchPendingEvents();
  service_->SetState(Service::kStateConfiguring);
  service_->SetState(Service::kStateIdle);
  EXPECT_TRUE(service_->out_of_credits_detection_in_progress_);
  dispatcher_.DispatchPendingEvents();
  service_->SetState(Service::kStateConnected);
  service_->SetState(Service::kStateIdle);
  EXPECT_TRUE(service_->out_of_credits_);
  EXPECT_FALSE(service_->out_of_credits_detection_in_progress_);
}

TEST_F(CellularServiceTest, OutOfCreditsDetectionSkippedAfterResume) {
  service_->set_enforce_out_of_credits_detection(true);
  service_->OnAfterResume();
  EXPECT_CALL(*device_, Connect(_));
  Error error;
  service_->Connect(&error, "in test");
  service_->SetState(Service::kStateConnected);
  service_->SetState(Service::kStateIdle);
  EXPECT_FALSE(service_->out_of_credits_);
  EXPECT_FALSE(service_->out_of_credits_detection_in_progress_);
  // There should not be any pending connect requests but dispatch pending
  // events anyway to be sure.
  dispatcher_.DispatchPendingEvents();
}

TEST_F(CellularServiceTest, OutOfCreditsDetectionSkippedAlreadyOutOfCredits) {
  service_->set_enforce_out_of_credits_detection(true);
  EXPECT_CALL(*device_, Connect(_));
  Error error;
  service_->Connect(&error, "in test");
  service_->out_of_credits_ = true;
  service_->SetState(Service::kStateConnected);
  service_->SetState(Service::kStateIdle);
  EXPECT_FALSE(service_->out_of_credits_detection_in_progress_);
  // There should not be any pending connect requests but dispatch pending
  // events anyway to be sure.
  dispatcher_.DispatchPendingEvents();
}

TEST_F(CellularServiceTest, OutOfCreditsDetectionSkippedExplicitDisconnect) {
  service_->set_enforce_out_of_credits_detection(true);
  EXPECT_CALL(*device_, Connect(_));
  Error error;
  service_->Connect(&error, "in test");
  service_->SetState(Service::kStateConnected);
  service_->UserInitiatedDisconnect(&error);
  service_->SetState(Service::kStateIdle);
  EXPECT_FALSE(service_->out_of_credits_);
  EXPECT_FALSE(service_->out_of_credits_detection_in_progress_);
  // There should not be any pending connect requests but dispatch pending
  // events anyway to be sure.
  dispatcher_.DispatchPendingEvents();
}

TEST_F(CellularServiceTest, OutOfCreditsNotDetectedConnectionNotDropped) {
  service_->set_enforce_out_of_credits_detection(true);
  EXPECT_CALL(*device_, Connect(_));
  Error error;
  service_->Connect(&error, "in test");
  service_->SetState(Service::kStateAssociating);
  service_->SetState(Service::kStateConfiguring);
  service_->SetState(Service::kStateConnected);
  EXPECT_FALSE(service_->out_of_credits_);
  EXPECT_FALSE(service_->out_of_credits_detection_in_progress_);
  // There should not be any pending connect requests but dispatch pending
  // events anyway to be sure.
  dispatcher_.DispatchPendingEvents();
}

TEST_F(CellularServiceTest, OutOfCreditsNotDetectedIntermittentNetwork) {
  service_->set_enforce_out_of_credits_detection(true);
  EXPECT_CALL(*device_, Connect(_));
  Error error;
  service_->Connect(&error, "in test");
  service_->SetState(Service::kStateConnected);
  service_->connect_start_time_ =
      base::Time::Now() -
      base::TimeDelta::FromSeconds(
          CellularService::kOutOfCreditsConnectionDropSeconds + 1);
  service_->SetState(Service::kStateIdle);
  EXPECT_FALSE(service_->out_of_credits_);
  EXPECT_FALSE(service_->out_of_credits_detection_in_progress_);
  // There should not be any pending connect requests but dispatch pending
  // events anyway to be sure.
  dispatcher_.DispatchPendingEvents();
}

TEST_F(CellularServiceTest, OutOfCreditsNotEnforced) {
  EXPECT_CALL(*device_, Connect(_));
  Error error;
  service_->Connect(&error, "in test");
  service_->SetState(Service::kStateConnected);
  service_->SetState(Service::kStateIdle);
  EXPECT_FALSE(service_->out_of_credits_);
  EXPECT_FALSE(service_->out_of_credits_detection_in_progress_);
  // There should not be any pending connect requests but dispatch pending
  // events anyway to be sure.
  dispatcher_.DispatchPendingEvents();
}

// Some of these tests duplicate signals tested above. However, it's
// convenient to have all the property change notifications documented
// (and tested) in one place.
TEST_F(CellularServiceTest, PropertyChanges) {
  TestCommonPropertyChanges(service_, adaptor_);
  TestAutoConnectPropertyChange(service_, adaptor_);

  bool activate_over_non_cellular =
      service_->activate_over_non_cellular_network();
  EXPECT_CALL(*adaptor_,
              EmitBoolChanged(kActivateOverNonCellularNetworkProperty, _));
  service_->SetActivateOverNonCellularNetwork(!activate_over_non_cellular);
  Mock::VerifyAndClearExpectations(adaptor_);

  EXPECT_NE(flimflam::kActivationStateNotActivated,
            service_->activation_state());
  EXPECT_CALL(*adaptor_,
              EmitStringChanged(flimflam::kActivationStateProperty, _));
  service_->SetActivationState(flimflam::kActivationStateNotActivated);
  Mock::VerifyAndClearExpectations(adaptor_);

  string network_technology = service_->network_technology();
  EXPECT_CALL(*adaptor_,
              EmitStringChanged(flimflam::kNetworkTechnologyProperty, _));
  service_->SetNetworkTechnology(network_technology + "and some new stuff");
  Mock::VerifyAndClearExpectations(adaptor_);

  bool out_of_credits = service_->out_of_credits();
  EXPECT_CALL(*adaptor_, EmitBoolChanged(kOutOfCreditsProperty, _));
  service_->SetOutOfCredits(!out_of_credits);
  Mock::VerifyAndClearExpectations(adaptor_);

  string roaming_state = service_->roaming_state();
  EXPECT_CALL(*adaptor_,
              EmitStringChanged(flimflam::kRoamingStateProperty, _));
  service_->SetRoamingState(roaming_state + "and some new stuff");
  Mock::VerifyAndClearExpectations(adaptor_);
}

// Custom property setters should return false, and make no changes, if
// the new value is the same as the old value.
TEST_F(CellularServiceTest, CustomSetterNoopChange) {
  // Test that we didn't break any setters provided by the base class.
  TestCustomSetterNoopChange(service_, modem_info_.mock_manager());

  // Test the new setter we added.
  // First set up our environment...
  static const char kApn[] = "TheAPN";
  static const char kUsername[] = "commander.data";
  Error error;
  Stringmap testapn;
  ProfileRefPtr profile(new NiceMock<MockProfile>(nullptr, nullptr, nullptr));
  service_->set_profile(profile);
  testapn[flimflam::kApnProperty] = kApn;
  testapn[flimflam::kApnUsernameProperty] = kUsername;
  // ... then set to a known value ...
  EXPECT_TRUE(service_->SetApn(testapn, &error));
  EXPECT_TRUE(error.IsSuccess());
  // ... then set to same value.
  EXPECT_FALSE(service_->SetApn(testapn, &error));
  EXPECT_TRUE(error.IsSuccess());
}

}  // namespace shill