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