1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <hdf_log.h>
18 #include "../../../chip/hdi_service/wifi_sta_iface.h"
19 #include "wifi_hal_fn.h"
20 
21 using namespace testing::ext;
22 using namespace OHOS::HDI::Wlan::Chip::V1_0;
23 
24 namespace WifiStaIfaceTest {
25 const std::string WLAN_IFNAME = "wlan0";
26 const std::string AP_IFNAME = "wlan1";
27 const std::string TEST_MAC = "000000";
28 
29 class WifiStaIfaceTest : public testing::Test {
30 public:
SetUpTestCase()31     static void SetUpTestCase() {}
TearDownTestCase()32     static void TearDownTestCase() {}
SetUp()33     void SetUp()
34     {
35         std::vector<std::string> instances = {WLAN_IFNAME};
36         ifaceTool = std::make_shared<IfaceTool>();
37         ifaceUtil = std::make_shared<IfaceUtil>(ifaceTool);
38         WifiHalFn fn;
39         InitWifiHalFuncTable(&fn);
40         wifiVendorHalTest = std::make_shared<WifiVendorHal>(ifaceTool, fn, true);
41         staIface = new (std::nothrow) WifiStaIface(WLAN_IFNAME, wifiVendorHalTest, ifaceUtil);
42         testIface = new (std::nothrow) WifiStaIface(AP_IFNAME, wifiVendorHalTest, ifaceUtil);
43     }
TearDown()44     void TearDown()
45     {
46         wifiVendorHalTest.reset();
47         ifaceTool.reset();
48         ifaceUtil.reset();
49     }
50 
51 public:
52     std::shared_ptr<WifiVendorHal> wifiVendorHalTest;
53     std::shared_ptr<IfaceTool> ifaceTool;
54     std::shared_ptr<IfaceUtil> ifaceUtil;
55     sptr<WifiStaIface> staIface;
56     sptr<WifiStaIface> testIface;
57 };
58 
59 /**
60  * @tc.name: WifiStaIfaceTest001
61  * @tc.desc: wifiStaIface
62  * @tc.type: FUNC
63  * @tc.require:
64  */
65 HWTEST_F(WifiStaIfaceTest, WifiStaIfaceTest001, TestSize.Level1)
66 {
67     HDF_LOGI("WifiStaIfaceTest001 started");
68     if (staIface == nullptr) {
69         HDF_LOGE("iface is null");
70         return;
71     }
72     staIface->Invalidate();
73     EXPECT_FALSE(staIface->IsValid());
74     staIface->IsValid();
75     EXPECT_TRUE(staIface->GetName() == WLAN_IFNAME);
76     IfaceType type = IfaceType::AP;
77     EXPECT_TRUE(staIface->GetIfaceType(type) == HDF_SUCCESS);
78     EXPECT_TRUE(type == IfaceType::STA);
79     std::string name;
80     EXPECT_TRUE(staIface->GetIfaceName(name) == HDF_SUCCESS);
81     EXPECT_TRUE(name == WLAN_IFNAME);
82 }
83 
84 HWTEST_F(WifiStaIfaceTest, SetDpiMarkRuleTest, TestSize.Level1)
85 {
86     HDF_LOGI("SetDpiMarkRuleTest started");
87     if (staIface == nullptr) {
88         HDF_LOGE("iface is null");
89         return;
90     }
91     EXPECT_TRUE(staIface->SetDpiMarkRule(0, 0, 0) == HDF_SUCCESS);
92     EXPECT_TRUE(staIface->SetDpiMarkRule(1, 1, 1) == HDF_FAILURE);
93     EXPECT_TRUE(staIface->SetTxPower(0) == HDF_SUCCESS);
94     EXPECT_TRUE(staIface->SetTxPower(1) == HDF_FAILURE);
95 }
96 
97 HWTEST_F(WifiStaIfaceTest, EnablePowerModeTest, TestSize.Level1)
98 {
99     HDF_LOGI("EnablePowerModeTest started");
100     if (staIface == nullptr) {
101         HDF_LOGE("iface is null");
102         return;
103     }
104     EXPECT_TRUE(staIface->EnablePowerMode(0) == HDF_SUCCESS);
105     uint32_t cap;
106     EXPECT_TRUE(staIface->GetIfaceCap(cap) == HDF_SUCCESS);
107     EXPECT_TRUE(testIface->GetIfaceCap(cap) == HDF_FAILURE);
108 }
109 
110 HWTEST_F(WifiStaIfaceTest, GetSupportFreqsTest, TestSize.Level1)
111 {
112     HDF_LOGI("GetSupportFreqsTest started");
113     if (staIface == nullptr) {
114         HDF_LOGE("iface is null");
115         return;
116     }
117     std::vector<uint32_t> freqs;
118     EXPECT_TRUE(staIface->GetSupportFreqs(0, freqs) == HDF_SUCCESS);
119     EXPECT_TRUE(staIface->SetMacAddress(TEST_MAC) == HDF_SUCCESS);
120     EXPECT_TRUE(staIface->SetCountryCode("cn") == HDF_SUCCESS);
121     EXPECT_TRUE(staIface->SetPowerMode(0) == HDF_ERR_NOT_SUPPORT);
122     int32_t mode;
123     EXPECT_TRUE(staIface->GetPowerMode(mode) == HDF_ERR_NOT_SUPPORT);
124 }
125 
126 HWTEST_F(WifiStaIfaceTest, RegisterChipIfaceCallBackTest, TestSize.Level1)
127 {
128     HDF_LOGI("RegisterChipIfaceCallBackTest started");
129     if (staIface == nullptr) {
130         HDF_LOGE("iface is null");
131         return;
132     }
133     sptr<IChipIfaceCallback> ifaceCallback;
134     EXPECT_TRUE(staIface->RegisterChipIfaceCallBack(ifaceCallback) == HDF_FAILURE);
135     EXPECT_TRUE(staIface->UnRegisterChipIfaceCallBack(ifaceCallback) == HDF_FAILURE);
136 }
137 
138 HWTEST_F(WifiStaIfaceTest, ScanTest, TestSize.Level1)
139 {
140     HDF_LOGI("ScanTest started");
141     if (staIface == nullptr) {
142         HDF_LOGE("iface is null");
143         return;
144     }
145     ScanParams scanParam;
146     scanParam.fastConnectFlag = 0;
147     EXPECT_TRUE(staIface->StartScan(scanParam) == HDF_SUCCESS);
148     scanParam.fastConnectFlag = 1;
149     EXPECT_TRUE(staIface->StartScan(scanParam) == HDF_FAILURE);
150     std::vector<ScanResultsInfo> scanInfo;
151     staIface->GetScanInfos(scanInfo);
152     SignalPollResult signalPollResult;
153     staIface->GetSignalPollInfo(signalPollResult);
154     PnoScanParams pnoParam;
155     pnoParam.min2gRssi = 0;
156     EXPECT_TRUE(staIface->StartPnoScan(pnoParam) == HDF_SUCCESS);
157     pnoParam.min2gRssi = 1;
158     EXPECT_TRUE(staIface->StartPnoScan(pnoParam) == HDF_FAILURE);
159     EXPECT_TRUE(staIface->StopPnoScan() == HDF_SUCCESS);
160 }
161 }