OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chromeos/network/network_state_handler.h" | 5 #include "chromeos/network/network_state_handler.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <map> | 9 #include <map> |
10 #include <memory> | 10 #include <memory> |
(...skipping 10 matching lines...) Expand all Loading... |
21 #include "chromeos/dbus/dbus_thread_manager.h" | 21 #include "chromeos/dbus/dbus_thread_manager.h" |
22 #include "chromeos/dbus/shill_device_client.h" | 22 #include "chromeos/dbus/shill_device_client.h" |
23 #include "chromeos/dbus/shill_ipconfig_client.h" | 23 #include "chromeos/dbus/shill_ipconfig_client.h" |
24 #include "chromeos/dbus/shill_manager_client.h" | 24 #include "chromeos/dbus/shill_manager_client.h" |
25 #include "chromeos/dbus/shill_profile_client.h" | 25 #include "chromeos/dbus/shill_profile_client.h" |
26 #include "chromeos/dbus/shill_service_client.h" | 26 #include "chromeos/dbus/shill_service_client.h" |
27 #include "chromeos/network/device_state.h" | 27 #include "chromeos/network/device_state.h" |
28 #include "chromeos/network/network_state.h" | 28 #include "chromeos/network/network_state.h" |
29 #include "chromeos/network/network_state_handler.h" | 29 #include "chromeos/network/network_state_handler.h" |
30 #include "chromeos/network/network_state_handler_observer.h" | 30 #include "chromeos/network/network_state_handler_observer.h" |
31 #include "chromeos/network/tether_constants.h" | |
32 #include "dbus/object_path.h" | 31 #include "dbus/object_path.h" |
33 #include "testing/gtest/include/gtest/gtest.h" | 32 #include "testing/gtest/include/gtest/gtest.h" |
34 #include "third_party/cros_system_api/dbus/service_constants.h" | 33 #include "third_party/cros_system_api/dbus/service_constants.h" |
35 | 34 |
36 namespace { | 35 namespace { |
37 | 36 |
38 void ErrorCallbackFunction(const std::string& error_name, | 37 void ErrorCallbackFunction(const std::string& error_name, |
39 const std::string& error_message) { | 38 const std::string& error_message) { |
40 LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message; | 39 LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message; |
41 } | 40 } |
(...skipping 25 matching lines...) Expand all Loading... |
67 using chromeos::NetworkStateHandler; | 66 using chromeos::NetworkStateHandler; |
68 | 67 |
69 class TestObserver : public chromeos::NetworkStateHandlerObserver { | 68 class TestObserver : public chromeos::NetworkStateHandlerObserver { |
70 public: | 69 public: |
71 explicit TestObserver(NetworkStateHandler* handler) | 70 explicit TestObserver(NetworkStateHandler* handler) |
72 : handler_(handler), | 71 : handler_(handler), |
73 device_list_changed_count_(0), | 72 device_list_changed_count_(0), |
74 device_count_(0), | 73 device_count_(0), |
75 network_list_changed_count_(0), | 74 network_list_changed_count_(0), |
76 network_count_(0), | 75 network_count_(0), |
77 default_network_change_count_(0), | 76 default_network_change_count_(0) { |
78 scan_completed_count_(0) {} | 77 } |
79 | 78 |
80 ~TestObserver() override {} | 79 ~TestObserver() override {} |
81 | 80 |
82 void DeviceListChanged() override { | 81 void DeviceListChanged() override { |
83 NetworkStateHandler::DeviceStateList devices; | 82 NetworkStateHandler::DeviceStateList devices; |
84 handler_->GetDeviceList(&devices); | 83 handler_->GetDeviceList(&devices); |
85 device_count_ = devices.size(); | 84 device_count_ = devices.size(); |
86 ++device_list_changed_count_; | 85 ++device_list_changed_count_; |
87 } | 86 } |
88 | 87 |
(...skipping 30 matching lines...) Expand all Loading... |
119 void NetworkPropertiesUpdated(const NetworkState* network) override { | 118 void NetworkPropertiesUpdated(const NetworkState* network) override { |
120 DCHECK(network); | 119 DCHECK(network); |
121 property_updates_[network->path()]++; | 120 property_updates_[network->path()]++; |
122 } | 121 } |
123 | 122 |
124 void DevicePropertiesUpdated(const DeviceState* device) override { | 123 void DevicePropertiesUpdated(const DeviceState* device) override { |
125 DCHECK(device); | 124 DCHECK(device); |
126 device_property_updates_[device->path()]++; | 125 device_property_updates_[device->path()]++; |
127 } | 126 } |
128 | 127 |
129 void ScanCompleted(const DeviceState* device) override { | |
130 DCHECK(device); | |
131 scan_completed_count_++; | |
132 } | |
133 | |
134 size_t device_list_changed_count() { return device_list_changed_count_; } | 128 size_t device_list_changed_count() { return device_list_changed_count_; } |
135 size_t device_count() { return device_count_; } | 129 size_t device_count() { return device_count_; } |
136 size_t network_list_changed_count() { return network_list_changed_count_; } | 130 size_t network_list_changed_count() { return network_list_changed_count_; } |
137 size_t network_count() { return network_count_; } | 131 size_t network_count() { return network_count_; } |
138 size_t default_network_change_count() { | 132 size_t default_network_change_count() { |
139 return default_network_change_count_; | 133 return default_network_change_count_; |
140 } | 134 } |
141 size_t scan_completed_count() { return scan_completed_count_; } | |
142 void reset_change_counts() { | 135 void reset_change_counts() { |
143 DVLOG(1) << "=== RESET CHANGE COUNTS ==="; | 136 DVLOG(1) << "=== RESET CHANGE COUNTS ==="; |
144 default_network_change_count_ = 0; | 137 default_network_change_count_ = 0; |
145 device_list_changed_count_ = 0; | 138 device_list_changed_count_ = 0; |
146 network_list_changed_count_ = 0; | 139 network_list_changed_count_ = 0; |
147 scan_completed_count_ = 0; | |
148 connection_state_changes_.clear(); | 140 connection_state_changes_.clear(); |
149 } | 141 } |
150 void reset_updates() { | 142 void reset_updates() { |
151 property_updates_.clear(); | 143 property_updates_.clear(); |
152 device_property_updates_.clear(); | 144 device_property_updates_.clear(); |
153 } | 145 } |
154 std::string default_network() { return default_network_; } | 146 std::string default_network() { return default_network_; } |
155 std::string default_network_connection_state() { | 147 std::string default_network_connection_state() { |
156 return default_network_connection_state_; | 148 return default_network_connection_state_; |
157 } | 149 } |
(...skipping 15 matching lines...) Expand all Loading... |
173 return network_connection_state_[service_path]; | 165 return network_connection_state_[service_path]; |
174 } | 166 } |
175 | 167 |
176 private: | 168 private: |
177 NetworkStateHandler* handler_; | 169 NetworkStateHandler* handler_; |
178 size_t device_list_changed_count_; | 170 size_t device_list_changed_count_; |
179 size_t device_count_; | 171 size_t device_count_; |
180 size_t network_list_changed_count_; | 172 size_t network_list_changed_count_; |
181 size_t network_count_; | 173 size_t network_count_; |
182 size_t default_network_change_count_; | 174 size_t default_network_change_count_; |
183 size_t scan_completed_count_; | |
184 std::string default_network_; | 175 std::string default_network_; |
185 std::string default_network_connection_state_; | 176 std::string default_network_connection_state_; |
186 std::map<std::string, int> property_updates_; | 177 std::map<std::string, int> property_updates_; |
187 std::map<std::string, int> device_property_updates_; | 178 std::map<std::string, int> device_property_updates_; |
188 std::map<std::string, int> connection_state_changes_; | 179 std::map<std::string, int> connection_state_changes_; |
189 std::map<std::string, std::string> network_connection_state_; | 180 std::map<std::string, std::string> network_connection_state_; |
190 | 181 |
191 DISALLOW_COPY_AND_ASSIGN(TestObserver); | 182 DISALLOW_COPY_AND_ASSIGN(TestObserver); |
192 }; | 183 }; |
193 | 184 |
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
332 NetworkTypePattern::Mobile())->path()); | 323 NetworkTypePattern::Mobile())->path()); |
333 EXPECT_EQ( | 324 EXPECT_EQ( |
334 kShillManagerClientStubCellular, | 325 kShillManagerClientStubCellular, |
335 network_state_handler_->FirstNetworkByType(NetworkTypePattern::Cellular()) | 326 network_state_handler_->FirstNetworkByType(NetworkTypePattern::Cellular()) |
336 ->path()); | 327 ->path()); |
337 EXPECT_EQ(shill::kStateOnline, | 328 EXPECT_EQ(shill::kStateOnline, |
338 test_observer_->default_network_connection_state()); | 329 test_observer_->default_network_connection_state()); |
339 } | 330 } |
340 | 331 |
341 TEST_F(NetworkStateHandlerTest, GetNetworkList) { | 332 TEST_F(NetworkStateHandlerTest, GetNetworkList) { |
342 network_state_handler_->SetTetherTechnologyState( | |
343 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
344 | |
345 // Ensure that the network list is the expected size. | 333 // Ensure that the network list is the expected size. |
346 const size_t kNumShillManagerClientStubImplServices = 4; | 334 const size_t kNumShillManagerClientStubImplServices = 4; |
347 EXPECT_EQ(kNumShillManagerClientStubImplServices, | 335 EXPECT_EQ(kNumShillManagerClientStubImplServices, |
348 test_observer_->network_count()); | 336 test_observer_->network_count()); |
349 // Add a non-visible network to the profile. | 337 // Add a non-visible network to the profile. |
350 const std::string profile = "/profile/profile1"; | 338 const std::string profile = "/profile/profile1"; |
351 const std::string wifi_favorite_path = "/service/wifi_faviorite"; | 339 const std::string wifi_favorite_path = "/service/wifi_faviorite"; |
352 service_test_->AddService(wifi_favorite_path, | 340 service_test_->AddService(wifi_favorite_path, |
353 "wifi_faviorite_guid", | 341 "wifi_faviorite_guid", |
354 "wifi_faviorite", | 342 "wifi_faviorite", |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
420 // Get configured (profile) networks. | 408 // Get configured (profile) networks. |
421 network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(), | 409 network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(), |
422 true /* configured_only */, | 410 true /* configured_only */, |
423 false /* visible_only */, | 411 false /* visible_only */, |
424 0 /* no limit */, | 412 0 /* no limit */, |
425 &networks); | 413 &networks); |
426 EXPECT_EQ(kNumTetherNetworks + 1u, networks.size()); | 414 EXPECT_EQ(kNumTetherNetworks + 1u, networks.size()); |
427 } | 415 } |
428 | 416 |
429 TEST_F(NetworkStateHandlerTest, GetTetherNetworkList) { | 417 TEST_F(NetworkStateHandlerTest, GetTetherNetworkList) { |
430 network_state_handler_->SetTetherTechnologyState( | |
431 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
432 | |
433 NetworkStateHandler::NetworkStateList tether_networks; | 418 NetworkStateHandler::NetworkStateList tether_networks; |
434 | 419 |
435 GetTetherNetworkList(0 /* no limit */, &tether_networks); | 420 GetTetherNetworkList(0 /* no limit */, &tether_networks); |
436 EXPECT_EQ(0u, tether_networks.size()); | 421 EXPECT_EQ(0u, tether_networks.size()); |
437 | 422 |
438 network_state_handler_->AddTetherNetworkState( | 423 network_state_handler_->AddTetherNetworkState( |
439 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, | 424 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, |
440 kTetherSignalStrength1); | 425 kTetherSignalStrength1); |
441 | 426 |
442 GetTetherNetworkList(0 /* no limit */, &tether_networks); | 427 GetTetherNetworkList(0 /* no limit */, &tether_networks); |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
576 base::RunLoop().RunUntilIdle(); | 561 base::RunLoop().RunUntilIdle(); |
577 EXPECT_EQ( | 562 EXPECT_EQ( |
578 NetworkStateHandler::TECHNOLOGY_UNAVAILABLE, | 563 NetworkStateHandler::TECHNOLOGY_UNAVAILABLE, |
579 network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); | 564 network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); |
580 } | 565 } |
581 | 566 |
582 TEST_F(NetworkStateHandlerTest, TetherTechnologyState) { | 567 TEST_F(NetworkStateHandlerTest, TetherTechnologyState) { |
583 EXPECT_EQ( | 568 EXPECT_EQ( |
584 NetworkStateHandler::TECHNOLOGY_UNAVAILABLE, | 569 NetworkStateHandler::TECHNOLOGY_UNAVAILABLE, |
585 network_state_handler_->GetTechnologyState(NetworkTypePattern::Tether())); | 570 network_state_handler_->GetTechnologyState(NetworkTypePattern::Tether())); |
586 EXPECT_FALSE(network_state_handler_->GetDeviceState(kTetherDevicePath)); | |
587 EXPECT_FALSE(network_state_handler_->GetDeviceStateByType( | |
588 NetworkTypePattern::Tether())); | |
589 | 571 |
590 // Test SetTetherTechnologyState(): | 572 base::CommandLine::ForCurrentProcess()->AppendSwitch( |
591 network_state_handler_->SetTetherTechnologyState( | 573 chromeos::switches::kEnableTether); |
592 NetworkStateHandler::TECHNOLOGY_AVAILABLE); | |
593 EXPECT_EQ(1u, test_observer_->device_list_changed_count()); | |
594 EXPECT_EQ( | |
595 NetworkStateHandler::TECHNOLOGY_AVAILABLE, | |
596 network_state_handler_->GetTechnologyState(NetworkTypePattern::Tether())); | |
597 const DeviceState* tether_device_state = | |
598 network_state_handler_->GetDeviceState(kTetherDevicePath); | |
599 EXPECT_TRUE(tether_device_state); | |
600 EXPECT_EQ(tether_device_state, network_state_handler_->GetDeviceStateByType( | |
601 NetworkTypePattern::Tether())); | |
602 | 574 |
603 // Test SetTechnologyEnabled() with a tether network: | |
604 network_state_handler_->SetTechnologyEnabled( | |
605 NetworkTypePattern::Tether(), true, network_handler::ErrorCallback()); | |
606 EXPECT_EQ(2u, test_observer_->device_list_changed_count()); | |
607 EXPECT_EQ( | 575 EXPECT_EQ( |
608 NetworkStateHandler::TECHNOLOGY_ENABLED, | 576 NetworkStateHandler::TECHNOLOGY_ENABLED, |
609 network_state_handler_->GetTechnologyState(NetworkTypePattern::Tether())); | 577 network_state_handler_->GetTechnologyState(NetworkTypePattern::Tether())); |
610 EXPECT_EQ(tether_device_state, | |
611 network_state_handler_->GetDeviceState(kTetherDevicePath)); | |
612 EXPECT_EQ(tether_device_state, network_state_handler_->GetDeviceStateByType( | |
613 NetworkTypePattern::Tether())); | |
614 | |
615 // Test SetProhibitedTechnologies() with a tether network: | |
616 network_state_handler_->SetProhibitedTechnologies( | |
617 std::vector<std::string>{kTypeTether}, network_handler::ErrorCallback()); | |
618 EXPECT_EQ(3u, test_observer_->device_list_changed_count()); | |
619 EXPECT_EQ( | |
620 NetworkStateHandler::TECHNOLOGY_PROHIBITED, | |
621 network_state_handler_->GetTechnologyState(NetworkTypePattern::Tether())); | |
622 EXPECT_EQ(tether_device_state, | |
623 network_state_handler_->GetDeviceState(kTetherDevicePath)); | |
624 EXPECT_EQ(tether_device_state, network_state_handler_->GetDeviceStateByType( | |
625 NetworkTypePattern::Tether())); | |
626 | |
627 // Set back to TECHNOLOGY_UNAVAILABLE; this should result in nullptr being | |
628 // returned by getters. | |
629 network_state_handler_->SetTetherTechnologyState( | |
630 NetworkStateHandler::TECHNOLOGY_UNAVAILABLE); | |
631 EXPECT_FALSE(network_state_handler_->GetDeviceState(kTetherDevicePath)); | |
632 EXPECT_FALSE(network_state_handler_->GetDeviceStateByType( | |
633 NetworkTypePattern::Tether())); | |
634 } | |
635 | |
636 TEST_F(NetworkStateHandlerTest, TetherScanningState) { | |
637 network_state_handler_->SetTetherTechnologyState( | |
638 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
639 | |
640 const DeviceState* tether_device_state = | |
641 network_state_handler_->GetDeviceStateByType( | |
642 NetworkTypePattern::Tether()); | |
643 EXPECT_TRUE(tether_device_state); | |
644 EXPECT_FALSE(tether_device_state->scanning()); | |
645 EXPECT_EQ(0u, test_observer_->scan_completed_count()); | |
646 | |
647 network_state_handler_->SetTetherScanState(true /* is_scanning */); | |
648 tether_device_state = network_state_handler_->GetDeviceStateByType( | |
649 NetworkTypePattern::Tether()); | |
650 EXPECT_TRUE(tether_device_state); | |
651 EXPECT_TRUE(tether_device_state->scanning()); | |
652 EXPECT_EQ(0u, test_observer_->scan_completed_count()); | |
653 | |
654 network_state_handler_->SetTetherScanState(false /* is_scanning */); | |
655 tether_device_state = network_state_handler_->GetDeviceStateByType( | |
656 NetworkTypePattern::Tether()); | |
657 EXPECT_TRUE(tether_device_state); | |
658 EXPECT_FALSE(tether_device_state->scanning()); | |
659 EXPECT_EQ(1u, test_observer_->scan_completed_count()); | |
660 } | 578 } |
661 | 579 |
662 TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) { | 580 TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) { |
663 // Set a service property. | 581 // Set a service property. |
664 const std::string eth1 = kShillManagerClientStubDefaultService; | 582 const std::string eth1 = kShillManagerClientStubDefaultService; |
665 const NetworkState* ethernet = network_state_handler_->GetNetworkState(eth1); | 583 const NetworkState* ethernet = network_state_handler_->GetNetworkState(eth1); |
666 ASSERT_TRUE(ethernet); | 584 ASSERT_TRUE(ethernet); |
667 EXPECT_EQ("", ethernet->security_class()); | 585 EXPECT_EQ("", ethernet->security_class()); |
668 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(eth1)); | 586 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(eth1)); |
669 base::Value security_class_value("TestSecurityClass"); | 587 base::Value security_class_value("TestSecurityClass"); |
(...skipping 30 matching lines...) Expand all Loading... |
700 network_state_handler_->GetNetworkStateFromGuid(wifi_network->guid()); | 618 network_state_handler_->GetNetworkStateFromGuid(wifi_network->guid()); |
701 EXPECT_EQ(wifi_network, wifi_network_guid); | 619 EXPECT_EQ(wifi_network, wifi_network_guid); |
702 | 620 |
703 // Remove the service, verify that there is no longer a NetworkState for it. | 621 // Remove the service, verify that there is no longer a NetworkState for it. |
704 service_test_->RemoveService(wifi_path); | 622 service_test_->RemoveService(wifi_path); |
705 UpdateManagerProperties(); | 623 UpdateManagerProperties(); |
706 EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path)); | 624 EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path)); |
707 } | 625 } |
708 | 626 |
709 TEST_F(NetworkStateHandlerTest, TetherNetworkState) { | 627 TEST_F(NetworkStateHandlerTest, TetherNetworkState) { |
710 network_state_handler_->SetTetherTechnologyState( | |
711 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
712 | |
713 EXPECT_EQ(0u, test_observer_->network_list_changed_count()); | 628 EXPECT_EQ(0u, test_observer_->network_list_changed_count()); |
714 | 629 |
715 network_state_handler_->AddTetherNetworkState( | 630 network_state_handler_->AddTetherNetworkState( |
716 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, | 631 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, |
717 kTetherSignalStrength1); | 632 kTetherSignalStrength1); |
718 | 633 |
719 EXPECT_EQ(1u, test_observer_->network_list_changed_count()); | 634 EXPECT_EQ(1u, test_observer_->network_list_changed_count()); |
720 | 635 |
721 const NetworkState* tether_network = | 636 const NetworkState* tether_network = |
722 network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1); | 637 network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1); |
(...skipping 26 matching lines...) Expand all Loading... |
749 | 664 |
750 ASSERT_FALSE(network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1)); | 665 ASSERT_FALSE(network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1)); |
751 | 666 |
752 // Updating tether properties should fail since the network was removed. | 667 // Updating tether properties should fail since the network was removed. |
753 EXPECT_FALSE(network_state_handler_->UpdateTetherNetworkProperties( | 668 EXPECT_FALSE(network_state_handler_->UpdateTetherNetworkProperties( |
754 kTetherGuid1, "NewNewCarrier", 15 /* battery_percentage */, | 669 kTetherGuid1, "NewNewCarrier", 15 /* battery_percentage */, |
755 20 /* signal_strength */)); | 670 20 /* signal_strength */)); |
756 } | 671 } |
757 | 672 |
758 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation) { | 673 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation) { |
759 network_state_handler_->SetTetherTechnologyState( | |
760 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
761 | |
762 EXPECT_EQ(0u, test_observer_->network_list_changed_count()); | 674 EXPECT_EQ(0u, test_observer_->network_list_changed_count()); |
763 | 675 |
764 const std::string profile = "/profile/profile1"; | 676 const std::string profile = "/profile/profile1"; |
765 const std::string wifi_path = "/service/wifi_with_guid"; | 677 const std::string wifi_path = "/service/wifi_with_guid"; |
766 AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi, | 678 AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi, |
767 shill::kStateOnline); | 679 shill::kStateOnline); |
768 profile_test_->AddProfile(profile, "" /* userhash */); | 680 profile_test_->AddProfile(profile, "" /* userhash */); |
769 EXPECT_TRUE(profile_test_->AddService(profile, wifi_path)); | 681 EXPECT_TRUE(profile_test_->AddService(profile, wifi_path)); |
770 UpdateManagerProperties(); | 682 UpdateManagerProperties(); |
771 | 683 |
(...skipping 21 matching lines...) Expand all Loading... |
793 | 705 |
794 network_state_handler_->RemoveTetherNetworkState(kTetherGuid1); | 706 network_state_handler_->RemoveTetherNetworkState(kTetherGuid1); |
795 | 707 |
796 EXPECT_EQ(4u, test_observer_->network_list_changed_count()); | 708 EXPECT_EQ(4u, test_observer_->network_list_changed_count()); |
797 | 709 |
798 wifi_network = network_state_handler_->GetNetworkStateFromGuid(kWifiGuid1); | 710 wifi_network = network_state_handler_->GetNetworkStateFromGuid(kWifiGuid1); |
799 ASSERT_TRUE(wifi_network->tether_guid().empty()); | 711 ASSERT_TRUE(wifi_network->tether_guid().empty()); |
800 } | 712 } |
801 | 713 |
802 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociationWifiRemoved) { | 714 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociationWifiRemoved) { |
803 network_state_handler_->SetTetherTechnologyState( | |
804 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
805 | |
806 const std::string profile = "/profile/profile1"; | 715 const std::string profile = "/profile/profile1"; |
807 const std::string wifi_path = "/service/wifi_with_guid"; | 716 const std::string wifi_path = "/service/wifi_with_guid"; |
808 AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi, | 717 AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi, |
809 shill::kStateOnline); | 718 shill::kStateOnline); |
810 profile_test_->AddProfile(profile, "" /* userhash */); | 719 profile_test_->AddProfile(profile, "" /* userhash */); |
811 EXPECT_TRUE(profile_test_->AddService(profile, wifi_path)); | 720 EXPECT_TRUE(profile_test_->AddService(profile, wifi_path)); |
812 UpdateManagerProperties(); | 721 UpdateManagerProperties(); |
813 | 722 |
814 network_state_handler_->AddTetherNetworkState( | 723 network_state_handler_->AddTetherNetworkState( |
815 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, | 724 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, |
(...skipping 12 matching lines...) Expand all Loading... |
828 | 737 |
829 service_test_->RemoveService(wifi_path); | 738 service_test_->RemoveService(wifi_path); |
830 UpdateManagerProperties(); | 739 UpdateManagerProperties(); |
831 | 740 |
832 tether_network = | 741 tether_network = |
833 network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1); | 742 network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1); |
834 ASSERT_TRUE(tether_network->tether_guid().empty()); | 743 ASSERT_TRUE(tether_network->tether_guid().empty()); |
835 } | 744 } |
836 | 745 |
837 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation_NoWifiNetwork) { | 746 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation_NoWifiNetwork) { |
838 network_state_handler_->SetTetherTechnologyState( | |
839 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
840 | |
841 network_state_handler_->AddTetherNetworkState( | 747 network_state_handler_->AddTetherNetworkState( |
842 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, | 748 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, |
843 kTetherSignalStrength1); | 749 kTetherSignalStrength1); |
844 | 750 |
845 EXPECT_FALSE( | 751 EXPECT_FALSE( |
846 network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork( | 752 network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork( |
847 kTetherGuid1, kWifiGuid1)); | 753 kTetherGuid1, kWifiGuid1)); |
848 } | 754 } |
849 | 755 |
850 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation_NoTetherNetwork) { | 756 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation_NoTetherNetwork) { |
851 network_state_handler_->SetTetherTechnologyState( | |
852 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
853 | |
854 const std::string profile = "/profile/profile1"; | 757 const std::string profile = "/profile/profile1"; |
855 const std::string wifi_path = "/service/wifi_with_guid"; | 758 const std::string wifi_path = "/service/wifi_with_guid"; |
856 AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi, | 759 AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi, |
857 shill::kStateOnline); | 760 shill::kStateOnline); |
858 profile_test_->AddProfile(profile, "" /* userhash */); | 761 profile_test_->AddProfile(profile, "" /* userhash */); |
859 EXPECT_TRUE(profile_test_->AddService(profile, wifi_path)); | 762 EXPECT_TRUE(profile_test_->AddService(profile, wifi_path)); |
860 UpdateManagerProperties(); | 763 UpdateManagerProperties(); |
861 | 764 |
862 ASSERT_FALSE( | 765 ASSERT_FALSE( |
863 network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork( | 766 network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork( |
864 kTetherGuid1, kWifiGuid1)); | 767 kTetherGuid1, kWifiGuid1)); |
865 } | 768 } |
866 | 769 |
867 TEST_F(NetworkStateHandlerTest, SetTetherNetworkStateConnectionState) { | 770 TEST_F(NetworkStateHandlerTest, SetTetherNetworkStateConnectionState) { |
868 network_state_handler_->SetTetherTechnologyState( | |
869 NetworkStateHandler::TECHNOLOGY_ENABLED); | |
870 | |
871 network_state_handler_->AddTetherNetworkState( | 771 network_state_handler_->AddTetherNetworkState( |
872 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, | 772 kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1, |
873 kTetherSignalStrength1); | 773 kTetherSignalStrength1); |
874 | 774 |
875 // Add corresponding Wi-Fi network. | 775 // Add corresponding Wi-Fi network. |
876 const std::string profile = "/profile/profile1"; | 776 const std::string profile = "/profile/profile1"; |
877 const std::string wifi_path = "/service/wifi_with_guid"; | 777 const std::string wifi_path = "/service/wifi_with_guid"; |
878 AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi, | 778 AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi, |
879 shill::kStateOnline); | 779 shill::kStateOnline); |
880 profile_test_->AddProfile(profile, "" /* userhash */); | 780 profile_test_->AddProfile(profile, "" /* userhash */); |
(...skipping 274 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1155 shill::kIPConfigProperty, | 1055 shill::kIPConfigProperty, |
1156 base::Value(kIPConfigPath)); | 1056 base::Value(kIPConfigPath)); |
1157 UpdateManagerProperties(); | 1057 UpdateManagerProperties(); |
1158 EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice( | 1058 EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice( |
1159 kShillManagerClientStubWifiDevice)); | 1059 kShillManagerClientStubWifiDevice)); |
1160 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService( | 1060 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService( |
1161 kShillManagerClientStubDefaultWifi)); | 1061 kShillManagerClientStubDefaultWifi)); |
1162 } | 1062 } |
1163 | 1063 |
1164 } // namespace chromeos | 1064 } // namespace chromeos |
OLD | NEW |