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 #include <memory>
16
17 #include "gtest/gtest.h"
18
19 #define private public
20 #define protected public
21
22 #include "test/unittest/core/rosen/rosen_render_context_test.h"
23 #undef private
24 #undef protected
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS::Ace::NG {
30 namespace {
31 const char* SRC_JPG = "file://data/data/com.example.test/res/exampleAlt.jpg";
32
33 } // namespace
34
SetUp()35 void RosenRenderContextTest::SetUp()
36 {
37 MockPipelineContext::SetUp();
38 MockContainer::SetUp();
39 }
40
TearDown()41 void RosenRenderContextTest::TearDown()
42 {
43 MockPipelineContext::TearDown();
44 MockContainer::TearDown();
45 }
46
InitRosenRenderContext(const RefPtr<FrameNode> & frameNode)47 RefPtr<RosenRenderContext> RosenRenderContextTest::InitRosenRenderContext(const RefPtr<FrameNode>& frameNode)
48 {
49 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
50 RenderContext::ContextParam contextParam;
51 contextParam.type = RenderContext::ContextType::CANVAS;
52 contextParam.surfaceName.emplace("test");
53 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
54 rosenRenderContext->InitContext(false, contextParamValue);
55 rosenRenderContext->SetHostNode(frameNode);
56 return rosenRenderContext;
57 }
58
59 /**
60 * @tc.name: RosenRenderContextTest001
61 * @tc.desc: SetPivot().
62 * @tc.type: FUNC
63 */
64 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest001, TestSize.Level1)
65 {
__anon54a3be8d0202() 66 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
67 auto rosenRenderContext = InitRosenRenderContext(frameNode);
68 float xPivot = 10.0;
69 float yPivot = 10.0;
70 float zPivot = 10.0;
71 rosenRenderContext->SetPivot(xPivot, yPivot, zPivot);
72 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 10.0);
73 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().y_, 10.0);
74 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivotZ(), 10.0);
75 xPivot = 5.0;
76 rosenRenderContext->SetPivot(xPivot, yPivot, zPivot);
77 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 5.0);
78 }
79
80 /**
81 * @tc.name: RosenRenderContextTest002
82 * @tc.desc: SetTransitionPivot().
83 * @tc.type: FUNC
84 */
85 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest002, TestSize.Level1)
86 {
__anon54a3be8d0302() 87 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
88 auto rosenRenderContext = InitRosenRenderContext(frameNode);
89 rosenRenderContext->SetTransitionPivot(SizeF(100.0, 100.0), true);
90 ScaleOptions scaleOptions;
91 scaleOptions.centerX = CalcDimension(50.0, DimensionUnit::PX);
92 scaleOptions.centerY = CalcDimension(50.0, DimensionUnit::PX);
93 rosenRenderContext->GetOrCreateTransitionAppearing()->UpdateScale(scaleOptions);
94 rosenRenderContext->SetTransitionPivot(SizeF(100.0, 100.0), true);
95 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 0.5);
96 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().y_, 0.5);
97 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivotZ(), 0);
98 RotateOptions rotateOptions;
99 rotateOptions.centerX = CalcDimension(50.0, DimensionUnit::PX);
100 rotateOptions.centerY = CalcDimension(50.0, DimensionUnit::PX);
101 rotateOptions.centerZ = CalcDimension(50.0, DimensionUnit::PX);
102 rosenRenderContext->GetOrCreateTransitionAppearing()->UpdateRotate(rotateOptions);
103 rosenRenderContext->SetTransitionPivot(SizeF(100.0, 100.0), true);
104 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 0.5);
105 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().y_, 0.5);
106 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivotZ(), 50.0);
107 }
108
109 /**
110 * @tc.name: RosenRenderContextTest003
111 * @tc.desc: SetSandBox().
112 * @tc.type: FUNC
113 */
114 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest003, TestSize.Level1)
115 {
__anon54a3be8d0402() 116 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
117 auto rosenRenderContext = InitRosenRenderContext(frameNode);
118 std::optional<OffsetF> parentPosition = std::make_optional(OffsetF(100.0, 100.0));
119 rosenRenderContext->SetSandBox(parentPosition, false);
120 EXPECT_EQ(rosenRenderContext->sandBoxCount_, 1);
121 rosenRenderContext->SetSandBox(parentPosition, true);
122 EXPECT_EQ(rosenRenderContext->sandBoxCount_, 1);
123 rosenRenderContext->SetSandBox(std::nullopt, true);
124 EXPECT_EQ(rosenRenderContext->sandBoxCount_, 0);
125 rosenRenderContext->sandBoxCount_ = 2;
126 rosenRenderContext->SetSandBox(std::nullopt, true);
127 EXPECT_EQ(rosenRenderContext->sandBoxCount_, 0);
128 }
129
130 /**
131 * @tc.name: RosenRenderContextTest004
132 * @tc.desc: SetFrameWithoutAnimation().
133 * @tc.type: FUNC
134 */
135 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest004, TestSize.Level1)
136 {
__anon54a3be8d0502() 137 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
138 auto rosenRenderContext = InitRosenRenderContext(frameNode);
139 RectF paintRect = { 10.0f, 10.0f, 10.0f, 10.0f };
140 rosenRenderContext->SetFrameWithoutAnimation(paintRect);
141 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[0], paintRect.GetX());
142 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[1], paintRect.GetY());
143 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[2], paintRect.Width());
144 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[3], paintRect.Height());
145 }
146
147 /**
148 * @tc.name: RosenRenderContextTest005
149 * @tc.desc: SyncGeometryFrame().
150 * @tc.type: FUNC
151 */
152 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest005, TestSize.Level1)
153 {
__anon54a3be8d0602() 154 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
155 auto rosenRenderContext = InitRosenRenderContext(frameNode);
156 RectF paintRect = { 10.0f, 10.0f, 10.0f, 10.0f };
157 rosenRenderContext->SyncGeometryFrame(paintRect);
158 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[0], paintRect.GetX());
159 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[1], paintRect.GetY());
160 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[2], paintRect.Width());
161 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[3], paintRect.Height());
162 rosenRenderContext->SyncGeometryFrame(paintRect);
163 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds()[0], paintRect.GetX());
164 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds()[1], paintRect.GetY());
165 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds()[2], paintRect.Width());
166 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds()[3], paintRect.Height());
167 }
168
169 /**
170 * @tc.name: RosenRenderContextTest006
171 * @tc.desc: SetChildBounds().
172 * @tc.type: FUNC
173 */
174 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest006, TestSize.Level1)
175 {
__anon54a3be8d0702() 176 auto hostNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
177 auto rosenRenderContext = InitRosenRenderContext(hostNode);
178 RectF paintRect = { 10.0f, 10.0f, 10.0f, 10.0f };
179 rosenRenderContext->SetChildBounds(paintRect);
180 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetChildren().size(), 0);
181 auto rosenRenderContextChild = AceType::MakeRefPtr<RosenRenderContext>();
182 RenderContext::ContextParam contextParam;
183 contextParam.type = RenderContext::ContextType::CANVAS;
184 contextParam.surfaceName.emplace("test1");
185 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
186 rosenRenderContextChild->InitContext(false, contextParamValue);
__anon54a3be8d0802() 187 auto frameNode = FrameNode::GetOrCreateFrameNode("child", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
188 rosenRenderContextChild->SetHostNode(frameNode);
189 rosenRenderContext->AddChild(rosenRenderContextChild, 10);
190 rosenRenderContext->SetChildBounds(paintRect);
191 EXPECT_EQ(rosenRenderContextChild->GetRSNode()->GetStagingProperties().GetBounds()[0], 0.0);
192 EXPECT_EQ(rosenRenderContextChild->GetRSNode()->GetStagingProperties().GetBounds()[1], 0.0);
193 EXPECT_EQ(rosenRenderContextChild->GetRSNode()->GetStagingProperties().GetBounds()[2], paintRect.Width());
194 EXPECT_EQ(rosenRenderContextChild->GetRSNode()->GetStagingProperties().GetBounds()[3], paintRect.Height());
195 }
196
197 /**
198 * @tc.name: RosenRenderContextTest008
199 * @tc.desc: OnForegroundEffectUpdate().
200 * @tc.type: FUNC
201 */
202 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest008, TestSize.Level1)
203 {
__anon54a3be8d0902() 204 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
205 auto rosenRenderContext = InitRosenRenderContext(frameNode);
206 rosenRenderContext->OnForegroundEffectUpdate(1.0f);
207 EXPECT_TRUE(rosenRenderContext->GetRSNode()->GetStagingProperties().GetForegroundEffectRadius() - 1.0 < 1);
208 }
209
210 /**
211 * @tc.name: RosenRenderContextTest011
212 * @tc.desc: SyncGeometryFrame().
213 * @tc.type: FUNC
214 */
215 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest011, TestSize.Level1)
216 {
__anon54a3be8d0a02() 217 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
218 auto rosenRenderContext = InitRosenRenderContext(frameNode);
219 rosenRenderContext->OnOpacityUpdate(10.0);
220 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetAlpha(), 10.0);
221 }
222
223 /**
224 * @tc.name: RosenRenderContextTest012
225 * @tc.desc: ConvertDimensionToScaleBySize().
226 * @tc.type: FUNC
227 */
228 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest012, TestSize.Level1)
229 {
230 Dimension dimension;
231 dimension.SetUnit(DimensionUnit::FP);
232 float size = 100.0;
233 float ret = RosenRenderContext::ConvertDimensionToScaleBySize(dimension, size);
234 EXPECT_EQ(ret == 0.5f, false);
235 dimension.SetUnit(DimensionUnit::PERCENT);
236 float ret2 = RosenRenderContext::ConvertDimensionToScaleBySize(dimension, size);
237 EXPECT_EQ(ret2 == 0.0f, true);
238 }
239
240 /**
241 * @tc.name: RosenRenderContextTest013
242 * @tc.desc: OnNodeAppear().
243 * @tc.type: FUNC
244 */
245 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest013, TestSize.Level1)
246 {
__anon54a3be8d0b02() 247 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
248 auto rosenRenderContext = InitRosenRenderContext(frameNode);
249 // recursive is false
250 rosenRenderContext->OnNodeAppear(false);
251 EXPECT_TRUE(rosenRenderContext->firstTransitionIn_);
252 // OnNodeAppear() recursive is true
253 rosenRenderContext->OnNodeAppear(true);
254 EXPECT_FALSE(rosenRenderContext->isDisappearing_);
255 }
256
257 /**
258 * @tc.name: RosenRenderContextTest014
259 * @tc.desc: CreateHardwareSurface().
260 * @tc.type: FUNC
261 */
262 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest014, TestSize.Level1)
263 {
__anon54a3be8d0c02() 264 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
265 auto rosenRenderContext = InitRosenRenderContext(frameNode);
266 std::optional<RenderContext::ContextParam> param = std::make_optional(RenderContext::ContextParam());
267 bool isTextureExportNode = true;
268 std::shared_ptr<Rosen::RSNode> ret = rosenRenderContext->CreateHardwareSurface(param, isTextureExportNode);
269 EXPECT_FALSE(ret == nullptr);
270 }
271
272 /**
273 * @tc.name: RosenRenderContextTest015
274 * @tc.desc: SyncGeometryProperties().
275 * @tc.type: FUNC
276 */
277 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest015, TestSize.Level1)
278 {
__anon54a3be8d0d02() 279 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
280 auto rosenRenderContext = InitRosenRenderContext(frameNode);
281 RectF paintRect = { 10.0f, 10.0f, 10.0f, 10.0f };
282 rosenRenderContext->SyncGeometryProperties(paintRect);
283 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[0], paintRect.GetX());
284 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[1], paintRect.GetY());
285 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[2], paintRect.Width());
286 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[3], paintRect.Height());
287 }
288
289 /**
290 * @tc.name: RosenRenderContextTest017
291 * @tc.desc: OnBackgroundImageUpdate().
292 * @tc.type: FUNC
293 */
294 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest017, TestSize.Level1)
295 {
__anon54a3be8d0e02() 296 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
297 auto rosenRenderContext = InitRosenRenderContext(frameNode);
298 // Src null,pixmap null
299 ImageSourceInfo src;
300 rosenRenderContext->OnBackgroundImageUpdate(src);
301 EXPECT_EQ(rosenRenderContext->bgImage_, nullptr);
302 EXPECT_EQ(rosenRenderContext->bgLoadingCtx_, nullptr);
303 // Src null,pixmap not null
304 RefPtr<PixelMap> pixmap;
305 std::optional<Color> fillColor = std::make_optional(Color::BLACK);
306 src.SetPixMap(pixmap, fillColor);
307 rosenRenderContext->OnBackgroundImageUpdate(src);
308 EXPECT_TRUE(rosenRenderContext->bgImage_ == nullptr);
309 EXPECT_TRUE(rosenRenderContext->bgLoadingCtx_ == nullptr);
310 // Src not null,pixmap null
311 src.SetSrc("test");
312 rosenRenderContext->OnBackgroundImageUpdate(src);
313 EXPECT_TRUE(rosenRenderContext->bgImage_ == nullptr);
314 EXPECT_TRUE(rosenRenderContext->bgLoadingCtx_ != nullptr);
315 }
316
317 /**
318 * @tc.name: RosenRenderContextTest019
319 * @tc.desc: OnParticleOptionArrayUpdate()
320 * @tc.type: FUNC
321 */
322 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest019, TestSize.Level1)
323 {
324 auto frameNode =
__anon54a3be8d0f02() 325 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
326 auto rosenRenderContext = InitRosenRenderContext(frameNode);
327 std::list<ParticleOption> optionList;
328 rosenRenderContext->OnParticleOptionArrayUpdate(optionList);
329 EXPECT_FALSE(rosenRenderContext->particleAnimationPlaying_);
330 rosenRenderContext->paintRect_ = RectT<float>(1.0f, 1.0f, 1.0f, 1.0f);
331 rosenRenderContext->OnParticleOptionArrayUpdate(optionList);
332 EXPECT_TRUE(rosenRenderContext->particleAnimationPlaying_);
__anon54a3be8d1002() 333 auto frameNode2 = FrameNode::GetOrCreateFrameNode("parent", -1, []() {
334 auto pattern = AceType::MakeRefPtr<ParticlePattern>(1);
335 pattern->SetHaveUnVisibleParent(true);
336 return pattern;
337 });
338 auto rosenRenderContext2 = InitRosenRenderContext(frameNode2);
339 rosenRenderContext2->paintRect_ = RectT<float>(1.0f, 1.0f, 1.0f, 1.0f);
340 rosenRenderContext2->OnParticleOptionArrayUpdate(optionList);
341 EXPECT_FALSE(rosenRenderContext2->particleAnimationPlaying_);
342 }
343
344 /**
345 * @tc.name: RosenRenderContextTest020
346 * @tc.desc: OnParticleOptionArrayUpdate()
347 * @tc.type: FUNC
348 */
349 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest020, TestSize.Level1)
350 {
351 auto frameNode =
__anon54a3be8d1102() 352 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
353 auto rosenRenderContext = InitRosenRenderContext(frameNode);
354 // constrcuct params,default value,expect SetLifeTime 0.0f,SetLifeTimeRange 1.0f
355 ParticleOption particleOption;
356 RectF rectF;
357 EmitterOption emitter;
358 Particle particle;
359 particle.SetLifeTime(0.0f);
360 particle.SetLifeTimeRange(1.0f);
361 emitter.SetParticle(particle);
362 particleOption.SetEmitterOption(emitter);
363 OHOS::Rosen::ParticleParams ret = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
364 EXPECT_EQ(ret.velocity_.velocityAngle_.start_, 0.0f);
365 EXPECT_EQ(ret.velocity_.velocityAngle_.end_, 0.0f);
366 // SetLifeTime 0.0f,SetLifeTimeRange 1.0f
367 Particle particle2;
368 particle2.SetLifeTime(-1.0f);
369 particle2.SetLifeTimeRange(1.0f);
370 emitter.SetParticle(particle2);
371 particleOption.SetEmitterOption(emitter);
372 OHOS::Rosen::ParticleParams ret2 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
373 EXPECT_EQ(ret2.velocity_.velocityAngle_.start_, 0.0f);
374 EXPECT_EQ(ret2.velocity_.velocityAngle_.end_, 0.0f);
375 // SetLifeTime 1.0f,SetLifeTimeRange 0.5f
376 Particle particle3;
377 particle3.SetLifeTime(1);
378 particle3.SetLifeTimeRange(0);
379 particle3.SetParticleType(ParticleType::IMAGE);
380 ParticleConfig config;
381 ImageParticleParameter imageParam;
382 ImageFit imageFit = ImageFit::FILL;
383 imageParam.SetImageFit(imageFit);
384 config.SetImageParticleParameter(imageParam);
385 particle3.SetConfig(config);
386 emitter.SetParticle(particle3);
387 particleOption.SetEmitterOption(emitter);
388 OHOS::Rosen::ParticleParams ret3 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
389 EXPECT_EQ(ret3.velocity_.velocityAngle_.start_, 0.0f);
390 EXPECT_EQ(ret3.velocity_.velocityAngle_.end_, 0.0f);
391 }
392
393 /**
394 * @tc.name: RosenRenderContextTest021
395 * @tc.desc: OnParticleOptionArrayUpdate()-2
396 * @tc.type: FUNC
397 */
398 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest021, TestSize.Level1)
399 {
400 auto frameNode =
__anon54a3be8d1202() 401 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
402 auto rosenRenderContext = InitRosenRenderContext(frameNode);
403 // constrcuct params,default value,expect SetLifeTime 0.0f,SetLifeTimeRange 1.0f
404 ParticleOption particleOption;
405 RectF rectF;
406 EmitterOption emitter;
407 Particle particle;
408 particle.SetLifeTime(0.0f);
409 particle.SetLifeTimeRange(1.0f);
410 emitter.SetParticle(particle);
411 particleOption.SetEmitterOption(emitter);
412 // particleColorPropertyOption assign value
413 ParticleColorPropertyOption particleColorPropertyOption;
414 particleOption.SetParticleColorOption(particleColorPropertyOption);
415 OHOS::Rosen::ParticleParams ret4 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
416 EXPECT_EQ(ret4.color_.updator_, OHOS::Rosen::ParticleUpdator::NONE);
417 ParticleColorPropertyUpdater colorUpdater;
418 colorUpdater.SetUpdateType(UpdaterType::RANDOM);
419 particleColorPropertyOption.SetUpdater(colorUpdater);
420 particleOption.SetParticleColorOption(particleColorPropertyOption);
421 OHOS::Rosen::ParticleParams ret5 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
422 EXPECT_EQ(ret5.color_.updator_, OHOS::Rosen::ParticleUpdator::RANDOM);
423 colorUpdater.SetUpdateType(UpdaterType::CURVE);
424 particleColorPropertyOption.SetUpdater(colorUpdater);
425 particleOption.SetParticleColorOption(particleColorPropertyOption);
426 OHOS::Rosen::ParticleParams ret6 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
427 EXPECT_EQ(ret6.color_.updator_, OHOS::Rosen::ParticleUpdator::CURVE);
428 // ParticleFloatPropertyOption assign value
429 ParticleFloatPropertyOption particleFloatPropertyOption;
430 particleOption.SetParticleOpacityOption(particleFloatPropertyOption);
431 OHOS::Rosen::ParticleParams ret7 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
432 EXPECT_EQ(ret7.opacity_.updator_, OHOS::Rosen::ParticleUpdator::NONE);
433 ParticleFloatPropertyUpdater particleFloatPropertyUpdater;
434 particleFloatPropertyUpdater.SetUpdaterType(UpdaterType::RANDOM);
435 particleFloatPropertyOption.SetUpdater(particleFloatPropertyUpdater);
436 particleOption.SetParticleOpacityOption(particleFloatPropertyOption);
437 OHOS::Rosen::ParticleParams ret8 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
438 EXPECT_EQ(ret8.opacity_.updator_, OHOS::Rosen::ParticleUpdator::RANDOM);
439 particleFloatPropertyUpdater.SetUpdaterType(UpdaterType::CURVE);
440 particleFloatPropertyOption.SetUpdater(particleFloatPropertyUpdater);
441 particleOption.SetParticleOpacityOption(particleFloatPropertyOption);
442 OHOS::Rosen::ParticleParams ret9 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
443 EXPECT_EQ(ret9.opacity_.updator_, OHOS::Rosen::ParticleUpdator::CURVE);
444 // scaleOptionOpt assing value,same as rsOpacityOpt
445 particleOption.SetParticleScaleOption(particleFloatPropertyOption);
446 OHOS::Rosen::ParticleParams ret10 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
447 EXPECT_EQ(ret10.scale_.updator_, OHOS::Rosen::ParticleUpdator::CURVE);
448 }
449
450 /**
451 * @tc.name: RosenRenderContextTest022
452 * @tc.desc: OnParticleOptionArrayUpdate()-3
453 * @tc.type: FUNC
454 */
455 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest022, TestSize.Level1)
456 {
457 auto frameNode =
__anon54a3be8d1302() 458 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
459 auto rosenRenderContext = InitRosenRenderContext(frameNode);
460 // constrcuct params,default value,expect SetLifeTime 0.0f,SetLifeTimeRange 1.0f
461 ParticleOption particleOption;
462 RectF rectF;
463 EmitterOption emitter;
464 Particle particle;
465 particle.SetLifeTime(0.0f);
466 particle.SetLifeTimeRange(1.0f);
467 emitter.SetParticle(particle);
468 particleOption.SetEmitterOption(emitter);
469 // velocityOptionOpt assing value
470 VelocityProperty velocityProperty;
471 std::pair<float, float> range = std::make_pair(1.0f, 2.0f);
472 velocityProperty.SetSpeedRange(range);
473 velocityProperty.SetAngleRange(range);
474 particleOption.SetParticleVelocityOption(velocityProperty);
475 OHOS::Rosen::ParticleParams ret11 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
476 EXPECT_EQ(ret11.velocity_.velocityAngle_.end_, 2.0f);
477 // accelerationProperty assing value
478 AccelerationProperty accelerationProperty;
479 particleOption.SetParticleAccelerationOption(accelerationProperty);
480 OHOS::Rosen::ParticleParams ret12 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
481 EXPECT_EQ(ret12.acceleration_.accelerationAngle_.val_.end_, 0.0f);
482 EXPECT_EQ(ret12.acceleration_.accelerationValue_.val_.end_, 0.0f);
483 ParticleFloatPropertyOption particleFloatPropertyOption1;
484 particleFloatPropertyOption1.SetRange(range);
485 accelerationProperty.SetSpeed(particleFloatPropertyOption1);
486 accelerationProperty.SetAngle(particleFloatPropertyOption1);
487 particleOption.SetParticleAccelerationOption(accelerationProperty);
488 OHOS::Rosen::ParticleParams ret13 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
489 EXPECT_EQ(ret13.acceleration_.accelerationAngle_.val_.end_, 2.0f);
490 EXPECT_EQ(ret13.acceleration_.accelerationValue_.val_.end_, 2.0f);
491 // spinOption assing value
492 particleOption.SetParticleSpinOption(particleFloatPropertyOption1);
493 OHOS::Rosen::ParticleParams ret14 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
494 EXPECT_EQ(ret14.spin_.updator_, OHOS::Rosen::ParticleUpdator::NONE);
495 }
496
497 /**
498 * @tc.name: RosenRenderContextTest023
499 * @tc.desc: OnDynamicRangeModeUpdate()
500 * @tc.type: FUNC
501 */
502 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest023, TestSize.Level1)
503 {
504 auto frameNode =
__anon54a3be8d1402() 505 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
506 auto rosenRenderContext = InitRosenRenderContext(frameNode);
507 // constrcuct params
508 DynamicRangeMode dynamicRangeMode = DynamicRangeMode::STANDARD;
509 rosenRenderContext->OnDynamicRangeModeUpdate(dynamicRangeMode);
510 EXPECT_EQ(rosenRenderContext->isHdr_, false);
511 dynamicRangeMode = DynamicRangeMode::HIGH;
512 rosenRenderContext->OnDynamicRangeModeUpdate(dynamicRangeMode);
513 EXPECT_EQ(rosenRenderContext->isHdr_, true);
514 rosenRenderContext->OnDynamicRangeModeUpdate(dynamicRangeMode);
515 EXPECT_EQ(rosenRenderContext->isHdr_, false);
516 }
517
518 /**
519 * @tc.name: RosenRenderContextTest024
520 * @tc.desc: GetThumbnailPixelMap()
521 * @tc.type: FUNC
522 */
523 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest024, TestSize.Level1)
524 {
525 auto frameNode =
__anon54a3be8d1502() 526 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
527 auto rosenRenderContext = InitRosenRenderContext(frameNode);
528 // constrcuct params
529 RefPtr<PixelMap> ret = rosenRenderContext->GetThumbnailPixelMap(false);
530 EXPECT_EQ(Referenced::RawPtr(ret) == nullptr, true);
531 RefPtr<PixelMap> ret2 = rosenRenderContext->GetThumbnailPixelMap(true);
532 EXPECT_EQ(Referenced::RawPtr(ret) == nullptr, true);
533 }
534
535 /**
536 * @tc.name: RosenRenderContextTest025
537 * @tc.desc: MarshallTranslate()
538 * @tc.type: FUNC
539 */
540 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest025, TestSize.Level1)
541 {
542 auto frameNode =
__anon54a3be8d1602() 543 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
544 auto rosenRenderContext = InitRosenRenderContext(frameNode);
545 // constrcuct params
546 TranslateOptions translate;
547 Vector3F ret = rosenRenderContext->MarshallTranslate(translate);
548 EXPECT_EQ(ret.x, 0.0f);
549 EXPECT_EQ(ret.y, 0.0f);
550 EXPECT_EQ(ret.z, 0.0f);
551 CalcDimension x(1.0, DimensionUnit::PX);
552 CalcDimension y(1.0, DimensionUnit::PERCENT);
553 CalcDimension z(1.0, DimensionUnit::PX);
554 TranslateOptions translate1(x, y, z);
555 Vector3F ret2 = rosenRenderContext->MarshallTranslate(translate1);
556 EXPECT_EQ(ret2.x, 0.0f);
557 CalcDimension x2(1.0, DimensionUnit::PERCENT);
558 TranslateOptions translate2(x2, y, z);
559 Vector3F ret3 = rosenRenderContext->MarshallTranslate(translate2);
560 EXPECT_EQ(ret3.x, 0.0f);
561 }
562
563 /**
564 * @tc.name: RosenRenderContextTest026
565 * @tc.desc: GetPaintRectWithTransform()
566 * @tc.type: FUNC
567 */
568 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest026, TestSize.Level1)
569 {
570 auto frameNode =
__anon54a3be8d1702() 571 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
572 auto rosenRenderContext = InitRosenRenderContext(frameNode);
573 // constrcuct params
574 RectF ret = rosenRenderContext->GetPaintRectWithTransform();
575 EXPECT_EQ(ret.x_, 0.0f);
576 rosenRenderContext->GetRSNode()->SetRotation(2.0f);
577 RectF ret2 = rosenRenderContext->GetPaintRectWithTransform();
578 EXPECT_EQ(ret2.x_, 0.0f);
579 rosenRenderContext->GetRSNode()->SetRotation(90.0f);
580 RectF ret3 = rosenRenderContext->GetPaintRectWithTransform();
581 EXPECT_EQ(ret3.x_, 0.0f);
582 rosenRenderContext->GetRSNode()->SetRotation(180.0f);
583 RectF ret4 = rosenRenderContext->GetPaintRectWithTransform();
584 EXPECT_EQ(ret4.x_, 0.0f);
585 rosenRenderContext->GetRSNode()->SetRotation(270.0f);
586 RectF ret5 = rosenRenderContext->GetPaintRectWithTransform();
587 EXPECT_EQ(ret5.x_, 0.0f);
588 }
589
590 /**
591 * @tc.name: RosenRenderContextTest027
592 * @tc.desc: GetPaintRectWithTranslate()
593 * @tc.type: FUNC
594 */
595 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest027, TestSize.Level1)
596 {
597 auto frameNode =
__anon54a3be8d1802() 598 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
599 auto rosenRenderContext = InitRosenRenderContext(frameNode);
600 // constrcuct params
601 std::pair<RectF, bool> ret = rosenRenderContext->GetPaintRectWithTranslate();
602 EXPECT_EQ(ret.first.x_, 0.0f);
603 rosenRenderContext->GetRSNode()->SetRotation(90.0f);
604 std::pair<RectF, bool> ret2 = rosenRenderContext->GetPaintRectWithTranslate();
605 EXPECT_EQ(ret2.first.width_, -1.0f);
606 }
607
608 /**
609 * @tc.name: RosenRenderContextTest028
610 * @tc.desc: GetRevertMatrix()/GetMatrix()/GetMatrixWithTransformRotate()
611 * @tc.type: FUNC
612 */
613 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest028, TestSize.Level1)
614 {
615 auto frameNode =
__anon54a3be8d1902() 616 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
617 auto rosenRenderContext = InitRosenRenderContext(frameNode);
618 // constrcuct params
619 Matrix4 ret = rosenRenderContext->GetRevertMatrix();
620 EXPECT_EQ(ret(0, 0), 1.0f);
621 Matrix4 ret2 = rosenRenderContext->GetMatrix();
622 EXPECT_EQ(ret2(0, 0), 1.0f);
623 Matrix4 ret3 = rosenRenderContext->GetMatrixWithTransformRotate();
624 EXPECT_EQ(ret3(0, 0), 1.0f);
625 }
626
627 /**
628 * @tc.name: RosenRenderContextTest029
629 * @tc.desc: GetPointWithTransform()
630 * @tc.type: FUNC
631 */
632 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest029, TestSize.Level1)
633 {
634 auto frameNode =
__anon54a3be8d1a02() 635 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
636 auto rosenRenderContext = InitRosenRenderContext(frameNode);
637 // constrcuct params
638 PointF pointf;
639 rosenRenderContext->GetPointWithTransform(pointf);
640 EXPECT_EQ(pointf.x_, 0.0f);
641 rosenRenderContext->GetRSNode()->SetRotation(90.0f);
642 rosenRenderContext->GetPointWithTransform(pointf);
643 EXPECT_EQ(pointf.x_, 0.0f);
644 }
645
646 /**
647 * @tc.name: RosenRenderContextTest030
648 * @tc.desc: NeedPreloadImage()
649 * @tc.type: FUNC
650 */
651 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest030, TestSize.Level1)
652 {
653 auto frameNode =
__anon54a3be8d1b02() 654 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
655 auto rosenRenderContext = InitRosenRenderContext(frameNode);
656 // constrcuct params
657 std::list<ParticleOption> optionList;
658 RectF rect;
659 bool ret = rosenRenderContext->NeedPreloadImage(optionList, rect);
660 EXPECT_FALSE(ret);
661 ParticleOption particleOption1;
662 EmitterOption emitter1;
663 Particle particle1;
664 particle1.SetLifeTime(1);
665 particle1.SetLifeTimeRange(0);
666 particle1.SetParticleType(ParticleType::POINT);
667 emitter1.SetParticle(particle1);
668 particleOption1.SetEmitterOption(emitter1);
669 optionList.push_back(particleOption1);
670 bool ret2 = rosenRenderContext->NeedPreloadImage(optionList, rect);
671 EXPECT_FALSE(ret2);
672 ParticleOption particleOption;
673 EmitterOption emitter;
674 Particle particle;
675 particle.SetLifeTime(1);
676 particle.SetLifeTimeRange(0);
677 particle.SetParticleType(ParticleType::IMAGE);
678 emitter.SetParticle(particle);
679 particleOption.SetEmitterOption(emitter);
680 optionList.push_back(particleOption);
681 bool ret3 = rosenRenderContext->NeedPreloadImage(optionList, rect);
682 EXPECT_TRUE(ret3);
683 }
684
685 /**
686 * @tc.name: RosenRenderContextTest031
687 * @tc.desc: OnParticleImageLoaded()/ConvertDimensionToPx
688 * @tc.type: FUNC
689 */
690 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest031, TestSize.Level1)
691 {
692 auto frameNode =
__anon54a3be8d1c02() 693 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
694 auto rosenRenderContext = InitRosenRenderContext(frameNode);
695 // constrcuct params
696 std::string src = "";
697 RefPtr<CanvasImage> canvasImage;
698 int size = rosenRenderContext->particleImageMap_.size();
699 rosenRenderContext->OnParticleImageLoaded(src, canvasImage);
700 EXPECT_EQ(rosenRenderContext->particleImageMap_.size(), size + 1);
701
702 OHOS::Ace::Dimension dimension(1.0, DimensionUnit::PX);
703 float ret = rosenRenderContext->ConvertDimensionToPx(dimension, 5);
704 EXPECT_EQ(ret, 1.0f);
705 OHOS::Ace::Dimension dimension2(1.0, DimensionUnit::PERCENT);
706 float ret2 = rosenRenderContext->ConvertDimensionToPx(dimension2, 5);
707 EXPECT_EQ(ret2, 5.0f);
708 }
709
710 /**
711 * @tc.name: RosenRenderContextTest032
712 * @tc.desc: InitContext()
713 * @tc.type: FUNC
714 */
715 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest032, TestSize.Level1)
716 {
717 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
718 RenderContext::ContextParam contextParam;
719 contextParam.type = RenderContext::ContextType::CANVAS;
720 contextParam.surfaceName.emplace("test");
721 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
722 // is root is true
723 rosenRenderContext->InitContext(true, contextParamValue);
724 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
725 rosenRenderContext->rsNode_ = nullptr;
726 // contextParamValue does not has value
727 std::optional<RenderContext::ContextParam> contextParamValue2 = std::make_optional(contextParam);
728 rosenRenderContext->InitContext(false, contextParamValue2);
729 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
730 rosenRenderContext->rsNode_ = nullptr;
731 contextParam.type = RenderContext::ContextType::ROOT;
732 std::optional<RenderContext::ContextParam> contextParamValue3 = std::make_optional(contextParam);
733 rosenRenderContext->InitContext(false, contextParamValue3);
734 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
735 rosenRenderContext->rsNode_ = nullptr;
736 contextParam.type = RenderContext::ContextType::SURFACE;
737 std::optional<RenderContext::ContextParam> contextParamValue4 = std::make_optional(contextParam);
738 rosenRenderContext->InitContext(false, contextParamValue4);
739 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
740 rosenRenderContext->rsNode_ = nullptr;
741 contextParam.type = RenderContext::ContextType::HARDWARE_SURFACE;
742 std::optional<RenderContext::ContextParam> contextParamValue5 = std::make_optional(contextParam);
743 rosenRenderContext->InitContext(false, contextParamValue5);
744 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
745 rosenRenderContext->rsNode_ = nullptr;
746 contextParam.type = RenderContext::ContextType::EFFECT;
747 std::optional<RenderContext::ContextParam> contextParamValue7 = std::make_optional(contextParam);
748 rosenRenderContext->InitContext(false, contextParamValue7);
749 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
750 rosenRenderContext->rsNode_ = nullptr;
751 contextParam.type = RenderContext::ContextType::INCREMENTAL_CANVAS;
752 std::optional<RenderContext::ContextParam> contextParamValue8 = std::make_optional(contextParam);
753 rosenRenderContext->InitContext(false, contextParamValue8);
754 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
755 rosenRenderContext->rsNode_ = nullptr;
756 contextParam.type = RenderContext::ContextType::EXTERNAL;
757 std::optional<RenderContext::ContextParam> contextParamValue9 = std::make_optional(contextParam);
758 rosenRenderContext->InitContext(false, contextParamValue9);
759 EXPECT_EQ(rosenRenderContext->rsNode_ == nullptr, true);
760 }
761
762 /**
763 * @tc.name: RosenRenderContextTest033
764 * @tc.desc: PaintDebugBoundary()
765 * @tc.type: FUNC
766 */
767 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest033, TestSize.Level1)
768 {
769 auto frameNode =
__anon54a3be8d1d02() 770 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
771 auto rosenRenderContext = InitRosenRenderContext(frameNode);
772 rosenRenderContext->PaintDebugBoundary(false);
773 EXPECT_EQ(rosenRenderContext->debugBoundaryModifier_ == nullptr, true);
774 auto rosenRenderContext2 = AceType::MakeRefPtr<RosenRenderContext>();
775 RenderContext::ContextParam contextParam;
776 contextParam.type = RenderContext::ContextType::SURFACE;
777 contextParam.surfaceName.emplace("test");
778 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
779 rosenRenderContext2->InitContext(false, contextParamValue);
780 rosenRenderContext2->SetHostNode(frameNode);
781 rosenRenderContext2->PaintDebugBoundary(true);
782 EXPECT_EQ(rosenRenderContext->debugBoundaryModifier_ == nullptr, true);
783 }
784
785 /**
786 * @tc.name: RosenRenderContextTest034
787 * @tc.desc: UpdateBlurBackgroundColor()
788 * @tc.type: FUNC
789 */
790 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest034, TestSize.Level1)
791 {
792 auto frameNode =
__anon54a3be8d1e02() 793 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
794 auto rosenRenderContext = InitRosenRenderContext(frameNode);
795 std::optional<BlurStyleOption> bgBlurStyle;
796 EXPECT_FALSE(rosenRenderContext->UpdateBlurBackgroundColor(bgBlurStyle));
797 std::optional<BlurStyleOption> bgBlurStyle2 = std::make_optional(BlurStyleOption());
798 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(bgBlurStyle2));
799 bgBlurStyle2->isValidColor = true;
800 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(bgBlurStyle2));
801 bgBlurStyle2->isWindowFocused = false;
802 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(bgBlurStyle2));
803
804 std::optional<EffectOption> efffectOption = std::make_optional(EffectOption());
805 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(efffectOption));
806 efffectOption->isValidColor = true;
807 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(efffectOption));
808 efffectOption->isWindowFocused = false;
809 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(efffectOption));
810 }
811
812 /**
813 * @tc.name: RosenRenderContextTest035
814 * @tc.desc: UpdateAccessibilityRoundRect().
815 * @tc.type: FUNC
816 */
817 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest035, TestSize.Level1)
818 {
__anon54a3be8d1f02() 819 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
820 auto rosenRenderContext = InitRosenRenderContext(frameNode);
821 if (!rosenRenderContext) {
822 return;
823 }
824
825 rosenRenderContext->accessibilityFocusStateModifier_ = std::make_shared<FocusStateModifier>();
826 if (!rosenRenderContext->accessibilityFocusStateModifier_) {
827 return;
828 }
829
830 RoundRect frameRect;
831 frameRect.SetRect(RectF(6, 6, 6, 6));
832 const constexpr double accessibilityFocusWidth = 4.0;
833 double lineWidth = accessibilityFocusWidth * PipelineBase::GetCurrentDensity();
834 Dimension paintWidth(lineWidth, DimensionUnit::PX);
835 auto paintWidthPx = static_cast<float>(paintWidth.ConvertToPx());
836 (void)paintWidthPx;
837 rosenRenderContext->accessibilityFocusStateModifier_->SetRoundRect(frameRect, paintWidthPx);
838 if (!rosenRenderContext->accessibilityFocusStateModifier_->animationRect_) {
839 return;
840 }
841 frameNode->geometryNode_->SetFrameSize(SizeF(10.0f, 10.0f));
842 rosenRenderContext->UpdateAccessibilityRoundRect();
843 auto rectBeforeUpdate = rosenRenderContext->accessibilityFocusStateModifier_->roundRect_.GetRect();
844 EXPECT_EQ(rectBeforeUpdate.GetLeft(), 2.0f);
845 EXPECT_EQ(rectBeforeUpdate.GetTop(), 2.0f);
846 EXPECT_EQ(rectBeforeUpdate.GetRight(), 8.0f);
847 EXPECT_EQ(rectBeforeUpdate.GetBottom(), 8.0f);
848
849 frameNode->geometryNode_->SetFrameSize(SizeF(20.0f, 20.0f));
850 rosenRenderContext->UpdateAccessibilityRoundRect();
851 auto rectAfterUpdate = rosenRenderContext->accessibilityFocusStateModifier_->roundRect_.GetRect();
852
853 EXPECT_EQ(rectAfterUpdate.GetLeft(), 2.0f);
854 EXPECT_EQ(rectAfterUpdate.GetTop(), 2.0f);
855 EXPECT_EQ(rectAfterUpdate.GetRight(), 18.0f);
856 EXPECT_EQ(rectAfterUpdate.GetBottom(), 18.0f);
857 }
858
859 /**
860 * @tc.name: RosenRenderContextTest037
861 * @tc.desc: UpdateShadow.
862 * @tc.type: FUNC
863 */
864 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest037, TestSize.Level1)
865 {
__anon54a3be8d2002() 866 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
867 auto rosenRenderContext = InitRosenRenderContext(frameNode);
868 if (!rosenRenderContext) {
869 return;
870 }
871 Shadow shadow;
872 shadow.SetBlurRadius(1.0);
873 shadow.SetOffsetX(1.0);
874 shadow.SetOffsetY(1.0);
875 shadow.SetIsFilled(true);
876 rosenRenderContext->OnBackShadowUpdate(shadow);
877 auto color = rosenRenderContext->rsNode_->GetStagingProperties().GetShadowColor();
878 ASSERT_TRUE(color.AsArgbInt() == Color::BLACK.GetValue());
879 auto offsetX = rosenRenderContext->rsNode_->GetStagingProperties().GetShadowOffsetY();
880 auto offsetY = rosenRenderContext->rsNode_->GetStagingProperties().GetShadowOffsetY();
881 ASSERT_TRUE(NearEqual(1.0, offsetX));
882 ASSERT_TRUE(NearEqual(1.0, offsetY));
883 auto isFilled = rosenRenderContext->rsNode_->GetStagingProperties().GetShadowIsFilled();
884 ASSERT_TRUE(isFilled);
885 }
886
887 /**
888 * @tc.name: RosenRenderContextTest38
889 * @tc.desc: UpdateClipEdge
890 * @tc.type: FUNC
891 */
892 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest038, TestSize.Level1)
893 {
__anon54a3be8d2102() 894 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
895 auto rosenRenderContext = InitRosenRenderContext(frameNode);
896 if (!rosenRenderContext) {
897 return;
898 }
899 rosenRenderContext->OnClipEdgeUpdate(true);
900 auto clip = rosenRenderContext->rsNode_->GetStagingProperties().GetClipToBounds();
901 ASSERT_TRUE(clip);
902 }
903
904 /**
905 * @tc.name: RosenRenderContextTest039
906 * @tc.desc: GetStatusByEffectTypeAndWindow.
907 * @tc.type: FUNC
908 */
909 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest039, TestSize.Level1)
910 {
911 auto frameNode =
__anon54a3be8d2202() 912 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
913 auto rosenRenderContext = InitRosenRenderContext(frameNode);
914 auto pipeline = MockPipelineContext::GetCurrentContext();
915
916 auto windowEffect = EffectType::WINDOW_EFFECT;
917 rosenRenderContext->UpdateUseEffectType(windowEffect);
918 pipeline->WindowFocus(false);
919 EXPECT_TRUE(rosenRenderContext->GetStatusByEffectTypeAndWindow());
920
921 pipeline->WindowFocus(true);
922 auto useEffectTypeVal = rosenRenderContext->GetUseEffectType();
923 EXPECT_EQ(useEffectTypeVal, windowEffect);
924 EXPECT_TRUE(pipeline->IsWindowFocused());
925 EXPECT_TRUE(rosenRenderContext->GetStatusByEffectTypeAndWindow());
926
927 rosenRenderContext->UpdateUseEffectType(EffectType::DEFAULT);
928 EXPECT_FALSE(rosenRenderContext->GetStatusByEffectTypeAndWindow());
929 }
930
931 /**
932 * @tc.name: RosenRenderContextTest040
933 * @tc.desc: OnUseEffectUpdate().
934 * @tc.type: FUNC
935 */
936 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest040, TestSize.Level1)
937 {
938 auto frameNode =
__anon54a3be8d2302() 939 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
940 auto rosenRenderContext = InitRosenRenderContext(frameNode);
941 auto pipeline = rosenRenderContext->GetPipelineContext();
942 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
943
944 rosenRenderContext->UpdateUseEffectType(EffectType::WINDOW_EFFECT);
945 bool value = true;
946 // GetStatusByEffectTypeAndWindow() is true
947 pipeline->WindowFocus(false);
948 rosenRenderContext->OnUseEffectUpdate(value);
949 bool willSetVal = false;
950 rosenRenderContext->rsNode_->SetUseEffect(willSetVal);
951 EXPECT_NE(willSetVal, value);
952
953 // GetStatusByEffectTypeAndWindow() is false
954 pipeline->WindowFocus(true);
955 rosenRenderContext->OnUseEffectUpdate(value);
956 willSetVal = true;
957 rosenRenderContext->rsNode_->SetUseEffect(willSetVal);
958 EXPECT_EQ(willSetVal, value);
959
960 value = false;
961 // value is false, GetStatusByEffectTypeAndWindow() is true
962 pipeline->WindowFocus(false);
963 rosenRenderContext->OnUseEffectUpdate(value);
964 willSetVal = false;
965 rosenRenderContext->rsNode_->SetUseEffect(value);
966 EXPECT_EQ(willSetVal, value);
967
968 // value is false, GetStatusByEffectTypeAndWindow() is false
969 pipeline->WindowFocus(true);
970 rosenRenderContext->OnUseEffectUpdate(value);
971 willSetVal = false;
972 rosenRenderContext->rsNode_->SetUseEffect(willSetVal);
973 EXPECT_EQ(willSetVal, value);
974 }
975
976 /**
977 * @tc.name: RosenRenderContextTest041
978 * @tc.desc: OnUseEffectTypeUpdate().
979 * @tc.type: FUNC
980 */
981 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest041, TestSize.Level1)
982 {
983 auto frameNode =
__anon54a3be8d2402() 984 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
985 auto rosenRenderContext = InitRosenRenderContext(frameNode);
986 EffectType effectType = EffectType::WINDOW_EFFECT;
987 rosenRenderContext->OnUseEffectTypeUpdate(effectType);
988 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
989
990 auto effectTypeParam = static_cast<Rosen::UseEffectType>(effectType);
991 rosenRenderContext->rsNode_->SetUseEffectType(effectTypeParam);
992
993 bool useEffect = true;
994 rosenRenderContext->UpdateUseEffect(useEffect);
995 rosenRenderContext->OnUseEffectUpdate(useEffect);
996
997 useEffect = false;
998 rosenRenderContext->UpdateUseEffect(useEffect);
999 rosenRenderContext->OnUseEffectUpdate(useEffect);
1000
1001 effectType = EffectType::DEFAULT;
1002 rosenRenderContext->OnUseEffectTypeUpdate(effectType);
1003 auto useEffectTypeVal = rosenRenderContext->GetUseEffectType().value_or(EffectType::DEFAULT);
1004 EXPECT_EQ(useEffectTypeVal, effectType);
1005 }
1006
1007 /**
1008 * @tc.name: RosenRenderContextTest042
1009 * @tc.desc: UpdateWindowFocusState().
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest042, TestSize.Level1)
1013 {
1014 auto frameNode =
__anon54a3be8d2502() 1015 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1016 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1017
1018 bool isFocused = true;
1019 rosenRenderContext->UpdateWindowFocusState(isFocused);
1020
1021 auto useEffect = rosenRenderContext->GetUseEffect().value_or(false);
1022 rosenRenderContext->UpdateUseEffectType(EffectType::WINDOW_EFFECT);
1023 rosenRenderContext->OnUseEffectUpdate(useEffect);
1024
1025 BlurStyleOption blurStyleObj;
1026 blurStyleObj.policy = BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE;
1027 blurStyleObj.isWindowFocused = isFocused;
1028 rosenRenderContext->UpdateBackBlurStyle(blurStyleObj);
1029
1030 EffectOption effectObj;
1031 effectObj.policy = BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE;
1032 rosenRenderContext->UpdateBackgroundEffect(effectObj);
1033 EXPECT_EQ(effectObj.isWindowFocused, isFocused);
1034 }
1035
1036 /**
1037 * @tc.name: RosenRenderContextTest043
1038 * @tc.desc: OnBackgroundColorUpdate().
1039 * @tc.type: FUNC
1040 */
1041 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest043, TestSize.Level1)
1042 {
1043 auto frameNode =
__anon54a3be8d2602() 1044 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1045 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1046 const Color value = Color::RED;
1047 rosenRenderContext->OnBackgroundColorUpdate(value);
1048 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1049 rosenRenderContext->rsNode_->SetBackgroundColor(value.GetValue());
1050 rosenRenderContext->PaintBackground();
1051 auto backgroundColorVal = rosenRenderContext->rsNode_->GetStagingProperties().GetBackgroundColor();
1052 EXPECT_EQ(backgroundColorVal, OHOS::Rosen::RSColor::FromArgbInt(value.GetValue()));
1053 }
1054
1055 /**
1056 * @tc.name: RosenRenderContextTest044
1057 * @tc.desc: HasValidBgImageResizable().
1058 * @tc.type: FUNC
1059 */
1060 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest044, TestSize.Level1)
1061 {
1062 auto frameNode =
__anon54a3be8d2702() 1063 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1064 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1065
1066 rosenRenderContext->bgLoadingCtx_ = nullptr;
1067 EXPECT_EQ(rosenRenderContext->HasValidBgImageResizable(), false);
1068 auto str = ImageSourceInfo(SRC_JPG);
1069 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(str, LoadNotifier(nullptr, nullptr, nullptr), true);
1070
1071 rosenRenderContext->bgLoadingCtx_ = ctx;
1072 auto srcSize = rosenRenderContext->bgLoadingCtx_->GetImageSize();
1073 auto slice = rosenRenderContext->GetBackgroundImageResizableSliceValue(ImageResizableSlice());
1074 auto left = slice.left.ConvertToPxWithSize(srcSize.Width());
1075 auto right = slice.right.ConvertToPxWithSize(srcSize.Width());
1076 auto top = slice.top.ConvertToPxWithSize(srcSize.Width());
1077 auto bottom = slice.bottom.ConvertToPxWithSize(srcSize.Width());
1078 bool firstRes = srcSize.Width() > left + right;
1079 bool secondRes = srcSize.Height() > top + bottom;
1080 bool thirdRes = right > 0;
1081 bool fourthRes = bottom > 0;
1082 bool res = firstRes && secondRes && thirdRes && fourthRes;
1083
1084 EXPECT_EQ(rosenRenderContext->HasValidBgImageResizable(), res);
1085 }
1086
1087 /**
1088 * @tc.name: RosenRenderContextTest045
1089 * @tc.desc: SetAlphaOffscreen().
1090 * @tc.type: FUNC
1091 */
1092 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest045, TestSize.Level1)
1093 {
1094 auto frameNode =
__anon54a3be8d2802() 1095 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1096 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1097 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1098 bool isOffScreen = true;
1099 bool isOffScreenVal = true;
1100 rosenRenderContext->SetAlphaOffscreen(isOffScreen);
1101 rosenRenderContext->rsNode_->SetAlphaOffscreen(isOffScreenVal);
1102 EXPECT_EQ(isOffScreen, isOffScreenVal);
1103
1104 isOffScreen = false;
1105 isOffScreenVal = false;
1106 rosenRenderContext->SetAlphaOffscreen(isOffScreen);
1107 rosenRenderContext->rsNode_->SetAlphaOffscreen(isOffScreenVal);
1108 EXPECT_EQ(isOffScreen, isOffScreenVal);
1109 }
1110
1111 /**
1112 * @tc.name: RosenRenderContextTest046
1113 * @tc.desc: Test SetRenderFit Func and GetRenderFit Func.
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest046, TestSize.Level1)
1117 {
1118 auto frameNode =
__anon54a3be8d2902() 1119 FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1120 ASSERT_NE(frameNode, nullptr);
1121 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1122 ASSERT_NE(rosenRenderContext, nullptr);
1123 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1124 rosenRenderContext->SetRenderFit(RenderFit::CENTER);
1125 auto renderFit = rosenRenderContext->GetRenderFit();
1126 ASSERT_NE(renderFit, std::nullopt);
1127 EXPECT_EQ(renderFit.value(), RenderFit::CENTER);
1128 }
1129 } // namespace OHOS::Ace::NG
