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