#include <wifi_system_test/mock_interface_tool.h>
#include <wifi_system_test/mock_supplicant_manager.h>
+#include "wificond/scanning/offload/offload_scan_utils.h"
#include "wificond/scanning/scanner_impl.h"
#include "wificond/tests/mock_client_interface_impl.h"
#include "wificond/tests/mock_netlink_manager.h"
#include "wificond/tests/mock_offload_scan_manager.h"
#include "wificond/tests/mock_offload_service_utils.h"
#include "wificond/tests/mock_scan_utils.h"
+#include "wificond/tests/offload_test_utils.h"
using ::android::binder::Status;
using ::android::wifi_system::MockInterfaceTool;
using ::com::android::server::wifi::wificond::SingleScanSettings;
using ::com::android::server::wifi::wificond::PnoSettings;
using ::com::android::server::wifi::wificond::NativeScanResult;
+using android::hardware::wifi::offload::V1_0::ScanResult;
using ::testing::Invoke;
using ::testing::NiceMock;
using ::testing::Return;
return true;
}
+bool ReturnOffloadScanResults(
+ std::vector<NativeScanResult>* native_scan_results_,
+ const std::vector<ScanResult>& offload_scan_results) {
+ return OffloadScanUtils::convertToNativeScanResults(offload_scan_results,
+ native_scan_results_);
+}
+
+bool ReturnNetlinkScanResults(
+ uint32_t interface_index,
+ std::vector<NativeScanResult>* native_scan_results_,
+ const std::vector<ScanResult>& offload_scan_results) {
+ return OffloadScanUtils::convertToNativeScanResults(offload_scan_results,
+ native_scan_results_);
+}
+
} // namespace
class ScannerTest : public ::testing::Test {
protected:
void SetUp() override {
- ON_CALL(*offload_service_utils_, IsOffloadScanSupported()).WillByDefault(
- Return(false));
- ON_CALL(*offload_service_utils_, GetOffloadScanManager(_, _))
- .WillByDefault(Return(offload_scan_manager_));
- ON_CALL(*offload_service_utils_, GetOffloadScanCallbackInterface(_))
- .WillByDefault(Return(offload_scan_callback_interface_));
- netlink_scanner_.reset(new ScannerImpl(
- kFakeWiphyIndex, kFakeInterfaceIndex,
- scan_capabilities_, wiphy_features_,
- &client_interface_impl_,
- &netlink_utils_, &scan_utils_, offload_service_utils_));
+ ON_CALL(*offload_service_utils_, GetOffloadScanManager(_, _))
+ .WillByDefault(Return(offload_scan_manager_));
+ ON_CALL(*offload_service_utils_, GetOffloadScanCallbackInterface(_))
+ .WillByDefault(Return(offload_scan_callback_interface_));
+ dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults();
}
- unique_ptr<ScannerImpl> netlink_scanner_;
+ void TearDown() override { dummy_scan_results_.clear(); }
+
+ unique_ptr<ScannerImpl> scanner_impl_;
NiceMock<MockNetlinkManager> netlink_manager_;
NiceMock<MockNetlinkUtils> netlink_utils_{&netlink_manager_};
NiceMock<MockScanUtils> scan_utils_{&netlink_manager_};
shared_ptr<NiceMock<MockOffloadScanCallbackInterfaceImpl>>
offload_scan_callback_interface_{
new NiceMock<MockOffloadScanCallbackInterfaceImpl>(
- netlink_scanner_.get())};
+ scanner_impl_.get())};
std::shared_ptr<NiceMock<MockOffloadScanManager>> offload_scan_manager_{
new NiceMock<MockOffloadScanManager>(offload_service_utils_,
offload_scan_callback_interface_)};
ScanCapabilities scan_capabilities_;
WiphyFeatures wiphy_features_;
+ std::vector<ScanResult> dummy_scan_results_;
};
TEST_F(ScannerTest, TestSingleScan) {
EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _)).WillOnce(Return(true));
bool success = false;
- EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(), &success).isOk());
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
+ EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk());
EXPECT_TRUE(success);
}
TEST_F(ScannerTest, TestSingleScanFailure) {
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
EXPECT_CALL(
scan_utils_,
Scan(_, _, _, _, _)).
ReturnErrorCodeForScanRequest, EBUSY, _1, _2, _3, _4, _5)));
bool success = false;
- EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(), &success).isOk());
+ EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk());
EXPECT_FALSE(success);
}
TEST_F(ScannerTest, TestProcessAbortsOnScanReturningNoDeviceError) {
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
ON_CALL(
scan_utils_,
Scan(_, _, _, _, _)).
ReturnErrorCodeForScanRequest, ENODEV, _1, _2, _3, _4, _5)));
bool success_ignored;
- EXPECT_DEATH(
- netlink_scanner_->scan(SingleScanSettings(), &success_ignored),
- "Driver is in a bad state*");
+ EXPECT_DEATH(scanner_impl_->scan(SingleScanSettings(), &success_ignored),
+ "Driver is in a bad state*");
}
TEST_F(ScannerTest, TestAbortScan) {
bool single_scan_success = false;
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _)).WillOnce(Return(true));
- EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(),
- &single_scan_success).isOk());
+ EXPECT_TRUE(
+ scanner_impl_->scan(SingleScanSettings(), &single_scan_success).isOk());
EXPECT_TRUE(single_scan_success);
EXPECT_CALL(scan_utils_, AbortScan(_));
- EXPECT_TRUE(netlink_scanner_->abortScan().isOk());
+ EXPECT_TRUE(scanner_impl_->abortScan().isOk());
}
TEST_F(ScannerTest, TestAbortScanNotIssuedIfNoOngoingScan) {
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
EXPECT_CALL(scan_utils_, AbortScan(_)).Times(0);
- EXPECT_TRUE(netlink_scanner_->abortScan().isOk());
+ EXPECT_TRUE(scanner_impl_->abortScan().isOk());
}
TEST_F(ScannerTest, TestGetScanResults) {
vector<NativeScanResult> scan_results;
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
EXPECT_CALL(scan_utils_, GetScanResult(_, _)).WillOnce(Return(true));
- EXPECT_TRUE(netlink_scanner_->getScanResults(&scan_results).isOk());
+ EXPECT_TRUE(scanner_impl_->getScanResults(&scan_results).isOk());
}
TEST_F(ScannerTest, TestStartPnoScanViaNetlink) {
bool success = false;
+ EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+ .Times(1)
+ .WillRepeatedly(Return(false));
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _)).
WillOnce(Return(true));
- EXPECT_TRUE(netlink_scanner_->startPnoScan(PnoSettings(), &success).isOk());
+ EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk());
EXPECT_TRUE(success);
}
TEST_F(ScannerTest, TestStopPnoScanViaNetlink) {
bool success = false;
+ EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+ .Times(1)
+ .WillRepeatedly(Return(false));
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
// StopScheduledScan() will be called no matter if there is an ongoing
// scheduled scan or not. This is for making the system more robust.
EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
- EXPECT_TRUE(netlink_scanner_->stopPnoScan(&success).isOk());
+ EXPECT_TRUE(scanner_impl_->stopPnoScan(&success).isOk());
+ EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestStartScanOverOffload) {
+ bool success = false;
+ EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, stopScan(_))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
+ scanner_impl_->startPnoScan(PnoSettings(), &success);
+ EXPECT_TRUE(success);
+ scanner_impl_->stopPnoScan(&success);
+ EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestStartScanOverNetlinkFallback) {
+ bool success = false;
+ ON_CALL(*offload_service_utils_, IsOffloadScanSupported())
+ .WillByDefault(Return(true));
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
+ EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+ .WillOnce(Return(false));
+ EXPECT_CALL(*offload_scan_manager_, stopScan(_)).Times(0);
+ EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _))
+ .WillOnce(Return(true));
+ EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
+ EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk());
+ EXPECT_TRUE(success == true);
+ scanner_impl_->stopPnoScan(&success);
+ EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestAsyncErrorOverOffload) {
+ bool success = false;
+ EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, stopScan(_))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
+ EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _))
+ .WillOnce(Return(true));
+ EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
+ scanner_impl_->startPnoScan(PnoSettings(), &success);
+ EXPECT_TRUE(success);
+ scanner_impl_->OnOffloadError(
+ OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE);
+ scanner_impl_->stopPnoScan(&success);
+ EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestGetScanResultsFromOffload) {
+ bool success = false;
+ EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, getScanResults(_))
+ .Times(1)
+ .WillOnce(
+ Invoke(bind(ReturnOffloadScanResults, _1, dummy_scan_results_)));
+ EXPECT_CALL(*offload_scan_manager_, stopScan(_))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
+ scanner_impl_->startPnoScan(PnoSettings(), &success);
+ EXPECT_TRUE(success);
+ scanner_impl_->OnOffloadScanResult();
+ std::vector<NativeScanResult> scan_results;
+ EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk());
+ EXPECT_FALSE(scan_results.empty());
+ scanner_impl_->stopPnoScan(&success);
+ EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestGetScanResultsWhenOffloadFails) {
+ bool success = false;
+ EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, stopScan(_))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*offload_scan_manager_, getScanResults(_)).Times(0);
+ EXPECT_CALL(scan_utils_, GetScanResult(_, _))
+ .Times(1)
+ .WillOnce(
+ Invoke(bind(ReturnNetlinkScanResults, _1, _2, dummy_scan_results_)));
+ scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+ scan_capabilities_, wiphy_features_,
+ &client_interface_impl_, &netlink_utils_,
+ &scan_utils_, offload_service_utils_));
+ EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _))
+ .WillOnce(Return(true));
+ EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
+ EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk());
+ EXPECT_TRUE(success);
+ scanner_impl_->OnOffloadError(
+ OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE);
+ std::vector<NativeScanResult> scan_results;
+ EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk());
+ EXPECT_FALSE(scan_results.empty());
+ scanner_impl_->stopPnoScan(&success);
EXPECT_TRUE(success);
}