1 /* 2 * Copyright (C) 2016 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 <android-base/logging.h> 18 19 #include <android/hardware/wifi/1.0/IWifiChip.h> 20 21 #include <VtsHalHidlTargetTestBase.h> 22 23 #include "wifi_hidl_call_util.h" 24 #include "wifi_hidl_test_utils.h" 25 26 using ::android::sp; 27 using ::android::hardware::hidl_string; 28 using ::android::hardware::hidl_vec; 29 using ::android::hardware::wifi::V1_0::IfaceType; 30 using ::android::hardware::wifi::V1_0::ChipId; 31 using ::android::hardware::wifi::V1_0::ChipModeId; 32 using ::android::hardware::wifi::V1_0::WifiDebugRingBufferStatus; 33 using ::android::hardware::wifi::V1_0::WifiDebugRingBufferVerboseLevel; 34 using ::android::hardware::wifi::V1_0::WifiDebugHostWakeReasonStats; 35 using ::android::hardware::wifi::V1_0::WifiStatus; 36 using ::android::hardware::wifi::V1_0::WifiStatusCode; 37 using ::android::hardware::wifi::V1_0::IWifiChip; 38 using ::android::hardware::wifi::V1_0::IWifiApIface; 39 using ::android::hardware::wifi::V1_0::IWifiIface; 40 using ::android::hardware::wifi::V1_0::IWifiNanIface; 41 using ::android::hardware::wifi::V1_0::IWifiP2pIface; 42 using ::android::hardware::wifi::V1_0::IWifiRttController; 43 using ::android::hardware::wifi::V1_0::IWifiStaIface; 44 45 extern WifiHidlEnvironment* gEnv; 46 47 namespace { 48 constexpr WifiDebugRingBufferVerboseLevel kDebugRingBufferVerboseLvl = 49 WifiDebugRingBufferVerboseLevel::VERBOSE; 50 constexpr uint32_t kDebugRingBufferMaxInterval = 5; 51 constexpr uint32_t kDebugRingBufferMaxDataSize = 1024; 52 53 /** 54 * Check if any of the ring buffer capabilities are set. 55 */ 56 bool hasAnyRingBufferCapabilities(uint32_t caps) { 57 return (caps & 58 (IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_CONNECT_EVENT | 59 IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_POWER_EVENT | 60 IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_WAKELOCK_EVENT | 61 IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_VENDOR_DATA)); 62 } 63 } // namespace 64 65 /** 66 * Fixture to use for all Wifi chip HIDL interface tests. 67 */ 68 class WifiChipHidlTest : public ::testing::VtsHalHidlTargetTestBase { 69 public: 70 virtual void SetUp() override { 71 wifi_chip_ = getWifiChip(); 72 ASSERT_NE(nullptr, wifi_chip_.get()); 73 } 74 75 virtual void TearDown() override { stopWifi(); } 76 77 protected: 78 // Helper function to configure the Chip in one of the supported modes. 79 // Most of the non-mode-configuration-related methods require chip 80 // to be first configured. 81 ChipModeId configureChipForIfaceType(IfaceType type, bool expectSuccess) { 82 ChipModeId mode_id; 83 EXPECT_EQ(expectSuccess, 84 configureChipToSupportIfaceType(wifi_chip_, type, &mode_id)); 85 return mode_id; 86 } 87 88 uint32_t configureChipForStaIfaceAndGetCapabilities() { 89 configureChipForIfaceType(IfaceType::STA, true); 90 const auto& status_and_caps = HIDL_INVOKE(wifi_chip_, getCapabilities); 91 if (status_and_caps.first.code != WifiStatusCode::SUCCESS) { 92 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status_and_caps.first.code); 93 return 0; 94 } 95 return status_and_caps.second; 96 } 97 98 std::string getIfaceName(const sp<IWifiIface>& iface) { 99 const auto& status_and_name = HIDL_INVOKE(iface, getName); 100 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_name.first.code); 101 return status_and_name.second; 102 } 103 104 WifiStatusCode createApIface(sp<IWifiApIface>* ap_iface) { 105 const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createApIface); 106 *ap_iface = status_and_iface.second; 107 return status_and_iface.first.code; 108 } 109 110 WifiStatusCode removeApIface(const std::string& name) { 111 return HIDL_INVOKE(wifi_chip_, removeApIface, name).code; 112 } 113 114 WifiStatusCode createNanIface(sp<IWifiNanIface>* nan_iface) { 115 const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createNanIface); 116 *nan_iface = status_and_iface.second; 117 return status_and_iface.first.code; 118 } 119 120 WifiStatusCode removeNanIface(const std::string& name) { 121 return HIDL_INVOKE(wifi_chip_, removeNanIface, name).code; 122 } 123 124 WifiStatusCode createP2pIface(sp<IWifiP2pIface>* p2p_iface) { 125 const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createP2pIface); 126 *p2p_iface = status_and_iface.second; 127 return status_and_iface.first.code; 128 } 129 130 WifiStatusCode removeP2pIface(const std::string& name) { 131 return HIDL_INVOKE(wifi_chip_, removeP2pIface, name).code; 132 } 133 134 WifiStatusCode createStaIface(sp<IWifiStaIface>* sta_iface) { 135 const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createStaIface); 136 *sta_iface = status_and_iface.second; 137 return status_and_iface.first.code; 138 } 139 140 WifiStatusCode removeStaIface(const std::string& name) { 141 return HIDL_INVOKE(wifi_chip_, removeStaIface, name).code; 142 } 143 144 sp<IWifiChip> wifi_chip_; 145 }; 146 147 /* 148 * Create: 149 * Ensures that an instance of the IWifiChip proxy object is 150 * successfully created. 151 */ 152 TEST(WifiChipHidlTestNoFixture, Create) { 153 EXPECT_NE(nullptr, getWifiChip().get()); 154 stopWifi(); 155 } 156 157 /* 158 * GetId: 159 */ 160 TEST_F(WifiChipHidlTest, GetId) { 161 EXPECT_EQ(WifiStatusCode::SUCCESS, 162 HIDL_INVOKE(wifi_chip_, getId).first.code); 163 } 164 165 /* 166 * GetAvailableMode: 167 */ 168 TEST_F(WifiChipHidlTest, GetAvailableModes) { 169 const auto& status_and_modes = HIDL_INVOKE(wifi_chip_, getAvailableModes); 170 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_modes.first.code); 171 EXPECT_LT(0u, status_and_modes.second.size()); 172 } 173 174 /* 175 * ConfigureChip: 176 */ 177 TEST_F(WifiChipHidlTest, ConfigureChip) { 178 const auto& status_and_modes = HIDL_INVOKE(wifi_chip_, getAvailableModes); 179 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_modes.first.code); 180 EXPECT_LT(0u, status_and_modes.second.size()); 181 for (const auto& mode : status_and_modes.second) { 182 // configureChip() requires to be called with a fresh IWifiChip object. 183 wifi_chip_ = getWifiChip(); 184 ASSERT_NE(nullptr, wifi_chip_.get()); 185 EXPECT_EQ(WifiStatusCode::SUCCESS, 186 HIDL_INVOKE(wifi_chip_, configureChip, mode.id).code); 187 stopWifi(); 188 // Sleep for 5 milliseconds between each wifi state toggle. 189 usleep(5000); 190 } 191 } 192 193 /* 194 * GetCapabilities: 195 */ 196 TEST_F(WifiChipHidlTest, GetCapabilities) { 197 configureChipForIfaceType(IfaceType::STA, true); 198 const auto& status_and_caps = HIDL_INVOKE(wifi_chip_, getCapabilities); 199 if (status_and_caps.first.code != WifiStatusCode::SUCCESS) { 200 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status_and_caps.first.code); 201 return; 202 } 203 EXPECT_NE(0u, status_and_caps.second); 204 } 205 206 /* 207 * GetMode: 208 */ 209 TEST_F(WifiChipHidlTest, GetMode) { 210 ChipModeId chip_mode_id = configureChipForIfaceType(IfaceType::STA, true); 211 const auto& status_and_mode = HIDL_INVOKE(wifi_chip_, getMode); 212 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_mode.first.code); 213 EXPECT_EQ(chip_mode_id, status_and_mode.second); 214 } 215 216 /* 217 * RequestChipDebugInfo: 218 */ 219 TEST_F(WifiChipHidlTest, RequestChipDebugInfo) { 220 configureChipForIfaceType(IfaceType::STA, true); 221 const auto& status_and_chip_info = 222 HIDL_INVOKE(wifi_chip_, requestChipDebugInfo); 223 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_chip_info.first.code); 224 EXPECT_LT(0u, status_and_chip_info.second.driverDescription.size()); 225 EXPECT_LT(0u, status_and_chip_info.second.firmwareDescription.size()); 226 } 227 228 /* 229 * RequestFirmwareDebugDump 230 */ 231 TEST_F(WifiChipHidlTest, RequestFirmwareDebugDump) { 232 uint32_t caps = configureChipForStaIfaceAndGetCapabilities(); 233 const auto& status_and_firmware_dump = 234 HIDL_INVOKE(wifi_chip_, requestFirmwareDebugDump); 235 if (caps & IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_FIRMWARE_DUMP) { 236 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_firmware_dump.first.code); 237 } else { 238 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, 239 status_and_firmware_dump.first.code); 240 } 241 } 242 243 /* 244 * RequestDriverDebugDump 245 */ 246 TEST_F(WifiChipHidlTest, RequestDriverDebugDump) { 247 uint32_t caps = configureChipForStaIfaceAndGetCapabilities(); 248 const auto& status_and_driver_dump = 249 HIDL_INVOKE(wifi_chip_, requestDriverDebugDump); 250 if (caps & IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_DRIVER_DUMP) { 251 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_driver_dump.first.code); 252 } else { 253 // API semantics (today) are such that function cannot be called if not capable! 254 // 255 // EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, 256 // status_and_driver_dump.first.code); 257 } 258 } 259 260 /* 261 * GetDebugRingBuffersStatus 262 */ 263 TEST_F(WifiChipHidlTest, GetDebugRingBuffersStatus) { 264 uint32_t caps = configureChipForStaIfaceAndGetCapabilities(); 265 const auto& status_and_ring_buffer_status = 266 HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus); 267 if (hasAnyRingBufferCapabilities(caps)) { 268 EXPECT_EQ(WifiStatusCode::SUCCESS, 269 status_and_ring_buffer_status.first.code); 270 for (const auto& ring_buffer : status_and_ring_buffer_status.second) { 271 EXPECT_LT(0u, ring_buffer.ringName.size()); 272 } 273 } else { 274 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, 275 status_and_ring_buffer_status.first.code); 276 } 277 } 278 279 /* 280 * StartLoggingToDebugRingBuffer 281 */ 282 TEST_F(WifiChipHidlTest, StartLoggingToDebugRingBuffer) { 283 uint32_t caps = configureChipForStaIfaceAndGetCapabilities(); 284 std::string ring_name; 285 const auto& status_and_ring_buffer_status = 286 HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus); 287 if (hasAnyRingBufferCapabilities(caps)) { 288 EXPECT_EQ(WifiStatusCode::SUCCESS, 289 status_and_ring_buffer_status.first.code); 290 ASSERT_LT(0u, status_and_ring_buffer_status.second.size()); 291 ring_name = status_and_ring_buffer_status.second[0].ringName.c_str(); 292 } else { 293 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, 294 status_and_ring_buffer_status.first.code); 295 } 296 const auto& status = 297 HIDL_INVOKE(wifi_chip_, startLoggingToDebugRingBuffer, ring_name, 298 kDebugRingBufferVerboseLvl, kDebugRingBufferMaxInterval, 299 kDebugRingBufferMaxDataSize); 300 if (hasAnyRingBufferCapabilities(caps)) { 301 EXPECT_EQ(WifiStatusCode::SUCCESS, status.code); 302 } else { 303 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status.code); 304 } 305 } 306 307 /* 308 * ForceDumpToDebugRingBuffer 309 */ 310 TEST_F(WifiChipHidlTest, ForceDumpToDebugRingBuffer) { 311 uint32_t caps = configureChipForStaIfaceAndGetCapabilities(); 312 std::string ring_name; 313 const auto& status_and_ring_buffer_status = 314 HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus); 315 if (hasAnyRingBufferCapabilities(caps)) { 316 EXPECT_EQ(WifiStatusCode::SUCCESS, 317 status_and_ring_buffer_status.first.code); 318 ASSERT_LT(0u, status_and_ring_buffer_status.second.size()); 319 ring_name = status_and_ring_buffer_status.second[0].ringName.c_str(); 320 } else { 321 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, 322 status_and_ring_buffer_status.first.code); 323 } 324 const auto& status = 325 HIDL_INVOKE(wifi_chip_, forceDumpToDebugRingBuffer, ring_name); 326 if (hasAnyRingBufferCapabilities(caps)) { 327 EXPECT_EQ(WifiStatusCode::SUCCESS, status.code); 328 } else { 329 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status.code); 330 } 331 } 332 333 /* 334 * GetDebugHostWakeReasonStats 335 */ 336 TEST_F(WifiChipHidlTest, GetDebugHostWakeReasonStats) { 337 uint32_t caps = configureChipForStaIfaceAndGetCapabilities(); 338 const auto& status_and_debug_wake_reason = 339 HIDL_INVOKE(wifi_chip_, getDebugHostWakeReasonStats); 340 if (caps & IWifiChip::ChipCapabilityMask::DEBUG_HOST_WAKE_REASON_STATS) { 341 EXPECT_EQ(WifiStatusCode::SUCCESS, 342 status_and_debug_wake_reason.first.code); 343 } else { 344 EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, 345 status_and_debug_wake_reason.first.code); 346 } 347 } 348 349 /* 350 * CreateApIface 351 * Configures the chip in AP mode and ensures that only 1 iface creation 352 * succeeds. The 2nd iface creation should be rejected. 353 */ 354 TEST_F(WifiChipHidlTest, CreateApIface) { 355 configureChipForIfaceType(IfaceType::AP, true); 356 357 sp<IWifiApIface> iface; 358 EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface)); 359 EXPECT_NE(nullptr, iface.get()); 360 361 EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createApIface(&iface)); 362 } 363 364 /* 365 * GetApIfaceNames 366 * Configures the chip in AP mode and ensures that the iface list is empty 367 * before creating the iface. Then, create the iface and ensure that 368 * iface name is returned via the list. 369 */ 370 TEST_F(WifiChipHidlTest, GetApIfaceNames) { 371 configureChipForIfaceType(IfaceType::AP, true); 372 373 const auto& status_and_iface_names1 = 374 HIDL_INVOKE(wifi_chip_, getApIfaceNames); 375 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code); 376 EXPECT_EQ(0u, status_and_iface_names1.second.size()); 377 378 sp<IWifiApIface> iface; 379 EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface)); 380 EXPECT_NE(nullptr, iface.get()); 381 382 std::string iface_name = getIfaceName(iface); 383 const auto& status_and_iface_names2 = 384 HIDL_INVOKE(wifi_chip_, getApIfaceNames); 385 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code); 386 EXPECT_EQ(1u, status_and_iface_names2.second.size()); 387 EXPECT_EQ(iface_name, status_and_iface_names2.second[0]); 388 389 EXPECT_EQ(WifiStatusCode::SUCCESS, removeApIface(iface_name)); 390 const auto& status_and_iface_names3 = 391 HIDL_INVOKE(wifi_chip_, getApIfaceNames); 392 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code); 393 EXPECT_EQ(0u, status_and_iface_names3.second.size()); 394 } 395 396 /* 397 * GetApIface 398 * Configures the chip in AP mode and create an iface. Then, retrieve 399 * the iface object using the correct name and ensure any other name 400 * doesn't retrieve an iface object. 401 */ 402 TEST_F(WifiChipHidlTest, GetApIface) { 403 configureChipForIfaceType(IfaceType::AP, true); 404 405 sp<IWifiApIface> ap_iface; 406 EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface)); 407 EXPECT_NE(nullptr, ap_iface.get()); 408 409 std::string iface_name = getIfaceName(ap_iface); 410 const auto& status_and_iface1 = 411 HIDL_INVOKE(wifi_chip_, getApIface, iface_name); 412 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code); 413 EXPECT_NE(nullptr, status_and_iface1.second.get()); 414 415 std::string invalid_name = iface_name + "0"; 416 const auto& status_and_iface2 = 417 HIDL_INVOKE(wifi_chip_, getApIface, invalid_name); 418 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code); 419 EXPECT_EQ(nullptr, status_and_iface2.second.get()); 420 } 421 422 /* 423 * RemoveApIface 424 * Configures the chip in AP mode and create an iface. Then, remove 425 * the iface object using the correct name and ensure any other name 426 * doesn't remove the iface. 427 */ 428 TEST_F(WifiChipHidlTest, RemoveApIface) { 429 configureChipForIfaceType(IfaceType::AP, true); 430 431 sp<IWifiApIface> ap_iface; 432 EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface)); 433 EXPECT_NE(nullptr, ap_iface.get()); 434 435 std::string iface_name = getIfaceName(ap_iface); 436 std::string invalid_name = iface_name + "0"; 437 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeApIface(invalid_name)); 438 EXPECT_EQ(WifiStatusCode::SUCCESS, removeApIface(iface_name)); 439 440 // No such iface exists now. So, this should return failure. 441 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeApIface(iface_name)); 442 } 443 444 /* 445 * CreateNanIface 446 * Configures the chip in NAN mode and ensures that only 1 iface creation 447 * succeeds. The 2nd iface creation should be rejected. 448 */ 449 TEST_F(WifiChipHidlTest, CreateNanIface) { 450 if (!gEnv->isNanOn) return; 451 configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn); 452 453 sp<IWifiNanIface> iface; 454 ASSERT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface)); 455 EXPECT_NE(nullptr, iface.get()); 456 457 EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createNanIface(&iface)); 458 } 459 460 /* 461 * GetNanIfaceNames 462 * Configures the chip in NAN mode and ensures that the iface list is empty 463 * before creating the iface. Then, create the iface and ensure that 464 * iface name is returned via the list. 465 */ 466 TEST_F(WifiChipHidlTest, GetNanIfaceNames) { 467 if (!gEnv->isNanOn) return; 468 configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn); 469 470 const auto& status_and_iface_names1 = 471 HIDL_INVOKE(wifi_chip_, getNanIfaceNames); 472 ASSERT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code); 473 EXPECT_EQ(0u, status_and_iface_names1.second.size()); 474 475 sp<IWifiNanIface> iface; 476 EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface)); 477 EXPECT_NE(nullptr, iface.get()); 478 479 std::string iface_name = getIfaceName(iface); 480 const auto& status_and_iface_names2 = 481 HIDL_INVOKE(wifi_chip_, getNanIfaceNames); 482 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code); 483 EXPECT_EQ(1u, status_and_iface_names2.second.size()); 484 EXPECT_EQ(iface_name, status_and_iface_names2.second[0]); 485 486 EXPECT_EQ(WifiStatusCode::SUCCESS, removeNanIface(iface_name)); 487 const auto& status_and_iface_names3 = 488 HIDL_INVOKE(wifi_chip_, getNanIfaceNames); 489 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code); 490 EXPECT_EQ(0u, status_and_iface_names3.second.size()); 491 } 492 493 /* 494 * GetNanIface 495 * Configures the chip in NAN mode and create an iface. Then, retrieve 496 * the iface object using the correct name and ensure any other name 497 * doesn't retrieve an iface object. 498 */ 499 TEST_F(WifiChipHidlTest, GetNanIface) { 500 if (!gEnv->isNanOn) return; 501 configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn); 502 503 sp<IWifiNanIface> nan_iface; 504 EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&nan_iface)); 505 EXPECT_NE(nullptr, nan_iface.get()); 506 507 std::string iface_name = getIfaceName(nan_iface); 508 const auto& status_and_iface1 = 509 HIDL_INVOKE(wifi_chip_, getNanIface, iface_name); 510 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code); 511 EXPECT_NE(nullptr, status_and_iface1.second.get()); 512 513 std::string invalid_name = iface_name + "0"; 514 const auto& status_and_iface2 = 515 HIDL_INVOKE(wifi_chip_, getNanIface, invalid_name); 516 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code); 517 EXPECT_EQ(nullptr, status_and_iface2.second.get()); 518 } 519 520 /* 521 * RemoveNanIface 522 * Configures the chip in NAN mode and create an iface. Then, remove 523 * the iface object using the correct name and ensure any other name 524 * doesn't remove the iface. 525 */ 526 TEST_F(WifiChipHidlTest, RemoveNanIface) { 527 if (!gEnv->isNanOn) return; 528 configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn); 529 530 sp<IWifiNanIface> nan_iface; 531 EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&nan_iface)); 532 EXPECT_NE(nullptr, nan_iface.get()); 533 534 std::string iface_name = getIfaceName(nan_iface); 535 std::string invalid_name = iface_name + "0"; 536 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeNanIface(invalid_name)); 537 538 EXPECT_EQ(WifiStatusCode::SUCCESS, removeNanIface(iface_name)); 539 540 // No such iface exists now. So, this should return failure. 541 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeNanIface(iface_name)); 542 } 543 544 /* 545 * CreateP2pIface 546 * Configures the chip in P2P mode and ensures that only 1 iface creation 547 * succeeds. The 2nd iface creation should be rejected. 548 */ 549 TEST_F(WifiChipHidlTest, CreateP2pIface) { 550 configureChipForIfaceType(IfaceType::P2P, true); 551 552 sp<IWifiP2pIface> iface; 553 EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface)); 554 EXPECT_NE(nullptr, iface.get()); 555 556 EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createP2pIface(&iface)); 557 } 558 559 /* 560 * GetP2pIfaceNames 561 * Configures the chip in P2P mode and ensures that the iface list is empty 562 * before creating the iface. Then, create the iface and ensure that 563 * iface name is returned via the list. 564 */ 565 TEST_F(WifiChipHidlTest, GetP2pIfaceNames) { 566 configureChipForIfaceType(IfaceType::P2P, true); 567 568 const auto& status_and_iface_names1 = 569 HIDL_INVOKE(wifi_chip_, getP2pIfaceNames); 570 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code); 571 EXPECT_EQ(0u, status_and_iface_names1.second.size()); 572 573 sp<IWifiP2pIface> iface; 574 EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface)); 575 EXPECT_NE(nullptr, iface.get()); 576 577 std::string iface_name = getIfaceName(iface); 578 const auto& status_and_iface_names2 = 579 HIDL_INVOKE(wifi_chip_, getP2pIfaceNames); 580 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code); 581 EXPECT_EQ(1u, status_and_iface_names2.second.size()); 582 EXPECT_EQ(iface_name, status_and_iface_names2.second[0]); 583 584 EXPECT_EQ(WifiStatusCode::SUCCESS, removeP2pIface(iface_name)); 585 const auto& status_and_iface_names3 = 586 HIDL_INVOKE(wifi_chip_, getP2pIfaceNames); 587 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code); 588 EXPECT_EQ(0u, status_and_iface_names3.second.size()); 589 } 590 591 /* 592 * GetP2pIface 593 * Configures the chip in P2P mode and create an iface. Then, retrieve 594 * the iface object using the correct name and ensure any other name 595 * doesn't retrieve an iface object. 596 */ 597 TEST_F(WifiChipHidlTest, GetP2pIface) { 598 configureChipForIfaceType(IfaceType::P2P, true); 599 600 sp<IWifiP2pIface> p2p_iface; 601 EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface)); 602 EXPECT_NE(nullptr, p2p_iface.get()); 603 604 std::string iface_name = getIfaceName(p2p_iface); 605 const auto& status_and_iface1 = 606 HIDL_INVOKE(wifi_chip_, getP2pIface, iface_name); 607 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code); 608 EXPECT_NE(nullptr, status_and_iface1.second.get()); 609 610 std::string invalid_name = iface_name + "0"; 611 const auto& status_and_iface2 = 612 HIDL_INVOKE(wifi_chip_, getP2pIface, invalid_name); 613 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code); 614 EXPECT_EQ(nullptr, status_and_iface2.second.get()); 615 } 616 617 /* 618 * RemoveP2pIface 619 * Configures the chip in P2P mode and create an iface. Then, remove 620 * the iface object using the correct name and ensure any other name 621 * doesn't remove the iface. 622 */ 623 TEST_F(WifiChipHidlTest, RemoveP2pIface) { 624 configureChipForIfaceType(IfaceType::P2P, true); 625 626 sp<IWifiP2pIface> p2p_iface; 627 EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface)); 628 EXPECT_NE(nullptr, p2p_iface.get()); 629 630 std::string iface_name = getIfaceName(p2p_iface); 631 std::string invalid_name = iface_name + "0"; 632 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeP2pIface(invalid_name)); 633 EXPECT_EQ(WifiStatusCode::SUCCESS, removeP2pIface(iface_name)); 634 635 // No such iface exists now. So, this should return failure. 636 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeP2pIface(iface_name)); 637 } 638 639 /* 640 * CreateStaIface 641 * Configures the chip in STA mode and ensures that only 1 iface creation 642 * succeeds. The 2nd iface creation should be rejected. 643 */ 644 TEST_F(WifiChipHidlTest, CreateStaIface) { 645 configureChipForIfaceType(IfaceType::STA, true); 646 647 sp<IWifiStaIface> iface; 648 EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface)); 649 EXPECT_NE(nullptr, iface.get()); 650 651 EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createStaIface(&iface)); 652 } 653 654 /* 655 * GetStaIfaceNames 656 * Configures the chip in STA mode and ensures that the iface list is empty 657 * before creating the iface. Then, create the iface and ensure that 658 * iface name is returned via the list. 659 */ 660 TEST_F(WifiChipHidlTest, GetStaIfaceNames) { 661 configureChipForIfaceType(IfaceType::STA, true); 662 663 const auto& status_and_iface_names1 = 664 HIDL_INVOKE(wifi_chip_, getStaIfaceNames); 665 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code); 666 EXPECT_EQ(0u, status_and_iface_names1.second.size()); 667 668 sp<IWifiStaIface> iface; 669 EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface)); 670 EXPECT_NE(nullptr, iface.get()); 671 672 std::string iface_name = getIfaceName(iface); 673 const auto& status_and_iface_names2 = 674 HIDL_INVOKE(wifi_chip_, getStaIfaceNames); 675 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code); 676 EXPECT_EQ(1u, status_and_iface_names2.second.size()); 677 EXPECT_EQ(iface_name, status_and_iface_names2.second[0]); 678 679 EXPECT_EQ(WifiStatusCode::SUCCESS, removeStaIface(iface_name)); 680 const auto& status_and_iface_names3 = 681 HIDL_INVOKE(wifi_chip_, getStaIfaceNames); 682 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code); 683 EXPECT_EQ(0u, status_and_iface_names3.second.size()); 684 } 685 686 /* 687 * GetStaIface 688 * Configures the chip in STA mode and create an iface. Then, retrieve 689 * the iface object using the correct name and ensure any other name 690 * doesn't retrieve an iface object. 691 */ 692 TEST_F(WifiChipHidlTest, GetStaIface) { 693 configureChipForIfaceType(IfaceType::STA, true); 694 695 sp<IWifiStaIface> sta_iface; 696 EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface)); 697 EXPECT_NE(nullptr, sta_iface.get()); 698 699 std::string iface_name = getIfaceName(sta_iface); 700 const auto& status_and_iface1 = 701 HIDL_INVOKE(wifi_chip_, getStaIface, iface_name); 702 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code); 703 EXPECT_NE(nullptr, status_and_iface1.second.get()); 704 705 std::string invalid_name = iface_name + "0"; 706 const auto& status_and_iface2 = 707 HIDL_INVOKE(wifi_chip_, getStaIface, invalid_name); 708 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code); 709 EXPECT_EQ(nullptr, status_and_iface2.second.get()); 710 } 711 712 /* 713 * RemoveStaIface 714 * Configures the chip in STA mode and create an iface. Then, remove 715 * the iface object using the correct name and ensure any other name 716 * doesn't remove the iface. 717 */ 718 TEST_F(WifiChipHidlTest, RemoveStaIface) { 719 configureChipForIfaceType(IfaceType::STA, true); 720 721 sp<IWifiStaIface> sta_iface; 722 EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface)); 723 EXPECT_NE(nullptr, sta_iface.get()); 724 725 std::string iface_name = getIfaceName(sta_iface); 726 std::string invalid_name = iface_name + "0"; 727 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeStaIface(invalid_name)); 728 EXPECT_EQ(WifiStatusCode::SUCCESS, removeStaIface(iface_name)); 729 730 // No such iface exists now. So, this should return failure. 731 EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeStaIface(iface_name)); 732 } 733 734 /* 735 * CreateRttController 736 */ 737 TEST_F(WifiChipHidlTest, CreateRttController) { 738 configureChipForIfaceType(IfaceType::AP, true); 739 740 sp<IWifiApIface> iface; 741 EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface)); 742 EXPECT_NE(nullptr, iface.get()); 743 744 const auto& status_and_rtt_controller = 745 HIDL_INVOKE(wifi_chip_, createRttController, iface); 746 EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_rtt_controller.first.code); 747 EXPECT_NE(nullptr, status_and_rtt_controller.second.get()); 748 } 749