1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "gtest/gtest.h" 17 #include "txt/text_style.h" 18 #include "symbol_engine/hm_symbol_run.h" 19 #include "symbol_engine/hm_symbol_txt.h" 20 21 using namespace testing; 22 using namespace testing::ext; 23 24 namespace OHOS { 25 namespace Rosen { 26 namespace SPText { 27 class OHHmSymbolRunTest : public testing::Test {}; 28 29 30 /* 31 * @tc.name: DrawSymbol001 32 * @tc.desc: test DrawSymbol with one Glyph 33 * @tc.type: FUNC 34 */ 35 HWTEST_F(OHHmSymbolRunTest, DrawSymbol001, TestSize.Level0) 36 { 37 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 38 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 39 HMSymbolTxt symbolTxt; 40 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90102(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 41 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 42 return true; 43 }; 44 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, nullptr, animationFunc); 45 46 // test rsCanvas is nullptr, textblob is nullptr 47 hmSymbolRun.DrawSymbol(nullptr, paint_); 48 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 49 50 // test rsCanvas isn't nullptr, textblob is nullptr 51 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 52 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 53 54 const char* str = "A"; // "A" is one Glyph 55 Drawing::Font font; 56 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 57 HMSymbolRun hmSymbolRun1 = HMSymbolRun(1, symbolTxt, textblob, animationFunc); 58 59 // test rsCanvas is nullptr, textblob isn't nullptr 60 hmSymbolRun1.DrawSymbol(nullptr, paint_); 61 EXPECT_FALSE(hmSymbolRun1.currentAnimationHasPlayed_); 62 63 // test rsCanvas isn't nullptr, textblob isn't nullptr 64 hmSymbolRun1.DrawSymbol(rsCanvas.get(), paint_); 65 EXPECT_FALSE(hmSymbolRun1.currentAnimationHasPlayed_); 66 } 67 68 /* 69 * @tc.name: DrawSymbol002 70 * @tc.desc: test DrawSymbol with Glyphs 71 * @tc.type: FUNC 72 */ 73 HWTEST_F(OHHmSymbolRunTest, DrawSymbol002, TestSize.Level0) 74 { 75 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 76 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 77 const char* str = "Test multiple glyphs"; // "Test multiple glyphs" is Glyphs 78 Drawing::Font font; 79 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 80 HMSymbolTxt symbolTxt; 81 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90202(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 82 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 83 return true; 84 }; 85 86 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 87 88 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 89 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 90 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 91 } 92 93 /* 94 * @tc.name: DrawSymbol003 95 * @tc.desc: test DrawSymbol with animation 96 * @tc.type: FUNC 97 */ 98 HWTEST_F(OHHmSymbolRunTest, DrawSymbol003, TestSize.Level0) 99 { 100 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 101 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 102 const char* str = "A"; 103 Drawing::Font font; 104 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 105 HMSymbolTxt symbolTxt; 106 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90302(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 107 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 108 return true; 109 }; 110 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 111 // test bounce animation 112 hmSymbolRun.SetAnimationStart(true); 113 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::BOUNCE); 114 115 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 116 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 117 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 118 119 // test appear animation 120 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::APPEAR); 121 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 122 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 123 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 124 125 // test pulse aimation, this glyph not support, result is false 126 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::PULSE); 127 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 128 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 129 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 130 } 131 132 /* 133 * @tc.name: DrawSymbol004 134 * @tc.desc: test DrawSymbol for custom symbol 135 * @tc.type: FUNC 136 */ 137 HWTEST_F(OHHmSymbolRunTest, DrawSymbol004, TestSize.Level0) 138 { 139 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 140 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 141 const char* str = "A"; // "A" is Glyphs 142 Drawing::Font font; 143 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 144 HMSymbolTxt symbolTxt; 145 symbolTxt.SetSymbolType(SymbolType::CUSTOM); 146 symbolTxt.SetSymbolEffect(RSEffectStrategy::REPLACE_APPEAR); 147 symbolTxt.SetAnimationMode(1); // the 1 is the byLayer or iterative effect 148 149 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90402(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 150 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { return true; }; 151 152 HMSymbolRun hmSymbolRun = HMSymbolRun(2, symbolTxt, textblob, animationFunc); 153 hmSymbolRun.SetAnimationStart(true); 154 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 155 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 156 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 157 } 158 159 /* 160 * @tc.name: SetSymbolRenderColor001 161 * @tc.desc: test SetSymbolRenderColor with multi colors 162 * @tc.type: FUNC 163 */ 164 HWTEST_F(OHHmSymbolRunTest, SetSymbolRenderColor001, TestSize.Level0) 165 { 166 // step 1: Simulation input 167 RSSColor color1 = {1.0f, 255, 0, 0}; // the 1.0 is alpha, 255, 0, 0 is RGB 168 RSSColor color2 = {0.5f, 0, 255, 0}; // the 0.5 is alpha, 0, 255, 0 is RGB 169 std::vector<RSSColor> colors = {color1, color2}; 170 RSRenderGroup group1; 171 RSRenderGroup group2; 172 RSSymbolLayers symbolInfo; 173 symbolInfo.renderGroups.push_back(group1); 174 symbolInfo.renderGroups.push_back(group2); 175 const char* str = "A"; 176 Drawing::Font font; 177 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 178 HMSymbolTxt symbolTxt; 179 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 180 animationFunc = nullptr; 181 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 182 183 // step 2: Import different RenderingStrategy to test the color result. 184 RSSymbolRenderingStrategy renderMode = RSSymbolRenderingStrategy::SINGLE; 185 hmSymbolRun.SetSymbolRenderColor(renderMode, colors, symbolInfo); 186 EXPECT_EQ(symbolInfo.renderGroups[0].color.r, color1.r); 187 188 renderMode = RSSymbolRenderingStrategy::MULTIPLE_COLOR; 189 hmSymbolRun.SetSymbolRenderColor(renderMode, colors, symbolInfo); 190 EXPECT_EQ(symbolInfo.renderGroups[1].color.a, color2.a); 191 192 renderMode = RSSymbolRenderingStrategy::MULTIPLE_OPACITY; 193 hmSymbolRun.SetSymbolRenderColor(renderMode, {color2}, symbolInfo); 194 EXPECT_NE(symbolInfo.renderGroups[1].color.a, color2.a); 195 } 196 197 /* 198 * @tc.name: SetSymbolRenderColor002 199 * @tc.desc: test SetSymbolRenderColor with one color 200 * @tc.type: FUNC 201 */ 202 HWTEST_F(OHHmSymbolRunTest, SetSymbolRenderColor002, TestSize.Level0) 203 { 204 std::vector<RSSColor> colors = {}; 205 RSSColor color = {1.0f, 0, 255, 0}; // the 1.0 is alpha, 0, 255, 0 is RGB 206 RSRenderGroup group1; 207 group1.color = color; 208 RSSymbolLayers symbolInfo; 209 symbolInfo.renderGroups.push_back(group1); 210 const char* str = "A"; 211 Drawing::Font font; 212 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 213 HMSymbolTxt symbolTxt; 214 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 215 animationFunc = nullptr; 216 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 217 218 // step 2: inputMode is SINGLE, colors is empty. 219 RSSymbolRenderingStrategy renderMode = RSSymbolRenderingStrategy::SINGLE; 220 hmSymbolRun.SetSymbolRenderColor(renderMode, colors, symbolInfo); 221 EXPECT_EQ(symbolInfo.renderGroups[0].color.g, color.g); 222 } 223 224 /* 225 * @tc.name: SymbolAnimation001 226 * @tc.desc: test SymbolAnimation with glyphId 227 * @tc.type: FUNC 228 */ 229 HWTEST_F(OHHmSymbolRunTest, SymbolAnimation001, TestSize.Level0) 230 { 231 uint16_t glyphId = 3; // 3 is an existing GlyphID 232 std::pair<float, float> offset = {100, 100}; // 100, 100 is the offset 233 const char* str = "A"; 234 Drawing::Font font; 235 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 236 HMSymbolTxt symbolTxt; 237 RSHMSymbolData symbol; 238 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 239 animationFunc = nullptr; 240 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 241 bool check = false; 242 hmSymbolRun.UpdateSymbolLayersGroups(glyphId); 243 check = hmSymbolRun.SymbolAnimation(symbol, offset); 244 EXPECT_FALSE(check); 245 } 246 247 /* 248 * @tc.name: GetAnimationGroups001 249 * @tc.desc: test GetAnimationGroups with glyphId 250 * @tc.type: FUNC 251 */ 252 HWTEST_F(OHHmSymbolRunTest, GetAnimationGroups001, TestSize.Level0) 253 { 254 uint16_t glyphId = 3; // 3 is an existing GlyphID 255 RSEffectStrategy effectStrategy = RSEffectStrategy::BOUNCE; 256 RSAnimationSetting animationOut; 257 const char* str = "A"; 258 Drawing::Font font; 259 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 260 HMSymbolTxt symbolTxt; 261 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 262 animationFunc = nullptr; 263 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 264 hmSymbolRun.UpdateSymbolLayersGroups(glyphId); 265 bool flag = hmSymbolRun.GetAnimationGroups(effectStrategy, animationOut); 266 EXPECT_TRUE(flag); 267 } 268 269 /* 270 * @tc.name: GetAnimationGroups002 271 * @tc.desc: test GetAnimationGroups with pulse animation 272 * @tc.type: FUNC 273 */ 274 HWTEST_F(OHHmSymbolRunTest, GetAnimationGroups002, TestSize.Level0) 275 { 276 uint16_t glyphId = 3; // 3 is an existing GlyphID 277 RSEffectStrategy effectStrategy = RSEffectStrategy::PULSE; 278 RSAnimationSetting animationOut; 279 const char* str = "A"; 280 Drawing::Font font; 281 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 282 HMSymbolTxt symbolTxt; 283 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 284 animationFunc = nullptr; 285 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 286 hmSymbolRun.UpdateSymbolLayersGroups(glyphId); 287 bool flag = hmSymbolRun.GetAnimationGroups(effectStrategy, animationOut); 288 EXPECT_FALSE(flag); 289 } 290 291 /* 292 * @tc.name: GetSymbolLayers001 293 * @tc.desc: test GetSymbolLayers with glyphId 294 * @tc.type: FUNC 295 */ 296 HWTEST_F(OHHmSymbolRunTest, GetSymbolLayers001, TestSize.Level0) 297 { 298 // step 1: init data 299 uint16_t glyphId = 3; // 3 is an existing GlyphID 300 RSSColor color = {1.0, 255, 0, 0}; // the 1.0 is alpha, 255, 0, 0 is RGB 301 HMSymbolTxt symbolTxt; 302 symbolTxt.SetRenderColor(color); 303 std::shared_ptr<RSTextBlob> textBlob = nullptr; 304 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = nullptr; 305 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textBlob, animationFunc); 306 auto symbolLayer = hmSymbolRun.GetSymbolLayers(glyphId, symbolTxt); 307 EXPECT_TRUE(symbolLayer.renderGroups.empty()); 308 309 hmSymbolRun.UpdateSymbolLayersGroups(glyphId); 310 symbolLayer = hmSymbolRun.GetSymbolLayers(glyphId, symbolTxt); 311 EXPECT_EQ(symbolLayer.symbolGlyphId, glyphId); 312 313 if (!symbolLayer.renderGroups.empty()) { 314 auto layerColor = symbolLayer.renderGroups[0].color; 315 EXPECT_EQ(layerColor.r, color.r); // the default color is {1.0, 0, 0, 0} 316 } 317 } 318 319 /* 320 * @tc.name: SetRenderColor001 321 * @tc.desc: test SetRenderColor with colorList 322 * @tc.type: FUNC 323 */ 324 HWTEST_F(OHHmSymbolRunTest, SetRenderColor001, TestSize.Level0) 325 { 326 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 327 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 328 const char* str = "A"; 329 Drawing::Font font; 330 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 331 HMSymbolTxt symbolTxt; 332 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90502(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 333 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 334 return true; 335 }; 336 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 337 RSSColor color1 = {1.0, 255, 0, 0}; // the 1.0 is alpha, 255, 0, 0 is RGB 338 RSSColor color2 = {1.0, 0, 0, 0}; // the 1.0 is alpha, 0, 0, 0 is RGB 339 std::vector<RSSColor> rsscolors1 = {color1}; 340 std::vector<RSSColor> rsscolors2 = {color1, color2}; 341 342 hmSymbolRun.SetAnimationStart(true); 343 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::BOUNCE); 344 345 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 346 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 347 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 348 349 hmSymbolRun.SetRenderColor(rsscolors1); 350 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 351 auto ret1 = hmSymbolRun.symbolTxt_.GetRenderColor(); 352 EXPECT_EQ(ret1.size(), 1); 353 354 hmSymbolRun.SetRenderColor(rsscolors2); 355 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 356 auto ret2 = hmSymbolRun.symbolTxt_.GetRenderColor(); 357 EXPECT_EQ(ret2.size(), 2); 358 } 359 360 /* 361 * @tc.name: SetRenderMode001 362 * @tc.desc: test SetRenderMode with SINGLE 363 * @tc.type: FUNC 364 */ 365 HWTEST_F(OHHmSymbolRunTest, SetRenderMode001, TestSize.Level0) 366 { 367 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 368 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 369 const char* str = "A"; 370 Drawing::Font font; 371 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 372 HMSymbolTxt symbolTxt; 373 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90602(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 374 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 375 return true; 376 }; 377 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 378 hmSymbolRun.SetAnimationStart(true); 379 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::BOUNCE); 380 381 hmSymbolRun.currentAnimationHasPlayed_ = true; 382 hmSymbolRun.SetRenderMode(Drawing::DrawingSymbolRenderingStrategy::SINGLE); 383 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetRenderMode(), Drawing::DrawingSymbolRenderingStrategy::SINGLE); 384 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 385 } 386 387 /* 388 * @tc.name: SetRenderMode002 389 * @tc.desc: test SetRenderMode with MULTIPLE_COLOR 390 * @tc.type: FUNC 391 */ 392 HWTEST_F(OHHmSymbolRunTest, SetRenderMode002, TestSize.Level0) 393 { 394 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 395 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 396 const char* str = "A"; 397 Drawing::Font font; 398 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 399 HMSymbolTxt symbolTxt; 400 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90702(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 401 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 402 return true; 403 }; 404 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 405 hmSymbolRun.SetAnimationStart(true); 406 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::BOUNCE); 407 408 hmSymbolRun.currentAnimationHasPlayed_ = true; 409 hmSymbolRun.SetRenderMode(Drawing::DrawingSymbolRenderingStrategy::MULTIPLE_COLOR); 410 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetRenderMode(), Drawing::DrawingSymbolRenderingStrategy::MULTIPLE_COLOR); 411 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 412 } 413 414 /* 415 * @tc.name: SetRenderMode003 416 * @tc.desc: test SetRenderMode with MULTIPLE_OPACITY 417 * @tc.type: FUNC 418 */ 419 HWTEST_F(OHHmSymbolRunTest, SetRenderMode003, TestSize.Level0) 420 { 421 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 422 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 423 const char* str = "A"; 424 Drawing::Font font; 425 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 426 HMSymbolTxt symbolTxt; 427 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90802(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 428 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 429 return true; 430 }; 431 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 432 hmSymbolRun.SetAnimationStart(true); 433 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::BOUNCE); 434 435 hmSymbolRun.currentAnimationHasPlayed_ = true; 436 hmSymbolRun.SetRenderMode(Drawing::DrawingSymbolRenderingStrategy::MULTIPLE_OPACITY); 437 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetRenderMode(), Drawing::DrawingSymbolRenderingStrategy::MULTIPLE_OPACITY); 438 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 439 } 440 441 /* 442 * @tc.name: SetSymbolEffect001 443 * @tc.desc: test SetSymbolEffect with DrawingEffectStrategy::NONE 444 * @tc.type: FUNC 445 */ 446 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect001, TestSize.Level0) 447 { 448 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 449 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 450 const char* str = "A"; 451 Drawing::Font font; 452 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 453 HMSymbolTxt symbolTxt; 454 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90902(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 455 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 456 return true; 457 }; 458 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 459 hmSymbolRun.SetAnimationStart(true); 460 hmSymbolRun.currentAnimationHasPlayed_ = true; 461 462 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::NONE); 463 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::NONE); 464 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 465 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 466 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 467 } 468 469 /* 470 * @tc.name: SetSymbolEffect002 471 * @tc.desc: test SetSymbolEffect with DrawingEffectStrategy::SCALE 472 * @tc.type: FUNC 473 */ 474 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect002, TestSize.Level0) 475 { 476 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 477 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 478 const char* str = "A"; 479 Drawing::Font font; 480 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 481 HMSymbolTxt symbolTxt; 482 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90a02(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 483 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 484 return true; 485 }; 486 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 487 hmSymbolRun.SetAnimationStart(true); 488 hmSymbolRun.currentAnimationHasPlayed_ = true; 489 490 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::SCALE); 491 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::SCALE); 492 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 493 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 494 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 495 } 496 497 /* 498 * @tc.name: SetSymbolEffect003 499 * @tc.desc: test SetSymbolEffect with DrawingEffectStrategy::VARIABLE_COLOR 500 * @tc.type: FUNC 501 */ 502 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect003, TestSize.Level0) 503 { 504 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 505 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 506 const char* str = "A"; 507 Drawing::Font font; 508 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 509 HMSymbolTxt symbolTxt; 510 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90b02(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 511 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 512 return true; 513 }; 514 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 515 hmSymbolRun.SetAnimationStart(true); 516 hmSymbolRun.currentAnimationHasPlayed_ = true; 517 518 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::VARIABLE_COLOR); 519 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::VARIABLE_COLOR); 520 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 521 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 522 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 523 } 524 525 /* 526 * @tc.name: SetSymbolEffect004 527 * @tc.desc: test SetSymbolEffect with DrawingEffectStrategy::APPEAR 528 * @tc.type: FUNC 529 */ 530 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect004, TestSize.Level0) 531 { 532 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 533 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 534 const char* str = "A"; 535 Drawing::Font font; 536 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 537 HMSymbolTxt symbolTxt; 538 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90c02(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 539 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 540 return true; 541 }; 542 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 543 hmSymbolRun.SetAnimationStart(true); 544 hmSymbolRun.currentAnimationHasPlayed_ = true; 545 546 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::APPEAR); 547 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::APPEAR); 548 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 549 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 550 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 551 } 552 553 /* 554 * @tc.name: SetSymbolEffect005 555 * @tc.desc: test SetSymbolEffect with different DrawingEffectStrategy::DISAPPEAR 556 * @tc.type: FUNC 557 */ 558 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect005, TestSize.Level0) 559 { 560 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 561 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 562 const char* str = "A"; 563 Drawing::Font font; 564 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 565 HMSymbolTxt symbolTxt; 566 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90d02(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 567 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 568 return true; 569 }; 570 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 571 hmSymbolRun.SetAnimationStart(true); 572 hmSymbolRun.currentAnimationHasPlayed_ = true; 573 574 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::DISAPPEAR); 575 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::DISAPPEAR); 576 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 577 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 578 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 579 } 580 581 /* 582 * @tc.name: SetSymbolEffect006 583 * @tc.desc: test SetSymbolEffect with different DrawingEffectStrategy::BOUNCE 584 * @tc.type: FUNC 585 */ 586 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect006, TestSize.Level0) 587 { 588 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 589 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 590 const char* str = "A"; 591 Drawing::Font font; 592 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 593 HMSymbolTxt symbolTxt; 594 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90e02(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 595 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 596 return true; 597 }; 598 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 599 hmSymbolRun.SetAnimationStart(true); 600 hmSymbolRun.currentAnimationHasPlayed_ = true; 601 602 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::BOUNCE); 603 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::BOUNCE); 604 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 605 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 606 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 607 } 608 609 /* 610 * @tc.name: SetSymbolEffect007 611 * @tc.desc: test SetSymbolEffect with different DrawingEffectStrategy::PULSE 612 * @tc.type: FUNC 613 */ 614 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect007, TestSize.Level0) 615 { 616 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 617 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 618 const char* str = "A"; 619 Drawing::Font font; 620 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 621 HMSymbolTxt symbolTxt; 622 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba90f02(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 623 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 624 return true; 625 }; 626 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 627 hmSymbolRun.SetAnimationStart(true); 628 hmSymbolRun.currentAnimationHasPlayed_ = true; 629 630 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::PULSE); 631 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::PULSE); 632 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 633 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 634 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 635 } 636 637 /* 638 * @tc.name: SetSymbolEffect008 639 * @tc.desc: test SetSymbolEffect with different DrawingEffectStrategy::REPLACE_APPEAR 640 * @tc.type: FUNC 641 */ 642 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect008, TestSize.Level0) 643 { 644 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 645 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 646 const char* str = "A"; 647 Drawing::Font font; 648 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 649 HMSymbolTxt symbolTxt; 650 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba91002(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 651 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 652 return true; 653 }; 654 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 655 hmSymbolRun.SetAnimationStart(true); 656 hmSymbolRun.currentAnimationHasPlayed_ = true; 657 658 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::REPLACE_APPEAR); 659 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::REPLACE_APPEAR); 660 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 661 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 662 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 663 } 664 665 /* 666 * @tc.name: SetSymbolEffect009 667 * @tc.desc: test SetSymbolEffect with different DrawingEffectStrategy::QUICK_REPLACE_APPEAR 668 * @tc.type: FUNC 669 */ 670 HWTEST_F(OHHmSymbolRunTest, SetSymbolEffect009, TestSize.Level0) 671 { 672 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 673 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 674 const char* str = "A"; 675 Drawing::Font font; 676 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 677 HMSymbolTxt symbolTxt; 678 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba91102(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 679 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 680 return true; 681 }; 682 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 683 hmSymbolRun.SetAnimationStart(true); 684 hmSymbolRun.currentAnimationHasPlayed_ = true; 685 686 hmSymbolRun.SetSymbolEffect(Drawing::DrawingEffectStrategy::QUICK_REPLACE_APPEAR); 687 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetEffectStrategy(), Drawing::DrawingEffectStrategy::QUICK_REPLACE_APPEAR); 688 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 689 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); // Draw once for Appear 690 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); // Draw twice for DisAppear 691 } 692 693 /* 694 * @tc.name: SetAnimationMode001 695 * @tc.desc: test SetAnimationMode with wholeSymbol 696 * @tc.type: FUNC 697 */ 698 HWTEST_F(OHHmSymbolRunTest, SetAnimationMode001, TestSize.Level0) 699 { 700 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 701 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 702 const char* str = "A"; 703 Drawing::Font font; 704 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 705 HMSymbolTxt symbolTxt; 706 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba91202(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 707 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 708 return true; 709 }; 710 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 711 hmSymbolRun.SetAnimationStart(true); 712 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::VARIABLE_COLOR); 713 714 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 715 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 716 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 717 718 hmSymbolRun.SetAnimationMode(0); // the 0 is the wholeSymbol or cumulative effect 719 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetAnimationMode(), 0); 720 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 721 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 722 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 723 } 724 725 /* 726 * @tc.name: SetAnimationMode002 727 * @tc.desc: test SetAnimationMode with byLayer 728 * @tc.type: FUNC 729 */ 730 HWTEST_F(OHHmSymbolRunTest, SetAnimationMode002, TestSize.Level0) 731 { 732 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 733 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 734 const char* str = "A"; 735 Drawing::Font font; 736 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 737 HMSymbolTxt symbolTxt; 738 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba91302(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 739 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 740 return true; 741 }; 742 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 743 hmSymbolRun.SetAnimationStart(true); 744 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::VARIABLE_COLOR); 745 746 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 747 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 748 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 749 750 hmSymbolRun.SetAnimationMode(1); // the 1 is the byLayer or iteratuve effect 751 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetAnimationMode(), 1); 752 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 753 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 754 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 755 } 756 757 /* 758 * @tc.name: SetAnimationMode003 759 * @tc.desc: test SetAnimationMode with invalid value 760 * @tc.type: FUNC 761 */ 762 HWTEST_F(OHHmSymbolRunTest, SetAnimationMode003, TestSize.Level0) 763 { 764 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 765 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 766 const char* str = "A"; 767 Drawing::Font font; 768 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 769 HMSymbolTxt symbolTxt; 770 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba91402(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 771 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 772 return true; 773 }; 774 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 775 hmSymbolRun.SetAnimationStart(true); 776 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::VARIABLE_COLOR); 777 778 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 779 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 780 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 781 782 hmSymbolRun.SetAnimationMode(500); // 500 is test Boundary Value 783 EXPECT_NE(hmSymbolRun.symbolTxt_.GetAnimationMode(), 500); 784 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetAnimationMode(), 1); 785 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 786 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 787 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 788 } 789 790 /* 791 * @tc.name: SetAnimationStart001 792 * @tc.desc: test SetAnimationStart with animationStart 793 * @tc.type: FUNC 794 */ 795 HWTEST_F(OHHmSymbolRunTest, SetAnimationStart001, TestSize.Level0) 796 { 797 const char* str = "A"; 798 Drawing::Font font; 799 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 800 HMSymbolTxt symbolTxt; 801 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 802 animationFunc = nullptr; 803 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 804 EXPECT_FALSE(hmSymbolRun.symbolTxt_.GetAnimationStart()); 805 hmSymbolRun.SetAnimationStart(true); 806 EXPECT_TRUE(hmSymbolRun.symbolTxt_.GetAnimationStart()); 807 } 808 809 /* 810 * @tc.name: SetCommonSubType001 811 * @tc.desc: test SetCommonSubType with commonSubType::DOWN 812 * @tc.type: FUNC 813 */ 814 HWTEST_F(OHHmSymbolRunTest, SetCommonSubType001, TestSize.Level0) 815 { 816 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 817 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 818 const char* str = "A"; 819 Drawing::Font font; 820 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 821 HMSymbolTxt symbolTxt; 822 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba91502(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 823 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 824 return true; 825 }; 826 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 827 hmSymbolRun.SetAnimationStart(true); 828 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::BOUNCE); 829 830 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 831 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 832 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 833 834 hmSymbolRun.SetCommonSubType(Drawing::DrawingCommonSubType::DOWN); 835 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetCommonSubType(), Drawing::DrawingCommonSubType::DOWN); 836 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 837 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 838 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 839 } 840 841 /* 842 * @tc.name: SetCommonSubType002 843 * @tc.desc: test SetCommonSubType with commonSubType::UP 844 * @tc.type: FUNC 845 */ 846 HWTEST_F(OHHmSymbolRunTest, SetCommonSubType002, TestSize.Level0) 847 { 848 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 849 RSPoint paint_ = {100, 100}; // 100, 100 is the offset 850 const char* str = "A"; 851 Drawing::Font font; 852 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 853 HMSymbolTxt symbolTxt; 854 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc = __anon3fdffba91602(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 855 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 856 return true; 857 }; 858 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 859 hmSymbolRun.SetAnimationStart(true); 860 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::BOUNCE); 861 862 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 863 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 864 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 865 866 hmSymbolRun.SetCommonSubType(Drawing::DrawingCommonSubType::UP); 867 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetCommonSubType(), Drawing::DrawingCommonSubType::UP); 868 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 869 hmSymbolRun.DrawSymbol(rsCanvas.get(), paint_); 870 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 871 } 872 873 /* 874 * @tc.name: SetTextBlob001 875 * @tc.desc: test SetTextBlob with null textBlob 876 * @tc.type: FUNC 877 */ 878 HWTEST_F(OHHmSymbolRunTest, SetTextBlob001, TestSize.Level0) 879 { 880 Drawing::Font font; 881 const char* str1 = "A"; 882 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 883 HMSymbolTxt symbolTxt; 884 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 885 animationFunc = nullptr; 886 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 887 888 EXPECT_NE(hmSymbolRun.textBlob_, nullptr); 889 hmSymbolRun.SetTextBlob(nullptr); 890 EXPECT_NE(hmSymbolRun.textBlob_, nullptr); 891 } 892 893 /* 894 * @tc.name: SetTextBlob002 895 * @tc.desc: test SetTextBlob with same content(before:"A",after:"A",Corresponding truth table: 111) 896 * @tc.type: FUNC 897 */ 898 HWTEST_F(OHHmSymbolRunTest, SetTextBlob002, TestSize.Level0) 899 { 900 Drawing::Font font; 901 const char* str1 = "A"; 902 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 903 HMSymbolTxt symbolTxt; 904 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 905 animationFunc = nullptr; 906 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 907 908 //glyphId1:"A", glyphId2:"A" 909 //glyphId1.size() == 1,glyphId2.size() == 1,glyphId1[0] == glyphId2[0] 910 const char* str2 = "A"; 911 auto textblob2 = Drawing::TextBlob::MakeFromText(str2, strlen(str2), font, Drawing::TextEncoding::UTF8); 912 hmSymbolRun.currentAnimationHasPlayed_ = true; 913 hmSymbolRun.SetTextBlob(textblob2); 914 EXPECT_TRUE(hmSymbolRun.currentAnimationHasPlayed_); 915 } 916 917 /* 918 * @tc.name: SetTextBlob003 919 * @tc.desc: test SetTextBlob with different content(before:"A",after:"B",Corresponding truth table: 110) 920 * @tc.type: FUNC 921 */ 922 HWTEST_F(OHHmSymbolRunTest, SetTextBlob003, TestSize.Level0) 923 { 924 Drawing::Font font; 925 const char* str1 = "A"; 926 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 927 HMSymbolTxt symbolTxt; 928 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 929 animationFunc = nullptr; 930 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 931 932 //glyphId1:"A", glyphId2:"B" 933 //glyphId1.size() == 1,glyphId2.size() == 1,glyphId1[0] != glyphId2[0] 934 const char* str2 = "B"; 935 auto textblob2 = Drawing::TextBlob::MakeFromText(str2, strlen(str2), font, Drawing::TextEncoding::UTF8); 936 hmSymbolRun.SetTextBlob(textblob2); 937 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 938 } 939 940 /* 941 * @tc.name: SetTextBlob004 942 * @tc.desc: test SetTextBlob with different content(before:"A",after:"AB",Corresponding truth table: 101) 943 * @tc.type: FUNC 944 */ 945 HWTEST_F(OHHmSymbolRunTest, SetTextBlob004, TestSize.Level0) 946 { 947 Drawing::Font font; 948 const char* str1 = "A"; 949 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 950 HMSymbolTxt symbolTxt; 951 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 952 animationFunc = nullptr; 953 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 954 955 //glyphId1:"A", glyphId2:"AB" 956 //glyphId1.size() == 1,glyphId2.size() != 1,glyphId1[0] == glyphId2[0] 957 const char* str2 = "AB"; 958 auto textblob2 = Drawing::TextBlob::MakeFromText(str2, strlen(str2), font, Drawing::TextEncoding::UTF8); 959 hmSymbolRun.currentAnimationHasPlayed_ = true; 960 hmSymbolRun.SetTextBlob(textblob2); 961 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 962 } 963 964 /* 965 * @tc.name: SetTextBlob005 966 * @tc.desc: test SetTextBlob with different content(before:"A",after:"BA",Corresponding truth table: 100) 967 * @tc.type: FUNC 968 */ 969 HWTEST_F(OHHmSymbolRunTest, SetTextBlob005, TestSize.Level0) 970 { 971 Drawing::Font font; 972 const char* str1 = "A"; 973 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 974 HMSymbolTxt symbolTxt; 975 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 976 animationFunc = nullptr; 977 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 978 979 //glyphId1:"A", glyphId2:"BA" 980 //glyphId1.size() == 1,glyphId2.size() != 1,glyphId1[0] != glyphId2[0] 981 const char* str2 = "BA"; 982 auto textblob2 = Drawing::TextBlob::MakeFromText(str2, strlen(str2), font, Drawing::TextEncoding::UTF8); 983 hmSymbolRun.currentAnimationHasPlayed_ = true; 984 hmSymbolRun.SetTextBlob(textblob2); 985 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 986 } 987 988 /* 989 * @tc.name: SetTextBlob006 990 * @tc.desc: test SetTextBlob with different content(before:"AB",after:"A",Corresponding truth table: 011) 991 * @tc.type: FUNC 992 */ 993 HWTEST_F(OHHmSymbolRunTest, SetTextBlob006, TestSize.Level0) 994 { 995 Drawing::Font font; 996 const char* str1 = "AB"; 997 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 998 HMSymbolTxt symbolTxt; 999 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 1000 animationFunc = nullptr; 1001 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 1002 1003 //glyphId1:"AB", glyphId2:"A" 1004 //glyphId1.size() != 1,glyphId2.size() == 1,glyphId1[0] == glyphId2[0] 1005 const char* str2 = "A"; 1006 auto textblob2 = Drawing::TextBlob::MakeFromText(str2, strlen(str2), font, Drawing::TextEncoding::UTF8); 1007 hmSymbolRun.currentAnimationHasPlayed_ = true; 1008 hmSymbolRun.SetTextBlob(textblob2); 1009 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 1010 } 1011 1012 /* 1013 * @tc.name: SetTextBlob007 1014 * @tc.desc: test SetTextBlob with different content(before:"AB",after:"B",Corresponding truth table: 010) 1015 * @tc.type: FUNC 1016 */ 1017 HWTEST_F(OHHmSymbolRunTest, SetTextBlob007, TestSize.Level0) 1018 { 1019 Drawing::Font font; 1020 const char* str1 = "AB"; 1021 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 1022 HMSymbolTxt symbolTxt; 1023 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 1024 animationFunc = nullptr; 1025 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 1026 1027 //glyphId1:"AB", glyphId2:"B" 1028 //glyphId1.size() != 1,glyphId2.size() == 1,glyphId1[0] != glyphId2[0] 1029 const char* str2 = "B"; 1030 auto textblob2 = Drawing::TextBlob::MakeFromText(str2, strlen(str2), font, Drawing::TextEncoding::UTF8); 1031 hmSymbolRun.currentAnimationHasPlayed_ = true; 1032 hmSymbolRun.SetTextBlob(textblob2); 1033 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 1034 } 1035 1036 /* 1037 * @tc.name: SetTextBlob008 1038 * @tc.desc: test SetTextBlob with different content(before:"AB",after:"AC",Corresponding truth table: 001) 1039 * @tc.type: FUNC 1040 */ 1041 HWTEST_F(OHHmSymbolRunTest, SetTextBlob008, TestSize.Level0) 1042 { 1043 Drawing::Font font; 1044 const char* str1 = "AB"; 1045 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 1046 HMSymbolTxt symbolTxt; 1047 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 1048 animationFunc = nullptr; 1049 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 1050 1051 //glyphId1:"AB", glyphId2:"AC" 1052 //glyphId1.size() != 1,glyphId2.size() != 1,glyphId1[0] == glyphId2[0] 1053 const char* str2 = "AC"; 1054 auto textblob2 = Drawing::TextBlob::MakeFromText(str2, strlen(str2), font, Drawing::TextEncoding::UTF8); 1055 hmSymbolRun.currentAnimationHasPlayed_ = true; 1056 hmSymbolRun.SetTextBlob(textblob2); 1057 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 1058 } 1059 1060 /* 1061 * @tc.name: SetTextBlob009 1062 * @tc.desc: test SetTextBlob with different content(before:"AB",after:"BA",Corresponding truth table: 000) 1063 * @tc.type: FUNC 1064 */ 1065 HWTEST_F(OHHmSymbolRunTest, SetTextBlob009, TestSize.Level0) 1066 { 1067 Drawing::Font font; 1068 const char* str1 = "AB"; 1069 auto textblob1 = Drawing::TextBlob::MakeFromText(str1, strlen(str1), font, Drawing::TextEncoding::UTF8); 1070 HMSymbolTxt symbolTxt; 1071 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 1072 animationFunc = nullptr; 1073 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob1, animationFunc); 1074 1075 //glyphId1:"AB", glyphId2:"BA" 1076 //glyphId1.size() != 1,glyphId2.size() != 1,glyphId1[0] != glyphId2[0] 1077 const char* str2 = "BA"; 1078 auto textblob2 = Drawing::TextBlob::MakeFromText(str2, strlen(str2), font, Drawing::TextEncoding::UTF8); 1079 hmSymbolRun.currentAnimationHasPlayed_ = true; 1080 hmSymbolRun.SetTextBlob(textblob2); 1081 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 1082 } 1083 1084 /* 1085 * @tc.name: SetAnimation001 1086 * @tc.desc: test SetAnimation with animationFunc 1087 * @tc.type: FUNC 1088 */ 1089 HWTEST_F(OHHmSymbolRunTest, SetAnimation001, TestSize.Level0) 1090 { 1091 const char* str = "A"; 1092 Drawing::Font font; 1093 auto textblob = Drawing::TextBlob::MakeFromText(str, strlen(str), font, Drawing::TextEncoding::UTF8); 1094 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 1095 animationFunc = nullptr; 1096 HMSymbolTxt symbolTxt; 1097 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textblob, animationFunc); 1098 EXPECT_EQ(hmSymbolRun.animationFunc_, nullptr); 1099 1100 std::function<bool(const std::shared_ptr<TextEngine::SymbolAnimationConfig>&)> animationFunc1 = __anon3fdffba91702(const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) 1101 [](const std::shared_ptr<TextEngine::SymbolAnimationConfig>& symbolAnimationConfig) { 1102 return true; 1103 }; 1104 hmSymbolRun.SetAnimation(animationFunc1); 1105 EXPECT_NE(hmSymbolRun.animationFunc_, nullptr); 1106 hmSymbolRun.SetAnimation(animationFunc); 1107 EXPECT_NE(hmSymbolRun.animationFunc_, nullptr); 1108 } 1109 1110 /* 1111 * @tc.name: UpdateSymbolLayersGroups001 1112 * @tc.desc: test UpdateSymbolLayersGroups 1113 * @tc.type: FUNC 1114 */ 1115 HWTEST_F(OHHmSymbolRunTest, UpdateSymbolLayersGroups001, TestSize.Level0) 1116 { 1117 HMSymbolTxt symbolTxt; 1118 symbolTxt.SetSymbolType(SymbolType::SYSTEM); 1119 std::function<bool(const std::shared_ptr<OHOS::Rosen::TextEngine::SymbolAnimationConfig>&)> 1120 animationFunc = nullptr; 1121 std::shared_ptr<RSTextBlob> textBlob = nullptr; 1122 HMSymbolRun hmSymbolRun = HMSymbolRun(0, symbolTxt, textBlob, animationFunc); 1123 uint16_t glyphId = 3; // 3 is an existing GlyphID 1124 hmSymbolRun.UpdateSymbolLayersGroups(glyphId); 1125 EXPECT_EQ(hmSymbolRun.symbolLayersGroups_.symbolGlyphId, glyphId); 1126 1127 glyphId = 0; // 0 is a nonexistent GlyphID 1128 HMSymbolRun hmSymbolRun1 = HMSymbolRun(0, symbolTxt, textBlob, animationFunc); 1129 hmSymbolRun1.UpdateSymbolLayersGroups(glyphId); 1130 EXPECT_TRUE(hmSymbolRun1.symbolLayersGroups_.renderModeGroups.empty()); 1131 1132 symbolTxt.SetSymbolType(SymbolType::CUSTOM); 1133 HMSymbolRun hmSymbolRun2 = HMSymbolRun(0, symbolTxt, textBlob, animationFunc); 1134 hmSymbolRun2.UpdateSymbolLayersGroups(glyphId); 1135 EXPECT_TRUE(hmSymbolRun2.symbolLayersGroups_.renderModeGroups.empty()); 1136 } 1137 1138 /* 1139 * @tc.name: SymbolUid001 1140 * @tc.desc: test GetSymbolUid and GetSymbolUid 1141 * @tc.type: FUNC 1142 */ 1143 HWTEST_F(OHHmSymbolRunTest, SymbolUid001, TestSize.Level0) 1144 { 1145 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1146 EXPECT_EQ(hmSymbolRun.GetSymbolUid(), 0); 1147 hmSymbolRun.SetSymbolUid(100); 1148 EXPECT_EQ(hmSymbolRun.GetSymbolUid(), 100); 1149 } 1150 1151 /* 1152 * @tc.name: SymbolTxt001 1153 * @tc.desc: test GetSymbolTxt and SetSymbolTxt 1154 * @tc.type: FUNC 1155 */ 1156 HWTEST_F(OHHmSymbolRunTest, SymbolTxt001, TestSize.Level0) 1157 { 1158 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1159 1160 //test get method 1161 HMSymbolTxt hmSymbolEmpty; 1162 HMSymbolTxt hmSymbolTxt = hmSymbolRun.GetSymbolTxt(); 1163 EXPECT_EQ(hmSymbolEmpty, hmSymbolTxt); 1164 1165 //test set method 1166 HMSymbolTxt hmSymbolTest; 1167 hmSymbolTest.SetRenderMode(Drawing::DrawingSymbolRenderingStrategy::MULTIPLE_COLOR); 1168 hmSymbolRun.SetSymbolTxt(hmSymbolTest); 1169 1170 EXPECT_EQ(hmSymbolRun.GetSymbolTxt().GetRenderMode(), Drawing::DrawingSymbolRenderingStrategy::MULTIPLE_COLOR); 1171 } 1172 1173 /* 1174 * @tc.name: SymbolAnimationTest001 1175 * @tc.desc: test SymbolAnimation with disable effectStrategy 1176 * @tc.type: FUNC 1177 */ 1178 HWTEST_F(OHHmSymbolRunTest, SymbolAnimationTest001, TestSize.Level0) 1179 { 1180 // init data 1181 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1182 hmSymbolRun.SetSymbolEffect(RSEffectStrategy::DISABLE); 1183 RSHMSymbolData symbol; 1184 std::pair<float, float> offsetXY(10.0f, 15.0f); // 10.0f is x, 15.0f is y of offset 1185 Drawing::DrawingAnimationSetting animationSettingOne = { 1186 // animationTypes 1187 { 1188 Drawing::DrawingAnimationType::DISABLE_TYPE 1189 }, 1190 // groupSettings 1191 { 1192 // {0, 1}: layerIndes, 0: animationIndex 1193 {{{{0, 1}}}, 0} 1194 } 1195 }; 1196 hmSymbolRun.symbolLayersGroups_.animationSettings.push_back(animationSettingOne); 1197 // test SymbolAnimation by DISABLE 1198 bool result = hmSymbolRun.SymbolAnimation(symbol, offsetXY); 1199 EXPECT_FALSE(result); 1200 std::vector<std::shared_ptr<SymbolGradient>> gradients; 1201 gradients.push_back(std::make_shared<SymbolGradient>()); 1202 hmSymbolRun.gradients_ = gradients; 1203 gradients.push_back(std::make_shared<SymbolGradient>()); 1204 SymbolColor symbolColor = {SymbolColorType::GRADIENT_TYPE, gradients}; 1205 hmSymbolRun.SetSymbolColor(symbolColor); 1206 hmSymbolRun.SetRenderMode(RSSymbolRenderingStrategy::MULTIPLE_COLOR); 1207 result = hmSymbolRun.SymbolAnimation(symbol, offsetXY); 1208 EXPECT_FALSE(result); 1209 } 1210 1211 /* 1212 * @tc.name: SetGradients001 1213 * @tc.desc: test SetGradients 1214 * @tc.type: FUNC 1215 */ 1216 HWTEST_F(OHHmSymbolRunTest, SetGradients001, TestSize.Level0) 1217 { 1218 uint16_t glyphId = 3; // 3 is an existing GlyphID 1219 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1220 auto color1 = std::make_shared<SymbolGradient>(); 1221 color1->SetColors({0XFFFF0000}); // 0XFFFF0000 is ARGB 1222 auto color2 = std::make_shared<SymbolGradient>(); 1223 color2->SetColors({0XFF0000FF}); // 0XFF0000FF is ARGB 1224 SymbolColor symbolColor = {SymbolColorType::GRADIENT_TYPE, {color1, color2}}; 1225 SPText::HMSymbolTxt symbolTxt; 1226 symbolTxt.SetSymbolColor(symbolColor); 1227 hmSymbolRun.SetSymbolTxt(symbolTxt); 1228 hmSymbolRun.UpdateSymbolLayersGroups(glyphId); 1229 auto symbolLayer = hmSymbolRun.GetSymbolLayers(glyphId, symbolTxt); 1230 1231 std::vector<std::shared_ptr<SymbolGradient>> gradients = {}; 1232 symbolColor.colorType = SymbolColorType::GRADIENT_TYPE; 1233 symbolColor.gradients = gradients; 1234 hmSymbolRun.SetSymbolColor(symbolColor); 1235 symbolLayer = hmSymbolRun.GetSymbolLayers(glyphId, symbolTxt); 1236 EXPECT_EQ(symbolLayer.symbolGlyphId, glyphId); 1237 } 1238 1239 /* 1240 * @tc.name: SetGradientColor001 1241 * @tc.desc: test SetGradientColor 1242 * @tc.type: FUNC 1243 */ 1244 HWTEST_F(OHHmSymbolRunTest, SetGradientColor001, TestSize.Level0) 1245 { 1246 // test gradients is empty 1247 RSSymbolRenderingStrategy renderMode = RSSymbolRenderingStrategy::SINGLE; 1248 RSSymbolLayers symbolInfo; 1249 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1250 hmSymbolRun.SetGradientColor(renderMode, symbolInfo); 1251 EXPECT_TRUE(hmSymbolRun.gradients_.empty()); 1252 1253 // test gradients is not empty 1254 std::vector<std::shared_ptr<SymbolGradient>> gradients; 1255 gradients.push_back(std::make_shared<SymbolGradient>()); 1256 gradients.push_back(std::make_shared<SymbolGradient>()); 1257 SymbolColor symbolColor = {SymbolColorType::GRADIENT_TYPE, gradients}; 1258 hmSymbolRun.SetSymbolColor(symbolColor); 1259 hmSymbolRun.SetGradientColor(renderMode, symbolInfo); 1260 EXPECT_TRUE(hmSymbolRun.gradients_.size() == 1); 1261 1262 // test renderMode is MULTIPLE_COLOR 1263 renderMode = RSSymbolRenderingStrategy::MULTIPLE_COLOR; 1264 symbolInfo.renderGroups.push_back({}); 1265 symbolInfo.renderGroups.push_back({}); 1266 gradients[0] = nullptr; 1267 symbolColor.gradients = gradients; 1268 hmSymbolRun.SetSymbolColor(symbolColor); 1269 hmSymbolRun.SetGradientColor(renderMode, symbolInfo); 1270 EXPECT_FALSE(hmSymbolRun.gradients_.empty()); 1271 1272 gradients = {}; 1273 gradients.push_back(std::make_shared<SymbolLineGradient>(50.0f)); // 50.0f is angle of lineGradient 1274 symbolColor.gradients = gradients; 1275 hmSymbolRun.SetSymbolColor(symbolColor); 1276 hmSymbolRun.SetGradientColor(renderMode, symbolInfo); 1277 EXPECT_FALSE(hmSymbolRun.gradients_.empty()); 1278 } 1279 1280 /* 1281 * @tc.name: SetDrawPath001 1282 * @tc.desc: test SetDrawPath 1283 * @tc.type: FUNC 1284 */ 1285 HWTEST_F(OHHmSymbolRunTest, SetDrawPath001, TestSize.Level0) 1286 { 1287 // test renderMode is SINGLE 1288 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 1289 RSSymbolRenderingStrategy renderMode = RSSymbolRenderingStrategy::SINGLE; 1290 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1291 hmSymbolRun.SetRenderMode(renderMode); 1292 std::vector<RSPath> multPaths; 1293 RSPath path; 1294 hmSymbolRun.DrawPaths(rsCanvas.get(), multPaths, path); 1295 EXPECT_TRUE(hmSymbolRun.gradients_.empty()); 1296 1297 // Test multPaths not is empty 1298 path.AddCircle(100.0f, 100.0f, 50.0f); // 100.0f x, 100.0f y, 50.0f radius 1299 multPaths.push_back(path); 1300 std::vector<std::shared_ptr<SymbolGradient>> gradients; 1301 gradients.push_back(std::make_shared<SymbolGradient>()); 1302 gradients.push_back(std::make_shared<SymbolGradient>()); 1303 SymbolColor symbolColor = {SymbolColorType::GRADIENT_TYPE, gradients}; 1304 hmSymbolRun.SetSymbolColor(symbolColor); 1305 hmSymbolRun.DrawPaths(rsCanvas.get(), multPaths, path); 1306 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetRenderMode(), RSSymbolRenderingStrategy::SINGLE); 1307 1308 // test renderMode is MULTIPLE_COLOR 1309 renderMode = RSSymbolRenderingStrategy::MULTIPLE_COLOR; 1310 hmSymbolRun.SetRenderMode(renderMode); 1311 hmSymbolRun.gradients_ = gradients; 1312 hmSymbolRun.DrawPaths(rsCanvas.get(), multPaths, path); 1313 EXPECT_EQ(hmSymbolRun.symbolTxt_.GetRenderMode(), RSSymbolRenderingStrategy::MULTIPLE_COLOR); 1314 } 1315 1316 /* 1317 * @tc.name: SetSymbolShadow001 1318 * @tc.desc: test SetSymbolShadow with animation current is false and true 1319 * @tc.type: FUNC 1320 */ 1321 HWTEST_F(OHHmSymbolRunTest, SetSymbolShadow001, TestSize.Level0) 1322 { 1323 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1324 // {10.0F, 10.0f} is offsetXY, 10.0f is radius 1325 SymbolShadow shadow = {Drawing::Color::COLOR_BLACK, {10.0F, 10.0f}, 10.0f}; 1326 std::optional<SymbolShadow> symbolShadow = shadow; 1327 hmSymbolRun.currentAnimationHasPlayed_ = true; 1328 hmSymbolRun.SetSymbolShadow(symbolShadow); 1329 EXPECT_FALSE(hmSymbolRun.currentAnimationHasPlayed_); 1330 1331 hmSymbolRun.SetSymbolShadow(symbolShadow); 1332 EXPECT_TRUE(hmSymbolRun.symbolTxt_.GetSymbolShadow().has_value()); 1333 } 1334 1335 /* 1336 * @tc.name: OnDrawSymbolTestShadow 1337 * @tc.desc: test OnDrawSymbol with shadow 1338 * @tc.type: FUNC 1339 */ 1340 HWTEST_F(OHHmSymbolRunTest, OnDrawSymbolTestShadow, TestSize.Level0) 1341 { 1342 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 1343 RSPoint offset = {100.0f, 100.0f}; // 100.0f, 100.0f is the offset 1344 RSPath path; 1345 path.AddCircle(100.0f, 100.0f, 40.0f); // 100.0f x, 100.0f, 40.0f radius 1346 RSHMSymbolData symbol; 1347 symbol.path_ = path; 1348 symbol.symbolInfo_.layers = {{0}}; // this one layers; 1349 symbol.symbolInfo_.renderGroups = {{{{{0}}}}}; // the {0} is layerIndexes of one group 1350 1351 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1352 // {10.0F, 10.0f} is offsetXY, 10.0f is radius 1353 SymbolShadow shadow = {Drawing::Color::COLOR_BLACK, {10.0F, 10.0f}, 10.0f}; 1354 std::optional<SymbolShadow> symbolShadow = shadow; 1355 hmSymbolRun.SetSymbolShadow(symbolShadow); 1356 hmSymbolRun.OnDrawSymbol(rsCanvas.get(), symbol, offset); 1357 EXPECT_TRUE(hmSymbolRun.symbolTxt_.GetSymbolShadow().has_value()); 1358 1359 // test radius < 1.0f 1360 shadow.blurRadius = 0.5f; 1361 symbolShadow = shadow; 1362 hmSymbolRun.SetSymbolShadow(symbolShadow); 1363 hmSymbolRun.OnDrawSymbol(rsCanvas.get(), symbol, offset); 1364 EXPECT_TRUE(hmSymbolRun.symbolTxt_.GetSymbolShadow().has_value()); 1365 } 1366 1367 /* 1368 * @tc.name: DrawSymbolShadow001 1369 * @tc.desc: test DrawSymbolShadow 1370 * @tc.type: FUNC 1371 */ 1372 HWTEST_F(OHHmSymbolRunTest, DrawSymbolShadow001, TestSize.Level0) 1373 { 1374 std::shared_ptr<RSCanvas> rsCanvas = std::make_shared<RSCanvas>(); 1375 RSPoint offset = {100.0f, 100.0f}; // 100.0f, 100.0f is the offset 1376 RSPath path1; 1377 path1.AddCircle(100.0f, 100.0f, 40.0f); // 100.0f x, 100.0f y, 40.0f radius 1378 RSPath path2; 1379 path2.AddCircle(100.0f, 50.0f, 40.0f); // 100.0f x, 50.0f y, 40.0f radius 1380 std::vector<RSPath> paths = {path1, path2}; 1381 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1382 // {10.0F, 10.0f} is offsetXY, 10.0f is radius 1383 SymbolShadow shadow = {Drawing::Color::COLOR_BLACK, {10.0F, 10.0f}, 10.0f}; 1384 std::optional<SymbolShadow> symbolShadow = shadow; 1385 hmSymbolRun.SetSymbolShadow(symbolShadow); 1386 hmSymbolRun.DrawSymbolShadow(rsCanvas.get(), paths); 1387 EXPECT_TRUE(hmSymbolRun.symbolTxt_.GetSymbolShadow().has_value()); 1388 1389 auto color1 = std::make_shared<SymbolGradient>(); 1390 color1->SetColors({0XFFFF0000}); // 0XFFFF0000 is ARGB 1391 auto color2 = std::make_shared<SymbolGradient>(); 1392 color2->SetColors({0XFF0000FF}); // 0XFF0000FF is ARGB 1393 hmSymbolRun.gradients_ = {color1, color2}; 1394 hmSymbolRun.DrawSymbolShadow(rsCanvas.get(), paths); 1395 EXPECT_TRUE(hmSymbolRun.symbolTxt_.GetSymbolShadow().has_value()); 1396 } 1397 1398 /* 1399 * @tc.name: DrawSymbolShadow002 1400 * @tc.desc: test DrawSymbolShadow width recordingCanvas 1401 * @tc.type: FUNC 1402 */ 1403 HWTEST_F(OHHmSymbolRunTest, DrawSymbolShadow002, TestSize.Level0) 1404 { 1405 // 100 is width, 200 is height of canvas 1406 std::shared_ptr<RSRecordingCanvas> rsCanvas = std::make_shared<RSRecordingCanvas>(100, 200); 1407 RSPoint offset = {100.0f, 100.0f}; // 100.0f, 100.0f is the offset 1408 RSPath path1; 1409 path1.AddCircle(100.0f, 100.0f, 40.0f); // 100.0f x, 100.0f y, 40.0f radius 1410 std::vector<RSPath> paths = {path1}; 1411 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1412 SymbolShadow shadow; 1413 shadow.blurRadius = 1.5f; // random value 1414 std::optional<SymbolShadow> symbolShadow = shadow; 1415 hmSymbolRun.SetSymbolShadow(symbolShadow); 1416 hmSymbolRun.DrawSymbolShadow(rsCanvas.get(), paths); 1417 EXPECT_TRUE(hmSymbolRun.symbolTxt_.GetSymbolShadow().has_value()); 1418 } 1419 1420 /* 1421 * @tc.name: SetSymbolLayersColorTest 1422 * @tc.desc: test SetSymbolLayersColorTest by different symbol color type 1423 * @tc.type: FUNC 1424 */ 1425 HWTEST_F(OHHmSymbolRunTest, SetSymbolLayersColorTest, TestSize.Level0) 1426 { 1427 uint16_t glyphId = 7; // 7 is an existing GlyphID 1428 HMSymbolRun hmSymbolRun = HMSymbolRun(); 1429 SymbolColor symbolColor = {SymbolColorType::GRADIENT_TYPE, {nullptr}}; 1430 SPText::HMSymbolTxt symbolTxt; 1431 symbolTxt.SetRenderMode(RSSymbolRenderingStrategy::MULTIPLE_COLOR); 1432 symbolTxt.SetSymbolColor(symbolColor); 1433 hmSymbolRun.SetSymbolTxt(symbolTxt); 1434 hmSymbolRun.UpdateSymbolLayersGroups(glyphId); 1435 auto symbolLayer = hmSymbolRun.GetSymbolLayers(glyphId, symbolTxt); 1436 EXPECT_NE(symbolLayer.symbolGlyphId, glyphId); 1437 1438 hmSymbolRun.gradients_ = {}; 1439 symbolColor.colorType = SymbolColorType::GRADIENT_DEFAULT_COLOR; 1440 symbolTxt.SetSymbolColor(symbolColor); 1441 symbolLayer = hmSymbolRun.GetSymbolLayers(glyphId, symbolTxt); 1442 EXPECT_TRUE(!hmSymbolRun.gradients_.empty()); 1443 1444 hmSymbolRun.gradients_ = {}; 1445 auto color = std::make_shared<SymbolGradient>(); 1446 color->SetColors({0XFFFF0000}); // 0XFFFF0000 is ARGB 1447 symbolColor.gradients[0] = color; 1448 symbolTxt.SetSymbolColor(symbolColor); 1449 hmSymbolRun.SetSymbolTxt(symbolTxt); 1450 symbolLayer = hmSymbolRun.GetSymbolLayers(glyphId, symbolTxt); 1451 EXPECT_TRUE(!hmSymbolRun.gradients_.empty()); 1452 } 1453 } // namespace SPText 1454 } // namespace Rosen 1455 } // namespace OHOS