151 lines
4.7 KiB
C++
151 lines
4.7 KiB
C++
//
|
|
// Copyright (C) 2012 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
#include "shill/ethernet/ethernet_service.h"
|
|
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "shill/ethernet/mock_ethernet.h"
|
|
#include "shill/mock_adaptors.h"
|
|
#include "shill/mock_manager.h"
|
|
#include "shill/mock_store.h"
|
|
#include "shill/property_store_unittest.h"
|
|
#include "shill/refptr_types.h"
|
|
#include "shill/service_property_change_test.h"
|
|
|
|
using ::testing::_;
|
|
using ::testing::NiceMock;
|
|
using ::testing::Return;
|
|
|
|
namespace shill {
|
|
|
|
class EthernetServiceTest : public PropertyStoreTest {
|
|
public:
|
|
EthernetServiceTest()
|
|
: mock_manager_(control_interface(), dispatcher(), metrics()),
|
|
ethernet_(
|
|
new NiceMock<MockEthernet>(control_interface(),
|
|
dispatcher(),
|
|
metrics(),
|
|
&mock_manager_,
|
|
"ethernet",
|
|
fake_mac,
|
|
0)),
|
|
service_(
|
|
new EthernetService(control_interface(),
|
|
dispatcher(),
|
|
metrics(),
|
|
&mock_manager_,
|
|
ethernet_->weak_ptr_factory_.GetWeakPtr())) {}
|
|
~EthernetServiceTest() override {}
|
|
|
|
protected:
|
|
static const char fake_mac[];
|
|
|
|
bool GetAutoConnect() {
|
|
return service_->GetAutoConnect(nullptr);
|
|
}
|
|
|
|
bool SetAutoConnect(const bool connect, Error* error) {
|
|
return service_->SetAutoConnectFull(connect, error);
|
|
}
|
|
|
|
ServiceMockAdaptor* GetAdaptor() {
|
|
return static_cast<ServiceMockAdaptor*>(service_->adaptor());
|
|
}
|
|
|
|
MockManager mock_manager_;
|
|
scoped_refptr<MockEthernet> ethernet_;
|
|
EthernetServiceRefPtr service_;
|
|
};
|
|
|
|
// static
|
|
const char EthernetServiceTest::fake_mac[] = "AaBBcCDDeeFF";
|
|
|
|
TEST_F(EthernetServiceTest, AutoConnect) {
|
|
EXPECT_TRUE(service_->IsAutoConnectByDefault());
|
|
EXPECT_TRUE(GetAutoConnect());
|
|
{
|
|
Error error;
|
|
SetAutoConnect(false, &error);
|
|
EXPECT_FALSE(error.IsSuccess());
|
|
}
|
|
EXPECT_TRUE(GetAutoConnect());
|
|
{
|
|
Error error;
|
|
SetAutoConnect(true, &error);
|
|
EXPECT_TRUE(error.IsSuccess());
|
|
}
|
|
EXPECT_TRUE(GetAutoConnect());
|
|
}
|
|
|
|
TEST_F(EthernetServiceTest, ConnectDisconnectDelegation) {
|
|
EXPECT_CALL(*ethernet_, link_up()).WillRepeatedly(Return(true));
|
|
EXPECT_CALL(*ethernet_, ConnectTo(service_.get()));
|
|
service_->AutoConnect();
|
|
EXPECT_CALL(*ethernet_, DisconnectFrom(service_.get()));
|
|
Error error;
|
|
service_->Disconnect(&error, "in test");
|
|
}
|
|
|
|
TEST_F(EthernetServiceTest, PropertyChanges) {
|
|
TestCommonPropertyChanges(service_, GetAdaptor());
|
|
}
|
|
|
|
// Custom property setters should return false, and make no changes, if
|
|
// the new value is the same as the old value.
|
|
TEST_F(EthernetServiceTest, CustomSetterNoopChange) {
|
|
TestCustomSetterNoopChange(service_, &mock_manager_);
|
|
}
|
|
|
|
TEST_F(EthernetServiceTest, LoadAutoConnect) {
|
|
// Make sure when we try to load an Ethernet service, it sets AutoConnect
|
|
// to be true even if the property is not found.
|
|
NiceMock<MockStore> mock_store;
|
|
EXPECT_CALL(mock_store, ContainsGroup(_)).WillRepeatedly(Return(true));
|
|
EXPECT_CALL(mock_store, GetBool(_, _, _)).WillRepeatedly(Return(false));
|
|
EXPECT_TRUE(service_->Load(&mock_store));
|
|
EXPECT_TRUE(GetAutoConnect());
|
|
}
|
|
|
|
TEST_F(EthernetServiceTest, GetTethering) {
|
|
EXPECT_CALL(*ethernet_, IsConnectedViaTether())
|
|
.WillOnce(Return(true))
|
|
.WillOnce(Return(false));
|
|
EXPECT_EQ(kTetheringConfirmedState, service_->GetTethering(nullptr));
|
|
EXPECT_EQ(kTetheringNotDetectedState, service_->GetTethering(nullptr));
|
|
}
|
|
|
|
TEST_F(EthernetServiceTest, IsVisible) {
|
|
EXPECT_CALL(*ethernet_, link_up())
|
|
.WillOnce(Return(false))
|
|
.WillOnce(Return(true));
|
|
EXPECT_FALSE(service_->IsVisible());
|
|
EXPECT_TRUE(service_->IsVisible());
|
|
}
|
|
|
|
TEST_F(EthernetServiceTest, IsAutoConnectable) {
|
|
EXPECT_CALL(*ethernet_, link_up())
|
|
.WillOnce(Return(false))
|
|
.WillOnce(Return(true));
|
|
const char* reason;
|
|
EXPECT_FALSE(service_->IsAutoConnectable(&reason));
|
|
EXPECT_STREQ("no carrier", reason);
|
|
EXPECT_TRUE(service_->IsAutoConnectable(nullptr));
|
|
}
|
|
|
|
} // namespace shill
|