| // 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 <base/stringprintf.h> |
| #include <gtest/gtest.h> |
| |
| #include "shill/event_dispatcher.h" |
| #include "shill/mock_glib.h" |
| #include "shill/mock_manager.h" |
| #include "shill/mock_metrics.h" |
| #include "shill/mock_wimax_device_proxy.h" |
| #include "shill/mock_wimax_network_proxy.h" |
| #include "shill/mock_wimax_service.h" |
| #include "shill/nice_mock_control.h" |
| #include "shill/proxy_factory.h" |
| |
| using std::string; |
| using testing::_; |
| 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"; |
| |
| string GetTestNetworkPath(uint32 identifier) { |
| return base::StringPrintf("%s%08x", |
| wimax_manager::kNetworkObjectPathPrefix, |
| identifier); |
| } |
| |
| } // namespace |
| |
| class WiMaxTest : public testing::Test { |
| public: |
| WiMaxTest() |
| : proxy_(new MockWiMaxDeviceProxy()), |
| network_proxy_(new MockWiMaxNetworkProxy()), |
| proxy_factory_(this), |
| manager_(&control_, &dispatcher_, &metrics_, &glib_), |
| wimax_(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(); |
| } |
| |
| virtual WiMaxNetworkProxyInterface *CreateWiMaxNetworkProxy( |
| const string &/*path*/) { |
| return test_->network_proxy_.release(); |
| } |
| |
| private: |
| WiMaxTest *test_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestProxyFactory); |
| }; |
| |
| virtual void SetUp() { |
| wimax_->proxy_factory_ = &proxy_factory_; |
| } |
| |
| virtual void TearDown() { |
| wimax_->services_.clear(); |
| wimax_->proxy_factory_ = NULL; |
| } |
| |
| scoped_ptr<MockWiMaxDeviceProxy> proxy_; |
| scoped_ptr<MockWiMaxNetworkProxy> network_proxy_; |
| TestProxyFactory proxy_factory_; |
| NiceMockControl control_; |
| EventDispatcher dispatcher_; |
| MockMetrics metrics_; |
| MockGLib glib_; |
| MockManager manager_; |
| WiMaxRefPtr wimax_; |
| }; |
| |
| TEST_F(WiMaxTest, Constructor) { |
| EXPECT_EQ(kTestPath, wimax_->path()); |
| EXPECT_FALSE(wimax_->scanning()); |
| } |
| |
| TEST_F(WiMaxTest, TechnologyIs) { |
| EXPECT_TRUE(wimax_->TechnologyIs(Technology::kWiMax)); |
| EXPECT_FALSE(wimax_->TechnologyIs(Technology::kEthernet)); |
| } |
| |
| TEST_F(WiMaxTest, StartStop) { |
| EXPECT_FALSE(wimax_->proxy_.get()); |
| EXPECT_CALL(*proxy_, Enable(_, _, _)); |
| EXPECT_CALL(*proxy_, set_networks_changed_callback(_)); |
| EXPECT_CALL(*proxy_, Disable(_, _, _)); |
| wimax_->Start(NULL, EnabledStateChangedCallback()); |
| EXPECT_TRUE(wimax_->proxy_.get()); |
| wimax_->Stop(NULL, EnabledStateChangedCallback()); |
| } |
| |
| TEST_F(WiMaxTest, OnNetworksChanged) { |
| wimax_->services_[GetTestNetworkPath(2)] = |
| new MockWiMaxService(&control_, NULL, &metrics_, &manager_, NULL); |
| RpcIdentifiers live_devices; |
| live_devices.push_back(GetTestNetworkPath(3)); |
| EXPECT_CALL(manager_, DeregisterService(_)); |
| EXPECT_CALL(*network_proxy_, Name(_)); |
| EXPECT_CALL(*network_proxy_, Identifier(_)); |
| EXPECT_CALL(manager_, RegisterService(_)); |
| wimax_->OnNetworksChanged(live_devices); |
| ASSERT_EQ(1, wimax_->services_.size()); |
| EXPECT_TRUE(ContainsKey(wimax_->services_, GetTestNetworkPath(3))); |
| } |
| |
| TEST_F(WiMaxTest, CreateService) { |
| EXPECT_TRUE(wimax_->services_.empty()); |
| |
| static const char kTestNetworkName[] = "TestWiMaxNetwork"; |
| |
| EXPECT_CALL(*network_proxy_, Name(_)).WillOnce(Return(kTestNetworkName)); |
| EXPECT_CALL(*network_proxy_, Identifier(_)); |
| EXPECT_CALL(manager_, RegisterService(_)); |
| wimax_->CreateService(GetTestNetworkPath(1)); |
| ASSERT_EQ(1, wimax_->services_.size()); |
| EXPECT_TRUE(ContainsKey(wimax_->services_, GetTestNetworkPath(1))); |
| EXPECT_EQ(kTestNetworkName, |
| wimax_->services_[GetTestNetworkPath(1)]->friendly_name()); |
| |
| WiMaxService *service = wimax_->services_[GetTestNetworkPath(1)]; |
| wimax_->CreateService(GetTestNetworkPath(1)); |
| EXPECT_EQ(service, wimax_->services_[GetTestNetworkPath(1)]); |
| } |
| |
| TEST_F(WiMaxTest, DestroyDeadServices) { |
| for (int i = 100; i < 104; i++) { |
| wimax_->services_[GetTestNetworkPath(i)] = |
| new MockWiMaxService(&control_, NULL, &metrics_, &manager_, NULL); |
| } |
| wimax_->SelectService(wimax_->services_[GetTestNetworkPath(100)]); |
| wimax_->pending_service_ = wimax_->services_[GetTestNetworkPath(103)]; |
| |
| RpcIdentifiers live_networks; |
| live_networks.push_back(GetTestNetworkPath(777)); |
| live_networks.push_back(GetTestNetworkPath(100)); |
| live_networks.push_back(GetTestNetworkPath(103)); |
| EXPECT_CALL(manager_, DeregisterService(_)).Times(2); |
| wimax_->DestroyDeadServices(live_networks); |
| ASSERT_EQ(2, wimax_->services_.size()); |
| EXPECT_TRUE(ContainsKey(wimax_->services_, GetTestNetworkPath(100))); |
| EXPECT_TRUE(ContainsKey(wimax_->services_, GetTestNetworkPath(103))); |
| EXPECT_TRUE(wimax_->selected_service()); |
| EXPECT_TRUE(wimax_->pending_service_); |
| |
| live_networks.pop_back(); |
| EXPECT_CALL(manager_, DeregisterService(_)).Times(1); |
| wimax_->DestroyDeadServices(live_networks); |
| ASSERT_EQ(1, wimax_->services_.size()); |
| EXPECT_TRUE(ContainsKey(wimax_->services_, GetTestNetworkPath(100))); |
| EXPECT_TRUE(wimax_->selected_service()); |
| EXPECT_FALSE(wimax_->pending_service_); |
| |
| live_networks.pop_back(); |
| EXPECT_CALL(manager_, DeregisterService(_)).Times(1); |
| wimax_->DestroyDeadServices(live_networks); |
| EXPECT_TRUE(wimax_->services_.empty()); |
| EXPECT_FALSE(wimax_->selected_service()); |
| } |
| |
| } // namespace shill |