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_p2p_iface.h"
19 
20 using namespace testing::ext;
21 using namespace OHOS::HDI::Wlan::Chip::V1_0;
22 
23 namespace WifiP2pIfaceTest {
24 const std::string P2P_IFNAME = "P2P0";
25 const std::string TEST_MAC = "000000";
26 
27 class WifiP2pIfaceTest : public testing::Test {
28 public:
SetUpTestCase()29     static void SetUpTestCase() {}
TearDownTestCase()30     static void TearDownTestCase() {}
SetUp()31     void SetUp()
32     {
33         std::weak_ptr<IfaceTool> ifaceTool = std::make_shared<IfaceTool>();
34         WifiHalFn fn;
35         std::weak_ptr<WifiVendorHal> vendorHal = std::make_shared<WifiVendorHal>(ifaceTool, fn, true);
36         p2pIface = new (std::nothrow) WifiP2pIface(P2P_IFNAME, vendorHal,
37             std::make_shared<IfaceUtil>(ifaceTool));
38         if (p2pIface == nullptr) {
39             HDF_LOGE("iface is null");
40             return;
41         }
42     }
TearDown()43     void TearDown()
44     {
45         HDF_LOGE("iface teardown");
46     }
47 
48 public:
49     sptr<WifiP2pIface> p2pIface;
50 };
51 
52 /**
53  * @tc.name: WifiP2pIfaceTest
54  * @tc.desc: WifiP2pIface
55  * @tc.type: FUNC
56  * @tc.require:
57  */
HWTEST_F(WifiP2pIfaceTest, WifiP2pIfaceTest, TestSize.Level1)58 HWTEST_F(WifiP2pIfaceTest, WifiP2pIfaceTest, TestSize.Level1)
59 {
60     HDF_LOGI("WifiP2pIfaceTest started");
61     if (p2pIface == nullptr) {
62         HDF_LOGE("iface is null");
63         return;
64     }
65     p2pIface->Invalidate();
66     EXPECT_FALSE(p2pIface->IsValid());
67     EXPECT_TRUE(p2pIface->GetName() == P2P_IFNAME);
68     IfaceType type = IfaceType::STA;
69     EXPECT_TRUE(p2pIface->GetIfaceType(type) == HDF_SUCCESS);
70     EXPECT_TRUE(type == IfaceType::P2P);
71     std::string name;
72     EXPECT_TRUE(p2pIface->GetIfaceName(name) == HDF_SUCCESS);
73     EXPECT_TRUE(name == P2P_IFNAME);
74     std::vector<uint32_t> frequencies;
75     EXPECT_TRUE(p2pIface->GetSupportFreqs(1, frequencies) == HDF_SUCCESS);
76 }
77 
HWTEST_F(WifiP2pIfaceTest, SetMacAddressTest, TestSize.Level1)78 HWTEST_F(WifiP2pIfaceTest, SetMacAddressTest, TestSize.Level1)
79 {
80     HDF_LOGI("SetMacAddressTest started");
81     if (p2pIface == nullptr) {
82         HDF_LOGE("iface is null");
83         return;
84     }
85     EXPECT_TRUE(p2pIface->SetMacAddress(TEST_MAC) == HDF_ERR_NOT_SUPPORT);
86 }
87 
HWTEST_F(WifiP2pIfaceTest, SetCountryCodeTest, TestSize.Level1)88 HWTEST_F(WifiP2pIfaceTest, SetCountryCodeTest, TestSize.Level1)
89 {
90     HDF_LOGI("SetCountryCodeTest started");
91     if (p2pIface == nullptr) {
92         HDF_LOGE("iface is null");
93         return;
94     }
95     EXPECT_TRUE(p2pIface->SetCountryCode("CN") == HDF_ERR_NOT_SUPPORT);
96 }
97 
HWTEST_F(WifiP2pIfaceTest, GetPowerModeTest, TestSize.Level1)98 HWTEST_F(WifiP2pIfaceTest, GetPowerModeTest, TestSize.Level1)
99 {
100     HDF_LOGI("GetPowerModeTest started");
101     if (p2pIface == nullptr) {
102         HDF_LOGE("iface is null");
103         return;
104     }
105     int32_t mode;
106     EXPECT_TRUE(p2pIface->GetPowerMode(mode) == HDF_ERR_NOT_SUPPORT);
107 }
108 
HWTEST_F(WifiP2pIfaceTest, SetPowerModeTest, TestSize.Level1)109 HWTEST_F(WifiP2pIfaceTest, SetPowerModeTest, TestSize.Level1)
110 {
111     HDF_LOGI("SetPowerModeTest started");
112     if (p2pIface == nullptr) {
113         HDF_LOGE("iface is null");
114         return;
115     }
116     EXPECT_TRUE(p2pIface->SetPowerMode(0) == HDF_ERR_NOT_SUPPORT);
117 }
118 
HWTEST_F(WifiP2pIfaceTest, GetIfaceCapTest, TestSize.Level1)119 HWTEST_F(WifiP2pIfaceTest, GetIfaceCapTest, TestSize.Level1)
120 {
121     HDF_LOGI("GetIfaceCapTest started");
122     if (p2pIface == nullptr) {
123         HDF_LOGE("iface is null");
124         return;
125     }
126     uint32_t cap;
127     EXPECT_TRUE(p2pIface->GetIfaceCap(cap) == HDF_SUCCESS);
128 }
129 
HWTEST_F(WifiP2pIfaceTest, StartScanTest, TestSize.Level1)130 HWTEST_F(WifiP2pIfaceTest, StartScanTest, TestSize.Level1)
131 {
132     HDF_LOGI("StartScanTest started");
133     if (p2pIface == nullptr) {
134         HDF_LOGE("iface is null");
135         return;
136     }
137     ScanParams scanParam;
138     scanParam.bssid = TEST_MAC;
139     EXPECT_TRUE(p2pIface->StartScan(scanParam) == HDF_ERR_NOT_SUPPORT);
140 }
141 
HWTEST_F(WifiP2pIfaceTest, GetScanInfosTest, TestSize.Level1)142 HWTEST_F(WifiP2pIfaceTest, GetScanInfosTest, TestSize.Level1)
143 {
144     HDF_LOGI("GetScanInfosTest started");
145     if (p2pIface == nullptr) {
146         HDF_LOGE("iface is null");
147         return;
148     }
149     std::vector<ScanResultsInfo> scanResult;
150     EXPECT_TRUE(p2pIface->GetScanInfos(scanResult) == HDF_ERR_NOT_SUPPORT);
151 }
152 
HWTEST_F(WifiP2pIfaceTest, StartPnoScanTest, TestSize.Level1)153 HWTEST_F(WifiP2pIfaceTest, StartPnoScanTest, TestSize.Level1)
154 {
155     HDF_LOGI("StartPnoScanTest started");
156     if (p2pIface == nullptr) {
157         HDF_LOGE("iface is null");
158         return;
159     }
160     PnoScanParams pnoParam;
161     pnoParam.min2gRssi = 1;
162     EXPECT_TRUE(p2pIface->StartPnoScan(pnoParam) == HDF_ERR_NOT_SUPPORT);
163 }
164 
HWTEST_F(WifiP2pIfaceTest, StopPnoScanTest, TestSize.Level1)165 HWTEST_F(WifiP2pIfaceTest, StopPnoScanTest, TestSize.Level1)
166 {
167     HDF_LOGI("StopPnoScanTest started");
168     if (p2pIface == nullptr) {
169         HDF_LOGE("iface is null");
170         return;
171     }
172     EXPECT_TRUE(p2pIface->StopPnoScan() == HDF_ERR_NOT_SUPPORT);
173 }
174 
HWTEST_F(WifiP2pIfaceTest, GetSignalPollInfoTest, TestSize.Level1)175 HWTEST_F(WifiP2pIfaceTest, GetSignalPollInfoTest, TestSize.Level1)
176 {
177     HDF_LOGI("GetSignalPollInfoTest started");
178     if (p2pIface == nullptr) {
179         HDF_LOGE("iface is null");
180         return;
181     }
182     SignalPollResult info;
183     EXPECT_TRUE(p2pIface->GetSignalPollInfo(info) == HDF_ERR_NOT_SUPPORT);
184 }
185 
HWTEST_F(WifiP2pIfaceTest, SetDpiMarkRuleTest, TestSize.Level1)186 HWTEST_F(WifiP2pIfaceTest, SetDpiMarkRuleTest, TestSize.Level1)
187 {
188     HDF_LOGI("SetDpiMarkRuleTest started");
189     if (p2pIface == nullptr) {
190         HDF_LOGE("iface is null");
191         return;
192     }
193     EXPECT_TRUE(p2pIface->SetDpiMarkRule(0, 0, 0) == HDF_ERR_NOT_SUPPORT);
194 }
195 
HWTEST_F(WifiP2pIfaceTest, EnablePowerModeTest, TestSize.Level1)196 HWTEST_F(WifiP2pIfaceTest, EnablePowerModeTest, TestSize.Level1)
197 {
198     HDF_LOGI("EnablePowerModeTest started");
199     if (p2pIface == nullptr) {
200         HDF_LOGE("iface is null");
201         return;
202     }
203     EXPECT_TRUE(p2pIface->EnablePowerMode(0) == HDF_ERR_NOT_SUPPORT);
204 }
205 }