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