1 /* 2 # Copyright (c) 2025 iSoftStone Information Technology (Group) 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 <string> 17 18 #include "gmock/gmock.h" 19 #include "gtest/gtest.h" 20 #include "test/mock/base/mock_system_properties.h" 21 22 #define protected public 23 #define private public 24 #include "core/common/container.h" 25 #include "core/common/resource/resource_object.h" 26 #include "core/common/resource/resource_parse_utils.h" 27 #undef private 28 #undef protected 29 30 using namespace testing; 31 using namespace testing::ext; 32 33 namespace OHOS::Ace { 34 class ResourceParseUtilsTest : public testing::Test {}; 35 extern RefPtr<ResourceObject> CompleteResourceObject(const std::unique_ptr<JsonValue>& json); 36 extern std::string GetReplaceContentStr( 37 int pos, const std::string& type, const std::vector<ResourceObjectParams> params, int32_t containCount); 38 extern void ReplaceHolder(std::string& originStr, const std::vector<ResourceObjectParams> params, int32_t containCount); 39 40 /** 41 * @tc.name: ResourceParseUtilsTest001 42 * @tc.desc: Test resourceParseUtils. 43 * @tc.type: FUNC 44 */ 45 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest001, TestSize.Level1) 46 { 47 auto resourceAdapter = ResourceAdapter::Create(); 48 ResourceManager::GetInstance().AddResourceAdapter("com.example.test", "entry", 100000, resourceAdapter); 49 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(); 50 51 std::string result; 52 CalcDimension dimension; 53 Color color; 54 double doubleRes; 55 EXPECT_FALSE(ResourceParseUtils::ParseResString(resObj, result)); 56 57 std::vector<ResourceObjectParams> resObjParamsList; 58 RefPtr<ResourceObject> resObjWithId = AceType::MakeRefPtr<ResourceObject>(100000, 100001, 59 resObjParamsList, "", "", 100000); 60 EXPECT_FALSE(ResourceParseUtils::ParseResString(resObjWithId, result)); 61 62 ResourceObjectParams params { .value = "test", .type = ResourceObjectParamType::STRING }; 63 resObjParamsList.push_back(params); 64 RefPtr<ResourceObject> resObjWithName = AceType::MakeRefPtr<ResourceObject>(-1, -1, 65 resObjParamsList, "com.example.test", "entry", 100000); 66 EXPECT_FALSE(ResourceParseUtils::ParseResString(resObjWithName, result)); 67 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObjWithName, color)); 68 69 RefPtr<ResourceObject> resObjWithErrId = AceType::MakeRefPtr<ResourceObject>(100000, -1, 70 resObjParamsList, "com.example.test", "entry", 100000); 71 EXPECT_FALSE(ResourceParseUtils::ParseResourceToDouble(resObjWithErrId, doubleRes)); 72 73 g_isResourceDecoupling = false; 74 EXPECT_FALSE(ResourceParseUtils::ParseResResource(resObjWithId, dimension)); 75 EXPECT_FALSE(ResourceParseUtils::ParseResDimensionNG(resObjWithErrId, dimension, DimensionUnit::VP)); 76 EXPECT_FALSE(ResourceParseUtils::ParseResColor(resObjWithName, color)); 77 g_isResourceDecoupling = true; 78 79 ResourceManager::GetInstance().AddResourceAdapter("", "", Container::CurrentIdSafely(), resourceAdapter); 80 RefPtr<ResourceObject> stringObj = AceType::MakeRefPtr<ResourceObject>(1, 10003, 81 resObjParamsList, "", "", 100000); 82 EXPECT_FALSE(ResourceParseUtils::ParseResResource(stringObj, dimension)); 83 84 RefPtr<ResourceObject> intObj = AceType::MakeRefPtr<ResourceObject>(1, 10007, 85 resObjParamsList, "", "", 100000); 86 EXPECT_TRUE(ResourceParseUtils::ParseResResource(intObj, dimension)); 87 88 RefPtr<ResourceObject> floatObj = AceType::MakeRefPtr<ResourceObject>(1, 10002, 89 resObjParamsList, "", "", 100000); 90 EXPECT_TRUE(ResourceParseUtils::ParseResResource(floatObj, dimension)); 91 } 92 93 /** 94 * @tc.name: ResourceParseUtilsTest002 95 * @tc.desc: Test resourceParseUtils. 96 * @tc.type: FUNC 97 */ 98 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest002, TestSize.Level1) 99 { 100 RefPtr<ResourceObject> resObj; 101 std::vector<ResourceObjectParams> resObjParamsList; 102 RefPtr<ResourceObject> resObjWithType = AceType::MakeRefPtr<ResourceObject>(-1, 10001, 103 resObjParamsList, "", "", 100000); 104 ResourceObjectParams params { .value = "test", .type = ResourceObjectParamType::STRING }; 105 resObjParamsList.push_back(params); 106 RefPtr<ResourceObject> resObjWithParams = AceType::MakeRefPtr<ResourceObject>(-1, -1, 107 resObjParamsList, "", "", 100000); 108 std::vector<uint32_t> resIntArr; 109 EXPECT_FALSE(ResourceParseUtils::ParseResIntegerArray(resObj, resIntArr)); 110 EXPECT_FALSE(ResourceParseUtils::ParseResIntegerArray(resObjWithType, resIntArr)); 111 112 std::vector<std::string> resStrArr; 113 EXPECT_FALSE(ResourceParseUtils::ParseResStrArray(resObj, resStrArr)); 114 EXPECT_FALSE(ResourceParseUtils::ParseResStrArray(resObjWithType, resStrArr)); 115 116 EXPECT_FALSE(ResourceParseUtils::ParseResFontFamilies(resObj, resStrArr)); 117 EXPECT_TRUE(ResourceParseUtils::ParseResFontFamilies(resObjWithParams, resStrArr)); 118 119 Color color; 120 EXPECT_FALSE(ResourceParseUtils::ParseResColor(resObj, color)); 121 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObjWithParams, color)); 122 123 std::u16string u16Str; 124 EXPECT_FALSE(ResourceParseUtils::ParseResString(resObj, u16Str)); 125 EXPECT_FALSE(ResourceParseUtils::ParseResString(resObjWithParams, u16Str)); 126 127 std::string strRes; 128 EXPECT_FALSE(ResourceParseUtils::ParseResString(resObj, strRes)); 129 EXPECT_FALSE(ResourceParseUtils::ParseResString(resObjWithParams, strRes)); 130 131 EXPECT_FALSE(ResourceParseUtils::ParseResMedia(resObj, strRes)); 132 EXPECT_FALSE(ResourceParseUtils::ParseResMedia(resObjWithType, strRes)); 133 134 bool boolRes; 135 EXPECT_FALSE(ResourceParseUtils::ParseResBool(resObj, boolRes)); 136 EXPECT_FALSE(ResourceParseUtils::ParseResBool(resObjWithType, boolRes)); 137 138 double doubleRes; 139 EXPECT_FALSE(ResourceParseUtils::ParseResourceToDouble(resObj, doubleRes)); 140 EXPECT_FALSE(ResourceParseUtils::ParseResourceToDouble(resObjWithParams, doubleRes)); 141 142 CalcDimension caclDimension; 143 EXPECT_FALSE(ResourceParseUtils::ParseResDimensionNG(resObj, caclDimension, DimensionUnit::VP)); 144 EXPECT_TRUE(ResourceParseUtils::ParseResDimensionNG(resObjWithParams, caclDimension, DimensionUnit::VP)); 145 146 EXPECT_FALSE(ResourceParseUtils::ParseResDimension(resObj, caclDimension, DimensionUnit::VP)); 147 EXPECT_FALSE(ResourceParseUtils::ParseResDimension(resObjWithParams, caclDimension, DimensionUnit::VP)); 148 149 EXPECT_FALSE(ResourceParseUtils::ParseResResource(resObj, caclDimension)); 150 151 Dimension dimension; 152 EXPECT_FALSE(ResourceParseUtils::ConvertFromResObjNG(resObj, dimension)); 153 } 154 155 /** 156 * @tc.name: ResourceParseUtilsTest003 157 * @tc.desc: Test resourceParseUtils. 158 * @tc.type: FUNC 159 */ 160 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest003, TestSize.Level1) 161 { 162 std::vector<ResourceObjectParams> resObjParamsList; 163 ResourceObjectParams params { .value = "test", .type = ResourceObjectParamType::STRING }; 164 resObjParamsList.push_back(params); 165 RefPtr<ResourceObject> resObjWithParams = AceType::MakeRefPtr<ResourceObject>(-1, -1, 166 resObjParamsList, "", "", 100000); 167 CalcDimension caclDimension; 168 EXPECT_FALSE(ResourceParseUtils::ParseResResource(resObjWithParams, caclDimension)); 169 } 170 171 /** 172 * @tc.name: ResourceParseUtilsTest004 173 * @tc.desc: Test resourceParseUtils. 174 * @tc.type: FUNC 175 */ 176 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest004, TestSize.Level1) 177 { 178 /** 179 * @tc.steps: step1. ParseResColor with not object. 180 * @tc.expect: ParseResColor return true. 181 */ 182 auto resourceAdapter = ResourceAdapter::Create(); 183 ResourceManager::GetInstance().AddResourceAdapter("com.example.test", "entry", 100000, resourceAdapter); 184 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(); 185 Color color = Color::WHITE; 186 resObj->SetColor(color); 187 resObj->SetIsResource(false); 188 resObj->SetColorMode(ColorMode::LIGHT); 189 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObj, color)); 190 191 /** 192 * @tc.steps: step2. ParseResColor with isReloading_ true. 193 * @tc.expect: ParseResColor return true. 194 */ 195 ResourceParseUtils::SetIsReloading(true); 196 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObj, color)); 197 198 /** 199 * @tc.steps: step3. ParseResColor with resId is -1. 200 * @tc.expect: ParseResColor return true. 201 */ 202 ResourceObjectParams params { .value = "test", .type = ResourceObjectParamType::STRING }; 203 std::vector<ResourceObjectParams> resObjParamsList; 204 resObjParamsList.push_back(params); 205 RefPtr<ResourceObject> resObjWithName = AceType::MakeRefPtr<ResourceObject>(-1, -1, 206 resObjParamsList, "com.example.test", "entry", 100000); 207 resObjWithName->SetColor(color); 208 resObjWithName->SetIsResource(false); 209 resObjWithName->SetColorMode(ColorMode::DARK); 210 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObjWithName, color)); 211 ResourceParseUtils::SetIsReloading(false); 212 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObjWithName, color)); 213 214 /** 215 * @tc.steps: step4. ParseResColor with string type. 216 * @tc.expect: ParseResColor return false. 217 */ 218 RefPtr<ResourceObject> resObjWithStr = AceType::MakeRefPtr<ResourceObject>(1, 10003, 219 resObjParamsList, "com.example.test", "entry", 100000); 220 resObjWithStr->SetColor(color); 221 ResourceParseUtils::SetIsReloading(true); 222 EXPECT_FALSE(ResourceParseUtils::ParseResColor(resObjWithStr, color)); 223 ResourceParseUtils::SetIsReloading(false); 224 EXPECT_FALSE(ResourceParseUtils::ParseResColor(resObjWithStr, color)); 225 226 /** 227 * @tc.steps: step5. ParseResColor with integer type. 228 * @tc.expect: ParseResColor return true. 229 */ 230 RefPtr<ResourceObject> resObjWithInt = AceType::MakeRefPtr<ResourceObject>(1, 10007, 231 resObjParamsList, "com.example.test", "entry", 100000); 232 resObjWithInt->SetColor(color); 233 ResourceParseUtils::SetIsReloading(true); 234 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObjWithInt, color)); 235 ResourceParseUtils::SetIsReloading(false); 236 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObjWithInt, color)); 237 238 /** 239 * @tc.steps: step6. ParseResColor with string type. 240 * @tc.expect: ParseResColor return true. 241 */ 242 RefPtr<ResourceObject> resObjWithColor = AceType::MakeRefPtr<ResourceObject>(1, 10001, 243 resObjParamsList, "com.example.test", "entry", 100000); 244 resObjWithColor->SetColor(color); 245 ResourceParseUtils::SetIsReloading(true); 246 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObjWithColor, color)); 247 ResourceParseUtils::SetIsReloading(false); 248 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObjWithColor, color)); 249 } 250 251 /** 252 * @tc.name: ResourceParseUtilsTest005 253 * @tc.desc: Test resourceParseUtils. 254 * @tc.type: FUNC 255 */ 256 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest005, TestSize.Level1) 257 { 258 /** 259 * @tc.steps: step1. ParseResColor with Color::WHITE. 260 * @tc.expect: ParseResColor return Color::WHITE. 261 */ 262 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(); 263 Color color = Color::WHITE; 264 resObj->SetColor(color); 265 resObj->SetIsResource(false); 266 ResourceParseUtils::SetIsReloading(false); 267 resObj->SetColorMode(ColorMode::LIGHT); 268 Color result; 269 ResourceParseUtils::ParseResColor(resObj, result); 270 EXPECT_EQ(color, result); 271 } 272 273 /** 274 * @tc.name: ResourceParseUtilsTest006 275 * @tc.desc: Test resourceParseUtils. 276 * @tc.type: FUNC 277 */ 278 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest006, TestSize.Level1) 279 { 280 /** 281 * @tc.steps: step1. ParseResColor with different colormode. 282 * @tc.expect: ParseResColor return True except colormode undefined. 283 */ 284 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(); 285 Color color = Color::WHITE; 286 resObj->SetColor(color); 287 resObj->SetIsResource(false); 288 resObj->SetColorMode(ColorMode::COLOR_MODE_UNDEFINED); 289 ResourceParseUtils::SetIsReloading(false); 290 EXPECT_FALSE(ResourceParseUtils::ParseResColor(resObj, color)); 291 resObj->SetColorMode(ColorMode::DARK); 292 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObj, color)); 293 ResourceParseUtils::SetIsReloading(true); 294 EXPECT_TRUE(ResourceParseUtils::ParseResColor(resObj, color)); 295 } 296 297 /** 298 * @tc.name: ResourceParseUtilsTest007 299 * @tc.desc: Test CompleteResourceObject. 300 * @tc.type: FUNC 301 */ 302 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest007, TestSize.Level1) 303 { 304 /** 305 * @tc.steps: step1. Create a JSON object with valid data. 306 * @tc.expect: CompleteResourceObject return nullptr. 307 */ 308 std::unique_ptr<JsonValue> json = JsonUtil::Create(true); 309 json->Put("id", 1); 310 json->Put("type", 2); 311 json->Put("params", 3); 312 json->Put("bundleName", "test_bundle"); 313 json->Put("moduleName", "test_module"); 314 315 /** 316 * @tc.steps: step2. Call the function. 317 * @tc.expect: the function is be called. 318 */ 319 auto result = CompleteResourceObject(json); 320 321 /** 322 * @tc.steps: step3. Verify the result. 323 * @tc.expect: result is nullptr. 324 */ 325 EXPECT_EQ(result, nullptr); 326 } 327 328 /** 329 * @tc.name: ResourceParseUtilsTest008 330 * @tc.desc: Test CompleteResourceObject. 331 * @tc.type: FUNC 332 */ 333 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest008, TestSize.Level1) 334 { 335 /** 336 * @tc.steps: step1. Create a JSON object with valid data. 337 * @tc.expect: CompleteResourceObject return not nullptr and GetParams().size() is 0. 338 */ 339 std::unique_ptr<JsonValue> json = JsonUtil::Create(true); 340 json->Put("id", 11); 341 json->Put("type", 22); 342 json->Put("params", JsonUtil::CreateArray(true)); 343 json->Put("bundleName", "test_bundle2"); 344 json->Put("moduleName", "test_module2"); 345 346 /** 347 * @tc.steps: step2. Call the function. 348 * @tc.expect: the function is be called. 349 */ 350 auto result = CompleteResourceObject(json); 351 352 /** 353 * @tc.steps: step3. Verify the result. 354 * @tc.expect: GetParams().size() is 0. 355 */ 356 EXPECT_NE(result, nullptr); 357 EXPECT_EQ(result->GetId(), 11); 358 EXPECT_EQ(result->GetType(), 22); 359 EXPECT_EQ(result->GetBundleName(), "\"test_bundle2\""); 360 EXPECT_EQ(result->GetModuleName(), "\"test_module2\""); 361 EXPECT_EQ(result->GetParams().size(), 0); 362 } 363 364 /** 365 * @tc.name: ResourceParseUtilsTest009 366 * @tc.desc: Test CompleteResourceObject. 367 * @tc.type: FUNC 368 */ 369 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest009, TestSize.Level1) 370 { 371 /** 372 * @tc.steps: step1. Create a JSON object with valid data. 373 * @tc.expect: CompleteResourceObject return not nullptr. 374 */ 375 std::unique_ptr<JsonValue> json = JsonUtil::Create(true); 376 json->Put("id", 111); 377 json->Put("type", 222); 378 json->Put("bundleName", "test_bundle3"); 379 json->Put("moduleName", "test_module3"); 380 auto paramsArray = JsonUtil::CreateArray(true); 381 paramsArray->Put("0", "string_value"); 382 paramsArray->Put("1", 1); 383 paramsArray->Put("2", 1.2); 384 json->Put("params", std::move(paramsArray)); 385 386 /** 387 * @tc.steps: step2. Call the function. 388 * @tc.expect: the function is be called. 389 */ 390 auto result = CompleteResourceObject(json); 391 392 /** 393 * @tc.steps: step3. Verify the result. 394 * @tc.expect: GetParams().size() is not 0. 395 */ 396 EXPECT_NE(result, nullptr); 397 EXPECT_EQ(result->GetParams().size(), 3); 398 EXPECT_EQ(result->GetParams()[0].value, "\"string_value\""); 399 EXPECT_EQ(result->GetParams()[0].type, ResourceObjectParamType::STRING); 400 EXPECT_EQ(result->GetParams()[1].value, "1"); 401 EXPECT_EQ(result->GetParams()[1].type, ResourceObjectParamType::INT); 402 EXPECT_EQ(result->GetParams()[2].value, "1.2"); 403 EXPECT_EQ(result->GetParams()[2].type, ResourceObjectParamType::FLOAT); 404 } 405 406 /** 407 * @tc.name: ResourceParseUtilsTest010 408 * @tc.desc: Test GetReplaceContentStr. 409 * @tc.type: FUNC 410 */ 411 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest010, TestSize.Level1) 412 { 413 /** 414 * @tc.steps: step1. Create a params with valid data. 415 * @tc.expect: GetReplaceContentStr return "". 416 */ 417 std::vector<ResourceObjectParams> params; 418 int pos = 0; 419 int32_t containCount = 0; 420 std::string type = "d"; 421 422 /** 423 * @tc.steps: step2. Call the function. 424 * @tc.expect: the function is be called. 425 */ 426 std::string result = GetReplaceContentStr(pos, type, params, containCount); 427 428 /** 429 * @tc.steps: step3. Verify the result. 430 * @tc.expect: result is not "". 431 */ 432 EXPECT_TRUE(result.empty()); 433 } 434 435 /** 436 * @tc.name: ResourceParseUtilsTest011 437 * @tc.desc: Test GetReplaceContentStr. 438 * @tc.type: FUNC 439 */ 440 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest011, TestSize.Level1) 441 { 442 /** 443 * @tc.steps: step1. Create a params with valid data. 444 * @tc.expect: GetReplaceContentStr return not nullptr. 445 */ 446 std::vector<ResourceObjectParams> params; 447 ResourceObjectParams param { .value = "123", .type = ResourceObjectParamType::INT }; 448 params.push_back(param); 449 int pos = 0; 450 int32_t containCount = 0; 451 std::string type = "d"; 452 std::string result = GetReplaceContentStr(pos, type, params, containCount); 453 /** 454 * @tc.steps: step2. Verify the result. 455 * @tc.expect: result equalto value". 456 */ 457 EXPECT_EQ(result, "123"); 458 459 std::vector<ResourceObjectParams> params2; 460 ResourceObjectParams param2 { .value = "45.67", .type = ResourceObjectParamType::FLOAT }; 461 params2.push_back(param2); 462 463 std::string result2 = GetReplaceContentStr(pos, type, params2, containCount); 464 /** 465 * @tc.steps: step3. Verify the result. 466 * @tc.expect: result equalto value. 467 */ 468 EXPECT_EQ(result2, "45.67"); 469 470 std::vector<ResourceObjectParams> params3; 471 ResourceObjectParams param3 { .value = "567", .type = ResourceObjectParamType::NONE }; 472 params3.push_back(param3); 473 std::string result3 = GetReplaceContentStr(pos, type, params3, containCount); 474 475 /** 476 * @tc.steps: step4. Verify the result. 477 * @tc.expect: result not equalto value. 478 */ 479 EXPECT_NE(result3, "567"); 480 } 481 482 /** 483 * @tc.name: ResourceParseUtilsTest012 484 * @tc.desc: Test GetReplaceContentStr. 485 * @tc.type: FUNC 486 */ 487 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest012, TestSize.Level1) 488 { 489 /** 490 * @tc.steps: step1. Create a params with valid data. 491 * @tc.expect: GetReplaceContentStr return not nullptr. 492 */ 493 std::vector<ResourceObjectParams> params; 494 ResourceObjectParams param { .value = "hello", .type = ResourceObjectParamType::STRING }; 495 params.push_back(param); 496 int pos = 0; 497 int32_t containCount = 0; 498 std::string type = "s"; 499 std::string result = GetReplaceContentStr(pos, type, params, containCount); 500 /** 501 * @tc.steps: step2. Verify the result. 502 * @tc.expect: result equalto value". 503 */ 504 EXPECT_EQ(result, "hello"); 505 506 std::vector<ResourceObjectParams> params2; 507 ResourceObjectParams param2 { .value = "world", .type = ResourceObjectParamType::NONE }; 508 params2.push_back(param2); 509 510 std::string result2 = GetReplaceContentStr(pos, type, params2, containCount); 511 /** 512 * @tc.steps: step3. Verify the result. 513 * @tc.expect: result not equalto value. 514 */ 515 EXPECT_NE(result2, "world"); 516 } 517 518 /** 519 * @tc.name: ResourceParseUtilsTest013 520 * @tc.desc: Test GetReplaceContentStr. 521 * @tc.type: FUNC 522 */ 523 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest013, TestSize.Level1) 524 { 525 /** 526 * @tc.steps: step1. Create a params with valid data. 527 * @tc.expect: GetReplaceContentStr return not nullptr. 528 */ 529 std::vector<ResourceObjectParams> params; 530 ResourceObjectParams param { .value = "789", .type = ResourceObjectParamType::INT }; 531 params.push_back(param); 532 int pos = 0; 533 int32_t containCount = 0; 534 std::string type = "f"; 535 std::string result = GetReplaceContentStr(pos, type, params, containCount); 536 /** 537 * @tc.steps: step2. Verify the result. 538 * @tc.expect: result equalto value". 539 */ 540 EXPECT_EQ(result, "789"); 541 542 std::vector<ResourceObjectParams> params2; 543 ResourceObjectParams param2 { .value = "123.45", .type = ResourceObjectParamType::FLOAT }; 544 params2.push_back(param2); 545 546 std::string result2 = GetReplaceContentStr(pos, type, params2, containCount); 547 /** 548 * @tc.steps: step3. Verify the result. 549 * @tc.expect: result equalto value. 550 */ 551 EXPECT_EQ(result2, "123.45"); 552 553 std::vector<ResourceObjectParams> params3; 554 ResourceObjectParams param3 { .value = "hi", .type = ResourceObjectParamType::NONE }; 555 params3.push_back(param3); 556 std::string result3 = GetReplaceContentStr(pos, type, params3, containCount); 557 558 /** 559 * @tc.steps: step4. Verify the result. 560 * @tc.expect: result not equalto value. 561 */ 562 EXPECT_NE(result3, "hi"); 563 } 564 565 /** 566 * @tc.name: ResourceParseUtilsTest014 567 * @tc.desc: Test GetReplaceContentStr. 568 * @tc.type: FUNC 569 */ 570 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest014, TestSize.Level1) 571 { 572 /** 573 * @tc.steps: step1. Create a params with valid data. 574 * @tc.expect: GetReplaceContentStr return "". 575 */ 576 std::vector<ResourceObjectParams> params; 577 ResourceObjectParams param { .value = "thanks", .type = ResourceObjectParamType::INT }; 578 params.push_back(param); 579 int pos = 0; 580 int32_t containCount = 0; 581 std::string type = "x"; 582 583 std::string result = GetReplaceContentStr(pos, type, params, containCount); 584 585 /** 586 * @tc.steps: step3. Verify the result. 587 * @tc.expect: result is not "". 588 */ 589 EXPECT_TRUE(result.empty()); 590 } 591 592 /** 593 * @tc.name: ResourceParseUtilsTest015 594 * @tc.desc: Test ParseResStringObj. 595 * @tc.type: FUNC 596 */ 597 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest015, TestSize.Level1) 598 { 599 /** 600 * @tc.steps: step1. Create a params with valid data. 601 * @tc.expect: params is empty(). 602 */ 603 std::vector<ResourceObjectParams> params; 604 std::string result; 605 int32_t type = static_cast<int32_t>(ResourceType::PLURAL); 606 RefPtr<ThemeConstants> themeConstants = nullptr; 607 RefPtr<ResourceAdapter> resourceAdapter = nullptr; 608 RefPtr<ResourceWrapper> resourceWrapper = AceType::MakeRefPtr<ResourceWrapper>(themeConstants, resourceAdapter); 609 610 bool success = ResourceParseUtils::ParseResStringObj(params, resourceWrapper, result, type); 611 612 /** 613 * @tc.steps: step3. Verify the result. 614 * @tc.expect: result is false. 615 */ 616 EXPECT_FALSE(success); 617 } 618 619 /** 620 * @tc.name: ResourceParseUtilsTest016 621 * @tc.desc: Test ParseResStringObj. 622 * @tc.type: FUNC 623 */ 624 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest016, TestSize.Level1) 625 { 626 /** 627 * @tc.steps: step1. Create a params with valid data. 628 * @tc.expect: params is not empty(). 629 */ 630 std::vector<ResourceObjectParams> params; 631 ResourceObjectParams param { .value = "12", .type = ResourceObjectParamType::INT }; 632 params.push_back(param); 633 std::string result; 634 int32_t type = static_cast<int32_t>(ResourceType::STRING); 635 RefPtr<ThemeConstants> themeConstants = nullptr; 636 RefPtr<ResourceAdapter> resourceAdapter = nullptr; 637 RefPtr<ResourceWrapper> resourceWrapper = AceType::MakeRefPtr<ResourceWrapper>(themeConstants, resourceAdapter); 638 639 bool success = ResourceParseUtils::ParseResStringObj(params, resourceWrapper, result, type); 640 641 /** 642 * @tc.steps: step3. Verify the result. 643 * @tc.expect: result is true. 644 */ 645 EXPECT_TRUE(success); 646 } 647 648 /** 649 * @tc.name: ResourceParseUtilsTest017 650 * @tc.desc: Test ParseResStringObj. 651 * @tc.type: FUNC 652 */ 653 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest017, TestSize.Level1) 654 { 655 /** 656 * @tc.steps: step1. Create a params with valid data. 657 * @tc.expect: params is not empty(). 658 */ 659 std::vector<ResourceObjectParams> params; 660 ResourceObjectParams param { .value = "17", .type = ResourceObjectParamType::INT }; 661 params.push_back(param); 662 ResourceObjectParams param2 { .value = "test", .type = ResourceObjectParamType::STRING }; 663 params.push_back(param2); 664 std::string result; 665 int32_t type = static_cast<int32_t>(ResourceType::PLURAL); 666 RefPtr<ThemeConstants> themeConstants = nullptr; 667 RefPtr<ResourceAdapter> resourceAdapter = nullptr; 668 RefPtr<ResourceWrapper> resourceWrapper = AceType::MakeRefPtr<ResourceWrapper>(themeConstants, resourceAdapter); 669 670 bool success = ResourceParseUtils::ParseResStringObj(params, resourceWrapper, result, type); 671 672 /** 673 * @tc.steps: step3. Verify the result. 674 * @tc.expect: result is false. 675 */ 676 EXPECT_FALSE(success); 677 } 678 679 /** 680 * @tc.name: ResourceParseUtilsTest018 681 * @tc.desc: Test ParseResStringObj. 682 * @tc.type: FUNC 683 */ 684 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest018, TestSize.Level1) 685 { 686 /** 687 * @tc.steps: step1. Create a params with valid data. 688 * @tc.expect: params is not empty(). 689 */ 690 std::vector<ResourceObjectParams> params; 691 ResourceObjectParams param { .value = "18", .type = ResourceObjectParamType::INT }; 692 params.push_back(param); 693 ResourceObjectParams param2 { .value = "1.8", .type = ResourceObjectParamType::FLOAT }; 694 params.push_back(param2); 695 std::string result; 696 int32_t type = static_cast<int32_t>(ResourceType::PLURAL); 697 RefPtr<ThemeConstants> themeConstants = nullptr; 698 RefPtr<ResourceAdapter> resourceAdapter = nullptr; 699 RefPtr<ResourceWrapper> resourceWrapper = AceType::MakeRefPtr<ResourceWrapper>(themeConstants, resourceAdapter); 700 701 bool success = ResourceParseUtils::ParseResStringObj(params, resourceWrapper, result, type); 702 703 /** 704 * @tc.steps: step3. Verify the result. 705 * @tc.expect: result is true. 706 */ 707 EXPECT_TRUE(success); 708 } 709 710 /** 711 * @tc.name: ResourceParseUtilsTest019 712 * @tc.desc: Test ParseResStringObj. 713 * @tc.type: FUNC 714 */ 715 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest019, TestSize.Level1) 716 { 717 /** 718 * @tc.steps: step1. Create a params with valid data. 719 * @tc.expect: params is not empty(). 720 */ 721 std::vector<ResourceObjectParams> params; 722 ResourceObjectParams param { .value = "19", .type = ResourceObjectParamType::INT }; 723 params.push_back(param); 724 std::string result; 725 int32_t type = static_cast<int32_t>(ResourceType::BOOLEAN); 726 RefPtr<ThemeConstants> themeConstants = nullptr; 727 RefPtr<ResourceAdapter> resourceAdapter = nullptr; 728 RefPtr<ResourceWrapper> resourceWrapper = AceType::MakeRefPtr<ResourceWrapper>(themeConstants, resourceAdapter); 729 730 bool success = ResourceParseUtils::ParseResStringObj(params, resourceWrapper, result, type); 731 732 /** 733 * @tc.steps: step3. Verify the result. 734 * @tc.expect: result is true. 735 */ 736 EXPECT_FALSE(success); 737 } 738 739 /** 740 * @tc.name: ResourceParseUtilsTest020 741 * @tc.desc: Test ParseResString. 742 * @tc.type: FUNC 743 */ 744 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest020, TestSize.Level1) 745 { 746 /** 747 * @tc.steps: step1. Create a params with valid data. 748 * @tc.expect: resObj is null. 749 */ 750 RefPtr<ResourceObject> resObj; 751 std::string result; 752 753 bool success = ResourceParseUtils::ParseResString(resObj, result); 754 755 /** 756 * @tc.steps: step2. Verify the result. 757 * @tc.expect: result is true. 758 */ 759 EXPECT_FALSE(success); 760 761 /** 762 * @tc.steps: step3. Create a params with valid data. 763 * @tc.expect: type is UNKNOWN_RESOURCE_TYPE, is -1 764 */ 765 std::vector<ResourceObjectParams> params; 766 RefPtr<ResourceObject> resObj2 = AceType::MakeRefPtr<ResourceObject>(1, -1, params, "", "", 100000); 767 bool success2 = ResourceParseUtils::ParseResString(resObj2, result); 768 769 /** 770 * @tc.steps: step4. Verify the result. 771 * @tc.expect: result is false. 772 */ 773 EXPECT_FALSE(success2); 774 } 775 776 /** 777 * @tc.name: ResourceParseUtilsTest021 778 * @tc.desc: Test ParseResString. 779 * @tc.type: FUNC 780 */ 781 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest021, TestSize.Level1) 782 { 783 /** 784 * @tc.steps: step1. Create a resObj with valid data. 785 * @tc.expect: id is -1. 786 */ 787 std::string result; 788 std::vector<ResourceObjectParams> params; 789 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(-1, 1, params, "", "", 100000); 790 bool success = ResourceParseUtils::ParseResString(resObj, result); 791 792 /** 793 * @tc.steps: step2. Verify the result. 794 * @tc.expect: result is false. 795 */ 796 EXPECT_FALSE(success); 797 798 /** 799 * @tc.steps: step3. Create a resObj with valid data. 800 * @tc.expect: type is static_cast<int32_t>(ResourceType::STRING) 801 */ 802 // std::vector<ResourceObjectParams> params; 803 RefPtr<ResourceObject> resObj2 = 804 AceType::MakeRefPtr<ResourceObject>(1, static_cast<int32_t>(ResourceType::STRING), params, "", "", 100000); 805 bool success2 = ResourceParseUtils::ParseResString(resObj2, result); 806 /** 807 * @tc.steps: step3. Verify the result. 808 * @tc.expect: result is false. 809 */ 810 EXPECT_TRUE(success2); 811 } 812 813 /** 814 * @tc.name: ResourceParseUtilsTest022 815 * @tc.desc: Test ParseResString. 816 * @tc.type: FUNC 817 */ 818 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest022, TestSize.Level1) 819 { 820 /** 821 * @tc.steps: step1. Create a resObj with valid data. 822 * @tc.expect: params is empty. 823 */ 824 std::string result; 825 int32_t type = static_cast<int32_t>(ResourceType::PLURAL); 826 std::vector<ResourceObjectParams> params; 827 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(1, type, params, "", "", 100000); 828 bool success = ResourceParseUtils::ParseResString(resObj, result); 829 830 /** 831 * @tc.steps: step2. Verify the result. 832 * @tc.expect: result is false. 833 */ 834 EXPECT_FALSE(success); 835 836 /** 837 * @tc.steps: step3. Create a resObj with valid data. 838 * @tc.expect: !IsNumberType() is true 839 */ 840 std::vector<ResourceObjectParams> params2; 841 ResourceObjectParams param2 { .value = "string", .type = ResourceObjectParamType::STRING }; 842 params2.push_back(param2); 843 RefPtr<ResourceObject> resObj2 = AceType::MakeRefPtr<ResourceObject>(1, type, params2, "", "", 100000); 844 bool success2 = ResourceParseUtils::ParseResString(resObj2, result); 845 846 /** 847 * @tc.steps: step4. Verify the result. 848 * @tc.expect: result is false. 849 */ 850 EXPECT_FALSE(success2); 851 852 /** 853 * @tc.steps: step5. Create a resObj with valid data. 854 * @tc.expect: !IsNumberType() is false 855 */ 856 std::vector<ResourceObjectParams> params3; 857 ResourceObjectParams param3 { .value = "123", .type = ResourceObjectParamType::INT }; 858 params3.push_back(param3); 859 RefPtr<ResourceObject> resObj3 = AceType::MakeRefPtr<ResourceObject>(1, type, params3, "", "", 100000); 860 bool success3 = ResourceParseUtils::ParseResString(resObj3, result); 861 /** 862 * @tc.steps: step6. Verify the result. 863 * @tc.expect: result is true. 864 */ 865 EXPECT_TRUE(success3); 866 } 867 868 /** 869 * @tc.name: ResourceParseUtilsTest023 870 * @tc.desc: Test ParseResString. 871 * @tc.type: FUNC 872 */ 873 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest023, TestSize.Level1) 874 { 875 /** 876 * @tc.steps: step1. Create a resObj with valid data. 877 * @tc.expect: type is static_cast<int32_t>(ResourceType::FLOAT). 878 */ 879 std::string result; 880 std::vector<ResourceObjectParams> params; 881 RefPtr<ResourceObject> resObj = 882 AceType::MakeRefPtr<ResourceObject>(1, static_cast<int32_t>(ResourceType::FLOAT), params, "", "", 100000); 883 bool success = ResourceParseUtils::ParseResString(resObj, result); 884 885 /** 886 * @tc.steps: step2. Verify the result. 887 * @tc.expect: result is true. 888 */ 889 EXPECT_TRUE(success); 890 891 /** 892 * @tc.steps: step3. Create a resObj with valid data. 893 * @tc.expect: type is static_cast<int32_t>(ResourceType::INTEGER) 894 */ 895 RefPtr<ResourceObject> resObj2 = 896 AceType::MakeRefPtr<ResourceObject>(1, static_cast<int32_t>(ResourceType::INTEGER), params, "", "", 100000); 897 bool success2 = ResourceParseUtils::ParseResString(resObj2, result); 898 899 /** 900 * @tc.steps: step4. Verify the result. 901 * @tc.expect: result is true. 902 */ 903 EXPECT_TRUE(success2); 904 905 /** 906 * @tc.steps: step5. Create a resObj with valid data. 907 * @tc.expect: type is static_cast<int32_t>(ResourceType::SYMBOL) 908 */ 909 RefPtr<ResourceObject> resObj3 = 910 AceType::MakeRefPtr<ResourceObject>(1, static_cast<int32_t>(ResourceType::SYMBOL), params, "", "", 100000); 911 bool success3 = ResourceParseUtils::ParseResString(resObj3, result); 912 /** 913 * @tc.steps: step6. Verify the result. 914 * @tc.expect: result is false. 915 */ 916 EXPECT_FALSE(success3); 917 } 918 919 /** 920 * @tc.name: ResourceParseUtilsTest024 921 * @tc.desc: Test ReplaceHolder. 922 * @tc.type: FUNC 923 */ 924 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest024, TestSize.Level1) 925 { 926 /** 927 * @tc.steps: step1. Create a params with valid data. 928 * @tc.expect: containCount == size. 929 */ 930 std::string originStr = "Hello"; 931 std::vector<ResourceObjectParams> params; 932 ResourceObjectParams param { .value = "123", .type = ResourceObjectParamType::INT }; 933 params.push_back(param); 934 int32_t containCount = 1; 935 ReplaceHolder(originStr, params, containCount); 936 937 /** 938 * @tc.steps: step2. Verify the result. 939 * @tc.expect: originStr is Hello. 940 */ 941 EXPECT_EQ(originStr, "Hello"); 942 } 943 944 /** 945 * @tc.name: ResourceParseUtilsTest025 946 * @tc.desc: Test ReplaceHolder. 947 * @tc.type: FUNC 948 */ 949 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest025, TestSize.Level1) 950 { 951 /** 952 * @tc.steps: step1. Create a params with valid data. 953 * @tc.expect: firstMatch is true, shortHolderType is true. 954 */ 955 std::string originStr = "Hello_%s"; 956 std::vector<ResourceObjectParams> params; 957 ResourceObjectParams param { .value = "World", .type = ResourceObjectParamType::STRING }; 958 params.push_back(param); 959 int32_t containCount = 0; 960 ReplaceHolder(originStr, params, containCount); 961 962 /** 963 * @tc.steps: step2. Verify the result. 964 * @tc.expect: originStr is Hello_World 965 */ 966 EXPECT_EQ(originStr, "Hello_World"); 967 968 /** 969 * @tc.steps: step3. Create a params with valid data. 970 * @tc.expect: first time firstMatch is true, and second time firstMatch is false, shortHolderType is true. 971 */ 972 std::string originStr2 = "Hello_%s_Welcome_to_%s"; 973 std::vector<ResourceObjectParams> params2; 974 ResourceObjectParams param21 { .value = "friend", .type = ResourceObjectParamType::STRING }; 975 params2.push_back(param21); 976 ResourceObjectParams param22 { .value = "Earth", .type = ResourceObjectParamType::STRING }; 977 params2.push_back(param22); 978 int32_t containCount2 = 0; 979 ReplaceHolder(originStr2, params2, containCount2); 980 981 /** 982 * @tc.steps: step2. Verify the result. 983 * @tc.expect: originStr is Hello_friend_Welcome_to_Earth 984 */ 985 EXPECT_EQ(originStr2, "Hello_friend_Welcome_to_Earth"); 986 EXPECT_EQ(containCount2, 0); 987 } 988 989 /** 990 * @tc.name: ResourceParseUtilsTest026 991 * @tc.desc: Test ReplaceHolder. 992 * @tc.type: FUNC 993 */ 994 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest026, TestSize.Level1) 995 { 996 /** 997 * @tc.steps: step1. Create a params with valid data. 998 * @tc.expect: shortHolderType ^ (pos.length() == 0) is true. 999 */ 1000 std::string originStr = "Hello_%s_and_%1$s"; 1001 std::vector<ResourceObjectParams> params; 1002 ResourceObjectParams param01 { .value = "World", .type = ResourceObjectParamType::STRING }; 1003 ResourceObjectParams param02 { .value = "Earth", .type = ResourceObjectParamType::STRING }; 1004 params.push_back(param01); 1005 params.push_back(param02); 1006 int32_t containCount = 0; 1007 ReplaceHolder(originStr, params, containCount); 1008 1009 /** 1010 * @tc.steps: step2. Verify the result. 1011 * @tc.expect: originStr is Hello_World_and_%1$s 1012 */ 1013 EXPECT_EQ(originStr, "Hello_World_and_%1$s"); 1014 1015 /** 1016 * @tc.steps: step3. Create a params with valid data. 1017 * @tc.expect: shortHolderType is false. 1018 */ 1019 std::string originStr2 = "Hello_%2$s_and_%1$s"; 1020 std::vector<ResourceObjectParams> params2; 1021 ResourceObjectParams param21 { .value = "friend", .type = ResourceObjectParamType::STRING }; 1022 params2.push_back(param21); 1023 ResourceObjectParams param22 { .value = "Earth", .type = ResourceObjectParamType::STRING }; 1024 params2.push_back(param22); 1025 int32_t containCount2 = 0; 1026 ReplaceHolder(originStr2, params2, containCount2); 1027 1028 /** 1029 * @tc.steps: step4. Verify the result. 1030 * @tc.expect: originStr is Hello_Earth_and_friend 1031 */ 1032 EXPECT_EQ(originStr2, "Hello_Earth_and_friend"); 1033 } 1034 1035 /** 1036 * @tc.name: ResourceParseUtilsTest027 1037 * @tc.desc: Test ParseResColorWithColorMode. 1038 * @tc.type: FUNC 1039 */ 1040 HWTEST_F(ResourceParseUtilsTest, ResourceParseUtilsTest027, TestSize.Level1) 1041 { 1042 /** 1043 * @tc.steps: step1. Create a params with invalid data. 1044 * @tc.expect: return false. 1045 */ 1046 RefPtr<ResourceObject> resObj; 1047 ColorMode colorMode = ColorMode::LIGHT; 1048 Color result; 1049 EXPECT_FALSE(ResourceParseUtils::ParseResColorWithColorMode(resObj, result, colorMode)); 1050 1051 /** 1052 * @tc.steps: step2. Create a params with no instanceId. 1053 * @tc.expect: return false. 1054 */ 1055 resObj = AceType::MakeRefPtr<ResourceObject>(); 1056 resObj->SetInstanceId(-1); 1057 resObj->SetIsResource(false); 1058 resObj->SetColorMode(ColorMode::COLOR_MODE_UNDEFINED); 1059 EXPECT_FALSE(ResourceParseUtils::ParseResColorWithColorMode(resObj, result, colorMode)); 1060 1061 /** 1062 * @tc.steps: step2. Create a params with instanceId ok. 1063 * @tc.expect: return false. 1064 */ 1065 resObj->SetInstanceId(100000); 1066 EXPECT_FALSE(ResourceParseUtils::ParseResColorWithColorMode(resObj, result, colorMode)); 1067 } 1068 } // namespace OHOS::Ace 1069