You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
447 lines
20 KiB
447 lines
20 KiB
/* |
|
* Copyright (C) 2016, 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 <functional> |
|
#include <memory> |
|
#include <string> |
|
#include <vector> |
|
|
|
#include <android/hardware/wifi/offload/1.0/IOffload.h> |
|
#include <gtest/gtest.h> |
|
|
|
#include "wificond/tests/mock_offload.h" |
|
#include "wificond/tests/mock_offload_scan_callback_interface.h" |
|
#include "wificond/tests/mock_offload_service_utils.h" |
|
#include "wificond/tests/offload_hal_test_constants.h" |
|
#include "wificond/tests/offload_test_utils.h" |
|
|
|
#include "wificond/scanning/offload/offload_callback.h" |
|
#include "wificond/scanning/offload/offload_callback_handlers.h" |
|
#include "wificond/scanning/offload/offload_scan_manager.h" |
|
#include "wificond/scanning/scan_result.h" |
|
|
|
using android::hardware::Return; |
|
using android::hardware::Void; |
|
using android::hardware::wifi::offload::V1_0::IOffload; |
|
using android::hardware::wifi::offload::V1_0::ScanResult; |
|
using android::hardware::wifi::offload::V1_0::OffloadStatus; |
|
using android::hardware::wifi::offload::V1_0::OffloadStatusCode; |
|
using android::hardware::wifi::offload::V1_0::ScanParam; |
|
using android::hardware::wifi::offload::V1_0::ScanFilter; |
|
using android::hardware::wifi::offload::V1_0::ScanStats; |
|
using android::sp; |
|
using com::android::server::wifi::wificond::NativeScanResult; |
|
using com::android::server::wifi::wificond::NativeScanStats; |
|
using testing::NiceMock; |
|
using testing::_; |
|
using testing::Invoke; |
|
using std::shared_ptr; |
|
using std::unique_ptr; |
|
using std::vector; |
|
using std::bind; |
|
|
|
using namespace std::placeholders; |
|
using namespace android::wificond::offload_hal_test_constants; |
|
|
|
namespace android { |
|
namespace wificond { |
|
|
|
sp<OffloadCallback> CaptureCallback(OffloadCallbackHandlers* handler, |
|
sp<OffloadCallback>* offload_callback) { |
|
*offload_callback = sp<OffloadCallback>(new OffloadCallback(handler)); |
|
return *offload_callback; |
|
} |
|
|
|
OffloadDeathRecipient* CaptureDeathRecipient( |
|
OffloadDeathRecipientHandler handler, |
|
sp<OffloadDeathRecipient>* death_recipient_) { |
|
OffloadDeathRecipient* death_recipient = new OffloadDeathRecipient(handler); |
|
*death_recipient_ = sp<OffloadDeathRecipient>(death_recipient); |
|
return death_recipient; |
|
} |
|
|
|
Return<void> HidlStatusReturn(android::wificond::StatusCallback cb, |
|
OffloadStatus* status) { |
|
cb(*status); |
|
return Void(); |
|
} |
|
|
|
Return<void> ScanStatusReturn(android::wificond::OnScanStatsCallback cb, |
|
OffloadStatus* status) { |
|
ScanStats stats; |
|
cb(*status, stats); |
|
return Void(); |
|
} |
|
|
|
class OffloadScanManagerTest : public ::testing::Test { |
|
protected: |
|
virtual void SetUp() { |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)) |
|
.WillByDefault(Invoke(bind(CaptureCallback, _1, &offload_callback_))); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)) |
|
.WillByDefault( |
|
Invoke(bind(CaptureDeathRecipient, _1, &death_recipient_))); |
|
status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::OK); |
|
ON_CALL(*mock_offload_, configureScans(_, _, _)) |
|
.WillByDefault(Invoke(bind(HidlStatusReturn, _3, &status))); |
|
ON_CALL(*mock_offload_, subscribeScanResults(_, _)) |
|
.WillByDefault(Invoke(bind(HidlStatusReturn, _2, &status))); |
|
ON_CALL(*mock_offload_, getScanStats(_)) |
|
.WillByDefault(Invoke(bind(ScanStatusReturn, _1, &status))); |
|
} |
|
|
|
void TearDown() override { |
|
offload_callback_.clear(); |
|
death_recipient_.clear(); |
|
} |
|
|
|
sp<NiceMock<MockOffload>> mock_offload_{new NiceMock<MockOffload>()}; |
|
sp<OffloadCallback> offload_callback_; |
|
sp<OffloadDeathRecipient> death_recipient_; |
|
shared_ptr<NiceMock<MockOffloadServiceUtils>> mock_offload_service_utils_{ |
|
new NiceMock<MockOffloadServiceUtils>()}; |
|
shared_ptr<NiceMock<MockOffloadScanCallbackInterface>> |
|
mock_offload_scan_callback_interface_{ |
|
new NiceMock<MockOffloadScanCallbackInterface>()}; |
|
unique_ptr<OffloadScanManager> offload_scan_manager_; |
|
OffloadStatus status; |
|
vector<vector<uint8_t>> scan_ssids{kSsid1, kSsid2}; |
|
vector<vector<uint8_t>> match_ssids{kSsid1, kSsid2}; |
|
vector<uint8_t> security_flags{kNetworkFlags, kNetworkFlags}; |
|
vector<uint32_t> frequencies{kFrequency1, kFrequency2}; |
|
uint64_t cookie_ = reinterpret_cast<uint64_t>(mock_offload_.get()); |
|
}; |
|
|
|
/** |
|
* Testing OffloadScanManager for binder death with registered cookie |
|
*/ |
|
TEST_F(OffloadScanManagerTest, BinderDeathRegisteredCookieAndService) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_CALL(*mock_offload_scan_callback_interface_, OnOffloadError(_)); |
|
death_recipient_->serviceDied(cookie_, mock_offload_); |
|
EXPECT_EQ(OffloadScanManager::kNoService, |
|
offload_scan_manager_->getOffloadStatus()); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for binder death with invalid cookie |
|
*/ |
|
TEST_F(OffloadScanManagerTest, BinderDeathUnregisteredCookie) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
death_recipient_->serviceDied(kDeathCode, mock_offload_); |
|
EXPECT_FALSE(OffloadScanManager::kNoService == |
|
offload_scan_manager_->getOffloadStatus()); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager with no handle on Offloal HAL service |
|
* and no registered handler for Offload Scan results |
|
*/ |
|
TEST_F(OffloadScanManagerTest, ServiceNotAvailableTest) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(nullptr)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_EQ(OffloadScanManager::kNoService, |
|
offload_scan_manager_->getOffloadStatus()); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager when service is available and valid handler |
|
* registered for Offload Scan results |
|
*/ |
|
TEST_F(OffloadScanManagerTest, ServiceAvailableTest) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_EQ(OffloadScanManager::kNoError, |
|
offload_scan_manager_->getOffloadStatus()); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager when service is available and valid handler |
|
* is registered, test to ensure that registered handler is invoked when |
|
* scan results are available |
|
*/ |
|
TEST_F(OffloadScanManagerTest, CallbackInvokedTest) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
EXPECT_CALL(*mock_offload_scan_callback_interface_, OnOffloadScanResult()); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
vector<ScanResult> dummy_scan_results_ = |
|
OffloadTestUtils::createOffloadScanResults(); |
|
offload_callback_->onScanResult(dummy_scan_results_); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager when service is available and valid handler |
|
* is registered, ensure that error callback is invoked |
|
*/ |
|
TEST_F(OffloadScanManagerTest, ErrorCallbackInvokedTest) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
OffloadStatus status = |
|
OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR); |
|
EXPECT_CALL(*mock_offload_scan_callback_interface_, OnOffloadError(_)); |
|
offload_callback_->onError(status); |
|
EXPECT_EQ(offload_scan_manager_->getOffloadStatus(), |
|
OffloadScanManager::kError); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for subscribing to the scan results from |
|
* Offload HAL when service is running without errors |
|
*/ |
|
TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsOk) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); |
|
EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); |
|
OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
|
bool result = offload_scan_manager_->startScan( |
|
kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
|
security_flags, frequencies, &reason_code); |
|
EXPECT_EQ(result, true); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for subscribing to the scan results from |
|
* Offload HAL when service is not available |
|
*/ |
|
TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotAvailable) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()).Times(2); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(nullptr)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
|
bool result = offload_scan_manager_->startScan( |
|
kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
|
security_flags, frequencies, &reason_code); |
|
EXPECT_EQ(result, false); |
|
EXPECT_EQ(reason_code, OffloadScanManager::kNotAvailable); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for subscribing to the scan results from |
|
* Offload HAL when service is not working correctly |
|
*/ |
|
TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotConnected) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
OffloadStatus status = |
|
OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); |
|
offload_callback_->onError(status); |
|
OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
|
bool result = offload_scan_manager_->startScan( |
|
kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
|
security_flags, frequencies, &reason_code); |
|
EXPECT_EQ(result, false); |
|
EXPECT_EQ(reason_code, OffloadScanManager::kNotAvailable); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for subscribing to the scan results from |
|
* Offload HAL twice when service is okay |
|
*/ |
|
TEST_F(OffloadScanManagerTest, StartScanTwiceTestWhenServiceIsOk) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(2); |
|
EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(2); |
|
OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
|
bool result = offload_scan_manager_->startScan( |
|
kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
|
security_flags, frequencies, &reason_code); |
|
EXPECT_EQ(result, true); |
|
result = offload_scan_manager_->startScan( |
|
kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
|
security_flags, frequencies, &reason_code); |
|
EXPECT_EQ(result, true); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for unsubscribing to the scan results from |
|
* Offload HAL when service is ok |
|
*/ |
|
TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsOk) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); |
|
EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); |
|
EXPECT_CALL(*mock_offload_, unsubscribeScanResults()); |
|
OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
|
bool result = offload_scan_manager_->startScan( |
|
kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
|
security_flags, frequencies, &reason_code); |
|
EXPECT_EQ(result, true); |
|
result = offload_scan_manager_->stopScan(&reason_code); |
|
EXPECT_EQ(result, true); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for unsubscribing to the scan results from |
|
* when service is not connected to the hardware |
|
*/ |
|
TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); |
|
EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); |
|
OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
|
bool result = offload_scan_manager_->startScan( |
|
kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
|
security_flags, frequencies, &reason_code); |
|
EXPECT_EQ(result, true); |
|
OffloadStatus status = |
|
OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); |
|
offload_callback_->onError(status); |
|
result = offload_scan_manager_->stopScan(&reason_code); |
|
EXPECT_EQ(result, false); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for getting scan statistics when the |
|
* Offload HAL service is running without errors |
|
*/ |
|
TEST_F(OffloadScanManagerTest, getScanStatsTestWhenServiceIsOk) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_CALL(*mock_offload_, getScanStats(_)); |
|
NativeScanStats stats; |
|
bool result = offload_scan_manager_->getScanStats(&stats); |
|
EXPECT_EQ(result, true); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for getting scan statistics when the |
|
* Offload HAL service is not connected |
|
*/ |
|
TEST_F(OffloadScanManagerTest, getScanStatsTestWhenServiceIsNotOk) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
OffloadStatus status = |
|
OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); |
|
offload_callback_->onError(status); |
|
EXPECT_CALL(*mock_offload_, getScanStats(_)).Times(0); |
|
NativeScanStats stats; |
|
bool result = offload_scan_manager_->getScanStats(&stats); |
|
EXPECT_EQ(result, false); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for subscribing to the scan results from |
|
* Offload HAL when service is running without errors, operation failure |
|
*/ |
|
TEST_F(OffloadScanManagerTest, StartScanFailedTest) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(0); |
|
EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(1); |
|
status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR); |
|
OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
|
bool result = offload_scan_manager_->startScan( |
|
kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
|
security_flags, frequencies, &reason_code); |
|
EXPECT_EQ(result, false); |
|
EXPECT_EQ(reason_code, OffloadScanManager::kOperationFailed); |
|
} |
|
|
|
/** |
|
* Testing OffloadScanManager for getting scan statistics when the |
|
* Offload HAL service is running without errors, getting scan stats failure |
|
*/ |
|
TEST_F(OffloadScanManagerTest, getScanStatsFailedTest) { |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
|
EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
|
ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
|
.WillByDefault(testing::Return(mock_offload_)); |
|
offload_scan_manager_.reset(new OffloadScanManager( |
|
mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
|
status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::TIMEOUT); |
|
EXPECT_CALL(*mock_offload_, getScanStats(_)); |
|
NativeScanStats stats; |
|
bool result = offload_scan_manager_->getScanStats(&stats); |
|
EXPECT_EQ(result, false); |
|
} |
|
|
|
} // namespace wificond |
|
} // namespace android
|
|
|