Correctly set technology state to UNAVAILABLE

chromeos/network/network_state_handler_unittest.cc

 // Copyright (c) 2012 The Chromium 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 "chromeos/network/network_state_handler.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 112 matching lines @@
 namespace chromeos {
 
 class NetworkStateHandlerTest : public testing::Test {
  public:
   NetworkStateHandlerTest() {}
   virtual ~NetworkStateHandlerTest() {}
 
   virtual void SetUp() OVERRIDE {
     // Initialize DBusThreadManager with a stub implementation.
     DBusThreadManager::InitializeWithStub();
+    SetupNetworkStateHandler();
+    message_loop_.RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     network_state_handler_.reset();
     test_observer_.reset();
     DBusThreadManager::Shutdown();
   }
 
   void SetupNetworkStateHandler() {
     SetupDefaultShillState();
@@ skipping 38 matching lines @@
 
   MessageLoopForUI message_loop_;
   scoped_ptr<NetworkStateHandler> network_state_handler_;
   scoped_ptr<TestObserver> test_observer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandlerTest);
 };
 
 TEST_F(NetworkStateHandlerTest, NetworkStateHandlerStub) {
-  SetupNetworkStateHandler();
-  message_loop_.RunUntilIdle();
   EXPECT_EQ(1u, test_observer_->manager_changed_count());
   // Ensure that the network list is the expected size.
   const size_t kNumShillManagerClientStubImplServices = 4;
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             test_observer_->network_count());
   // Ensure that the first stub network is the default network.
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             test_observer_->default_network());
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             network_state_handler_->ConnectedNetworkByType(
                 NetworkStateHandler::kMatchTypeDefault)->path());
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             network_state_handler_->ConnectedNetworkByType(
                 flimflam::kTypeEthernet)->path());
   EXPECT_EQ(kShillManagerClientStubDefaultWireless,
             network_state_handler_->ConnectedNetworkByType(
                 NetworkStateHandler::kMatchTypeWireless)->path());
   EXPECT_EQ(flimflam::kStateOnline,
             test_observer_->default_network_connection_state());
 }
 
 TEST_F(NetworkStateHandlerTest, TechnologyChanged) {
-  SetupNetworkStateHandler();
-  message_loop_.RunUntilIdle();
   EXPECT_EQ(1u, test_observer_->manager_changed_count());
   // Enable a technology.
   EXPECT_NE(NetworkStateHandler::TECHNOLOGY_ENABLED,
             network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
   network_state_handler_->SetTechnologyEnabled(
       flimflam::kTypeWimax, true, network_handler::ErrorCallback());
   // The technology state should immediately change to ENABLING and we should
   // receive a manager changed callback.
   EXPECT_EQ(2u, test_observer_->manager_changed_count());
   EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_ENABLING,
             network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
   message_loop_.RunUntilIdle();
   // Ensure we receive another manager changed callbacks when the technology
   // becomes enabled.
   EXPECT_EQ(3u, test_observer_->manager_changed_count());
   EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_ENABLED,
             network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
 }
 
+TEST_F(NetworkStateHandlerTest, TechnologyState) {
+  ShillManagerClient::TestInterface* manager_test =
+      DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
+  EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_UNAVAILABLE,
+            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+
+  manager_test->AddTechnology(flimflam::kTypeWimax, false);
+  message_loop_.RunUntilIdle();
+  EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_AVAILABLE,
+            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+
+  manager_test->SetTechnologyInitializing(flimflam::kTypeWimax, true);
+  message_loop_.RunUntilIdle();
+  EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_UNINITIALIZED,
+            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+
+  manager_test->SetTechnologyInitializing(flimflam::kTypeWimax, false);
+  network_state_handler_->SetTechnologyEnabled(
+      flimflam::kTypeWimax, true, network_handler::ErrorCallback());
+  message_loop_.RunUntilIdle();
+  EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_ENABLED,
+            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+
+  manager_test->RemoveTechnology(flimflam::kTypeWimax);
+  message_loop_.RunUntilIdle();
+  EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_UNAVAILABLE,
+            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+}
+
 TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) {
-  SetupNetworkStateHandler();
-  message_loop_.RunUntilIdle();
   // Set a service property.
   const std::string eth0 = "stub_ethernet";
   EXPECT_EQ("", network_state_handler_->GetNetworkState(eth0)->security());
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(eth0));
   base::StringValue security_value("TestSecurity");
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(eth0),
       flimflam::kSecurityProperty, security_value,
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ("TestSecurity",
             network_state_handler_->GetNetworkState(eth0)->security());
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth0));
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) {
-  SetupNetworkStateHandler();
-  message_loop_.RunUntilIdle();
   // Change a network state.
   ShillServiceClient::TestInterface* service_test =
       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
   const std::string eth0 = "stub_ethernet";
   base::StringValue connection_state_idle_value(flimflam::kStateIdle);
   service_test->SetServiceProperty(eth0, flimflam::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(flimflam::kStateIdle,
             test_observer_->NetworkConnectionStateForService(eth0));
   EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth0));
   // Confirm that changing the connection state to the same value does *not*
   // signal the observer.
   service_test->SetServiceProperty(eth0, flimflam::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth0));
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceChanged) {
-  SetupNetworkStateHandler();
-  message_loop_.RunUntilIdle();
-
   ShillManagerClient::TestInterface* manager_test =
       DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
   ASSERT_TRUE(manager_test);
   ShillServiceClient::TestInterface* service_test =
       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
   ASSERT_TRUE(service_test);
 
   // Change the default network by inserting wifi1 at the front of the list
   // and changing the state of stub_ethernet to Idle.
   const std::string wifi1 = "stub_wifi1";
@@ skipping 22 matching lines @@
   // No default network updates for signal strength changes.
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(wifi1),
       flimflam::kSignalStrengthProperty, base::FundamentalValue(32),
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ(3u, test_observer_->default_network_change_count());
 }
 
 }  // namespace chromeos