1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Staache 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 <numeric>
18 #include <vector>
19
20 #include <VtsCoreUtil.h>
21 #include <aidl/Gtest.h>
22 #include <aidl/Vintf.h>
23 #include <aidl/android/hardware/wifi/BnWifi.h>
24 #include <aidl/android/hardware/wifi/BnWifiChipEventCallback.h>
25 #include <aidl/android/hardware/wifi/WifiIfaceMode.h>
26 #include <android/binder_manager.h>
27 #include <android/binder_status.h>
28 #include <binder/IServiceManager.h>
29 #include <binder/ProcessState.h>
30
31 #include "wifi_aidl_test_utils.h"
32
33 using aidl::android::hardware::wifi::AfcChannelAllowance;
34 using aidl::android::hardware::wifi::AvailableAfcChannelInfo;
35 using aidl::android::hardware::wifi::AvailableAfcFrequencyInfo;
36 using aidl::android::hardware::wifi::BnWifiChipEventCallback;
37 using aidl::android::hardware::wifi::IfaceType;
38 using aidl::android::hardware::wifi::IWifiApIface;
39 using aidl::android::hardware::wifi::IWifiChip;
40 using aidl::android::hardware::wifi::IWifiNanIface;
41 using aidl::android::hardware::wifi::IWifiP2pIface;
42 using aidl::android::hardware::wifi::IWifiRttController;
43 using aidl::android::hardware::wifi::WifiBand;
44 using aidl::android::hardware::wifi::WifiChipCapabilities;
45 using aidl::android::hardware::wifi::WifiDebugHostWakeReasonStats;
46 using aidl::android::hardware::wifi::WifiDebugRingBufferStatus;
47 using aidl::android::hardware::wifi::WifiDebugRingBufferVerboseLevel;
48 using aidl::android::hardware::wifi::WifiIfaceMode;
49 using aidl::android::hardware::wifi::WifiRadioCombination;
50 using aidl::android::hardware::wifi::WifiStatusCode;
51 using aidl::android::hardware::wifi::WifiUsableChannel;
52
53 class WifiChipAidlTest : public testing::TestWithParam<std::string> {
54 public:
SetUp()55 void SetUp() override {
56 stopWifiService(getInstanceName());
57 wifi_chip_ = getWifiChip(getInstanceName());
58 ASSERT_NE(nullptr, wifi_chip_.get());
59 ASSERT_TRUE(wifi_chip_->getInterfaceVersion(&interface_version_).isOk());
60 }
61
TearDown()62 void TearDown() override { stopWifiService(getInstanceName()); }
63
64 protected:
configureChipForConcurrencyType(IfaceConcurrencyType type)65 int configureChipForConcurrencyType(IfaceConcurrencyType type) {
66 int mode_id;
67 EXPECT_TRUE(configureChipToSupportConcurrencyType(wifi_chip_, type, &mode_id));
68 return mode_id;
69 }
70
isConcurrencyTypeSupported(IfaceConcurrencyType type)71 bool isConcurrencyTypeSupported(IfaceConcurrencyType type) {
72 return doesChipSupportConcurrencyType(wifi_chip_, type);
73 }
74
configureChipForStaAndGetIface()75 std::shared_ptr<IWifiStaIface> configureChipForStaAndGetIface() {
76 std::shared_ptr<IWifiStaIface> iface;
77 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
78 EXPECT_TRUE(wifi_chip_->createStaIface(&iface).isOk());
79 EXPECT_NE(nullptr, iface.get());
80 return iface;
81 }
82
configureChipForP2pAndGetIface()83 std::shared_ptr<IWifiP2pIface> configureChipForP2pAndGetIface() {
84 std::shared_ptr<IWifiP2pIface> iface;
85 configureChipForConcurrencyType(IfaceConcurrencyType::P2P);
86 EXPECT_TRUE(wifi_chip_->createP2pIface(&iface).isOk());
87 EXPECT_NE(nullptr, iface.get());
88 return iface;
89 }
90
configureChipForApAndGetIface()91 std::shared_ptr<IWifiApIface> configureChipForApAndGetIface() {
92 std::shared_ptr<IWifiApIface> iface;
93 configureChipForConcurrencyType(IfaceConcurrencyType::AP);
94 EXPECT_TRUE(wifi_chip_->createApIface(&iface).isOk());
95 EXPECT_NE(nullptr, iface.get());
96 return iface;
97 }
98
configureChipForNanAndGetIface()99 std::shared_ptr<IWifiNanIface> configureChipForNanAndGetIface() {
100 std::shared_ptr<IWifiNanIface> iface;
101 configureChipForConcurrencyType(IfaceConcurrencyType::NAN_IFACE);
102 EXPECT_TRUE(wifi_chip_->createNanIface(&iface).isOk());
103 EXPECT_NE(nullptr, iface.get());
104 return iface;
105 }
106
getStaIfaceName(const std::shared_ptr<IWifiStaIface> & iface)107 std::string getStaIfaceName(const std::shared_ptr<IWifiStaIface>& iface) {
108 std::string iface_name;
109 EXPECT_TRUE(iface->getName(&iface_name).isOk());
110 return iface_name;
111 }
112
getP2pIfaceName(const std::shared_ptr<IWifiP2pIface> & iface)113 std::string getP2pIfaceName(const std::shared_ptr<IWifiP2pIface>& iface) {
114 std::string iface_name;
115 EXPECT_TRUE(iface->getName(&iface_name).isOk());
116 return iface_name;
117 }
118
getApIfaceName(const std::shared_ptr<IWifiApIface> & iface)119 std::string getApIfaceName(const std::shared_ptr<IWifiApIface>& iface) {
120 std::string iface_name;
121 EXPECT_TRUE(iface->getName(&iface_name).isOk());
122 return iface_name;
123 }
124
getNanIfaceName(const std::shared_ptr<IWifiNanIface> & iface)125 std::string getNanIfaceName(const std::shared_ptr<IWifiNanIface>& iface) {
126 std::string iface_name;
127 EXPECT_TRUE(iface->getName(&iface_name).isOk());
128 return iface_name;
129 }
130
create2StaIfacesIfPossible()131 std::vector<std::shared_ptr<IWifiStaIface>> create2StaIfacesIfPossible() {
132 std::shared_ptr<IWifiStaIface> iface1 = configureChipForStaAndGetIface();
133
134 // Try create a create second iface.
135 std::shared_ptr<IWifiStaIface> iface2;
136 bool add_second_success = wifi_chip_->createStaIface(&iface2).isOk();
137 if (!add_second_success) {
138 return {iface1};
139 }
140 EXPECT_NE(nullptr, iface2.get());
141 return {iface1, iface2};
142 }
143
getInstanceName()144 const char* getInstanceName() { return GetParam().c_str(); }
145
146 std::shared_ptr<IWifiChip> wifi_chip_;
147 int interface_version_;
148 };
149
150 class WifiChipEventCallback : public BnWifiChipEventCallback {
151 public:
152 WifiChipEventCallback() = default;
153
onChipReconfigureFailure(WifiStatusCode)154 ::ndk::ScopedAStatus onChipReconfigureFailure(WifiStatusCode /* status */) override {
155 return ndk::ScopedAStatus::ok();
156 }
onChipReconfigured(int)157 ::ndk::ScopedAStatus onChipReconfigured(int /* modeId */) override {
158 return ndk::ScopedAStatus::ok();
159 }
onDebugErrorAlert(int,const std::vector<uint8_t> &)160 ::ndk::ScopedAStatus onDebugErrorAlert(int /* errorCode */,
161 const std::vector<uint8_t>& /* debugData */) override {
162 return ndk::ScopedAStatus::ok();
163 }
onDebugRingBufferDataAvailable(const WifiDebugRingBufferStatus &,const std::vector<uint8_t> &)164 ::ndk::ScopedAStatus onDebugRingBufferDataAvailable(
165 const WifiDebugRingBufferStatus& /* status */,
166 const std::vector<uint8_t>& /* data */) override {
167 return ndk::ScopedAStatus::ok();
168 }
onIfaceAdded(IfaceType,const std::string &)169 ::ndk::ScopedAStatus onIfaceAdded(IfaceType /* type */,
170 const std::string& /* name */) override {
171 return ndk::ScopedAStatus::ok();
172 }
onIfaceRemoved(IfaceType,const std::string &)173 ::ndk::ScopedAStatus onIfaceRemoved(IfaceType /* type */,
174 const std::string& /* name */) override {
175 return ndk::ScopedAStatus::ok();
176 }
onRadioModeChange(const std::vector<RadioModeInfo> &)177 ::ndk::ScopedAStatus onRadioModeChange(
178 const std::vector<RadioModeInfo>& /* radioModeInfos */) override {
179 return ndk::ScopedAStatus::ok();
180 }
181 };
182
183 /*
184 * RegisterEventCallback
185 *
186 * Note: it is not feasible to test the invocation of the callback function,
187 * since events are triggered internally in the HAL implementation and cannot be
188 * triggered from the test case.
189 */
TEST_P(WifiChipAidlTest,RegisterEventCallback)190 TEST_P(WifiChipAidlTest, RegisterEventCallback) {
191 std::shared_ptr<WifiChipEventCallback> callback =
192 ndk::SharedRefBase::make<WifiChipEventCallback>();
193 ASSERT_NE(nullptr, callback.get());
194 EXPECT_TRUE(wifi_chip_->registerEventCallback(callback).isOk());
195 }
196
197 /*
198 * GetFeatureSet
199 */
TEST_P(WifiChipAidlTest,GetFeatureSet)200 TEST_P(WifiChipAidlTest, GetFeatureSet) {
201 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
202 int32_t features;
203 EXPECT_TRUE(wifi_chip_->getFeatureSet(&features).isOk());
204 }
205
206 /*
207 * GetId
208 */
TEST_P(WifiChipAidlTest,GetId)209 TEST_P(WifiChipAidlTest, GetId) {
210 int id;
211 EXPECT_TRUE(wifi_chip_->getId(&id).isOk());
212 }
213
214 /*
215 * GetAvailableModes
216 */
TEST_P(WifiChipAidlTest,GetAvailableModes)217 TEST_P(WifiChipAidlTest, GetAvailableModes) {
218 std::vector<IWifiChip::ChipMode> modes;
219 EXPECT_TRUE(wifi_chip_->getAvailableModes(&modes).isOk());
220 EXPECT_NE(modes.size(), 0);
221 }
222
223 /*
224 * GetMode
225 */
TEST_P(WifiChipAidlTest,GetMode)226 TEST_P(WifiChipAidlTest, GetMode) {
227 int expected_mode = configureChipForConcurrencyType(IfaceConcurrencyType::STA);
228 int retrieved_mode;
229 EXPECT_TRUE(wifi_chip_->getMode(&retrieved_mode).isOk());
230 EXPECT_EQ(retrieved_mode, expected_mode);
231 }
232
233 /*
234 * GetUsableChannels
235 */
TEST_P(WifiChipAidlTest,GetUsableChannels)236 TEST_P(WifiChipAidlTest, GetUsableChannels) {
237 WifiBand band = WifiBand::BAND_24GHZ_5GHZ_6GHZ;
238 uint32_t ifaceModeMask = static_cast<uint32_t>(WifiIfaceMode::IFACE_MODE_P2P_CLIENT) |
239 static_cast<uint32_t>(WifiIfaceMode::IFACE_MODE_P2P_GO);
240 uint32_t filterMask =
241 static_cast<uint32_t>(IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE) |
242 static_cast<uint32_t>(IWifiChip::UsableChannelFilter::CONCURRENCY);
243
244 std::vector<WifiUsableChannel> channels;
245 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
246 auto status = wifi_chip_->getUsableChannels(band, ifaceModeMask, filterMask, &channels);
247 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
248 GTEST_SKIP() << "getUsableChannels() is not supported by vendor.";
249 }
250 EXPECT_TRUE(status.isOk());
251 }
252
253 /*
254 * GetSupportedRadioCombinations
255 */
TEST_P(WifiChipAidlTest,GetSupportedRadioCombinations)256 TEST_P(WifiChipAidlTest, GetSupportedRadioCombinations) {
257 std::vector<WifiRadioCombination> combinations;
258 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
259 auto status = wifi_chip_->getSupportedRadioCombinations(&combinations);
260 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
261 GTEST_SKIP() << "Skipping this test since getSupportedRadioCombinations() "
262 "is not supported by vendor.";
263 }
264 EXPECT_TRUE(status.isOk());
265 }
266
267 /*
268 * SetCountryCode
269 */
TEST_P(WifiChipAidlTest,SetCountryCode)270 TEST_P(WifiChipAidlTest, SetCountryCode) {
271 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
272 std::array<uint8_t, 2> country_code = {0x55, 0x53};
273 EXPECT_TRUE(wifi_chip_->setCountryCode(country_code).isOk());
274 }
275
276 /*
277 * Tests the setAfcChannelAllowance() API.
278 */
TEST_P(WifiChipAidlTest,SetAfcChannelAllowance)279 TEST_P(WifiChipAidlTest, SetAfcChannelAllowance) {
280 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
281 int32_t features = getChipFeatureSet(wifi_chip_);
282 AfcChannelAllowance allowance;
283 allowance.availableAfcChannelInfos = std::vector<AvailableAfcChannelInfo>();
284 allowance.availableAfcFrequencyInfos = std::vector<AvailableAfcFrequencyInfo>();
285 auto status = wifi_chip_->setAfcChannelAllowance(allowance);
286 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_AFC_CHANNEL_ALLOWANCE)) {
287 EXPECT_TRUE(status.isOk());
288 } else {
289 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
290 }
291 }
292
293 /*
294 * SetLatencyMode_normal
295 * Tests the setLatencyMode() API with Latency mode NORMAL.
296 */
TEST_P(WifiChipAidlTest,SetLatencyMode_normal)297 TEST_P(WifiChipAidlTest, SetLatencyMode_normal) {
298 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
299 int32_t features = getChipFeatureSet(wifi_chip_);
300 auto status = wifi_chip_->setLatencyMode(IWifiChip::LatencyMode::NORMAL);
301 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_LATENCY_MODE)) {
302 EXPECT_TRUE(status.isOk());
303 } else {
304 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
305 }
306 }
307
308 /*
309 * SetLatencyMode_low
310 * Tests the setLatencyMode() API with Latency mode LOW.
311 */
TEST_P(WifiChipAidlTest,SetLatencyMode_low)312 TEST_P(WifiChipAidlTest, SetLatencyMode_low) {
313 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
314 int32_t features = getChipFeatureSet(wifi_chip_);
315 auto status = wifi_chip_->setLatencyMode(IWifiChip::LatencyMode::LOW);
316 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_LATENCY_MODE)) {
317 EXPECT_TRUE(status.isOk());
318 } else {
319 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
320 }
321 }
322
323 /*
324 * SetMultiStaPrimaryConnection
325 *
326 * Only runs if the device supports 2 STA ifaces.
327 */
TEST_P(WifiChipAidlTest,SetMultiStaPrimaryConnection)328 TEST_P(WifiChipAidlTest, SetMultiStaPrimaryConnection) {
329 auto ifaces = create2StaIfacesIfPossible();
330 if (ifaces.size() < 2) {
331 GTEST_SKIP() << "Device does not support more than 1 STA concurrently";
332 }
333
334 auto status = wifi_chip_->setMultiStaPrimaryConnection(getStaIfaceName(ifaces[0]));
335 if (!status.isOk()) {
336 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
337 }
338 }
339
340 /*
341 * SetMultiStaUseCase
342 *
343 * Only runs if the device supports 2 STA ifaces.
344 */
TEST_P(WifiChipAidlTest,setMultiStaUseCase)345 TEST_P(WifiChipAidlTest, setMultiStaUseCase) {
346 auto ifaces = create2StaIfacesIfPossible();
347 if (ifaces.size() < 2) {
348 GTEST_SKIP() << "Device does not support more than 1 STA concurrently";
349 }
350
351 auto status = wifi_chip_->setMultiStaUseCase(
352 IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY);
353 if (!status.isOk()) {
354 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
355 }
356 }
357
358 /*
359 * SetCoexUnsafeChannels
360 */
TEST_P(WifiChipAidlTest,SetCoexUnsafeChannels)361 TEST_P(WifiChipAidlTest, SetCoexUnsafeChannels) {
362 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
363
364 // Test with an empty vector of CoexUnsafeChannels.
365 std::vector<IWifiChip::CoexUnsafeChannel> vec;
366 int restrictions = 0;
367 auto status = wifi_chip_->setCoexUnsafeChannels(vec, restrictions);
368 if (!status.isOk()) {
369 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
370 }
371
372 // Test with a non-empty vector of CoexUnsafeChannels.
373 IWifiChip::CoexUnsafeChannel unsafeChannel24Ghz;
374 unsafeChannel24Ghz.band = WifiBand::BAND_24GHZ;
375 unsafeChannel24Ghz.channel = 6;
376 vec.push_back(unsafeChannel24Ghz);
377 IWifiChip::CoexUnsafeChannel unsafeChannel5Ghz;
378 unsafeChannel5Ghz.band = WifiBand::BAND_5GHZ;
379 unsafeChannel5Ghz.channel = 36;
380 vec.push_back(unsafeChannel5Ghz);
381 restrictions = static_cast<int32_t>(IWifiChip::CoexRestriction::WIFI_AWARE) |
382 static_cast<int32_t>(IWifiChip::CoexRestriction::SOFTAP) |
383 static_cast<int32_t>(IWifiChip::CoexRestriction::WIFI_DIRECT);
384
385 status = wifi_chip_->setCoexUnsafeChannels(vec, restrictions);
386 if (!status.isOk()) {
387 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
388 }
389 }
390
391 /*
392 * SelectTxPowerScenario - Body
393 */
TEST_P(WifiChipAidlTest,SelectTxPowerScenario_body)394 TEST_P(WifiChipAidlTest, SelectTxPowerScenario_body) {
395 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
396 int32_t features = getChipFeatureSet(wifi_chip_);
397 int32_t expected_features =
398 static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_TX_POWER_LIMIT) |
399 static_cast<int32_t>(IWifiChip::FeatureSetMask::USE_BODY_HEAD_SAR);
400 auto status = wifi_chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF);
401 if (features & expected_features) {
402 EXPECT_TRUE(status.isOk());
403 } else {
404 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
405 }
406 }
407
408 /*
409 * SelectTxPowerScenario - Voice Call
410 */
TEST_P(WifiChipAidlTest,SelectTxPowerScenario_voiceCall)411 TEST_P(WifiChipAidlTest, SelectTxPowerScenario_voiceCall) {
412 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
413 int32_t features = getChipFeatureSet(wifi_chip_);
414 auto status = wifi_chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::VOICE_CALL);
415 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_TX_POWER_LIMIT)) {
416 EXPECT_TRUE(status.isOk());
417 } else {
418 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
419 }
420 }
421
422 /*
423 * ResetTxPowerScenario
424 */
TEST_P(WifiChipAidlTest,ResetTxPowerScenario)425 TEST_P(WifiChipAidlTest, ResetTxPowerScenario) {
426 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
427 int32_t features = getChipFeatureSet(wifi_chip_);
428 auto status = wifi_chip_->resetTxPowerScenario();
429 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_TX_POWER_LIMIT)) {
430 EXPECT_TRUE(status.isOk());
431 } else {
432 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
433 }
434 }
435
436 /*
437 * ConfigureChip
438 */
TEST_P(WifiChipAidlTest,ConfigureChip)439 TEST_P(WifiChipAidlTest, ConfigureChip) {
440 std::vector<IWifiChip::ChipMode> modes;
441 EXPECT_TRUE(wifi_chip_->getAvailableModes(&modes).isOk());
442 EXPECT_NE(modes.size(), 0);
443 for (const auto& mode : modes) {
444 // configureChip() requires a fresh IWifiChip object.
445 wifi_chip_ = getWifiChip(getInstanceName());
446 ASSERT_NE(nullptr, wifi_chip_.get());
447 EXPECT_TRUE(wifi_chip_->configureChip(mode.id).isOk());
448 stopWifiService(getInstanceName());
449 // Sleep for 5 milliseconds between each wifi state toggle.
450 usleep(5000);
451 }
452 }
453
454 /*
455 * RequestChipDebugInfo
456 */
TEST_P(WifiChipAidlTest,RequestChipDebugInfo)457 TEST_P(WifiChipAidlTest, RequestChipDebugInfo) {
458 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
459 IWifiChip::ChipDebugInfo debug_info = {};
460 EXPECT_TRUE(wifi_chip_->requestChipDebugInfo(&debug_info).isOk());
461 EXPECT_NE(debug_info.driverDescription.size(), 0);
462 EXPECT_NE(debug_info.firmwareDescription.size(), 0);
463 }
464
465 /*
466 * RequestFirmwareDebugDump
467 */
TEST_P(WifiChipAidlTest,RequestFirmwareDebugDump)468 TEST_P(WifiChipAidlTest, RequestFirmwareDebugDump) {
469 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
470 std::vector<uint8_t> debug_dump;
471 auto status = wifi_chip_->requestFirmwareDebugDump(&debug_dump);
472 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
473 }
474
475 /*
476 * RequestDriverDebugDump
477 */
TEST_P(WifiChipAidlTest,RequestDriverDebugDump)478 TEST_P(WifiChipAidlTest, RequestDriverDebugDump) {
479 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
480 std::vector<uint8_t> debug_dump;
481 auto status = wifi_chip_->requestDriverDebugDump(&debug_dump);
482 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
483 }
484
485 /*
486 * GetDebugRingBuffersStatus
487 */
TEST_P(WifiChipAidlTest,GetDebugRingBuffersStatus)488 TEST_P(WifiChipAidlTest, GetDebugRingBuffersStatus) {
489 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
490 std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
491 auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
492 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
493 if (status.isOk()) {
494 ASSERT_NE(ring_buffer_status.size(), 0);
495 for (const auto& ring_buffer : ring_buffer_status) {
496 EXPECT_NE(ring_buffer.ringName.size(), 0);
497 }
498 }
499 }
500
501 /*
502 * GetDebugHostWakeReasonStats
503 */
TEST_P(WifiChipAidlTest,GetDebugHostWakeReasonStats)504 TEST_P(WifiChipAidlTest, GetDebugHostWakeReasonStats) {
505 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
506 WifiDebugHostWakeReasonStats wake_reason_stats = {};
507 auto status = wifi_chip_->getDebugHostWakeReasonStats(&wake_reason_stats);
508 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
509 }
510
511 /*
512 * StartLoggingToDebugRingBuffer
513 */
TEST_P(WifiChipAidlTest,StartLoggingToDebugRingBuffer)514 TEST_P(WifiChipAidlTest, StartLoggingToDebugRingBuffer) {
515 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
516 std::string ring_name;
517 std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
518
519 auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
520 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
521 if (status.isOk()) {
522 ASSERT_NE(ring_buffer_status.size(), 0);
523 ring_name = ring_buffer_status[0].ringName;
524 }
525
526 status = wifi_chip_->startLoggingToDebugRingBuffer(
527 ring_name, WifiDebugRingBufferVerboseLevel::VERBOSE, 5, 1024);
528 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
529
530 status = wifi_chip_->stopLoggingToDebugRingBuffer();
531 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
532 }
533
534 /*
535 * ForceDumpToDebugRingBuffer
536 */
TEST_P(WifiChipAidlTest,ForceDumpToDebugRingBuffer)537 TEST_P(WifiChipAidlTest, ForceDumpToDebugRingBuffer) {
538 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
539 std::string ring_name;
540 std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
541
542 auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
543 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
544 if (status.isOk()) {
545 ASSERT_NE(ring_buffer_status.size(), 0);
546 ring_name = ring_buffer_status[0].ringName;
547 }
548
549 status = wifi_chip_->forceDumpToDebugRingBuffer(ring_name);
550 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
551 }
552
553 /*
554 * CreateStaIface
555 * Configures the chip in STA mode and creates an iface.
556 */
TEST_P(WifiChipAidlTest,CreateStaIface)557 TEST_P(WifiChipAidlTest, CreateStaIface) {
558 configureChipForStaAndGetIface();
559 }
560
561 /*
562 * CreateApIface
563 */
TEST_P(WifiChipAidlTest,CreateApIface)564 TEST_P(WifiChipAidlTest, CreateApIface) {
565 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::AP)) {
566 GTEST_SKIP() << "AP is not supported";
567 }
568 configureChipForApAndGetIface();
569 }
570
571 /*
572 * CreateNanIface
573 */
TEST_P(WifiChipAidlTest,CreateNanIface)574 TEST_P(WifiChipAidlTest, CreateNanIface) {
575 if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware")) {
576 GTEST_SKIP() << "Skipping this test since NAN is not supported.";
577 }
578 configureChipForNanAndGetIface();
579 }
580
581 /*
582 * CreateP2pIface
583 */
TEST_P(WifiChipAidlTest,CreateP2pIface)584 TEST_P(WifiChipAidlTest, CreateP2pIface) {
585 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::P2P)) {
586 GTEST_SKIP() << "P2P is not supported";
587 }
588 configureChipForP2pAndGetIface();
589 }
590
591 /*
592 * GetStaIfaceNames
593 * Configures the chip in STA mode and ensures that the iface name list is
594 * empty before creating the iface. Then create the iface and ensure that
595 * iface name is returned in the iface name list.
596 */
TEST_P(WifiChipAidlTest,GetStaIfaceNames)597 TEST_P(WifiChipAidlTest, GetStaIfaceNames) {
598 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
599
600 std::vector<std::string> iface_names;
601 EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
602 EXPECT_EQ(iface_names.size(), 0);
603
604 std::shared_ptr<IWifiStaIface> iface;
605 EXPECT_TRUE(wifi_chip_->createStaIface(&iface).isOk());
606 ASSERT_NE(nullptr, iface.get());
607
608 std::string iface_name = getStaIfaceName(iface);
609 EXPECT_TRUE(wifi_chip_->getStaIfaceNames(&iface_names).isOk());
610 EXPECT_EQ(iface_names.size(), 1);
611 EXPECT_EQ(iface_name, iface_names[0]);
612
613 EXPECT_TRUE(wifi_chip_->removeStaIface(iface_name).isOk());
614 EXPECT_TRUE(wifi_chip_->getStaIfaceNames(&iface_names).isOk());
615 EXPECT_EQ(iface_names.size(), 0);
616 }
617
618 /*
619 * GetP2pIfaceNames
620 */
TEST_P(WifiChipAidlTest,GetP2pIfaceNames)621 TEST_P(WifiChipAidlTest, GetP2pIfaceNames) {
622 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::P2P)) {
623 GTEST_SKIP() << "P2P is not supported";
624 }
625 configureChipForConcurrencyType(IfaceConcurrencyType::P2P);
626
627 std::vector<std::string> iface_names;
628 EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
629 EXPECT_EQ(iface_names.size(), 0);
630
631 std::shared_ptr<IWifiP2pIface> iface;
632 EXPECT_TRUE(wifi_chip_->createP2pIface(&iface).isOk());
633 ASSERT_NE(nullptr, iface.get());
634
635 std::string iface_name = getP2pIfaceName(iface);
636 EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
637 EXPECT_EQ(iface_names.size(), 1);
638 EXPECT_EQ(iface_name, iface_names[0]);
639
640 EXPECT_TRUE(wifi_chip_->removeP2pIface(iface_name).isOk());
641 EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
642 EXPECT_EQ(iface_names.size(), 0);
643 }
644
645 /*
646 * GetApIfaceNames
647 */
TEST_P(WifiChipAidlTest,GetApIfaceNames)648 TEST_P(WifiChipAidlTest, GetApIfaceNames) {
649 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::AP)) {
650 GTEST_SKIP() << "AP is not supported";
651 }
652 configureChipForConcurrencyType(IfaceConcurrencyType::AP);
653
654 std::vector<std::string> iface_names;
655 EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
656 EXPECT_EQ(iface_names.size(), 0);
657
658 std::shared_ptr<IWifiApIface> iface;
659 EXPECT_TRUE(wifi_chip_->createApIface(&iface).isOk());
660 ASSERT_NE(nullptr, iface.get());
661
662 std::string iface_name = getApIfaceName(iface);
663 EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
664 EXPECT_EQ(iface_names.size(), 1);
665 EXPECT_EQ(iface_name, iface_names[0]);
666
667 EXPECT_TRUE(wifi_chip_->removeApIface(iface_name).isOk());
668 EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
669 EXPECT_EQ(iface_names.size(), 0);
670 }
671
672 /*
673 * GetNanIfaceNames
674 */
TEST_P(WifiChipAidlTest,GetNanIfaceNames)675 TEST_P(WifiChipAidlTest, GetNanIfaceNames) {
676 if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware")) {
677 GTEST_SKIP() << "Skipping this test since NAN is not supported.";
678 }
679 configureChipForConcurrencyType(IfaceConcurrencyType::NAN_IFACE);
680
681 std::vector<std::string> iface_names;
682 EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
683 EXPECT_EQ(iface_names.size(), 0);
684
685 std::shared_ptr<IWifiNanIface> iface;
686 EXPECT_TRUE(wifi_chip_->createNanIface(&iface).isOk());
687 ASSERT_NE(nullptr, iface.get());
688
689 std::string iface_name = getNanIfaceName(iface);
690 EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
691 EXPECT_EQ(iface_names.size(), 1);
692 EXPECT_EQ(iface_name, iface_names[0]);
693
694 EXPECT_TRUE(wifi_chip_->removeNanIface(iface_name).isOk());
695 EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
696 EXPECT_EQ(iface_names.size(), 0);
697 }
698
699 /*
700 * GetStaIface
701 * Configures the chip in STA mode and creates an iface. Then retrieves
702 * the iface object using its name and ensures that any other name
703 * doesn't retrieve a valid iface object.
704 */
TEST_P(WifiChipAidlTest,GetStaIface)705 TEST_P(WifiChipAidlTest, GetStaIface) {
706 std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
707 std::string iface_name = getStaIfaceName(iface);
708
709 std::shared_ptr<IWifiStaIface> retrieved_iface;
710 EXPECT_TRUE(wifi_chip_->getStaIface(iface_name, &retrieved_iface).isOk());
711 EXPECT_NE(nullptr, retrieved_iface.get());
712
713 std::string invalid_name = iface_name + "0";
714 std::shared_ptr<IWifiStaIface> invalid_iface;
715 auto status = wifi_chip_->getStaIface(invalid_name, &invalid_iface);
716 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
717 EXPECT_EQ(nullptr, invalid_iface.get());
718 }
719
720 /*
721 * GetP2pIface
722 */
TEST_P(WifiChipAidlTest,GetP2pIface)723 TEST_P(WifiChipAidlTest, GetP2pIface) {
724 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::P2P)) {
725 GTEST_SKIP() << "P2P is not supported";
726 }
727 std::shared_ptr<IWifiP2pIface> iface = configureChipForP2pAndGetIface();
728 std::string iface_name = getP2pIfaceName(iface);
729
730 std::shared_ptr<IWifiP2pIface> retrieved_iface;
731 EXPECT_TRUE(wifi_chip_->getP2pIface(iface_name, &retrieved_iface).isOk());
732 EXPECT_NE(nullptr, retrieved_iface.get());
733
734 std::string invalid_name = iface_name + "0";
735 std::shared_ptr<IWifiP2pIface> invalid_iface;
736 auto status = wifi_chip_->getP2pIface(invalid_name, &invalid_iface);
737 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
738 EXPECT_EQ(nullptr, invalid_iface.get());
739 }
740
741 /*
742 * GetApIface
743 */
TEST_P(WifiChipAidlTest,GetApIface)744 TEST_P(WifiChipAidlTest, GetApIface) {
745 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::AP)) {
746 GTEST_SKIP() << "AP is not supported";
747 }
748 std::shared_ptr<IWifiApIface> iface = configureChipForApAndGetIface();
749 std::string iface_name = getApIfaceName(iface);
750
751 std::shared_ptr<IWifiApIface> retrieved_iface;
752 EXPECT_TRUE(wifi_chip_->getApIface(iface_name, &retrieved_iface).isOk());
753 EXPECT_NE(nullptr, retrieved_iface.get());
754
755 std::string invalid_name = iface_name + "0";
756 std::shared_ptr<IWifiApIface> invalid_iface;
757 auto status = wifi_chip_->getApIface(invalid_name, &invalid_iface);
758 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
759 EXPECT_EQ(nullptr, invalid_iface.get());
760 }
761
762 /*
763 * GetNanIface
764 */
TEST_P(WifiChipAidlTest,GetNanIface)765 TEST_P(WifiChipAidlTest, GetNanIface) {
766 if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware")) {
767 GTEST_SKIP() << "Skipping this test since NAN is not supported.";
768 }
769 std::shared_ptr<IWifiNanIface> iface = configureChipForNanAndGetIface();
770 std::string iface_name = getNanIfaceName(iface);
771
772 std::shared_ptr<IWifiNanIface> retrieved_iface;
773 EXPECT_TRUE(wifi_chip_->getNanIface(iface_name, &retrieved_iface).isOk());
774 EXPECT_NE(nullptr, retrieved_iface.get());
775
776 std::string invalid_name = iface_name + "0";
777 std::shared_ptr<IWifiNanIface> invalid_iface;
778 auto status = wifi_chip_->getNanIface(invalid_name, &invalid_iface);
779 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
780 EXPECT_EQ(nullptr, invalid_iface.get());
781 }
782
783 /*
784 * RemoveStaIface
785 * Configures the chip in STA mode and creates an iface. Then removes
786 * the iface object using the correct name and ensures that any other
787 * name doesn't remove the iface.
788 */
TEST_P(WifiChipAidlTest,RemoveStaIface)789 TEST_P(WifiChipAidlTest, RemoveStaIface) {
790 std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
791 std::string iface_name = getStaIfaceName(iface);
792
793 std::string invalid_name = iface_name + "0";
794 auto status = wifi_chip_->removeStaIface(invalid_name);
795 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
796 EXPECT_TRUE(wifi_chip_->removeStaIface(iface_name).isOk());
797
798 // No such iface exists now, so this should return failure.
799 EXPECT_FALSE(wifi_chip_->removeStaIface(iface_name).isOk());
800 }
801
802 /*
803 * RemoveP2pIface
804 */
TEST_P(WifiChipAidlTest,RemoveP2pIface)805 TEST_P(WifiChipAidlTest, RemoveP2pIface) {
806 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::P2P)) {
807 GTEST_SKIP() << "P2P is not supported";
808 }
809 std::shared_ptr<IWifiP2pIface> iface = configureChipForP2pAndGetIface();
810 std::string iface_name = getP2pIfaceName(iface);
811
812 std::string invalid_name = iface_name + "0";
813 auto status = wifi_chip_->removeP2pIface(invalid_name);
814 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
815 EXPECT_TRUE(wifi_chip_->removeP2pIface(iface_name).isOk());
816
817 // No such iface exists now, so this should return failure.
818 EXPECT_FALSE(wifi_chip_->removeP2pIface(iface_name).isOk());
819 }
820
821 /*
822 * RemoveApIface
823 */
TEST_P(WifiChipAidlTest,RemoveApIface)824 TEST_P(WifiChipAidlTest, RemoveApIface) {
825 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::AP)) {
826 GTEST_SKIP() << "AP is not supported";
827 }
828 std::shared_ptr<IWifiApIface> iface = configureChipForApAndGetIface();
829 std::string iface_name = getApIfaceName(iface);
830
831 std::string invalid_name = iface_name + "0";
832 auto status = wifi_chip_->removeApIface(invalid_name);
833 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
834 EXPECT_TRUE(wifi_chip_->removeApIface(iface_name).isOk());
835
836 // No such iface exists now, so this should return failure.
837 EXPECT_FALSE(wifi_chip_->removeApIface(iface_name).isOk());
838 }
839
840 /*
841 * RemoveNanIface
842 */
TEST_P(WifiChipAidlTest,RemoveNanIface)843 TEST_P(WifiChipAidlTest, RemoveNanIface) {
844 if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware")) {
845 GTEST_SKIP() << "Skipping this test since NAN is not supported.";
846 }
847 std::shared_ptr<IWifiNanIface> iface = configureChipForNanAndGetIface();
848 std::string iface_name = getNanIfaceName(iface);
849
850 std::string invalid_name = iface_name + "0";
851 auto status = wifi_chip_->removeNanIface(invalid_name);
852 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
853 EXPECT_TRUE(wifi_chip_->removeNanIface(iface_name).isOk());
854
855 // No such iface exists now, so this should return failure.
856 EXPECT_FALSE(wifi_chip_->removeNanIface(iface_name).isOk());
857 }
858
859 /*
860 * CreateRttController
861 */
TEST_P(WifiChipAidlTest,CreateRttController)862 TEST_P(WifiChipAidlTest, CreateRttController) {
863 std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
864 std::shared_ptr<IWifiRttController> rtt_controller;
865 auto status = wifi_chip_->createRttController(iface, &rtt_controller);
866 if (status.isOk()) {
867 EXPECT_NE(nullptr, rtt_controller.get());
868 } else {
869 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
870 }
871 }
872
873 /**
874 * CreateBridgedApIface & RemoveIfaceInstanceFromBridgedApIface
875 */
TEST_P(WifiChipAidlTest,CreateBridgedApIfaceAndremoveIfaceInstanceFromBridgedApIfaceTest)876 TEST_P(WifiChipAidlTest, CreateBridgedApIfaceAndremoveIfaceInstanceFromBridgedApIfaceTest) {
877 bool isBridgedSupport = testing::checkSubstringInCommandOutput(
878 "/system/bin/cmd wifi get-softap-supported-features",
879 "wifi_softap_bridged_ap_supported");
880 if (!isBridgedSupport) {
881 GTEST_SKIP() << "Missing Bridged AP support";
882 }
883
884 std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
885 ASSERT_NE(nullptr, wifi_chip.get());
886 std::shared_ptr<IWifiApIface> wifi_ap_iface = getBridgedWifiApIface(wifi_chip);
887 ASSERT_NE(nullptr, wifi_ap_iface.get());
888
889 std::string br_name;
890 std::vector<std::string> instances;
891 EXPECT_TRUE(wifi_ap_iface->getName(&br_name).isOk());
892 EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
893 EXPECT_EQ(instances.size(), 2);
894
895 std::vector<std::string> instances_after_remove;
896 EXPECT_TRUE(wifi_chip->removeIfaceInstanceFromBridgedApIface(br_name, instances[0]).isOk());
897 EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances_after_remove).isOk());
898 EXPECT_EQ(instances_after_remove.size(), 1);
899 }
900
901 /*
902 * SetVoipMode_off
903 * Tests the setVoipMode() API with VoIP mode OFF.
904 */
TEST_P(WifiChipAidlTest,SetVoipMode_off)905 TEST_P(WifiChipAidlTest, SetVoipMode_off) {
906 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
907 int32_t features = getChipFeatureSet(wifi_chip_);
908 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_VOIP_MODE)) {
909 auto status = wifi_chip_->setVoipMode(IWifiChip::VoipMode::OFF);
910 EXPECT_TRUE(status.isOk());
911 } else {
912 GTEST_SKIP() << "setVoipMode() is not supported by vendor.";
913 }
914 }
915
916 /*
917 * SetVoipMode_voice
918 * Tests the setVoipMode() API with VoIP mode VOICE.
919 */
TEST_P(WifiChipAidlTest,SetVoipMode_voice)920 TEST_P(WifiChipAidlTest, SetVoipMode_voice) {
921 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
922 int32_t features = getChipFeatureSet(wifi_chip_);
923 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_VOIP_MODE)) {
924 auto status = wifi_chip_->setVoipMode(IWifiChip::VoipMode::VOICE);
925 EXPECT_TRUE(status.isOk());
926 } else {
927 GTEST_SKIP() << "setVoipMode() is not supported by vendor.";
928 }
929 }
930
931 /**
932 * CreateApOrBridgedApIfaceWithParams for signal ap.
933 */
TEST_P(WifiChipAidlTest,CreateApOrBridgedApIfaceWithParams_signal_ap)934 TEST_P(WifiChipAidlTest, CreateApOrBridgedApIfaceWithParams_signal_ap) {
935 if (interface_version_ < 3) {
936 GTEST_SKIP() << "CreateApOrBridgedApIfaceWithParams is available as of WifiChip V3";
937 }
938 if (!isConcurrencyTypeSupported(IfaceConcurrencyType::AP)) {
939 GTEST_SKIP() << "AP is not supported";
940 }
941
942 std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
943 ASSERT_NE(nullptr, wifi_chip.get());
944 std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApOrBridgedApIface(
945 wifi_chip, generateApIfaceParams(IfaceConcurrencyType::AP, false, 0));
946 ASSERT_NE(nullptr, wifi_ap_iface.get());
947 }
948
949 /**
950 * CreateApOrBridgedApIfaceWithParams for non mlo bridged ap.
951 */
TEST_P(WifiChipAidlTest,CreateApOrBridgedApIfaceWithParams_non_mlo_bridged_ap)952 TEST_P(WifiChipAidlTest, CreateApOrBridgedApIfaceWithParams_non_mlo_bridged_ap) {
953 if (interface_version_ < 3) {
954 GTEST_SKIP() << "CreateApOrBridgedApIfaceWithParams is available as of WifiChip V3";
955 }
956 bool isBridgedSupport = testing::checkSubstringInCommandOutput(
957 "/system/bin/cmd wifi get-softap-supported-features",
958 "wifi_softap_bridged_ap_supported");
959 if (!isBridgedSupport) {
960 GTEST_SKIP() << "Missing Bridged AP support";
961 }
962
963 std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
964 ASSERT_NE(nullptr, wifi_chip.get());
965 std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApOrBridgedApIface(
966 wifi_chip, generateApIfaceParams(IfaceConcurrencyType::AP_BRIDGED, false, 0));
967 ASSERT_NE(nullptr, wifi_ap_iface.get());
968
969 std::string br_name;
970 std::vector<std::string> instances;
971 bool uses_mlo;
972 EXPECT_TRUE(wifi_ap_iface->getName(&br_name).isOk());
973 EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
974 EXPECT_TRUE(wifi_ap_iface->usesMlo(&uses_mlo).isOk());
975 EXPECT_FALSE(uses_mlo);
976 EXPECT_EQ(instances.size(), 2);
977 }
978
979 /**
980 * CreateApOrBridgedApIfaceWithParams for mlo bridged ap.
981 */
TEST_P(WifiChipAidlTest,CreateApOrBridgedApIfaceWithParams_mlo_bridged_ap)982 TEST_P(WifiChipAidlTest, CreateApOrBridgedApIfaceWithParams_mlo_bridged_ap) {
983 if (interface_version_ < 3) {
984 GTEST_SKIP() << "CreateApOrBridgedApIfaceWithParams is available as of WifiChip V3";
985 }
986 bool isBridgedSupport = testing::checkSubstringInCommandOutput(
987 "/system/bin/cmd wifi get-softap-supported-features",
988 "wifi_softap_bridged_ap_supported");
989 if (!isBridgedSupport) {
990 GTEST_SKIP() << "Missing Bridged AP support";
991 }
992
993 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
994 int32_t features = getChipFeatureSet(wifi_chip_);
995 if (!(features & static_cast<int32_t>(IWifiChip::FeatureSetMask::MLO_SAP))) {
996 GTEST_SKIP() << "MLO_SAP is not supported by vendor.";
997 }
998 std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
999 ASSERT_NE(nullptr, wifi_chip.get());
1000 std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApOrBridgedApIface(
1001 wifi_chip, generateApIfaceParams(IfaceConcurrencyType::AP_BRIDGED, true, 0));
1002 ASSERT_NE(nullptr, wifi_ap_iface.get());
1003
1004 std::string br_name;
1005 std::vector<std::string> instances;
1006 bool uses_mlo;
1007 EXPECT_TRUE(wifi_ap_iface->getName(&br_name).isOk());
1008 EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
1009 EXPECT_TRUE(wifi_ap_iface->usesMlo(&uses_mlo).isOk());
1010 EXPECT_TRUE(uses_mlo);
1011 EXPECT_EQ(instances.size(), 2);
1012 }
1013
1014 /*
1015 * GetWifiChipCapabilities
1016 */
TEST_P(WifiChipAidlTest,GetWifiChipCapabilities)1017 TEST_P(WifiChipAidlTest, GetWifiChipCapabilities) {
1018 WifiChipCapabilities chipCapabilities;
1019 // STA iface needs to be configured for this test
1020 auto iface = configureChipForStaAndGetIface();
1021 ASSERT_NE(iface, nullptr);
1022
1023 auto status = wifi_chip_->getWifiChipCapabilities(&chipCapabilities);
1024 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
1025 GTEST_SKIP() << "getWifiChipCapabilities() is not supported by vendor.";
1026 }
1027 EXPECT_TRUE(status.isOk());
1028 }
1029
1030 /*
1031 * SetMloMode
1032 */
TEST_P(WifiChipAidlTest,SetMloMode)1033 TEST_P(WifiChipAidlTest, SetMloMode) {
1034 // STA iface needs to be configured for this test
1035 auto iface = configureChipForStaAndGetIface();
1036 ASSERT_NE(iface, nullptr);
1037
1038 auto status = wifi_chip_->setMloMode(IWifiChip::ChipMloMode::LOW_LATENCY);
1039 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
1040 GTEST_SKIP() << "setMloMode() is not supported by vendor.";
1041 }
1042 EXPECT_TRUE(status.isOk());
1043 }
1044
1045 /*
1046 * EnableDebugErrorAlerts
1047 */
TEST_P(WifiChipAidlTest,EnableDebugErrorAlerts)1048 TEST_P(WifiChipAidlTest, EnableDebugErrorAlerts) {
1049 // STA iface needs to be configured for this test
1050 auto iface = configureChipForStaAndGetIface();
1051 ASSERT_NE(iface, nullptr);
1052
1053 auto status = wifi_chip_->enableDebugErrorAlerts(true);
1054 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
1055 GTEST_SKIP() << "EnableDebugErrorAlerts is not supported by vendor";
1056 }
1057 EXPECT_TRUE(status.isOk());
1058 EXPECT_TRUE(wifi_chip_->enableDebugErrorAlerts(false).isOk());
1059 }
1060
1061 /*
1062 * TriggerSubsystemRestart
1063 */
TEST_P(WifiChipAidlTest,TriggerSubsystemRestart)1064 TEST_P(WifiChipAidlTest, TriggerSubsystemRestart) {
1065 // STA iface needs to be configured for this test
1066 auto iface = configureChipForStaAndGetIface();
1067 ASSERT_NE(iface, nullptr);
1068
1069 auto status = wifi_chip_->triggerSubsystemRestart();
1070 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
1071 GTEST_SKIP() << "TriggerSubsystemRestart is not supported by vendor";
1072 }
1073 EXPECT_TRUE(status.isOk());
1074 }
1075
1076 /*
1077 * EnableStaChannelForPeerNetwork
1078 */
TEST_P(WifiChipAidlTest,EnableStaChannelForPeerNetwork)1079 TEST_P(WifiChipAidlTest, EnableStaChannelForPeerNetwork) {
1080 // STA iface needs to be configured for this test
1081 auto iface = configureChipForStaAndGetIface();
1082 ASSERT_NE(iface, nullptr);
1083
1084 int categoryMask = (int)IWifiChip::ChannelCategoryMask::INDOOR_CHANNEL |
1085 (int)IWifiChip::ChannelCategoryMask::DFS_CHANNEL;
1086 auto status = wifi_chip_->enableStaChannelForPeerNetwork(categoryMask);
1087 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
1088 GTEST_SKIP() << "EnableStaChannelForPeerNetwork is not supported by vendor";
1089 }
1090 EXPECT_TRUE(status.isOk());
1091 }
1092
1093 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiChipAidlTest);
1094 INSTANTIATE_TEST_SUITE_P(WifiTest, WifiChipAidlTest,
1095 testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
1096 android::PrintInstanceNameToString);
1097
main(int argc,char ** argv)1098 int main(int argc, char** argv) {
1099 ::testing::InitGoogleTest(&argc, argv);
1100 android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
1101 android::ProcessState::self()->startThreadPool();
1102 return RUN_ALL_TESTS();
1103 }
1104