1 /*
2  * Copyright (C) 2020 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 <gtest/gtest.h>
18 
19 #include <stddef.h>
20 #include <cstring>
21 
22 #include "chpp/common/wifi_types.h"
23 #include "chpp/memory.h"
24 #include "chre/test/common/macros.h"
25 
26 namespace {
27 
validateScanResult(const ChppWifiScanResult & chppAp,const chreWifiScanResult & chreAp,bool decodeMode)28 void validateScanResult(const ChppWifiScanResult &chppAp,
29                         const chreWifiScanResult &chreAp, bool decodeMode) {
30   EXPECT_EQ(chppAp.ageMs, chreAp.ageMs);
31   EXPECT_EQ(chppAp.capabilityInfo, chreAp.capabilityInfo);
32   EXPECT_EQ(chppAp.ssidLen, chreAp.ssidLen);
33   EXPECT_EQ(std::memcmp(chppAp.ssid, chreAp.ssid, sizeof(chppAp.ssid)), 0);
34   EXPECT_EQ(std::memcmp(chppAp.bssid, chreAp.bssid, sizeof(chppAp.bssid)), 0);
35   EXPECT_EQ(chppAp.flags, chreAp.flags);
36   EXPECT_EQ(chppAp.rssi, chreAp.rssi);
37   EXPECT_EQ(chppAp.band, chreAp.band);
38   EXPECT_EQ(chppAp.primaryChannel, chreAp.primaryChannel);
39   EXPECT_EQ(chppAp.centerFreqPrimary, chreAp.centerFreqPrimary);
40   EXPECT_EQ(chppAp.centerFreqSecondary, chreAp.centerFreqSecondary);
41   EXPECT_EQ(chppAp.channelWidth, chreAp.channelWidth);
42   EXPECT_EQ(chppAp.securityMode, chreAp.securityMode);
43   EXPECT_EQ(chppAp.radioChain, chreAp.radioChain);
44   EXPECT_EQ(chppAp.rssiChain0, chreAp.rssiChain0);
45   EXPECT_EQ(chppAp.rssiChain1, chreAp.rssiChain1);
46 
47   for (size_t i = 0;
48        i < (decodeMode ? sizeof(chreAp.reserved) : sizeof(chppAp.reserved));
49        i++) {
50     SCOPED_TRACE(i);
51     EXPECT_EQ((decodeMode ? chreAp.reserved[i] : chppAp.reserved[i]), 0);
52   }
53 }
54 
validateScanEvent(const chreWifiScanEvent & chreEvent)55 void validateScanEvent(const chreWifiScanEvent &chreEvent) {
56   ChppWifiScanEventWithHeader *chppWithHeader = nullptr;
57   size_t outputSize = 999;
58 
59   // Encode
60   bool result =
61       chppWifiScanEventFromChre(&chreEvent, &chppWithHeader, &outputSize);
62   ASSERT_TRUE(result);
63   ASSERT_NE(chppWithHeader, nullptr);
64 
65   size_t expectedSize = sizeof(ChppWifiScanEventWithHeader) +
66                         chreEvent.scannedFreqListLen * sizeof(uint32_t) +
67                         chreEvent.resultCount * sizeof(ChppWifiScanResult);
68   EXPECT_EQ(outputSize, expectedSize);
69 
70   ChppWifiScanEvent *chppEvent = &chppWithHeader->payload;
71 
72   // Decode
73   outputSize -= sizeof(struct ChppAppHeader);
74   chreWifiScanEvent *backEvent = chppWifiScanEventToChre(chppEvent, outputSize);
75   ASSERT_NE(backEvent, nullptr);
76 
77   // Compare chreEvent against encoded (chppEvent) and decoded back (backEvent)
78 
79   EXPECT_EQ(chppEvent->version, CHRE_WIFI_SCAN_EVENT_VERSION);
80   EXPECT_EQ(chppEvent->resultCount, chreEvent.resultCount);
81   EXPECT_EQ(chppEvent->resultTotal, chreEvent.resultTotal);
82   EXPECT_EQ(chppEvent->resultCount, chreEvent.resultCount);
83   EXPECT_EQ(chppEvent->eventIndex, chreEvent.eventIndex);
84   EXPECT_EQ(chppEvent->scanType, chreEvent.scanType);
85   EXPECT_EQ(chppEvent->ssidSetSize, chreEvent.ssidSetSize);
86   EXPECT_EQ(chppEvent->scannedFreqListLen, chreEvent.scannedFreqListLen);
87   EXPECT_EQ(chppEvent->referenceTime, chreEvent.referenceTime);
88   EXPECT_EQ(chppEvent->radioChainPref, chreEvent.radioChainPref);
89 
90   EXPECT_EQ(backEvent->version, CHRE_WIFI_SCAN_EVENT_VERSION);
91   EXPECT_EQ(backEvent->resultCount, chreEvent.resultCount);
92   EXPECT_EQ(backEvent->resultTotal, chreEvent.resultTotal);
93   EXPECT_EQ(backEvent->resultCount, chreEvent.resultCount);
94   EXPECT_EQ(backEvent->eventIndex, chreEvent.eventIndex);
95   EXPECT_EQ(backEvent->scanType, chreEvent.scanType);
96   EXPECT_EQ(backEvent->ssidSetSize, chreEvent.ssidSetSize);
97   EXPECT_EQ(backEvent->scannedFreqListLen, chreEvent.scannedFreqListLen);
98   EXPECT_EQ(backEvent->referenceTime, chreEvent.referenceTime);
99   EXPECT_EQ(backEvent->radioChainPref, chreEvent.radioChainPref);
100 
101   uint16_t baseOffset = sizeof(ChppWifiScanEvent);
102   if (chreEvent.scannedFreqListLen > 0) {
103     EXPECT_EQ(chppEvent->scannedFreqList.offset, baseOffset);
104     EXPECT_EQ(chppEvent->scannedFreqList.length,
105               chppEvent->scannedFreqListLen * sizeof(uint32_t));
106     baseOffset += chppEvent->scannedFreqList.length;
107 
108     auto *chppScannedFreqList =
109         ((const uint8_t *)chppEvent + chppEvent->scannedFreqList.offset);
110     for (size_t i = 0; i < chppEvent->scannedFreqListLen; i++) {
111       uint32_t currScannedFreq;
112       memcpy(&currScannedFreq, chppScannedFreqList + (i * sizeof(uint32_t)),
113              sizeof(uint32_t));
114       SCOPED_TRACE(i);
115       EXPECT_EQ(currScannedFreq, chreEvent.scannedFreqList[i]);
116       EXPECT_EQ(currScannedFreq, backEvent->scannedFreqList[i]);
117     }
118   } else {
119     EXPECT_EQ(chppEvent->scannedFreqList.offset, 0);
120     EXPECT_EQ(chppEvent->scannedFreqList.length, 0);
121   }
122 
123   if (chreEvent.resultCount > 0) {
124     EXPECT_EQ(chppEvent->results.offset, baseOffset);
125     EXPECT_EQ(chppEvent->results.length,
126               chppEvent->resultCount * sizeof(ChppWifiScanResult));
127     baseOffset += chppEvent->results.length;
128 
129     const ChppWifiScanResult *chppAp =
130         (const ChppWifiScanResult *)((const uint8_t *)chppEvent +
131                                      chppEvent->results.offset);
132     for (size_t i = 0; i < chppEvent->resultCount; i++) {
133       SCOPED_TRACE(::testing::Message() << "Scan result index " << i);
134       validateScanResult(chppAp[i], chreEvent.results[i], /*decodeMode=*/false);
135       validateScanResult(chppAp[i], backEvent->results[i], /*decodeMode=*/true);
136     }
137   } else {
138     EXPECT_EQ(chppEvent->results.offset, 0);
139     EXPECT_EQ(chppEvent->results.length, 0);
140   }
141 
142   // Handling of short input
143   chreWifiScanEvent *chreMalformed;
144   chreMalformed = chppWifiScanEventToChre(chppEvent, outputSize - 1);
145   ASSERT_EQ(chreMalformed, nullptr);
146 
147   chppFree(chppWithHeader);
148   chppFree(backEvent);
149 }
150 
validateScanParams(const chreWifiScanParams & chreParams)151 void validateScanParams(const chreWifiScanParams &chreParams) {
152   ChppWifiScanParamsWithHeader *chppWithHeader = nullptr;
153   size_t outputSize = 999;
154 
155   // Encode
156   bool result =
157       chppWifiScanParamsFromChre(&chreParams, &chppWithHeader, &outputSize);
158   ASSERT_TRUE(result);
159   ASSERT_NE(chppWithHeader, nullptr);
160 
161   size_t expectedSize = sizeof(ChppWifiScanParamsWithHeader) +
162                         chreParams.frequencyListLen * sizeof(uint32_t) +
163                         chreParams.ssidListLen * sizeof(ChppWifiSsidListItem);
164   EXPECT_EQ(outputSize, expectedSize);
165 
166   ChppWifiScanParams *chppParams = &chppWithHeader->payload;
167 
168   // Decode
169   outputSize -= sizeof(struct ChppAppHeader);
170   chreWifiScanParams *backParams =
171       chppWifiScanParamsToChre(chppParams, outputSize);
172   ASSERT_NE(backParams, nullptr);
173 
174   // Compare chreEvent against encoded (chppEvent) and decoded back (backEvent)
175 
176   EXPECT_EQ(chppParams->scanType, chreParams.scanType);
177   EXPECT_EQ(chppParams->maxScanAgeMs, chreParams.maxScanAgeMs);
178   EXPECT_EQ(chppParams->frequencyListLen, chreParams.frequencyListLen);
179   EXPECT_EQ(chppParams->ssidListLen, chreParams.ssidListLen);
180   EXPECT_EQ(chppParams->radioChainPref, chreParams.radioChainPref);
181 
182   EXPECT_EQ(backParams->scanType, chreParams.scanType);
183   EXPECT_EQ(backParams->maxScanAgeMs, chreParams.maxScanAgeMs);
184   EXPECT_EQ(backParams->frequencyListLen, chreParams.frequencyListLen);
185   EXPECT_EQ(backParams->ssidListLen, chreParams.ssidListLen);
186   EXPECT_EQ(backParams->radioChainPref, chreParams.radioChainPref);
187 
188   uint16_t baseOffset = sizeof(ChppWifiScanParams);
189   if (chreParams.frequencyListLen > 0) {
190     EXPECT_EQ(chppParams->frequencyList.offset, baseOffset);
191     EXPECT_EQ(chppParams->frequencyList.length,
192               chppParams->frequencyListLen * sizeof(uint32_t));
193     baseOffset += chppParams->frequencyList.length;
194 
195     auto *chppFrequencyList =
196         ((const uint8_t *)chppParams + chppParams->frequencyList.offset);
197     for (size_t i = 0; i < chppParams->frequencyListLen; i++) {
198       uint32_t currScannedFreq;
199       memcpy(&currScannedFreq, chppFrequencyList + (i * sizeof(uint32_t)),
200              sizeof(uint32_t));
201       SCOPED_TRACE(i);
202       EXPECT_EQ(currScannedFreq, chreParams.frequencyList[i]);
203       EXPECT_EQ(currScannedFreq, backParams->frequencyList[i]);
204     }
205   } else {
206     EXPECT_EQ(chppParams->frequencyList.offset, 0);
207     EXPECT_EQ(chppParams->frequencyList.length, 0);
208   }
209 
210   if (chreParams.ssidListLen > 0) {
211     EXPECT_EQ(chppParams->ssidList.offset, baseOffset);
212     EXPECT_EQ(chppParams->ssidList.length,
213               chppParams->ssidListLen * sizeof(ChppWifiSsidListItem));
214     baseOffset += chppParams->ssidList.length;
215 
216     const ChppWifiSsidListItem *chppSsidList =
217         (const ChppWifiSsidListItem *)((const uint8_t *)chppParams +
218                                        chppParams->ssidList.offset);
219     for (size_t i = 0; i < chppParams->ssidListLen; i++) {
220       SCOPED_TRACE(i);
221       EXPECT_EQ(chppSsidList[i].ssidLen, chreParams.ssidList[i].ssidLen);
222       EXPECT_EQ(std::memcmp(chppSsidList[i].ssid, chreParams.ssidList[i].ssid,
223                             sizeof(chppSsidList[i].ssid)),
224                 0);
225       EXPECT_EQ(chppSsidList[i].ssidLen, backParams->ssidList[i].ssidLen);
226       EXPECT_EQ(std::memcmp(chppSsidList[i].ssid, backParams->ssidList[i].ssid,
227                             sizeof(chppSsidList[i].ssid)),
228                 0);
229     }
230   } else {
231     EXPECT_EQ(chppParams->ssidList.offset, 0);
232     EXPECT_EQ(chppParams->ssidList.length, 0);
233   }
234 
235   // Handling of short input
236   chreWifiScanParams *chreMalformed;
237   chreMalformed = chppWifiScanParamsToChre(chppParams, outputSize - 1);
238   ASSERT_EQ(chreMalformed, nullptr);
239 
240   chppFree(chppWithHeader);
241   chppFree(backParams);
242 }
243 
validateRangingParams(const chreWifiRangingParams & chreParams)244 void validateRangingParams(const chreWifiRangingParams &chreParams) {
245   ChppWifiRangingParamsWithHeader *chppWithHeader = nullptr;
246   size_t outputSize = 999;
247 
248   // Encode
249   bool result =
250       chppWifiRangingParamsFromChre(&chreParams, &chppWithHeader, &outputSize);
251   ASSERT_TRUE(result);
252   ASSERT_NE(chppWithHeader, nullptr);
253 
254   size_t expectedSize =
255       sizeof(ChppWifiRangingParamsWithHeader) +
256       chreParams.targetListLen * sizeof(ChppWifiRangingTarget);
257   EXPECT_EQ(outputSize, expectedSize);
258 
259   ChppWifiRangingParams *chppParams = &chppWithHeader->payload;
260 
261   // Decode
262   outputSize -= sizeof(struct ChppAppHeader);
263   chreWifiRangingParams *backParams =
264       chppWifiRangingParamsToChre(chppParams, outputSize);
265   ASSERT_NE(backParams, nullptr);
266 
267   // Compare chreEvent against encoded (chppEvent) and decoded back (backEvent)
268   EXPECT_EQ(chppParams->targetListLen, chreParams.targetListLen);
269   EXPECT_EQ(backParams->targetListLen, chreParams.targetListLen);
270 
271   uint16_t baseOffset = sizeof(ChppWifiRangingParams);
272   if (chreParams.targetListLen > 0) {
273     EXPECT_EQ(chppParams->targetList.offset, baseOffset);
274     EXPECT_EQ(chppParams->targetList.length,
275               chppParams->targetListLen * sizeof(ChppWifiRangingTarget));
276     baseOffset += chppParams->targetList.length;
277 
278     auto *chppRangingList =
279         ((const uint8_t *)chppParams + chppParams->targetList.offset);
280     for (size_t i = 0; i < chppParams->targetListLen; i++) {
281       ChppWifiRangingTarget currentRangingTarget;
282       memcpy(&currentRangingTarget,
283              chppRangingList + (i * sizeof(ChppWifiRangingTarget)),
284              sizeof(ChppWifiRangingTarget));
285       SCOPED_TRACE(i);
286       EXPECT_EQ(currentRangingTarget.macAddress[0],
287                 chreParams.targetList[i].macAddress[0]);
288       EXPECT_EQ(currentRangingTarget.macAddress[1],
289                 chreParams.targetList[i].macAddress[1]);
290       EXPECT_EQ(currentRangingTarget.macAddress[2],
291                 chreParams.targetList[i].macAddress[2]);
292       EXPECT_EQ(currentRangingTarget.macAddress[3],
293                 chreParams.targetList[i].macAddress[3]);
294       EXPECT_EQ(currentRangingTarget.macAddress[4],
295                 chreParams.targetList[i].macAddress[4]);
296       EXPECT_EQ(currentRangingTarget.macAddress[5],
297                 chreParams.targetList[i].macAddress[5]);
298       EXPECT_EQ(currentRangingTarget.primaryChannel,
299                 chreParams.targetList[i].primaryChannel);
300       EXPECT_EQ(currentRangingTarget.centerFreqPrimary,
301                 chreParams.targetList[i].centerFreqPrimary);
302       EXPECT_EQ(currentRangingTarget.centerFreqSecondary,
303                 chreParams.targetList[i].centerFreqSecondary);
304       EXPECT_EQ(currentRangingTarget.channelWidth,
305                 chreParams.targetList[i].channelWidth);
306 
307       EXPECT_EQ(currentRangingTarget.macAddress[0],
308                 backParams->targetList[i].macAddress[0]);
309       EXPECT_EQ(currentRangingTarget.macAddress[1],
310                 backParams->targetList[i].macAddress[1]);
311       EXPECT_EQ(currentRangingTarget.macAddress[2],
312                 backParams->targetList[i].macAddress[2]);
313       EXPECT_EQ(currentRangingTarget.macAddress[3],
314                 backParams->targetList[i].macAddress[3]);
315       EXPECT_EQ(currentRangingTarget.macAddress[4],
316                 backParams->targetList[i].macAddress[4]);
317       EXPECT_EQ(currentRangingTarget.macAddress[5],
318                 backParams->targetList[i].macAddress[5]);
319       EXPECT_EQ(currentRangingTarget.primaryChannel,
320                 backParams->targetList[i].primaryChannel);
321       EXPECT_EQ(currentRangingTarget.centerFreqPrimary,
322                 backParams->targetList[i].centerFreqPrimary);
323       EXPECT_EQ(currentRangingTarget.centerFreqSecondary,
324                 backParams->targetList[i].centerFreqSecondary);
325       EXPECT_EQ(currentRangingTarget.channelWidth,
326                 backParams->targetList[i].channelWidth);
327     }
328   } else {
329     EXPECT_EQ(chppParams->targetList.offset, 0);
330     EXPECT_EQ(chppParams->targetList.length, 0);
331   }
332 
333   // Handling of short input
334   chreWifiRangingParams *chreMalformed;
335   chreMalformed = chppWifiRangingParamsToChre(chppParams, outputSize - 1);
336   ASSERT_EQ(chreMalformed, nullptr);
337 
338   chppFree(chppWithHeader);
339   chppFree(backParams);
340 }
341 
342 }  // anonymous namespace
343 
TEST(WifiConvert,EmptyScanResult)344 TEST(WifiConvert, EmptyScanResult) {
345   const chreWifiScanEvent chreEvent = {
346       .version = 200,  // ignored
347       .resultCount = 0,
348       .resultTotal = 0,
349       .eventIndex = 0,
350       .scanType = CHRE_WIFI_SCAN_TYPE_ACTIVE_PLUS_PASSIVE_DFS,
351       .ssidSetSize = 2,
352       .scannedFreqListLen = 0,
353       .referenceTime = 1234,
354       .scannedFreqList = nullptr,
355       .results = nullptr,
356       .radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_HIGH_ACCURACY,
357   };
358 
359   validateScanEvent(chreEvent);
360 }
361 
TEST(WifiConvert,SingleResult)362 TEST(WifiConvert, SingleResult) {
363   // clang-format off
364   const chreWifiScanResult chreAp = {
365       .ageMs = 11,
366       .capabilityInfo = 22,
367       .ssidLen = 4,
368       .ssid = {'a', 'b', 'c', 'd',},
369       .bssid = {0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff},
370       .flags = CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER,
371       .rssi = -37,
372       .band = CHRE_WIFI_BAND_2_4_GHZ,
373       .primaryChannel = 2437,
374       .centerFreqPrimary = 2442,
375       .centerFreqSecondary = 2447,
376       .channelWidth = CHRE_WIFI_CHANNEL_WIDTH_80_MHZ,
377       .securityMode = CHRE_WIFI_SECURITY_MODE_PSK,
378       .radioChain = CHRE_WIFI_RADIO_CHAIN_0 | CHRE_WIFI_RADIO_CHAIN_1,
379       .rssiChain0 = -37,
380       .rssiChain1 = -42,
381   };
382   const chreWifiScanEvent chreEvent = {
383       .version = 200,  // ignored
384       .resultCount = 1,
385       .resultTotal = 5,
386       .eventIndex = 2,
387       .scanType = CHRE_WIFI_SCAN_TYPE_ACTIVE,
388       .ssidSetSize = 0,
389       .scannedFreqListLen = 0,
390       .referenceTime = 12345,
391       .scannedFreqList = nullptr,
392       .results = &chreAp,
393       .radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_DEFAULT,
394   };
395   // clang-format on
396 
397   validateScanEvent(chreEvent);
398 }
399 
TEST(WifiConvert,TwoResultsWithFreqList)400 TEST(WifiConvert, TwoResultsWithFreqList) {
401   // clang-format off
402   const chreWifiScanResult chreAps[] = {
403   {
404       .ageMs = 11,
405       .capabilityInfo = 22,
406       .ssidLen = 4,
407       .ssid = {'a', 'b', 'c', 'd',},
408       .bssid = {0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff},
409       .flags = CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER,
410       .rssi = -37,
411       .band = CHRE_WIFI_BAND_2_4_GHZ,
412       .primaryChannel = 2437,
413       .centerFreqPrimary = 2442,
414       .centerFreqSecondary = 2447,
415       .channelWidth = CHRE_WIFI_CHANNEL_WIDTH_80_MHZ,
416       .securityMode = CHRE_WIFI_SECURITY_MODE_PSK,
417       .radioChain = CHRE_WIFI_RADIO_CHAIN_0 | CHRE_WIFI_RADIO_CHAIN_1,
418       .rssiChain0 = -37,
419       .rssiChain1 = -42,
420   },
421   {
422       .ageMs = 4325,
423       .capabilityInfo = 37,
424       .ssidLen = 2,
425       .ssid = {'h', 'i',},
426       .bssid = {0xab, 0xcd, 0xef, 0x01, 0x23, 0x45},
427       .flags = CHRE_WIFI_SCAN_RESULT_FLAGS_VHT_OPS_PRESENT,
428       .rssi = -52,
429       .band = CHRE_WIFI_BAND_5_GHZ,
430       .primaryChannel = 9999,
431       .centerFreqPrimary = 8888,
432       .centerFreqSecondary = 7777,
433       .channelWidth = CHRE_WIFI_CHANNEL_WIDTH_160_MHZ,
434       .securityMode = CHRE_WIFI_SECURITY_MODE_SAE,
435       .radioChain = CHRE_WIFI_RADIO_CHAIN_0,
436       .rssiChain0 = -37,
437       .rssiChain1 = 0,
438   }};
439   const uint32_t freqList[] = {0xdeadbeef, 0xc001cafe, 0xc0a1ba11};
440   const chreWifiScanEvent chreEvent = {
441       .version = 200,  // ignored
442       .resultCount = 2,
443       .resultTotal = 3,
444       .eventIndex = 1,
445       .scanType = CHRE_WIFI_SCAN_TYPE_ACTIVE,
446       .ssidSetSize = 10,
447       .scannedFreqListLen = 3,
448       .referenceTime = 56789,
449       .scannedFreqList = freqList,
450       .results = chreAps,
451       .radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_LOW_POWER,
452   };
453   // clang-format on
454 
455   validateScanEvent(chreEvent);
456 }
457 
TEST(WifiConvert,DefaultScanParams)458 TEST(WifiConvert, DefaultScanParams) {
459   // From chreWifiRequestScanAsyncDefault
460   struct chreWifiScanParams params = {};
461   params.scanType = CHRE_WIFI_SCAN_TYPE_ACTIVE;
462   params.maxScanAgeMs = 5000;  // 5 seconds
463   params.frequencyListLen = 0;
464   params.ssidListLen = 0;
465   params.radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_DEFAULT;
466 
467   validateScanParams(params);
468 }
469 
TEST(WifiConvert,ScanParamsWithFreqList)470 TEST(WifiConvert, ScanParamsWithFreqList) {
471   uint32_t freqList[] = {1234, 3456};
472   struct chreWifiScanParams chreParams = {
473       .scanType = CHRE_WIFI_SCAN_TYPE_ACTIVE_PLUS_PASSIVE_DFS,
474       .maxScanAgeMs = 9999,
475       .frequencyListLen = 2,
476       .frequencyList = freqList,
477       .ssidListLen = 0,
478       .ssidList = nullptr,
479       .radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_LOW_POWER,
480   };
481 
482   validateScanParams(chreParams);
483 }
484 
TEST(WifiConvert,ScanParamsWithSsidList)485 TEST(WifiConvert, ScanParamsWithSsidList) {
486   // clang-format off
487   chreWifiSsidListItem ssidList[] = {
488       {.ssidLen = 4, .ssid = {0xde, 0xad, 0xbe, 0xef}},
489       {.ssidLen = 2, .ssid = {':', ')'}}
490   };
491   // clang-format on
492   struct chreWifiScanParams chreParams = {
493       .scanType = CHRE_WIFI_SCAN_TYPE_ACTIVE_PLUS_PASSIVE_DFS,
494       .maxScanAgeMs = 9999,
495       .frequencyListLen = 0,
496       .frequencyList = nullptr,
497       .ssidListLen = 2,
498       .ssidList = ssidList,
499       .radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_LOW_POWER,
500   };
501 
502   validateScanParams(chreParams);
503 }
504 
TEST(WifiConvert,ScanParamsWithBothLists)505 TEST(WifiConvert, ScanParamsWithBothLists) {
506   uint32_t freqList[] = {1234, 3456, 5678};
507   // clang-format off
508   chreWifiSsidListItem ssidList[] = {
509       {.ssidLen = 4, .ssid = {0xde, 0xad, 0xbe, 0xef}},
510       {.ssidLen = 3, .ssid = {':', '-', ')'}}
511   };
512   // clang-format on
513   struct chreWifiScanParams chreParams = {
514       .scanType = CHRE_WIFI_SCAN_TYPE_ACTIVE_PLUS_PASSIVE_DFS,
515       .maxScanAgeMs = 9999,
516       .frequencyListLen = 3,
517       .frequencyList = freqList,
518       .ssidListLen = 2,
519       .ssidList = ssidList,
520       .radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_LOW_POWER,
521   };
522 
523   validateScanParams(chreParams);
524 }
525 
TEST(WifiConvert,RangingParamsEmpty)526 TEST(WifiConvert, RangingParamsEmpty) {
527   struct chreWifiRangingParams chreParams = {
528       .targetListLen = 0,
529       .targetList = NULL,
530   };
531 
532   validateRangingParams(chreParams);
533 }
534 
TEST(WifiConvert,RangingParamsWithTarget)535 TEST(WifiConvert, RangingParamsWithTarget) {
536   struct chreWifiRangingTarget target = {
537       .macAddress = {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc},
538       .primaryChannel = 0xdef02468,
539       .centerFreqPrimary = 0xace13579,
540       .centerFreqSecondary = 0xbdf369cf,
541       .channelWidth = 0x48,
542   };
543 
544   struct chreWifiRangingParams chreParams = {
545       .targetListLen = 1,
546       .targetList = &target,
547   };
548 
549   validateRangingParams(chreParams);
550 }
551