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_filter.h"
17 
18 namespace OHOS {
19 namespace DistributedHardware {
SetUp()20 void DiscoveryFilterTest::SetUp()
21 {
22 }
TearDown()23 void DiscoveryFilterTest::TearDown()
24 {
25 }
SetUpTestCase()26 void DiscoveryFilterTest::SetUpTestCase()
27 {
28 }
TearDownTestCase()29 void DiscoveryFilterTest::TearDownTestCase()
30 {
31 }
32 
33 const std::string FILTERS_KEY = "filters";
34 const std::string FILTER_OP_KEY = "filter_op";
35 namespace {
36 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_001, testing::ext::TestSize.Level0)
37 {
38     DeviceFilterOption filterOption;
39     std::string str;
40     int32_t ret = filterOption.ParseFilterJson(str);
41     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
42 }
43 
44 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_002, testing::ext::TestSize.Level0)
45 {
46     DeviceFilterOption filterOption;
47     nlohmann::json jsonObject;
48     std::string str = jsonObject.dump();
49     int32_t ret = filterOption.ParseFilterJson(str);
50     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
51 }
52 
53 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_003, testing::ext::TestSize.Level0)
54 {
55     DeviceFilterOption filterOption;
56     nlohmann::json jsonObject;
57     jsonObject[FILTERS_KEY] = "filters";
58     std::string str = jsonObject.dump();
59     int32_t ret = filterOption.ParseFilterJson(str);
60     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
61 }
62 
63 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_004, testing::ext::TestSize.Level0)
64 {
65     DeviceFilterOption filterOption;
66     nlohmann::json jsonObject;
67     std::vector<int> myArray;
68     jsonObject[FILTERS_KEY] = myArray;
69     std::string str = jsonObject.dump();
70     int32_t ret = filterOption.ParseFilterJson(str);
71     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
72 }
73 
74 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_005, testing::ext::TestSize.Level0)
75 {
76     DeviceFilterOption filterOption;
77     nlohmann::json jsonObject;
78     int myArray[5] = {1, 2, 3, 4, 5};
79     jsonObject[FILTERS_KEY] = myArray;
80     std::string str = jsonObject.dump();
81     int32_t ret = filterOption.ParseFilterJson(str);
82     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
83 }
84 
85 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_006, testing::ext::TestSize.Level0)
86 {
87     DeviceFilterOption filterOption;
88     nlohmann::json jsonObject;
89     int myArray[5] = {1, 2, 3, 4, 5};
90     jsonObject[FILTERS_KEY] = myArray;
91     jsonObject[FILTER_OP_KEY] = 12345;
92     std::string str = jsonObject.dump();
93     int32_t ret = filterOption.ParseFilterJson(str);
94     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
95 }
96 
97 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_007, testing::ext::TestSize.Level0)
98 {
99     DeviceFilterOption filterOption;
100     nlohmann::json jsonObject;
101     int myArray[5] = {1, 2, 3, 4, 5};
102     jsonObject[FILTERS_KEY] = myArray;
103     jsonObject[FILTER_OP_KEY] = "filter_op";
104     std::string str = jsonObject.dump();
105     int32_t ret = filterOption.ParseFilterJson(str);
106     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
107 }
108 
109 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_008, testing::ext::TestSize.Level0)
110 {
111     DeviceFilterOption filterOption;
112     nlohmann::json jsonObject;
113     nlohmann::json object;
114     object["type"] = 1;
115     std::vector<nlohmann::json>myArray;
116     myArray.push_back(object);
117     jsonObject[FILTERS_KEY] = myArray;
118     jsonObject[FILTER_OP_KEY] = "filter_op";
119     std::string str = jsonObject.dump();
120     int32_t ret = filterOption.ParseFilterJson(str);
121     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
122 }
123 
124 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_009, testing::ext::TestSize.Level0)
125 {
126     DeviceFilterOption filterOption;
127     nlohmann::json jsonObject;
128     nlohmann::json object;
129     object["type"] = "1";
130     object["value"] = "1";
131     std::vector<nlohmann::json>myArray;
132     myArray.push_back(object);
133     jsonObject[FILTERS_KEY] = myArray;
134     jsonObject[FILTER_OP_KEY] = "filter_op";
135     std::string str = jsonObject.dump();
136     int32_t ret = filterOption.ParseFilterJson(str);
137     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
138 }
139 
140 HWTEST_F(DiscoveryFilterTest, ParseFilterJson_0010, testing::ext::TestSize.Level0)
141 {
142     DeviceFilterOption filterOption;
143     nlohmann::json jsonObject;
144     nlohmann::json object;
145     object["type"] = "1";
146     object["value"] = 1;
147     std::vector<nlohmann::json>myArray;
148     myArray.push_back(object);
149     jsonObject[FILTERS_KEY] = myArray;
150     jsonObject[FILTER_OP_KEY] = "filter_op";
151     std::string str = jsonObject.dump();
152     int32_t ret = filterOption.ParseFilterJson(str);
153     EXPECT_EQ(ret, DM_OK);
154 }
155 
156 HWTEST_F(DiscoveryFilterTest, ParseFilterOptionJson_001, testing::ext::TestSize.Level0)
157 {
158     DeviceFilterOption filterOption;
159     std::string str;
160     filterOption.ParseFilterOptionJson(str);
161     EXPECT_EQ(filterOption.filterOp_ != "AND", true);
162 }
163 
164 HWTEST_F(DiscoveryFilterTest, ParseFilterOptionJson_002, testing::ext::TestSize.Level0)
165 {
166     DeviceFilterOption filterOption;
167     nlohmann::json jsonObject;
168     std::string str = jsonObject.dump();
169     filterOption.ParseFilterOptionJson(str);
170     EXPECT_EQ(filterOption.filterOp_ == "AND", true);
171 }
172 
173 HWTEST_F(DiscoveryFilterTest, ParseFilterOptionJson_003, testing::ext::TestSize.Level0)
174 {
175     DeviceFilterOption filterOption;
176     nlohmann::json jsonObject;
177     jsonObject["credible"] = "123";
178     std::string str = jsonObject.dump();
179     filterOption.ParseFilterOptionJson(str);
180     EXPECT_EQ(filterOption.filterOp_ == "AND", true);
181 }
182 
183 HWTEST_F(DiscoveryFilterTest, ParseFilterOptionJson_004, testing::ext::TestSize.Level0)
184 {
185     DeviceFilterOption filterOption;
186     nlohmann::json jsonObject;
187     jsonObject["credible"] = 1;
188     jsonObject["isTrusted"] = "123";
189     std::string str = jsonObject.dump();
190     filterOption.ParseFilterOptionJson(str);
191     EXPECT_EQ(filterOption.filterOp_ == "AND", true);
192 }
193 
194 HWTEST_F(DiscoveryFilterTest, ParseFilterOptionJson_005, testing::ext::TestSize.Level0)
195 {
196     DeviceFilterOption filterOption;
197     nlohmann::json jsonObject;
198     jsonObject["credible"] = 1;
199     jsonObject["isTrusted"] = 2;
200     jsonObject["authForm"] = "3";
201     std::string str = jsonObject.dump();
202     filterOption.ParseFilterOptionJson(str);
203     EXPECT_EQ(filterOption.filterOp_ == "AND", true);
204 }
205 
206 HWTEST_F(DiscoveryFilterTest, ParseFilterOptionJson_006, testing::ext::TestSize.Level0)
207 {
208     DeviceFilterOption filterOption;
209     nlohmann::json jsonObject;
210     jsonObject["credible"] = 1;
211     jsonObject["isTrusted"] = 2;
212     jsonObject["authForm"] = 3;
213     jsonObject["deviceType"] = "4";
214     std::string str = jsonObject.dump();
215     filterOption.ParseFilterOptionJson(str);
216     EXPECT_EQ(filterOption.filterOp_ == "AND", true);
217 }
218 
219 HWTEST_F(DiscoveryFilterTest, ParseFilterOptionJson_007, testing::ext::TestSize.Level0)
220 {
221     DeviceFilterOption filterOption;
222     nlohmann::json jsonObject;
223     jsonObject["credible"] = 1;
224     jsonObject["isTrusted"] = 2;
225     jsonObject["authForm"] = 3;
226     jsonObject["deviceType"] = 4;
227     std::string str = jsonObject.dump();
228     filterOption.ParseFilterOptionJson(str);
229     EXPECT_EQ(filterOption.filterOp_ == "AND", true);
230 }
231 
232 HWTEST_F(DiscoveryFilterTest, TransformToFilter_001, testing::ext::TestSize.Level0)
233 {
234     DeviceFilterOption filterOption;
235     std::string filterOptions;
236     int32_t ret = filterOption.TransformToFilter(filterOptions);
237     EXPECT_EQ(ret, DM_OK);
238 }
239 
240 HWTEST_F(DiscoveryFilterTest, TransformToFilter_002, testing::ext::TestSize.Level0)
241 {
242     DeviceFilterOption filterOption;
243     std::string filterOptions = "filterOptions";
244     int32_t ret = filterOption.TransformToFilter(filterOptions);
245     EXPECT_NE(ret, DM_OK);
246 }
247 
248 HWTEST_F(DiscoveryFilterTest, TransformFilterOption_001, testing::ext::TestSize.Level0)
249 {
250     DeviceFilterOption filterOption;
251     std::string filterOptions;
252     filterOption.TransformFilterOption(filterOptions);
253     EXPECT_EQ(filterOptions.empty(), true);
254 }
255 
256 HWTEST_F(DiscoveryFilterTest, TransformFilterOption_002, testing::ext::TestSize.Level0)
257 {
258     DeviceFilterOption filterOption;
259     std::string filterOptions = "filterOptions";
260     filterOption.TransformFilterOption(filterOptions);
261     EXPECT_EQ(filterOptions.empty(), false);
262 }
263 
264 HWTEST_F(DiscoveryFilterTest, FilterByDeviceState_001, testing::ext::TestSize.Level0)
265 {
266     DiscoveryFilter filter;
267     int32_t value = 0;
268     bool isOnline = false;
269     bool ret = filter.FilterByDeviceState(value, isOnline);
270     EXPECT_EQ(ret, true);
271 }
272 
273 HWTEST_F(DiscoveryFilterTest, FilterByDeviceState_002, testing::ext::TestSize.Level0)
274 {
275     DiscoveryFilter filter;
276     int32_t value = 1;
277     bool isOnline = false;
278     bool ret = filter.FilterByDeviceState(value, isOnline);
279     EXPECT_EQ(ret, false);
280 }
281 
282 HWTEST_F(DiscoveryFilterTest, FilterByDeviceState_003, testing::ext::TestSize.Level0)
283 {
284     DiscoveryFilter filter;
285     int32_t value = 2;
286     bool isOnline = false;
287     bool ret = filter.FilterByDeviceState(value, isOnline);
288     EXPECT_EQ(ret, true);
289 }
290 
291 HWTEST_F(DiscoveryFilterTest, FilterByRange_001, testing::ext::TestSize.Level0)
292 {
293     DiscoveryFilter filter;
294     int32_t value = 0;
295     bool isActive = true;
296     bool ret = filter.FilterByRange(value, isActive);
297     EXPECT_EQ(ret, false);
298 }
299 
300 HWTEST_F(DiscoveryFilterTest, FilterByRange_002, testing::ext::TestSize.Level0)
301 {
302     DiscoveryFilter filter;
303     int32_t value = 1;
304     bool isActive = true;
305     bool ret = filter.FilterByRange(value, isActive);
306     EXPECT_EQ(ret, true);
307 }
308 
309 HWTEST_F(DiscoveryFilterTest, FilterByRange_003, testing::ext::TestSize.Level0)
310 {
311     DiscoveryFilter filter;
312     int32_t value = 2;
313     bool isActive = true;
314     bool ret = filter.FilterByRange(value, isActive);
315     EXPECT_EQ(ret, true);
316 }
317 
318 HWTEST_F(DiscoveryFilterTest, FilterByRange_004, testing::ext::TestSize.Level0)
319 {
320     DiscoveryFilter filter;
321     int32_t value = -1;
322     int32_t range = 1;
323     bool ret = filter.FilterByRange(value, range);
324     EXPECT_EQ(ret, false);
325 }
326 
327 HWTEST_F(DiscoveryFilterTest, FilterByRange_005, testing::ext::TestSize.Level0)
328 {
329     DiscoveryFilter filter;
330     int32_t value = 0;
331     int32_t range = -1;
332     bool ret = filter.FilterByRange(value, range);
333     EXPECT_EQ(ret, false);
334 }
335 
336 HWTEST_F(DiscoveryFilterTest, FilterByRange_006, testing::ext::TestSize.Level0)
337 {
338     DiscoveryFilter filter;
339     int32_t value = 1;
340     int32_t range = 1;
341     bool ret = filter.FilterByRange(value, range);
342     EXPECT_EQ(ret, true);
343 }
344 
345 HWTEST_F(DiscoveryFilterTest, FilterByRange_007, testing::ext::TestSize.Level0)
346 {
347     DiscoveryFilter filter;
348     int32_t value = 2;
349     int32_t deviceType = 2;
350     bool ret = filter.FilterByRange(value, deviceType);
351     EXPECT_EQ(ret, true);
352 }
353 
354 HWTEST_F(DiscoveryFilterTest, FilterOr_001, testing::ext::TestSize.Level0)
355 {
356     DiscoveryFilter filter;
357     DeviceFilters filters;
358     filters.type = "typeTest";
359     std::vector<DeviceFilters> filtersVec;
360     filtersVec.push_back(filters);
361     DeviceFilterPara filterPara;
362     bool ret = filter.FilterOr(filtersVec, filterPara);
363     EXPECT_EQ(ret, false);
364 }
365 
366 HWTEST_F(DiscoveryFilterTest, FilterOr_002, testing::ext::TestSize.Level0)
367 {
368     DiscoveryFilter filter;
369     DeviceFilters filters;
370     filters.type = "range";
371     filters.value = 1;
372     std::vector<DeviceFilters> filtersVec;
373     filtersVec.push_back(filters);
374     DeviceFilterPara filterPara;
375     filterPara.range = 1;
376     bool ret = filter.FilterOr(filtersVec, filterPara);
377     EXPECT_EQ(ret, true);
378 }
379 
380 HWTEST_F(DiscoveryFilterTest, FilterOr_003, testing::ext::TestSize.Level0)
381 {
382     DiscoveryFilter filter;
383     DeviceFilters filters;
384     filters.type = "credible";
385     filters.value = 0;
386     std::vector<DeviceFilters> filtersVec;
387     filtersVec.push_back(filters);
388     DeviceFilterPara filterPara;
389     filterPara.isOnline = false;
390     bool ret = filter.FilterOr(filtersVec, filterPara);
391     EXPECT_EQ(ret, true);
392 }
393 
394 HWTEST_F(DiscoveryFilterTest, FilterAnd_001, testing::ext::TestSize.Level0)
395 {
396     DiscoveryFilter filter;
397     DeviceFilters filters;
398     filters.type = "typeTest";
399     std::vector<DeviceFilters> filtersVec;
400     filtersVec.push_back(filters);
401     DeviceFilterPara filterPara;
402     bool ret = filter.FilterAnd(filtersVec, filterPara);
403     EXPECT_EQ(ret, false);
404 }
405 
406 HWTEST_F(DiscoveryFilterTest, FilterAnd_002, testing::ext::TestSize.Level0)
407 {
408     DiscoveryFilter filter;
409     DeviceFilters filters;
410     filters.type = "range";
411     filters.value = 1;
412     std::vector<DeviceFilters> filtersVec;
413     filtersVec.push_back(filters);
414     DeviceFilterPara filterPara;
415     filterPara.range = 1;
416     bool ret = filter.FilterAnd(filtersVec, filterPara);
417     EXPECT_EQ(ret, true);
418 }
419 
420 HWTEST_F(DiscoveryFilterTest, FilterAnd_003, testing::ext::TestSize.Level0)
421 {
422     DiscoveryFilter filter;
423     DeviceFilters filters;
424     filters.type = "credible";
425     filters.value = 0;
426     std::vector<DeviceFilters> filtersVec;
427     filtersVec.push_back(filters);
428     DeviceFilterPara filterPara;
429     filterPara.isOnline = false;
430     bool ret = filter.FilterAnd(filtersVec, filterPara);
431     EXPECT_EQ(ret, true);
432 }
433 
434 HWTEST_F(DiscoveryFilterTest, FilterByType_001, testing::ext::TestSize.Level0)
435 {
436     DeviceFilters filters = {
437         .type = "credible",
438         .value = 0,
439     };
440     DeviceFilterPara filterPara = {
441         .isOnline = true,
442     };
443     DiscoveryFilter filter;
444     bool ret = filter.FilterByType(filters, filterPara);
445     EXPECT_EQ(ret, false);
446 }
447 
448 HWTEST_F(DiscoveryFilterTest, FilterByType_002, testing::ext::TestSize.Level0)
449 {
450     DeviceFilters filters = {
451         .type = "range",
452         .value = 1,
453     };
454     DeviceFilterPara filterPara = {
455         .range = 1,
456     };
457     DiscoveryFilter filter;
458     bool ret = filter.FilterByType(filters, filterPara);
459     EXPECT_EQ(ret, true);
460 }
461 
462 HWTEST_F(DiscoveryFilterTest, FilterByType_003, testing::ext::TestSize.Level0)
463 {
464     DeviceFilters filters = {
465         .type = "isTrusted",
466         .value = 1,
467     };
468     DeviceFilterPara filterPara = {
469         .isTrusted = true,
470     };
471     DiscoveryFilter filter;
472     bool ret = filter.FilterByType(filters, filterPara);
473     EXPECT_EQ(ret, true);
474 }
475 
476 HWTEST_F(DiscoveryFilterTest, FilterByType_004, testing::ext::TestSize.Level0)
477 {
478     DeviceFilters filters = {
479         .type = "deviceType",
480         .value = 1,
481     };
482     DeviceFilterPara filterPara = {
483         .deviceType = 1,
484     };
485     DiscoveryFilter filter;
486     bool ret = filter.FilterByType(filters, filterPara);
487     EXPECT_EQ(ret, true);
488 }
489 
490 HWTEST_F(DiscoveryFilterTest, FilterByType_005, testing::ext::TestSize.Level0)
491 {
492     DeviceFilters filters = {
493         .type = "filterByType",
494         .value = 1,
495     };
496     DeviceFilterPara filterPara = {
497         .deviceType = 1,
498     };
499     DiscoveryFilter filter;
500     bool ret = filter.FilterByType(filters, filterPara);
501     EXPECT_EQ(ret, false);
502 }
503 
504 HWTEST_F(DiscoveryFilterTest, IsValidDevice_001, testing::ext::TestSize.Level0)
505 {
506     DiscoveryFilter filter;
507     const std::string filterOp = "OR";
508     DeviceFilters filters;
509     filters.type = "credible";
510     filters.value = 0;
511     std::vector<DeviceFilters> filtersVec;
512     filtersVec.push_back(filters);
513     DeviceFilterPara filterPara;
514     filterPara.isOnline = false;
515     bool ret = filter.IsValidDevice(filterOp, filtersVec, filterPara);
516     EXPECT_EQ(ret, true);
517 }
518 
519 HWTEST_F(DiscoveryFilterTest, IsValidDevice_002, testing::ext::TestSize.Level0)
520 {
521     DiscoveryFilter filter;
522     const std::string filterOp = "AND";
523     DeviceFilters filters;
524     filters.type = "range";
525     filters.value = 1;
526     std::vector<DeviceFilters> filtersVec;
527     filtersVec.push_back(filters);
528     DeviceFilterPara filterPara;
529     filterPara.range = 1;
530     bool ret = filter.IsValidDevice(filterOp, filtersVec, filterPara);
531     EXPECT_EQ(ret, true);
532 }
533 
534 HWTEST_F(DiscoveryFilterTest, IsValidDevice_003, testing::ext::TestSize.Level0)
535 {
536     DiscoveryFilter filter;
537     const std::string filterOp = "filterOpTest";
538     std::vector<DeviceFilters> filtersVec;
539     DeviceFilterPara filterPara;
540     bool ret = filter.IsValidDevice(filterOp, filtersVec, filterPara);
541     EXPECT_EQ(ret, false);
542 }
543 } // namespace
544 } // namespace DistributedHardware
545 } // namespace OHOS