1 /*
2  * Copyright (C) 2021 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 #include <gtest/gtest.h>
16 
17 #include <cstdio>
18 #include "wifi_msg.h"
19 #include "wifi_p2p_service_manager.h"
20 
21 using ::testing::ext::TestSize;
22 
23 namespace OHOS {
24 namespace Wifi {
25 class WifiP2pServiceManagerTest : public testing::Test {
26 public:
WifiP2pServiceManagerTest()27     WifiP2pServiceManagerTest()
28     {}
29 
SetUp()30     virtual void SetUp()
31     {
32         pWifiP2pServiceManager.reset(new WifiP2pServiceManager());
33     }
TearDown()34     virtual void TearDown()
35     {
36         pWifiP2pServiceManager.reset();
37     }
SetUpTestCase()38     static void SetUpTestCase()
39     {}
TearDownTestCase()40     static void TearDownTestCase()
41     {}
42     std::unique_ptr<WifiP2pServiceManager> pWifiP2pServiceManager;
43 };
44 
45 HWTEST_F(WifiP2pServiceManagerTest, Init, TestSize.Level1)
46 {
47     pWifiP2pServiceManager->Init();
48 }
49 
50 HWTEST_F(WifiP2pServiceManagerTest, SetQueryId, TestSize.Level1)
51 {
52     pWifiP2pServiceManager->SetQueryId("queryId");
53     EXPECT_EQ(pWifiP2pServiceManager->GetQueryId(), "queryId");
54 }
55 
56 HWTEST_F(WifiP2pServiceManagerTest, GetTransId, TestSize.Level1)
57 {
58     EXPECT_EQ(pWifiP2pServiceManager->GetTransId(), 1);
59 }
60 
61 HWTEST_F(WifiP2pServiceManagerTest, AddLocalService, TestSize.Level1)
62 {
63     WifiP2pServiceInfo p2pSvrInfo;
64     EXPECT_TRUE(pWifiP2pServiceManager->AddLocalService(p2pSvrInfo));
65     EXPECT_FALSE(pWifiP2pServiceManager->AddLocalService(p2pSvrInfo));
66 }
67 
68 HWTEST_F(WifiP2pServiceManagerTest, RemoveLocalService, TestSize.Level1)
69 {
70     WifiP2pServiceInfo p2pSvrInfo;
71     EXPECT_FALSE(pWifiP2pServiceManager->RemoveLocalService(p2pSvrInfo));
72     EXPECT_TRUE(pWifiP2pServiceManager->AddLocalService(p2pSvrInfo));
73     EXPECT_TRUE(pWifiP2pServiceManager->RemoveLocalService(p2pSvrInfo));
74 }
75 
76 HWTEST_F(WifiP2pServiceManagerTest, GetLocalServiceList, TestSize.Level1)
77 {
78     WifiP2pServiceInfo p2pSvrInfo;
79     std::vector<WifiP2pServiceInfo> localServicesInfo;
80     localServicesInfo.push_back(p2pSvrInfo);
81     EXPECT_TRUE(pWifiP2pServiceManager->AddLocalService(p2pSvrInfo));
82     EXPECT_EQ(pWifiP2pServiceManager->GetLocalServiceList(), localServicesInfo);
83 }
84 
85 HWTEST_F(WifiP2pServiceManagerTest, AddDeviceResponses, TestSize.Level1)
86 {
87     WifiP2pDevice device;
88     WifiP2pServiceResponseList p2pSvrReq;
89     EXPECT_TRUE(pWifiP2pServiceManager->AddDeviceResponses(p2pSvrReq));
90     device.SetDeviceAddress("AA:BB:CC:DD:EE:FF");
91     p2pSvrReq.SetDevice(device);
92     WifiP2pServiceResponse resp;
93     p2pSvrReq.AddServiceResponse(resp);
94     EXPECT_TRUE(pWifiP2pServiceManager->AddDeviceResponses(p2pSvrReq));
95 }
96 
97 HWTEST_F(WifiP2pServiceManagerTest, AddDeviceService, TestSize.Level1)
98 {
99     WifiP2pServiceResponse rsp;
100     WifiP2pDevice dev;
101     rsp.SetServiceStatus(P2pServiceStatus::PSRS_SERVICE_PROTOCOL_NOT_AVAILABLE);
102     EXPECT_FALSE(pWifiP2pServiceManager->AddDeviceService(rsp, dev));
103     dev.SetDeviceAddress("AA:BB:CC:DD:EE:FF");
104     rsp.SetServiceStatus(P2pServiceStatus::PSRS_SUCCESS);
105     EXPECT_TRUE(pWifiP2pServiceManager->AddDeviceService(rsp, dev));
106 }
107 
108 HWTEST_F(WifiP2pServiceManagerTest, DelServicesFormAddress, TestSize.Level1)
109 {
110     EXPECT_FALSE(pWifiP2pServiceManager->DelServicesFormAddress("AA:BB:CC:DD:EE:FF"));
111     WifiP2pDevice device;
112     device.SetDeviceAddress("AA:BB:CC:DD:EE:FF");
113     WifiP2pServiceResponse rsp;
114     rsp.SetServiceStatus(P2pServiceStatus::PSRS_SUCCESS);
115     EXPECT_TRUE(pWifiP2pServiceManager->AddDeviceService(rsp, device));
116     EXPECT_TRUE(pWifiP2pServiceManager->DelServicesFormAddress("AA:BB:CC:DD:EE:FF"));
117 }
118 
119 HWTEST_F(WifiP2pServiceManagerTest, GetDeviceServices, TestSize.Level1)
120 {
121     std::vector<WifiP2pServiceInfo> services, services1;
122     WifiP2pServiceInfo info;
123     services1.push_back(info);
124 
125     WifiP2pDevice device;
126     device.SetDeviceAddress("AA:BB:CC:DD:EE:FF");
127     WifiP2pServiceResponse rsp;
128     rsp.SetServiceStatus(P2pServiceStatus::PSRS_SUCCESS);
129     EXPECT_TRUE(pWifiP2pServiceManager->AddDeviceService(rsp, device));
130     pWifiP2pServiceManager->GetDeviceServices(services);
131 }
132 
133 HWTEST_F(WifiP2pServiceManagerTest, GetServiceResponseList, TestSize.Level1)
134 {
135     std::vector<WifiP2pServiceResponseList> respLists;
136     WifiP2pServiceResponseList respList;
137     respLists.push_back(respList);
138     pWifiP2pServiceManager->GetServiceResponseList(respLists);
139 }
140 
141 HWTEST_F(WifiP2pServiceManagerTest, AddServiceResponse_SUCCESS, TestSize.Level1)
142 {
143     WifiP2pDevice device;
144     WifiP2pServiceResponseList p2pSvrReq, p2pSvrReq1;
145     device.SetDeviceAddress("AA:BB:CC:DD:EE:FF");
146     p2pSvrReq.SetDevice(device);
147     p2pSvrReq1.SetDevice(device);
148     WifiP2pServiceResponse resp, resq1;
149     resq1.SetServiceStatus(P2pServiceStatus::PSRS_REQUESTED_INFORMATION_NOT_AVAILABLE);
150     p2pSvrReq.AddServiceResponse(resp);
151     p2pSvrReq1.AddServiceResponse(resq1);
152     EXPECT_TRUE(pWifiP2pServiceManager->AddServiceResponse(p2pSvrReq));
153     EXPECT_FALSE(pWifiP2pServiceManager->AddServiceResponse(p2pSvrReq));
154     EXPECT_TRUE(pWifiP2pServiceManager->AddServiceResponse(p2pSvrReq1));
155 }
156 
157 HWTEST_F(WifiP2pServiceManagerTest, RemoveServiceResponse_SUCCESS, TestSize.Level1)
158 {
159     WifiP2pDevice device;
160     WifiP2pServiceResponseList p2pSvrReq, p2pSvrReq1;
161     device.SetDeviceAddress("AA:BB:CC:DD:EE:FF");
162     p2pSvrReq.SetDevice(device);
163     p2pSvrReq1.SetDevice(device);
164     WifiP2pServiceResponse resp, resq1;
165     resq1.SetServiceStatus(P2pServiceStatus::PSRS_REQUESTED_INFORMATION_NOT_AVAILABLE);
166     p2pSvrReq.AddServiceResponse(resp);
167     p2pSvrReq1.AddServiceResponse(resq1);
168 
169     EXPECT_FALSE(pWifiP2pServiceManager->RemoveServiceResponse(p2pSvrReq));
170     EXPECT_TRUE(pWifiP2pServiceManager->AddServiceResponse(p2pSvrReq));
171     EXPECT_TRUE(pWifiP2pServiceManager->RemoveServiceResponse(p2pSvrReq));
172     EXPECT_TRUE(pWifiP2pServiceManager->RemoveServiceResponse(p2pSvrReq1));
173     EXPECT_TRUE(pWifiP2pServiceManager->AddServiceResponse(p2pSvrReq));
174     EXPECT_TRUE(pWifiP2pServiceManager->RemoveServiceResponse("AA:BB:CC:DD:EE:FF"));
175     EXPECT_FALSE(pWifiP2pServiceManager->RemoveServiceResponse("AA:BB:CC:DD:EE:FF"));
176 }
177 
178 HWTEST_F(WifiP2pServiceManagerTest, ProcessServiceRequestList, TestSize.Level1)
179 {
180     WifiP2pServiceRequestList respList;
181     WifiP2pServiceRequest req;
182     respList.AddServiceRequest(req);
183     WifiP2pServiceInfo p2pSvrInfo;
184     pWifiP2pServiceManager->ProcessServiceRequestList(respList);
185     EXPECT_TRUE(pWifiP2pServiceManager->AddLocalService(p2pSvrInfo));
186     pWifiP2pServiceManager->ProcessServiceRequestList(respList);
187 }
188 
189 HWTEST_F(WifiP2pServiceManagerTest, ProcessServiceResponseList, TestSize.Level1)
190 {
191     WifiP2pServiceResponseList respList;
192     WifiP2pServiceResponse resp;
193     respList.AddServiceResponse(resp);
194     WifiP2pServiceInfo p2pSvrInfo;
195     pWifiP2pServiceManager->ProcessServiceResponseList(respList);
196     EXPECT_TRUE(pWifiP2pServiceManager->AddLocalService(p2pSvrInfo));
197     pWifiP2pServiceManager->ProcessServiceResponseList(respList);
198 }
199 
200 HWTEST_F(WifiP2pServiceManagerTest, AddRequestRecord, TestSize.Level1)
201 {
202     pWifiP2pServiceManager->AddRequestRecord("AA:BB:CC:DD:EE:FF", 10);
203     pWifiP2pServiceManager->AddRequestRecord("AA:BB:CC:DD:EE:FF", 10);
204     pWifiP2pServiceManager->AddRequestRecord("AA:BB:CC:DD:EE:FF", 11);
205 }
206 
207 HWTEST_F(WifiP2pServiceManagerTest, IsRecordedRequest, TestSize.Level1)
208 {
209     WifiP2pServiceInfo p2pSvrInfo;
210     EXPECT_FALSE(pWifiP2pServiceManager->IsRecordedRequest("AA:BB:CC:DD:EE:FF", 10));
211     p2pSvrInfo.SetDeviceAddress("AA:BB:CC:DD:EE:FF");
212     EXPECT_TRUE(pWifiP2pServiceManager->AddLocalService(p2pSvrInfo));
213 
214     EXPECT_FALSE(pWifiP2pServiceManager->IsRecordedRequest("AA:BB:CC:DD:EE:FF", 10));
215     pWifiP2pServiceManager->AddRequestRecord("AA:BB:CC:DD:EE:FF", 10);
216     EXPECT_TRUE(pWifiP2pServiceManager->IsRecordedRequest("AA:BB:CC:DD:EE:FF", 10));
217 }
218 
219 HWTEST_F(WifiP2pServiceManagerTest, RemoveRequestRecord, TestSize.Level1)
220 {
221     pWifiP2pServiceManager->RemoveRequestRecord("AA:BB:CC:DD:EE:FF", 10);
222     pWifiP2pServiceManager->AddRequestRecord("AA:BB:CC:DD:EE:FF", 10);
223 
224     pWifiP2pServiceManager->RemoveRequestRecord("AA:BB:CC:DD:EE:FF", 10);
225     pWifiP2pServiceManager->RemoveRequestRecord("AA:BB:CC:DD:EE:FF", 11);
226 }
227 
228 HWTEST_F(WifiP2pServiceManagerTest, UpdateServiceName1, TestSize.Level1)
229 {
230     WifiP2pServiceResponse resp;
231     resp.SetServiceStatus(P2pServiceStatus::PSRS_SUCCESS);
232     WifiP2pDevice device;
233     device.SetDeviceAddress(std::string("aa:bb:cc:dd:ee:ff"));
234     EXPECT_FALSE(pWifiP2pServiceManager->UpdateServiceName(std::string("aa:bb:cc:dd:ee:ff"), resp));
235 }
236 
237 HWTEST_F(WifiP2pServiceManagerTest, UpdateServiceName2, TestSize.Level1)
238 {
239     WifiP2pServiceResponse resp;
240     resp.SetServiceStatus(P2pServiceStatus::PSRS_SUCCESS);
241     WifiP2pDevice device;
242     device.SetDeviceAddress(std::string("aa:bb:cc:dd:ee:ff"));
243     pWifiP2pServiceManager->AddDeviceService(resp, device);
244     EXPECT_TRUE(pWifiP2pServiceManager->UpdateServiceName(std::string("aa:bb:cc:dd:ee:ff"), resp));
245 }
246 
247 HWTEST_F(WifiP2pServiceManagerTest, UpdateServiceName3, TestSize.Level1)
248 {
249     WifiP2pServiceResponse resp;
250     resp.SetServiceStatus(P2pServiceStatus::PSRS_SUCCESS);
251     resp.SetProtocolType(P2pServicerProtocolType::SERVICE_TYPE_BONJOUR);
252     WifiP2pDevice device;
253     device.SetDeviceAddress(std::string("aa:bb:cc:dd:ee:ff"));
254     pWifiP2pServiceManager->AddDeviceService(resp, device);
255     resp.SetProtocolType(P2pServicerProtocolType::SERVICE_TYPE_UP_NP);
256     EXPECT_FALSE(pWifiP2pServiceManager->UpdateServiceName(std::string("aa:bb:cc:dd:ee:ff"), resp));
257 }
258 }  // namespace Wifi
259 }  // namespace OHOS
260