1 /*
2 * Copyright (c) 2022-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_dm_discovery_filter.h"
17
18 namespace OHOS {
19 namespace DistributedHardware {
SetUp()20 void DmDiscoveryFilterTest::SetUp()
21 {
22 }
TearDown()23 void DmDiscoveryFilterTest::TearDown()
24 {
25 }
SetUpTestCase()26 void DmDiscoveryFilterTest::SetUpTestCase()
27 {
28 }
TearDownTestCase()29 void DmDiscoveryFilterTest::TearDownTestCase()
30 {
31 }
32
33 const std::string FILTERS_KEY = "filters";
34 const std::string FILTER_OP_KEY = "filter_op";
35 namespace {
36
37 /**
38 * @tc.name: ParseFilterJson_001
39 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
40 * @tc.type: FUNC
41 * @tc.require: AR000GHSJK
42 */
43 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_001, testing::ext::TestSize.Level0)
44 {
45 DmDeviceFilterOption filterOption;
46 std::string str;
47 int32_t ret = filterOption.ParseFilterJson(str);
48 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
49 }
50
51 /**
52 * @tc.name: ParseFilterJson_002
53 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
54 * @tc.type: FUNC
55 * @tc.require: AR000GHSJK
56 */
57 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_002, testing::ext::TestSize.Level0)
58 {
59 DmDeviceFilterOption filterOption;
60 nlohmann::json jsonObject;
61 std::string str = jsonObject.dump();
62 int32_t ret = filterOption.ParseFilterJson(str);
63 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
64 }
65
66 /**
67 * @tc.name: ParseFilterJson_003
68 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
69 * @tc.type: FUNC
70 * @tc.require: AR000GHSJK
71 */
72 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_003, testing::ext::TestSize.Level0)
73 {
74 DmDeviceFilterOption filterOption;
75 nlohmann::json jsonObject;
76 jsonObject[FILTERS_KEY] = "filters";
77 std::string str = jsonObject.dump();
78 int32_t ret = filterOption.ParseFilterJson(str);
79 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
80 }
81
82 /**
83 * @tc.name: ParseFilterJson_004
84 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
85 * @tc.type: FUNC
86 * @tc.require: AR000GHSJK
87 */
88 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_004, testing::ext::TestSize.Level0)
89 {
90 DmDeviceFilterOption filterOption;
91 nlohmann::json jsonObject;
92 std::vector<int> myArray;
93 jsonObject[FILTERS_KEY] = myArray;
94 std::string str = jsonObject.dump();
95 int32_t ret = filterOption.ParseFilterJson(str);
96 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
97 }
98
99 /**
100 * @tc.name: ParseFilterJson_005
101 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
102 * @tc.type: FUNC
103 * @tc.require: AR000GHSJK
104 */
105 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_005, testing::ext::TestSize.Level0)
106 {
107 DmDeviceFilterOption filterOption;
108 nlohmann::json jsonObject;
109 int myArray[5] = {1, 2, 3, 4, 5};
110 jsonObject[FILTERS_KEY] = myArray;
111 std::string str = jsonObject.dump();
112 int32_t ret = filterOption.ParseFilterJson(str);
113 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
114 }
115
116 /**
117 * @tc.name: ParseFilterJson_006
118 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
119 * @tc.type: FUNC
120 * @tc.require: AR000GHSJK
121 */
122 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_006, testing::ext::TestSize.Level0)
123 {
124 DmDeviceFilterOption filterOption;
125 nlohmann::json jsonObject;
126 int myArray[5] = {1, 2, 3, 4, 5};
127 jsonObject[FILTERS_KEY] = myArray;
128 jsonObject[FILTER_OP_KEY] = 12345;
129 std::string str = jsonObject.dump();
130 int32_t ret = filterOption.ParseFilterJson(str);
131 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
132 }
133
134 /**
135 * @tc.name: ParseFilterJson_007
136 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
137 * @tc.type: FUNC
138 * @tc.require: AR000GHSJK
139 */
140 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_007, testing::ext::TestSize.Level0)
141 {
142 DmDeviceFilterOption filterOption;
143 nlohmann::json jsonObject;
144 int myArray[5] = {1, 2, 3, 4, 5};
145 jsonObject[FILTERS_KEY] = myArray;
146 jsonObject[FILTER_OP_KEY] = "filter_op";
147 std::string str = jsonObject.dump();
148 int32_t ret = filterOption.ParseFilterJson(str);
149 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
150 }
151
152 /**
153 * @tc.name: ParseFilterJson_008
154 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
155 * @tc.type: FUNC
156 * @tc.require: AR000GHSJK
157 */
158 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_008, testing::ext::TestSize.Level0)
159 {
160 DmDeviceFilterOption filterOption;
161 nlohmann::json jsonObject;
162 nlohmann::json object;
163 object["type"] = 1;
164 std::vector<nlohmann::json>myArray;
165 myArray.push_back(object);
166 jsonObject[FILTERS_KEY] = myArray;
167 jsonObject[FILTER_OP_KEY] = "filter_op";
168 std::string str = jsonObject.dump();
169 int32_t ret = filterOption.ParseFilterJson(str);
170 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
171 }
172
173 /**
174 * @tc.name: ParseFilterJson_009
175 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
176 * @tc.type: FUNC
177 * @tc.require: AR000GHSJK
178 */
179 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_009, testing::ext::TestSize.Level0)
180 {
181 DmDeviceFilterOption filterOption;
182 nlohmann::json jsonObject;
183 nlohmann::json object;
184 object["type"] = "1";
185 object["value"] = "1";
186 std::vector<nlohmann::json>myArray;
187 myArray.push_back(object);
188 jsonObject[FILTERS_KEY] = myArray;
189 jsonObject[FILTER_OP_KEY] = "filter_op";
190 std::string str = jsonObject.dump();
191 int32_t ret = filterOption.ParseFilterJson(str);
192 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
193 }
194
195 /**
196 * @tc.name: ParseFilterJson_0010
197 * @tc.desc: Return DM_OK
198 * @tc.type: FUNC
199 * @tc.require: AR000GHSJK
200 */
201 HWTEST_F(DmDiscoveryFilterTest, ParseFilterJson_0010, testing::ext::TestSize.Level0)
202 {
203 DmDeviceFilterOption filterOption;
204 nlohmann::json jsonObject;
205 nlohmann::json object;
206 object["type"] = "1";
207 object["value"] = 1;
208 std::vector<nlohmann::json>myArray;
209 myArray.push_back(object);
210 jsonObject[FILTERS_KEY] = myArray;
211 jsonObject[FILTER_OP_KEY] = "filter_op";
212 std::string str = jsonObject.dump();
213 int32_t ret = filterOption.ParseFilterJson(str);
214 EXPECT_EQ(ret, DM_OK);
215 }
216
217 /**
218 * @tc.name: ParseFilterOptionJson_001
219 * @tc.desc:
220 * @tc.type: FUNC
221 * @tc.require: AR000GHSJK
222 */
223 HWTEST_F(DmDiscoveryFilterTest, ParseFilterOptionJson_001, testing::ext::TestSize.Level0)
224 {
225 DmDeviceFilterOption filterOption;
226 std::string str;
227 filterOption.ParseFilterOptionJson(str);
228 EXPECT_EQ(filterOption.filterOp_ != "AND", true);
229 }
230
231 /**
232 * @tc.name: ParseFilterOptionJson_002
233 * @tc.desc:
234 * @tc.type: FUNC
235 * @tc.require: AR000GHSJK
236 */
237 HWTEST_F(DmDiscoveryFilterTest, ParseFilterOptionJson_002, testing::ext::TestSize.Level0)
238 {
239 DmDeviceFilterOption filterOption;
240 nlohmann::json jsonObject;
241 std::string str = jsonObject.dump();
242 filterOption.ParseFilterOptionJson(str);
243 EXPECT_EQ(filterOption.filterOp_ == "AND", true);
244 }
245
246 /**
247 * @tc.name: ParseFilterOptionJson_003
248 * @tc.desc:
249 * @tc.type: FUNC
250 * @tc.require: AR000GHSJK
251 */
252 HWTEST_F(DmDiscoveryFilterTest, ParseFilterOptionJson_003, testing::ext::TestSize.Level0)
253 {
254 DmDeviceFilterOption filterOption;
255 nlohmann::json jsonObject;
256 jsonObject["credible"] = "123";
257 std::string str = jsonObject.dump();
258 filterOption.ParseFilterOptionJson(str);
259 EXPECT_EQ(filterOption.filterOp_ == "AND", true);
260 }
261
262 /**
263 * @tc.name: ParseFilterOptionJson_004
264 * @tc.desc:
265 * @tc.type: FUNC
266 * @tc.require: AR000GHSJK
267 */
268 HWTEST_F(DmDiscoveryFilterTest, ParseFilterOptionJson_004, testing::ext::TestSize.Level0)
269 {
270 DmDeviceFilterOption filterOption;
271 nlohmann::json jsonObject;
272 jsonObject["credible"] = 1;
273 jsonObject["isTrusted"] = "123";
274 std::string str = jsonObject.dump();
275 filterOption.ParseFilterOptionJson(str);
276 EXPECT_EQ(filterOption.filterOp_ == "AND", true);
277 }
278
279 /**
280 * @tc.name: ParseFilterOptionJson_005
281 * @tc.desc:
282 * @tc.type: FUNC
283 * @tc.require: AR000GHSJK
284 */
285 HWTEST_F(DmDiscoveryFilterTest, ParseFilterOptionJson_005, testing::ext::TestSize.Level0)
286 {
287 DmDeviceFilterOption filterOption;
288 nlohmann::json jsonObject;
289 jsonObject["credible"] = 1;
290 jsonObject["isTrusted"] = 2;
291 jsonObject["authForm"] = "3";
292 std::string str = jsonObject.dump();
293 filterOption.ParseFilterOptionJson(str);
294 EXPECT_EQ(filterOption.filterOp_ == "AND", true);
295 }
296
297 /**
298 * @tc.name: ParseFilterOptionJson_006
299 * @tc.desc:
300 * @tc.type: FUNC
301 * @tc.require: AR000GHSJK
302 */
303 HWTEST_F(DmDiscoveryFilterTest, ParseFilterOptionJson_006, testing::ext::TestSize.Level0)
304 {
305 DmDeviceFilterOption filterOption;
306 nlohmann::json jsonObject;
307 jsonObject["credible"] = 1;
308 jsonObject["isTrusted"] = 2;
309 jsonObject["authForm"] = 3;
310 jsonObject["deviceType"] = "4";
311 std::string str = jsonObject.dump();
312 filterOption.ParseFilterOptionJson(str);
313 EXPECT_EQ(filterOption.filterOp_ == "AND", true);
314 }
315
316 /**
317 * @tc.name: ParseFilterOptionJson_007
318 * @tc.desc:
319 * @tc.type: FUNC
320 * @tc.require: AR000GHSJK
321 */
322 HWTEST_F(DmDiscoveryFilterTest, ParseFilterOptionJson_007, testing::ext::TestSize.Level0)
323 {
324 DmDeviceFilterOption filterOption;
325 nlohmann::json jsonObject;
326 jsonObject["credible"] = 1;
327 jsonObject["isTrusted"] = 2;
328 jsonObject["authForm"] = 3;
329 jsonObject["deviceType"] = 4;
330 std::string str = jsonObject.dump();
331 filterOption.ParseFilterOptionJson(str);
332 EXPECT_EQ(filterOption.filterOp_ == "AND", true);
333 }
334
335 /**
336 * @tc.name: TransformToFilter_001
337 * @tc.desc: return DM_OK
338 * @tc.type: FUNC
339 * @tc.require: AR000GHSJK
340 */
341 HWTEST_F(DmDiscoveryFilterTest, TransformToFilter_001, testing::ext::TestSize.Level0)
342 {
343 DmDeviceFilterOption filterOption;
344 std::string filterOptions;
345 int32_t ret = filterOption.TransformToFilter(filterOptions);
346 EXPECT_EQ(ret, DM_OK);
347 }
348
349 /**
350 * @tc.name: TransformToFilter_002
351 * @tc.desc: return DM_OK
352 * @tc.type: FUNC
353 * @tc.require: AR000GHSJK
354 */
355 HWTEST_F(DmDiscoveryFilterTest, TransformToFilter_002, testing::ext::TestSize.Level0)
356 {
357 DmDeviceFilterOption filterOption;
358 std::string filterOptions = "filterOptions";
359 int32_t ret = filterOption.TransformToFilter(filterOptions);
360 EXPECT_NE(ret, DM_OK);
361 }
362
363 /**
364 * @tc.name: TransformFilterOption_001
365 * @tc.desc:
366 * @tc.type: FUNC
367 * @tc.require: AR000GHSJK
368 */
369 HWTEST_F(DmDiscoveryFilterTest, TransformFilterOption_001, testing::ext::TestSize.Level0)
370 {
371 DmDeviceFilterOption filterOption;
372 std::string filterOptions;
373 filterOption.TransformFilterOption(filterOptions);
374 EXPECT_EQ(filterOptions.empty(), true);
375 }
376
377 /**
378 * @tc.name: TransformFilterOption_002
379 * @tc.desc:
380 * @tc.type: FUNC
381 * @tc.require: AR000GHSJK
382 */
383 HWTEST_F(DmDiscoveryFilterTest, TransformFilterOption_002, testing::ext::TestSize.Level0)
384 {
385 DmDeviceFilterOption filterOption;
386 std::string filterOptions = "filterOptions";
387 filterOption.TransformFilterOption(filterOptions);
388 EXPECT_EQ(filterOptions.empty(), false);
389 }
390
391 /**
392 * @tc.name: FilterByDeviceState_001
393 * @tc.desc: Return true
394 * @tc.type: FUNC
395 * @tc.require: AR000GHSJK
396 */
397 HWTEST_F(DmDiscoveryFilterTest, FilterByDeviceState_001, testing::ext::TestSize.Level0)
398 {
399 DmDiscoveryFilter filter;
400 int32_t value = 0;
401 bool isOnline = false;
402 bool ret = filter.FilterByDeviceState(value, isOnline);
403 EXPECT_EQ(ret, true);
404 }
405
406 /**
407 * @tc.name: FilterByDeviceState_002
408 * @tc.desc: Return false
409 * @tc.type: FUNC
410 * @tc.require: AR000GHSJK
411 */
412 HWTEST_F(DmDiscoveryFilterTest, FilterByDeviceState_002, testing::ext::TestSize.Level0)
413 {
414 DmDiscoveryFilter filter;
415 int32_t value = 1;
416 bool isOnline = false;
417 bool ret = filter.FilterByDeviceState(value, isOnline);
418 EXPECT_EQ(ret, false);
419 }
420
421 /**
422 * @tc.name: FilterByDeviceState_003
423 * @tc.desc: Return true
424 * @tc.type: FUNC
425 * @tc.require: AR000GHSJK
426 */
427 HWTEST_F(DmDiscoveryFilterTest, FilterByDeviceState_003, testing::ext::TestSize.Level0)
428 {
429 DmDiscoveryFilter filter;
430 int32_t value = 2;
431 bool isOnline = false;
432 bool ret = filter.FilterByDeviceState(value, isOnline);
433 EXPECT_EQ(ret, true);
434 }
435
436 /**
437 * @tc.name: FilterByRange_001
438 * @tc.desc: Return false
439 * @tc.type: FUNC
440 * @tc.require: AR000GHSJK
441 */
442 HWTEST_F(DmDiscoveryFilterTest, FilterByRange_001, testing::ext::TestSize.Level0)
443 {
444 DmDiscoveryFilter filter;
445 int32_t value = 0;
446 int32_t range = 1;
447 bool ret = filter.FilterByRange(value, range);
448 EXPECT_EQ(ret, false);
449 }
450
451 /**
452 * @tc.name: FilterByRange_002
453 * @tc.desc: Return false
454 * @tc.type: FUNC
455 * @tc.require: AR000GHSJK
456 */
457 HWTEST_F(DmDiscoveryFilterTest, FilterByRange_002, testing::ext::TestSize.Level0)
458 {
459 DmDiscoveryFilter filter;
460 int32_t value = 0;
461 int32_t range = -1;
462 bool ret = filter.FilterByRange(value, range);
463 EXPECT_EQ(ret, false);
464 }
465
466 /**
467 * @tc.name: FilterByRange_003
468 * @tc.desc: Return true
469 * @tc.type: FUNC
470 * @tc.require: AR000GHSJK
471 */
472 HWTEST_F(DmDiscoveryFilterTest, FilterByRange_003, testing::ext::TestSize.Level0)
473 {
474 DmDiscoveryFilter filter;
475 int32_t value = 1;
476 int32_t range = 1;
477 bool ret = filter.FilterByRange(value, range);
478 EXPECT_EQ(ret, true);
479 }
480
481 /**
482 * @tc.name: FilterByAuthForm_001
483 * @tc.desc: Return true
484 * @tc.type: FUNC
485 * @tc.require: AR000GHSJK
486 */
487 HWTEST_F(DmDiscoveryFilterTest, FilterByAuthForm_001, testing::ext::TestSize.Level0)
488 {
489 DmDiscoveryFilter filter;
490 int32_t value = 1;
491 int32_t authForm = 1;
492 bool ret = filter.FilterByAuthForm(value, authForm);
493 EXPECT_EQ(ret, true);
494 }
495
496 /**
497 * @tc.name: FilterByAuthForm_002
498 * @tc.desc: Return false
499 * @tc.type: FUNC
500 * @tc.require: AR000GHSJK
501 */
502 HWTEST_F(DmDiscoveryFilterTest, FilterByAuthForm_002, testing::ext::TestSize.Level0)
503 {
504 DmDiscoveryFilter filter;
505 int32_t value = 1;
506 int32_t authForm = 2;
507 bool ret = filter.FilterByAuthForm(value, authForm);
508 EXPECT_EQ(ret, false);
509 }
510
511 /**
512 * @tc.name: FilterByDeviceType_001
513 * @tc.desc: Return true
514 * @tc.type: FUNC
515 * @tc.require: AR000GHSJK
516 */
517 HWTEST_F(DmDiscoveryFilterTest, FilterByDeviceType_001, testing::ext::TestSize.Level0)
518 {
519 DmDiscoveryFilter filter;
520 int32_t value = 1;
521 int32_t deviceType = 1;
522 bool ret = filter.FilterByDeviceType(value, deviceType);
523 EXPECT_EQ(ret, true);
524 }
525
526 /**
527 * @tc.name: FilterByDeviceType_002
528 * @tc.desc: Return false
529 * @tc.type: FUNC
530 * @tc.require: AR000GHSJK
531 */
532 HWTEST_F(DmDiscoveryFilterTest, FilterByDeviceType, testing::ext::TestSize.Level0)
533 {
534 DmDiscoveryFilter filter;
535 int32_t value = 1;
536 int32_t deviceType = 2;
537 bool ret = filter.FilterByDeviceType(value, deviceType);
538 EXPECT_EQ(ret, false);
539 }
540
541 /**
542 * @tc.name: FilterByType_001
543 * @tc.desc: Return true
544 * @tc.type: FUNC
545 * @tc.require: AR000GHSJK
546 */
547 HWTEST_F(DmDiscoveryFilterTest, FilterByType_001, testing::ext::TestSize.Level0)
548 {
549 DmDiscoveryFilter filter;
550 DmDeviceFilters filters;
551 filters.type = "credible";
552 filters.value = 0;
553 DmDeviceFilterPara filterPara;
554 filterPara.isOnline = false;
555 bool ret = filter.FilterByType(filters, filterPara);
556 EXPECT_EQ(ret, true);
557 }
558
559 /**
560 * @tc.name: FilterByType_002
561 * @tc.desc: Return true
562 * @tc.type: FUNC
563 * @tc.require: AR000GHSJK
564 */
565 HWTEST_F(DmDiscoveryFilterTest, FilterByType_002, testing::ext::TestSize.Level0)
566 {
567 DmDiscoveryFilter filter;
568 DmDeviceFilters filters;
569 filters.type = "range";
570 filters.value = 1;
571 DmDeviceFilterPara filterPara;
572 filterPara.range = 1;
573 bool ret = filter.FilterByType(filters, filterPara);
574 EXPECT_EQ(ret, true);
575 }
576
577 /**
578 * @tc.name: FilterByType_003
579 * @tc.desc: Return false
580 * @tc.type: FUNC
581 * @tc.require: AR000GHSJK
582 */
583 HWTEST_F(DmDiscoveryFilterTest, FilterByType_003, testing::ext::TestSize.Level0)
584 {
585 DmDiscoveryFilter filter;
586 DmDeviceFilters filters;
587 filters.type = "isTrusted";
588 filters.value = 1;
589 DmDeviceFilterPara filterPara;
590 filterPara.isTrusted = false;
591 bool ret = filter.FilterByType(filters, filterPara);
592 EXPECT_EQ(ret, false);
593 }
594
595 /**
596 * @tc.name: FilterByType_004
597 * @tc.desc: Return true
598 * @tc.type: FUNC
599 * @tc.require: AR000GHSJK
600 */
601 HWTEST_F(DmDiscoveryFilterTest, FilterByType_004, testing::ext::TestSize.Level0)
602 {
603 DmDiscoveryFilter filter;
604 DmDeviceFilters filters;
605 filters.type = "authForm";
606 filters.value = 1;
607 DmDeviceFilterPara filterPara;
608 filterPara.authForm = 1;
609 bool ret = filter.FilterByType(filters, filterPara);
610 EXPECT_EQ(ret, true);
611 }
612
613 /**
614 * @tc.name: FilterByType_005
615 * @tc.desc: Return true
616 * @tc.type: FUNC
617 * @tc.require: AR000GHSJK
618 */
619 HWTEST_F(DmDiscoveryFilterTest, FilterByType_005, testing::ext::TestSize.Level0)
620 {
621 DmDiscoveryFilter filter;
622 DmDeviceFilters filters;
623 filters.type = "deviceType";
624 filters.value = 1;
625 DmDeviceFilterPara filterPara;
626 filterPara.deviceType = 1;
627 bool ret = filter.FilterByType(filters, filterPara);
628 EXPECT_EQ(ret, true);
629 }
630
631 /**
632 * @tc.name: FilterByType_006
633 * @tc.desc: Return false
634 * @tc.type: FUNC
635 * @tc.require: AR000GHSJK
636 */
637 HWTEST_F(DmDiscoveryFilterTest, FilterByType_006, testing::ext::TestSize.Level0)
638 {
639 DmDiscoveryFilter filter;
640 DmDeviceFilters filters;
641 DmDeviceFilterPara filterPara;
642 filters.type = "typeTest";
643 bool ret = filter.FilterByType(filters, filterPara);
644 EXPECT_EQ(ret, false);
645 }
646
647 /**
648 * @tc.name: FilterOr_001
649 * @tc.desc: Return false
650 * @tc.type: FUNC
651 * @tc.require: AR000GHSJK
652 */
653 HWTEST_F(DmDiscoveryFilterTest, FilterOr_001, testing::ext::TestSize.Level0)
654 {
655 DmDiscoveryFilter filter;
656 DmDeviceFilters filters;
657 filters.type = "typeTest";
658 std::vector<DmDeviceFilters> filtersVec;
659 filtersVec.push_back(filters);
660 DmDeviceFilterPara filterPara;
661 bool ret = filter.FilterOr(filtersVec, filterPara);
662 EXPECT_EQ(ret, false);
663 }
664
665 /**
666 * @tc.name: FilterOr_002
667 * @tc.desc: Return true
668 * @tc.type: FUNC
669 * @tc.require: AR000GHSJK
670 */
671 HWTEST_F(DmDiscoveryFilterTest, FilterOr_002, testing::ext::TestSize.Level0)
672 {
673 DmDiscoveryFilter filter;
674 DmDeviceFilters filters;
675 filters.type = "range";
676 filters.value = 1;
677 std::vector<DmDeviceFilters> filtersVec;
678 filtersVec.push_back(filters);
679 DmDeviceFilterPara filterPara;
680 filterPara.range = 1;
681 bool ret = filter.FilterOr(filtersVec, filterPara);
682 EXPECT_EQ(ret, true);
683 }
684
685 /**
686 * @tc.name: FilterOr_003
687 * @tc.desc: Return true
688 * @tc.type: FUNC
689 * @tc.require: AR000GHSJK
690 */
691 HWTEST_F(DmDiscoveryFilterTest, FilterOr_003, testing::ext::TestSize.Level0)
692 {
693 DmDiscoveryFilter filter;
694 DmDeviceFilters filters;
695 filters.type = "credible";
696 filters.value = 0;
697 std::vector<DmDeviceFilters> filtersVec;
698 filtersVec.push_back(filters);
699 DmDeviceFilterPara filterPara;
700 filterPara.isOnline = false;
701 bool ret = filter.FilterOr(filtersVec, filterPara);
702 EXPECT_EQ(ret, true);
703 }
704
705 /**
706 * @tc.name: FilterAnd_001
707 * @tc.desc: Return false
708 * @tc.type: FUNC
709 * @tc.require: AR000GHSJK
710 */
711 HWTEST_F(DmDiscoveryFilterTest, FilterAnd_001, testing::ext::TestSize.Level0)
712 {
713 DmDiscoveryFilter filter;
714 DmDeviceFilters filters;
715 filters.type = "typeTest";
716 std::vector<DmDeviceFilters> filtersVec;
717 filtersVec.push_back(filters);
718 DmDeviceFilterPara filterPara;
719 bool ret = filter.FilterAnd(filtersVec, filterPara);
720 EXPECT_EQ(ret, false);
721 }
722
723 /**
724 * @tc.name: FilterAnd_002
725 * @tc.desc: Return true
726 * @tc.type: FUNC
727 * @tc.require: AR000GHSJK
728 */
729 HWTEST_F(DmDiscoveryFilterTest, FilterAnd_002, testing::ext::TestSize.Level0)
730 {
731 DmDiscoveryFilter filter;
732 DmDeviceFilters filters;
733 filters.type = "range";
734 filters.value = 1;
735 std::vector<DmDeviceFilters> filtersVec;
736 filtersVec.push_back(filters);
737 DmDeviceFilterPara filterPara;
738 filterPara.range = 1;
739 bool ret = filter.FilterAnd(filtersVec, filterPara);
740 EXPECT_EQ(ret, true);
741 }
742
743 /**
744 * @tc.name: FilterAnd_003
745 * @tc.desc: Return true
746 * @tc.type: FUNC
747 * @tc.require: AR000GHSJK
748 */
749 HWTEST_F(DmDiscoveryFilterTest, FilterAnd_003, testing::ext::TestSize.Level0)
750 {
751 DmDiscoveryFilter filter;
752 DmDeviceFilters filters;
753 filters.type = "credible";
754 filters.value = 0;
755 std::vector<DmDeviceFilters> filtersVec;
756 filtersVec.push_back(filters);
757 DmDeviceFilterPara filterPara;
758 filterPara.isOnline = false;
759 bool ret = filter.FilterAnd(filtersVec, filterPara);
760 EXPECT_EQ(ret, true);
761 }
762
763 /**
764 * @tc.name: IsValidDevice_001
765 * @tc.desc: Return true
766 * @tc.type: FUNC
767 * @tc.require: AR000GHSJK
768 */
769 HWTEST_F(DmDiscoveryFilterTest, IsValidDevice_001, testing::ext::TestSize.Level0)
770 {
771 DmDiscoveryFilter filter;
772 const std::string filterOp = "OR";
773 DmDeviceFilters filters;
774 filters.type = "credible";
775 filters.value = 0;
776 std::vector<DmDeviceFilters> filtersVec;
777 filtersVec.push_back(filters);
778 DmDeviceFilterPara filterPara;
779 filterPara.isOnline = false;
780 bool ret = filter.IsValidDevice(filterOp, filtersVec, filterPara);
781 EXPECT_EQ(ret, true);
782 }
783
784 /**
785 * @tc.name: IsValidDevice_002
786 * @tc.desc: Return true
787 * @tc.type: FUNC
788 * @tc.require: AR000GHSJK
789 */
790 HWTEST_F(DmDiscoveryFilterTest, IsValidDevice_002, testing::ext::TestSize.Level0)
791 {
792 DmDiscoveryFilter filter;
793 const std::string filterOp = "AND";
794 DmDeviceFilters filters;
795 filters.type = "range";
796 filters.value = 1;
797 std::vector<DmDeviceFilters> filtersVec;
798 filtersVec.push_back(filters);
799 DmDeviceFilterPara filterPara;
800 filterPara.range = 1;
801 bool ret = filter.IsValidDevice(filterOp, filtersVec, filterPara);
802 EXPECT_EQ(ret, true);
803 }
804
805 /**
806 * @tc.name: IsValidDevice_003
807 * @tc.desc: Return false
808 * @tc.type: FUNC
809 * @tc.require: AR000GHSJK
810 */
811 HWTEST_F(DmDiscoveryFilterTest, IsValidDevice_003, testing::ext::TestSize.Level0)
812 {
813 DmDiscoveryFilter filter;
814 const std::string filterOp = "filterOpTest";
815 DmDeviceFilters filters;
816 std::vector<DmDeviceFilters> filtersVec;
817 filtersVec.push_back(filters);
818 DmDeviceFilterPara filterPara;
819 bool ret = filter.IsValidDevice(filterOp, filtersVec, filterPara);
820 EXPECT_EQ(ret, false);
821 }
822 } // namespace
823 } // namespace DistributedHardware
824 } // namespace OHOS