1 /*
2 * Copyright (C) 2017, 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 <vector>
18
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21 #include <wifi_system_test/mock_interface_tool.h>
22 #include <wifi_system_test/mock_supplicant_manager.h>
23
24 #include "android/net/wifi/IWifiScannerImpl.h"
25 #include "wificond/scanning/offload/offload_scan_utils.h"
26 #include "wificond/scanning/scanner_impl.h"
27 #include "wificond/tests/mock_client_interface_impl.h"
28 #include "wificond/tests/mock_netlink_manager.h"
29 #include "wificond/tests/mock_netlink_utils.h"
30 #include "wificond/tests/mock_offload_scan_callback_interface_impl.h"
31 #include "wificond/tests/mock_offload_scan_manager.h"
32 #include "wificond/tests/mock_offload_service_utils.h"
33 #include "wificond/tests/mock_scan_utils.h"
34 #include "wificond/tests/offload_test_utils.h"
35
36 using ::android::binder::Status;
37 using ::android::net::wifi::IWifiScannerImpl;
38 using ::android::wifi_system::MockInterfaceTool;
39 using ::com::android::server::wifi::wificond::SingleScanSettings;
40 using ::com::android::server::wifi::wificond::PnoSettings;
41 using ::com::android::server::wifi::wificond::NativeScanResult;
42 using android::hardware::wifi::offload::V1_0::ScanResult;
43 using ::testing::Invoke;
44 using ::testing::NiceMock;
45 using ::testing::Return;
46 using ::testing::_;
47 using std::shared_ptr;
48 using std::unique_ptr;
49 using std::vector;
50
51 using namespace std::placeholders;
52
53 namespace android {
54 namespace wificond {
55
56 namespace {
57
58 constexpr uint32_t kFakeInterfaceIndex = 12;
59 constexpr uint32_t kFakeScanIntervalMs = 10000;
60
61 // This is a helper function to mock the behavior of ScanUtils::Scan()
62 // when we expect a error code.
63 // |interface_index_ignored|, |request_random_mac_ignored|, |ssids_ignored|,
64 // |freqs_ignored|, |error_code| are mapped to existing parameters of ScanUtils::Scan().
65 // |mock_error_code| is a additional parameter used for specifying expected error code.
ReturnErrorCodeForScanRequest(int mock_error_code,uint32_t interface_index_ignored,bool request_random_mac_ignored,int scan_type,const std::vector<std::vector<uint8_t>> & ssids_ignored,const std::vector<uint32_t> & freqs_ignored,int * error_code)66 bool ReturnErrorCodeForScanRequest(
67 int mock_error_code,
68 uint32_t interface_index_ignored,
69 bool request_random_mac_ignored,
70 int scan_type,
71 const std::vector<std::vector<uint8_t>>& ssids_ignored,
72 const std::vector<uint32_t>& freqs_ignored,
73 int* error_code) {
74 *error_code = mock_error_code;
75 // Returing false because this helper function is used for failure case.
76 return false;
77 }
78
CaptureSchedScanIntervalSetting(uint32_t,const SchedScanIntervalSetting & interval_setting,int32_t,int32_t,bool,bool,const std::vector<std::vector<uint8_t>> &,const std::vector<std::vector<uint8_t>> &,const std::vector<uint32_t> &,int *,SchedScanIntervalSetting * out_interval_setting)79 bool CaptureSchedScanIntervalSetting(
80 uint32_t /* interface_index */,
81 const SchedScanIntervalSetting& interval_setting,
82 int32_t /* rssi_threshold_2g */,
83 int32_t /* rssi_threshold_5g */,
84 bool /* request_random_mac */,
85 bool /* request_low_power_scan */,
86 const std::vector<std::vector<uint8_t>>& /* scan_ssids */,
87 const std::vector<std::vector<uint8_t>>& /* match_ssids */,
88 const std::vector<uint32_t>& /* freqs */,
89 int* /* error_code */,
90 SchedScanIntervalSetting* out_interval_setting) {
91 *out_interval_setting = interval_setting;
92 return true;
93 }
94
ReturnOffloadScanResults(std::vector<NativeScanResult> * native_scan_results_,const std::vector<ScanResult> & offload_scan_results)95 bool ReturnOffloadScanResults(
96 std::vector<NativeScanResult>* native_scan_results_,
97 const std::vector<ScanResult>& offload_scan_results) {
98 return OffloadScanUtils::convertToNativeScanResults(offload_scan_results,
99 native_scan_results_);
100 }
101
ReturnNetlinkScanResults(uint32_t interface_index,std::vector<NativeScanResult> * native_scan_results_,const std::vector<ScanResult> & offload_scan_results)102 bool ReturnNetlinkScanResults(
103 uint32_t interface_index,
104 std::vector<NativeScanResult>* native_scan_results_,
105 const std::vector<ScanResult>& offload_scan_results) {
106 return OffloadScanUtils::convertToNativeScanResults(offload_scan_results,
107 native_scan_results_);
108 }
109
110 } // namespace
111
112 class ScannerTest : public ::testing::Test {
113 protected:
SetUp()114 void SetUp() override {
115 ON_CALL(*offload_service_utils_, GetOffloadScanManager(_, _))
116 .WillByDefault(Return(offload_scan_manager_));
117 ON_CALL(*offload_service_utils_, GetOffloadScanCallbackInterface(_))
118 .WillByDefault(Return(offload_scan_callback_interface_));
119 dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults();
120 }
121
TearDown()122 void TearDown() override { dummy_scan_results_.clear(); }
123
124 unique_ptr<ScannerImpl> scanner_impl_;
125 NiceMock<MockNetlinkManager> netlink_manager_;
126 NiceMock<MockNetlinkUtils> netlink_utils_{&netlink_manager_};
127 NiceMock<MockScanUtils> scan_utils_{&netlink_manager_};
128 NiceMock<MockInterfaceTool> if_tool_;
129 NiceMock<MockClientInterfaceImpl> client_interface_impl_{
130 &if_tool_, &netlink_utils_, &scan_utils_};
131 shared_ptr<NiceMock<MockOffloadServiceUtils>> offload_service_utils_{
132 new NiceMock<MockOffloadServiceUtils>()};
133 shared_ptr<NiceMock<MockOffloadScanCallbackInterfaceImpl>>
134 offload_scan_callback_interface_{
135 new NiceMock<MockOffloadScanCallbackInterfaceImpl>(
136 scanner_impl_.get())};
137 std::shared_ptr<NiceMock<MockOffloadScanManager>> offload_scan_manager_{
138 new NiceMock<MockOffloadScanManager>(offload_service_utils_,
139 offload_scan_callback_interface_)};
140 ScanCapabilities scan_capabilities_;
141 WiphyFeatures wiphy_features_;
142 std::vector<ScanResult> dummy_scan_results_;
143 };
144
TEST_F(ScannerTest,TestSingleScan)145 TEST_F(ScannerTest, TestSingleScan) {
146 EXPECT_CALL(scan_utils_,
147 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _)).
148 WillOnce(Return(true));
149 bool success = false;
150 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
151 scan_capabilities_, wiphy_features_,
152 &client_interface_impl_,
153 &scan_utils_, offload_service_utils_));
154 EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk());
155 EXPECT_TRUE(success);
156 }
157
TEST_F(ScannerTest,TestSingleScanForLowSpanScan)158 TEST_F(ScannerTest, TestSingleScanForLowSpanScan) {
159 EXPECT_CALL(scan_utils_,
160 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_LOW_SPAN, _, _, _)).
161 WillOnce(Return(true));
162 wiphy_features_.supports_low_span_oneshot_scan = true;
163 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
164 wiphy_features_, &client_interface_impl_,
165 &scan_utils_, offload_service_utils_);
166 SingleScanSettings settings;
167 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_LOW_SPAN;
168 bool success = false;
169 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk());
170 EXPECT_TRUE(success);
171 }
172
TEST_F(ScannerTest,TestSingleScanForLowPowerScan)173 TEST_F(ScannerTest, TestSingleScanForLowPowerScan) {
174 EXPECT_CALL(scan_utils_,
175 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_LOW_POWER, _, _, _)).
176 WillOnce(Return(true));
177 wiphy_features_.supports_low_power_oneshot_scan = true;
178 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
179 wiphy_features_, &client_interface_impl_,
180 &scan_utils_, offload_service_utils_);
181 SingleScanSettings settings;
182 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_LOW_POWER;
183 bool success = false;
184 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk());
185 EXPECT_TRUE(success);
186 }
187
TEST_F(ScannerTest,TestSingleScanForHighAccuracyScan)188 TEST_F(ScannerTest, TestSingleScanForHighAccuracyScan) {
189 EXPECT_CALL(scan_utils_,
190 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY, _, _, _)).
191 WillOnce(Return(true));
192 wiphy_features_.supports_high_accuracy_oneshot_scan = true;
193 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
194 wiphy_features_, &client_interface_impl_,
195 &scan_utils_, offload_service_utils_);
196 SingleScanSettings settings;
197 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY;
198 bool success = false;
199 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk());
200 EXPECT_TRUE(success);
201 }
202
TEST_F(ScannerTest,TestSingleScanForLowSpanScanWithNoWiphySupport)203 TEST_F(ScannerTest, TestSingleScanForLowSpanScanWithNoWiphySupport) {
204 EXPECT_CALL(scan_utils_,
205 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _)).
206 WillOnce(Return(true));
207 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
208 wiphy_features_, &client_interface_impl_,
209 &scan_utils_, offload_service_utils_);
210 SingleScanSettings settings;
211 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_LOW_SPAN;
212 bool success = false;
213 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk());
214 EXPECT_TRUE(success);
215 }
216
TEST_F(ScannerTest,TestSingleScanForLowPowerScanWithNoWiphySupport)217 TEST_F(ScannerTest, TestSingleScanForLowPowerScanWithNoWiphySupport) {
218 EXPECT_CALL(scan_utils_,
219 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _)).
220 WillOnce(Return(true));
221 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
222 wiphy_features_, &client_interface_impl_,
223 &scan_utils_, offload_service_utils_);
224 SingleScanSettings settings;
225 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_LOW_POWER;
226 bool success = false;
227 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk());
228 EXPECT_TRUE(success);
229 }
230
TEST_F(ScannerTest,TestSingleScanForHighAccuracyScanWithNoWiphySupport)231 TEST_F(ScannerTest, TestSingleScanForHighAccuracyScanWithNoWiphySupport) {
232 EXPECT_CALL(scan_utils_,
233 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _)).
234 WillOnce(Return(true));
235 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
236 wiphy_features_, &client_interface_impl_,
237 &scan_utils_, offload_service_utils_);
238 SingleScanSettings settings;
239 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY;
240 bool success = false;
241 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk());
242 EXPECT_TRUE(success);
243 }
244
TEST_F(ScannerTest,TestSingleScanFailure)245 TEST_F(ScannerTest, TestSingleScanFailure) {
246 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
247 scan_capabilities_, wiphy_features_,
248 &client_interface_impl_,
249 &scan_utils_, offload_service_utils_));
250 EXPECT_CALL(
251 scan_utils_,
252 Scan(_, _, _, _, _, _)).
253 WillOnce(Invoke(bind(
254 ReturnErrorCodeForScanRequest, EBUSY,
255 _1, _2, _3, _4, _5, _6)));
256
257 bool success = false;
258 EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk());
259 EXPECT_FALSE(success);
260 }
261
TEST_F(ScannerTest,TestProcessAbortsOnScanReturningNoDeviceError)262 TEST_F(ScannerTest, TestProcessAbortsOnScanReturningNoDeviceError) {
263 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
264 scan_capabilities_, wiphy_features_,
265 &client_interface_impl_,
266 &scan_utils_, offload_service_utils_));
267 ON_CALL(
268 scan_utils_,
269 Scan(_, _, _, _, _, _)).
270 WillByDefault(Invoke(bind(
271 ReturnErrorCodeForScanRequest, ENODEV,
272 _1, _2, _3, _4, _5, _6)));
273
274 bool success_ignored;
275 EXPECT_DEATH(scanner_impl_->scan(SingleScanSettings(), &success_ignored),
276 "Driver is in a bad state*");
277 }
278
TEST_F(ScannerTest,TestAbortScan)279 TEST_F(ScannerTest, TestAbortScan) {
280 bool single_scan_success = false;
281 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
282 scan_capabilities_, wiphy_features_,
283 &client_interface_impl_,
284 &scan_utils_, offload_service_utils_));
285 EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _, _))
286 .WillOnce(Return(true));
287 EXPECT_TRUE(
288 scanner_impl_->scan(SingleScanSettings(), &single_scan_success).isOk());
289 EXPECT_TRUE(single_scan_success);
290
291 EXPECT_CALL(scan_utils_, AbortScan(_));
292 EXPECT_TRUE(scanner_impl_->abortScan().isOk());
293 }
294
TEST_F(ScannerTest,TestAbortScanNotIssuedIfNoOngoingScan)295 TEST_F(ScannerTest, TestAbortScanNotIssuedIfNoOngoingScan) {
296 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
297 scan_capabilities_, wiphy_features_,
298 &client_interface_impl_,
299 &scan_utils_, offload_service_utils_));
300 EXPECT_CALL(scan_utils_, AbortScan(_)).Times(0);
301 EXPECT_TRUE(scanner_impl_->abortScan().isOk());
302 }
303
TEST_F(ScannerTest,TestGetScanResults)304 TEST_F(ScannerTest, TestGetScanResults) {
305 vector<NativeScanResult> scan_results;
306 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
307 scan_capabilities_, wiphy_features_,
308 &client_interface_impl_,
309 &scan_utils_, offload_service_utils_));
310 EXPECT_CALL(scan_utils_, GetScanResult(_, _)).WillOnce(Return(true));
311 EXPECT_TRUE(scanner_impl_->getScanResults(&scan_results).isOk());
312 }
313
TEST_F(ScannerTest,TestStartPnoScanViaNetlink)314 TEST_F(ScannerTest, TestStartPnoScanViaNetlink) {
315 bool success = false;
316 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
317 .Times(1)
318 .WillRepeatedly(Return(false));
319 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
320 wiphy_features_, &client_interface_impl_,
321 &scan_utils_, offload_service_utils_);
322 EXPECT_CALL(
323 scan_utils_,
324 StartScheduledScan(_, _, _, _, _, false, _, _, _, _)).
325 WillOnce(Return(true));
326 EXPECT_TRUE(scanner_impl.startPnoScan(PnoSettings(), &success).isOk());
327 EXPECT_TRUE(success);
328 }
329
TEST_F(ScannerTest,TestStartPnoScanViaNetlinkWithLowPowerScanWiphySupport)330 TEST_F(ScannerTest, TestStartPnoScanViaNetlinkWithLowPowerScanWiphySupport) {
331 bool success = false;
332 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
333 .Times(1)
334 .WillRepeatedly(Return(false));
335 wiphy_features_.supports_low_power_oneshot_scan = true;
336 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
337 wiphy_features_, &client_interface_impl_,
338 &scan_utils_, offload_service_utils_);
339 EXPECT_CALL(
340 scan_utils_,
341 StartScheduledScan(_, _, _, _, _, true, _, _, _, _)).
342 WillOnce(Return(true));
343 EXPECT_TRUE(scanner_impl.startPnoScan(PnoSettings(), &success).isOk());
344 EXPECT_TRUE(success);
345 }
346
TEST_F(ScannerTest,TestStopPnoScanViaNetlink)347 TEST_F(ScannerTest, TestStopPnoScanViaNetlink) {
348 bool success = false;
349 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
350 .Times(1)
351 .WillRepeatedly(Return(false));
352 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
353 scan_capabilities_, wiphy_features_,
354 &client_interface_impl_,
355 &scan_utils_, offload_service_utils_));
356 // StopScheduledScan() will be called no matter if there is an ongoing
357 // scheduled scan or not. This is for making the system more robust.
358 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
359 EXPECT_TRUE(scanner_impl_->stopPnoScan(&success).isOk());
360 EXPECT_TRUE(success);
361 }
362
TEST_F(ScannerTest,TestStartScanOverOffload)363 TEST_F(ScannerTest, TestStartScanOverOffload) {
364 bool success = false;
365 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
366 .Times(1)
367 .WillRepeatedly(Return(true));
368 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
369 .Times(1)
370 .WillRepeatedly(Return(true));
371 EXPECT_CALL(*offload_scan_manager_, stopScan(_))
372 .Times(1)
373 .WillRepeatedly(Return(true));
374 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
375 scan_capabilities_, wiphy_features_,
376 &client_interface_impl_,
377 &scan_utils_, offload_service_utils_));
378 scanner_impl_->startPnoScan(PnoSettings(), &success);
379 EXPECT_TRUE(success);
380 scanner_impl_->stopPnoScan(&success);
381 EXPECT_TRUE(success);
382 }
383
TEST_F(ScannerTest,TestStartScanOverNetlinkFallback)384 TEST_F(ScannerTest, TestStartScanOverNetlinkFallback) {
385 bool success = false;
386 ON_CALL(*offload_service_utils_, IsOffloadScanSupported())
387 .WillByDefault(Return(true));
388 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
389 scan_capabilities_, wiphy_features_,
390 &client_interface_impl_,
391 &scan_utils_, offload_service_utils_));
392 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
393 .WillOnce(Return(false));
394 EXPECT_CALL(*offload_scan_manager_, stopScan(_)).Times(0);
395 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _, _, _))
396 .WillOnce(Return(true));
397 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
398 EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk());
399 EXPECT_TRUE(success == true);
400 scanner_impl_->stopPnoScan(&success);
401 EXPECT_TRUE(success);
402 }
403
TEST_F(ScannerTest,TestAsyncErrorOverOffload)404 TEST_F(ScannerTest, TestAsyncErrorOverOffload) {
405 bool success = false;
406 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
407 .Times(1)
408 .WillRepeatedly(Return(true));
409 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
410 .Times(1)
411 .WillRepeatedly(Return(true));
412 EXPECT_CALL(*offload_scan_manager_, stopScan(_))
413 .Times(1)
414 .WillRepeatedly(Return(true));
415 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
416 scan_capabilities_, wiphy_features_,
417 &client_interface_impl_,
418 &scan_utils_, offload_service_utils_));
419 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _, _, _))
420 .WillOnce(Return(true));
421 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
422 scanner_impl_->startPnoScan(PnoSettings(), &success);
423 EXPECT_TRUE(success);
424 scanner_impl_->OnOffloadError(
425 OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE);
426 scanner_impl_->stopPnoScan(&success);
427 EXPECT_TRUE(success);
428 }
429
TEST_F(ScannerTest,TestGetScanResultsFromOffload)430 TEST_F(ScannerTest, TestGetScanResultsFromOffload) {
431 bool success = false;
432 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
433 .Times(1)
434 .WillRepeatedly(Return(true));
435 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
436 .Times(1)
437 .WillRepeatedly(Return(true));
438 EXPECT_CALL(*offload_scan_manager_, getScanResults(_))
439 .Times(1)
440 .WillOnce(
441 Invoke(bind(ReturnOffloadScanResults, _1, dummy_scan_results_)));
442 EXPECT_CALL(*offload_scan_manager_, stopScan(_))
443 .Times(1)
444 .WillRepeatedly(Return(true));
445 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
446 scan_capabilities_, wiphy_features_,
447 &client_interface_impl_,
448 &scan_utils_, offload_service_utils_));
449 scanner_impl_->startPnoScan(PnoSettings(), &success);
450 EXPECT_TRUE(success);
451 scanner_impl_->OnOffloadScanResult();
452 std::vector<NativeScanResult> scan_results;
453 EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk());
454 EXPECT_FALSE(scan_results.empty());
455 scanner_impl_->stopPnoScan(&success);
456 EXPECT_TRUE(success);
457 }
458
TEST_F(ScannerTest,TestGetScanResultsWhenOffloadFails)459 TEST_F(ScannerTest, TestGetScanResultsWhenOffloadFails) {
460 bool success = false;
461 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
462 .Times(1)
463 .WillRepeatedly(Return(true));
464 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
465 .Times(1)
466 .WillRepeatedly(Return(true));
467 EXPECT_CALL(*offload_scan_manager_, stopScan(_))
468 .Times(1)
469 .WillRepeatedly(Return(true));
470 EXPECT_CALL(*offload_scan_manager_, getScanResults(_)).Times(0);
471 EXPECT_CALL(scan_utils_, GetScanResult(_, _))
472 .Times(1)
473 .WillOnce(
474 Invoke(bind(ReturnNetlinkScanResults, _1, _2, dummy_scan_results_)));
475 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
476 scan_capabilities_, wiphy_features_,
477 &client_interface_impl_,
478 &scan_utils_, offload_service_utils_));
479 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _, _, _))
480 .WillOnce(Return(true));
481 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
482 EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk());
483 EXPECT_TRUE(success);
484 scanner_impl_->OnOffloadError(
485 OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE);
486 std::vector<NativeScanResult> scan_results;
487 EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk());
488 EXPECT_FALSE(scan_results.empty());
489 scanner_impl_->stopPnoScan(&success);
490 EXPECT_TRUE(success);
491 }
492
TEST_F(ScannerTest,TestGenerateScanPlansIfDeviceSupports)493 TEST_F(ScannerTest, TestGenerateScanPlansIfDeviceSupports) {
494 ScanCapabilities scan_capabilities_scan_plan_supported(
495 0 /* max_num_scan_ssids */,
496 0 /* max_num_sched_scan_ssids */,
497 0 /* max_match_sets */,
498 // Parameters above are not related to this test.
499 2 /* 1 plan for finite repeated scan and 1 plan for ininfite scan loop */,
500 kFakeScanIntervalMs * PnoSettings::kSlowScanIntervalMultiplier / 1000,
501 PnoSettings::kFastScanIterations);
502 ScannerImpl scanner(
503 kFakeInterfaceIndex,
504 scan_capabilities_scan_plan_supported, wiphy_features_,
505 &client_interface_impl_,
506 &scan_utils_, offload_service_utils_);
507
508 PnoSettings pno_settings;
509 pno_settings.interval_ms_ = kFakeScanIntervalMs;
510
511 SchedScanIntervalSetting interval_setting;
512 EXPECT_CALL(
513 scan_utils_,
514 StartScheduledScan(_, _, _, _, _, _, _, _, _, _)).
515 WillOnce(Invoke(bind(
516 CaptureSchedScanIntervalSetting,
517 _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, &interval_setting)));
518
519 bool success_ignored = 0;
520 EXPECT_TRUE(scanner.startPnoScan(pno_settings, &success_ignored).isOk());
521 /* 1 plan for finite repeated scan */
522 EXPECT_EQ(1U, interval_setting.plans.size());
523 EXPECT_EQ(kFakeScanIntervalMs * PnoSettings::kSlowScanIntervalMultiplier,
524 interval_setting.final_interval_ms);
525 }
526
TEST_F(ScannerTest,TestGenerateSingleIntervalIfDeviceDoesNotSupportScanPlan)527 TEST_F(ScannerTest, TestGenerateSingleIntervalIfDeviceDoesNotSupportScanPlan) {
528 ScanCapabilities scan_capabilities_no_scan_plan_support(
529 0 /* max_num_scan_ssids */,
530 0 /* max_num_sched_scan_ssids */,
531 0 /* max_match_sets */,
532 // Parameters above are not related to this test.
533 0 /* max_num_scan_plans */,
534 0 /* max_scan_plan_interval */,
535 0 /* max_scan_plan_iterations */);
536 ScannerImpl scanner(
537 kFakeInterfaceIndex,
538 scan_capabilities_no_scan_plan_support, wiphy_features_,
539 &client_interface_impl_,
540 &scan_utils_, offload_service_utils_);
541 PnoSettings pno_settings;
542 pno_settings.interval_ms_ = kFakeScanIntervalMs;
543
544 SchedScanIntervalSetting interval_setting;
545 EXPECT_CALL(
546 scan_utils_,
547 StartScheduledScan(_, _, _, _, _, _, _, _, _, _)).
548 WillOnce(Invoke(bind(
549 CaptureSchedScanIntervalSetting,
550 _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, &interval_setting)));
551
552 bool success_ignored = 0;
553 EXPECT_TRUE(scanner.startPnoScan(pno_settings, &success_ignored).isOk());
554
555 EXPECT_EQ(0U, interval_setting.plans.size());
556 EXPECT_EQ(kFakeScanIntervalMs, interval_setting.final_interval_ms);
557 }
558
559 } // namespace wificond
560 } // namespace android
561