1 /*
2  * Copyright (C) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #define private public
17 #include <gtest/gtest.h>
18 #include <fstream>
19 #include "attr_data.h"
20 #include "image_type.h"
21 #include "plugin_errors.h"
22 
23 using namespace testing::ext;
24 using namespace OHOS::Media;
25 using namespace OHOS::MultimediaPlugin;
26 namespace OHOS {
27 namespace Multimedia {
28 static const std::string IMAGE_INPUT_JPEG_PATH = "/data/local/tmp/image/test.jpg";
29 static constexpr uint8_t LOWER_BOUND_INDEX = 0;
30 static constexpr uint8_t UPPER_BOUND_INDEX = 1;
31 class AttrDataTest : public testing::Test {
32 public:
AttrDataTest()33     AttrDataTest() {}
~AttrDataTest()34     ~AttrDataTest() {}
35 };
36 
37 /**
38  * @tc.name: AttrDataTest001
39  * @tc.desc: test SetData and ClearData data type is bool
40  * @tc.type: FUNC
41  */
42 HWTEST_F(AttrDataTest, AttrDataTest001, TestSize.Level3)
43 {
44     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest001 start";
45     bool value = false;
46     MultimediaPlugin::AttrData aData(value);
47     bool value1 = false;
48     aData.SetData(value1);
49     ASSERT_EQ(aData.GetValue(value), SUCCESS);
50     aData.ClearData();
51     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest001 end";
52 }
53 
54 /**
55  * @tc.name: AttrDataTest02
56  * @tc.desc: test SetData and ClearData data type is bool
57  * @tc.type: FUNC
58  */
59 HWTEST_F(AttrDataTest, AttrDataTest002, TestSize.Level3)
60 {
61     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest002 start";
62     bool value = true;
63     MultimediaPlugin::AttrData aData(value);
64     bool value1 = true;
65     aData.SetData(value1);
66     ASSERT_EQ(aData.GetValue(value), SUCCESS);
67     aData.ClearData();
68     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest002 end";
69 }
70 
71 /**
72  * @tc.name: AttrDataTest003
73  * @tc.desc: test SetData and ClearData data type is uint32_t
74  * @tc.type: FUNC
75  */
76 HWTEST_F(AttrDataTest, AttrDataTest003, TestSize.Level3)
77 {
78     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest003 start";
79     uint32_t value = 0;
80     MultimediaPlugin::AttrData aData(value);
81     uint32_t value1 = 2;
82     aData.SetData(value1);
83     ASSERT_EQ(aData.GetValue(value), SUCCESS);
84     aData.ClearData();
85     ASSERT_EQ(value, value1);
86     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest003 end";
87 }
88 
89 /**
90  * @tc.name: AttrDataTest004
91  * @tc.desc: test SetData and ClearData data type is std::string
92  * @tc.type: FUNC
93  */
94 HWTEST_F(AttrDataTest, AttrDataTest004, TestSize.Level3)
95 {
96     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest004 start";
97     std::string value = "0";
98     MultimediaPlugin::AttrData aData(value);
99     std::string value1 = "1";
100     uint32_t ret = aData.SetData(value1);
101     ASSERT_EQ(ret, SUCCESS);
102     aData.ClearData();
103     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest004 end";
104 }
105 
106 /**
107  * @tc.name: AttrDataTest005
108  * @tc.desc: test SetData and ClearData data type is std::string
109  * @tc.type: FUNC
110  */
111 HWTEST_F(AttrDataTest, AttrDataTest005, TestSize.Level3)
112 {
113     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest005 start";
114     std::string &&value = "11";
115     MultimediaPlugin::AttrData aData(value);
116     std::string &&value1 = "1";
117     uint32_t ret = aData.SetData(value1);
118     ASSERT_EQ(ret, SUCCESS);
119     aData.ClearData();
120     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest005 end";
121 }
122 
123 /**
124  * @tc.name: AttrDataTest006
125  * @tc.desc: test SetData and ClearData data type is uint32_t and uint32_t
126  * @tc.type: FUNC
127  */
128 HWTEST_F(AttrDataTest, AttrDataTest006, TestSize.Level3)
129 {
130     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest006 start";
131     uint32_t value1 = 0;
132     uint32_t value2 = 1000;
133     MultimediaPlugin::AttrData aData(value1, value2);
134     uint32_t value3 = 0;
135     uint32_t value4 = 1000;
136     uint32_t ret = aData.SetData(value3, value4);
137     ASSERT_EQ(ret, SUCCESS);
138     aData.ClearData();
139     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest006 end";
140 }
141 
142 /**
143  * @tc.name: AttrDataTest007
144  * @tc.desc: test SetData data and ClearData type is uint32_t and uint32_t
145  * @tc.type: FUNC
146  */
147 HWTEST_F(AttrDataTest, AttrDataTest007, TestSize.Level3)
148 {
149     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest007 start";
150     uint32_t value1 = 100;
151     uint32_t value2 = 1;
152     MultimediaPlugin::AttrData aData(value1, value2);
153     uint32_t value3 = 0;
154     uint32_t value4 = 1000;
155     uint32_t ret = aData.SetData(value3, value4);
156     ASSERT_EQ(ret, SUCCESS);
157     aData.ClearData();
158     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest007 end";
159 }
160 
161 /**
162  * @tc.name: AttrDataTest008
163  * @tc.desc: test SetData and ClearData data type is uint32_t and uint32_t
164  * @tc.type: FUNC
165  */
166 HWTEST_F(AttrDataTest, AttrDataTest008, TestSize.Level3)
167 {
168     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest008 start";
169     uint32_t value1 = 0;
170     uint32_t value2 = 1000;
171     MultimediaPlugin::AttrData aData(value1, value2);
172     uint32_t value3 = 1000;
173     uint32_t value4 = 0;
174     uint32_t ret = aData.SetData(value3, value4);
175     ASSERT_NE(ret, SUCCESS);
176     aData.ClearData();
177     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest008 end";
178 }
179 
180 /**
181  * @tc.name: AttrDataTest009
182  * @tc.desc: test InsertSet type is std::string &&
183  * @tc.type: FUNC
184  */
185 HWTEST_F(AttrDataTest, AttrDataTest009, TestSize.Level3)
186 {
187     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest009 start";
188     std::string &&value = "111";
189     MultimediaPlugin::AttrData aData(value);
190     std::string &&value1 = "1111";
191     uint32_t ret = aData.SetData(value1);
192     ASSERT_EQ(ret, SUCCESS);
193     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest009 end";
194 }
195 
196 /**
197  * @tc.name: AttrDataTest0010
198  * @tc.desc: test InsertSet type is uint32_t
199  * @tc.type: FUNC
200  */
201 HWTEST_F(AttrDataTest, AttrDataTest0010, TestSize.Level3)
202 {
203     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0010 start";
204     MultimediaPlugin::AttrData aData;
205     uint32_t value = 0;
206     uint32_t ret = aData.InsertSet(value);
207     ASSERT_EQ(ret, SUCCESS);
208     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0010 end";
209 }
210 
211 /**
212  * @tc.name: AttrDataTest0011
213  * @tc.desc: test InsertSet type is uint32_t
214  * @tc.type: FUNC
215  */
216 HWTEST_F(AttrDataTest, AttrDataTest0011, TestSize.Level3)
217 {
218     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0011 start";
219     MultimediaPlugin::AttrData aData;
220     uint32_t value = 1;
221     uint32_t ret = aData.InsertSet(value);
222     ASSERT_EQ(ret, SUCCESS);
223     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0011 end";
224 }
225 
226 /**
227  * @tc.name: AttrDataTest0012
228  * @tc.desc: test InsertSet type is std::string
229  * @tc.type: FUNC
230  */
231 HWTEST_F(AttrDataTest, AttrDataTest0012, TestSize.Level3)
232 {
233     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0012 start";
234     std::string value = "111";
235     MultimediaPlugin::AttrData aData(value);
236     uint32_t ret = aData.InsertSet(value);
237     ASSERT_EQ(ret, ERR_UNSUPPORTED);
238     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0012 end";
239 }
240 
241 /**
242  * @tc.name: AttrDataTest0013
243  * @tc.desc: test InsertSet type is std::string
244  * @tc.type: FUNC
245  */
246 HWTEST_F(AttrDataTest, AttrDataTest0013, TestSize.Level3)
247 {
248     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0013 start";
249     std::string value = "111";
250     MultimediaPlugin::AttrData aData;
251     uint32_t ret = aData.InsertSet(value);
252     ASSERT_EQ(ret, SUCCESS);
253     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0013 end";
254 }
255 
256 /**
257  * @tc.name: AttrDataTest0014
258  * @tc.desc: test InsertSet type is std::string
259  * @tc.type: FUNC
260  */
261 HWTEST_F(AttrDataTest, AttrDataTest0014, TestSize.Level3)
262 {
263     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0014 start";
264     std::string value = "";
265     MultimediaPlugin::AttrData aData;
266     uint32_t ret = aData.InsertSet(value);
267     ASSERT_EQ(ret, SUCCESS);
268     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0014 end";
269 }
270 
271 /**
272  * @tc.name: AttrDataTest0015
273  * @tc.desc: test InsertSet type is std::string
274  * @tc.type: FUNC
275  */
276 HWTEST_F(AttrDataTest, AttrDataTest0015, TestSize.Level3)
277 {
278     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0015 start";
279     std::string &&value = "11";
280     MultimediaPlugin::AttrData aData(value);
281     uint32_t ret = aData.InsertSet(value);
282     ASSERT_EQ(ret, ERR_UNSUPPORTED);
283     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0015 end";
284 }
285 
286 /**
287  * @tc.name: AttrDataTest0016
288  * @tc.desc: test InsertSet type is std::string
289  * @tc.type: FUNC
290  */
291 HWTEST_F(AttrDataTest, AttrDataTest0016, TestSize.Level3)
292 {
293     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0016 start";
294     std::string &&value = "11";
295     MultimediaPlugin::AttrData aData;
296     uint32_t ret = aData.InsertSet(value);
297     ASSERT_EQ(ret, SUCCESS);
298     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0016 end";
299 }
300 
301 /**
302  * @tc.name: AttrDataTest0017
303  * @tc.desc: test InRange type is bool
304  * @tc.type: FUNC
305  */
306 HWTEST_F(AttrDataTest, AttrDataTest0017, TestSize.Level3)
307 {
308     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0017 start";
309     MultimediaPlugin::AttrData aData(true);
310     bool value = true;
311     bool ret = aData.InRange(value);
312     ASSERT_EQ(ret, true);
313     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0017 end";
314 }
315 
316 /**
317  * @tc.name: AttrDataTest0018
318  * @tc.desc: test InRange type is bool
319  * @tc.type: FUNC
320  */
321 HWTEST_F(AttrDataTest, AttrDataTest0018, TestSize.Level3)
322 {
323     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0018 start";
324     MultimediaPlugin::AttrData aData;
325     bool value = false;
326     bool ret = aData.InRange(value);
327     ASSERT_EQ(ret, false);
328     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0018 end";
329 }
330 
331 /**
332  * @tc.name: AttrDataTest0019
333  * @tc.desc: test InRange type is uint32_t
334  * @tc.type: FUNC
335  */
336 HWTEST_F(AttrDataTest, AttrDataTest0019, TestSize.Level3)
337 {
338     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0019 start";
339     uint32_t value = 11;
340     MultimediaPlugin::AttrData aData(value);
341     uint32_t value1 = 1;
342     bool ret = aData.InRange(value1);
343     ASSERT_EQ(ret, false);
344     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0019 end";
345 }
346 
347 /**
348  * @tc.name: AttrDataTest0020
349  * @tc.desc: test InRange type is uint32_t
350  * @tc.type: FUNC
351  */
352 HWTEST_F(AttrDataTest, AttrDataTest0020, TestSize.Level3)
353 {
354     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0020 start";
355     MultimediaPlugin::AttrData aData;
356     uint32_t value = 1;
357     bool ret = aData.InRange(value);
358     ASSERT_EQ(ret, false);
359     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0020 end";
360 }
361 
362 /**
363  * @tc.name: AttrDataTest0021
364  * @tc.desc: test InRange type is std::string
365  * @tc.type: FUNC
366  */
367 HWTEST_F(AttrDataTest, AttrDataTest0021, TestSize.Level3)
368 {
369     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0021 start";
370     std::string value = "1";
371     MultimediaPlugin::AttrData aData(value);
372     std::string value1 = "11";
373     bool ret = aData.InRange(value1);
374     ASSERT_EQ(ret, false);
375     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0021 end";
376 }
377 
378 /**
379  * @tc.name: AttrDataTest0022
380  * @tc.desc: test InRange type is std::string
381  * @tc.type: FUNC
382  */
383 HWTEST_F(AttrDataTest, AttrDataTest0022, TestSize.Level3)
384 {
385     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0022 start";
386     MultimediaPlugin::AttrData aData;
387     std::string value1 = "11";
388     bool ret = aData.InRange(value1);
389     ASSERT_EQ(ret, false);
390     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0022 end";
391 }
392 
393 /**
394  * @tc.name: AttrDataTest0023
395  * @tc.desc: test InRange type is MultimediaPlugin::AttrData
396  * @tc.type: FUNC
397  */
398 HWTEST_F(AttrDataTest, AttrDataTest0023, TestSize.Level3)
399 {
400     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0023 start";
401     MultimediaPlugin::AttrData aData;
402     MultimediaPlugin::AttrData data;
403     MultimediaPlugin::AttrData aData1(data);
404     bool ret = aData.InRange(aData1);
405     ASSERT_EQ(ret, true);
406     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0023 end";
407 }
408 
409 /**
410  * @tc.name: AttrDataTest0024
411  * @tc.desc: test InRange type is MultimediaPlugin::AttrData
412  * @tc.type: FUNC
413  */
414 HWTEST_F(AttrDataTest, AttrDataTest0024, TestSize.Level3)
415 {
416     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0024 start";
417     MultimediaPlugin::AttrData aData;
418     MultimediaPlugin::AttrData aData1;
419     bool ret = aData.InRange(aData1);
420     ASSERT_EQ(ret, true);
421     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0024 end";
422 }
423 
424 /**
425  * @tc.name: AttrDataTest0025
426  * @tc.desc: test GetType
427  * @tc.type: FUNC
428  */
429 HWTEST_F(AttrDataTest, AttrDataTest0025, TestSize.Level3)
430 {
431     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0025 start";
432     MultimediaPlugin::AttrData aData;
433     AttrDataType type = aData.GetType();
434     ASSERT_EQ(type, AttrDataType::ATTR_DATA_NULL);
435     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0025 end";
436 }
437 
438 /**
439  * @tc.name: AttrDataTest0026
440  * @tc.desc: test GetMinValue and data type is uint32_t
441  * @tc.type: FUNC
442  */
443 HWTEST_F(AttrDataTest, AttrDataTest0026, TestSize.Level3)
444 {
445     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0026 start";
446     uint32_t value = 1;
447     MultimediaPlugin::AttrData aData(value);
448     uint32_t v;
449     uint32_t ret = aData.GetMinValue(v);
450     ASSERT_EQ(ret, SUCCESS);
451     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0026 end";
452 }
453 
454 /**
455  * @tc.name: AttrDataTest0027
456  * @tc.desc: test GetMinValue and data type is uint32_t
457  * @tc.type: FUNC
458  */
459 HWTEST_F(AttrDataTest, AttrDataTest0027, TestSize.Level3)
460 {
461     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0027 start";
462     MultimediaPlugin::AttrData aData;
463     uint32_t v;
464     uint32_t ret = aData.GetMinValue(v);
465     ASSERT_EQ(ret, ERR_INVALID_PARAMETER);
466     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0027 end";
467 }
468 
469 /**
470  * @tc.name: AttrDataTest0028
471  * @tc.desc: test GetMaxValue and data type is uint32_t
472  * @tc.type: FUNC
473  */
474 HWTEST_F(AttrDataTest, AttrDataTest0028, TestSize.Level3)
475 {
476     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0028 start";
477     uint32_t value = 1;
478     MultimediaPlugin::AttrData aData(value);
479     uint32_t v;
480     uint32_t ret = aData.GetMaxValue(v);
481     ASSERT_EQ(ret, SUCCESS);
482     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0028 end";
483 }
484 
485 /**
486  * @tc.name: AttrDataTest0029
487  * @tc.desc: test GetMaxValue and data type is uint32_t
488  * @tc.type: FUNC
489  */
490 HWTEST_F(AttrDataTest, AttrDataTest0029, TestSize.Level3)
491 {
492     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0029 start";
493     MultimediaPlugin::AttrData aData;
494     uint32_t v;
495     uint32_t ret = aData.GetMaxValue(v);
496     ASSERT_EQ(ret, ERR_INVALID_PARAMETER);
497     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0029 end";
498 }
499 
500 /**
501  * @tc.name: AttrDataTest0030
502  * @tc.desc: test InsertSet type is std::string
503  * @tc.type: FUNC
504  */
505 HWTEST_F(AttrDataTest, AttrDataTest0030, TestSize.Level3)
506 {
507     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0030 start";
508     uint32_t value1 = 0;
509     uint32_t value2 = 1000;
510     MultimediaPlugin::AttrData aData(value1, value2);
511     uint32_t value3 = 0;
512     uint32_t value4 = 1000;
513     uint32_t ret = aData.SetData(value3, value4);
514     ASSERT_EQ(ret, SUCCESS);
515     uint32_t value0 = 1;
516     bool res = aData.InRange(value0);
517     ASSERT_EQ(res, true);
518     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0030 end";
519 }
520 
521 /**
522  * @tc.name: AttrDataTest0031
523  * @tc.desc: test InsertSet type is std::string
524  * @tc.type: FUNC
525  */
526 HWTEST_F(AttrDataTest, AttrDataTest0031, TestSize.Level3)
527 {
528     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0031 start";
529     MultimediaPlugin::AttrData aData;
530     std::string value = "1";
531     uint32_t ret = aData.InsertSet(value);
532     ASSERT_EQ(ret, SUCCESS);
533     std::string value1 = "11";
534     bool res = aData.InRange(value1);
535     ASSERT_EQ(res, false);
536     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0031 end";
537 }
538 
539 /**
540  * @tc.name: AttrDataTest0033
541  * @tc.desc: test GetValue and data type is bool
542  * @tc.type: FUNC
543  */
544 HWTEST_F(AttrDataTest, AttrDataTest0033, TestSize.Level3)
545 {
546     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0033 start";
547     bool value = true;
548     MultimediaPlugin::AttrData aData(value);
549     bool v;
550     uint32_t ret = aData.GetValue(v);
551     ASSERT_EQ(ret, SUCCESS);
552     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0033 end";
553 }
554 
555 /**
556  * @tc.name: AttrDataTest0034
557  * @tc.desc: test GetValue and data type is bool
558  * @tc.type: FUNC
559  */
560 HWTEST_F(AttrDataTest, AttrDataTest0034, TestSize.Level3)
561 {
562     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0034 start";
563     MultimediaPlugin::AttrData aData;
564     bool v;
565     uint32_t ret = aData.GetValue(v);
566     ASSERT_EQ(ret, ERR_INVALID_PARAMETER);
567     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0034 end";
568 }
569 
570 /**
571  * @tc.name: AttrDataTest0035
572  * @tc.desc: test GetValue and data type is uint32_t
573  * @tc.type: FUNC
574  */
575 HWTEST_F(AttrDataTest, AttrDataTest0035, TestSize.Level3)
576 {
577     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0035 start";
578     uint32_t value = 1;
579     MultimediaPlugin::AttrData aData(value);
580     uint32_t v;
581     uint32_t ret = aData.GetValue(v);
582     ASSERT_EQ(ret, SUCCESS);
583     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0035 end";
584 }
585 
586 /**
587  * @tc.name: AttrDataTest0036
588  * @tc.desc: test GetValue and data type is uint32_t
589  * @tc.type: FUNC
590  */
591 HWTEST_F(AttrDataTest, AttrDataTest0036, TestSize.Level3)
592 {
593     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0036 start";
594     MultimediaPlugin::AttrData aData;
595     uint32_t v;
596     uint32_t ret = aData.GetValue(v);
597     ASSERT_EQ(ret, ERR_INVALID_PARAMETER);
598     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0036 end";
599 }
600 
601 /**
602  * @tc.name: AttrDataTest0037
603  * @tc.desc: test GetValue and data type is std::string
604  * @tc.type: FUNC
605  */
606 HWTEST_F(AttrDataTest, AttrDataTest0037, TestSize.Level3)
607 {
608     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0037 start";
609     std::string value = "1";
610     MultimediaPlugin::AttrData aData(value);
611     std::string v;
612     uint32_t ret = aData.GetValue(v);
613     ASSERT_EQ(ret, SUCCESS);
614     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0037 end";
615 }
616 
617 /**
618  * @tc.name: AttrDataTest0038
619  * @tc.desc: test GetValue and data type is std::string
620  * @tc.type: FUNC
621  */
622 HWTEST_F(AttrDataTest, AttrDataTest0038, TestSize.Level3)
623 {
624     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0038 start";
625     MultimediaPlugin::AttrData aData;
626     std::string v;
627     uint32_t ret = aData.GetValue(v);
628     ASSERT_EQ(ret, ERR_INVALID_PARAMETER);
629     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0038 end";
630 }
631 
632 /**
633  * @tc.name: AttrDataTest0039
634  * @tc.desc: test GetValue and data type is std::string
635  * @tc.type: FUNC
636  */
637 HWTEST_F(AttrDataTest, AttrDataTest0039, TestSize.Level3)
638 {
639     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0039 start";
640     MultimediaPlugin::AttrData aData;
641     bool value = true;
642     bool value1 = false;
643     aData.SetData(value1);
644     MultimediaPlugin::AttrData aData1(aData);
645     ASSERT_EQ(aData1.GetValue(value), SUCCESS);
646     ASSERT_EQ(value, value1);
647     aData1.ClearData();
648     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0039 end";
649 }
650 
651 /**
652  * @tc.name: AttrDataTest0040
653  * @tc.desc: test GetValue and data type is uint32_t
654  * @tc.type: FUNC
655  */
656 HWTEST_F(AttrDataTest, AttrDataTest0040, TestSize.Level3)
657 {
658     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0040 start";
659     uint32_t value = 0;
660     uint32_t value1 = 1;
661     MultimediaPlugin::AttrData aData(value);
662     MultimediaPlugin::AttrData aData1(aData);
663     ASSERT_EQ(aData1.GetValue(value1), SUCCESS);
664     ASSERT_EQ(value, value1);
665     aData1.ClearData();
666     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0040 end";
667 }
668 
669 /**
670  * @tc.name: AttrDataTest0041
671  * @tc.desc: test InsertSet type is uint32_t
672  * @tc.type: FUNC
673  */
674 HWTEST_F(AttrDataTest, AttrDataTest0041, TestSize.Level3)
675 {
676     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0041 start";
677     MultimediaPlugin::AttrData aData;
678     uint32_t value = 0;
679     uint32_t ret = aData.InsertSet(value);
680     ASSERT_EQ(ret, SUCCESS);
681     MultimediaPlugin::AttrData aData1(aData);
682     aData1.ClearData();
683     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0041 end";
684 }
685 
686 /**
687  * @tc.name: AttrDataTest0042
688  * @tc.desc: test InsertSet type is std::string
689  * @tc.type: FUNC
690  */
691 HWTEST_F(AttrDataTest, AttrDataTest0042, TestSize.Level3)
692 {
693     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0042 start";
694     std::string value = "111";
695     MultimediaPlugin::AttrData aData;
696     uint32_t ret = aData.InsertSet(value);
697     ASSERT_EQ(ret, SUCCESS);
698     MultimediaPlugin::AttrData aData1(aData);
699     aData1.ClearData();
700     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0042 end";
701 }
702 
703 /**
704  * @tc.name: AttrDataTest0043
705  * @tc.desc: test SetData and ClearData data type is uint32_t and uint32_t
706  * @tc.type: FUNC
707  */
708 HWTEST_F(AttrDataTest, AttrDataTest0043, TestSize.Level3)
709 {
710     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0043 start";
711     uint32_t value1 = 0;
712     uint32_t value2 = 1000;
713     MultimediaPlugin::AttrData aData(value1, value2);
714     uint32_t value3 = 0;
715     uint32_t value4 = 1000;
716     uint32_t ret = aData.SetData(value3, value4);
717     ASSERT_EQ(ret, SUCCESS);
718     MultimediaPlugin::AttrData aData1(aData);
719     aData1.ClearData();
720     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0043 end";
721 }
722 
723 /**
724  * @tc.name: AttrDataTest0044
725  * @tc.desc: test InsertSet type is std::string
726  * @tc.type: FUNC
727  */
728 HWTEST_F(AttrDataTest, AttrDataTest0044, TestSize.Level3)
729 {
730     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0044 start";
731     MultimediaPlugin::AttrData aData;
732     uint32_t value = 0;
733     uint32_t ret = aData.InsertSet(value);
734     ASSERT_EQ(ret, SUCCESS);
735     const std::string value1 = "111";
736     aData.SetData(value1);
737     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0044 end";
738 }
739 
740 /**
741  * @tc.name: AttrDataTest0045
742  * @tc.desc: test InsertSet type is std::string
743  * @tc.type: FUNC
744  */
745 HWTEST_F(AttrDataTest, AttrDataTest0045, TestSize.Level3)
746 {
747     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0045 start";
748     std::string value1 = "111";
749     MultimediaPlugin::AttrData aData(value1);
750     uint32_t value = 0;
751     uint32_t ret = aData.InsertSet(value);
752     ASSERT_EQ(ret, ERR_UNSUPPORTED);
753     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0045 end";
754 }
755 
756 /**
757  * @tc.name: AttrDataTest0046
758  * @tc.desc: test InsertSet type is std::string
759  * @tc.type: FUNC
760  */
761 HWTEST_F(AttrDataTest, AttrDataTest0046, TestSize.Level3)
762 {
763     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0046 start";
764     MultimediaPlugin::AttrData aData;
765     uint32_t value = 0;
766     uint32_t ret = aData.InsertSet(value);
767     ASSERT_EQ(ret, SUCCESS);
768     uint32_t value1 = 1;
769     bool res = aData.InRange(value1);
770     ASSERT_EQ(res, false);
771     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0046 end";
772 }
773 
774 /**
775  * @tc.name: AttrDataTest0047
776  * @tc.desc: test InsertSet type is std::string
777  * @tc.type: FUNC
778  */
779 HWTEST_F(AttrDataTest, AttrDataTest0047, TestSize.Level3)
780 {
781     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0047 start";
782     std::string value = "111";
783     MultimediaPlugin::AttrData aData;
784     uint32_t ret = aData.InsertSet(value);
785     ASSERT_EQ(ret, SUCCESS);
786     uint32_t res = aData.InsertSet(value);
787     ASSERT_EQ(res, ERR_INTERNAL);
788     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0047 end";
789 }
790 
791 /**
792  * @tc.name: AttrDataTest0048
793  * @tc.desc: test InsertSet type is uint32_t
794  * @tc.type: FUNC
795  */
796 HWTEST_F(AttrDataTest, AttrDataTest0048, TestSize.Level3)
797 {
798     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0048 start";
799     uint32_t value = 1;
800     MultimediaPlugin::AttrData aData;
801     uint32_t ret = aData.InsertSet(value);
802     ASSERT_EQ(ret, SUCCESS);
803     uint32_t res = aData.InsertSet(value);
804     ASSERT_EQ(res, ERR_GENERAL);
805     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0048 end";
806 }
807 
808 /**
809  * @tc.name: AttrDataTest0049
810  * @tc.desc: test InsertSet type is std::string
811  * @tc.type: FUNC
812  */
813 HWTEST_F(AttrDataTest, AttrDataTest0049, TestSize.Level3)
814 {
815     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0049 start";
816     std::string value = "111";
817     std::string value1 = "1111";
818     MultimediaPlugin::AttrData aData;
819     uint32_t ret = aData.InsertSet(value);
820     ASSERT_EQ(ret, SUCCESS);
821     uint32_t res = aData.InsertSet(value1);
822     ASSERT_EQ(res, SUCCESS);
823     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0049 end";
824 }
825 
826 /**
827  * @tc.name: AttrDataTest0050
828  * @tc.desc: test InsertSet type is uint32_t
829  * @tc.type: FUNC
830  */
831 HWTEST_F(AttrDataTest, AttrDataTest0050, TestSize.Level3)
832 {
833     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0050 start";
834     uint32_t value = 1;
835     uint32_t value1 = 11;
836     MultimediaPlugin::AttrData aData;
837     uint32_t ret = aData.InsertSet(value);
838     ASSERT_EQ(ret, SUCCESS);
839     uint32_t res = aData.InsertSet(value1);
840     ASSERT_EQ(res, SUCCESS);
841     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0050 end";
842 }
843 
844 /**
845  * @tc.name: AttrDataTest0051
846  * @tc.desc: test InsertSet type is std::string &&
847  * @tc.type: FUNC
848  */
849 HWTEST_F(AttrDataTest, AttrDataTest0051, TestSize.Level3)
850 {
851     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0051 start";
852     std::string &&value = "111";
853     MultimediaPlugin::AttrData aData;
854     uint32_t ret = aData.InsertSet(value);
855     ASSERT_EQ(ret, SUCCESS);
856     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0051 end";
857 }
858 
859 /**
860  * @tc.name: AttrDataTest0052
861  * @tc.desc: test InsertSet type is std::string &&
862  * @tc.type: FUNC
863  */
864 HWTEST_F(AttrDataTest, AttrDataTest0052, TestSize.Level3)
865 {
866     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0052 start";
867     std::string &&value = "111";
868     MultimediaPlugin::AttrData aData;
869     uint32_t ret = aData.InsertSet(value);
870     ASSERT_EQ(ret, SUCCESS);
871     uint32_t res = aData.InsertSet(value);
872     ASSERT_EQ(res, ERR_INTERNAL);
873     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0052 end";
874 }
875 
876 /**
877  * @tc.name: AttrDataTest0053
878  * @tc.desc: test InsertSet type is std::string &&
879  * @tc.type: FUNC
880  */
881 HWTEST_F(AttrDataTest, AttrDataTest0053, TestSize.Level3)
882 {
883     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0053 start";
884     std::string &&value = "111";
885     std::string &&value1 = "1111";
886     MultimediaPlugin::AttrData aData;
887     uint32_t ret = aData.InsertSet(value);
888     ASSERT_EQ(ret, SUCCESS);
889     uint32_t res = aData.InsertSet(value1);
890     ASSERT_EQ(res, SUCCESS);
891     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0053 end";
892 }
893 
894 /**
895  * @tc.name: AttrDataTest0054
896  * @tc.desc: test InsertSet type is std::string
897  * @tc.type: FUNC
898  */
899 HWTEST_F(AttrDataTest, AttrDataTest0054, TestSize.Level3)
900 {
901     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0054 start";
902     uint32_t value = 0;
903     MultimediaPlugin::AttrData aData(value);
904     std::string &&value1 = "111";
905     uint32_t ret = aData.InsertSet(value1);
906     ASSERT_EQ(ret, ERR_UNSUPPORTED);
907     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0054 end";
908 }
909 
910 /**
911  * @tc.name: AttrDataTest0055
912  * @tc.desc: test InsertSet type is std::string
913  * @tc.type: FUNC
914  */
915 HWTEST_F(AttrDataTest, AttrDataTest0055, TestSize.Level3)
916 {
917     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0055 start";
918     MultimediaPlugin::AttrData aData;
919     std::string value = "1";
920     uint32_t ret = aData.InsertSet(value);
921     ASSERT_EQ(ret, SUCCESS);
922     MultimediaPlugin::AttrData aData1;
923     bool res = aData1.InRange(aData);
924     ASSERT_EQ(res, false);
925     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0055 end";
926 }
927 
928 /**
929  * @tc.name: AttrDataTest0055
930  * @tc.desc: test InsertSet type is std::string
931  * @tc.type: FUNC
932  */
933 HWTEST_F(AttrDataTest, AttrDataTest0056, TestSize.Level3)
934 {
935     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0055 start";
936     MultimediaPlugin::AttrData aData;
937     uint32_t value = 1;
938     uint32_t ret = aData.InsertSet(value);
939     ASSERT_EQ(ret, SUCCESS);
940     MultimediaPlugin::AttrData aData1;
941     bool res = aData1.InRange(aData);
942     ASSERT_EQ(res, false);
943     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0056 end";
944 }
945 
946 /**
947  * @tc.name: AttrDataTest0057
948  * @tc.desc: test InsertSet type is std::string
949  * @tc.type: FUNC
950  */
951 HWTEST_F(AttrDataTest, AttrDataTest0057, TestSize.Level3)
952 {
953     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0057 start";
954     std::string value = "1";
955     MultimediaPlugin::AttrData aData(value);
956     MultimediaPlugin::AttrData aData1;
957     bool res = aData1.InRange(aData);
958     ASSERT_EQ(res, false);
959     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0057 end";
960 }
961 
962 /**
963  * @tc.name: AttrDataTest0058
964  * @tc.desc: test InsertSet type is std::string
965  * @tc.type: FUNC
966  */
967 HWTEST_F(AttrDataTest, AttrDataTest0058, TestSize.Level3)
968 {
969     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0058 start";
970     uint32_t value = 1;
971     MultimediaPlugin::AttrData aData(value);
972     MultimediaPlugin::AttrData aData1;
973     bool res = aData1.InRange(aData);
974     ASSERT_EQ(res, false);
975     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0058 end";
976 }
977 
978 /**
979  * @tc.name: AttrDataTest0059
980  * @tc.desc: test InsertSet type is std::string
981  * @tc.type: FUNC
982  */
983 HWTEST_F(AttrDataTest, AttrDataTest0059, TestSize.Level3)
984 {
985     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0059 start";
986     bool value = true;
987     MultimediaPlugin::AttrData aData(value);
988     MultimediaPlugin::AttrData aData1;
989     bool res = aData1.InRange(aData);
990     ASSERT_EQ(res, false);
991     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0059 end";
992 }
993 
994 /**
995  * @tc.name: AttrDataTest0060
996  * @tc.desc: test InsertSet type is range
997  * @tc.type: FUNC
998  */
999 HWTEST_F(AttrDataTest, AttrDataTest0060, TestSize.Level3)
1000 {
1001     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0060 start";
1002     uint32_t value1 = 0;
1003     uint32_t value2 = 1000;
1004     MultimediaPlugin::AttrData aData(value1, value2);
1005     uint32_t value3 = 0;
1006     uint32_t value4 = 1000;
1007     uint32_t ret = aData.SetData(value3, value4);
1008     ASSERT_EQ(ret, SUCCESS);
1009     MultimediaPlugin::AttrData aData1;
1010     bool res = aData1.InRange(aData);
1011     ASSERT_EQ(res, false);
1012     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0060 end";
1013 }
1014 
1015 /**
1016  * @tc.name: AttrDataTest0061
1017  * @tc.desc: test GetMinValue and data type is uint32_t range
1018  * @tc.type: FUNC
1019  */
1020 HWTEST_F(AttrDataTest, AttrDataTest0061, TestSize.Level3)
1021 {
1022     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0061 start";
1023     uint32_t value1 = 0;
1024     uint32_t value2 = 1000;
1025     MultimediaPlugin::AttrData aData(value1, value2);
1026     uint32_t value3 = 0;
1027     uint32_t value4 = 1000;
1028     uint32_t ret = aData.SetData(value3, value4);
1029     ASSERT_EQ(ret, SUCCESS);
1030     uint32_t v;
1031     uint32_t res = aData.GetMinValue(v);
1032     ASSERT_EQ(res, SUCCESS);
1033     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0061 end";
1034 }
1035 
1036 /**
1037  * @tc.name: AttrDataTest0062
1038  * @tc.desc: test GetMinValue and data type is uint32_t set
1039  * @tc.type: FUNC
1040  */
1041 HWTEST_F(AttrDataTest, AttrDataTest0062, TestSize.Level3)
1042 {
1043     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0062 start";
1044     MultimediaPlugin::AttrData aData;
1045     uint32_t value = 1;
1046     uint32_t ret = aData.InsertSet(value);
1047     ASSERT_EQ(ret, SUCCESS);
1048     uint32_t v;
1049     uint32_t res = aData.GetMinValue(v);
1050     ASSERT_EQ(res, SUCCESS);
1051     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0062 end";
1052 }
1053 
1054 /**
1055  * @tc.name: AttrDataTest0063
1056  * @tc.desc: test GetMaxValue and data type is uint32_t range
1057  * @tc.type: FUNC
1058  */
1059 HWTEST_F(AttrDataTest, AttrDataTest0063, TestSize.Level3)
1060 {
1061     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0063 start";
1062     uint32_t value1 = 0;
1063     uint32_t value2 = 1000;
1064     MultimediaPlugin::AttrData aData(value1, value2);
1065     uint32_t value3 = 0;
1066     uint32_t value4 = 1000;
1067     uint32_t ret = aData.SetData(value3, value4);
1068     ASSERT_EQ(ret, SUCCESS);
1069     uint32_t v;
1070     uint32_t res = aData.GetMaxValue(v);
1071     ASSERT_EQ(res, SUCCESS);
1072     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0063 end";
1073 }
1074 
1075 /**
1076  * @tc.name: AttrDataTest0064
1077  * @tc.desc: test GetMaxValue and data type is uint32_t set
1078  * @tc.type: FUNC
1079  */
1080 HWTEST_F(AttrDataTest, AttrDataTest0064, TestSize.Level3)
1081 {
1082     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0064 start";
1083     MultimediaPlugin::AttrData aData;
1084     uint32_t value = 1;
1085     uint32_t ret = aData.InsertSet(value);
1086     ASSERT_EQ(ret, SUCCESS);
1087     uint32_t v;
1088     uint32_t res = aData.GetMaxValue(v);
1089     ASSERT_EQ(res, SUCCESS);
1090     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0064 end";
1091 }
1092 
1093 /**
1094  * @tc.name: AttrDataTest0065
1095  * @tc.desc: test GetMinValue and data type is uint32_t set
1096  * @tc.type: FUNC
1097  */
1098 HWTEST_F(AttrDataTest, AttrDataTest0065, TestSize.Level3)
1099 {
1100     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0065 start";
1101     MultimediaPlugin::AttrData aData;
1102     uint32_t value = 1;
1103     uint32_t ret = aData.InsertSet(value);
1104     ASSERT_EQ(ret, SUCCESS);
1105     const string *value1 = nullptr;
1106     uint32_t res = aData.GetMinValue(value1);
1107     ASSERT_EQ(res, ERR_INVALID_PARAMETER);
1108     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0065 end";
1109 }
1110 
1111 /**
1112  * @tc.name: AttrDataTest0066
1113  * @tc.desc: test GetMinValue and data type is string set
1114  * @tc.type: FUNC
1115  */
1116 HWTEST_F(AttrDataTest, AttrDataTest0066, TestSize.Level3)
1117 {
1118     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0066 start";
1119     MultimediaPlugin::AttrData aData;
1120     std::string value = "111";
1121     uint32_t ret = aData.InsertSet(value);
1122     ASSERT_EQ(ret, SUCCESS);
1123     const string *value1 = nullptr;
1124     uint32_t res = aData.GetMinValue(value1);
1125     ASSERT_EQ(res, SUCCESS);
1126     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0066 end";
1127 }
1128 
1129 /**
1130  * @tc.name: AttrDataTest0067
1131  * @tc.desc: test GetMinValue and data type is string
1132  * @tc.type: FUNC
1133  */
1134 HWTEST_F(AttrDataTest, AttrDataTest0067, TestSize.Level3)
1135 {
1136     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0067 start";
1137     std::string value = "111";
1138     MultimediaPlugin::AttrData aData(value);
1139     const string *value1 = nullptr;
1140     uint32_t res = aData.GetMinValue(value1);
1141     ASSERT_EQ(res, SUCCESS);
1142     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0067 end";
1143 }
1144 
1145 /**
1146  * @tc.name: AttrDataTest0068
1147  * @tc.desc: test GetMaxValue and data type is uint32_t set
1148  * @tc.type: FUNC
1149  */
1150 HWTEST_F(AttrDataTest, AttrDataTest0068, TestSize.Level3)
1151 {
1152     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0068 start";
1153     MultimediaPlugin::AttrData aData;
1154     uint32_t value = 1;
1155     uint32_t ret = aData.InsertSet(value);
1156     ASSERT_EQ(ret, SUCCESS);
1157     const string *value1 = nullptr;
1158     uint32_t res = aData.GetMaxValue(value1);
1159     ASSERT_EQ(res, ERR_INVALID_PARAMETER);
1160     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0068 end";
1161 }
1162 
1163 /**
1164  * @tc.name: AttrDataTest0069
1165  * @tc.desc: test GetMaxValue and data type is string set
1166  * @tc.type: FUNC
1167  */
1168 HWTEST_F(AttrDataTest, AttrDataTest0069, TestSize.Level3)
1169 {
1170     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0069 start";
1171     MultimediaPlugin::AttrData aData;
1172     std::string value = "111";
1173     uint32_t ret = aData.InsertSet(value);
1174     ASSERT_EQ(ret, SUCCESS);
1175     const string *value1 = nullptr;
1176     uint32_t res = aData.GetMaxValue(value1);
1177     ASSERT_EQ(res, SUCCESS);
1178     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0069 end";
1179 }
1180 
1181 /**
1182  * @tc.name: AttrDataTest0070
1183  * @tc.desc: test GetMaxValue and data type is string
1184  * @tc.type: FUNC
1185  */
1186 HWTEST_F(AttrDataTest, AttrDataTest0070, TestSize.Level3)
1187 {
1188     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0070 start";
1189     std::string value = "111";
1190     MultimediaPlugin::AttrData aData(value);
1191     const string *value1 = nullptr;
1192     uint32_t res = aData.GetMaxValue(value1);
1193     ASSERT_EQ(res, SUCCESS);
1194     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0070 end";
1195 }
1196 
1197 /**
1198  * @tc.name: AttrDataTest0071
1199  * @tc.desc: test GetMaxValue and data type is string
1200  * @tc.type: FUNC
1201  */
1202 HWTEST_F(AttrDataTest, AttrDataTest0071, TestSize.Level3)
1203 {
1204     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0071 start";
1205     MultimediaPlugin::AttrData aData;
1206     std::string value = "111";
1207     uint32_t ret = aData.InsertSet(value);
1208     ASSERT_EQ(ret, SUCCESS);
1209     const string *value1 = nullptr;
1210     uint32_t res = aData.GetValue(value1);
1211     ASSERT_EQ(res, ERR_INVALID_PARAMETER);
1212     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0071 end";
1213 }
1214 
1215 /**
1216  * @tc.name: AttrDataTest0072
1217  * @tc.desc: test GetMaxValue and data type is string
1218  * @tc.type: FUNC
1219  */
1220 HWTEST_F(AttrDataTest, AttrDataTest0072, TestSize.Level3)
1221 {
1222     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0072 start";
1223     std::string value = "111";
1224     MultimediaPlugin::AttrData aData(value);
1225     const string *value1 = nullptr;
1226     uint32_t res = aData.GetValue(value1);
1227     ASSERT_EQ(res, SUCCESS);
1228     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0072 end";
1229 }
1230 
1231 /**
1232  * @tc.name: AttrDataTest0073
1233  * @tc.desc: test AttrData::AttrData
1234  * @tc.type: FUNC
1235  */
1236 HWTEST_F(AttrDataTest, AttrDataTest0073, TestSize.Level3)
1237 {
1238     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0073 start";
1239     uint32_t value = 1;
1240     MultimediaPlugin::AttrData aData(value);
1241     aData.SetData(value);
1242     value = 2;
1243     aData.SetData(value);
1244     value = 3;
1245     aData.SetData(value);
1246     value = 4;
1247     aData.SetData(value);
1248     value = 5;
1249     aData.SetData(value);
1250     value = 6;
1251     aData.SetData(value);
1252     value = 7;
1253     aData.SetData(value);
1254     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest0073 end";
1255 }
1256 
1257 /**
1258  * @tc.name: AttrDataTest0074
1259  * @tc.desc: test InRange
1260  * @tc.type: FUNC
1261  */
1262 HWTEST_F(AttrDataTest, InRangeTest0074, TestSize.Level3)
1263 {
1264     GTEST_LOG_(INFO) << "AttrDataTest: InRangeTest0074 start";
1265     uint32_t value = 2;
1266     MultimediaPlugin::AttrData aData(value);
1267     bool res = aData.InRange(value);
1268     ASSERT_EQ(res, true);
1269     value = 6;
1270     res = aData.InRange(value);
1271     ASSERT_EQ(res, false);
1272     value = 8;
1273     res = aData.InRange(value);
1274     ASSERT_EQ(res, false);
1275     GTEST_LOG_(INFO) << "AttrDataTest: InRange1Test0074 end";
1276 }
1277 
1278 /**
1279  * @tc.name: SetDataTest001
1280  * @tc.desc: test SetData
1281  * @tc.type: FUNC
1282  */
1283 HWTEST_F(AttrDataTest, SetDataTest001, TestSize.Level3)
1284 {
1285     GTEST_LOG_(INFO) << "AttrDataTest: SetDataTest001 start";
1286     string &&value = "AttrData";
1287     AttrData attrData(std::move(value));
1288     ASSERT_EQ(attrData.type_, AttrDataType::ATTR_DATA_STRING);
1289     ASSERT_EQ(*(attrData.value_.stringValue), "AttrData");
1290     ASSERT_EQ(value, "");
1291 
1292     attrData.type_ = AttrDataType::ATTR_DATA_STRING;
1293     string &&value1 = "SetData";
1294     uint32_t ret = attrData.SetData(std::move(value1));
1295     ASSERT_EQ(*(attrData.value_.stringValue), "SetData");
1296     ASSERT_EQ(value1, "");
1297     ASSERT_EQ(ret, SUCCESS);
1298     GTEST_LOG_(INFO) << "AttrDataTest: SetDataTest001 end";
1299 }
1300 
1301 /**
1302  * @tc.name: InsertSetTest001
1303  * @tc.desc: test InsertSet
1304  * @tc.type: FUNC
1305  */
1306 HWTEST_F(AttrDataTest, InsertSetTest001, TestSize.Level3)
1307 {
1308     GTEST_LOG_(INFO) << "AttrDataTest: InsertSetTest001 start";
1309     string &&value = "AttrData";
1310     AttrData attrData(std::move(value));
1311     attrData.type_ = AttrDataType::ATTR_DATA_NULL;
1312     string &&value1 = "SetData";
1313     uint32_t ret = attrData.InsertSet(std::move(value1));
1314     ASSERT_EQ(attrData.type_, AttrDataType::ATTR_DATA_STRING_SET);
1315     ASSERT_EQ(ret, SUCCESS);
1316 
1317     attrData.type_ = AttrDataType::ATTR_DATA_BOOL;
1318     ret = attrData.InsertSet(std::move(value1));
1319     ASSERT_EQ(ret, ERR_UNSUPPORTED);
1320 
1321     attrData.type_ = AttrDataType::ATTR_DATA_STRING_SET;
1322     ret = attrData.InsertSet(std::move(value1));
1323     ASSERT_EQ(ret, SUCCESS);
1324 
1325     attrData.value_.stringSet->insert(std::move(value1));
1326     ret = attrData.InsertSet(std::move(value1));
1327     ASSERT_EQ(ret, ERR_INTERNAL);
1328     GTEST_LOG_(INFO) << "AttrDataTest: InsertSetTest001 end";
1329 }
1330 
1331 /**
1332  * @tc.name: InRangeTest001
1333  * @tc.desc: test InRange
1334  * @tc.type: FUNC
1335  */
1336 HWTEST_F(AttrDataTest, InRangeTest001, TestSize.Level3)
1337 {
1338     GTEST_LOG_(INFO) << "AttrDataTest: InRangeTest001 start";
1339     AttrData attr;
1340     AttrData attrData(attr);
1341     attr.type_ = AttrDataType::ATTR_DATA_TYPE_INVALID;
1342     bool ret = attrData.InRange(attr);
1343     ASSERT_EQ(ret, false);
1344     GTEST_LOG_(INFO) << "AttrDataTest: InRangeTest001 end";
1345 }
1346 
1347 /**
1348  * @tc.name: AttrDataTest075
1349  * @tc.desc: test GetMinValue and GetMaxValue
1350  * @tc.type: FUNC
1351  */
1352 HWTEST_F(AttrDataTest, AttrDataTest075, TestSize.Level3)
1353 {
1354     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest075 start";
1355     uint32_t value = 0;
1356     AttrData attrData(value);
1357     uint32_t value1 = 0;
1358     attrData.type_ = AttrDataType::ATTR_DATA_UINT32_SET;
1359     attrData.value_.uint32Set = new (std::nothrow) std::set<uint32_t>();
1360     ASSERT_NE(attrData.value_.uint32Set, nullptr);
1361 
1362     attrData.value_.uint32Set->begin() = attrData.value_.uint32Set->end();
1363     uint32_t ret = attrData.GetMinValue(value1);
1364     ASSERT_EQ(ret, ERR_GENERAL);
1365 
1366     attrData.value_.uint32Set->rbegin() = attrData.value_.uint32Set->rend();
1367     ret = attrData.GetMaxValue(value1);
1368     ASSERT_EQ(ret, ERR_GENERAL);
1369     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest075 end";
1370 }
1371 
1372 /**
1373  * @tc.name: AttrDataTest076
1374  * @tc.desc: test GetMinValue and GetMaxValue
1375  * @tc.type: FUNC
1376  */
1377 HWTEST_F(AttrDataTest, AttrDataTest076, TestSize.Level3)
1378 {
1379     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest076 start";
1380     string value = "AttrData";
1381     AttrData attrData(value);
1382     const string *value1 = nullptr;
1383     attrData.type_ = AttrDataType::ATTR_DATA_STRING_SET;
1384     attrData.value_.uint32Set = new (std::nothrow) std::set<uint32_t>();
1385     ASSERT_NE(attrData.value_.uint32Set, nullptr);
1386 
1387     attrData.value_.uint32Set->begin() = attrData.value_.uint32Set->end();
1388     uint32_t ret = attrData.GetMinValue(value1);
1389     ASSERT_EQ(ret, ERR_GENERAL);
1390 
1391     attrData.value_.uint32Set->rbegin() = attrData.value_.uint32Set->rend();
1392     ret = attrData.GetMaxValue(value1);
1393     ASSERT_EQ(ret, ERR_GENERAL);
1394     GTEST_LOG_(INFO) << "AttrDataTest: AttrDataTest076 end";
1395 }
1396 
1397 /**
1398  * @tc.name: InRangeTest002
1399  * @tc.desc: test InRange
1400  * @tc.type: FUNC
1401  */
1402 HWTEST_F(AttrDataTest, InRangeTest002, TestSize.Level3)
1403 {
1404     GTEST_LOG_(INFO) << "AttrDataTest: InRangeTest002 start";
1405     AttrData attrData;
1406     std::set<uint32_t> uint32Set;
1407     ASSERT_EQ(uint32Set.empty(), true);
1408     bool ret = attrData.InRange(uint32Set);
1409     ASSERT_EQ(ret, false);
1410 
1411     attrData.type_ = AttrDataType::ATTR_DATA_UINT32;
1412     uint32Set.insert(attrData.value_.uint32Value);
1413     ASSERT_EQ(uint32Set.empty(), false);
1414     ret = attrData.InRange(uint32Set);
1415     ASSERT_EQ(ret, true);
1416     GTEST_LOG_(INFO) << "AttrDataTest: InRangeTest002 end";
1417 }
1418 
1419 /**
1420  * @tc.name: InRangeTest003
1421  * @tc.desc: test InRange
1422  * @tc.type: FUNC
1423  */
1424 HWTEST_F(AttrDataTest, InRangeTest003, TestSize.Level3)
1425 {
1426     GTEST_LOG_(INFO) << "AttrDataTest: InRangeTest003 start";
1427     AttrData attrData(1, 0);
1428     bool ret = attrData.InRange(attrData.value_.uint32Rang);
1429     ASSERT_EQ(attrData.value_.uint32Rang[LOWER_BOUND_INDEX], 1);
1430     ASSERT_EQ(attrData.value_.uint32Rang[UPPER_BOUND_INDEX], 0);
1431     ASSERT_EQ(ret, false);
1432 
1433     AttrData attr(0, 1);
1434     attr.type_ = AttrDataType::ATTR_DATA_UINT32;
1435     ret = attrData.InRange(attr.value_.uint32Rang);
1436     ASSERT_EQ(ret, false);
1437 
1438     attr.type_ = AttrDataType::ATTR_DATA_UINT32_RANGE;
1439     ret = attr.InRange(attr.value_.uint32Rang);
1440     ASSERT_EQ(ret, true);
1441 
1442     attr.type_ = AttrDataType::ATTR_DATA_TYPE_INVALID;
1443     ret = attr.InRange(attr.value_.uint32Rang);
1444     ASSERT_EQ(ret, false);
1445     GTEST_LOG_(INFO) << "AttrDataTest: InRangeTest003 end";
1446 }
1447 }
1448 }