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

 // 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/wimax.h"

 #include <string>

 #include <base/stringprintf.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include "shill/event_dispatcher.h"
 #include "shill/mock_manager.h"
 #include "shill/mock_metrics.h"
 #include "shill/mock_wimax_device_proxy.h"
 #include "shill/mock_wimax_provider.h"
 #include "shill/mock_wimax_service.h"
 #include "shill/nice_mock_control.h"
 #include "shill/proxy_factory.h"

 using base::Bind;
 using base::Unretained;
 using std::string;
 using testing::_;
 using testing::NiceMock;
 using testing::Return;

 namespace shill {

 namespace {

 const char kTestLinkName[] = "wm0";
 const char kTestAddress[] = "01:23:45:67:89:ab";
 const int kTestInterfaceIndex = 5;
 const char kTestPath[] = "/org/chromium/WiMaxManager/Device/6";

 }  // namespace

 class WiMaxTest : public testing::Test {
  public:
   WiMaxTest()
       : proxy_(new MockWiMaxDeviceProxy()),
         proxy_factory_(this),
         manager_(&control_, &dispatcher_, &metrics_, NULL),
         device_(new WiMax(&control_, &dispatcher_, &metrics_, &manager_,
                           kTestLinkName, kTestAddress, kTestInterfaceIndex,
                           kTestPath)) {}

   virtual ~WiMaxTest() {}

  protected:
   class TestProxyFactory : public ProxyFactory {
    public:
     explicit TestProxyFactory(WiMaxTest *test) : test_(test) {}

     virtual WiMaxDeviceProxyInterface *CreateWiMaxDeviceProxy(
         const string &/*path*/) {
       return test_->proxy_.release();
     }

    private:
     WiMaxTest *test_;

     DISALLOW_COPY_AND_ASSIGN(TestProxyFactory);
   };

   class Target {
    public:
     virtual ~Target() {}

     MOCK_METHOD1(EnabledStateChanged, void(const Error &error));
   };

   virtual void SetUp() {
     device_->proxy_factory_ = &proxy_factory_;
   }

   virtual void TearDown() {
     device_->SelectService(NULL);
     device_->pending_service_ = NULL;
     device_->proxy_factory_ = NULL;
   }

   scoped_ptr<MockWiMaxDeviceProxy> proxy_;
   TestProxyFactory proxy_factory_;
   NiceMockControl control_;
   EventDispatcher dispatcher_;
   NiceMock<MockMetrics> metrics_;
   MockManager manager_;
   WiMaxRefPtr device_;
 };

 TEST_F(WiMaxTest, Constructor) {
   EXPECT_EQ(kTestPath, device_->path());
   EXPECT_FALSE(device_->scanning());
 }

 TEST_F(WiMaxTest, StartStop) {
   EXPECT_FALSE(device_->proxy_.get());
   EXPECT_CALL(*proxy_, Enable(_, _, _));
   EXPECT_CALL(*proxy_, set_networks_changed_callback(_));
   EXPECT_CALL(*proxy_, set_status_changed_callback(_));
   EXPECT_CALL(*proxy_, Disable(_, _, _));
   device_->Start(NULL, EnabledStateChangedCallback());
   ASSERT_TRUE(device_->proxy_.get());

   scoped_refptr<MockWiMaxService> service(
       new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
   device_->pending_service_ = service;
   EXPECT_CALL(*service, SetState(Service::kStateIdle));
   device_->networks_.insert("path");
   MockWiMaxProvider provider;
   EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
   EXPECT_CALL(provider, OnNetworksChanged());
   device_->StartConnectTimeout();
   device_->Stop(NULL, EnabledStateChangedCallback());
   EXPECT_TRUE(device_->networks_.empty());
   EXPECT_FALSE(device_->IsConnectTimeoutStarted());
   EXPECT_FALSE(device_->pending_service_);
 }

 TEST_F(WiMaxTest, OnServiceStopped) {
   scoped_refptr<NiceMock<MockWiMaxService> > service0(
       new NiceMock<MockWiMaxService>(
           &control_,
           reinterpret_cast<EventDispatcher *>(NULL),
           &metrics_,
           &manager_));
   scoped_refptr<MockWiMaxService> service1(
       new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
   device_->SelectService(service0);
   device_->pending_service_ = service1;

   device_->OnServiceStopped(NULL);
   EXPECT_TRUE(device_->selected_service());
   EXPECT_TRUE(device_->pending_service_);

   device_->OnServiceStopped(service0);
   EXPECT_FALSE(device_->selected_service());
   EXPECT_TRUE(device_->pending_service_);

   device_->OnServiceStopped(service1);
   EXPECT_FALSE(device_->selected_service());
   EXPECT_FALSE(device_->pending_service_);
 }

 TEST_F(WiMaxTest, OnNetworksChanged) {
   MockWiMaxProvider provider;
   EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
   EXPECT_CALL(provider, OnNetworksChanged());
   device_->networks_.insert("foo");
   RpcIdentifiers networks;
   networks.push_back("bar");
   networks.push_back("zoo");
   networks.push_back("bar");
   device_->OnNetworksChanged(networks);
   EXPECT_EQ(2, device_->networks_.size());
   EXPECT_TRUE(ContainsKey(device_->networks_, "bar"));
   EXPECT_TRUE(ContainsKey(device_->networks_, "zoo"));
 }

 TEST_F(WiMaxTest, OnConnectComplete) {
   scoped_refptr<MockWiMaxService> service(
       new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
   device_->pending_service_ = service;
   EXPECT_CALL(*service, SetState(_)).Times(0);
   EXPECT_TRUE(device_->pending_service_);
   EXPECT_CALL(*service, SetState(Service::kStateFailure));
   device_->OnConnectComplete(Error(Error::kOperationFailed));
   EXPECT_FALSE(device_->pending_service_);
 }

 TEST_F(WiMaxTest, OnStatusChanged) {
   scoped_refptr<MockWiMaxService> service(
       new MockWiMaxService(&control_, NULL, &metrics_, &manager_));

   EXPECT_EQ(wimax_manager::kDeviceStatusUninitialized, device_->status_);
   device_->pending_service_ = service;
   EXPECT_CALL(*service, SetState(_)).Times(0);
   EXPECT_CALL(*service, ClearPassphrase()).Times(0);
   device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
   EXPECT_TRUE(device_->pending_service_);
   EXPECT_EQ(wimax_manager::kDeviceStatusScanning, device_->status_);

   device_->status_ = wimax_manager::kDeviceStatusConnecting;
   EXPECT_CALL(*service, SetState(Service::kStateFailure));
   EXPECT_CALL(*service, ClearPassphrase());
   device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
   EXPECT_FALSE(device_->pending_service_);

   device_->status_ = wimax_manager::kDeviceStatusConnecting;
   device_->SelectService(service);
   EXPECT_CALL(*service, SetState(Service::kStateFailure));
   EXPECT_CALL(*service, SetState(Service::kStateIdle));
   EXPECT_CALL(*service, ClearPassphrase()).Times(0);
   device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
   EXPECT_FALSE(device_->selected_service());

   device_->pending_service_ = service;
   device_->SelectService(service);
   EXPECT_CALL(*service, SetState(_)).Times(0);
   EXPECT_CALL(*service, ClearPassphrase()).Times(0);
   device_->OnStatusChanged(wimax_manager::kDeviceStatusConnecting);
   EXPECT_TRUE(device_->pending_service_);
   EXPECT_TRUE(device_->selected_service());
   EXPECT_EQ(wimax_manager::kDeviceStatusConnecting, device_->status_);

   EXPECT_CALL(*service, SetState(Service::kStateIdle));
   device_->SelectService(NULL);
 }

 TEST_F(WiMaxTest, DropService) {
   scoped_refptr<NiceMock<MockWiMaxService> > service0(
       new NiceMock<MockWiMaxService>(
           &control_,
           reinterpret_cast<EventDispatcher *>(NULL),
           &metrics_,
           &manager_));
   scoped_refptr<MockWiMaxService> service1(
       new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
   device_->SelectService(service0);
   device_->pending_service_ = service1;
   device_->StartConnectTimeout();

   EXPECT_CALL(*service0, SetState(Service::kStateIdle)).Times(2);
   EXPECT_CALL(*service1, SetState(Service::kStateIdle));
   device_->DropService(Service::kStateIdle);
   EXPECT_FALSE(device_->selected_service());
   EXPECT_FALSE(device_->pending_service_);
   EXPECT_FALSE(device_->IsConnectTimeoutStarted());

   // Expect no crash.
   device_->DropService(Service::kStateFailure);
 }

 TEST_F(WiMaxTest, OnDeviceVanished) {
   device_->proxy_.reset(proxy_.release());
   scoped_refptr<MockWiMaxService> service(
       new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
   device_->pending_service_ = service;
   EXPECT_CALL(*service, SetState(Service::kStateIdle));
   device_->OnDeviceVanished();
   EXPECT_FALSE(device_->proxy_.get());
   EXPECT_FALSE(device_->pending_service_);
 }

 TEST_F(WiMaxTest, OnEnableComplete) {
   MockWiMaxProvider provider;
   EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
   RpcIdentifiers networks(1, "path");
   EXPECT_CALL(*proxy_, Networks(_)).WillOnce(Return(networks));
   device_->proxy_.reset(proxy_.release());
   EXPECT_CALL(provider, OnNetworksChanged());
   Target target;
   EXPECT_CALL(target, EnabledStateChanged(_));
   EnabledStateChangedCallback callback(
       Bind(&Target::EnabledStateChanged, Unretained(&target)));
   Error error;
   device_->OnEnableComplete(callback, error);
   EXPECT_EQ(1, device_->networks_.size());
   EXPECT_TRUE(ContainsKey(device_->networks_, "path"));

   EXPECT_TRUE(device_->proxy_.get());
   error.Populate(Error::kOperationFailed);
   EXPECT_CALL(target, EnabledStateChanged(_));
   device_->OnEnableComplete(callback, error);
   EXPECT_FALSE(device_->proxy_.get());
 }

 TEST_F(WiMaxTest, ConnectTimeout) {
   EXPECT_EQ(&dispatcher_, device_->dispatcher());
   EXPECT_TRUE(device_->connect_timeout_callback_.IsCancelled());
   EXPECT_FALSE(device_->IsConnectTimeoutStarted());
   EXPECT_EQ(WiMax::kDefaultConnectTimeoutSeconds,
             device_->connect_timeout_seconds_);
   device_->connect_timeout_seconds_ = 0;
   device_->StartConnectTimeout();
   EXPECT_FALSE(device_->connect_timeout_callback_.IsCancelled());
   EXPECT_TRUE(device_->IsConnectTimeoutStarted());
   device_->dispatcher_ = NULL;
   device_->StartConnectTimeout();  // Expect no crash.
   scoped_refptr<MockWiMaxService> service(
       new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
   device_->pending_service_ = service;
   EXPECT_CALL(*service, SetState(Service::kStateFailure));
   dispatcher_.DispatchPendingEvents();
   EXPECT_TRUE(device_->connect_timeout_callback_.IsCancelled());
   EXPECT_FALSE(device_->IsConnectTimeoutStarted());
   EXPECT_FALSE(device_->pending_service_);
 }

 TEST_F(WiMaxTest, ConnectTo) {
   static const char kPath[] = "/network/path";
   scoped_refptr<MockWiMaxService> service(
       new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
   EXPECT_CALL(*service, SetState(Service::kStateAssociating));
   device_->status_ = wimax_manager::kDeviceStatusScanning;
   EXPECT_CALL(*service, GetNetworkObjectPath()).WillOnce(Return(kPath));
   EXPECT_CALL(*proxy_, Connect(kPath, _, _, _, _));
   device_->proxy_.reset(proxy_.release());
   Error error;
   device_->ConnectTo(service, &error);
   EXPECT_TRUE(error.IsSuccess());
   EXPECT_EQ(service.get(), device_->pending_service_.get());
   EXPECT_EQ(wimax_manager::kDeviceStatusUninitialized, device_->status_);
   EXPECT_TRUE(device_->IsConnectTimeoutStarted());

   device_->ConnectTo(service, &error);
   EXPECT_EQ(Error::kInProgress, error.type());

   device_->pending_service_ = NULL;
 }

 TEST_F(WiMaxTest, IsIdle) {
   EXPECT_TRUE(device_->IsIdle());
   scoped_refptr<NiceMock<MockWiMaxService> > service(
       new NiceMock<MockWiMaxService>(
           &control_,
           reinterpret_cast<EventDispatcher *>(NULL),
           &metrics_,
           &manager_));
   device_->pending_service_ = service;
   EXPECT_FALSE(device_->IsIdle());
   device_->pending_service_ = NULL;
   device_->SelectService(service);
   EXPECT_FALSE(device_->IsIdle());
 }

 }  // namespace shill
	// 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/wimax.h"

	#include <string>

	#include <base/stringprintf.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include "shill/event_dispatcher.h"
	#include "shill/mock_manager.h"
	#include "shill/mock_metrics.h"
	#include "shill/mock_wimax_device_proxy.h"
	#include "shill/mock_wimax_provider.h"
	#include "shill/mock_wimax_service.h"
	#include "shill/nice_mock_control.h"
	#include "shill/proxy_factory.h"

	using base::Bind;
	using base::Unretained;
	using std::string;
	using testing::_;
	using testing::NiceMock;
	using testing::Return;

	namespace shill {

	namespace {

	const char kTestLinkName[] = "wm0";
	const char kTestAddress[] = "01:23:45:67:89:ab";
	const int kTestInterfaceIndex = 5;
	const char kTestPath[] = "/org/chromium/WiMaxManager/Device/6";

	} // namespace

	class WiMaxTest : public testing::Test {
	public:
	WiMaxTest()
	: proxy_(new MockWiMaxDeviceProxy()),
	proxy_factory_(this),
	manager_(&control_, &dispatcher_, &metrics_, NULL),
	device_(new WiMax(&control_, &dispatcher_, &metrics_, &manager_,
	kTestLinkName, kTestAddress, kTestInterfaceIndex,
	kTestPath)) {}

	virtual ~WiMaxTest() {}

	protected:
	class TestProxyFactory : public ProxyFactory {
	public:
	explicit TestProxyFactory(WiMaxTest *test) : test_(test) {}

	virtual WiMaxDeviceProxyInterface *CreateWiMaxDeviceProxy(
	const string &/path/) {
	return test_->proxy_.release();
	}

	private:
	WiMaxTest *test_;

	DISALLOW_COPY_AND_ASSIGN(TestProxyFactory);
	};

	class Target {
	public:
	virtual ~Target() {}

	MOCK_METHOD1(EnabledStateChanged, void(const Error &error));
	};

	virtual void SetUp() {
	device_->proxy_factory_ = &proxy_factory_;
	}

	virtual void TearDown() {
	device_->SelectService(NULL);
	device_->pending_service_ = NULL;
	device_->proxy_factory_ = NULL;
	}

	scoped_ptr<MockWiMaxDeviceProxy> proxy_;
	TestProxyFactory proxy_factory_;
	NiceMockControl control_;
	EventDispatcher dispatcher_;
	NiceMock<MockMetrics> metrics_;
	MockManager manager_;
	WiMaxRefPtr device_;
	};

	TEST_F(WiMaxTest, Constructor) {
	EXPECT_EQ(kTestPath, device_->path());
	EXPECT_FALSE(device_->scanning());
	}

	TEST_F(WiMaxTest, StartStop) {
	EXPECT_FALSE(device_->proxy_.get());
	EXPECT_CALL(*proxy_, Enable(_, _, _));
	EXPECT_CALL(*proxy_, set_networks_changed_callback(_));
	EXPECT_CALL(*proxy_, set_status_changed_callback(_));
	EXPECT_CALL(*proxy_, Disable(_, _, _));
	device_->Start(NULL, EnabledStateChangedCallback());
	ASSERT_TRUE(device_->proxy_.get());

	scoped_refptr<MockWiMaxService> service(
	new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
	device_->pending_service_ = service;
	EXPECT_CALL(*service, SetState(Service::kStateIdle));
	device_->networks_.insert("path");
	MockWiMaxProvider provider;
	EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
	EXPECT_CALL(provider, OnNetworksChanged());
	device_->StartConnectTimeout();
	device_->Stop(NULL, EnabledStateChangedCallback());
	EXPECT_TRUE(device_->networks_.empty());
	EXPECT_FALSE(device_->IsConnectTimeoutStarted());
	EXPECT_FALSE(device_->pending_service_);
	}

	TEST_F(WiMaxTest, OnServiceStopped) {
	scoped_refptr<NiceMock<MockWiMaxService> > service0(
	new NiceMock<MockWiMaxService>(
	&control_,
	reinterpret_cast<EventDispatcher *>(NULL),
	&metrics_,
	&manager_));
	scoped_refptr<MockWiMaxService> service1(
	new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
	device_->SelectService(service0);
	device_->pending_service_ = service1;

	device_->OnServiceStopped(NULL);
	EXPECT_TRUE(device_->selected_service());
	EXPECT_TRUE(device_->pending_service_);

	device_->OnServiceStopped(service0);
	EXPECT_FALSE(device_->selected_service());
	EXPECT_TRUE(device_->pending_service_);

	device_->OnServiceStopped(service1);
	EXPECT_FALSE(device_->selected_service());
	EXPECT_FALSE(device_->pending_service_);
	}

	TEST_F(WiMaxTest, OnNetworksChanged) {
	MockWiMaxProvider provider;
	EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
	EXPECT_CALL(provider, OnNetworksChanged());
	device_->networks_.insert("foo");
	RpcIdentifiers networks;
	networks.push_back("bar");
	networks.push_back("zoo");
	networks.push_back("bar");
	device_->OnNetworksChanged(networks);
	EXPECT_EQ(2, device_->networks_.size());
	EXPECT_TRUE(ContainsKey(device_->networks_, "bar"));
	EXPECT_TRUE(ContainsKey(device_->networks_, "zoo"));
	}

	TEST_F(WiMaxTest, OnConnectComplete) {
	scoped_refptr<MockWiMaxService> service(
	new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
	device_->pending_service_ = service;
	EXPECT_CALL(*service, SetState(_)).Times(0);
	EXPECT_TRUE(device_->pending_service_);
	EXPECT_CALL(*service, SetState(Service::kStateFailure));
	device_->OnConnectComplete(Error(Error::kOperationFailed));
	EXPECT_FALSE(device_->pending_service_);
	}

	TEST_F(WiMaxTest, OnStatusChanged) {
	scoped_refptr<MockWiMaxService> service(
	new MockWiMaxService(&control_, NULL, &metrics_, &manager_));

	EXPECT_EQ(wimax_manager::kDeviceStatusUninitialized, device_->status_);
	device_->pending_service_ = service;
	EXPECT_CALL(*service, SetState(_)).Times(0);
	EXPECT_CALL(*service, ClearPassphrase()).Times(0);
	device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
	EXPECT_TRUE(device_->pending_service_);
	EXPECT_EQ(wimax_manager::kDeviceStatusScanning, device_->status_);

	device_->status_ = wimax_manager::kDeviceStatusConnecting;
	EXPECT_CALL(*service, SetState(Service::kStateFailure));
	EXPECT_CALL(*service, ClearPassphrase());
	device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
	EXPECT_FALSE(device_->pending_service_);

	device_->status_ = wimax_manager::kDeviceStatusConnecting;
	device_->SelectService(service);
	EXPECT_CALL(*service, SetState(Service::kStateFailure));
	EXPECT_CALL(*service, SetState(Service::kStateIdle));
	EXPECT_CALL(*service, ClearPassphrase()).Times(0);
	device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
	EXPECT_FALSE(device_->selected_service());

	device_->pending_service_ = service;
	device_->SelectService(service);
	EXPECT_CALL(*service, SetState(_)).Times(0);
	EXPECT_CALL(*service, ClearPassphrase()).Times(0);
	device_->OnStatusChanged(wimax_manager::kDeviceStatusConnecting);
	EXPECT_TRUE(device_->pending_service_);
	EXPECT_TRUE(device_->selected_service());
	EXPECT_EQ(wimax_manager::kDeviceStatusConnecting, device_->status_);

	EXPECT_CALL(*service, SetState(Service::kStateIdle));
	device_->SelectService(NULL);
	}

	TEST_F(WiMaxTest, DropService) {
	scoped_refptr<NiceMock<MockWiMaxService> > service0(
	new NiceMock<MockWiMaxService>(
	&control_,
	reinterpret_cast<EventDispatcher *>(NULL),
	&metrics_,
	&manager_));
	scoped_refptr<MockWiMaxService> service1(
	new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
	device_->SelectService(service0);
	device_->pending_service_ = service1;
	device_->StartConnectTimeout();

	EXPECT_CALL(*service0, SetState(Service::kStateIdle)).Times(2);
	EXPECT_CALL(*service1, SetState(Service::kStateIdle));
	device_->DropService(Service::kStateIdle);
	EXPECT_FALSE(device_->selected_service());
	EXPECT_FALSE(device_->pending_service_);
	EXPECT_FALSE(device_->IsConnectTimeoutStarted());

	// Expect no crash.
	device_->DropService(Service::kStateFailure);
	}

	TEST_F(WiMaxTest, OnDeviceVanished) {
	device_->proxy_.reset(proxy_.release());
	scoped_refptr<MockWiMaxService> service(
	new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
	device_->pending_service_ = service;
	EXPECT_CALL(*service, SetState(Service::kStateIdle));
	device_->OnDeviceVanished();
	EXPECT_FALSE(device_->proxy_.get());
	EXPECT_FALSE(device_->pending_service_);
	}

	TEST_F(WiMaxTest, OnEnableComplete) {
	MockWiMaxProvider provider;
	EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
	RpcIdentifiers networks(1, "path");
	EXPECT_CALL(*proxy_, Networks(_)).WillOnce(Return(networks));
	device_->proxy_.reset(proxy_.release());
	EXPECT_CALL(provider, OnNetworksChanged());
	Target target;
	EXPECT_CALL(target, EnabledStateChanged(_));
	EnabledStateChangedCallback callback(
	Bind(&Target::EnabledStateChanged, Unretained(&target)));
	Error error;
	device_->OnEnableComplete(callback, error);
	EXPECT_EQ(1, device_->networks_.size());
	EXPECT_TRUE(ContainsKey(device_->networks_, "path"));

	EXPECT_TRUE(device_->proxy_.get());
	error.Populate(Error::kOperationFailed);
	EXPECT_CALL(target, EnabledStateChanged(_));
	device_->OnEnableComplete(callback, error);
	EXPECT_FALSE(device_->proxy_.get());
	}

	TEST_F(WiMaxTest, ConnectTimeout) {
	EXPECT_EQ(&dispatcher_, device_->dispatcher());
	EXPECT_TRUE(device_->connect_timeout_callback_.IsCancelled());
	EXPECT_FALSE(device_->IsConnectTimeoutStarted());
	EXPECT_EQ(WiMax::kDefaultConnectTimeoutSeconds,
	device_->connect_timeout_seconds_);
	device_->connect_timeout_seconds_ = 0;
	device_->StartConnectTimeout();
	EXPECT_FALSE(device_->connect_timeout_callback_.IsCancelled());
	EXPECT_TRUE(device_->IsConnectTimeoutStarted());
	device_->dispatcher_ = NULL;
	device_->StartConnectTimeout(); // Expect no crash.
	scoped_refptr<MockWiMaxService> service(
	new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
	device_->pending_service_ = service;
	EXPECT_CALL(*service, SetState(Service::kStateFailure));
	dispatcher_.DispatchPendingEvents();
	EXPECT_TRUE(device_->connect_timeout_callback_.IsCancelled());
	EXPECT_FALSE(device_->IsConnectTimeoutStarted());
	EXPECT_FALSE(device_->pending_service_);
	}

	TEST_F(WiMaxTest, ConnectTo) {
	static const char kPath[] = "/network/path";
	scoped_refptr<MockWiMaxService> service(
	new MockWiMaxService(&control_, NULL, &metrics_, &manager_));
	EXPECT_CALL(*service, SetState(Service::kStateAssociating));
	device_->status_ = wimax_manager::kDeviceStatusScanning;
	EXPECT_CALL(*service, GetNetworkObjectPath()).WillOnce(Return(kPath));
	EXPECT_CALL(*proxy_, Connect(kPath, _, _, _, _));
	device_->proxy_.reset(proxy_.release());
	Error error;
	device_->ConnectTo(service, &error);
	EXPECT_TRUE(error.IsSuccess());
	EXPECT_EQ(service.get(), device_->pending_service_.get());
	EXPECT_EQ(wimax_manager::kDeviceStatusUninitialized, device_->status_);
	EXPECT_TRUE(device_->IsConnectTimeoutStarted());

	device_->ConnectTo(service, &error);
	EXPECT_EQ(Error::kInProgress, error.type());

	device_->pending_service_ = NULL;
	}

	TEST_F(WiMaxTest, IsIdle) {
	EXPECT_TRUE(device_->IsIdle());
	scoped_refptr<NiceMock<MockWiMaxService> > service(
	new NiceMock<MockWiMaxService>(
	&control_,
	reinterpret_cast<EventDispatcher *>(NULL),
	&metrics_,
	&manager_));
	device_->pending_service_ = service;
	EXPECT_FALSE(device_->IsIdle());
	device_->pending_service_ = NULL;
	device_->SelectService(service);
	EXPECT_FALSE(device_->IsIdle());
	}

	} // namespace shill