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_5 {
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(true))
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(true))
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(true))
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(true))
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(true))
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(true))
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(
177                 [&iface_name](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 
subsystemRestartHandler(const std::string &)266     static void subsystemRestartHandler(const std::string& /*error*/) {}
267 
268     sp<WifiChip> chip_;
269     ChipId chip_id_ = kFakeChipId;
270     legacy_hal::wifi_hal_fn fake_func_table_;
271     std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
272         new NiceMock<wifi_system::MockInterfaceTool>};
273     std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
274         new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_,
275                                                     fake_func_table_, true)};
276     std::shared_ptr<NiceMock<mode_controller::MockWifiModeController>>
277         mode_controller_{new NiceMock<mode_controller::MockWifiModeController>};
278     std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
279         new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
280     std::shared_ptr<NiceMock<feature_flags::MockWifiFeatureFlags>>
281         feature_flags_{new NiceMock<feature_flags::MockWifiFeatureFlags>};
282 
283    public:
SetUp()284     void SetUp() override {
285         chip_ =
286             new WifiChip(chip_id_, true, legacy_hal_, mode_controller_,
287                          iface_util_, feature_flags_, subsystemRestartHandler);
288 
289         EXPECT_CALL(*mode_controller_, changeFirmwareMode(testing::_))
290             .WillRepeatedly(testing::Return(true));
291         EXPECT_CALL(*legacy_hal_, start())
292             .WillRepeatedly(testing::Return(legacy_hal::WIFI_SUCCESS));
293     }
294 
TearDown()295     void TearDown() override {
296         // Restore default system iface names (This should ideally be using a
297         // mock).
298         property_set("wifi.interface", "wlan0");
299         property_set("wifi.concurrent.interface", "wlan1");
300         property_set("wifi.aware.interface", nullptr);
301     }
302 };
303 
304 ////////// V1 Iface Combinations ////////////
305 // Mode 1 - STA + P2P
306 // Mode 2 - AP
307 class WifiChipV1IfaceCombinationTest : public WifiChipTest {
308    public:
SetUp()309     void SetUp() override {
310         setupV1IfaceCombination();
311         WifiChipTest::SetUp();
312         // V1 has 2 modes of operation.
313         assertNumberOfModes(2u);
314     }
315 };
316 
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateSta_ShouldSucceed)317 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
318     findModeAndConfigureForIfaceType(IfaceType::STA);
319     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
320 }
321 
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateP2p_ShouldSucceed)322 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
323     findModeAndConfigureForIfaceType(IfaceType::STA);
324     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
325 }
326 
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateNan_ShouldFail)327 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateNan_ShouldFail) {
328     findModeAndConfigureForIfaceType(IfaceType::STA);
329     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
330 }
331 
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateAp_ShouldFail)332 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
333     findModeAndConfigureForIfaceType(IfaceType::STA);
334     ASSERT_TRUE(createIface(IfaceType::AP).empty());
335 }
336 
TEST_F(WifiChipV1IfaceCombinationTest,StaMode_CreateStaP2p_ShouldSucceed)337 TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateStaP2p_ShouldSucceed) {
338     findModeAndConfigureForIfaceType(IfaceType::STA);
339     ASSERT_FALSE(createIface(IfaceType::STA).empty());
340     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
341 }
342 
TEST_F(WifiChipV1IfaceCombinationTest,ApMode_CreateAp_ShouldSucceed)343 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateAp_ShouldSucceed) {
344     findModeAndConfigureForIfaceType(IfaceType::AP);
345     ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
346 }
347 
TEST_F(WifiChipV1IfaceCombinationTest,ApMode_CreateSta_ShouldFail)348 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateSta_ShouldFail) {
349     findModeAndConfigureForIfaceType(IfaceType::AP);
350     ASSERT_TRUE(createIface(IfaceType::STA).empty());
351 }
352 
TEST_F(WifiChipV1IfaceCombinationTest,ApMode_CreateP2p_ShouldFail)353 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateP2p_ShouldFail) {
354     findModeAndConfigureForIfaceType(IfaceType::AP);
355     ASSERT_TRUE(createIface(IfaceType::STA).empty());
356 }
357 
TEST_F(WifiChipV1IfaceCombinationTest,ApMode_CreateNan_ShouldFail)358 TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
359     findModeAndConfigureForIfaceType(IfaceType::AP);
360     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
361 }
362 
363 ////////// V1 + Aware Iface Combinations ////////////
364 // Mode 1 - STA + P2P/NAN
365 // Mode 2 - AP
366 class WifiChipV1_AwareIfaceCombinationTest : public WifiChipTest {
367    public:
SetUp()368     void SetUp() override {
369         setupV1_AwareIfaceCombination();
370         WifiChipTest::SetUp();
371         // V1_Aware has 2 modes of operation.
372         assertNumberOfModes(2u);
373     }
374 };
375 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateSta_ShouldSucceed)376 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
377     findModeAndConfigureForIfaceType(IfaceType::STA);
378     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
379 }
380 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateP2p_ShouldSucceed)381 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
382     findModeAndConfigureForIfaceType(IfaceType::STA);
383     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
384 }
385 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateNan_ShouldSucceed)386 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateNan_ShouldSucceed) {
387     findModeAndConfigureForIfaceType(IfaceType::STA);
388     ASSERT_FALSE(createIface(IfaceType::NAN).empty());
389 }
390 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateAp_ShouldFail)391 TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
392     findModeAndConfigureForIfaceType(IfaceType::STA);
393     ASSERT_TRUE(createIface(IfaceType::AP).empty());
394 }
395 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaP2p_ShouldSucceed)396 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
397        StaMode_CreateStaP2p_ShouldSucceed) {
398     findModeAndConfigureForIfaceType(IfaceType::STA);
399     ASSERT_FALSE(createIface(IfaceType::STA).empty());
400     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
401 }
402 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaNan_ShouldSucceed)403 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
404        StaMode_CreateStaNan_ShouldSucceed) {
405     findModeAndConfigureForIfaceType(IfaceType::STA);
406     ASSERT_FALSE(createIface(IfaceType::STA).empty());
407     ASSERT_FALSE(createIface(IfaceType::NAN).empty());
408 }
409 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaP2PNan_ShouldFail)410 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
411        StaMode_CreateStaP2PNan_ShouldFail) {
412     findModeAndConfigureForIfaceType(IfaceType::STA);
413     ASSERT_FALSE(createIface(IfaceType::STA).empty());
414     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
415     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
416 }
417 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed)418 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
419        StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
420     findModeAndConfigureForIfaceType(IfaceType::STA);
421     ASSERT_FALSE(createIface(IfaceType::STA).empty());
422     const auto p2p_iface_name = createIface(IfaceType::P2P);
423     ASSERT_FALSE(p2p_iface_name.empty());
424     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
425 
426     // After removing P2P iface, NAN iface creation should succeed.
427     removeIface(IfaceType::P2P, p2p_iface_name);
428     ASSERT_FALSE(createIface(IfaceType::NAN).empty());
429 }
430 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed)431 TEST_F(WifiChipV1_AwareIfaceCombinationTest,
432        StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
433     findModeAndConfigureForIfaceType(IfaceType::STA);
434     ASSERT_FALSE(createIface(IfaceType::STA).empty());
435     const auto nan_iface_name = createIface(IfaceType::NAN);
436     ASSERT_FALSE(nan_iface_name.empty());
437     ASSERT_TRUE(createIface(IfaceType::P2P).empty());
438 
439     // After removing NAN iface, P2P iface creation should succeed.
440     removeIface(IfaceType::NAN, nan_iface_name);
441     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
442 }
443 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,ApMode_CreateAp_ShouldSucceed)444 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateAp_ShouldSucceed) {
445     findModeAndConfigureForIfaceType(IfaceType::AP);
446     ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
447 }
448 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,ApMode_CreateSta_ShouldFail)449 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateSta_ShouldFail) {
450     findModeAndConfigureForIfaceType(IfaceType::AP);
451     ASSERT_TRUE(createIface(IfaceType::STA).empty());
452 }
453 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,ApMode_CreateP2p_ShouldFail)454 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateP2p_ShouldFail) {
455     findModeAndConfigureForIfaceType(IfaceType::AP);
456     ASSERT_TRUE(createIface(IfaceType::STA).empty());
457 }
458 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,ApMode_CreateNan_ShouldFail)459 TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
460     findModeAndConfigureForIfaceType(IfaceType::AP);
461     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
462 }
463 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,RttControllerFlowStaModeNoSta)464 TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
465     findModeAndConfigureForIfaceType(IfaceType::STA);
466     ASSERT_TRUE(createRttController());
467 }
468 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,RttControllerFlowStaModeWithSta)469 TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeWithSta) {
470     findModeAndConfigureForIfaceType(IfaceType::STA);
471     ASSERT_FALSE(createIface(IfaceType::STA).empty());
472     ASSERT_TRUE(createRttController());
473 }
474 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,RttControllerFlowApToSta)475 TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowApToSta) {
476     findModeAndConfigureForIfaceType(IfaceType::AP);
477     const auto ap_iface_name = createIface(IfaceType::AP);
478     ASSERT_FALSE(ap_iface_name.empty());
479     ASSERT_FALSE(createRttController());
480 
481     removeIface(IfaceType::AP, ap_iface_name);
482 
483     findModeAndConfigureForIfaceType(IfaceType::STA);
484     ASSERT_TRUE(createRttController());
485 }
486 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,SelectTxScenarioWithOnlySta)487 TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
488     findModeAndConfigureForIfaceType(IfaceType::STA);
489     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
490     EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
491         .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
492     chip_->selectTxPowerScenario_1_2(
493         V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
494         [](const WifiStatus& status) {
495             ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
496         });
497 }
498 
TEST_F(WifiChipV1_AwareIfaceCombinationTest,SelectTxScenarioWithOnlyAp)499 TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
500     findModeAndConfigureForIfaceType(IfaceType::AP);
501     ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
502     EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
503         .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
504     chip_->selectTxPowerScenario_1_2(
505         V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
506         [](const WifiStatus& status) {
507             ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
508         });
509 }
510 
511 ////////// V2 + Aware Iface Combinations ////////////
512 // Mode 1 - STA + STA/AP
513 //        - STA + P2P/NAN
514 class WifiChipV2_AwareIfaceCombinationTest : public WifiChipTest {
515    public:
SetUp()516     void SetUp() override {
517         setupV2_AwareIfaceCombination();
518         WifiChipTest::SetUp();
519         // V2_Aware has 1 mode of operation.
520         assertNumberOfModes(1u);
521     }
522 };
523 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateSta_ShouldSucceed)524 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateSta_ShouldSucceed) {
525     findModeAndConfigureForIfaceType(IfaceType::STA);
526     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
527 }
528 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateP2p_ShouldSucceed)529 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateP2p_ShouldSucceed) {
530     findModeAndConfigureForIfaceType(IfaceType::STA);
531     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
532 }
533 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateNan_ShouldSucceed)534 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNan_ShouldSucceed) {
535     findModeAndConfigureForIfaceType(IfaceType::STA);
536     ASSERT_FALSE(createIface(IfaceType::NAN).empty());
537 }
538 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateAp_ShouldSucceed)539 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateAp_ShouldSucceed) {
540     findModeAndConfigureForIfaceType(IfaceType::STA);
541     ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
542 }
543 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaSta_ShouldFail)544 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaSta_ShouldFail) {
545     findModeAndConfigureForIfaceType(IfaceType::AP);
546     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
547     ASSERT_TRUE(createIface(IfaceType::STA).empty());
548 }
549 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaAp_ShouldSucceed)550 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaAp_ShouldSucceed) {
551     findModeAndConfigureForIfaceType(IfaceType::AP);
552     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
553     ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
554 }
555 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateApSta_ShouldSucceed)556 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApSta_ShouldSucceed) {
557     findModeAndConfigureForIfaceType(IfaceType::AP);
558     ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
559     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
560 }
561 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateSta_AfterStaApRemove_ShouldSucceed)562 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
563        CreateSta_AfterStaApRemove_ShouldSucceed) {
564     findModeAndConfigureForIfaceType(IfaceType::STA);
565     const auto sta_iface_name = createIface(IfaceType::STA);
566     ASSERT_FALSE(sta_iface_name.empty());
567     const auto ap_iface_name = createIface(IfaceType::AP);
568     ASSERT_FALSE(ap_iface_name.empty());
569 
570     ASSERT_TRUE(createIface(IfaceType::STA).empty());
571 
572     // After removing AP & STA iface, STA iface creation should succeed.
573     removeIface(IfaceType::STA, sta_iface_name);
574     removeIface(IfaceType::AP, ap_iface_name);
575     ASSERT_FALSE(createIface(IfaceType::STA).empty());
576 }
577 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaP2p_ShouldSucceed)578 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2p_ShouldSucceed) {
579     findModeAndConfigureForIfaceType(IfaceType::STA);
580     ASSERT_FALSE(createIface(IfaceType::STA).empty());
581     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
582 }
583 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaNan_ShouldSucceed)584 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_ShouldSucceed) {
585     findModeAndConfigureForIfaceType(IfaceType::STA);
586     ASSERT_FALSE(createIface(IfaceType::STA).empty());
587     ASSERT_FALSE(createIface(IfaceType::NAN).empty());
588 }
589 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaP2PNan_ShouldFail)590 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2PNan_ShouldFail) {
591     findModeAndConfigureForIfaceType(IfaceType::STA);
592     ASSERT_FALSE(createIface(IfaceType::STA).empty());
593     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
594     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
595 }
596 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaNan_AfterP2pRemove_ShouldSucceed)597 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
598        CreateStaNan_AfterP2pRemove_ShouldSucceed) {
599     findModeAndConfigureForIfaceType(IfaceType::STA);
600     ASSERT_FALSE(createIface(IfaceType::STA).empty());
601     const auto p2p_iface_name = createIface(IfaceType::P2P);
602     ASSERT_FALSE(p2p_iface_name.empty());
603     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
604 
605     // After removing P2P iface, NAN iface creation should succeed.
606     removeIface(IfaceType::P2P, p2p_iface_name);
607     ASSERT_FALSE(createIface(IfaceType::NAN).empty());
608 }
609 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaP2p_AfterNanRemove_ShouldSucceed)610 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
611        CreateStaP2p_AfterNanRemove_ShouldSucceed) {
612     findModeAndConfigureForIfaceType(IfaceType::STA);
613     ASSERT_FALSE(createIface(IfaceType::STA).empty());
614     const auto nan_iface_name = createIface(IfaceType::NAN);
615     ASSERT_FALSE(nan_iface_name.empty());
616     ASSERT_TRUE(createIface(IfaceType::P2P).empty());
617 
618     // After removing NAN iface, P2P iface creation should succeed.
619     removeIface(IfaceType::NAN, nan_iface_name);
620     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
621 }
622 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateApNan_ShouldFail)623 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApNan_ShouldFail) {
624     findModeAndConfigureForIfaceType(IfaceType::AP);
625     ASSERT_FALSE(createIface(IfaceType::AP).empty());
626     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
627 }
628 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateApP2p_ShouldFail)629 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApP2p_ShouldFail) {
630     findModeAndConfigureForIfaceType(IfaceType::AP);
631     ASSERT_FALSE(createIface(IfaceType::AP).empty());
632     ASSERT_TRUE(createIface(IfaceType::P2P).empty());
633 }
634 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed)635 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
636        StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
637     findModeAndConfigureForIfaceType(IfaceType::STA);
638     ASSERT_FALSE(createIface(IfaceType::STA).empty());
639     const auto p2p_iface_name = createIface(IfaceType::P2P);
640     ASSERT_FALSE(p2p_iface_name.empty());
641     ASSERT_TRUE(createIface(IfaceType::NAN).empty());
642 
643     // After removing P2P iface, NAN iface creation should succeed.
644     removeIface(IfaceType::P2P, p2p_iface_name);
645     ASSERT_FALSE(createIface(IfaceType::NAN).empty());
646 }
647 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed)648 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
649        StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
650     findModeAndConfigureForIfaceType(IfaceType::STA);
651     ASSERT_FALSE(createIface(IfaceType::STA).empty());
652     const auto nan_iface_name = createIface(IfaceType::NAN);
653     ASSERT_FALSE(nan_iface_name.empty());
654     ASSERT_TRUE(createIface(IfaceType::P2P).empty());
655 
656     // After removing NAN iface, P2P iface creation should succeed.
657     removeIface(IfaceType::NAN, nan_iface_name);
658     ASSERT_FALSE(createIface(IfaceType::P2P).empty());
659 }
660 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateStaAp_EnsureDifferentIfaceNames)661 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
662        CreateStaAp_EnsureDifferentIfaceNames) {
663     findModeAndConfigureForIfaceType(IfaceType::AP);
664     const auto sta_iface_name = createIface(IfaceType::STA);
665     const auto ap_iface_name = createIface(IfaceType::AP);
666     ASSERT_FALSE(sta_iface_name.empty());
667     ASSERT_FALSE(ap_iface_name.empty());
668     ASSERT_NE(sta_iface_name, ap_iface_name);
669 }
670 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,RttControllerFlowStaModeNoSta)671 TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
672     findModeAndConfigureForIfaceType(IfaceType::STA);
673     ASSERT_TRUE(createRttController());
674 }
675 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,RttControllerFlowStaModeWithSta)676 TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlowStaModeWithSta) {
677     findModeAndConfigureForIfaceType(IfaceType::STA);
678     ASSERT_FALSE(createIface(IfaceType::STA).empty());
679     ASSERT_TRUE(createRttController());
680 }
681 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,RttControllerFlow)682 TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlow) {
683     findModeAndConfigureForIfaceType(IfaceType::STA);
684     ASSERT_FALSE(createIface(IfaceType::STA).empty());
685     ASSERT_FALSE(createIface(IfaceType::AP).empty());
686     ASSERT_TRUE(createRttController());
687 }
688 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,SelectTxScenarioWithOnlySta)689 TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
690     findModeAndConfigureForIfaceType(IfaceType::STA);
691     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
692     EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
693         .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
694     chip_->selectTxPowerScenario_1_2(
695         V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
696         [](const WifiStatus& status) {
697             ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
698         });
699 }
700 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,SelectTxScenarioWithOnlyAp)701 TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
702     findModeAndConfigureForIfaceType(IfaceType::AP);
703     ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
704     EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan1", testing::_))
705         .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
706     chip_->selectTxPowerScenario_1_2(
707         V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
708         [](const WifiStatus& status) {
709             ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
710         });
711 }
712 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,InvalidateAndRemoveNanOnStaRemove)713 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
714        InvalidateAndRemoveNanOnStaRemove) {
715     findModeAndConfigureForIfaceType(IfaceType::STA);
716     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
717 
718     // Create NAN iface
719     ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
720 
721     // We should have 1 nan iface.
722     chip_->getNanIfaceNames(
723         [](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
724             ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
725             ASSERT_EQ(iface_names.size(), 1u);
726             ASSERT_EQ(iface_names[0], "wlan0");
727         });
728     // Retrieve the exact iface object.
729     sp<android::hardware::wifi::V1_0::IWifiNanIface> nan_iface;
730     chip_->getNanIface(
731         "wlan0",
732         [&nan_iface](
733             const WifiStatus& status,
734             const sp<android::hardware::wifi::V1_0::IWifiNanIface>& iface) {
735             ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
736             ASSERT_NE(iface.get(), nullptr);
737             nan_iface = iface;
738         });
739 
740     // Remove the STA iface.
741     removeIface(IfaceType::STA, "wlan0");
742     // We should have 0 nan iface now.
743     chip_->getNanIfaceNames(
744         [](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
745             ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
746             ASSERT_EQ(iface_names.size(), 0u);
747         });
748     // Any operation on the nan iface object should return error now.
749     nan_iface->getName(
750         [](const WifiStatus& status, const std::string& /* iface_name */) {
751             ASSERT_EQ(WifiStatusCode::ERROR_WIFI_IFACE_INVALID, status.code);
752         });
753 }
754 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,InvalidateAndRemoveRttControllerOnStaRemove)755 TEST_F(WifiChipV2_AwareIfaceCombinationTest,
756        InvalidateAndRemoveRttControllerOnStaRemove) {
757     findModeAndConfigureForIfaceType(IfaceType::STA);
758     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
759 
760     // Create RTT controller
761     sp<IWifiRttController> rtt_controller;
762     chip_->createRttController_1_4(
763         NULL, [&rtt_controller](const WifiStatus& status,
764                                 const sp<IWifiRttController>& rtt) {
765             if (WifiStatusCode::SUCCESS == status.code) {
766                 ASSERT_NE(rtt.get(), nullptr);
767                 rtt_controller = rtt;
768             }
769         });
770 
771     // Remove the STA iface.
772     removeIface(IfaceType::STA, "wlan0");
773 
774     // Any operation on the rtt controller object should return error now.
775     rtt_controller->getBoundIface(
776         [](const WifiStatus& status, const sp<IWifiIface>& /* iface */) {
777             ASSERT_EQ(WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
778                       status.code);
779         });
780 }
781 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateNanWithSharedNanIface)782 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithSharedNanIface) {
783     property_set("wifi.aware.interface", nullptr);
784     findModeAndConfigureForIfaceType(IfaceType::STA);
785     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
786     ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
787     removeIface(IfaceType::NAN, "wlan0");
788     EXPECT_CALL(*iface_util_, setUpState(testing::_, testing::_)).Times(0);
789 }
790 
TEST_F(WifiChipV2_AwareIfaceCombinationTest,CreateNanWithDedicatedNanIface)791 TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithDedicatedNanIface) {
792     property_set("wifi.aware.interface", "aware0");
793     findModeAndConfigureForIfaceType(IfaceType::STA);
794     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
795     EXPECT_CALL(*iface_util_, ifNameToIndex("aware0"))
796         .WillOnce(testing::Return(4));
797     EXPECT_CALL(*iface_util_, setUpState("aware0", true))
798         .WillOnce(testing::Return(true));
799     ASSERT_EQ(createIface(IfaceType::NAN), "aware0");
800 
801     EXPECT_CALL(*iface_util_, setUpState("aware0", false))
802         .WillOnce(testing::Return(true));
803     removeIface(IfaceType::NAN, "aware0");
804 }
805 
806 ////////// V1 Iface Combinations when AP creation is disabled //////////
807 class WifiChipV1_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
808    public:
SetUp()809     void SetUp() override {
810         setupV1_AwareDisabledApIfaceCombination();
811         WifiChipTest::SetUp();
812     }
813 };
814 
TEST_F(WifiChipV1_AwareDisabledApIfaceCombinationTest,StaMode_CreateSta_ShouldSucceed)815 TEST_F(WifiChipV1_AwareDisabledApIfaceCombinationTest,
816        StaMode_CreateSta_ShouldSucceed) {
817     findModeAndConfigureForIfaceType(IfaceType::STA);
818     ASSERT_FALSE(createIface(IfaceType::STA).empty());
819     ASSERT_TRUE(createIface(IfaceType::AP).empty());
820 }
821 
822 ////////// V2 Iface Combinations when AP creation is disabled //////////
823 class WifiChipV2_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
824    public:
SetUp()825     void SetUp() override {
826         setupV2_AwareDisabledApIfaceCombination();
827         WifiChipTest::SetUp();
828     }
829 };
830 
TEST_F(WifiChipV2_AwareDisabledApIfaceCombinationTest,CreateSta_ShouldSucceed)831 TEST_F(WifiChipV2_AwareDisabledApIfaceCombinationTest,
832        CreateSta_ShouldSucceed) {
833     findModeAndConfigureForIfaceType(IfaceType::STA);
834     ASSERT_FALSE(createIface(IfaceType::STA).empty());
835     ASSERT_TRUE(createIface(IfaceType::AP).empty());
836 }
837 
838 ////////// Hypothetical Iface Combination with multiple ifaces //////////
839 class WifiChip_MultiIfaceTest : public WifiChipTest {
840    public:
SetUp()841     void SetUp() override {
842         setup_MultiIfaceCombination();
843         WifiChipTest::SetUp();
844     }
845 };
846 
TEST_F(WifiChip_MultiIfaceTest,Create3Sta)847 TEST_F(WifiChip_MultiIfaceTest, Create3Sta) {
848     findModeAndConfigureForIfaceType(IfaceType::STA);
849     ASSERT_FALSE(createIface(IfaceType::STA).empty());
850     ASSERT_FALSE(createIface(IfaceType::STA).empty());
851     ASSERT_FALSE(createIface(IfaceType::STA).empty());
852     ASSERT_TRUE(createIface(IfaceType::STA).empty());
853 }
854 
TEST_F(WifiChip_MultiIfaceTest,CreateStaWithDefaultNames)855 TEST_F(WifiChip_MultiIfaceTest, CreateStaWithDefaultNames) {
856     property_set("wifi.interface.0", "");
857     property_set("wifi.interface.1", "");
858     property_set("wifi.interface.2", "");
859     property_set("wifi.interface", "");
860     property_set("wifi.concurrent.interface", "");
861     findModeAndConfigureForIfaceType(IfaceType::STA);
862     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
863     ASSERT_EQ(createIface(IfaceType::STA), "wlan1");
864     ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
865 }
866 
TEST_F(WifiChip_MultiIfaceTest,CreateStaWithCustomNames)867 TEST_F(WifiChip_MultiIfaceTest, CreateStaWithCustomNames) {
868     property_set("wifi.interface.0", "test0");
869     property_set("wifi.interface.1", "test1");
870     property_set("wifi.interface.2", "test2");
871     property_set("wifi.interface", "bad0");
872     property_set("wifi.concurrent.interface", "bad1");
873     findModeAndConfigureForIfaceType(IfaceType::STA);
874     ASSERT_EQ(createIface(IfaceType::STA), "bad0");
875     ASSERT_EQ(createIface(IfaceType::STA), "bad1");
876     ASSERT_EQ(createIface(IfaceType::STA), "test2");
877 }
878 
TEST_F(WifiChip_MultiIfaceTest,CreateStaWithCustomAltNames)879 TEST_F(WifiChip_MultiIfaceTest, CreateStaWithCustomAltNames) {
880     property_set("wifi.interface.0", "");
881     property_set("wifi.interface.1", "");
882     property_set("wifi.interface.2", "");
883     property_set("wifi.interface", "testA0");
884     property_set("wifi.concurrent.interface", "testA1");
885     findModeAndConfigureForIfaceType(IfaceType::STA);
886     ASSERT_EQ(createIface(IfaceType::STA), "testA0");
887     ASSERT_EQ(createIface(IfaceType::STA), "testA1");
888     ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
889 }
890 
TEST_F(WifiChip_MultiIfaceTest,CreateApStartsWithIdx1)891 TEST_F(WifiChip_MultiIfaceTest, CreateApStartsWithIdx1) {
892     findModeAndConfigureForIfaceType(IfaceType::STA);
893     // First AP will be slotted to wlan1.
894     ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
895     // First STA will be slotted to wlan0.
896     ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
897     // All further STA will be slotted to the remaining free indices.
898     ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
899     ASSERT_EQ(createIface(IfaceType::STA), "wlan3");
900 }
901 }  // namespace implementation
902 }  // namespace V1_5
903 }  // namespace wifi
904 }  // namespace hardware
905 }  // namespace android
906