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