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 #include "UTTest_mine_softbus_listener.h"
16 
17 #include <securec.h>
18 #include <unistd.h>
19 #include <cstdlib>
20 #include <thread>
21 
22 #include "dm_dialog_manager.h"
23 #include "dm_anonymous.h"
24 #include "dm_constants.h"
25 #include "dm_device_info.h"
26 #include "dm_log.h"
27 #include "parameter.h"
28 #include "nlohmann/json.hpp"
29 #include "system_ability_definition.h"
30 #include "softbus_error_code.h"
31 
32 namespace OHOS {
33 namespace DistributedHardware {
SetUp()34 void MineSoftbusListenerTest::SetUp()
35 {
36 }
TearDown()37 void MineSoftbusListenerTest::TearDown()
38 {
39 }
SetUpTestCase()40 void MineSoftbusListenerTest::SetUpTestCase()
41 {
42 }
TearDownTestCase()43 void MineSoftbusListenerTest::TearDownTestCase()
44 {
45 }
46 
47 namespace {
48 
CheckSoftbusRes(int32_t ret)49 bool CheckSoftbusRes(int32_t ret)
50 {
51     return ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_NETWORK_NOT_INIT || ret == SOFTBUS_NETWORK_LOOPER_ERR
52         || ret == SOFTBUS_IPC_ERR;
53 }
54 
55 HWTEST_F(MineSoftbusListenerTest, RefreshSoftbusLNN_001, testing::ext::TestSize.Level0)
56 {
57     string pkgName;
58     string searchJson;
59     DmSubscribeInfo dmSubscribeInfo;
60     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
61     int32_t ret = mineListener->RefreshSoftbusLNN(pkgName, searchJson, dmSubscribeInfo);
62     EXPECT_EQ(ret, ERR_DM_JSON_PARSE_STRING);
63 }
64 
65 HWTEST_F(MineSoftbusListenerTest, RefreshSoftbusLNN_002, testing::ext::TestSize.Level0)
66 {
67     nlohmann::json jsonObj;
68     jsonObj["findDeviceMode"] = 4;
69     string pkgName;
70     string searchJson = jsonObj.dump();
71     DmSubscribeInfo dmSubscribeInfo;
72     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
73     int32_t ret = mineListener->RefreshSoftbusLNN(pkgName, searchJson, dmSubscribeInfo);
74     EXPECT_EQ(ret, ERR_DM_SOFTBUS_SEND_BROADCAST);
75 }
76 
77 HWTEST_F(MineSoftbusListenerTest, StopRefreshSoftbusLNN_001, testing::ext::TestSize.Level0)
78 {
79     uint16_t subscribeId = 1;
80     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
81     int32_t ret = mineListener->StopRefreshSoftbusLNN(subscribeId);
82     EXPECT_TRUE(CheckSoftbusRes(ret));
83 }
84 
85 HWTEST_F(MineSoftbusListenerTest, OnPublishResult_001, testing::ext::TestSize.Level0)
86 {
87     int publishId = 1;
88     PublishResult reason = PublishResult::PUBLISH_LNN_SUCCESS;
89     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
90     mineListener->OnPublishResult(publishId, reason);
91     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
92 }
93 
94 HWTEST_F(MineSoftbusListenerTest, OnPublishResult_002, testing::ext::TestSize.Level0)
95 {
96     int publishId = 1;
97     PublishResult reason = static_cast<PublishResult>(12);
98     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
99     mineListener->OnPublishResult(publishId, reason);
100     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
101 }
102 
103 HWTEST_F(MineSoftbusListenerTest, OnPublishDeviceFound_001, testing::ext::TestSize.Level0)
104 {
105     DeviceInfo *deviceInfo = nullptr;
106     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
107     mineListener->OnPublishDeviceFound(deviceInfo);
108     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
109 }
110 
111 HWTEST_F(MineSoftbusListenerTest, OnPublishDeviceFound_002, testing::ext::TestSize.Level0)
112 {
113     DeviceInfo deviceInfo = {
114         .devId = "123456",
115         .devType = (DeviceType)1,
116         .devName = "11111"
117     };
118     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
119     mineListener->OnPublishDeviceFound(&deviceInfo);
120     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
121 }
122 
123 HWTEST_F(MineSoftbusListenerTest, OnRePublish_001, testing::ext::TestSize.Level0)
124 {
125     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
126     mineListener->OnRePublish();
127     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
128 }
129 
130 HWTEST_F(MineSoftbusListenerTest, ParseSearchJson_001, testing::ext::TestSize.Level0)
131 {
132     string pkgName;
133     string searchJson;
134     size_t outLen = 0;
135     char output[DISC_MAX_CUST_DATA_LEN] = {0};
136     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
137     int32_t ret = mineListener->ParseSearchJson(pkgName, searchJson, output, &outLen);
138     EXPECT_EQ(ret, ERR_DM_INVALID_JSON_STRING);
139 }
140 
141 HWTEST_F(MineSoftbusListenerTest, ParseSearchJson_002, testing::ext::TestSize.Level0)
142 {
143     size_t outLen = 0;
144     char output[DISC_MAX_CUST_DATA_LEN] = {0};
145     nlohmann::json jsonObj;
146     jsonObj["findDeviceMode"] = static_cast<char>(1);
147     string pkgName;
148     string searchJson = jsonObj.dump();
149     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
150     int32_t ret = mineListener->ParseSearchJson(pkgName, searchJson, output, &outLen);
151     EXPECT_EQ(ret, ERR_DM_FAILED);
152 }
153 
154 HWTEST_F(MineSoftbusListenerTest, ParseSearchJson_003, testing::ext::TestSize.Level0)
155 {
156     size_t outLen = 0;
157     char output[DISC_MAX_CUST_DATA_LEN] = {0};
158     nlohmann::json jsonObj;
159     jsonObj["findDeviceMode"] = static_cast<char>(2);
160     string pkgName;
161     string searchJson = jsonObj.dump();
162     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
163     int32_t ret = mineListener->ParseSearchJson(pkgName, searchJson, output, &outLen);
164     EXPECT_EQ(ret, ERR_DM_FAILED);
165 }
166 
167 HWTEST_F(MineSoftbusListenerTest, ParseSearchJson_004, testing::ext::TestSize.Level0)
168 {
169     size_t outLen = 0;
170     char output[DISC_MAX_CUST_DATA_LEN] = {0};
171     nlohmann::json jsonObj;
172     jsonObj["findDeviceMode"] = static_cast<char>(3);
173     string pkgName;
174     string searchJson = jsonObj.dump();
175     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
176     int32_t ret = mineListener->ParseSearchJson(pkgName, searchJson, output, &outLen);
177     EXPECT_EQ(ret, ERR_DM_FAILED);
178 }
179 
180 HWTEST_F(MineSoftbusListenerTest, ParseSearchJson_005, testing::ext::TestSize.Level0)
181 {
182     size_t outLen = 0;
183     char output[DISC_MAX_CUST_DATA_LEN] = {0};
184     nlohmann::json jsonObj;
185     jsonObj["findDeviceMode"] = static_cast<char>(4);
186     string pkgName;
187     string searchJson = jsonObj.dump();
188     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
189     int32_t ret = mineListener->ParseSearchJson(pkgName, searchJson, output, &outLen);
190     EXPECT_EQ(ret, DM_OK);
191 }
192 
193 HWTEST_F(MineSoftbusListenerTest, ParseSearchAllDevice_001, testing::ext::TestSize.Level0)
194 {
195     size_t outLen = 0;
196     char output[DISC_MAX_CUST_DATA_LEN] = {0};
197     nlohmann::json jsonObj;
198     jsonObj["findDeviceMode"] = static_cast<char>(2);
199     string pkgName;
200     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
201     int32_t ret = mineListener->ParseSearchAllDevice(jsonObj, pkgName, output, &outLen);
202     EXPECT_EQ(ret, ERR_DM_FAILED);
203 }
204 
205 HWTEST_F(MineSoftbusListenerTest, ParseSearchAllDevice_002, testing::ext::TestSize.Level0)
206 {
207     size_t outLen = 0;
208     char output[DISC_MAX_CUST_DATA_LEN] = {0};
209     nlohmann::json jsonObj;
210     jsonObj["findDeviceMode"] = static_cast<char>(2);
211     jsonObj["tructOptions"] = true;
212     string pkgName = "1234656";
213     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
214     int32_t ret = mineListener->ParseSearchAllDevice(jsonObj, pkgName, output, &outLen);
215     EXPECT_EQ(ret, DM_OK);
216 }
217 
218 HWTEST_F(MineSoftbusListenerTest, ParseSearchScopeDevice_001, testing::ext::TestSize.Level0)
219 {
220     size_t outLen = 0;
221     char output[DISC_MAX_CUST_DATA_LEN] = {0};
222     nlohmann::json jsonObj;
223     jsonObj["findDeviceMode"] = static_cast<char>(2);
224     string pkgName;
225     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
226     int32_t ret = mineListener->ParseSearchScopeDevice(jsonObj, pkgName, output, &outLen);
227     EXPECT_EQ(ret, ERR_DM_FAILED);
228 }
229 
230 HWTEST_F(MineSoftbusListenerTest, ParseSearchScopeDevice_002, testing::ext::TestSize.Level0)
231 {
232     size_t outLen = 0;
233     char output[DISC_MAX_CUST_DATA_LEN] = {0};
234     nlohmann::json jsonObj;
235     jsonObj["findDeviceMode"] = static_cast<char>(2);
236     jsonObj["tructOptions"] = true;
237     string pkgName = "1231301230213";
238     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
239     int32_t ret = mineListener->ParseSearchScopeDevice(jsonObj, pkgName, output, &outLen);
240     EXPECT_EQ(ret, ERR_DM_FAILED);
241 }
242 
243 HWTEST_F(MineSoftbusListenerTest, ParseSearchScopeDevice_003, testing::ext::TestSize.Level0)
244 {
245     size_t outLen = 0;
246     char output[DISC_MAX_CUST_DATA_LEN] = {0};
247     nlohmann::json jsonObj;
248     jsonObj["findDeviceMode"] = static_cast<char>(2);
249     jsonObj["tructOptions"] = true;
250     jsonObj["filterOptions"] = 1;
251     string pkgName = "1231301230213";
252     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
253     int32_t ret = mineListener->ParseSearchScopeDevice(jsonObj, pkgName, output, &outLen);
254     EXPECT_EQ(ret, ERR_DM_FAILED);
255 }
256 
257 HWTEST_F(MineSoftbusListenerTest, ParseSearchScopeDevice_004, testing::ext::TestSize.Level0)
258 {
259     size_t outLen = 0;
260     char output[DISC_MAX_CUST_DATA_LEN] = {0};
261     std::vector<int> info;
262     nlohmann::json jsonObj;
263     jsonObj["findDeviceMode"] = static_cast<char>(2);
264     jsonObj["tructOptions"] = true;
265     jsonObj["filterOptions"] = info;
266     string pkgName = "1231301230213";
267     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
268     int32_t ret = mineListener->ParseSearchScopeDevice(jsonObj, pkgName, output, &outLen);
269     EXPECT_EQ(ret, ERR_DM_INVALID_JSON_STRING);
270 }
271 
272 HWTEST_F(MineSoftbusListenerTest, ParseSearchScopeDevice_005, testing::ext::TestSize.Level0)
273 {
274     size_t outLen = 0;
275     char output[DISC_MAX_CUST_DATA_LEN] = {0};
276     int parameter = 6;
277     std::vector<int> info;
278     info.push_back(parameter);
279     nlohmann::json jsonObj;
280     jsonObj["findDeviceMode"] = static_cast<char>(2);
281     jsonObj["tructOptions"] = true;
282     jsonObj["filterOptions"] = info;
283     string pkgName = "1231301230213";
284     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
285     int32_t ret = mineListener->ParseSearchScopeDevice(jsonObj, pkgName, output, &outLen);
286     EXPECT_EQ(ret, ERR_DM_FAILED);
287 }
288 
289 HWTEST_F(MineSoftbusListenerTest, ParseSearchVertexDevice_001, testing::ext::TestSize.Level0)
290 {
291     size_t outLen = 0;
292     char output[DISC_MAX_CUST_DATA_LEN] = {0};
293     nlohmann::json jsonObj;
294     jsonObj["findDeviceMode"] = static_cast<char>(2);
295     string pkgName;
296     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
297     int32_t ret = mineListener->ParseSearchVertexDevice(jsonObj, pkgName, output, &outLen);
298     EXPECT_EQ(ret, ERR_DM_FAILED);
299 }
300 
301 HWTEST_F(MineSoftbusListenerTest, ParseSearchVertexDevice_002, testing::ext::TestSize.Level0)
302 {
303     size_t outLen = 0;
304     char output[DISC_MAX_CUST_DATA_LEN] = {0};
305     nlohmann::json jsonObj;
306     jsonObj["findDeviceMode"] = static_cast<char>(2);
307     jsonObj["tructOptions"] = true;
308     string pkgName = "1231301230213";
309     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
310     int32_t ret = mineListener->ParseSearchVertexDevice(jsonObj, pkgName, output, &outLen);
311     EXPECT_EQ(ret, ERR_DM_FAILED);
312 }
313 
314 HWTEST_F(MineSoftbusListenerTest, ParseSearchVertexDevice_003, testing::ext::TestSize.Level0)
315 {
316     size_t outLen = 0;
317     char output[DISC_MAX_CUST_DATA_LEN] = {0};
318     nlohmann::json jsonObj;
319     jsonObj["findDeviceMode"] = static_cast<char>(2);
320     jsonObj["tructOptions"] = true;
321     jsonObj["filterOptions"] = 1;
322     string pkgName = "1231301230213";
323     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
324     int32_t ret = mineListener->ParseSearchVertexDevice(jsonObj, pkgName, output, &outLen);
325     EXPECT_EQ(ret, ERR_DM_FAILED);
326 }
327 
328 HWTEST_F(MineSoftbusListenerTest, ParseSearchVertexDevice_004, testing::ext::TestSize.Level0)
329 {
330     size_t outLen = 0;
331     char output[DISC_MAX_CUST_DATA_LEN] = {0};
332     std::vector<int> info;
333     nlohmann::json jsonObj;
334     jsonObj["findDeviceMode"] = static_cast<char>(2);
335     jsonObj["tructOptions"] = true;
336     jsonObj["filterOptions"] = info;
337     string pkgName = "1231301230213";
338     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
339     int32_t ret = mineListener->ParseSearchVertexDevice(jsonObj, pkgName, output, &outLen);
340     EXPECT_EQ(ret, ERR_DM_FAILED);
341 }
342 
343 HWTEST_F(MineSoftbusListenerTest, ParseSearchVertexDevice_005, testing::ext::TestSize.Level0)
344 {
345     size_t outLen = 0;
346     char output[DISC_MAX_CUST_DATA_LEN] = {0};
347     int parameter = 6;
348     std::vector<int> info;
349     info.push_back(parameter);
350     nlohmann::json jsonObj;
351     jsonObj["findDeviceMode"] = static_cast<char>(2);
352     jsonObj["tructOptions"] = true;
353     jsonObj["filterOptions"] = info;
354     string pkgName = "1231301230213";
355     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
356     int32_t ret = mineListener->ParseSearchVertexDevice(jsonObj, pkgName, output, &outLen);
357     EXPECT_EQ(ret, DM_OK);
358 }
359 
360 HWTEST_F(MineSoftbusListenerTest, SetBroadcastHead_001, testing::ext::TestSize.Level0)
361 {
362     nlohmann::json jsonObj;
363     string pkgName;
364     BroadcastHead broadcastHead;
365     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
366     int32_t ret = mineListener->SetBroadcastHead(jsonObj, pkgName, broadcastHead);
367     EXPECT_EQ(ret, ERR_DM_FAILED);
368 }
369 
370 HWTEST_F(MineSoftbusListenerTest, SetBroadcastHead_002, testing::ext::TestSize.Level0)
371 {
372     BroadcastHead broadcastHead;
373     nlohmann::json jsonObj;
374     jsonObj["findDeviceMode"] = static_cast<char>(2);
375     jsonObj["tructOptions"] = true;
376     string pkgName;
377     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
378     int32_t ret = mineListener->SetBroadcastHead(jsonObj, pkgName, broadcastHead);
379     EXPECT_EQ(ret, ERR_DM_FAILED);
380 }
381 
382 HWTEST_F(MineSoftbusListenerTest, SetBroadcastHead_003, testing::ext::TestSize.Level0)
383 {
384     BroadcastHead broadcastHead;
385     nlohmann::json jsonObj;
386     jsonObj["findDeviceMode"] = static_cast<char>(2);
387     jsonObj["tructOptions"] = true;
388     string pkgName = "1231301230213";
389     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
390     int32_t ret = mineListener->SetBroadcastHead(jsonObj, pkgName, broadcastHead);
391     EXPECT_EQ(ret, DM_OK);
392 }
393 
394 HWTEST_F(MineSoftbusListenerTest, AddHeadToBroadcast_001, testing::ext::TestSize.Level0)
395 {
396     BroadcastHead broadcastHead = {
397         .version = '1',
398         .headDataLen = '2',
399         .tlvDataLen = '3',
400         .pkgNameHash = "name",
401         .findMode = '5',
402         .trustFilter = '6',
403     };
404     char output[DISC_MAX_CUST_DATA_LEN] = {0};
405     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
406     mineListener->AddHeadToBroadcast(broadcastHead, output);
407     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
408 }
409 
410 HWTEST_F(MineSoftbusListenerTest, ParseScopeDeviceJsonArray_001, testing::ext::TestSize.Level0)
411 {
412     vector<ScopeOptionInfo> optionInfo;
413     size_t outLen = 0;
414     char output[DISC_MAX_CUST_DATA_LEN] = {0};
415     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
416     int32_t ret = mineListener->ParseScopeDeviceJsonArray(optionInfo, output, &outLen);
417     EXPECT_EQ(ret, DM_OK);
418 }
419 
420 HWTEST_F(MineSoftbusListenerTest, ParseScopeDeviceJsonArray_002, testing::ext::TestSize.Level0)
421 {
422     ScopeOptionInfo info = {
423         .deviceAlias = "deviceAlias",
424         .startNumber = 0,
425         .endNumber = 1,
426     };
427     vector<ScopeOptionInfo> optionInfo;
428     optionInfo.push_back(info);
429     size_t outLen = 0;
430     char output[DISC_MAX_CUST_DATA_LEN] = {0};
431     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
432     int32_t ret = mineListener->ParseScopeDeviceJsonArray(optionInfo, output, &outLen);
433     EXPECT_EQ(ret, DM_OK);
434 }
435 
436 HWTEST_F(MineSoftbusListenerTest, ParseVertexDeviceJsonArray_001, testing::ext::TestSize.Level0)
437 {
438     vector<VertexOptionInfo> optionInfo;
439     size_t outLen = 0;
440     char output[DISC_MAX_CUST_DATA_LEN] = {0};
441     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
442     int32_t ret = mineListener->ParseVertexDeviceJsonArray(optionInfo, output, &outLen);
443     EXPECT_EQ(ret, DM_OK);
444 }
445 
446 HWTEST_F(MineSoftbusListenerTest, ParseVertexDeviceJsonArray_002, testing::ext::TestSize.Level0)
447 {
448     VertexOptionInfo info = {
449         .type = "",
450         .value = "1",
451     };
452     vector<VertexOptionInfo> optionInfo;
453     optionInfo.push_back(info);
454     size_t outLen = 0;
455     char output[DISC_MAX_CUST_DATA_LEN] = {0};
456     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
457     int32_t ret = mineListener->ParseVertexDeviceJsonArray(optionInfo, output, &outLen);
458     EXPECT_EQ(ret, DM_OK);
459 }
460 
461 HWTEST_F(MineSoftbusListenerTest, ParseVertexDeviceJsonArray_003, testing::ext::TestSize.Level0)
462 {
463     VertexOptionInfo info = {
464         .type = "1",
465         .value = "",
466     };
467     vector<VertexOptionInfo> optionInfo;
468     optionInfo.push_back(info);
469     size_t outLen = 0;
470     char output[DISC_MAX_CUST_DATA_LEN] = {0};
471     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
472     int32_t ret = mineListener->ParseVertexDeviceJsonArray(optionInfo, output, &outLen);
473     EXPECT_EQ(ret, DM_OK);
474 }
475 
476 HWTEST_F(MineSoftbusListenerTest, ParseVertexDeviceJsonArray_004, testing::ext::TestSize.Level0)
477 {
478     VertexOptionInfo info = {
479         .type = "1",
480         .value = "1",
481     };
482     vector<VertexOptionInfo> optionInfo;
483     optionInfo.push_back(info);
484     size_t outLen = 0;
485     char output[DISC_MAX_CUST_DATA_LEN] = {0};
486     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
487     int32_t ret = mineListener->ParseVertexDeviceJsonArray(optionInfo, output, &outLen);
488     EXPECT_EQ(ret, ERR_DM_FAILED);
489 }
490 
491 HWTEST_F(MineSoftbusListenerTest, ParseVertexDeviceJsonArray_005, testing::ext::TestSize.Level0)
492 {
493     VertexOptionInfo info = {
494         .type = "deviceUdid",
495         .value = "112341234",
496     };
497     vector<VertexOptionInfo> optionInfo;
498     optionInfo.push_back(info);
499     size_t outLen = 0;
500     char output[DISC_MAX_CUST_DATA_LEN] = {0};
501     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
502     int32_t ret = mineListener->ParseVertexDeviceJsonArray(optionInfo, output, &outLen);
503     EXPECT_EQ(ret, DM_OK);
504 }
505 
506 HWTEST_F(MineSoftbusListenerTest, ParseVertexDeviceJsonArray_006, testing::ext::TestSize.Level0)
507 {
508     VertexOptionInfo info = {
509         .type = "deviceType",
510         .value = "112341234",
511     };
512     vector<VertexOptionInfo> optionInfo;
513     optionInfo.push_back(info);
514     size_t outLen = 0;
515     char output[DISC_MAX_CUST_DATA_LEN] = {0};
516     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
517     int32_t ret = mineListener->ParseVertexDeviceJsonArray(optionInfo, output, &outLen);
518     EXPECT_EQ(ret, DM_OK);
519 }
520 
521 HWTEST_F(MineSoftbusListenerTest, ParseVertexDeviceJsonArray_007, testing::ext::TestSize.Level0)
522 {
523     VertexOptionInfo info = {
524         .type = "deviceSn",
525         .value = "112341234",
526     };
527     vector<VertexOptionInfo> optionInfo;
528     optionInfo.push_back(info);
529     size_t outLen = 0;
530     char output[DISC_MAX_CUST_DATA_LEN] = {0};
531     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
532     int32_t ret = mineListener->ParseVertexDeviceJsonArray(optionInfo, output, &outLen);
533     EXPECT_EQ(ret, DM_OK);
534 }
535 
536 HWTEST_F(MineSoftbusListenerTest, GetSha256Hash_001, testing::ext::TestSize.Level0)
537 {
538     char *data = nullptr;
539     size_t outLen = 1024;
540     char output[DISC_MAX_CUST_DATA_LEN] = {0};
541     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
542     int32_t ret = mineListener->GetSha256Hash(data, outLen, output);
543     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
544 }
545 
546 HWTEST_F(MineSoftbusListenerTest, GetSha256Hash_002, testing::ext::TestSize.Level0)
547 {
548     std::string data = "data";
549     size_t outLen = 1024;
550     char *output = nullptr;
551     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
552     int32_t ret = mineListener->GetSha256Hash(data.c_str(), outLen, output);
553     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
554 }
555 
556 HWTEST_F(MineSoftbusListenerTest, GetSha256Hash_003, testing::ext::TestSize.Level0)
557 {
558     std::string data = "data";
559     size_t outLen = 0;
560     char output[DISC_MAX_CUST_DATA_LEN] = {0};
561     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
562     int32_t ret = mineListener->GetSha256Hash(data.c_str(), outLen, output);
563     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
564 }
565 
566 HWTEST_F(MineSoftbusListenerTest, GetSha256Hash_004, testing::ext::TestSize.Level0)
567 {
568     std::string data = "data";
569     size_t outLen = 1024;
570     char output[DISC_MAX_CUST_DATA_LEN] = {0};
571     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
572     int32_t ret = mineListener->GetSha256Hash(data.c_str(), outLen, output);
573     EXPECT_EQ(ret, DM_OK);
574 }
575 
576 HWTEST_F(MineSoftbusListenerTest, SetBroadcastTrustOptions_001, testing::ext::TestSize.Level0)
577 {
578     BroadcastHead broadcastHead;
579     nlohmann::json jsonObj;
580     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
581     int32_t ret = mineListener->SetBroadcastTrustOptions(jsonObj, broadcastHead);
582     EXPECT_EQ(ret, DM_OK);
583 }
584 
585 HWTEST_F(MineSoftbusListenerTest, SetBroadcastTrustOptions_002, testing::ext::TestSize.Level0)
586 {
587     BroadcastHead broadcastHead;
588     nlohmann::json jsonObj;
589     jsonObj["tructOptions"] = "tructOptions";
590     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
591     int32_t ret = mineListener->SetBroadcastTrustOptions(jsonObj, broadcastHead);
592     EXPECT_EQ(ret, ERR_DM_FAILED);
593 }
594 
595 HWTEST_F(MineSoftbusListenerTest, SetBroadcastTrustOptions_003, testing::ext::TestSize.Level0)
596 {
597     BroadcastHead broadcastHead;
598     nlohmann::json jsonObj;
599     jsonObj["tructOptions"] = true;
600     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
601     int32_t ret = mineListener->SetBroadcastTrustOptions(jsonObj, broadcastHead);
602     EXPECT_EQ(ret, DM_OK);
603 }
604 
605 HWTEST_F(MineSoftbusListenerTest, SetBroadcastTrustOptions_004, testing::ext::TestSize.Level0)
606 {
607     BroadcastHead broadcastHead;
608     nlohmann::json jsonObj;
609     jsonObj["tructOptions"] = false;
610     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
611     int32_t ret = mineListener->SetBroadcastTrustOptions(jsonObj, broadcastHead);
612     EXPECT_EQ(ret, DM_OK);
613 }
614 
615 HWTEST_F(MineSoftbusListenerTest, SetBroadcastPkgname_001, testing::ext::TestSize.Level0)
616 {
617     string pkgName;
618     BroadcastHead broadcastHead;
619     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
620     int32_t ret = mineListener->SetBroadcastPkgname(pkgName, broadcastHead);
621     EXPECT_EQ(ret, ERR_DM_FAILED);
622 }
623 
624 HWTEST_F(MineSoftbusListenerTest, SetBroadcastPkgname_002, testing::ext::TestSize.Level0)
625 {
626     string pkgName = "2134165415";
627     BroadcastHead broadcastHead;
628     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
629     int32_t ret = mineListener->SetBroadcastPkgname(pkgName, broadcastHead);
630     EXPECT_EQ(ret, DM_OK);
631 }
632 
633 HWTEST_F(MineSoftbusListenerTest, SetSubscribeInfo_001, testing::ext::TestSize.Level0)
634 {
635     SubscribeInfo subscribeInfo;
636     DmSubscribeInfo dmSubscribeInfo;
637     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
638     mineListener->SetSubscribeInfo(dmSubscribeInfo, subscribeInfo);
639     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
640 }
641 
642 HWTEST_F(MineSoftbusListenerTest, SendBroadcastInfo_001, testing::ext::TestSize.Level0)
643 {
644     string pkgName;
645     SubscribeInfo subscribeInfo;
646     char *output = nullptr;
647     size_t outputLen = 0;
648     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
649     int32_t ret = mineListener->SendBroadcastInfo(pkgName, subscribeInfo, output, outputLen);
650     EXPECT_EQ(ret, ERR_DM_FAILED);
651 }
652 
653 HWTEST_F(MineSoftbusListenerTest, DmBase64Encode_001, testing::ext::TestSize.Level0)
654 {
655     char *output = nullptr;
656     size_t outputLen = 1024;
657     char input[DISC_MAX_CUST_DATA_LEN] = {0};
658     size_t inputLen = 1024;
659     size_t base64OutLen = 0;
660     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
661     int32_t ret = mineListener->DmBase64Encode(output, outputLen, input, inputLen, base64OutLen);
662     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
663 }
664 
665 HWTEST_F(MineSoftbusListenerTest, DmBase64Encode_002, testing::ext::TestSize.Level0)
666 {
667     char output[DISC_MAX_CUST_DATA_LEN] = {0};
668     size_t outputLen = 1024;
669     char *input = nullptr;
670     size_t inputLen = 1024;
671     size_t base64OutLen = 0;
672     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
673     int32_t ret = mineListener->DmBase64Encode(output, outputLen, input, inputLen, base64OutLen);
674     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
675 }
676 
677 HWTEST_F(MineSoftbusListenerTest, DmBase64Encode_003, testing::ext::TestSize.Level0)
678 {
679     char output[DISC_MAX_CUST_DATA_LEN] = {0};
680     size_t outputLen = 0;
681     std::string input = "input";
682     size_t inputLen = 1024;
683     size_t base64OutLen = 0;
684     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
685     int32_t ret = mineListener->DmBase64Encode(output, outputLen, input.c_str(), inputLen, base64OutLen);
686     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
687 }
688 
689 HWTEST_F(MineSoftbusListenerTest, DmBase64Encode_004, testing::ext::TestSize.Level0)
690 {
691     char output[DISC_MAX_CUST_DATA_LEN] = {0};
692     size_t outputLen = 1024;
693     std::string input = "input";
694     size_t inputLen = 0;
695     size_t base64OutLen = 0;
696     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
697     int32_t ret = mineListener->DmBase64Encode(output, outputLen, input.c_str(), inputLen, base64OutLen);
698     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
699 }
700 
701 HWTEST_F(MineSoftbusListenerTest, DmBase64Decode_001, testing::ext::TestSize.Level0)
702 {
703     char *output = nullptr;
704     size_t outputLen = 1024;
705     char input[DISC_MAX_CUST_DATA_LEN] = {0};
706     size_t inputLen = 1024;
707     size_t base64OutLen = 0;
708     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
709     int32_t ret = mineListener->DmBase64Decode(output, outputLen, input, inputLen, base64OutLen);
710     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
711 }
712 
713 HWTEST_F(MineSoftbusListenerTest, DmBase64Decode_002, testing::ext::TestSize.Level0)
714 {
715     char output[DISC_MAX_CUST_DATA_LEN] = {0};
716     size_t outputLen = 1024;
717     char *input = nullptr;
718     size_t inputLen = 1024;
719     size_t base64OutLen = 0;
720     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
721     int32_t ret = mineListener->DmBase64Decode(output, outputLen, input, inputLen, base64OutLen);
722     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
723 }
724 
725 HWTEST_F(MineSoftbusListenerTest, DmBase64Decode_003, testing::ext::TestSize.Level0)
726 {
727     char output[DISC_MAX_CUST_DATA_LEN] = {0};
728     size_t outputLen = 0;
729     std::string input = "input";
730     size_t inputLen = 1024;
731     size_t base64OutLen = 0;
732     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
733     int32_t ret = mineListener->DmBase64Decode(output, outputLen, input.c_str(), inputLen, base64OutLen);
734     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
735 }
736 
737 HWTEST_F(MineSoftbusListenerTest, DmBase64Decode_004, testing::ext::TestSize.Level0)
738 {
739     char output[DISC_MAX_CUST_DATA_LEN] = {0};
740     size_t outputLen = 1024;
741     std::string input = "input";
742     size_t inputLen = 0;
743     size_t base64OutLen = 0;
744     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
745     int32_t ret = mineListener->DmBase64Decode(output, outputLen, input.c_str(), inputLen, base64OutLen);
746     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
747 }
748 
749 HWTEST_F(MineSoftbusListenerTest, DmBase64Decode_005, testing::ext::TestSize.Level0)
750 {
751     char output[DISC_MAX_CUST_DATA_LEN] = {0};
752     size_t outputLen = 1024;
753     std::string input = "input";
754     size_t inputLen = 1024;
755     size_t base64OutLen = 0;
756     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
757     int32_t ret = mineListener->DmBase64Decode(output, outputLen, input.c_str(), inputLen, base64OutLen);
758     EXPECT_EQ(ret, ERR_DM_FAILED);
759 }
760 
761 HWTEST_F(MineSoftbusListenerTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
762 {
763     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
764     int32_t ret = mineListener->PublishDeviceDiscovery();
765     EXPECT_TRUE(CheckSoftbusRes(ret));
766 }
767 
768 HWTEST_F(MineSoftbusListenerTest, MatchSearchDealTask_001, testing::ext::TestSize.Level0)
769 {
770     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
771     mineListener->MatchSearchDealTask();
772     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
773 }
774 
775 HWTEST_F(MineSoftbusListenerTest, ParseBroadcastInfo_001, testing::ext::TestSize.Level0)
776 {
777     DeviceInfo deviceInfo;
778     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
779     int32_t ret = mineListener->ParseBroadcastInfo(deviceInfo);
780     EXPECT_EQ(ret, ERR_DM_FAILED);
781 }
782 
783 HWTEST_F(MineSoftbusListenerTest, ParseBroadcastInfo_002, testing::ext::TestSize.Level0)
784 {
785     DeviceInfo deviceInfo = {
786         .devId = "123456",
787         .devType = (DeviceType)1,
788         .devName = "com.ohos.helloworld"
789     };
790     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
791     int32_t ret = mineListener->ParseBroadcastInfo(deviceInfo);
792     EXPECT_EQ(ret, ERR_DM_FAILED);
793 }
794 
795 HWTEST_F(MineSoftbusListenerTest, GetBroadcastData_001, testing::ext::TestSize.Level0)
796 {
797     DeviceInfo deviceInfo = {
798         .devId = "123456",
799         .devType = (DeviceType)1,
800         .devName = "com.ohos.helloworld"
801     };
802     char output[DISC_MAX_CUST_DATA_LEN] = {0};
803     size_t outputLen = 1024;
804     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
805     bool ret = mineListener->GetBroadcastData(deviceInfo, output, outputLen);
806     EXPECT_EQ(ret, true);
807 }
808 
809 HWTEST_F(MineSoftbusListenerTest, MatchSearchAllDevice_001, testing::ext::TestSize.Level0)
810 {
811     DeviceInfo deviceInfo = {
812         .devId = "123456",
813         .devType = (DeviceType)1,
814         .devName = "com.ohos.helloworld"
815     };
816     BroadcastHead broadcastHead;
817     broadcastHead.trustFilter = 0;
818     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
819     auto ret = mineListener->MatchSearchAllDevice(deviceInfo, broadcastHead);
820     EXPECT_EQ(ret, BUSINESS_EXACT_MATCH);
821 }
822 
823 HWTEST_F(MineSoftbusListenerTest, MatchSearchAllDevice_002, testing::ext::TestSize.Level0)
824 {
825     DeviceInfo deviceInfo = {
826         .devId = "123456",
827         .devType = (DeviceType)1,
828         .devName = "com.ohos.helloworld"
829     };
830     BroadcastHead broadcastHead;
831     deviceInfo.isOnline = true;
832     broadcastHead.trustFilter = static_cast<char>(3);
833     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
834     auto ret = mineListener->MatchSearchAllDevice(deviceInfo, broadcastHead);
835     EXPECT_EQ(ret, BUSINESS_EXACT_MATCH);
836 }
837 
838 HWTEST_F(MineSoftbusListenerTest, MatchSearchAllDevice_003, testing::ext::TestSize.Level0)
839 {
840     DeviceInfo deviceInfo = {
841         .devId = "123456",
842         .devType = (DeviceType)1,
843         .devName = "com.ohos.helloworld"
844     };
845     BroadcastHead broadcastHead;
846     deviceInfo.isOnline = true;
847     broadcastHead.trustFilter = static_cast<char>(2);
848     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
849     auto ret = mineListener->MatchSearchAllDevice(deviceInfo, broadcastHead);
850     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
851 }
852 
853 HWTEST_F(MineSoftbusListenerTest, MatchSearchAllDevice_004, testing::ext::TestSize.Level0)
854 {
855     DeviceInfo deviceInfo = {
856         .devId = "123456",
857         .devType = (DeviceType)1,
858         .devName = "com.ohos.helloworld"
859     };
860     BroadcastHead broadcastHead;
861     broadcastHead.trustFilter = 1;
862     deviceInfo.isOnline = false;
863     broadcastHead.trustFilter = static_cast<char>(3);
864     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
865     auto ret = mineListener->MatchSearchAllDevice(deviceInfo, broadcastHead);
866     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
867 }
868 
869 HWTEST_F(MineSoftbusListenerTest, MatchSearchAllDevice_005, testing::ext::TestSize.Level0)
870 {
871     DeviceInfo deviceInfo = {
872         .devId = "123456",
873         .devType = (DeviceType)1,
874         .devName = "com.ohos.helloworld"
875     };
876     BroadcastHead broadcastHead;
877     broadcastHead.trustFilter = 1;
878     deviceInfo.isOnline = false;
879     broadcastHead.trustFilter = 7;
880     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
881     auto ret = mineListener->MatchSearchAllDevice(deviceInfo, broadcastHead);
882     EXPECT_EQ(ret, BUSINESS_EXACT_MATCH);
883 }
884 
885 HWTEST_F(MineSoftbusListenerTest, GetScopeDevicePolicyInfo_001, testing::ext::TestSize.Level0)
886 {
887     DevicePolicyInfo devicePolicyInfo;
888     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
889     mineListener->GetScopeDevicePolicyInfo(devicePolicyInfo);
890     EXPECT_NE(mineListener->PublishDeviceDiscovery(), DM_OK);
891 }
892 
893 HWTEST_F(MineSoftbusListenerTest, MatchSearchScopeDevice_001, testing::ext::TestSize.Level0)
894 {
895     DeviceInfo deviceInfo;
896     deviceInfo.isOnline = true;
897     char output[DISC_MAX_CUST_DATA_LEN] = {0};
898     DevicePolicyInfo devicePolicyInfo;
899     BroadcastHead broadcastHead;
900     broadcastHead.trustFilter = static_cast<char>(2);
901     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
902     auto ret = mineListener->MatchSearchScopeDevice(deviceInfo, output, devicePolicyInfo, broadcastHead);
903     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
904 }
905 
906 HWTEST_F(MineSoftbusListenerTest, MatchSearchScopeDevice_002, testing::ext::TestSize.Level0)
907 {
908     DeviceInfo deviceInfo;
909     deviceInfo.isOnline = false;
910     char output[DISC_MAX_CUST_DATA_LEN] = {0};
911     DevicePolicyInfo devicePolicyInfo;
912     BroadcastHead broadcastHead;
913     broadcastHead.trustFilter = static_cast<char>(3);
914     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
915     auto ret = mineListener->MatchSearchScopeDevice(deviceInfo, output, devicePolicyInfo, broadcastHead);
916     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
917 }
918 
919 HWTEST_F(MineSoftbusListenerTest, MatchSearchScopeDevice_003, testing::ext::TestSize.Level0)
920 {
921     DeviceInfo deviceInfo;
922     deviceInfo.isOnline = false;
923     char output[DISC_MAX_CUST_DATA_LEN] = {1};
924     DevicePolicyInfo devicePolicyInfo;
925     BroadcastHead broadcastHead;
926     broadcastHead.trustFilter = static_cast<char>(7);
927     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
928     auto ret = mineListener->MatchSearchScopeDevice(deviceInfo, output, devicePolicyInfo, broadcastHead);
929     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
930 }
931 
932 HWTEST_F(MineSoftbusListenerTest, GetVertexDevicePolicyInfo_001, testing::ext::TestSize.Level0)
933 {
934     DevicePolicyInfo devicePolicyInfo;
935     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
936     mineListener->GetVertexDevicePolicyInfo(devicePolicyInfo);
937     EXPECT_EQ(devicePolicyInfo.snHashValid, true);
938 }
939 
940 HWTEST_F(MineSoftbusListenerTest, MatchSearchVertexDevice_001, testing::ext::TestSize.Level0)
941 {
942     DeviceInfo deviceInfo;
943     deviceInfo.isOnline = true;
944     char output[DISC_MAX_CUST_DATA_LEN] = {0};
945     DevicePolicyInfo devicePolicyInfo;
946     BroadcastHead broadcastHead;
947     broadcastHead.trustFilter = static_cast<char>(2);
948     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
949     auto ret = mineListener->MatchSearchVertexDevice(deviceInfo, output, devicePolicyInfo, broadcastHead);
950     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
951 }
952 
953 HWTEST_F(MineSoftbusListenerTest, MatchSearchVertexDevice_002, testing::ext::TestSize.Level0)
954 {
955     DeviceInfo deviceInfo;
956     deviceInfo.isOnline = false;
957     char output[DISC_MAX_CUST_DATA_LEN] = {0};
958     DevicePolicyInfo devicePolicyInfo;
959     BroadcastHead broadcastHead;
960     broadcastHead.trustFilter = static_cast<char>(3);
961     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
962     auto ret = mineListener->MatchSearchVertexDevice(deviceInfo, output, devicePolicyInfo, broadcastHead);
963     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
964 }
965 
966 HWTEST_F(MineSoftbusListenerTest, MatchSearchVertexDevice_003, testing::ext::TestSize.Level0)
967 {
968     DeviceInfo deviceInfo;
969     deviceInfo.isOnline = false;
970     char output[DISC_MAX_CUST_DATA_LEN] = {1};
971     DevicePolicyInfo devicePolicyInfo;
972     BroadcastHead broadcastHead;
973     broadcastHead.trustFilter = static_cast<char>(7);
974     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
975     auto ret = mineListener->MatchSearchVertexDevice(deviceInfo, output, devicePolicyInfo, broadcastHead);
976     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
977 }
978 
979 HWTEST_F(MineSoftbusListenerTest, SendReturnwave_001, testing::ext::TestSize.Level0)
980 {
981     DeviceInfo deviceInfo;
982     BroadcastHead broadcastHead;
983     Action matchResult = static_cast<Action>(1);
984     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
985     auto ret = mineListener->SendReturnwave(deviceInfo, broadcastHead, matchResult);
986     EXPECT_EQ(ret, DM_OK);
987 }
988 
989 HWTEST_F(MineSoftbusListenerTest, GetDeviceAliasHash_001, testing::ext::TestSize.Level0)
990 {
991     char output[DISC_MAX_CUST_DATA_LEN] = {1};
992     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
993     auto ret = mineListener->GetDeviceAliasHash(output);
994     EXPECT_EQ(ret, false);
995 }
996 
997 HWTEST_F(MineSoftbusListenerTest, GetDeviceSnHash_001, testing::ext::TestSize.Level0)
998 {
999     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1000     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1001     auto ret = mineListener->GetDeviceSnHash(output);
1002     EXPECT_EQ(ret, true);
1003 }
1004 
1005 HWTEST_F(MineSoftbusListenerTest, GetDeviceUdidHash_001, testing::ext::TestSize.Level0)
1006 {
1007     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1008     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1009     auto ret = mineListener->GetDeviceUdidHash(output);
1010     EXPECT_EQ(ret, true);
1011 }
1012 
1013 HWTEST_F(MineSoftbusListenerTest, GetDeviceTypeHash_001, testing::ext::TestSize.Level0)
1014 {
1015     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1016     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1017     auto ret = mineListener->GetDeviceTypeHash(output);
1018     EXPECT_EQ(ret, true);
1019 }
1020 
1021 HWTEST_F(MineSoftbusListenerTest, GetDeviceNumber_001, testing::ext::TestSize.Level0)
1022 {
1023     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1024     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1025     auto ret = mineListener->GetDeviceNumber(output);
1026     EXPECT_EQ(ret, false);
1027 }
1028 
1029 HWTEST_F(MineSoftbusListenerTest, CheckDeviceAliasMatch_001, testing::ext::TestSize.Level0)
1030 {
1031     DevicePolicyInfo devicePolicyInfo;
1032     devicePolicyInfo.aliasHashValid = false;
1033     char data[DISC_MAX_CUST_DATA_LEN] = {1};
1034     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1035     auto ret = mineListener->CheckDeviceAliasMatch(devicePolicyInfo, data);
1036     EXPECT_EQ(ret, false);
1037 }
1038 
1039 HWTEST_F(MineSoftbusListenerTest, CheckDeviceAliasMatch_002, testing::ext::TestSize.Level0)
1040 {
1041     DevicePolicyInfo devicePolicyInfo;
1042     devicePolicyInfo.aliasHashValid = true;
1043     char data[DISC_MAX_CUST_DATA_LEN] = {1};
1044     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1045     auto ret = mineListener->CheckDeviceAliasMatch(devicePolicyInfo, data);
1046     EXPECT_EQ(ret, false);
1047 }
1048 
1049 HWTEST_F(MineSoftbusListenerTest, CheckDeviceNumberMatch_001, testing::ext::TestSize.Level0)
1050 {
1051     DevicePolicyInfo devicePolicyInfo;
1052     devicePolicyInfo.aliasHashValid = false;
1053     int32_t startNumber = 1;
1054     int32_t endNumber = 1;
1055     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1056     auto ret = mineListener->CheckDeviceNumberMatch(devicePolicyInfo, startNumber, endNumber);
1057     EXPECT_EQ(ret, false);
1058 }
1059 
1060 HWTEST_F(MineSoftbusListenerTest, CheckDeviceNumberMatch_002, testing::ext::TestSize.Level0)
1061 {
1062     DevicePolicyInfo devicePolicyInfo;
1063     devicePolicyInfo.aliasHashValid = true;
1064     int32_t startNumber = -1;
1065     int32_t endNumber = 2;
1066     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1067     auto ret = mineListener->CheckDeviceNumberMatch(devicePolicyInfo, startNumber, endNumber);
1068     EXPECT_EQ(ret, false);
1069 }
1070 
1071 HWTEST_F(MineSoftbusListenerTest, CheckDeviceNumberMatch_003, testing::ext::TestSize.Level0)
1072 {
1073     DevicePolicyInfo devicePolicyInfo;
1074     devicePolicyInfo.aliasHashValid = true;
1075     int32_t startNumber = 2;
1076     int32_t endNumber = -1;
1077     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1078     auto ret = mineListener->CheckDeviceNumberMatch(devicePolicyInfo, startNumber, endNumber);
1079     EXPECT_EQ(ret, false);
1080 }
1081 
1082 HWTEST_F(MineSoftbusListenerTest, CheckDeviceNumberMatchh_004, testing::ext::TestSize.Level0)
1083 {
1084     DevicePolicyInfo devicePolicyInfo = {
1085         .number = "1",
1086     };
1087     devicePolicyInfo.aliasHashValid = true;
1088     int32_t startNumber = 2;
1089     int32_t endNumber = 2;
1090     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1091     auto ret = mineListener->CheckDeviceNumberMatch(devicePolicyInfo, startNumber, endNumber);
1092     EXPECT_EQ(ret, false);
1093 }
1094 
1095 HWTEST_F(MineSoftbusListenerTest, CheckDeviceNumberMatch_005, testing::ext::TestSize.Level0)
1096 {
1097     DevicePolicyInfo devicePolicyInfo = {
1098         .number = "3",
1099     };
1100     devicePolicyInfo.aliasHashValid = true;
1101     int32_t startNumber = 2;
1102     int32_t endNumber = 2;
1103     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1104     auto ret = mineListener->CheckDeviceNumberMatch(devicePolicyInfo, startNumber, endNumber);
1105     EXPECT_EQ(ret, false);
1106 }
1107 
1108 HWTEST_F(MineSoftbusListenerTest, CheckDeviceNumberMatch_006, testing::ext::TestSize.Level0)
1109 {
1110     DevicePolicyInfo devicePolicyInfo = {
1111         .number = "10",
1112     };
1113     devicePolicyInfo.aliasHashValid = true;
1114     int32_t startNumber = 2;
1115     int32_t endNumber = 20;
1116     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1117     auto ret = mineListener->CheckDeviceNumberMatch(devicePolicyInfo, startNumber, endNumber);
1118     EXPECT_EQ(ret, false);
1119 }
1120 
1121 HWTEST_F(MineSoftbusListenerTest, CheckDeviceSnMatch_001, testing::ext::TestSize.Level0)
1122 {
1123     DevicePolicyInfo devicePolicyInfo;
1124     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1125     devicePolicyInfo.snHashValid = false;
1126     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1127     auto ret = mineListener->CheckDeviceSnMatch(devicePolicyInfo, output);
1128     EXPECT_EQ(ret, false);
1129 }
1130 
1131 HWTEST_F(MineSoftbusListenerTest, CheckDeviceSnMatch_002, testing::ext::TestSize.Level0)
1132 {
1133     DevicePolicyInfo devicePolicyInfo;
1134     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1135     devicePolicyInfo.snHashValid = true;
1136     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1137     auto ret = mineListener->CheckDeviceSnMatch(devicePolicyInfo, output);
1138     EXPECT_EQ(ret, false);
1139 }
1140 
1141 HWTEST_F(MineSoftbusListenerTest, CheckDeviceTypeMatch_001, testing::ext::TestSize.Level0)
1142 {
1143     DevicePolicyInfo devicePolicyInfo;
1144     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1145     devicePolicyInfo.typeHashValid = false;
1146     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1147     auto ret = mineListener->CheckDeviceTypeMatch(devicePolicyInfo, output);
1148     EXPECT_EQ(ret, false);
1149 }
1150 
1151 HWTEST_F(MineSoftbusListenerTest, CheckDeviceTypeMatch_002, testing::ext::TestSize.Level0)
1152 {
1153     DevicePolicyInfo devicePolicyInfo;
1154     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1155     devicePolicyInfo.typeHashValid = true;
1156     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1157     auto ret = mineListener->CheckDeviceTypeMatch(devicePolicyInfo, output);
1158     EXPECT_EQ(ret, false);
1159 }
1160 
1161 HWTEST_F(MineSoftbusListenerTest, CheckDeviceUdidMatch_001, testing::ext::TestSize.Level0)
1162 {
1163     DevicePolicyInfo devicePolicyInfo;
1164     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1165     devicePolicyInfo.udidHashValid = false;
1166     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1167     auto ret = mineListener->CheckDeviceUdidMatch(devicePolicyInfo, output);
1168     EXPECT_EQ(ret, false);
1169 }
1170 
1171 HWTEST_F(MineSoftbusListenerTest, CheckDeviceUdidMatch_002, testing::ext::TestSize.Level0)
1172 {
1173     DevicePolicyInfo devicePolicyInfo;
1174     char output[DISC_MAX_CUST_DATA_LEN] = {1};
1175     devicePolicyInfo.udidHashValid = true;
1176     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1177     auto ret = mineListener->CheckDeviceUdidMatch(devicePolicyInfo, output);
1178     EXPECT_EQ(ret, false);
1179 }
1180 
1181 HWTEST_F(MineSoftbusListenerTest, GetMatchResult_001, testing::ext::TestSize.Level0)
1182 {
1183     std::vector<int> matchItemNum;
1184     std::vector<int> matchItemResult;
1185     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1186     auto ret = mineListener->GetMatchResult(matchItemNum, matchItemResult);
1187     EXPECT_EQ(ret, BUSINESS_EXACT_NOT_MATCH);
1188 }
1189 
1190 HWTEST_F(MineSoftbusListenerTest, GetMatchResult_002, testing::ext::TestSize.Level0)
1191 {
1192     std::vector<int> matchItemNum;
1193     matchItemNum.push_back(1);
1194     std::vector<int> matchItemResult;
1195     matchItemResult.push_back(2);
1196     std::shared_ptr<MineSoftbusListener> mineListener = std::make_shared<MineSoftbusListener>();
1197     auto ret = mineListener->GetMatchResult(matchItemNum, matchItemResult);
1198     EXPECT_EQ(ret, BUSINESS_PARTIAL_MATCH);
1199 }
1200 } // namespace
1201 } // namespace DistributedHardware
1202 } // namespace OHOS