1 /*
2 * Copyright (C) 2017, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <android-base/logging.h>
18 #include <android-base/macros.h>
19 #include <cutils/properties.h>
20 #include <gmock/gmock.h>
21
22 #undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
23 #include "wifi_chip.h"
24
25 #include "mock_interface_tool.h"
26 #include "mock_wifi_feature_flags.h"
27 #include "mock_wifi_iface_util.h"
28 #include "mock_wifi_legacy_hal.h"
29 #include "mock_wifi_mode_controller.h"
30
31 using testing::NiceMock;
32 using testing::Return;
33 using testing::Test;
34
35 namespace {
36 using android::hardware::wifi::V1_0::ChipId;
37
38 constexpr ChipId kFakeChipId = 5;
39 } // namespace
40
41 namespace android {
42 namespace hardware {
43 namespace wifi {
44 namespace V1_4 {
45 namespace implementation {
46
47 class WifiChipTest : public Test {
48 protected:
setupV1IfaceCombination()49 void setupV1IfaceCombination() {
50 // clang-format off
51 const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinationsSta = {
52 {{{{IfaceType::STA}, 1}, {{IfaceType::P2P}, 1}}}
53 };
54 const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinationsAp = {
55 {{{{IfaceType::AP}, 1}}}
56 };
57 const std::vector<V1_0::IWifiChip::ChipMode> modes = {
58 {feature_flags::chip_mode_ids::kV1Sta, combinationsSta},
59 {feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
60 };
61 // clang-format on
62 EXPECT_CALL(*feature_flags_, getChipModes())
63 .WillRepeatedly(testing::Return(modes));
64 }
65
setupV1_AwareIfaceCombination()66 void setupV1_AwareIfaceCombination() {
67 // clang-format off
68 const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinationsSta = {
69 {{{{IfaceType::STA}, 1}, {{IfaceType::P2P, IfaceType::NAN}, 1}}}
70 };
71 const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinationsAp = {
72 {{{{IfaceType::AP}, 1}}}
73 };
74 const std::vector<V1_0::IWifiChip::ChipMode> modes = {
75 {feature_flags::chip_mode_ids::kV1Sta, combinationsSta},
76 {feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
77 };
78 // clang-format on
79 EXPECT_CALL(*feature_flags_, getChipModes())
80 .WillRepeatedly(testing::Return(modes));
81 }
82
setupV1_AwareDisabledApIfaceCombination()83 void setupV1_AwareDisabledApIfaceCombination() {
84 // clang-format off
85 const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinationsSta = {
86 {{{{IfaceType::STA}, 1}, {{IfaceType::P2P, IfaceType::NAN}, 1}}}
87 };
88 const std::vector<V1_0::IWifiChip::ChipMode> modes = {
89 {feature_flags::chip_mode_ids::kV1Sta, combinationsSta}
90 };
91 // clang-format on
92 EXPECT_CALL(*feature_flags_, getChipModes())
93 .WillRepeatedly(testing::Return(modes));
94 }
95
setupV2_AwareIfaceCombination()96 void setupV2_AwareIfaceCombination() {
97 // clang-format off
98 const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinations = {
99 {{{{IfaceType::STA}, 1}, {{IfaceType::AP}, 1}}},
100 {{{{IfaceType::STA}, 1}, {{IfaceType::P2P, IfaceType::NAN}, 1}}}
101 };
102 const std::vector<V1_0::IWifiChip::ChipMode> modes = {
103 {feature_flags::chip_mode_ids::kV3, combinations}
104 };
105 // clang-format on
106 EXPECT_CALL(*feature_flags_, getChipModes())
107 .WillRepeatedly(testing::Return(modes));
108 }
109
setupV2_AwareDisabledApIfaceCombination()110 void setupV2_AwareDisabledApIfaceCombination() {
111 // clang-format off
112 const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinations = {
113 {{{{IfaceType::STA}, 1}, {{IfaceType::P2P, IfaceType::NAN}, 1}}}
114 };
115 const std::vector<V1_0::IWifiChip::ChipMode> modes = {
116 {feature_flags::chip_mode_ids::kV3, combinations}
117 };
118 // clang-format on
119 EXPECT_CALL(*feature_flags_, getChipModes())
120 .WillRepeatedly(testing::Return(modes));
121 }
122
setup_MultiIfaceCombination()123 void setup_MultiIfaceCombination() {
124 // clang-format off
125 const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinations = {
126 {{{{IfaceType::STA}, 3}, {{IfaceType::AP}, 1}}}
127 };
128 const std::vector<V1_0::IWifiChip::ChipMode> modes = {
129 {feature_flags::chip_mode_ids::kV3, combinations}
130 };
131 // clang-format on
132 EXPECT_CALL(*feature_flags_, getChipModes())
133 .WillRepeatedly(testing::Return(modes));
134 }
135
assertNumberOfModes(uint32_t num_modes)136 void assertNumberOfModes(uint32_t num_modes) {
137 chip_->getAvailableModes(
138 [num_modes](const WifiStatus& status,
139 const std::vector<WifiChip::ChipMode>& modes) {
140 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
141 // V2_Aware has 1 mode of operation.
142 ASSERT_EQ(num_modes, modes.size());
143 });
144 }
145
findModeAndConfigureForIfaceType(const IfaceType & type)146 void findModeAndConfigureForIfaceType(const IfaceType& type) {
147 // This should be aligned with kInvalidModeId in wifi_chip.cpp.
148 ChipModeId mode_id = UINT32_MAX;
149 chip_->getAvailableModes(
150 [&mode_id, &type](const WifiStatus& status,
151 const std::vector<WifiChip::ChipMode>& modes) {
152 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
153 for (const auto& mode : modes) {
154 for (const auto& combination : mode.availableCombinations) {
155 for (const auto& limit : combination.limits) {
156 if (limit.types.end() !=
157 std::find(limit.types.begin(),
158 limit.types.end(), type)) {
159 mode_id = mode.id;
160 }
161 }
162 }
163 }
164 });
165 ASSERT_NE(UINT32_MAX, mode_id);
166
167 chip_->configureChip(mode_id, [](const WifiStatus& status) {
168 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
169 });
170 }
171
172 // Returns an empty string on error.
createIface(const IfaceType & type)173 std::string createIface(const IfaceType& type) {
174 std::string iface_name;
175 if (type == IfaceType::AP) {
176 chip_->createApIface([&iface_name](
177 const WifiStatus& status,
178 const sp<V1_0::IWifiApIface>& iface) {
179 if (WifiStatusCode::SUCCESS == status.code) {
180 ASSERT_NE(iface.get(), nullptr);
181 iface->getName([&iface_name](const WifiStatus& status,
182 const hidl_string& name) {
183 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
184 iface_name = name.c_str();
185 });
186 }
187 });
188 } else if (type == IfaceType::NAN) {
189 chip_->createNanIface(
190 [&iface_name](
191 const WifiStatus& status,
192 const sp<android::hardware::wifi::V1_0::IWifiNanIface>&
193 iface) {
194 if (WifiStatusCode::SUCCESS == status.code) {
195 ASSERT_NE(iface.get(), nullptr);
196 iface->getName([&iface_name](const WifiStatus& status,
197 const hidl_string& name) {
198 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
199 iface_name = name.c_str();
200 });
201 }
202 });
203 } else if (type == IfaceType::P2P) {
204 chip_->createP2pIface(
205 [&iface_name](const WifiStatus& status,
206 const sp<IWifiP2pIface>& iface) {
207 if (WifiStatusCode::SUCCESS == status.code) {
208 ASSERT_NE(iface.get(), nullptr);
209 iface->getName([&iface_name](const WifiStatus& status,
210 const hidl_string& name) {
211 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
212 iface_name = name.c_str();
213 });
214 }
215 });
216 } else if (type == IfaceType::STA) {
217 chip_->createStaIface(
218 [&iface_name](const WifiStatus& status,
219 const sp<V1_0::IWifiStaIface>& iface) {
220 if (WifiStatusCode::SUCCESS == status.code) {
221 ASSERT_NE(iface.get(), nullptr);
222 iface->getName([&iface_name](const WifiStatus& status,
223 const hidl_string& name) {
224 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
225 iface_name = name.c_str();
226 });
227 }
228 });
229 }
230 return iface_name;
231 }
232
removeIface(const IfaceType & type,const std::string & iface_name)233 void removeIface(const IfaceType& type, const std::string& iface_name) {
234 if (type == IfaceType::AP) {
235 chip_->removeApIface(iface_name, [](const WifiStatus& status) {
236 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
237 });
238 } else if (type == IfaceType::NAN) {
239 chip_->removeNanIface(iface_name, [](const WifiStatus& status) {
240 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
241 });
242 } else if (type == IfaceType::P2P) {
243 chip_->removeP2pIface(iface_name, [](const WifiStatus& status) {
244 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
245 });
246 } else if (type == IfaceType::STA) {
247 chip_->removeStaIface(iface_name, [](const WifiStatus& status) {
248 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
249 });
250 }
251 }
252
createRttController()253 bool createRttController() {
254 bool success = false;
255 chip_->createRttController_1_4(
256 NULL, [&success](const WifiStatus& status,
257 const sp<IWifiRttController>& rtt) {
258 if (WifiStatusCode::SUCCESS == status.code) {
259 ASSERT_NE(rtt.get(), nullptr);
260 success = true;
261 }
262 });
263 return success;
264 }
265
266 sp<WifiChip> chip_;
267 ChipId chip_id_ = kFakeChipId;
268 std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
269 new NiceMock<wifi_system::MockInterfaceTool>};
270 std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
271 new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_)};
272 std::shared_ptr<NiceMock<mode_controller::MockWifiModeController>>
273 mode_controller_{new NiceMock<mode_controller::MockWifiModeController>};
274 std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
275 new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_)};
276 std::shared_ptr<NiceMock<feature_flags::MockWifiFeatureFlags>>
277 feature_flags_{new NiceMock<feature_flags::MockWifiFeatureFlags>};
278
279 public:
SetUp()280 void SetUp() override {
281 chip_ = new WifiChip(chip_id_, legacy_hal_, mode_controller_,
282 iface_util_, feature_flags_);
283
284 EXPECT_CALL(*mode_controller_, changeFirmwareMode(testing::_))
285 .WillRepeatedly(testing::Return(true));
286 EXPECT_CALL(*legacy_hal_, start())
287 .WillRepeatedly(testing::Return(legacy_hal::WIFI_SUCCESS));
288 }
289
TearDown()290 void TearDown() override {
291 // Restore default system iface names (This should ideally be using a
292 // mock).
293 property_set("wifi.interface", "wlan0");
294 property_set("wifi.concurrent.interface", "wlan1");
295 property_set("wifi.aware.interface", nullptr);
296 }
297 };
298
299 ////////// V1 Iface Combinations ////////////
300 // Mode 1 - STA + P2P
301 // Mode 2 - AP
302 class WifiChipV1IfaceCombinationTest : public WifiChipTest {
303 public:
SetUp()304 void SetUp() override {
305 setupV1IfaceCombination();
306 WifiChipTest::SetUp();
307 // V1 has 2 modes of operation.
308 assertNumberOfModes(2u);
309 }
310 };
311
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateSta_ShouldSucceed)312 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
313 findModeAndConfigureForIfaceType(IfaceType::STA);
314 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
315 }
316
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateP2p_ShouldSucceed)317 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
318 findModeAndConfigureForIfaceType(IfaceType::STA);
319 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
320 }
321
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateNan_ShouldFail)322 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateNan_ShouldFail) {
323 findModeAndConfigureForIfaceType(IfaceType::STA);
324 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
325 }
326
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateAp_ShouldFail)327 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
328 findModeAndConfigureForIfaceType(IfaceType::STA);
329 ASSERT_TRUE(createIface(IfaceType::AP).empty());
330 }
331
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateStaP2p_ShouldSucceed)332 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateStaP2p_ShouldSucceed) {
333 findModeAndConfigureForIfaceType(IfaceType::STA);
334 ASSERT_FALSE(createIface(IfaceType::STA).empty());
335 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
336 }
337
TEST_F(WifiChipV1IfaceCombinationTest,ApMode_CreateAp_ShouldSucceed)338 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateAp_ShouldSucceed) {
339 findModeAndConfigureForIfaceType(IfaceType::AP);
340 ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
341 }
342
TEST_F(WifiChipV1IfaceCombinationTest,ApMode_CreateSta_ShouldFail)343 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateSta_ShouldFail) {
344 findModeAndConfigureForIfaceType(IfaceType::AP);
345 ASSERT_TRUE(createIface(IfaceType::STA).empty());
346 }
347
TEST_F(WifiChipV1IfaceCombinationTest,ApMode_CreateP2p_ShouldFail)348 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateP2p_ShouldFail) {
349 findModeAndConfigureForIfaceType(IfaceType::AP);
350 ASSERT_TRUE(createIface(IfaceType::STA).empty());
351 }
352
TEST_F(WifiChipV1IfaceCombinationTest,ApMode_CreateNan_ShouldFail)353 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
354 findModeAndConfigureForIfaceType(IfaceType::AP);
355 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
356 }
357
358 ////////// V1 + Aware Iface Combinations ////////////
359 // Mode 1 - STA + P2P/NAN
360 // Mode 2 - AP
361 class WifiChipV1_AwareIfaceCombinationTest : public WifiChipTest {
362 public:
SetUp()363 void SetUp() override {
364 setupV1_AwareIfaceCombination();
365 WifiChipTest::SetUp();
366 // V1_Aware has 2 modes of operation.
367 assertNumberOfModes(2u);
368 }
369 };
370
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateSta_ShouldSucceed)371 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
372 findModeAndConfigureForIfaceType(IfaceType::STA);
373 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
374 }
375
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateP2p_ShouldSucceed)376 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
377 findModeAndConfigureForIfaceType(IfaceType::STA);
378 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
379 }
380
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateNan_ShouldSucceed)381 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateNan_ShouldSucceed) {
382 findModeAndConfigureForIfaceType(IfaceType::STA);
383 ASSERT_FALSE(createIface(IfaceType::NAN).empty());
384 }
385
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateAp_ShouldFail)386 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
387 findModeAndConfigureForIfaceType(IfaceType::STA);
388 ASSERT_TRUE(createIface(IfaceType::AP).empty());
389 }
390
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaP2p_ShouldSucceed)391 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
392 StaMode_CreateStaP2p_ShouldSucceed) {
393 findModeAndConfigureForIfaceType(IfaceType::STA);
394 ASSERT_FALSE(createIface(IfaceType::STA).empty());
395 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
396 }
397
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaNan_ShouldSucceed)398 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
399 StaMode_CreateStaNan_ShouldSucceed) {
400 findModeAndConfigureForIfaceType(IfaceType::STA);
401 ASSERT_FALSE(createIface(IfaceType::STA).empty());
402 ASSERT_FALSE(createIface(IfaceType::NAN).empty());
403 }
404
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaP2PNan_ShouldFail)405 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
406 StaMode_CreateStaP2PNan_ShouldFail) {
407 findModeAndConfigureForIfaceType(IfaceType::STA);
408 ASSERT_FALSE(createIface(IfaceType::STA).empty());
409 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
410 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
411 }
412
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed)413 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
414 StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
415 findModeAndConfigureForIfaceType(IfaceType::STA);
416 ASSERT_FALSE(createIface(IfaceType::STA).empty());
417 const auto p2p_iface_name = createIface(IfaceType::P2P);
418 ASSERT_FALSE(p2p_iface_name.empty());
419 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
420
421 // After removing P2P iface, NAN iface creation should succeed.
422 removeIface(IfaceType::P2P, p2p_iface_name);
423 ASSERT_FALSE(createIface(IfaceType::NAN).empty());
424 }
425
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed)426 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
427 StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
428 findModeAndConfigureForIfaceType(IfaceType::STA);
429 ASSERT_FALSE(createIface(IfaceType::STA).empty());
430 const auto nan_iface_name = createIface(IfaceType::NAN);
431 ASSERT_FALSE(nan_iface_name.empty());
432 ASSERT_TRUE(createIface(IfaceType::P2P).empty());
433
434 // After removing NAN iface, P2P iface creation should succeed.
435 removeIface(IfaceType::NAN, nan_iface_name);
436 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
437 }
438
TEST_F(WifiChipV1_AwareIfaceCombinationTest,ApMode_CreateAp_ShouldSucceed)439 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateAp_ShouldSucceed) {
440 findModeAndConfigureForIfaceType(IfaceType::AP);
441 ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
442 }
443
TEST_F(WifiChipV1_AwareIfaceCombinationTest,ApMode_CreateSta_ShouldFail)444 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateSta_ShouldFail) {
445 findModeAndConfigureForIfaceType(IfaceType::AP);
446 ASSERT_TRUE(createIface(IfaceType::STA).empty());
447 }
448
TEST_F(WifiChipV1_AwareIfaceCombinationTest,ApMode_CreateP2p_ShouldFail)449 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateP2p_ShouldFail) {
450 findModeAndConfigureForIfaceType(IfaceType::AP);
451 ASSERT_TRUE(createIface(IfaceType::STA).empty());
452 }
453
TEST_F(WifiChipV1_AwareIfaceCombinationTest,ApMode_CreateNan_ShouldFail)454 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
455 findModeAndConfigureForIfaceType(IfaceType::AP);
456 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
457 }
458
TEST_F(WifiChipV1_AwareIfaceCombinationTest,RttControllerFlowStaModeNoSta)459 TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
460 findModeAndConfigureForIfaceType(IfaceType::STA);
461 ASSERT_TRUE(createRttController());
462 }
463
TEST_F(WifiChipV1_AwareIfaceCombinationTest,RttControllerFlowStaModeWithSta)464 TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeWithSta) {
465 findModeAndConfigureForIfaceType(IfaceType::STA);
466 ASSERT_FALSE(createIface(IfaceType::STA).empty());
467 ASSERT_TRUE(createRttController());
468 }
469
TEST_F(WifiChipV1_AwareIfaceCombinationTest,RttControllerFlowApToSta)470 TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowApToSta) {
471 findModeAndConfigureForIfaceType(IfaceType::AP);
472 const auto ap_iface_name = createIface(IfaceType::AP);
473 ASSERT_FALSE(ap_iface_name.empty());
474 ASSERT_FALSE(createRttController());
475
476 removeIface(IfaceType::AP, ap_iface_name);
477
478 findModeAndConfigureForIfaceType(IfaceType::STA);
479 ASSERT_TRUE(createRttController());
480 }
481
TEST_F(WifiChipV1_AwareIfaceCombinationTest,SelectTxScenarioWithOnlySta)482 TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
483 findModeAndConfigureForIfaceType(IfaceType::STA);
484 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
485 EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
486 .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
487 chip_->selectTxPowerScenario_1_2(
488 V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
489 [](const WifiStatus& status) {
490 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
491 });
492 }
493
TEST_F(WifiChipV1_AwareIfaceCombinationTest,SelectTxScenarioWithOnlyAp)494 TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
495 findModeAndConfigureForIfaceType(IfaceType::AP);
496 ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
497 EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
498 .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
499 chip_->selectTxPowerScenario_1_2(
500 V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
501 [](const WifiStatus& status) {
502 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
503 });
504 }
505
506 ////////// V2 + Aware Iface Combinations ////////////
507 // Mode 1 - STA + STA/AP
508 // - STA + P2P/NAN
509 class WifiChipV2_AwareIfaceCombinationTest : public WifiChipTest {
510 public:
SetUp()511 void SetUp() override {
512 setupV2_AwareIfaceCombination();
513 WifiChipTest::SetUp();
514 // V2_Aware has 1 mode of operation.
515 assertNumberOfModes(1u);
516 }
517 };
518
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateSta_ShouldSucceed)519 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateSta_ShouldSucceed) {
520 findModeAndConfigureForIfaceType(IfaceType::STA);
521 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
522 }
523
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateP2p_ShouldSucceed)524 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateP2p_ShouldSucceed) {
525 findModeAndConfigureForIfaceType(IfaceType::STA);
526 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
527 }
528
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateNan_ShouldSucceed)529 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNan_ShouldSucceed) {
530 findModeAndConfigureForIfaceType(IfaceType::STA);
531 ASSERT_FALSE(createIface(IfaceType::NAN).empty());
532 }
533
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateAp_ShouldSucceed)534 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateAp_ShouldSucceed) {
535 findModeAndConfigureForIfaceType(IfaceType::STA);
536 ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
537 }
538
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaSta_ShouldFail)539 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaSta_ShouldFail) {
540 findModeAndConfigureForIfaceType(IfaceType::AP);
541 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
542 ASSERT_TRUE(createIface(IfaceType::STA).empty());
543 }
544
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaAp_ShouldSucceed)545 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaAp_ShouldSucceed) {
546 findModeAndConfigureForIfaceType(IfaceType::AP);
547 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
548 ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
549 }
550
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateApSta_ShouldSucceed)551 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApSta_ShouldSucceed) {
552 findModeAndConfigureForIfaceType(IfaceType::AP);
553 ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
554 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
555 }
556
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateSta_AfterStaApRemove_ShouldSucceed)557 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
558 CreateSta_AfterStaApRemove_ShouldSucceed) {
559 findModeAndConfigureForIfaceType(IfaceType::STA);
560 const auto sta_iface_name = createIface(IfaceType::STA);
561 ASSERT_FALSE(sta_iface_name.empty());
562 const auto ap_iface_name = createIface(IfaceType::AP);
563 ASSERT_FALSE(ap_iface_name.empty());
564
565 ASSERT_TRUE(createIface(IfaceType::STA).empty());
566
567 // After removing AP & STA iface, STA iface creation should succeed.
568 removeIface(IfaceType::STA, sta_iface_name);
569 removeIface(IfaceType::AP, ap_iface_name);
570 ASSERT_FALSE(createIface(IfaceType::STA).empty());
571 }
572
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaP2p_ShouldSucceed)573 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2p_ShouldSucceed) {
574 findModeAndConfigureForIfaceType(IfaceType::STA);
575 ASSERT_FALSE(createIface(IfaceType::STA).empty());
576 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
577 }
578
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaNan_ShouldSucceed)579 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_ShouldSucceed) {
580 findModeAndConfigureForIfaceType(IfaceType::STA);
581 ASSERT_FALSE(createIface(IfaceType::STA).empty());
582 ASSERT_FALSE(createIface(IfaceType::NAN).empty());
583 }
584
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaP2PNan_ShouldFail)585 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2PNan_ShouldFail) {
586 findModeAndConfigureForIfaceType(IfaceType::STA);
587 ASSERT_FALSE(createIface(IfaceType::STA).empty());
588 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
589 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
590 }
591
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaNan_AfterP2pRemove_ShouldSucceed)592 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
593 CreateStaNan_AfterP2pRemove_ShouldSucceed) {
594 findModeAndConfigureForIfaceType(IfaceType::STA);
595 ASSERT_FALSE(createIface(IfaceType::STA).empty());
596 const auto p2p_iface_name = createIface(IfaceType::P2P);
597 ASSERT_FALSE(p2p_iface_name.empty());
598 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
599
600 // After removing P2P iface, NAN iface creation should succeed.
601 removeIface(IfaceType::P2P, p2p_iface_name);
602 ASSERT_FALSE(createIface(IfaceType::NAN).empty());
603 }
604
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaP2p_AfterNanRemove_ShouldSucceed)605 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
606 CreateStaP2p_AfterNanRemove_ShouldSucceed) {
607 findModeAndConfigureForIfaceType(IfaceType::STA);
608 ASSERT_FALSE(createIface(IfaceType::STA).empty());
609 const auto nan_iface_name = createIface(IfaceType::NAN);
610 ASSERT_FALSE(nan_iface_name.empty());
611 ASSERT_TRUE(createIface(IfaceType::P2P).empty());
612
613 // After removing NAN iface, P2P iface creation should succeed.
614 removeIface(IfaceType::NAN, nan_iface_name);
615 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
616 }
617
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateApNan_ShouldFail)618 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApNan_ShouldFail) {
619 findModeAndConfigureForIfaceType(IfaceType::AP);
620 ASSERT_FALSE(createIface(IfaceType::AP).empty());
621 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
622 }
623
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateApP2p_ShouldFail)624 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApP2p_ShouldFail) {
625 findModeAndConfigureForIfaceType(IfaceType::AP);
626 ASSERT_FALSE(createIface(IfaceType::AP).empty());
627 ASSERT_TRUE(createIface(IfaceType::P2P).empty());
628 }
629
TEST_F(WifiChipV2_AwareIfaceCombinationTest,StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed)630 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
631 StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
632 findModeAndConfigureForIfaceType(IfaceType::STA);
633 ASSERT_FALSE(createIface(IfaceType::STA).empty());
634 const auto p2p_iface_name = createIface(IfaceType::P2P);
635 ASSERT_FALSE(p2p_iface_name.empty());
636 ASSERT_TRUE(createIface(IfaceType::NAN).empty());
637
638 // After removing P2P iface, NAN iface creation should succeed.
639 removeIface(IfaceType::P2P, p2p_iface_name);
640 ASSERT_FALSE(createIface(IfaceType::NAN).empty());
641 }
642
TEST_F(WifiChipV2_AwareIfaceCombinationTest,StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed)643 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
644 StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
645 findModeAndConfigureForIfaceType(IfaceType::STA);
646 ASSERT_FALSE(createIface(IfaceType::STA).empty());
647 const auto nan_iface_name = createIface(IfaceType::NAN);
648 ASSERT_FALSE(nan_iface_name.empty());
649 ASSERT_TRUE(createIface(IfaceType::P2P).empty());
650
651 // After removing NAN iface, P2P iface creation should succeed.
652 removeIface(IfaceType::NAN, nan_iface_name);
653 ASSERT_FALSE(createIface(IfaceType::P2P).empty());
654 }
655
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaAp_EnsureDifferentIfaceNames)656 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
657 CreateStaAp_EnsureDifferentIfaceNames) {
658 findModeAndConfigureForIfaceType(IfaceType::AP);
659 const auto sta_iface_name = createIface(IfaceType::STA);
660 const auto ap_iface_name = createIface(IfaceType::AP);
661 ASSERT_FALSE(sta_iface_name.empty());
662 ASSERT_FALSE(ap_iface_name.empty());
663 ASSERT_NE(sta_iface_name, ap_iface_name);
664 }
665
TEST_F(WifiChipV2_AwareIfaceCombinationTest,RttControllerFlowStaModeNoSta)666 TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
667 findModeAndConfigureForIfaceType(IfaceType::STA);
668 ASSERT_TRUE(createRttController());
669 }
670
TEST_F(WifiChipV2_AwareIfaceCombinationTest,RttControllerFlowStaModeWithSta)671 TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlowStaModeWithSta) {
672 findModeAndConfigureForIfaceType(IfaceType::STA);
673 ASSERT_FALSE(createIface(IfaceType::STA).empty());
674 ASSERT_TRUE(createRttController());
675 }
676
TEST_F(WifiChipV2_AwareIfaceCombinationTest,RttControllerFlow)677 TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlow) {
678 findModeAndConfigureForIfaceType(IfaceType::STA);
679 ASSERT_FALSE(createIface(IfaceType::STA).empty());
680 ASSERT_FALSE(createIface(IfaceType::AP).empty());
681 ASSERT_TRUE(createRttController());
682 }
683
TEST_F(WifiChipV2_AwareIfaceCombinationTest,SelectTxScenarioWithOnlySta)684 TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
685 findModeAndConfigureForIfaceType(IfaceType::STA);
686 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
687 EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
688 .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
689 chip_->selectTxPowerScenario_1_2(
690 V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
691 [](const WifiStatus& status) {
692 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
693 });
694 }
695
TEST_F(WifiChipV2_AwareIfaceCombinationTest,SelectTxScenarioWithOnlyAp)696 TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
697 findModeAndConfigureForIfaceType(IfaceType::AP);
698 ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
699 EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan1", testing::_))
700 .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
701 chip_->selectTxPowerScenario_1_2(
702 V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
703 [](const WifiStatus& status) {
704 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
705 });
706 }
707
TEST_F(WifiChipV2_AwareIfaceCombinationTest,InvalidateAndRemoveNanOnStaRemove)708 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
709 InvalidateAndRemoveNanOnStaRemove) {
710 findModeAndConfigureForIfaceType(IfaceType::STA);
711 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
712
713 // Create NAN iface
714 ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
715
716 // We should have 1 nan iface.
717 chip_->getNanIfaceNames(
718 [](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
719 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
720 ASSERT_EQ(iface_names.size(), 1u);
721 ASSERT_EQ(iface_names[0], "wlan0");
722 });
723 // Retrieve the exact iface object.
724 sp<android::hardware::wifi::V1_0::IWifiNanIface> nan_iface;
725 chip_->getNanIface(
726 "wlan0",
727 [&nan_iface](
728 const WifiStatus& status,
729 const sp<android::hardware::wifi::V1_0::IWifiNanIface>& iface) {
730 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
731 ASSERT_NE(iface.get(), nullptr);
732 nan_iface = iface;
733 });
734
735 // Remove the STA iface.
736 removeIface(IfaceType::STA, "wlan0");
737 // We should have 0 nan iface now.
738 chip_->getNanIfaceNames(
739 [](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
740 ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
741 ASSERT_EQ(iface_names.size(), 0u);
742 });
743 // Any operation on the nan iface object should return error now.
744 nan_iface->getName(
745 [](const WifiStatus& status, const std::string& /* iface_name */) {
746 ASSERT_EQ(WifiStatusCode::ERROR_WIFI_IFACE_INVALID, status.code);
747 });
748 }
749
TEST_F(WifiChipV2_AwareIfaceCombinationTest,InvalidateAndRemoveRttControllerOnStaRemove)750 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
751 InvalidateAndRemoveRttControllerOnStaRemove) {
752 findModeAndConfigureForIfaceType(IfaceType::STA);
753 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
754
755 // Create RTT controller
756 sp<IWifiRttController> rtt_controller;
757 chip_->createRttController_1_4(
758 NULL, [&rtt_controller](const WifiStatus& status,
759 const sp<IWifiRttController>& rtt) {
760 if (WifiStatusCode::SUCCESS == status.code) {
761 ASSERT_NE(rtt.get(), nullptr);
762 rtt_controller = rtt;
763 }
764 });
765
766 // Remove the STA iface.
767 removeIface(IfaceType::STA, "wlan0");
768
769 // Any operation on the rtt controller object should return error now.
770 rtt_controller->getBoundIface(
771 [](const WifiStatus& status, const sp<IWifiIface>& /* iface */) {
772 ASSERT_EQ(WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
773 status.code);
774 });
775 }
776
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateNanWithSharedNanIface)777 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithSharedNanIface) {
778 property_set("wifi.aware.interface", nullptr);
779 findModeAndConfigureForIfaceType(IfaceType::STA);
780 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
781 ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
782 removeIface(IfaceType::NAN, "wlan0");
783 EXPECT_CALL(*iface_util_, setUpState(testing::_, testing::_)).Times(0);
784 }
785
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateNanWithDedicatedNanIface)786 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithDedicatedNanIface) {
787 property_set("wifi.aware.interface", "aware0");
788 findModeAndConfigureForIfaceType(IfaceType::STA);
789 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
790 EXPECT_CALL(*iface_util_, ifNameToIndex("aware0"))
791 .WillOnce(testing::Return(4));
792 EXPECT_CALL(*iface_util_, setUpState("aware0", true))
793 .WillOnce(testing::Return(true));
794 ASSERT_EQ(createIface(IfaceType::NAN), "aware0");
795
796 EXPECT_CALL(*iface_util_, setUpState("aware0", false))
797 .WillOnce(testing::Return(true));
798 removeIface(IfaceType::NAN, "aware0");
799 }
800
801 ////////// V1 Iface Combinations when AP creation is disabled //////////
802 class WifiChipV1_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
803 public:
SetUp()804 void SetUp() override {
805 setupV1_AwareDisabledApIfaceCombination();
806 WifiChipTest::SetUp();
807 }
808 };
809
TEST_F(WifiChipV1_AwareDisabledApIfaceCombinationTest,StaMode_CreateSta_ShouldSucceed)810 TEST_F(WifiChipV1_AwareDisabledApIfaceCombinationTest,
811 StaMode_CreateSta_ShouldSucceed) {
812 findModeAndConfigureForIfaceType(IfaceType::STA);
813 ASSERT_FALSE(createIface(IfaceType::STA).empty());
814 ASSERT_TRUE(createIface(IfaceType::AP).empty());
815 }
816
817 ////////// V2 Iface Combinations when AP creation is disabled //////////
818 class WifiChipV2_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
819 public:
SetUp()820 void SetUp() override {
821 setupV2_AwareDisabledApIfaceCombination();
822 WifiChipTest::SetUp();
823 }
824 };
825
TEST_F(WifiChipV2_AwareDisabledApIfaceCombinationTest,CreateSta_ShouldSucceed)826 TEST_F(WifiChipV2_AwareDisabledApIfaceCombinationTest,
827 CreateSta_ShouldSucceed) {
828 findModeAndConfigureForIfaceType(IfaceType::STA);
829 ASSERT_FALSE(createIface(IfaceType::STA).empty());
830 ASSERT_TRUE(createIface(IfaceType::AP).empty());
831 }
832
833 ////////// Hypothetical Iface Combination with multiple ifaces //////////
834 class WifiChip_MultiIfaceTest : public WifiChipTest {
835 public:
SetUp()836 void SetUp() override {
837 setup_MultiIfaceCombination();
838 WifiChipTest::SetUp();
839 }
840 };
841
TEST_F(WifiChip_MultiIfaceTest,Create3Sta)842 TEST_F(WifiChip_MultiIfaceTest, Create3Sta) {
843 findModeAndConfigureForIfaceType(IfaceType::STA);
844 ASSERT_FALSE(createIface(IfaceType::STA).empty());
845 ASSERT_FALSE(createIface(IfaceType::STA).empty());
846 ASSERT_FALSE(createIface(IfaceType::STA).empty());
847 ASSERT_TRUE(createIface(IfaceType::STA).empty());
848 }
849
TEST_F(WifiChip_MultiIfaceTest,CreateStaWithDefaultNames)850 TEST_F(WifiChip_MultiIfaceTest, CreateStaWithDefaultNames) {
851 property_set("wifi.interface.0", "");
852 property_set("wifi.interface.1", "");
853 property_set("wifi.interface.2", "");
854 property_set("wifi.interface", "");
855 property_set("wifi.concurrent.interface", "");
856 findModeAndConfigureForIfaceType(IfaceType::STA);
857 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
858 ASSERT_EQ(createIface(IfaceType::STA), "wlan1");
859 ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
860 }
861
TEST_F(WifiChip_MultiIfaceTest,CreateStaWithCustomNames)862 TEST_F(WifiChip_MultiIfaceTest, CreateStaWithCustomNames) {
863 property_set("wifi.interface.0", "test0");
864 property_set("wifi.interface.1", "test1");
865 property_set("wifi.interface.2", "test2");
866 property_set("wifi.interface", "bad0");
867 property_set("wifi.concurrent.interface", "bad1");
868 findModeAndConfigureForIfaceType(IfaceType::STA);
869 ASSERT_EQ(createIface(IfaceType::STA), "bad0");
870 ASSERT_EQ(createIface(IfaceType::STA), "bad1");
871 ASSERT_EQ(createIface(IfaceType::STA), "test2");
872 }
873
TEST_F(WifiChip_MultiIfaceTest,CreateStaWithCustomAltNames)874 TEST_F(WifiChip_MultiIfaceTest, CreateStaWithCustomAltNames) {
875 property_set("wifi.interface.0", "");
876 property_set("wifi.interface.1", "");
877 property_set("wifi.interface.2", "");
878 property_set("wifi.interface", "testA0");
879 property_set("wifi.concurrent.interface", "testA1");
880 findModeAndConfigureForIfaceType(IfaceType::STA);
881 ASSERT_EQ(createIface(IfaceType::STA), "testA0");
882 ASSERT_EQ(createIface(IfaceType::STA), "testA1");
883 ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
884 }
885
TEST_F(WifiChip_MultiIfaceTest,CreateApStartsWithIdx1)886 TEST_F(WifiChip_MultiIfaceTest, CreateApStartsWithIdx1) {
887 findModeAndConfigureForIfaceType(IfaceType::STA);
888 // First AP will be slotted to wlan1.
889 ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
890 // First STA will be slotted to wlan0.
891 ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
892 // All further STA will be slotted to the remaining free indices.
893 ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
894 ASSERT_EQ(createIface(IfaceType::STA), "wlan3");
895 }
896 } // namespace implementation
897 } // namespace V1_4
898 } // namespace wifi
899 } // namespace hardware
900 } // namespace android
901