1// 2// Copyright (C) 2012 The Android Open Source Project 3// 4// Licensed under the Apache License, Version 2.0 (the "License"); 5// you may not use this file except in compliance with the License. 6// You may obtain a copy of the License at 7// 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// See the License for the specific language governing permissions and 14// limitations under the License. 15// 16 17#include "shill/ethernet/ethernet_service.h" 18 19#include <gmock/gmock.h> 20#include <gtest/gtest.h> 21 22#include "shill/ethernet/mock_ethernet.h" 23#include "shill/mock_adaptors.h" 24#include "shill/mock_manager.h" 25#include "shill/mock_store.h" 26#include "shill/property_store_unittest.h" 27#include "shill/refptr_types.h" 28#include "shill/service_property_change_test.h" 29 30using ::testing::_; 31using ::testing::NiceMock; 32using ::testing::Return; 33 34namespace shill { 35 36class EthernetServiceTest : public PropertyStoreTest { 37 public: 38 EthernetServiceTest() 39 : mock_manager_(control_interface(), dispatcher(), metrics()), 40 ethernet_( 41 new NiceMock<MockEthernet>(control_interface(), 42 dispatcher(), 43 metrics(), 44 &mock_manager_, 45 "ethernet", 46 fake_mac, 47 0)), 48 service_( 49 new EthernetService(control_interface(), 50 dispatcher(), 51 metrics(), 52 &mock_manager_, 53 ethernet_->weak_ptr_factory_.GetWeakPtr())) {} 54 ~EthernetServiceTest() override {} 55 56 protected: 57 static const char fake_mac[]; 58 59 bool GetAutoConnect() { 60 return service_->GetAutoConnect(nullptr); 61 } 62 63 bool SetAutoConnect(const bool connect, Error* error) { 64 return service_->SetAutoConnectFull(connect, error); 65 } 66 67 ServiceMockAdaptor* GetAdaptor() { 68 return static_cast<ServiceMockAdaptor*>(service_->adaptor()); 69 } 70 71 MockManager mock_manager_; 72 scoped_refptr<MockEthernet> ethernet_; 73 EthernetServiceRefPtr service_; 74}; 75 76// static 77const char EthernetServiceTest::fake_mac[] = "AaBBcCDDeeFF"; 78 79TEST_F(EthernetServiceTest, AutoConnect) { 80 EXPECT_TRUE(service_->IsAutoConnectByDefault()); 81 EXPECT_TRUE(GetAutoConnect()); 82 { 83 Error error; 84 SetAutoConnect(false, &error); 85 EXPECT_FALSE(error.IsSuccess()); 86 } 87 EXPECT_TRUE(GetAutoConnect()); 88 { 89 Error error; 90 SetAutoConnect(true, &error); 91 EXPECT_TRUE(error.IsSuccess()); 92 } 93 EXPECT_TRUE(GetAutoConnect()); 94} 95 96TEST_F(EthernetServiceTest, ConnectDisconnectDelegation) { 97 EXPECT_CALL(*ethernet_, link_up()).WillRepeatedly(Return(true)); 98 EXPECT_CALL(*ethernet_, ConnectTo(service_.get())); 99 service_->AutoConnect(); 100 EXPECT_CALL(*ethernet_, DisconnectFrom(service_.get())); 101 Error error; 102 service_->Disconnect(&error, "in test"); 103} 104 105TEST_F(EthernetServiceTest, PropertyChanges) { 106 TestCommonPropertyChanges(service_, GetAdaptor()); 107} 108 109// Custom property setters should return false, and make no changes, if 110// the new value is the same as the old value. 111TEST_F(EthernetServiceTest, CustomSetterNoopChange) { 112 TestCustomSetterNoopChange(service_, &mock_manager_); 113} 114 115TEST_F(EthernetServiceTest, LoadAutoConnect) { 116 // Make sure when we try to load an Ethernet service, it sets AutoConnect 117 // to be true even if the property is not found. 118 NiceMock<MockStore> mock_store; 119 EXPECT_CALL(mock_store, ContainsGroup(_)).WillRepeatedly(Return(true)); 120 EXPECT_CALL(mock_store, GetBool(_, _, _)).WillRepeatedly(Return(false)); 121 EXPECT_TRUE(service_->Load(&mock_store)); 122 EXPECT_TRUE(GetAutoConnect()); 123} 124 125TEST_F(EthernetServiceTest, GetTethering) { 126 EXPECT_CALL(*ethernet_, IsConnectedViaTether()) 127 .WillOnce(Return(true)) 128 .WillOnce(Return(false)); 129 EXPECT_EQ(kTetheringConfirmedState, service_->GetTethering(nullptr)); 130 EXPECT_EQ(kTetheringNotDetectedState, service_->GetTethering(nullptr)); 131} 132 133TEST_F(EthernetServiceTest, IsVisible) { 134 EXPECT_CALL(*ethernet_, link_up()) 135 .WillOnce(Return(false)) 136 .WillOnce(Return(true)); 137 EXPECT_FALSE(service_->IsVisible()); 138 EXPECT_TRUE(service_->IsVisible()); 139} 140 141TEST_F(EthernetServiceTest, IsAutoConnectable) { 142 EXPECT_CALL(*ethernet_, link_up()) 143 .WillOnce(Return(false)) 144 .WillOnce(Return(true)); 145 const char* reason; 146 EXPECT_FALSE(service_->IsAutoConnectable(&reason)); 147 EXPECT_STREQ("no carrier", reason); 148 EXPECT_TRUE(service_->IsAutoConnectable(nullptr)); 149} 150 151} // namespace shill 152