1 /* 2 * Copyright (C) 2016, 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 <memory> 18 #include <vector> 19 20 #include <gmock/gmock.h> 21 #include <gtest/gtest.h> 22 #include <wifi_system_test/mock_hostapd_manager.h> 23 #include <wifi_system_test/mock_interface_tool.h> 24 25 #include "wificond/tests/mock_ap_interface_event_callback.h" 26 #include "wificond/tests/mock_netlink_manager.h" 27 #include "wificond/tests/mock_netlink_utils.h" 28 29 #include "wificond/ap_interface_impl.h" 30 31 using android::wifi_system::HostapdManager; 32 using android::wifi_system::MockHostapdManager; 33 using android::wifi_system::MockInterfaceTool; 34 using std::placeholders::_1; 35 using std::placeholders::_2; 36 using std::unique_ptr; 37 using std::vector; 38 using testing::NiceMock; 39 using testing::Invoke; 40 using testing::Return; 41 using testing::Sequence; 42 using testing::StrEq; 43 using testing::_; 44 45 namespace android { 46 namespace wificond { 47 namespace { 48 49 const char kTestInterfaceName[] = "testwifi0"; 50 const uint32_t kTestInterfaceIndex = 42; 51 const uint8_t kFakeMacAddress[] = {0x45, 0x54, 0xad, 0x67, 0x98, 0xf6}; 52 53 void CaptureStationEventHandler( 54 OnStationEventHandler* out_handler, 55 uint32_t interface_index, 56 OnStationEventHandler handler) { 57 *out_handler = handler; 58 } 59 60 void CaptureChannelSwitchEventHandler( 61 OnChannelSwitchEventHandler* out_handler, 62 uint32_t interface_index, 63 OnChannelSwitchEventHandler handler) { 64 *out_handler = handler; 65 } 66 67 class ApInterfaceImplTest : public ::testing::Test { 68 protected: 69 unique_ptr<NiceMock<MockInterfaceTool>> if_tool_{ 70 new NiceMock<MockInterfaceTool>}; 71 unique_ptr<NiceMock<MockHostapdManager>> hostapd_manager_{ 72 new NiceMock<MockHostapdManager>}; 73 unique_ptr<NiceMock<MockNetlinkManager>> netlink_manager_{ 74 new NiceMock<MockNetlinkManager>()}; 75 unique_ptr<NiceMock<MockNetlinkUtils>> netlink_utils_{ 76 new NiceMock<MockNetlinkUtils>(netlink_manager_.get())}; 77 78 unique_ptr<ApInterfaceImpl> ap_interface_; 79 80 void SetUp() override { 81 ap_interface_.reset(new ApInterfaceImpl( 82 kTestInterfaceName, 83 kTestInterfaceIndex, 84 netlink_utils_.get(), 85 if_tool_.get(), 86 hostapd_manager_.get())); 87 } 88 }; // class ApInterfaceImplTest 89 90 } // namespace 91 92 TEST_F(ApInterfaceImplTest, ShouldReportStartFailure) { 93 EXPECT_CALL(*hostapd_manager_, StartHostapd()) 94 .WillOnce(Return(false)); 95 EXPECT_FALSE(ap_interface_->StartHostapd()); 96 } 97 98 TEST_F(ApInterfaceImplTest, ShouldReportStartSuccess) { 99 EXPECT_CALL(*hostapd_manager_, StartHostapd()) 100 .WillOnce(Return(true)); 101 EXPECT_TRUE(ap_interface_->StartHostapd()); 102 } 103 104 TEST_F(ApInterfaceImplTest, ShouldReportStopFailure) { 105 EXPECT_CALL(*hostapd_manager_, StopHostapd()) 106 .WillOnce(Return(false)); 107 EXPECT_FALSE(ap_interface_->StopHostapd()); 108 } 109 110 TEST_F(ApInterfaceImplTest, ShouldReportStopSuccess) { 111 EXPECT_CALL(*hostapd_manager_, StopHostapd()) 112 .WillOnce(Return(true)); 113 EXPECT_CALL(*if_tool_, SetUpState(StrEq(kTestInterfaceName), false)) 114 .WillOnce(Return(true)); 115 EXPECT_CALL(*netlink_utils_, SetInterfaceMode( 116 kTestInterfaceIndex, 117 NetlinkUtils::STATION_MODE)).WillOnce(Return(true)); 118 EXPECT_TRUE(ap_interface_->StopHostapd()); 119 testing::Mock::VerifyAndClearExpectations(if_tool_.get()); 120 } 121 122 TEST_F(ApInterfaceImplTest, CanGetNumberOfAssociatedStations) { 123 OnStationEventHandler handler; 124 EXPECT_CALL(*netlink_utils_, 125 SubscribeStationEvent(kTestInterfaceIndex, _)). 126 WillOnce(Invoke(bind(CaptureStationEventHandler, &handler, _1, _2))); 127 128 ap_interface_.reset(new ApInterfaceImpl( 129 kTestInterfaceName, 130 kTestInterfaceIndex, 131 netlink_utils_.get(), 132 if_tool_.get(), 133 hostapd_manager_.get())); 134 135 vector<uint8_t> fake_mac_address(kFakeMacAddress, 136 kFakeMacAddress + sizeof(kFakeMacAddress)); 137 EXPECT_EQ(0, ap_interface_->GetNumberOfAssociatedStations()); 138 handler(NEW_STATION, fake_mac_address); 139 EXPECT_EQ(1, ap_interface_->GetNumberOfAssociatedStations()); 140 handler(NEW_STATION, fake_mac_address); 141 EXPECT_EQ(2, ap_interface_->GetNumberOfAssociatedStations()); 142 handler(DEL_STATION, fake_mac_address); 143 EXPECT_EQ(1, ap_interface_->GetNumberOfAssociatedStations()); 144 } 145 146 TEST_F(ApInterfaceImplTest, CallbackIsCalledOnNumAssociatedStationsChanged) { 147 OnStationEventHandler handler; 148 EXPECT_CALL(*netlink_utils_, SubscribeStationEvent(kTestInterfaceIndex, _)) 149 .WillOnce(Invoke(bind(CaptureStationEventHandler, &handler, _1, _2))); 150 ap_interface_.reset(new ApInterfaceImpl( 151 kTestInterfaceName, kTestInterfaceIndex, netlink_utils_.get(), 152 if_tool_.get(), hostapd_manager_.get())); 153 154 EXPECT_CALL(*hostapd_manager_, StartHostapd()).WillOnce(Return(true)); 155 auto binder = ap_interface_->GetBinder(); 156 sp<MockApInterfaceEventCallback> callback(new MockApInterfaceEventCallback()); 157 bool out_success = false; 158 EXPECT_TRUE(binder->startHostapd(callback, &out_success).isOk()); 159 EXPECT_TRUE(out_success); 160 161 vector<uint8_t> fake_mac_address(kFakeMacAddress, 162 kFakeMacAddress + sizeof(kFakeMacAddress)); 163 EXPECT_CALL(*callback, onNumAssociatedStationsChanged(1)); 164 handler(NEW_STATION, fake_mac_address); 165 EXPECT_CALL(*callback, onNumAssociatedStationsChanged(2)); 166 handler(NEW_STATION, fake_mac_address); 167 EXPECT_CALL(*callback, onNumAssociatedStationsChanged(1)); 168 handler(DEL_STATION, fake_mac_address); 169 } 170 171 TEST_F(ApInterfaceImplTest, CallbackIsCalledOnSoftApChannelSwitched) { 172 OnChannelSwitchEventHandler handler; 173 EXPECT_CALL(*netlink_utils_, SubscribeChannelSwitchEvent(kTestInterfaceIndex, _)) 174 .WillOnce(Invoke(bind(CaptureChannelSwitchEventHandler, &handler, _1, _2))); 175 ap_interface_.reset(new ApInterfaceImpl( 176 kTestInterfaceName, kTestInterfaceIndex, netlink_utils_.get(), 177 if_tool_.get(), hostapd_manager_.get())); 178 179 EXPECT_CALL(*hostapd_manager_, StartHostapd()).WillOnce(Return(true)); 180 auto binder = ap_interface_->GetBinder(); 181 sp<MockApInterfaceEventCallback> callback(new MockApInterfaceEventCallback()); 182 bool out_success = false; 183 EXPECT_TRUE(binder->startHostapd(callback, &out_success).isOk()); 184 EXPECT_TRUE(out_success); 185 186 const uint32_t kTestChannelFrequency = 2437; 187 const ChannelBandwidth kTestChannelBandwidth = ChannelBandwidth::BW_20; 188 EXPECT_CALL(*callback, onSoftApChannelSwitched(kTestChannelFrequency, 189 kTestChannelBandwidth)); 190 handler(kTestChannelFrequency, kTestChannelBandwidth); 191 } 192 193 } // namespace wificond 194 } // namespace android 195
