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 "UTTest_discovery_manager.h"
17 
18 #include <iostream>
19 #include <string>
20 #include <unistd.h>
21 
22 #include "device_manager_service_listener.h"
23 #include "dm_anonymous.h"
24 #include "dm_constants.h"
25 #include "dm_log.h"
26 #include "ipc_server_listener.h"
27 #include "softbus_bus_center.h"
28 #include "softbus_error_code.h"
29 
30 namespace OHOS {
31 namespace DistributedHardware {
SetUp()32 void DiscoveryManagerTest::SetUp()
33 {
34 }
35 
TearDown()36 void DiscoveryManagerTest::TearDown()
37 {
38 }
39 
SetUpTestCase()40 void DiscoveryManagerTest::SetUpTestCase()
41 {
42 }
43 
TearDownTestCase()44 void DiscoveryManagerTest::TearDownTestCase()
45 {
46 }
47 
48 namespace {
49     std::shared_ptr<SoftbusListener> softbusListener = std::make_shared<SoftbusListener>();
50     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
51     std::shared_ptr<DiscoveryManager> manager = std::make_shared<DiscoveryManager>(softbusListener, listener);
52 
CheckSoftbusRes(int32_t ret)53 bool CheckSoftbusRes(int32_t ret)
54 {
55     return ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_NETWORK_NOT_INIT || ret == SOFTBUS_NETWORK_LOOPER_ERR;
56 }
57 
58 HWTEST_F(DiscoveryManagerTest, EnableDiscoveryListener_001, testing::ext::TestSize.Level0)
59 {
60     std::string pkgName;
61     std::map<std::string, std::string> discoverParam;
62     std::map<std::string, std::string> filterOptions;
63     int32_t ret = manager->EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
64     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
65 }
66 
67 HWTEST_F(DiscoveryManagerTest, EnableDiscoveryListener_002, testing::ext::TestSize.Level0)
68 {
69     std::string pkgName = "pkgName";
70     std::map<std::string, std::string> discoverParam;
71     discoverParam.insert(std::pair<std::string, std::string>("META_TYPE", "ohos.test"));
72     discoverParam.insert(std::pair<std::string, std::string>("SUBSCRIBE_ID", "ohos.test"));
73     std::map<std::string, std::string> filterOptions;
74     int32_t ret = manager->EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
75     EXPECT_EQ(true, CheckSoftbusRes(ret));
76 }
77 
78 HWTEST_F(DiscoveryManagerTest, EnableDiscoveryListener_003, testing::ext::TestSize.Level0)
79 {
80     std::string pkgName = "pkgName";
81     std::map<std::string, std::string> discoverParam;
82     std::map<std::string, std::string> filterOptions;
83     int32_t ret = manager->EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
84     EXPECT_EQ(true, CheckSoftbusRes(ret));
85 }
86 
87 HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_001, testing::ext::TestSize.Level0)
88 {
89     std::string pkgName;
90     std::map<std::string, std::string> extraParam;
91     int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
92     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
93 }
94 
95 HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_002, testing::ext::TestSize.Level0)
96 {
97     std::string pkgName = "pkgName";
98     std::map<std::string, std::string> extraParam;
99     extraParam.insert(std::pair<std::string, std::string>("META_TYPE", "ohos.test"));
100     extraParam.insert(std::pair<std::string, std::string>("SUBSCRIBE_ID", "ohos.test"));
101     int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
102     EXPECT_EQ(true, CheckSoftbusRes(ret));
103 }
104 
105 HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_003, testing::ext::TestSize.Level0)
106 {
107     std::string pkgName = "pkgName";
108     std::map<std::string, std::string> extraParam;
109     int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
110     EXPECT_EQ(true, CheckSoftbusRes(ret));
111 }
112 
113 HWTEST_F(DiscoveryManagerTest, StartDiscovering_001, testing::ext::TestSize.Level0)
114 {
115     std::string pkgName;
116     std::map<std::string, std::string> discoverParam;
117     std::map<std::string, std::string> filterOptions;
118     int32_t ret = manager->StartDiscovering(pkgName, discoverParam, filterOptions);
119     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
120 }
121 
122 HWTEST_F(DiscoveryManagerTest, StartDiscovering_002, testing::ext::TestSize.Level0)
123 {
124     std::string pkgName = "pkgName";
125     std::map<std::string, std::string> discoverParam;
126     discoverParam.insert(std::pair<std::string, std::string>("SUBSCRIBE_ID", "ohos.test"));
127     discoverParam.insert(std::pair<std::string, std::string>("DISC_MEDIUM", "ohos.test"));
128     discoverParam.insert(std::pair<std::string, std::string>("META_TYPE", "ohos.test"));
129     discoverParam.insert(std::pair<std::string, std::string>("FILTER_OPTIONS", "ohos.test"));
130     std::map<std::string, std::string> filterOptions;
131     int32_t ret = manager->StartDiscovering(pkgName, discoverParam, filterOptions);
132     EXPECT_EQ(true, CheckSoftbusRes(ret));
133 }
134 
135 HWTEST_F(DiscoveryManagerTest, StartDiscovering_003, testing::ext::TestSize.Level0)
136 {
137     std::string pkgName = "pkgName";
138     std::map<std::string, std::string> discoverParam;
139     std::map<std::string, std::string> filterOptions;
140     int32_t ret = manager->StartDiscovering(pkgName, discoverParam, filterOptions);
141     EXPECT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
142 }
143 
144 HWTEST_F(DiscoveryManagerTest, StartDiscovering4MineLibary_001, testing::ext::TestSize.Level0)
145 {
146     std::string pkgName = "pkgName";
147     DmSubscribeInfo dmSubInfo;
148     std::string searchJson = "searchJson";
149     int32_t ret = manager->StartDiscovering4MineLibary(pkgName, dmSubInfo, searchJson);
150     EXPECT_EQ(ret, ERR_DM_JSON_PARSE_STRING);
151 }
152 
153 HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_001, testing::ext::TestSize.Level0)
154 {
155     DmSubscribeInfo dmSubInfo;
156     std::string pkgName = "pkgNameTest01";
157     std::map<std::string, std::string> param;
158     param.insert(std::pair<std::string, std::string>("META_TYPE", std::to_string(MetaNodeType::PROXY_SHARE)));
159     int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
160     EXPECT_NE(ret, DM_OK);
161 }
162 
163 HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_002, testing::ext::TestSize.Level0)
164 {
165     DmSubscribeInfo dmSubInfo;
166     std::string pkgName = "pkgNameTest02";
167     std::map<std::string, std::string> param;
168     param.insert(std::pair<std::string, std::string>("META_TYPE", std::to_string(MetaNodeType::PROXY_WEAR)));
169     int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
170     EXPECT_NE(ret, DM_OK);
171 }
172 
173 HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_003, testing::ext::TestSize.Level0)
174 {
175     DmSubscribeInfo dmSubInfo;
176     std::string pkgName = "pkgNameTest03";
177     std::map<std::string, std::string> param;
178     param.insert(std::pair<std::string, std::string>("META_TYPE", std::to_string(MetaNodeType::PROXY_CASTPLUS)));
179     int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
180     EXPECT_NE(ret, DM_OK);
181 }
182 
183 HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_004, testing::ext::TestSize.Level0)
184 {
185     DmSubscribeInfo dmSubInfo;
186     std::string pkgName = "pkgNameTest04";
187     std::map<std::string, std::string> param;
188     int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
189     EXPECT_NE(ret, DM_OK);
190 }
191 
192 HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_001, testing::ext::TestSize.Level0)
193 {
194     DmSubscribeInfo dmSubInfo;
195     std::string pkgName = "pkgNameTest01";
196     std::map<std::string, std::string> param;
197     param.emplace("META_TYPE", "4");
198     int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
199     EXPECT_NE(ret, DM_OK);
200 }
201 
202 HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_002, testing::ext::TestSize.Level0)
203 {
204     DmSubscribeInfo dmSubInfo;
205     std::string pkgName = "pkgNameTest02";
206     std::map<std::string, std::string> param;
207     param.emplace("META_TYPE", "7");
208     int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
209     EXPECT_NE(ret, DM_OK);
210 }
211 
212 HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_003, testing::ext::TestSize.Level0)
213 {
214     DmSubscribeInfo dmSubInfo;
215     std::string pkgName = "pkgNameTest03";
216     std::map<std::string, std::string> param;
217     param.emplace("META_TYPE", "5");
218     int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
219     EXPECT_NE(ret, DM_OK);
220 }
221 
222 HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_004, testing::ext::TestSize.Level0)
223 {
224     DmSubscribeInfo dmSubInfo;
225     std::string pkgName = "pkgNameTest04";
226     std::map<std::string, std::string> param;
227     param.emplace("META_TYPE", "1234");
228     int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
229     EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
230 }
231 
232 HWTEST_F(DiscoveryManagerTest, StopDiscovering_001, testing::ext::TestSize.Level0)
233 {
234     std::string pkgName;
235     uint16_t subscribeId = 0;
236     int32_t ret = manager->StopDiscovering(pkgName, subscribeId);
237     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
238 }
239 
240 HWTEST_F(DiscoveryManagerTest, StopDiscovering_002, testing::ext::TestSize.Level0)
241 {
242     std::string pkgName = "pkgName";
243     uint16_t subscribeId = 0;
244     manager->pkgNameSet_.insert(pkgName);
245     DiscoveryContext context;
246     manager->discoveryContextMap_.emplace(pkgName, context);
247     int32_t ret = manager->StopDiscovering(pkgName, subscribeId);
248     EXPECT_EQ(true, CheckSoftbusRes(ret));
249 }
250 
251 HWTEST_F(DiscoveryManagerTest, OnDeviceFound_001, testing::ext::TestSize.Level0)
252 {
253     std::string pkgName = "pkgName";
254     DmDeviceInfo info;
255     bool isOnline = false;
256     manager->OnDeviceFound(pkgName, info, isOnline);
257     EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
258 }
259 
260 HWTEST_F(DiscoveryManagerTest, OnDeviceFound_002, testing::ext::TestSize.Level0)
261 {
262     std::string pkgName = "pkgName";
263     DmDeviceInfo info;
264     bool isOnline = true;
265     manager->OnDeviceFound(pkgName, info, isOnline);
266     EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
267 }
268 
269 HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_001, testing::ext::TestSize.Level0)
270 {
271     std::string pkgName;
272     int32_t subscribeId = 1;
273     int32_t result = 0;
274     manager->OnDiscoveringResult(pkgName, subscribeId, result);
275     EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
276 }
277 
278 HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_002, testing::ext::TestSize.Level0)
279 {
280     std::string pkgName = "pkgName";
281     int32_t subscribeId = 1;
282     int32_t result = 0;
283     manager->listener_ = nullptr;
284     manager->OnDiscoveringResult(pkgName, subscribeId, result);
285     EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
286 }
287 
288 HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_003, testing::ext::TestSize.Level0)
289 {
290     std::string pkgName = "pkgName";
291     int32_t subscribeId = 1;
292     int32_t result = 0;
293     manager->listener_ = std::make_shared<DeviceManagerServiceListener>();
294     manager->OnDiscoveringResult(pkgName, subscribeId, result);
295     EXPECT_NE(manager->discoveryContextMap_.empty(), true);
296 }
297 
298 HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_004, testing::ext::TestSize.Level0)
299 {
300     std::string pkgName = "pkgName";
301     int32_t subscribeId = 1;
302     int32_t result = 1;
303     manager->pkgNameSet_.insert(pkgName);
304     DiscoveryContext context;
305     manager->discoveryContextMap_.emplace(pkgName, context);
306     manager->listener_ = std::make_shared<DeviceManagerServiceListener>();
307     manager->OnDiscoveringResult(pkgName, subscribeId, result);
308     EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
309 }
310 
311 HWTEST_F(DiscoveryManagerTest, StartDiscoveryTimer_001, testing::ext::TestSize.Level0)
312 {
313     manager->timer_ = nullptr;
314     std::string pkgName = "timeTest";
315     manager->StartDiscoveryTimer(pkgName);
316     EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
317 }
318 
319 HWTEST_F(DiscoveryManagerTest, HandleDiscoveryQueue_001, testing::ext::TestSize.Level0)
320 {
321     std::string pkgName = "pkgName";
322     uint16_t subscribeId = 0;
323     std::map<std::string, std::string> filterOps;
324     filterOps.insert(std::pair<std::string, std::string>("FILTER_OPTIONS", pkgName));
325     int32_t ret = manager->HandleDiscoveryQueue(pkgName, subscribeId, filterOps);
326     EXPECT_NE(ret, DM_OK);
327 }
328 
329 HWTEST_F(DiscoveryManagerTest, HandleDiscoveryTimeout_001, testing::ext::TestSize.Level0)
330 {
331     std::string name = "nameTest01";
332     std::set<std::string> emptySet;
333     manager->pkgNameSet_ = emptySet;
334     manager->HandleDiscoveryTimeout(name);
335     EXPECT_EQ(manager->pkgNameSet_.empty(), true);
336 }
337 
338 HWTEST_F(DiscoveryManagerTest, HandleDiscoveryTimeout_002, testing::ext::TestSize.Level0)
339 {
340     std::string name = "nameTest02";
341     manager->pkgNameSet_.insert(name);
342     manager->discoveryContextMap_.clear();
343     manager->HandleDiscoveryTimeout(name);
344     EXPECT_EQ(manager->pkgNameSet_.empty(), false);
345 }
346 
347 HWTEST_F(DiscoveryManagerTest, HandleDiscoveryTimeout_003, testing::ext::TestSize.Level0)
348 {
349     manager->pkgNameSet_.clear();
350     std::string name = "nameTest03";
351     manager->pkgNameSet_.insert(name);
352     DiscoveryContext context;
353     manager->discoveryContextMap_.emplace(name, context);
354     manager->HandleDiscoveryTimeout(name);
355     EXPECT_NE(manager->pkgNameSet_.empty(), false);
356 }
357 
358 HWTEST_F(DiscoveryManagerTest, GetDeviceAclParam_001, testing::ext::TestSize.Level0)
359 {
360     std::string pkgName;
361     std::string deviceId;
362     bool isonline = true;
363     int32_t authForm = 0;
364     int32_t ret = manager->GetDeviceAclParam(pkgName, deviceId, isonline, authForm);
365     EXPECT_EQ(ret, DM_OK);
366 }
367 
368 HWTEST_F(DiscoveryManagerTest, GetCommonDependencyObj_001, testing::ext::TestSize.Level0)
369 {
370     auto ret = manager->GetCommonDependencyObj();
371     EXPECT_NE(ret, nullptr);
372 }
373 
374 HWTEST_F(DiscoveryManagerTest, IsCommonDependencyReady_001, testing::ext::TestSize.Level0)
375 {
376     manager->isSoLoaded_ = false;
377     bool ret = manager->IsCommonDependencyReady();
378     EXPECT_EQ(ret, true);
379 }
380 
381 HWTEST_F(DiscoveryManagerTest, CloseCommonDependencyObj_001, testing::ext::TestSize.Level0)
382 {
383     manager->isSoLoaded_ = false;
384     manager->dpConnector_ = nullptr;
385     manager->dpConnectorHandle_ = nullptr;
386     bool ret = manager->CloseCommonDependencyObj();
387     EXPECT_EQ(ret, true);
388 }
389 
390 HWTEST_F(DiscoveryManagerTest, CloseCommonDependencyObj_002, testing::ext::TestSize.Level0)
391 {
392     bool ret = manager->CloseCommonDependencyObj();
393     EXPECT_EQ(ret, true);
394 }
395 } // namespace
396 } // namespace DistributedHardware
397 } // namespace OHOS
398