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::BnWifiChipEventCallback;
34 using aidl::android::hardware::wifi::IfaceType;
35 using aidl::android::hardware::wifi::IWifiApIface;
36 using aidl::android::hardware::wifi::IWifiChip;
37 using aidl::android::hardware::wifi::IWifiNanIface;
38 using aidl::android::hardware::wifi::IWifiP2pIface;
39 using aidl::android::hardware::wifi::IWifiRttController;
40 using aidl::android::hardware::wifi::WifiBand;
41 using aidl::android::hardware::wifi::WifiDebugHostWakeReasonStats;
42 using aidl::android::hardware::wifi::WifiDebugRingBufferStatus;
43 using aidl::android::hardware::wifi::WifiDebugRingBufferVerboseLevel;
44 using aidl::android::hardware::wifi::WifiIfaceMode;
45 using aidl::android::hardware::wifi::WifiRadioCombination;
46 using aidl::android::hardware::wifi::WifiStatusCode;
47 using aidl::android::hardware::wifi::WifiUsableChannel;
48
49 class WifiChipAidlTest : public testing::TestWithParam<std::string> {
50 public:
SetUp()51 void SetUp() override {
52 stopWifiService(getInstanceName());
53 wifi_chip_ = getWifiChip(getInstanceName());
54 ASSERT_NE(nullptr, wifi_chip_.get());
55 }
56
TearDown()57 void TearDown() override { stopWifiService(getInstanceName()); }
58
59 protected:
configureChipForConcurrencyType(IfaceConcurrencyType type)60 int configureChipForConcurrencyType(IfaceConcurrencyType type) {
61 int mode_id;
62 EXPECT_TRUE(configureChipToSupportConcurrencyType(wifi_chip_, type, &mode_id));
63 return mode_id;
64 }
65
configureChipForStaAndGetIface()66 std::shared_ptr<IWifiStaIface> configureChipForStaAndGetIface() {
67 std::shared_ptr<IWifiStaIface> iface;
68 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
69 EXPECT_TRUE(wifi_chip_->createStaIface(&iface).isOk());
70 EXPECT_NE(nullptr, iface.get());
71 return iface;
72 }
73
configureChipForP2pAndGetIface()74 std::shared_ptr<IWifiP2pIface> configureChipForP2pAndGetIface() {
75 std::shared_ptr<IWifiP2pIface> iface;
76 configureChipForConcurrencyType(IfaceConcurrencyType::P2P);
77 EXPECT_TRUE(wifi_chip_->createP2pIface(&iface).isOk());
78 EXPECT_NE(nullptr, iface.get());
79 return iface;
80 }
81
configureChipForApAndGetIface()82 std::shared_ptr<IWifiApIface> configureChipForApAndGetIface() {
83 std::shared_ptr<IWifiApIface> iface;
84 configureChipForConcurrencyType(IfaceConcurrencyType::AP);
85 EXPECT_TRUE(wifi_chip_->createApIface(&iface).isOk());
86 EXPECT_NE(nullptr, iface.get());
87 return iface;
88 }
89
configureChipForNanAndGetIface()90 std::shared_ptr<IWifiNanIface> configureChipForNanAndGetIface() {
91 std::shared_ptr<IWifiNanIface> iface;
92 configureChipForConcurrencyType(IfaceConcurrencyType::NAN_IFACE);
93 EXPECT_TRUE(wifi_chip_->createNanIface(&iface).isOk());
94 EXPECT_NE(nullptr, iface.get());
95 return iface;
96 }
97
getStaIfaceName(const std::shared_ptr<IWifiStaIface> & iface)98 std::string getStaIfaceName(const std::shared_ptr<IWifiStaIface>& iface) {
99 std::string iface_name;
100 EXPECT_TRUE(iface->getName(&iface_name).isOk());
101 return iface_name;
102 }
103
getP2pIfaceName(const std::shared_ptr<IWifiP2pIface> & iface)104 std::string getP2pIfaceName(const std::shared_ptr<IWifiP2pIface>& iface) {
105 std::string iface_name;
106 EXPECT_TRUE(iface->getName(&iface_name).isOk());
107 return iface_name;
108 }
109
getApIfaceName(const std::shared_ptr<IWifiApIface> & iface)110 std::string getApIfaceName(const std::shared_ptr<IWifiApIface>& iface) {
111 std::string iface_name;
112 EXPECT_TRUE(iface->getName(&iface_name).isOk());
113 return iface_name;
114 }
115
getNanIfaceName(const std::shared_ptr<IWifiNanIface> & iface)116 std::string getNanIfaceName(const std::shared_ptr<IWifiNanIface>& iface) {
117 std::string iface_name;
118 EXPECT_TRUE(iface->getName(&iface_name).isOk());
119 return iface_name;
120 }
121
create2StaIfacesIfPossible()122 std::vector<std::shared_ptr<IWifiStaIface>> create2StaIfacesIfPossible() {
123 std::shared_ptr<IWifiStaIface> iface1 = configureChipForStaAndGetIface();
124
125 // Try create a create second iface.
126 std::shared_ptr<IWifiStaIface> iface2;
127 bool add_second_success = wifi_chip_->createStaIface(&iface2).isOk();
128 if (!add_second_success) {
129 return {iface1};
130 }
131 EXPECT_NE(nullptr, iface2.get());
132 return {iface1, iface2};
133 }
134
getInstanceName()135 const char* getInstanceName() { return GetParam().c_str(); }
136
137 std::shared_ptr<IWifiChip> wifi_chip_;
138 };
139
140 class WifiChipEventCallback : public BnWifiChipEventCallback {
141 public:
142 WifiChipEventCallback() = default;
143
onChipReconfigureFailure(WifiStatusCode)144 ::ndk::ScopedAStatus onChipReconfigureFailure(WifiStatusCode /* status */) override {
145 return ndk::ScopedAStatus::ok();
146 }
onChipReconfigured(int)147 ::ndk::ScopedAStatus onChipReconfigured(int /* modeId */) override {
148 return ndk::ScopedAStatus::ok();
149 }
onDebugErrorAlert(int,const std::vector<uint8_t> &)150 ::ndk::ScopedAStatus onDebugErrorAlert(int /* errorCode */,
151 const std::vector<uint8_t>& /* debugData */) override {
152 return ndk::ScopedAStatus::ok();
153 }
onDebugRingBufferDataAvailable(const WifiDebugRingBufferStatus &,const std::vector<uint8_t> &)154 ::ndk::ScopedAStatus onDebugRingBufferDataAvailable(
155 const WifiDebugRingBufferStatus& /* status */,
156 const std::vector<uint8_t>& /* data */) override {
157 return ndk::ScopedAStatus::ok();
158 }
onIfaceAdded(IfaceType,const std::string &)159 ::ndk::ScopedAStatus onIfaceAdded(IfaceType /* type */,
160 const std::string& /* name */) override {
161 return ndk::ScopedAStatus::ok();
162 }
onIfaceRemoved(IfaceType,const std::string &)163 ::ndk::ScopedAStatus onIfaceRemoved(IfaceType /* type */,
164 const std::string& /* name */) override {
165 return ndk::ScopedAStatus::ok();
166 }
onRadioModeChange(const std::vector<RadioModeInfo> &)167 ::ndk::ScopedAStatus onRadioModeChange(
168 const std::vector<RadioModeInfo>& /* radioModeInfos */) override {
169 return ndk::ScopedAStatus::ok();
170 }
171 };
172
173 /*
174 * RegisterEventCallback
175 *
176 * Note: it is not feasible to test the invocation of the callback function,
177 * since events are triggered internally in the HAL implementation and cannot be
178 * triggered from the test case.
179 */
TEST_P(WifiChipAidlTest,RegisterEventCallback)180 TEST_P(WifiChipAidlTest, RegisterEventCallback) {
181 std::shared_ptr<WifiChipEventCallback> callback =
182 ndk::SharedRefBase::make<WifiChipEventCallback>();
183 ASSERT_NE(nullptr, callback.get());
184 EXPECT_TRUE(wifi_chip_->registerEventCallback(callback).isOk());
185 }
186
187 /*
188 * GetFeatureSet
189 */
TEST_P(WifiChipAidlTest,GetFeatureSet)190 TEST_P(WifiChipAidlTest, GetFeatureSet) {
191 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
192 int32_t features;
193 EXPECT_TRUE(wifi_chip_->getFeatureSet(&features).isOk());
194 }
195
196 /*
197 * GetId
198 */
TEST_P(WifiChipAidlTest,GetId)199 TEST_P(WifiChipAidlTest, GetId) {
200 int id;
201 EXPECT_TRUE(wifi_chip_->getId(&id).isOk());
202 }
203
204 /*
205 * GetAvailableModes
206 */
TEST_P(WifiChipAidlTest,GetAvailableModes)207 TEST_P(WifiChipAidlTest, GetAvailableModes) {
208 std::vector<IWifiChip::ChipMode> modes;
209 EXPECT_TRUE(wifi_chip_->getAvailableModes(&modes).isOk());
210 EXPECT_NE(modes.size(), 0);
211 }
212
213 /*
214 * GetMode
215 */
TEST_P(WifiChipAidlTest,GetMode)216 TEST_P(WifiChipAidlTest, GetMode) {
217 int expected_mode = configureChipForConcurrencyType(IfaceConcurrencyType::STA);
218 int retrieved_mode;
219 EXPECT_TRUE(wifi_chip_->getMode(&retrieved_mode).isOk());
220 EXPECT_EQ(retrieved_mode, expected_mode);
221 }
222
223 /*
224 * GetUsableChannels
225 */
TEST_P(WifiChipAidlTest,GetUsableChannels)226 TEST_P(WifiChipAidlTest, GetUsableChannels) {
227 WifiBand band = WifiBand::BAND_24GHZ_5GHZ_6GHZ;
228 uint32_t ifaceModeMask = static_cast<uint32_t>(WifiIfaceMode::IFACE_MODE_P2P_CLIENT) |
229 static_cast<uint32_t>(WifiIfaceMode::IFACE_MODE_P2P_GO);
230 uint32_t filterMask =
231 static_cast<uint32_t>(IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE) |
232 static_cast<uint32_t>(IWifiChip::UsableChannelFilter::CONCURRENCY);
233
234 std::vector<WifiUsableChannel> channels;
235 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
236 auto status = wifi_chip_->getUsableChannels(band, ifaceModeMask, filterMask, &channels);
237 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
238 GTEST_SKIP() << "getUsableChannels() is not supported by vendor.";
239 }
240 EXPECT_TRUE(status.isOk());
241 }
242
243 /*
244 * GetSupportedRadioCombinations
245 */
TEST_P(WifiChipAidlTest,GetSupportedRadioCombinations)246 TEST_P(WifiChipAidlTest, GetSupportedRadioCombinations) {
247 std::vector<WifiRadioCombination> combinations;
248 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
249 auto status = wifi_chip_->getSupportedRadioCombinations(&combinations);
250 if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
251 GTEST_SKIP() << "Skipping this test since getSupportedRadioCombinations() "
252 "is not supported by vendor.";
253 }
254 EXPECT_TRUE(status.isOk());
255 }
256
257 /*
258 * SetCountryCode
259 */
TEST_P(WifiChipAidlTest,SetCountryCode)260 TEST_P(WifiChipAidlTest, SetCountryCode) {
261 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
262 std::array<uint8_t, 2> country_code = {0x55, 0x53};
263 EXPECT_TRUE(wifi_chip_->setCountryCode(country_code).isOk());
264 }
265
266 /*
267 * SetLatencyMode_normal
268 * Tests the setLatencyMode() API with Latency mode NORMAL.
269 */
TEST_P(WifiChipAidlTest,SetLatencyMode_normal)270 TEST_P(WifiChipAidlTest, SetLatencyMode_normal) {
271 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
272 int32_t features = getChipFeatureSet(wifi_chip_);
273 auto status = wifi_chip_->setLatencyMode(IWifiChip::LatencyMode::NORMAL);
274 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_LATENCY_MODE)) {
275 EXPECT_TRUE(status.isOk());
276 } else {
277 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
278 }
279 }
280
281 /*
282 * SetLatencyMode_low
283 * Tests the setLatencyMode() API with Latency mode LOW.
284 */
TEST_P(WifiChipAidlTest,SetLatencyMode_low)285 TEST_P(WifiChipAidlTest, SetLatencyMode_low) {
286 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
287 int32_t features = getChipFeatureSet(wifi_chip_);
288 auto status = wifi_chip_->setLatencyMode(IWifiChip::LatencyMode::LOW);
289 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_LATENCY_MODE)) {
290 EXPECT_TRUE(status.isOk());
291 } else {
292 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
293 }
294 }
295
296 /*
297 * SetMultiStaPrimaryConnection
298 *
299 * Only runs if the device supports 2 STA ifaces.
300 */
TEST_P(WifiChipAidlTest,SetMultiStaPrimaryConnection)301 TEST_P(WifiChipAidlTest, SetMultiStaPrimaryConnection) {
302 auto ifaces = create2StaIfacesIfPossible();
303 if (ifaces.size() < 2) {
304 GTEST_SKIP() << "Device does not support more than 1 STA concurrently";
305 }
306
307 auto status = wifi_chip_->setMultiStaPrimaryConnection(getStaIfaceName(ifaces[0]));
308 if (!status.isOk()) {
309 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
310 }
311 }
312
313 /*
314 * SetMultiStaUseCase
315 *
316 * Only runs if the device supports 2 STA ifaces.
317 */
TEST_P(WifiChipAidlTest,setMultiStaUseCase)318 TEST_P(WifiChipAidlTest, setMultiStaUseCase) {
319 auto ifaces = create2StaIfacesIfPossible();
320 if (ifaces.size() < 2) {
321 GTEST_SKIP() << "Device does not support more than 1 STA concurrently";
322 }
323
324 auto status = wifi_chip_->setMultiStaUseCase(
325 IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY);
326 if (!status.isOk()) {
327 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
328 }
329 }
330
331 /*
332 * SetCoexUnsafeChannels
333 */
TEST_P(WifiChipAidlTest,SetCoexUnsafeChannels)334 TEST_P(WifiChipAidlTest, SetCoexUnsafeChannels) {
335 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
336
337 // Test with an empty vector of CoexUnsafeChannels.
338 std::vector<IWifiChip::CoexUnsafeChannel> vec;
339 int restrictions = 0;
340 auto status = wifi_chip_->setCoexUnsafeChannels(vec, restrictions);
341 if (!status.isOk()) {
342 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
343 }
344
345 // Test with a non-empty vector of CoexUnsafeChannels.
346 IWifiChip::CoexUnsafeChannel unsafeChannel24Ghz;
347 unsafeChannel24Ghz.band = WifiBand::BAND_24GHZ;
348 unsafeChannel24Ghz.channel = 6;
349 vec.push_back(unsafeChannel24Ghz);
350 IWifiChip::CoexUnsafeChannel unsafeChannel5Ghz;
351 unsafeChannel5Ghz.band = WifiBand::BAND_5GHZ;
352 unsafeChannel5Ghz.channel = 36;
353 vec.push_back(unsafeChannel5Ghz);
354 restrictions = static_cast<int32_t>(IWifiChip::CoexRestriction::WIFI_AWARE) |
355 static_cast<int32_t>(IWifiChip::CoexRestriction::SOFTAP) |
356 static_cast<int32_t>(IWifiChip::CoexRestriction::WIFI_DIRECT);
357
358 status = wifi_chip_->setCoexUnsafeChannels(vec, restrictions);
359 if (!status.isOk()) {
360 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
361 }
362 }
363
364 /*
365 * SelectTxPowerScenario - Body
366 */
TEST_P(WifiChipAidlTest,SelectTxPowerScenario_body)367 TEST_P(WifiChipAidlTest, SelectTxPowerScenario_body) {
368 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
369 int32_t features = getChipFeatureSet(wifi_chip_);
370 int32_t expected_features =
371 static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_TX_POWER_LIMIT) |
372 static_cast<int32_t>(IWifiChip::FeatureSetMask::USE_BODY_HEAD_SAR);
373 auto status = wifi_chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF);
374 if (features & expected_features) {
375 EXPECT_TRUE(status.isOk());
376 } else {
377 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
378 }
379 }
380
381 /*
382 * SelectTxPowerScenario - Voice Call
383 */
TEST_P(WifiChipAidlTest,SelectTxPowerScenario_voiceCall)384 TEST_P(WifiChipAidlTest, SelectTxPowerScenario_voiceCall) {
385 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
386 int32_t features = getChipFeatureSet(wifi_chip_);
387 auto status = wifi_chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::VOICE_CALL);
388 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_TX_POWER_LIMIT)) {
389 EXPECT_TRUE(status.isOk());
390 } else {
391 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
392 }
393 }
394
395 /*
396 * ResetTxPowerScenario
397 */
TEST_P(WifiChipAidlTest,ResetTxPowerScenario)398 TEST_P(WifiChipAidlTest, ResetTxPowerScenario) {
399 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
400 int32_t features = getChipFeatureSet(wifi_chip_);
401 auto status = wifi_chip_->resetTxPowerScenario();
402 if (features & static_cast<int32_t>(IWifiChip::FeatureSetMask::SET_TX_POWER_LIMIT)) {
403 EXPECT_TRUE(status.isOk());
404 } else {
405 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
406 }
407 }
408
409 /*
410 * ConfigureChip
411 */
TEST_P(WifiChipAidlTest,ConfigureChip)412 TEST_P(WifiChipAidlTest, ConfigureChip) {
413 std::vector<IWifiChip::ChipMode> modes;
414 EXPECT_TRUE(wifi_chip_->getAvailableModes(&modes).isOk());
415 EXPECT_NE(modes.size(), 0);
416 for (const auto& mode : modes) {
417 // configureChip() requires a fresh IWifiChip object.
418 wifi_chip_ = getWifiChip(getInstanceName());
419 ASSERT_NE(nullptr, wifi_chip_.get());
420 EXPECT_TRUE(wifi_chip_->configureChip(mode.id).isOk());
421 stopWifiService(getInstanceName());
422 // Sleep for 5 milliseconds between each wifi state toggle.
423 usleep(5000);
424 }
425 }
426
427 /*
428 * RequestChipDebugInfo
429 */
TEST_P(WifiChipAidlTest,RequestChipDebugInfo)430 TEST_P(WifiChipAidlTest, RequestChipDebugInfo) {
431 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
432 IWifiChip::ChipDebugInfo debug_info = {};
433 EXPECT_TRUE(wifi_chip_->requestChipDebugInfo(&debug_info).isOk());
434 EXPECT_NE(debug_info.driverDescription.size(), 0);
435 EXPECT_NE(debug_info.firmwareDescription.size(), 0);
436 }
437
438 /*
439 * RequestFirmwareDebugDump
440 */
TEST_P(WifiChipAidlTest,RequestFirmwareDebugDump)441 TEST_P(WifiChipAidlTest, RequestFirmwareDebugDump) {
442 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
443 std::vector<uint8_t> debug_dump;
444 auto status = wifi_chip_->requestFirmwareDebugDump(&debug_dump);
445 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
446 }
447
448 /*
449 * RequestDriverDebugDump
450 */
TEST_P(WifiChipAidlTest,RequestDriverDebugDump)451 TEST_P(WifiChipAidlTest, RequestDriverDebugDump) {
452 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
453 std::vector<uint8_t> debug_dump;
454 auto status = wifi_chip_->requestDriverDebugDump(&debug_dump);
455 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
456 }
457
458 /*
459 * GetDebugRingBuffersStatus
460 */
TEST_P(WifiChipAidlTest,GetDebugRingBuffersStatus)461 TEST_P(WifiChipAidlTest, GetDebugRingBuffersStatus) {
462 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
463 std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
464 auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
465 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
466 if (status.isOk()) {
467 ASSERT_NE(ring_buffer_status.size(), 0);
468 for (const auto& ring_buffer : ring_buffer_status) {
469 EXPECT_NE(ring_buffer.ringName.size(), 0);
470 }
471 }
472 }
473
474 /*
475 * GetDebugHostWakeReasonStats
476 */
TEST_P(WifiChipAidlTest,GetDebugHostWakeReasonStats)477 TEST_P(WifiChipAidlTest, GetDebugHostWakeReasonStats) {
478 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
479 WifiDebugHostWakeReasonStats wake_reason_stats = {};
480 auto status = wifi_chip_->getDebugHostWakeReasonStats(&wake_reason_stats);
481 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
482 }
483
484 /*
485 * StartLoggingToDebugRingBuffer
486 */
TEST_P(WifiChipAidlTest,StartLoggingToDebugRingBuffer)487 TEST_P(WifiChipAidlTest, StartLoggingToDebugRingBuffer) {
488 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
489 std::string ring_name;
490 std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
491
492 auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
493 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
494 if (status.isOk()) {
495 ASSERT_NE(ring_buffer_status.size(), 0);
496 ring_name = ring_buffer_status[0].ringName;
497 }
498
499 status = wifi_chip_->startLoggingToDebugRingBuffer(
500 ring_name, WifiDebugRingBufferVerboseLevel::VERBOSE, 5, 1024);
501 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
502 }
503
504 /*
505 * ForceDumpToDebugRingBuffer
506 */
TEST_P(WifiChipAidlTest,ForceDumpToDebugRingBuffer)507 TEST_P(WifiChipAidlTest, ForceDumpToDebugRingBuffer) {
508 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
509 std::string ring_name;
510 std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
511
512 auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
513 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
514 if (status.isOk()) {
515 ASSERT_NE(ring_buffer_status.size(), 0);
516 ring_name = ring_buffer_status[0].ringName;
517 }
518
519 status = wifi_chip_->forceDumpToDebugRingBuffer(ring_name);
520 EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
521 }
522
523 /*
524 * CreateStaIface
525 * Configures the chip in STA mode and creates an iface.
526 */
TEST_P(WifiChipAidlTest,CreateStaIface)527 TEST_P(WifiChipAidlTest, CreateStaIface) {
528 configureChipForStaAndGetIface();
529 }
530
531 /*
532 * CreateApIface
533 */
TEST_P(WifiChipAidlTest,CreateApIface)534 TEST_P(WifiChipAidlTest, CreateApIface) {
535 configureChipForApAndGetIface();
536 }
537
538 /*
539 * CreateNanIface
540 */
TEST_P(WifiChipAidlTest,CreateNanIface)541 TEST_P(WifiChipAidlTest, CreateNanIface) {
542 if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware")) {
543 GTEST_SKIP() << "Skipping this test since NAN is not supported.";
544 }
545 configureChipForNanAndGetIface();
546 }
547
548 /*
549 * CreateP2pIface
550 */
TEST_P(WifiChipAidlTest,CreateP2pIface)551 TEST_P(WifiChipAidlTest, CreateP2pIface) {
552 configureChipForP2pAndGetIface();
553 }
554
555 /*
556 * GetStaIfaceNames
557 * Configures the chip in STA mode and ensures that the iface name list is
558 * empty before creating the iface. Then create the iface and ensure that
559 * iface name is returned in the iface name list.
560 */
TEST_P(WifiChipAidlTest,GetStaIfaceNames)561 TEST_P(WifiChipAidlTest, GetStaIfaceNames) {
562 configureChipForConcurrencyType(IfaceConcurrencyType::STA);
563
564 std::vector<std::string> iface_names;
565 EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
566 EXPECT_EQ(iface_names.size(), 0);
567
568 std::shared_ptr<IWifiStaIface> iface;
569 EXPECT_TRUE(wifi_chip_->createStaIface(&iface).isOk());
570 ASSERT_NE(nullptr, iface.get());
571
572 std::string iface_name = getStaIfaceName(iface);
573 EXPECT_TRUE(wifi_chip_->getStaIfaceNames(&iface_names).isOk());
574 EXPECT_EQ(iface_names.size(), 1);
575 EXPECT_EQ(iface_name, iface_names[0]);
576
577 EXPECT_TRUE(wifi_chip_->removeStaIface(iface_name).isOk());
578 EXPECT_TRUE(wifi_chip_->getStaIfaceNames(&iface_names).isOk());
579 EXPECT_EQ(iface_names.size(), 0);
580 }
581
582 /*
583 * GetP2pIfaceNames
584 */
TEST_P(WifiChipAidlTest,GetP2pIfaceNames)585 TEST_P(WifiChipAidlTest, GetP2pIfaceNames) {
586 configureChipForConcurrencyType(IfaceConcurrencyType::P2P);
587
588 std::vector<std::string> iface_names;
589 EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
590 EXPECT_EQ(iface_names.size(), 0);
591
592 std::shared_ptr<IWifiP2pIface> iface;
593 EXPECT_TRUE(wifi_chip_->createP2pIface(&iface).isOk());
594 ASSERT_NE(nullptr, iface.get());
595
596 std::string iface_name = getP2pIfaceName(iface);
597 EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
598 EXPECT_EQ(iface_names.size(), 1);
599 EXPECT_EQ(iface_name, iface_names[0]);
600
601 EXPECT_TRUE(wifi_chip_->removeP2pIface(iface_name).isOk());
602 EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
603 EXPECT_EQ(iface_names.size(), 0);
604 }
605
606 /*
607 * GetApIfaceNames
608 */
TEST_P(WifiChipAidlTest,GetApIfaceNames)609 TEST_P(WifiChipAidlTest, GetApIfaceNames) {
610 configureChipForConcurrencyType(IfaceConcurrencyType::AP);
611
612 std::vector<std::string> iface_names;
613 EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
614 EXPECT_EQ(iface_names.size(), 0);
615
616 std::shared_ptr<IWifiApIface> iface;
617 EXPECT_TRUE(wifi_chip_->createApIface(&iface).isOk());
618 ASSERT_NE(nullptr, iface.get());
619
620 std::string iface_name = getApIfaceName(iface);
621 EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
622 EXPECT_EQ(iface_names.size(), 1);
623 EXPECT_EQ(iface_name, iface_names[0]);
624
625 EXPECT_TRUE(wifi_chip_->removeApIface(iface_name).isOk());
626 EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
627 EXPECT_EQ(iface_names.size(), 0);
628 }
629
630 /*
631 * GetNanIfaceNames
632 */
TEST_P(WifiChipAidlTest,GetNanIfaceNames)633 TEST_P(WifiChipAidlTest, GetNanIfaceNames) {
634 if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware")) {
635 GTEST_SKIP() << "Skipping this test since NAN is not supported.";
636 }
637 configureChipForConcurrencyType(IfaceConcurrencyType::NAN_IFACE);
638
639 std::vector<std::string> iface_names;
640 EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
641 EXPECT_EQ(iface_names.size(), 0);
642
643 std::shared_ptr<IWifiNanIface> iface;
644 EXPECT_TRUE(wifi_chip_->createNanIface(&iface).isOk());
645 ASSERT_NE(nullptr, iface.get());
646
647 std::string iface_name = getNanIfaceName(iface);
648 EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
649 EXPECT_EQ(iface_names.size(), 1);
650 EXPECT_EQ(iface_name, iface_names[0]);
651
652 EXPECT_TRUE(wifi_chip_->removeNanIface(iface_name).isOk());
653 EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
654 EXPECT_EQ(iface_names.size(), 0);
655 }
656
657 /*
658 * GetStaIface
659 * Configures the chip in STA mode and creates an iface. Then retrieves
660 * the iface object using its name and ensures that any other name
661 * doesn't retrieve a valid iface object.
662 */
TEST_P(WifiChipAidlTest,GetStaIface)663 TEST_P(WifiChipAidlTest, GetStaIface) {
664 std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
665 std::string iface_name = getStaIfaceName(iface);
666
667 std::shared_ptr<IWifiStaIface> retrieved_iface;
668 EXPECT_TRUE(wifi_chip_->getStaIface(iface_name, &retrieved_iface).isOk());
669 EXPECT_NE(nullptr, retrieved_iface.get());
670
671 std::string invalid_name = iface_name + "0";
672 std::shared_ptr<IWifiStaIface> invalid_iface;
673 auto status = wifi_chip_->getStaIface(invalid_name, &invalid_iface);
674 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
675 EXPECT_EQ(nullptr, invalid_iface.get());
676 }
677
678 /*
679 * GetP2pIface
680 */
TEST_P(WifiChipAidlTest,GetP2pIface)681 TEST_P(WifiChipAidlTest, GetP2pIface) {
682 std::shared_ptr<IWifiP2pIface> iface = configureChipForP2pAndGetIface();
683 std::string iface_name = getP2pIfaceName(iface);
684
685 std::shared_ptr<IWifiP2pIface> retrieved_iface;
686 EXPECT_TRUE(wifi_chip_->getP2pIface(iface_name, &retrieved_iface).isOk());
687 EXPECT_NE(nullptr, retrieved_iface.get());
688
689 std::string invalid_name = iface_name + "0";
690 std::shared_ptr<IWifiP2pIface> invalid_iface;
691 auto status = wifi_chip_->getP2pIface(invalid_name, &invalid_iface);
692 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
693 EXPECT_EQ(nullptr, invalid_iface.get());
694 }
695
696 /*
697 * GetApIface
698 */
TEST_P(WifiChipAidlTest,GetApIface)699 TEST_P(WifiChipAidlTest, GetApIface) {
700 std::shared_ptr<IWifiApIface> iface = configureChipForApAndGetIface();
701 std::string iface_name = getApIfaceName(iface);
702
703 std::shared_ptr<IWifiApIface> retrieved_iface;
704 EXPECT_TRUE(wifi_chip_->getApIface(iface_name, &retrieved_iface).isOk());
705 EXPECT_NE(nullptr, retrieved_iface.get());
706
707 std::string invalid_name = iface_name + "0";
708 std::shared_ptr<IWifiApIface> invalid_iface;
709 auto status = wifi_chip_->getApIface(invalid_name, &invalid_iface);
710 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
711 EXPECT_EQ(nullptr, invalid_iface.get());
712 }
713
714 /*
715 * GetNanIface
716 */
TEST_P(WifiChipAidlTest,GetNanIface)717 TEST_P(WifiChipAidlTest, GetNanIface) {
718 if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware")) {
719 GTEST_SKIP() << "Skipping this test since NAN is not supported.";
720 }
721 std::shared_ptr<IWifiNanIface> iface = configureChipForNanAndGetIface();
722 std::string iface_name = getNanIfaceName(iface);
723
724 std::shared_ptr<IWifiNanIface> retrieved_iface;
725 EXPECT_TRUE(wifi_chip_->getNanIface(iface_name, &retrieved_iface).isOk());
726 EXPECT_NE(nullptr, retrieved_iface.get());
727
728 std::string invalid_name = iface_name + "0";
729 std::shared_ptr<IWifiNanIface> invalid_iface;
730 auto status = wifi_chip_->getNanIface(invalid_name, &invalid_iface);
731 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
732 EXPECT_EQ(nullptr, invalid_iface.get());
733 }
734
735 /*
736 * RemoveStaIface
737 * Configures the chip in STA mode and creates an iface. Then removes
738 * the iface object using the correct name and ensures that any other
739 * name doesn't remove the iface.
740 */
TEST_P(WifiChipAidlTest,RemoveStaIface)741 TEST_P(WifiChipAidlTest, RemoveStaIface) {
742 std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
743 std::string iface_name = getStaIfaceName(iface);
744
745 std::string invalid_name = iface_name + "0";
746 auto status = wifi_chip_->removeStaIface(invalid_name);
747 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
748 EXPECT_TRUE(wifi_chip_->removeStaIface(iface_name).isOk());
749
750 // No such iface exists now, so this should return failure.
751 EXPECT_FALSE(wifi_chip_->removeStaIface(iface_name).isOk());
752 }
753
754 /*
755 * RemoveP2pIface
756 */
TEST_P(WifiChipAidlTest,RemoveP2pIface)757 TEST_P(WifiChipAidlTest, RemoveP2pIface) {
758 std::shared_ptr<IWifiP2pIface> iface = configureChipForP2pAndGetIface();
759 std::string iface_name = getP2pIfaceName(iface);
760
761 std::string invalid_name = iface_name + "0";
762 auto status = wifi_chip_->removeP2pIface(invalid_name);
763 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
764 EXPECT_TRUE(wifi_chip_->removeP2pIface(iface_name).isOk());
765
766 // No such iface exists now, so this should return failure.
767 EXPECT_FALSE(wifi_chip_->removeP2pIface(iface_name).isOk());
768 }
769
770 /*
771 * RemoveApIface
772 */
TEST_P(WifiChipAidlTest,RemoveApIface)773 TEST_P(WifiChipAidlTest, RemoveApIface) {
774 std::shared_ptr<IWifiApIface> iface = configureChipForApAndGetIface();
775 std::string iface_name = getApIfaceName(iface);
776
777 std::string invalid_name = iface_name + "0";
778 auto status = wifi_chip_->removeApIface(invalid_name);
779 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
780 EXPECT_TRUE(wifi_chip_->removeApIface(iface_name).isOk());
781
782 // No such iface exists now, so this should return failure.
783 EXPECT_FALSE(wifi_chip_->removeApIface(iface_name).isOk());
784 }
785
786 /*
787 * RemoveNanIface
788 */
TEST_P(WifiChipAidlTest,RemoveNanIface)789 TEST_P(WifiChipAidlTest, RemoveNanIface) {
790 if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware")) {
791 GTEST_SKIP() << "Skipping this test since NAN is not supported.";
792 }
793 std::shared_ptr<IWifiNanIface> iface = configureChipForNanAndGetIface();
794 std::string iface_name = getNanIfaceName(iface);
795
796 std::string invalid_name = iface_name + "0";
797 auto status = wifi_chip_->removeNanIface(invalid_name);
798 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
799 EXPECT_TRUE(wifi_chip_->removeNanIface(iface_name).isOk());
800
801 // No such iface exists now, so this should return failure.
802 EXPECT_FALSE(wifi_chip_->removeNanIface(iface_name).isOk());
803 }
804
805 /*
806 * CreateRttController
807 */
TEST_P(WifiChipAidlTest,CreateRttController)808 TEST_P(WifiChipAidlTest, CreateRttController) {
809 std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
810 std::shared_ptr<IWifiRttController> rtt_controller;
811 auto status = wifi_chip_->createRttController(iface, &rtt_controller);
812 if (status.isOk()) {
813 EXPECT_NE(nullptr, rtt_controller.get());
814 } else {
815 EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
816 }
817 }
818
819 /**
820 * CreateBridgedApIface & RemoveIfaceInstanceFromBridgedApIface
821 */
TEST_P(WifiChipAidlTest,CreateBridgedApIfaceAndremoveIfaceInstanceFromBridgedApIfaceTest)822 TEST_P(WifiChipAidlTest, CreateBridgedApIfaceAndremoveIfaceInstanceFromBridgedApIfaceTest) {
823 bool isBridgedSupport = testing::checkSubstringInCommandOutput(
824 "/system/bin/cmd wifi get-softap-supported-features",
825 "wifi_softap_bridged_ap_supported");
826 if (!isBridgedSupport) {
827 GTEST_SKIP() << "Missing Bridged AP support";
828 }
829
830 std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
831 ASSERT_NE(nullptr, wifi_chip.get());
832 std::shared_ptr<IWifiApIface> wifi_ap_iface = getBridgedWifiApIface(wifi_chip);
833 ASSERT_NE(nullptr, wifi_ap_iface.get());
834
835 std::string br_name;
836 std::vector<std::string> instances;
837 EXPECT_TRUE(wifi_ap_iface->getName(&br_name).isOk());
838 EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
839 EXPECT_EQ(instances.size(), 2);
840
841 std::vector<std::string> instances_after_remove;
842 EXPECT_TRUE(wifi_chip->removeIfaceInstanceFromBridgedApIface(br_name, instances[0]).isOk());
843 EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances_after_remove).isOk());
844 EXPECT_EQ(instances_after_remove.size(), 1);
845 }
846
847 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiChipAidlTest);
848 INSTANTIATE_TEST_SUITE_P(WifiTest, WifiChipAidlTest,
849 testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
850 android::PrintInstanceNameToString);
851
main(int argc,char ** argv)852 int main(int argc, char** argv) {
853 ::testing::InitGoogleTest(&argc, argv);
854 android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
855 android::ProcessState::self()->startThreadPool();
856 return RUN_ALL_TESTS();
857 }
858