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 #include "gmock/gmock.h"
19
20 #define private public
21 #define protected public
22
23 #include "test/unittest/core/rosen/rosen_render_context_test.h"
24 #undef private
25 #undef protected
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS::Ace::NG {
31 namespace {
32 constexpr char SRC_JPG[] = "file://data/data/com.example.test/res/exampleAlt.jpg";
33
34 template <typename T>
CompareVector(const std::vector<T> & vec1,const std::vector<T> & vec2)35 bool CompareVector(const std::vector<T>& vec1, const std::vector<T>& vec2)
36 {
37 if (vec1.size() != vec2.size()) {
38 return false;
39 }
40 for (size_t i = 0; i != vec1.size(); ++i) {
41 if (!NearEqual(vec1[i], vec2[i])) {
42 return false;
43 }
44 }
45 return true;
46 }
47 } // namespace
48
SetUp()49 void RosenRenderContextTest::SetUp()
50 {
51 MockPipelineContext::SetUp();
52 MockContainer::SetUp();
53 }
54
TearDown()55 void RosenRenderContextTest::TearDown()
56 {
57 MockPipelineContext::TearDown();
58 MockContainer::TearDown();
59 }
60
InitRosenRenderContext(const RefPtr<FrameNode> & frameNode)61 RefPtr<RosenRenderContext> RosenRenderContextTest::InitRosenRenderContext(const RefPtr<FrameNode>& frameNode)
62 {
63 return InitRosenRenderContext(frameNode, RenderContext::ContextType::CANVAS);
64 }
65
InitRosenRenderContext(const RefPtr<FrameNode> & frameNode,const RenderContext::ContextType & type)66 RefPtr<RosenRenderContext> RosenRenderContextTest::InitRosenRenderContext(const RefPtr<FrameNode>& frameNode,
67 const RenderContext::ContextType& type)
68 {
69 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
70 RenderContext::ContextParam contextParam;
71 contextParam.type = type;
72 contextParam.surfaceName.emplace("test");
73 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
74 rosenRenderContext->InitContext(false, contextParamValue);
75 rosenRenderContext->SetHostNode(frameNode);
76 return rosenRenderContext;
77 }
78
79 /**
80 * @tc.name: RosenRenderContextTest001
81 * @tc.desc: SetPivot().
82 * @tc.type: FUNC
83 */
84 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest001, TestSize.Level1)
85 {
__anon099ef3ef0202() 86 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
87 auto rosenRenderContext = InitRosenRenderContext(frameNode);
88 float xPivot = 10.0;
89 float yPivot = 10.0;
90 float zPivot = 10.0;
91 rosenRenderContext->SetPivot(xPivot, yPivot, zPivot);
92 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 10.0);
93 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().y_, 10.0);
94 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivotZ(), 10.0);
95 xPivot = 5.0;
96 rosenRenderContext->SetPivot(xPivot, yPivot, zPivot);
97 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 5.0);
98 }
99
100 /**
101 * @tc.name: RosenRenderContextTest002
102 * @tc.desc: SetTransitionPivot().
103 * @tc.type: FUNC
104 */
105 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest002, TestSize.Level1)
106 {
__anon099ef3ef0302() 107 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
108 auto rosenRenderContext = InitRosenRenderContext(frameNode);
109 rosenRenderContext->SetTransitionPivot(SizeF(100.0, 100.0), true);
110 ScaleOptions scaleOptions;
111 scaleOptions.centerX = CalcDimension(50.0, DimensionUnit::PX);
112 scaleOptions.centerY = CalcDimension(50.0, DimensionUnit::PX);
113 rosenRenderContext->GetOrCreateTransitionAppearing()->UpdateScale(scaleOptions);
114 rosenRenderContext->SetTransitionPivot(SizeF(100.0, 100.0), true);
115 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 0.5);
116 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().y_, 0.5);
117 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivotZ(), 0);
118 RotateOptions rotateOptions;
119 rotateOptions.centerX = CalcDimension(50.0, DimensionUnit::PX);
120 rotateOptions.centerY = CalcDimension(50.0, DimensionUnit::PX);
121 rotateOptions.centerZ = CalcDimension(50.0, DimensionUnit::PX);
122 rosenRenderContext->GetOrCreateTransitionAppearing()->UpdateRotate(rotateOptions);
123 rosenRenderContext->SetTransitionPivot(SizeF(100.0, 100.0), true);
124 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 0.5);
125 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().y_, 0.5);
126 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivotZ(), 50.0);
127 }
128
129 /**
130 * @tc.name: RosenRenderContextTest003
131 * @tc.desc: SetSandBox().
132 * @tc.type: FUNC
133 */
134 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest003, TestSize.Level1)
135 {
__anon099ef3ef0402() 136 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
137 auto rosenRenderContext = InitRosenRenderContext(frameNode);
138 std::optional<OffsetF> parentPosition = std::make_optional(OffsetF(100.0, 100.0));
139 rosenRenderContext->SetSandBox(parentPosition, false);
140 EXPECT_EQ(rosenRenderContext->sandBoxCount_, 1);
141 rosenRenderContext->SetSandBox(parentPosition, true);
142 EXPECT_EQ(rosenRenderContext->sandBoxCount_, 1);
143 rosenRenderContext->SetSandBox(std::nullopt, true);
144 EXPECT_EQ(rosenRenderContext->sandBoxCount_, 0);
145 rosenRenderContext->sandBoxCount_ = 2;
146 rosenRenderContext->SetSandBox(std::nullopt, true);
147 EXPECT_EQ(rosenRenderContext->sandBoxCount_, 0);
148 }
149
150 /**
151 * @tc.name: RosenRenderContextTest004
152 * @tc.desc: SetFrameWithoutAnimation().
153 * @tc.type: FUNC
154 */
155 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest004, TestSize.Level1)
156 {
__anon099ef3ef0502() 157 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
158 auto rosenRenderContext = InitRosenRenderContext(frameNode);
159 RectF paintRect = { 10.0f, 10.0f, 10.0f, 10.0f };
160 rosenRenderContext->SetFrameWithoutAnimation(paintRect);
161 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[0], paintRect.GetX());
162 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[1], paintRect.GetY());
163 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[2], paintRect.Width());
164 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[3], paintRect.Height());
165 }
166
167 /**
168 * @tc.name: RosenRenderContextTest005
169 * @tc.desc: SyncGeometryFrame().
170 * @tc.type: FUNC
171 */
172 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest005, TestSize.Level1)
173 {
__anon099ef3ef0602() 174 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
175 auto rosenRenderContext = InitRosenRenderContext(frameNode);
176 RectF paintRect = { 10.0f, 10.0f, 10.0f, 10.0f };
177 rosenRenderContext->SyncGeometryFrame(paintRect);
178 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[0], paintRect.GetX());
179 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[1], paintRect.GetY());
180 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[2], paintRect.Width());
181 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[3], paintRect.Height());
182 rosenRenderContext->SyncGeometryFrame(paintRect);
183 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds()[0], paintRect.GetX());
184 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds()[1], paintRect.GetY());
185 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds()[2], paintRect.Width());
186 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds()[3], paintRect.Height());
187 }
188
189 /**
190 * @tc.name: RosenRenderContextTest006
191 * @tc.desc: SetChildBounds().
192 * @tc.type: FUNC
193 */
194 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest006, TestSize.Level1)
195 {
__anon099ef3ef0702() 196 auto hostNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
197 auto rosenRenderContext = InitRosenRenderContext(hostNode);
198 RectF paintRect = { 10.0f, 10.0f, 10.0f, 10.0f };
199 rosenRenderContext->SetChildBounds(paintRect);
200 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetChildren().size(), 0);
201 auto rosenRenderContextChild = AceType::MakeRefPtr<RosenRenderContext>();
202 RenderContext::ContextParam contextParam;
203 contextParam.type = RenderContext::ContextType::CANVAS;
204 contextParam.surfaceName.emplace("test1");
205 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
206 rosenRenderContextChild->InitContext(false, contextParamValue);
__anon099ef3ef0802() 207 auto frameNode = FrameNode::GetOrCreateFrameNode("child", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
208 rosenRenderContextChild->SetHostNode(frameNode);
209 rosenRenderContext->AddChild(rosenRenderContextChild, 10);
210 rosenRenderContext->SetChildBounds(paintRect);
211 EXPECT_EQ(rosenRenderContextChild->GetRSNode()->GetStagingProperties().GetBounds()[0], 0.0);
212 EXPECT_EQ(rosenRenderContextChild->GetRSNode()->GetStagingProperties().GetBounds()[1], 0.0);
213 EXPECT_EQ(rosenRenderContextChild->GetRSNode()->GetStagingProperties().GetBounds()[2], paintRect.Width());
214 EXPECT_EQ(rosenRenderContextChild->GetRSNode()->GetStagingProperties().GetBounds()[3], paintRect.Height());
215 }
216
217 /**
218 * @tc.name: RosenRenderContextTest008
219 * @tc.desc: OnForegroundEffectUpdate().
220 * @tc.type: FUNC
221 */
222 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest008, TestSize.Level1)
223 {
__anon099ef3ef0902() 224 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
225 auto rosenRenderContext = InitRosenRenderContext(frameNode);
226 rosenRenderContext->OnForegroundEffectUpdate(1.0f);
227 EXPECT_TRUE(rosenRenderContext->GetRSNode()->GetStagingProperties().GetForegroundEffectRadius() - 1.0 < 1);
228 }
229
230 /**
231 * @tc.name: RosenRenderContextTest011
232 * @tc.desc: SyncGeometryFrame().
233 * @tc.type: FUNC
234 */
235 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest011, TestSize.Level1)
236 {
__anon099ef3ef0a02() 237 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
238 auto rosenRenderContext = InitRosenRenderContext(frameNode);
239 rosenRenderContext->OnOpacityUpdate(10.0);
240 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetAlpha(), 10.0);
241 }
242
243 /**
244 * @tc.name: RosenRenderContextTest012
245 * @tc.desc: ConvertDimensionToScaleBySize().
246 * @tc.type: FUNC
247 */
248 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest012, TestSize.Level1)
249 {
250 Dimension dimension;
251 dimension.SetUnit(DimensionUnit::FP);
252 float size = 100.0;
253 float ret = RosenRenderContext::ConvertDimensionToScaleBySize(dimension, size);
254 EXPECT_EQ(ret == 0.5f, false);
255 dimension.SetUnit(DimensionUnit::PERCENT);
256 float ret2 = RosenRenderContext::ConvertDimensionToScaleBySize(dimension, size);
257 EXPECT_EQ(ret2 == 0.0f, true);
258 }
259
260 /**
261 * @tc.name: RosenRenderContextTest013
262 * @tc.desc: OnNodeAppear().
263 * @tc.type: FUNC
264 */
265 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest013, TestSize.Level1)
266 {
__anon099ef3ef0b02() 267 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
268 auto rosenRenderContext = InitRosenRenderContext(frameNode);
269 // recursive is false
270 rosenRenderContext->OnNodeAppear(false);
271 EXPECT_TRUE(rosenRenderContext->firstTransitionIn_);
272 // OnNodeAppear() recursive is true
273 rosenRenderContext->OnNodeAppear(true);
274 EXPECT_FALSE(rosenRenderContext->isDisappearing_);
275 }
276
277 /**
278 * @tc.name: RosenRenderContextTest014
279 * @tc.desc: CreateHardwareSurface().
280 * @tc.type: FUNC
281 */
282 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest014, TestSize.Level1)
283 {
__anon099ef3ef0c02() 284 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
285 auto rosenRenderContext = InitRosenRenderContext(frameNode);
286 std::optional<RenderContext::ContextParam> param = std::make_optional(RenderContext::ContextParam());
287 bool isTextureExportNode = true;
288 std::shared_ptr<Rosen::RSUIContext> rsUIContext;
289 std::shared_ptr<Rosen::RSNode> ret = rosenRenderContext->CreateHardwareSurface(
290 param, isTextureExportNode, rsUIContext);
291 EXPECT_FALSE(ret == nullptr);
292 }
293
294 /**
295 * @tc.name: RosenRenderContextTest015
296 * @tc.desc: SyncGeometryProperties().
297 * @tc.type: FUNC
298 */
299 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest015, TestSize.Level1)
300 {
__anon099ef3ef0d02() 301 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
302 auto rosenRenderContext = InitRosenRenderContext(frameNode);
303 RectF paintRect = { 10.0f, 10.0f, 10.0f, 10.0f };
304 rosenRenderContext->SyncGeometryProperties(paintRect);
305 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[0], paintRect.GetX());
306 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[1], paintRect.GetY());
307 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[2], paintRect.Width());
308 EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame()[3], paintRect.Height());
309 }
310
311 /**
312 * @tc.name: RosenRenderContextTest017
313 * @tc.desc: OnBackgroundImageUpdate().
314 * @tc.type: FUNC
315 */
316 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest017, TestSize.Level1)
317 {
__anon099ef3ef0e02() 318 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
319 auto rosenRenderContext = InitRosenRenderContext(frameNode);
320 // Src null,pixmap null
321 ImageSourceInfo src;
322 rosenRenderContext->OnBackgroundImageUpdate(src);
323 EXPECT_EQ(rosenRenderContext->bgImage_, nullptr);
324 EXPECT_EQ(rosenRenderContext->bgLoadingCtx_, nullptr);
325 // Src null,pixmap not null
326 RefPtr<PixelMap> pixmap;
327 std::optional<Color> fillColor = std::make_optional(Color::BLACK);
328 src.SetPixMap(pixmap, fillColor);
329 rosenRenderContext->OnBackgroundImageUpdate(src);
330 EXPECT_TRUE(rosenRenderContext->bgImage_ == nullptr);
331 EXPECT_TRUE(rosenRenderContext->bgLoadingCtx_ == nullptr);
332 // Src not null,pixmap null
333 src.SetSrc("test");
334 rosenRenderContext->OnBackgroundImageUpdate(src);
335 EXPECT_TRUE(rosenRenderContext->bgImage_ == nullptr);
336 EXPECT_TRUE(rosenRenderContext->bgLoadingCtx_ != nullptr);
337 }
338
339 /**
340 * @tc.name: RosenRenderContextTest019
341 * @tc.desc: OnParticleOptionArrayUpdate()
342 * @tc.type: FUNC
343 */
344 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest019, TestSize.Level1)
345 {
346 auto frameNode =
__anon099ef3ef0f02() 347 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
348 auto rosenRenderContext = InitRosenRenderContext(frameNode);
349 std::list<ParticleOption> optionList;
350 rosenRenderContext->OnParticleOptionArrayUpdate(optionList);
351 EXPECT_FALSE(rosenRenderContext->particleAnimationPlaying_);
352 rosenRenderContext->paintRect_ = RectT<float>(1.0f, 1.0f, 1.0f, 1.0f);
353 rosenRenderContext->OnParticleOptionArrayUpdate(optionList);
354 EXPECT_TRUE(rosenRenderContext->particleAnimationPlaying_);
__anon099ef3ef1002() 355 auto frameNode2 = FrameNode::GetOrCreateFrameNode("parent", -1, []() {
356 auto pattern = AceType::MakeRefPtr<ParticlePattern>(1);
357 pattern->SetHaveUnVisibleParent(true);
358 return pattern;
359 });
360 auto rosenRenderContext2 = InitRosenRenderContext(frameNode2);
361 rosenRenderContext2->paintRect_ = RectT<float>(1.0f, 1.0f, 1.0f, 1.0f);
362 rosenRenderContext2->OnParticleOptionArrayUpdate(optionList);
363 EXPECT_FALSE(rosenRenderContext2->particleAnimationPlaying_);
364 }
365
366 /**
367 * @tc.name: RosenRenderContextTest020
368 * @tc.desc: OnParticleOptionArrayUpdate()
369 * @tc.type: FUNC
370 */
371 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest020, TestSize.Level1)
372 {
373 auto frameNode =
__anon099ef3ef1102() 374 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
375 auto rosenRenderContext = InitRosenRenderContext(frameNode);
376 // constrcuct params,default value,expect SetLifeTime 0.0f,SetLifeTimeRange 1.0f
377 ParticleOption particleOption;
378 RectF rectF;
379 EmitterOption emitter;
380 Particle particle;
381 particle.SetLifeTime(0.0f);
382 particle.SetLifeTimeRange(1.0f);
383 emitter.SetParticle(particle);
384 particleOption.SetEmitterOption(emitter);
385 OHOS::Rosen::ParticleParams ret = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
386 EXPECT_EQ(ret.velocity_.velocityAngle_.start_, 0.0f);
387 EXPECT_EQ(ret.velocity_.velocityAngle_.end_, 0.0f);
388 // SetLifeTime 0.0f,SetLifeTimeRange 1.0f
389 Particle particle2;
390 particle2.SetLifeTime(-1.0f);
391 particle2.SetLifeTimeRange(1.0f);
392 emitter.SetParticle(particle2);
393 particleOption.SetEmitterOption(emitter);
394 OHOS::Rosen::ParticleParams ret2 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
395 EXPECT_EQ(ret2.velocity_.velocityAngle_.start_, 0.0f);
396 EXPECT_EQ(ret2.velocity_.velocityAngle_.end_, 0.0f);
397 // SetLifeTime 1.0f,SetLifeTimeRange 0.5f
398 Particle particle3;
399 particle3.SetLifeTime(1);
400 particle3.SetLifeTimeRange(0);
401 particle3.SetParticleType(ParticleType::IMAGE);
402 ParticleConfig config;
403 ImageParticleParameter imageParam;
404 ImageFit imageFit = ImageFit::FILL;
405 imageParam.SetImageFit(imageFit);
406 config.SetImageParticleParameter(imageParam);
407 particle3.SetConfig(config);
408 emitter.SetParticle(particle3);
409 particleOption.SetEmitterOption(emitter);
410 OHOS::Rosen::ParticleParams ret3 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
411 EXPECT_EQ(ret3.velocity_.velocityAngle_.start_, 0.0f);
412 EXPECT_EQ(ret3.velocity_.velocityAngle_.end_, 0.0f);
413 }
414
415 /**
416 * @tc.name: RosenRenderContextTest021
417 * @tc.desc: OnParticleOptionArrayUpdate()-2
418 * @tc.type: FUNC
419 */
420 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest021, TestSize.Level1)
421 {
422 auto frameNode =
__anon099ef3ef1202() 423 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
424 auto rosenRenderContext = InitRosenRenderContext(frameNode);
425 // constrcuct params,default value,expect SetLifeTime 0.0f,SetLifeTimeRange 1.0f
426 ParticleOption particleOption;
427 RectF rectF;
428 EmitterOption emitter;
429 Particle particle;
430 particle.SetLifeTime(0.0f);
431 particle.SetLifeTimeRange(1.0f);
432 emitter.SetParticle(particle);
433 particleOption.SetEmitterOption(emitter);
434 // particleColorPropertyOption assign value
435 ParticleColorPropertyOption particleColorPropertyOption;
436 particleOption.SetParticleColorOption(particleColorPropertyOption);
437 OHOS::Rosen::ParticleParams ret4 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
438 EXPECT_EQ(ret4.color_.updator_, OHOS::Rosen::ParticleUpdator::NONE);
439 ParticleColorPropertyUpdater colorUpdater;
440 colorUpdater.SetUpdateType(UpdaterType::RANDOM);
441 particleColorPropertyOption.SetUpdater(colorUpdater);
442 particleOption.SetParticleColorOption(particleColorPropertyOption);
443 OHOS::Rosen::ParticleParams ret5 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
444 EXPECT_EQ(ret5.color_.updator_, OHOS::Rosen::ParticleUpdator::RANDOM);
445 colorUpdater.SetUpdateType(UpdaterType::CURVE);
446 particleColorPropertyOption.SetUpdater(colorUpdater);
447 particleOption.SetParticleColorOption(particleColorPropertyOption);
448 OHOS::Rosen::ParticleParams ret6 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
449 EXPECT_EQ(ret6.color_.updator_, OHOS::Rosen::ParticleUpdator::CURVE);
450 // ParticleFloatPropertyOption assign value
451 ParticleFloatPropertyOption particleFloatPropertyOption;
452 particleOption.SetParticleOpacityOption(particleFloatPropertyOption);
453 OHOS::Rosen::ParticleParams ret7 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
454 EXPECT_EQ(ret7.opacity_.updator_, OHOS::Rosen::ParticleUpdator::NONE);
455 ParticleFloatPropertyUpdater particleFloatPropertyUpdater;
456 particleFloatPropertyUpdater.SetUpdaterType(UpdaterType::RANDOM);
457 particleFloatPropertyOption.SetUpdater(particleFloatPropertyUpdater);
458 particleOption.SetParticleOpacityOption(particleFloatPropertyOption);
459 OHOS::Rosen::ParticleParams ret8 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
460 EXPECT_EQ(ret8.opacity_.updator_, OHOS::Rosen::ParticleUpdator::RANDOM);
461 particleFloatPropertyUpdater.SetUpdaterType(UpdaterType::CURVE);
462 particleFloatPropertyOption.SetUpdater(particleFloatPropertyUpdater);
463 particleOption.SetParticleOpacityOption(particleFloatPropertyOption);
464 OHOS::Rosen::ParticleParams ret9 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
465 EXPECT_EQ(ret9.opacity_.updator_, OHOS::Rosen::ParticleUpdator::CURVE);
466 // scaleOptionOpt assing value,same as rsOpacityOpt
467 particleOption.SetParticleScaleOption(particleFloatPropertyOption);
468 OHOS::Rosen::ParticleParams ret10 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
469 EXPECT_EQ(ret10.scale_.updator_, OHOS::Rosen::ParticleUpdator::CURVE);
470 }
471
472 /**
473 * @tc.name: RosenRenderContextTest022
474 * @tc.desc: OnParticleOptionArrayUpdate()-3
475 * @tc.type: FUNC
476 */
477 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest022, TestSize.Level1)
478 {
479 auto frameNode =
__anon099ef3ef1302() 480 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
481 auto rosenRenderContext = InitRosenRenderContext(frameNode);
482 // constrcuct params,default value,expect SetLifeTime 0.0f,SetLifeTimeRange 1.0f
483 ParticleOption particleOption;
484 RectF rectF;
485 EmitterOption emitter;
486 Particle particle;
487 particle.SetLifeTime(0.0f);
488 particle.SetLifeTimeRange(1.0f);
489 emitter.SetParticle(particle);
490 particleOption.SetEmitterOption(emitter);
491 // velocityOptionOpt assing value
492 VelocityProperty velocityProperty;
493 std::pair<float, float> range = std::make_pair(1.0f, 2.0f);
494 velocityProperty.SetSpeedRange(range);
495 velocityProperty.SetAngleRange(range);
496 particleOption.SetParticleVelocityOption(velocityProperty);
497 OHOS::Rosen::ParticleParams ret11 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
498 EXPECT_EQ(ret11.velocity_.velocityAngle_.end_, 2.0f);
499 // accelerationProperty assing value
500 AccelerationProperty accelerationProperty;
501 particleOption.SetParticleAccelerationOption(accelerationProperty);
502 OHOS::Rosen::ParticleParams ret12 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
503 EXPECT_EQ(ret12.acceleration_.accelerationAngle_.val_.end_, 0.0f);
504 EXPECT_EQ(ret12.acceleration_.accelerationValue_.val_.end_, 0.0f);
505 ParticleFloatPropertyOption particleFloatPropertyOption1;
506 particleFloatPropertyOption1.SetRange(range);
507 accelerationProperty.SetSpeed(particleFloatPropertyOption1);
508 accelerationProperty.SetAngle(particleFloatPropertyOption1);
509 particleOption.SetParticleAccelerationOption(accelerationProperty);
510 OHOS::Rosen::ParticleParams ret13 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
511 EXPECT_EQ(ret13.acceleration_.accelerationAngle_.val_.end_, 2.0f);
512 EXPECT_EQ(ret13.acceleration_.accelerationValue_.val_.end_, 2.0f);
513 // spinOption assing value
514 particleOption.SetParticleSpinOption(particleFloatPropertyOption1);
515 OHOS::Rosen::ParticleParams ret14 = rosenRenderContext->ConvertParticleOptionToParams(particleOption, rectF);
516 EXPECT_EQ(ret14.spin_.updator_, OHOS::Rosen::ParticleUpdator::NONE);
517 }
518
519 /**
520 * @tc.name: RosenRenderContextTest023
521 * @tc.desc: OnDynamicRangeModeUpdate()
522 * @tc.type: FUNC
523 */
524 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest023, TestSize.Level1)
525 {
526 auto frameNode =
__anon099ef3ef1402() 527 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
528 auto rosenRenderContext = InitRosenRenderContext(frameNode);
529 // constrcuct params
530 DynamicRangeMode dynamicRangeMode = DynamicRangeMode::STANDARD;
531 rosenRenderContext->OnDynamicRangeModeUpdate(dynamicRangeMode);
532 EXPECT_EQ(rosenRenderContext->isHdr_, false);
533 dynamicRangeMode = DynamicRangeMode::HIGH;
534 rosenRenderContext->OnDynamicRangeModeUpdate(dynamicRangeMode);
535 EXPECT_EQ(rosenRenderContext->isHdr_, true);
536 rosenRenderContext->OnDynamicRangeModeUpdate(dynamicRangeMode);
537 EXPECT_EQ(rosenRenderContext->isHdr_, false);
538 }
539
540 /**
541 * @tc.name: RosenRenderContextTest024
542 * @tc.desc: GetThumbnailPixelMap()
543 * @tc.type: FUNC
544 */
545 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest024, TestSize.Level1)
546 {
547 auto frameNode =
__anon099ef3ef1502() 548 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
549 auto rosenRenderContext = InitRosenRenderContext(frameNode);
550 // constrcuct params
551 RefPtr<PixelMap> ret = rosenRenderContext->GetThumbnailPixelMap(false);
552 EXPECT_EQ(Referenced::RawPtr(ret) == nullptr, true);
553 RefPtr<PixelMap> ret2 = rosenRenderContext->GetThumbnailPixelMap(true);
554 EXPECT_EQ(Referenced::RawPtr(ret) == nullptr, true);
555 }
556
557 /**
558 * @tc.name: RosenRenderContextTest025
559 * @tc.desc: MarshallTranslate()
560 * @tc.type: FUNC
561 */
562 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest025, TestSize.Level1)
563 {
564 auto frameNode =
__anon099ef3ef1602() 565 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
566 auto rosenRenderContext = InitRosenRenderContext(frameNode);
567 // constrcuct params
568 TranslateOptions translate;
569 Vector3F ret = rosenRenderContext->MarshallTranslate(translate);
570 EXPECT_EQ(ret.x, 0.0f);
571 EXPECT_EQ(ret.y, 0.0f);
572 EXPECT_EQ(ret.z, 0.0f);
573 CalcDimension x(1.0, DimensionUnit::PX);
574 CalcDimension y(1.0, DimensionUnit::PERCENT);
575 CalcDimension z(1.0, DimensionUnit::PX);
576 TranslateOptions translate1(x, y, z);
577 Vector3F ret2 = rosenRenderContext->MarshallTranslate(translate1);
578 EXPECT_EQ(ret2.x, 0.0f);
579 CalcDimension x2(1.0, DimensionUnit::PERCENT);
580 TranslateOptions translate2(x2, y, z);
581 Vector3F ret3 = rosenRenderContext->MarshallTranslate(translate2);
582 EXPECT_EQ(ret3.x, 0.0f);
583 }
584
585 /**
586 * @tc.name: RosenRenderContextTest026
587 * @tc.desc: GetPaintRectWithTransform()
588 * @tc.type: FUNC
589 */
590 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest026, TestSize.Level1)
591 {
592 auto frameNode =
__anon099ef3ef1702() 593 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
594 auto rosenRenderContext = InitRosenRenderContext(frameNode);
595 // constrcuct params
596 RectF ret = rosenRenderContext->GetPaintRectWithTransform();
597 EXPECT_EQ(ret.x_, 0.0f);
598 rosenRenderContext->GetRSNode()->SetRotation(2.0f);
599 RectF ret2 = rosenRenderContext->GetPaintRectWithTransform();
600 EXPECT_EQ(ret2.x_, 0.0f);
601 rosenRenderContext->GetRSNode()->SetRotation(90.0f);
602 RectF ret3 = rosenRenderContext->GetPaintRectWithTransform();
603 EXPECT_EQ(ret3.x_, 0.0f);
604 rosenRenderContext->GetRSNode()->SetRotation(180.0f);
605 RectF ret4 = rosenRenderContext->GetPaintRectWithTransform();
606 EXPECT_EQ(ret4.x_, 0.0f);
607 rosenRenderContext->GetRSNode()->SetRotation(270.0f);
608 RectF ret5 = rosenRenderContext->GetPaintRectWithTransform();
609 EXPECT_EQ(ret5.x_, 0.0f);
610 }
611
612 /**
613 * @tc.name: RosenRenderContextTest027
614 * @tc.desc: GetPaintRectWithTranslate()
615 * @tc.type: FUNC
616 */
617 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest027, TestSize.Level1)
618 {
619 auto frameNode =
__anon099ef3ef1802() 620 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
621 auto rosenRenderContext = InitRosenRenderContext(frameNode);
622 // constrcuct params
623 std::pair<RectF, bool> ret = rosenRenderContext->GetPaintRectWithTranslate();
624 EXPECT_EQ(ret.first.x_, 0.0f);
625 rosenRenderContext->GetRSNode()->SetRotation(90.0f);
626 std::pair<RectF, bool> ret2 = rosenRenderContext->GetPaintRectWithTranslate();
627 EXPECT_EQ(ret2.first.width_, -1.0f);
628 }
629
630 /**
631 * @tc.name: RosenRenderContextTest028
632 * @tc.desc: GetRevertMatrix()/GetMatrix()/GetMatrixWithTransformRotate()
633 * @tc.type: FUNC
634 */
635 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest028, TestSize.Level1)
636 {
637 auto frameNode =
__anon099ef3ef1902() 638 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
639 auto rosenRenderContext = InitRosenRenderContext(frameNode);
640 // constrcuct params
641 Matrix4 ret = rosenRenderContext->GetRevertMatrix();
642 EXPECT_EQ(ret(0, 0), 1.0f);
643 Matrix4 ret2 = rosenRenderContext->GetMatrix();
644 EXPECT_EQ(ret2(0, 0), 1.0f);
645 Matrix4 ret3 = rosenRenderContext->GetMatrixWithTransformRotate();
646 EXPECT_EQ(ret3(0, 0), 1.0f);
647 }
648
649 /**
650 * @tc.name: RosenRenderContextTest029
651 * @tc.desc: GetPointWithTransform()
652 * @tc.type: FUNC
653 */
654 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest029, TestSize.Level1)
655 {
656 auto frameNode =
__anon099ef3ef1a02() 657 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
658 auto rosenRenderContext = InitRosenRenderContext(frameNode);
659 // constrcuct params
660 PointF pointf;
661 rosenRenderContext->GetPointWithTransform(pointf);
662 EXPECT_EQ(pointf.x_, 0.0f);
663 rosenRenderContext->GetRSNode()->SetRotation(90.0f);
664 rosenRenderContext->GetPointWithTransform(pointf);
665 EXPECT_EQ(pointf.x_, 0.0f);
666 }
667
668 /**
669 * @tc.name: RosenRenderContextTest030
670 * @tc.desc: NeedPreloadImage()
671 * @tc.type: FUNC
672 */
673 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest030, TestSize.Level1)
674 {
675 auto frameNode =
__anon099ef3ef1b02() 676 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
677 auto rosenRenderContext = InitRosenRenderContext(frameNode);
678 // constrcuct params
679 std::list<ParticleOption> optionList;
680 RectF rect;
681 bool ret = rosenRenderContext->NeedPreloadImage(optionList, rect);
682 EXPECT_FALSE(ret);
683 ParticleOption particleOption1;
684 EmitterOption emitter1;
685 Particle particle1;
686 particle1.SetLifeTime(1);
687 particle1.SetLifeTimeRange(0);
688 particle1.SetParticleType(ParticleType::POINT);
689 emitter1.SetParticle(particle1);
690 particleOption1.SetEmitterOption(emitter1);
691 optionList.push_back(particleOption1);
692 bool ret2 = rosenRenderContext->NeedPreloadImage(optionList, rect);
693 EXPECT_FALSE(ret2);
694 ParticleOption particleOption;
695 EmitterOption emitter;
696 Particle particle;
697 particle.SetLifeTime(1);
698 particle.SetLifeTimeRange(0);
699 particle.SetParticleType(ParticleType::IMAGE);
700 emitter.SetParticle(particle);
701 particleOption.SetEmitterOption(emitter);
702 optionList.push_back(particleOption);
703 bool ret3 = rosenRenderContext->NeedPreloadImage(optionList, rect);
704 EXPECT_TRUE(ret3);
705 }
706
707 /**
708 * @tc.name: RosenRenderContextTest031
709 * @tc.desc: OnParticleImageLoaded()/ConvertDimensionToPx
710 * @tc.type: FUNC
711 */
712 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest031, TestSize.Level1)
713 {
714 auto frameNode =
__anon099ef3ef1c02() 715 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
716 auto rosenRenderContext = InitRosenRenderContext(frameNode);
717 // constrcuct params
718 std::string src = "";
719 RefPtr<CanvasImage> canvasImage;
720 int size = rosenRenderContext->particleImageMap_.size();
721 rosenRenderContext->OnParticleImageLoaded(src, canvasImage);
722 EXPECT_EQ(rosenRenderContext->particleImageMap_.size(), size + 1);
723
724 OHOS::Ace::Dimension dimension(1.0, DimensionUnit::PX);
725 float ret = rosenRenderContext->ConvertDimensionToPx(dimension, 5);
726 EXPECT_EQ(ret, 1.0f);
727 OHOS::Ace::Dimension dimension2(1.0, DimensionUnit::PERCENT);
728 float ret2 = rosenRenderContext->ConvertDimensionToPx(dimension2, 5);
729 EXPECT_EQ(ret2, 5.0f);
730 }
731
732 /**
733 * @tc.name: RosenRenderContextTest032
734 * @tc.desc: InitContext()
735 * @tc.type: FUNC
736 */
737 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest032, TestSize.Level1)
738 {
739 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
740 RenderContext::ContextParam contextParam;
741 contextParam.type = RenderContext::ContextType::CANVAS;
742 contextParam.surfaceName.emplace("test");
743 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
744 // is root is true
745 rosenRenderContext->InitContext(true, contextParamValue);
746 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
747 rosenRenderContext->rsNode_ = nullptr;
748 // contextParamValue does not has value
749 std::optional<RenderContext::ContextParam> contextParamValue2 = std::make_optional(contextParam);
750 rosenRenderContext->InitContext(false, contextParamValue2);
751 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
752 rosenRenderContext->rsNode_ = nullptr;
753 contextParam.type = RenderContext::ContextType::ROOT;
754 std::optional<RenderContext::ContextParam> contextParamValue3 = std::make_optional(contextParam);
755 rosenRenderContext->InitContext(false, contextParamValue3);
756 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
757 rosenRenderContext->rsNode_ = nullptr;
758 contextParam.type = RenderContext::ContextType::SURFACE;
759 std::optional<RenderContext::ContextParam> contextParamValue4 = std::make_optional(contextParam);
760 rosenRenderContext->InitContext(false, contextParamValue4);
761 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
762 rosenRenderContext->rsNode_ = nullptr;
763 contextParam.type = RenderContext::ContextType::HARDWARE_SURFACE;
764 std::optional<RenderContext::ContextParam> contextParamValue5 = std::make_optional(contextParam);
765 rosenRenderContext->InitContext(false, contextParamValue5);
766 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
767 rosenRenderContext->rsNode_ = nullptr;
768 contextParam.type = RenderContext::ContextType::EFFECT;
769 std::optional<RenderContext::ContextParam> contextParamValue7 = std::make_optional(contextParam);
770 rosenRenderContext->InitContext(false, contextParamValue7);
771 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
772 rosenRenderContext->rsNode_ = nullptr;
773 contextParam.type = RenderContext::ContextType::INCREMENTAL_CANVAS;
774 std::optional<RenderContext::ContextParam> contextParamValue8 = std::make_optional(contextParam);
775 rosenRenderContext->InitContext(false, contextParamValue8);
776 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
777 rosenRenderContext->rsNode_ = nullptr;
778 contextParam.type = RenderContext::ContextType::EXTERNAL;
779 std::optional<RenderContext::ContextParam> contextParamValue9 = std::make_optional(contextParam);
780 rosenRenderContext->InitContext(false, contextParamValue9);
781 EXPECT_EQ(rosenRenderContext->rsNode_ == nullptr, true);
782 }
783
784 /**
785 * @tc.name: RosenRenderContextTest033
786 * @tc.desc: PaintDebugBoundary()
787 * @tc.type: FUNC
788 */
789 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest033, TestSize.Level1)
790 {
791 auto frameNode =
__anon099ef3ef1d02() 792 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
793 auto rosenRenderContext = InitRosenRenderContext(frameNode);
794 rosenRenderContext->PaintDebugBoundary(false);
795 EXPECT_EQ(rosenRenderContext->debugBoundaryModifier_ == nullptr, true);
796 auto rosenRenderContext2 = AceType::MakeRefPtr<RosenRenderContext>();
797 RenderContext::ContextParam contextParam;
798 contextParam.type = RenderContext::ContextType::SURFACE;
799 contextParam.surfaceName.emplace("test");
800 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
801 rosenRenderContext2->InitContext(false, contextParamValue);
802 rosenRenderContext2->SetHostNode(frameNode);
803 rosenRenderContext2->PaintDebugBoundary(true);
804 EXPECT_EQ(rosenRenderContext->debugBoundaryModifier_ == nullptr, true);
805 }
806
807 /**
808 * @tc.name: RosenRenderContextTest034
809 * @tc.desc: UpdateBlurBackgroundColor()
810 * @tc.type: FUNC
811 */
812 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest034, TestSize.Level1)
813 {
814 auto frameNode =
__anon099ef3ef1e02() 815 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<ParticlePattern>(1); });
816 auto rosenRenderContext = InitRosenRenderContext(frameNode);
817 std::optional<BlurStyleOption> bgBlurStyle;
818 EXPECT_FALSE(rosenRenderContext->UpdateBlurBackgroundColor(bgBlurStyle));
819 std::optional<BlurStyleOption> bgBlurStyle2 = std::make_optional(BlurStyleOption());
820 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(bgBlurStyle2));
821 bgBlurStyle2->isValidColor = true;
822 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(bgBlurStyle2));
823 bgBlurStyle2->isWindowFocused = false;
824 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(bgBlurStyle2));
825
826 std::optional<EffectOption> efffectOption = std::make_optional(EffectOption());
827 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(efffectOption));
828 efffectOption->isValidColor = true;
829 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(efffectOption));
830 efffectOption->isWindowFocused = false;
831 EXPECT_TRUE(rosenRenderContext->UpdateBlurBackgroundColor(efffectOption));
832 }
833
834 /**
835 * @tc.name: RosenRenderContextTest035
836 * @tc.desc: UpdateAccessibilityRoundRect().
837 * @tc.type: FUNC
838 */
839 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest035, TestSize.Level1)
840 {
__anon099ef3ef1f02() 841 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
842 auto rosenRenderContext = InitRosenRenderContext(frameNode);
843 if (!rosenRenderContext) {
844 return;
845 }
846
847 rosenRenderContext->accessibilityFocusStateModifier_ = std::make_shared<FocusStateModifier>();
848 if (!rosenRenderContext->accessibilityFocusStateModifier_) {
849 return;
850 }
851
852 RoundRect frameRect;
853 frameRect.SetRect(RectF(6, 6, 6, 6));
854 const constexpr double accessibilityFocusWidth = 4.0;
855 double lineWidth = accessibilityFocusWidth * PipelineBase::GetCurrentDensity();
856 Dimension paintWidth(lineWidth, DimensionUnit::PX);
857 auto paintWidthPx = static_cast<float>(paintWidth.ConvertToPx());
858 (void)paintWidthPx;
859 rosenRenderContext->accessibilityFocusStateModifier_->SetRoundRect(frameRect, paintWidthPx);
860 if (!rosenRenderContext->accessibilityFocusStateModifier_->animationRect_) {
861 return;
862 }
863 frameNode->geometryNode_->SetFrameSize(SizeF(10.0f, 10.0f));
864 rosenRenderContext->UpdateAccessibilityRoundRect();
865 auto rectBeforeUpdate = rosenRenderContext->accessibilityFocusStateModifier_->roundRect_.GetRect();
866 EXPECT_EQ(rectBeforeUpdate.GetLeft(), 2.0f);
867 EXPECT_EQ(rectBeforeUpdate.GetTop(), 2.0f);
868 EXPECT_EQ(rectBeforeUpdate.GetRight(), 8.0f);
869 EXPECT_EQ(rectBeforeUpdate.GetBottom(), 8.0f);
870
871 frameNode->geometryNode_->SetFrameSize(SizeF(20.0f, 20.0f));
872 rosenRenderContext->UpdateAccessibilityRoundRect();
873 auto rectAfterUpdate = rosenRenderContext->accessibilityFocusStateModifier_->roundRect_.GetRect();
874
875 EXPECT_EQ(rectAfterUpdate.GetLeft(), 2.0f);
876 EXPECT_EQ(rectAfterUpdate.GetTop(), 2.0f);
877 EXPECT_EQ(rectAfterUpdate.GetRight(), 18.0f);
878 EXPECT_EQ(rectAfterUpdate.GetBottom(), 18.0f);
879
880 Dimension focusPaddingVp = Dimension(0.0, DimensionUnit::VP);
881 auto borderPaddingPx = static_cast<float>(focusPaddingVp.ConvertToPx());
882 auto diffRadiusValueX = borderPaddingPx + paintWidthPx / 2;
883 auto diffRadiusValueY = borderPaddingPx + paintWidthPx / 2;
884
885 auto roundRectAfterUpdate = rosenRenderContext->accessibilityFocusStateModifier_->roundRect_;
886 auto focusPaintCornerTopLeftAfter = roundRectAfterUpdate.GetCornerRadius(RSRoundRect::RoundRect::CornerPos::TOP_LEFT_POS);
887 auto focusPaintCornerTopRightAfter = roundRectAfterUpdate.GetCornerRadius(RSRoundRect::RoundRect::CornerPos::TOP_RIGHT_POS);
888 auto focusPaintCornerBottomLeftAfter = roundRectAfterUpdate.GetCornerRadius(RSRoundRect::RoundRect::CornerPos::BOTTOM_LEFT_POS);
889 auto focusPaintCornerBottomRightAfter = roundRectAfterUpdate.GetCornerRadius(RSRoundRect::RoundRect::CornerPos::BOTTOM_RIGHT_POS);
890
891 EXPECT_EQ(focusPaintCornerTopLeftAfter.GetX(), diffRadiusValueX);
892 EXPECT_EQ(focusPaintCornerTopLeftAfter.GetY(), diffRadiusValueY);
893 EXPECT_EQ(focusPaintCornerTopRightAfter.GetX(), diffRadiusValueX);
894 EXPECT_EQ(focusPaintCornerTopRightAfter.GetY(), diffRadiusValueY);
895 EXPECT_EQ(focusPaintCornerBottomLeftAfter.GetX(), diffRadiusValueX);
896 EXPECT_EQ(focusPaintCornerBottomLeftAfter.GetY(), diffRadiusValueY);
897 EXPECT_EQ(focusPaintCornerBottomRightAfter.GetX(), diffRadiusValueX);
898 EXPECT_EQ(focusPaintCornerBottomRightAfter.GetY(), diffRadiusValueY);
899 }
900
901 /**
902 * @tc.name: RosenRenderContextTest037
903 * @tc.desc: UpdateShadow.
904 * @tc.type: FUNC
905 */
906 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest037, TestSize.Level1)
907 {
__anon099ef3ef2002() 908 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
909 auto rosenRenderContext = InitRosenRenderContext(frameNode);
910 if (!rosenRenderContext) {
911 return;
912 }
913 Shadow shadow;
914 shadow.SetBlurRadius(1.0);
915 shadow.SetOffsetX(1.0);
916 shadow.SetOffsetY(1.0);
917 shadow.SetIsFilled(true);
918 rosenRenderContext->OnBackShadowUpdate(shadow);
919 auto color = rosenRenderContext->rsNode_->GetStagingProperties().GetShadowColor();
920 ASSERT_TRUE(color.AsArgbInt() == Color::BLACK.GetValue());
921 auto offsetX = rosenRenderContext->rsNode_->GetStagingProperties().GetShadowOffsetY();
922 auto offsetY = rosenRenderContext->rsNode_->GetStagingProperties().GetShadowOffsetY();
923 ASSERT_TRUE(NearEqual(1.0, offsetX));
924 ASSERT_TRUE(NearEqual(1.0, offsetY));
925 auto isFilled = rosenRenderContext->rsNode_->GetStagingProperties().GetShadowIsFilled();
926 ASSERT_TRUE(isFilled);
927 }
928
929 /**
930 * @tc.name: RosenRenderContextTest38
931 * @tc.desc: UpdateClipEdge
932 * @tc.type: FUNC
933 */
934 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest038, TestSize.Level1)
935 {
__anon099ef3ef2102() 936 auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
937 auto rosenRenderContext = InitRosenRenderContext(frameNode);
938 if (!rosenRenderContext) {
939 return;
940 }
941 rosenRenderContext->OnClipEdgeUpdate(true);
942 auto clip = rosenRenderContext->rsNode_->GetStagingProperties().GetClipToBounds();
943 ASSERT_TRUE(clip);
944 }
945
946 /**
947 * @tc.name: RosenRenderContextTest039
948 * @tc.desc: GetStatusByEffectTypeAndWindow.
949 * @tc.type: FUNC
950 */
951 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest039, TestSize.Level1)
952 {
953 auto frameNode =
__anon099ef3ef2202() 954 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
955 auto rosenRenderContext = InitRosenRenderContext(frameNode);
956 auto pipeline = MockPipelineContext::GetCurrentContext();
957
958 auto windowEffect = EffectType::WINDOW_EFFECT;
959 rosenRenderContext->UpdateUseEffectType(windowEffect);
960 pipeline->WindowFocus(false);
961 EXPECT_TRUE(rosenRenderContext->GetStatusByEffectTypeAndWindow());
962
963 pipeline->WindowFocus(true);
964 auto useEffectTypeVal = rosenRenderContext->GetUseEffectType();
965 EXPECT_EQ(useEffectTypeVal, windowEffect);
966 EXPECT_TRUE(pipeline->IsWindowFocused());
967 EXPECT_TRUE(rosenRenderContext->GetStatusByEffectTypeAndWindow());
968
969 rosenRenderContext->UpdateUseEffectType(EffectType::DEFAULT);
970 EXPECT_FALSE(rosenRenderContext->GetStatusByEffectTypeAndWindow());
971 }
972
973 /**
974 * @tc.name: RosenRenderContextTest040
975 * @tc.desc: OnUseEffectUpdate().
976 * @tc.type: FUNC
977 */
978 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest040, TestSize.Level1)
979 {
980 auto frameNode =
__anon099ef3ef2302() 981 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
982 auto rosenRenderContext = InitRosenRenderContext(frameNode);
983 auto pipeline = rosenRenderContext->GetPipelineContext();
984 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
985
986 rosenRenderContext->UpdateUseEffectType(EffectType::WINDOW_EFFECT);
987 bool value = true;
988 // GetStatusByEffectTypeAndWindow() is true
989 pipeline->WindowFocus(false);
990 rosenRenderContext->OnUseEffectUpdate(value);
991 bool willSetVal = false;
992 rosenRenderContext->rsNode_->SetUseEffect(willSetVal);
993 EXPECT_NE(willSetVal, value);
994
995 // GetStatusByEffectTypeAndWindow() is false
996 pipeline->WindowFocus(true);
997 rosenRenderContext->OnUseEffectUpdate(value);
998 willSetVal = true;
999 rosenRenderContext->rsNode_->SetUseEffect(willSetVal);
1000 EXPECT_EQ(willSetVal, value);
1001
1002 value = false;
1003 // value is false, GetStatusByEffectTypeAndWindow() is true
1004 pipeline->WindowFocus(false);
1005 rosenRenderContext->OnUseEffectUpdate(value);
1006 willSetVal = false;
1007 rosenRenderContext->rsNode_->SetUseEffect(value);
1008 EXPECT_EQ(willSetVal, value);
1009
1010 // value is false, GetStatusByEffectTypeAndWindow() is false
1011 pipeline->WindowFocus(true);
1012 rosenRenderContext->OnUseEffectUpdate(value);
1013 willSetVal = false;
1014 rosenRenderContext->rsNode_->SetUseEffect(willSetVal);
1015 EXPECT_EQ(willSetVal, value);
1016 }
1017
1018 /**
1019 * @tc.name: RosenRenderContextTest041
1020 * @tc.desc: OnUseEffectTypeUpdate().
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest041, TestSize.Level1)
1024 {
1025 auto frameNode =
__anon099ef3ef2402() 1026 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1027 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1028 EffectType effectType = EffectType::WINDOW_EFFECT;
1029 rosenRenderContext->OnUseEffectTypeUpdate(effectType);
1030 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1031
1032 auto effectTypeParam = static_cast<Rosen::UseEffectType>(effectType);
1033 rosenRenderContext->rsNode_->SetUseEffectType(effectTypeParam);
1034
1035 bool useEffect = true;
1036 rosenRenderContext->UpdateUseEffect(useEffect);
1037 rosenRenderContext->OnUseEffectUpdate(useEffect);
1038
1039 useEffect = false;
1040 rosenRenderContext->UpdateUseEffect(useEffect);
1041 rosenRenderContext->OnUseEffectUpdate(useEffect);
1042
1043 effectType = EffectType::DEFAULT;
1044 rosenRenderContext->OnUseEffectTypeUpdate(effectType);
1045 auto useEffectTypeVal = rosenRenderContext->GetUseEffectType().value_or(EffectType::DEFAULT);
1046 EXPECT_EQ(useEffectTypeVal, effectType);
1047 }
1048
1049 /**
1050 * @tc.name: RosenRenderContextTest042
1051 * @tc.desc: UpdateWindowFocusState().
1052 * @tc.type: FUNC
1053 */
1054 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest042, TestSize.Level1)
1055 {
1056 auto frameNode =
__anon099ef3ef2502() 1057 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1058 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1059
1060 bool isFocused = true;
1061 rosenRenderContext->UpdateWindowFocusState(isFocused);
1062
1063 auto useEffect = rosenRenderContext->GetUseEffect().value_or(false);
1064 rosenRenderContext->UpdateUseEffectType(EffectType::WINDOW_EFFECT);
1065 rosenRenderContext->OnUseEffectUpdate(useEffect);
1066
1067 BlurStyleOption blurStyleObj;
1068 blurStyleObj.policy = BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE;
1069 blurStyleObj.isWindowFocused = isFocused;
1070 rosenRenderContext->UpdateBackBlurStyle(blurStyleObj);
1071
1072 EffectOption effectObj;
1073 effectObj.policy = BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE;
1074 rosenRenderContext->UpdateBackgroundEffect(effectObj);
1075 EXPECT_EQ(effectObj.isWindowFocused, isFocused);
1076 }
1077
1078 /**
1079 * @tc.name: RosenRenderContextTest043
1080 * @tc.desc: OnBackgroundColorUpdate().
1081 * @tc.type: FUNC
1082 */
1083 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest043, TestSize.Level1)
1084 {
1085 /**
1086 * @tc.steps: step1. Create node and check basic information.
1087 */
1088 auto frameNode =
__anon099ef3ef2602() 1089 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1090 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1091 const Color value = Color::RED;
1092 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1093 OHOS::Rosen::RSColor rsColor;
1094 /**
1095 * @tc.steps: step2. Call OnBackgroundColorUpdate function with value (RED), and convert it to rsColor.
1096 * @tc.expected: step2. The backgroundColorVal value on node should match rsColor value.
1097 */
1098 rosenRenderContext->OnBackgroundColorUpdate(value);
1099 rosenRenderContext->ColorToRSColor(value, rsColor);
1100 rosenRenderContext->rsNode_->SetBackgroundColor(rsColor);
1101 rosenRenderContext->PaintBackground();
1102 auto backgroundColorVal = rosenRenderContext->rsNode_->GetStagingProperties().GetBackgroundColor();
1103 rsColor.ConvertToP3ColorSpace();
1104 EXPECT_EQ(backgroundColorVal.GetRed(), rsColor.GetRed());
1105 EXPECT_EQ(backgroundColorVal.GetGreen(), rsColor.GetGreen());
1106 EXPECT_EQ(backgroundColorVal.GetBlue(), rsColor.GetBlue());
1107 EXPECT_EQ(backgroundColorVal.GetAlpha(), rsColor.GetAlpha());
1108 EXPECT_EQ(backgroundColorVal.GetColorSpace(), rsColor.GetColorSpace());
1109 /**
1110 * @tc.steps: step3. Call OnBackgroundColorUpdate function with p3Color (RED with DISPLAY_P3 color space),
1111 * and convert it to rsColor.
1112 * @tc.expected: step3. The colorSpace of p3BackgroundColorVal on node should match colorSpace of rsColor.
1113 */
1114 Color p3Color = Color::RED;
1115 p3Color.SetColorSpace(ColorSpace::DISPLAY_P3);
1116 rosenRenderContext->OnBackgroundColorUpdate(p3Color);
1117 rosenRenderContext->ColorToRSColor(p3Color, rsColor);
1118 rosenRenderContext->rsNode_->SetBackgroundColor(rsColor);
1119 rosenRenderContext->PaintBackground();
1120 auto p3BackgroundColorVal = rosenRenderContext->rsNode_->GetStagingProperties().GetBackgroundColor();
1121 EXPECT_EQ(p3BackgroundColorVal.GetColorSpace(), rsColor.GetColorSpace());
1122 }
1123
1124 /**
1125 * @tc.name: RosenRenderContextTest044
1126 * @tc.desc: HasValidBgImageResizable().
1127 * @tc.type: FUNC
1128 */
1129 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest044, TestSize.Level1)
1130 {
1131 auto frameNode =
__anon099ef3ef2702() 1132 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1133 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1134
1135 rosenRenderContext->bgLoadingCtx_ = nullptr;
1136 EXPECT_EQ(rosenRenderContext->HasValidBgImageResizable(), false);
1137 auto str = ImageSourceInfo(SRC_JPG);
1138 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(str, LoadNotifier(nullptr, nullptr, nullptr), true);
1139
1140 rosenRenderContext->bgLoadingCtx_ = ctx;
1141 auto srcSize = rosenRenderContext->bgLoadingCtx_->GetImageSize();
1142 auto slice = rosenRenderContext->GetBackgroundImageResizableSliceValue(ImageResizableSlice());
1143 auto left = slice.left.ConvertToPxWithSize(srcSize.Width());
1144 auto right = slice.right.ConvertToPxWithSize(srcSize.Width());
1145 auto top = slice.top.ConvertToPxWithSize(srcSize.Width());
1146 auto bottom = slice.bottom.ConvertToPxWithSize(srcSize.Width());
1147 bool firstRes = srcSize.Width() > left + right;
1148 bool secondRes = srcSize.Height() > top + bottom;
1149 bool thirdRes = right > 0;
1150 bool fourthRes = bottom > 0;
1151 bool res = firstRes && secondRes && thirdRes && fourthRes;
1152
1153 EXPECT_EQ(rosenRenderContext->HasValidBgImageResizable(), res);
1154 }
1155
1156 /**
1157 * @tc.name: RosenRenderContextTest045
1158 * @tc.desc: SetAlphaOffscreen().
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest045, TestSize.Level1)
1162 {
1163 auto frameNode =
__anon099ef3ef2802() 1164 FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1165 auto rosenRenderContext = InitRosenRenderContext(frameNode);
1166 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1167 bool isOffScreen = true;
1168 bool isOffScreenVal = true;
1169 rosenRenderContext->SetAlphaOffscreen(isOffScreen);
1170 rosenRenderContext->rsNode_->SetAlphaOffscreen(isOffScreenVal);
1171 EXPECT_EQ(isOffScreen, isOffScreenVal);
1172
1173 isOffScreen = false;
1174 isOffScreenVal = false;
1175 rosenRenderContext->SetAlphaOffscreen(isOffScreen);
1176 rosenRenderContext->rsNode_->SetAlphaOffscreen(isOffScreenVal);
1177 EXPECT_EQ(isOffScreen, isOffScreenVal);
1178 }
1179
1180 /**
1181 * @tc.name: RosenRenderContextTest046
1182 * @tc.desc: Test SetRenderFit Func and GetRenderFit Func.
1183 * @tc.type: FUNC
1184 */
1185 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest046, TestSize.Level1)
1186 {
1187 auto frameNode =
__anon099ef3ef2902() 1188 FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1189 ASSERT_NE(frameNode, nullptr);
1190 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1191 ASSERT_NE(rosenRenderContext, nullptr);
1192 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1193 rosenRenderContext->SetRenderFit(RenderFit::CENTER);
1194 auto renderFit = rosenRenderContext->GetRenderFit();
1195 ASSERT_NE(renderFit, std::nullopt);
1196 EXPECT_EQ(renderFit.value(), RenderFit::CENTER);
1197 }
1198
1199 /**
1200 * @tc.name: RosenRenderContextTest047
1201 * @tc.desc: Test OnTransformRotateAngleUpdate Func.
1202 * @tc.type: FUNC
1203 */
1204 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest047, TestSize.Level1)
1205 {
__anon099ef3ef2a02() 1206 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1207 ASSERT_NE(frameNode, nullptr);
1208 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1209 ASSERT_NE(rosenRenderContext, nullptr);
1210 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1211 auto rotateX = 40.0f;
1212 auto rotateY = -40.0f;
1213 auto rotateZ = 0.0f;
1214 auto perspective = 120.0f;
1215 auto rotate = 0.0f;
1216 auto rotationXUserModifier = std::make_shared<Rosen::RSAnimatableProperty<float>>(rotate);
1217 auto rotationYUserModifier = std::make_shared<Rosen::RSAnimatableProperty<float>>(rotate);
1218 auto rotationZUserModifier = std::make_shared<Rosen::RSAnimatableProperty<float>>(rotate);
1219 auto cameraDistanceUserModifier = std::make_shared<Rosen::RSAnimatableProperty<float>>(rotate);
1220 rosenRenderContext->rotationXUserModifier_ = std::make_shared<Rosen::ModifierNG::RSTransformModifier>();
1221 rosenRenderContext->rotationXUserModifier_->AttachProperty(
1222 Rosen::ModifierNG::RSPropertyType::ROTATION_X, rotationXUserModifier);
1223 rosenRenderContext->rotationYUserModifier_ = std::make_shared<Rosen::ModifierNG::RSTransformModifier>();
1224 rosenRenderContext->rotationYUserModifier_->AttachProperty(
1225 Rosen::ModifierNG::RSPropertyType::ROTATION_Y, rotationYUserModifier);
1226 rosenRenderContext->rotationZUserModifier_ = std::make_shared<Rosen::ModifierNG::RSTransformModifier>();
1227 rosenRenderContext->rotationZUserModifier_->AttachProperty(
1228 Rosen::ModifierNG::RSPropertyType::ROTATION, rotationZUserModifier);
1229 rosenRenderContext->cameraDistanceUserModifier_ = std::make_shared<Rosen::ModifierNG::RSTransformModifier>();
1230 rosenRenderContext->cameraDistanceUserModifier_->AttachProperty(
1231 Rosen::ModifierNG::RSPropertyType::CAMERA_DISTANCE, cameraDistanceUserModifier);
1232 rosenRenderContext->OnTransformRotateAngleUpdate({ rotateX, rotateY, rotateZ, perspective });
1233 auto rotationXValue = rosenRenderContext->rotationXUserModifier_->GetRotationX();
1234 auto rotationYValue = rosenRenderContext->rotationYUserModifier_->GetRotationY();
1235 auto rotationZValue = rosenRenderContext->rotationZUserModifier_->GetRotation();
1236 auto cameraDistanceValue = rosenRenderContext->cameraDistanceUserModifier_->GetCameraDistance();
1237 EXPECT_EQ(rotationXValue, -rotateX);
1238 EXPECT_EQ(rotationYValue, -rotateY);
1239 EXPECT_EQ(rotationZValue, rotateZ);
1240 EXPECT_EQ(cameraDistanceValue, perspective);
1241 }
1242
1243 /**
1244 * @tc.name: RosenRenderContextTest048
1245 * @tc.desc: Test BlendBgColor Func and ResetBlendBgColor Func.
1246 * @tc.type: FUNC
1247 */
1248 HWTEST_F(RosenRenderContextTest, RosenRenderContextTest048, TestSize.Level1)
1249 {
1250 /**
1251 * @tc.steps: step1. Create node and check basic information.
1252 */
1253 auto frameNode =
__anon099ef3ef2b02() 1254 FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1255 ASSERT_NE(frameNode, nullptr);
1256 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1257 ASSERT_NE(rosenRenderContext, nullptr);
1258 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1259 /**
1260 * @tc.steps: step2. Call the BlendBgColor function and ResetBlendBgColor function.
1261 * @tc.expected: step2. The current colorSpace value on the node should match the original colorSpace value.
1262 */
1263 Color bgColor = Color::RED;
1264 OHOS::Rosen::RSColor rsColor;
1265 rosenRenderContext->OnBackgroundColorUpdate(bgColor);
1266 rosenRenderContext->ColorToRSColor(bgColor, rsColor);
1267 rosenRenderContext->rsNode_->SetBackgroundColor(rsColor);
1268 rosenRenderContext->PaintBackground();
1269 Color blendColor = Color::FromRGB(6, 7, 8);
1270 auto originBackgroundColorVal = rosenRenderContext->rsNode_->GetStagingProperties().GetBackgroundColor();
1271 rosenRenderContext->BlendBgColor(blendColor);
1272 auto backgroundColorVal = rosenRenderContext->rsNode_->GetStagingProperties().GetBackgroundColor();
1273 EXPECT_EQ(backgroundColorVal.GetColorSpace(), originBackgroundColorVal.GetColorSpace());
1274 rosenRenderContext->ResetBlendBgColor();
1275 backgroundColorVal = rosenRenderContext->rsNode_->GetStagingProperties().GetBackgroundColor();
1276 EXPECT_EQ(backgroundColorVal.GetColorSpace(), originBackgroundColorVal.GetColorSpace());
1277 }
1278
1279 /**
1280 * @tc.name: AnimationPropertyTest001
1281 * @tc.desc: Test GetRenderNodePropertyValue func.
1282 * @tc.type: FUNC
1283 */
1284 HWTEST_F(RosenRenderContextTest, AnimationPropertyTest001, TestSize.Level1)
1285 {
1286 /**
1287 * @tc.steps: step1. Create node and check basic infomation.
1288 */
__anon099ef3ef2c02() 1289 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1290 ASSERT_NE(frameNode, nullptr);
1291 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1292 ASSERT_NE(rosenRenderContext, nullptr);
1293 auto rsNode = rosenRenderContext->rsNode_;
1294 ASSERT_NE(rsNode, nullptr);
1295 /**
1296 * @tc.steps: step2. Test GetRenderNodePropertyValue function without setting value.
1297 * @tc.expected: step2. property value on node is default value.
1298 */
1299 auto rotationValue = rosenRenderContext->GetRenderNodePropertyValue(AnimationPropertyType::ROTATION);
1300 std::vector<float> expectedRotationValue = { 0.0f, 0.0f, 0.0f };
1301 EXPECT_TRUE(CompareVector(rotationValue, expectedRotationValue));
1302 auto scaleValue = rosenRenderContext->GetRenderNodePropertyValue(AnimationPropertyType::SCALE);
1303 std::vector<float> expectedScaleValue = { 1.0f, 1.0f };
1304 EXPECT_TRUE(CompareVector(scaleValue, expectedScaleValue));
1305 auto translateValue = rosenRenderContext->GetRenderNodePropertyValue(AnimationPropertyType::TRANSLATION);
1306 std::vector<float> expectedTranslateValue = { 0.0f, 0.0f };
1307 EXPECT_TRUE(CompareVector(translateValue, expectedTranslateValue));
1308 auto opacityValue = rosenRenderContext->GetRenderNodePropertyValue(AnimationPropertyType::OPACITY);
1309 std::vector<float> expectedOpacityValue = { 1.0f };
1310 EXPECT_TRUE(CompareVector(opacityValue, expectedOpacityValue));
1311 }
1312
1313 /**
1314 * @tc.name: AnimationPropertyTest002
1315 * @tc.desc: Test SetAnimationPropertyValue and GetRenderNodePropertyValue func.
1316 * @tc.type: FUNC
1317 */
1318 HWTEST_F(RosenRenderContextTest, AnimationPropertyTest002, TestSize.Level1)
1319 {
1320 /**
1321 * @tc.steps: step1. Create node and check basic infomation.
1322 */
__anon099ef3ef2d02() 1323 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1324 ASSERT_NE(frameNode, nullptr);
1325 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1326 ASSERT_NE(rosenRenderContext, nullptr);
1327 auto rsNode = rosenRenderContext->rsNode_;
1328 ASSERT_NE(rsNode, nullptr);
1329 /**
1330 * @tc.steps: step2. call SetAnimationPropertyValue function.
1331 * @tc.expected: step2. The value on rsNode is same with set value.
1332 */
1333 std::vector<float> rotationValue { 45.0f, -30.0f, 180.0f };
1334 rosenRenderContext->SetAnimationPropertyValue(AnimationPropertyType::ROTATION, rotationValue);
1335 std::vector<float> scaleValue { 2.0f, 1.2f };
1336 rosenRenderContext->SetAnimationPropertyValue(AnimationPropertyType::SCALE, scaleValue);
1337 std::vector<float> translateValue { 100.0f, -20.0f };
1338 rosenRenderContext->SetAnimationPropertyValue(AnimationPropertyType::TRANSLATION, translateValue);
1339 std::vector<float> opacityValue { 0.5f };
1340 rosenRenderContext->SetAnimationPropertyValue(AnimationPropertyType::OPACITY, opacityValue);
1341 auto nodeRotateValue = rosenRenderContext->GetRenderNodePropertyValue(AnimationPropertyType::ROTATION);
1342 auto nodeScaleValue = rosenRenderContext->GetRenderNodePropertyValue(AnimationPropertyType::SCALE);
1343 auto nodeTranslateValue = rosenRenderContext->GetRenderNodePropertyValue(AnimationPropertyType::TRANSLATION);
1344 auto nodeOpacityValue = rosenRenderContext->GetRenderNodePropertyValue(AnimationPropertyType::OPACITY);
1345 EXPECT_TRUE(CompareVector(nodeRotateValue, rotationValue));
1346 EXPECT_TRUE(CompareVector(nodeScaleValue, scaleValue));
1347 EXPECT_TRUE(CompareVector(nodeTranslateValue, translateValue));
1348 EXPECT_TRUE(CompareVector(nodeOpacityValue, opacityValue));
1349 /**
1350 * @tc.steps: step3. call SyncRSPropertyToRenderContext function.
1351 * @tc.expected: step3. The value on renderContext is same with set value.
1352 */
1353 rosenRenderContext->SyncRSPropertyToRenderContext(AnimationPropertyType::ROTATION);
1354 rosenRenderContext->SyncRSPropertyToRenderContext(AnimationPropertyType::SCALE);
1355 rosenRenderContext->SyncRSPropertyToRenderContext(AnimationPropertyType::TRANSLATION);
1356 rosenRenderContext->SyncRSPropertyToRenderContext(AnimationPropertyType::OPACITY);
1357 ASSERT_TRUE(rosenRenderContext->GetTransformRotateAngle().has_value());
1358 EXPECT_TRUE(NearEqual(rotationValue[2], rosenRenderContext->GetTransformRotateAngle()->z));
1359 ASSERT_TRUE(rosenRenderContext->GetTransformScale().has_value());
1360 EXPECT_TRUE(NearEqual(scaleValue[0], rosenRenderContext->GetTransformScale()->x));
1361 ASSERT_TRUE(rosenRenderContext->GetTransformTranslate().has_value());
1362 ASSERT_TRUE(rosenRenderContext->GetOpacity().has_value());
1363 EXPECT_TRUE(NearEqual(opacityValue[0], rosenRenderContext->GetOpacity().value()));
1364 }
1365
1366 /**
1367 * @tc.name: UpdateTransformTranslate001
1368 * @tc.desc: Test UpdateTransformTranslate Func.
1369 * @tc.type: FUNC
1370 */
1371 HWTEST_F(RosenRenderContextTest, UpdateTransformTranslate001, TestSize.Level1)
1372 {
1373 /**
1374 * @tc.steps: step1. Create node and check basic infomation.
1375 */
__anon099ef3ef2e02() 1376 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1377 ASSERT_NE(frameNode, nullptr);
1378 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1379 ASSERT_NE(rosenRenderContext, nullptr);
1380 auto rsNode = rosenRenderContext->rsNode_;
1381 ASSERT_NE(rsNode, nullptr);
1382 /**
1383 * @tc.steps: step2. Set a TranslateOptions value whose unit is px.
1384 * @tc.expected: step2. Translate value in RSNode is correct.
1385 */
1386 constexpr float translateX = 30.0f;
1387 constexpr float translateY = -10.0f;
1388 constexpr float translateZ = 3.0f;
1389 Rosen::Vector2f translateRS;
1390 float translateZRS = 0.0f;
1391 TranslateOptions options { Dimension(translateX), Dimension(translateY), Dimension(translateZ) };
1392 rosenRenderContext->UpdateTransformTranslate(options);
1393 translateRS = rsNode->GetStagingProperties().GetTranslate();
1394 translateZRS = rsNode->GetStagingProperties().GetTranslateZ();
1395 EXPECT_TRUE(NearEqual(translateRS[0], translateX));
1396 EXPECT_TRUE(NearEqual(translateRS[1], translateY));
1397 EXPECT_TRUE(NearEqual(translateRS[2], translateZ));
1398 /**
1399 * @tc.steps: step3. Set a TranslateOptions value whose unit is percent. The node need have size.
1400 * @tc.expected: step3. Translate value in RSNode is correct.
1401 */
1402 constexpr float width = 200.0f;
1403 constexpr float height = 100.0f;
1404 constexpr float translateXPercent1 = 0.1f;
1405 constexpr float translateYPercent1 = 0.0f;
1406 RectF frame { 0, 0, width, height };
1407 rosenRenderContext->UpdatePaintRect(frame);
1408 rosenRenderContext->SyncGeometryProperties(frame);
1409 TranslateOptions options1 { Dimension(translateXPercent1, DimensionUnit::PERCENT),
1410 Dimension(translateYPercent1, DimensionUnit::PERCENT), Dimension(translateZ) };
1411 rosenRenderContext->UpdateTransformTranslate(options1);
1412 translateRS = rsNode->GetStagingProperties().GetTranslate();
1413 EXPECT_TRUE(NearEqual(translateRS[0], translateXPercent1 * width));
1414 EXPECT_TRUE(NearEqual(translateRS[1], translateYPercent1 * height));
1415 }
1416
1417 /**
1418 * @tc.name: UpdateTransformRotate001
1419 * @tc.desc: Test UpdateTransformRotate Func.
1420 * @tc.type: FUNC
1421 */
1422 HWTEST_F(RosenRenderContextTest, UpdateTransformRotate001, TestSize.Level1)
1423 {
1424 /**
1425 * @tc.steps: step1. Create node and check basic infomation.
1426 */
__anon099ef3ef2f02() 1427 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1428 ASSERT_NE(frameNode, nullptr);
1429 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1430 ASSERT_NE(rosenRenderContext, nullptr);
1431 auto rsNode = rosenRenderContext->rsNode_;
1432 ASSERT_NE(rsNode, nullptr);
1433 constexpr float angle = 90.0f;
1434 constexpr float angleZero = 0.0f;
1435 /**
1436 * @tc.steps: step2. Set rotationX.
1437 * @tc.expected: step2. RotationX value in RSNode is correct.
1438 */
1439 Vector5F vecX { 1.0f, 0.0f, 0.0f, angle, 0.0f };
1440 rosenRenderContext->UpdateTransformRotate(vecX);
1441 // ignore the sign
1442 EXPECT_TRUE(NearEqual(std::abs(rsNode->GetStagingProperties().GetRotationX()), angle));
1443 EXPECT_TRUE(NearEqual(rsNode->GetStagingProperties().GetRotationY(), angleZero));
1444 EXPECT_TRUE(NearEqual(rsNode->GetStagingProperties().GetRotation(), angleZero));
1445 /**
1446 * @tc.steps: step3. Set rotationY.
1447 * @tc.expected: step3. RotationY value in RSNode is correct.
1448 */
1449 Vector5F vecY { 0.0f, 1.0f, 0.0f, angle, 0.0f };
1450 rosenRenderContext->UpdateTransformRotate(vecY);
1451 EXPECT_TRUE(NearEqual(rsNode->GetStagingProperties().GetRotationX(), angleZero));
1452 EXPECT_TRUE(NearEqual(std::abs(rsNode->GetStagingProperties().GetRotationY()), angle));
1453 EXPECT_TRUE(NearEqual(rsNode->GetStagingProperties().GetRotation(), angleZero));
1454 /**
1455 * @tc.steps: step4. Set rotationZ.
1456 * @tc.expected: step4. RotationZ value in RSNode is correct.
1457 */
1458 Vector5F vecZ { 0.0f, 0.0f, 1.0f, angle, 0.0f };
1459 rosenRenderContext->UpdateTransformRotate(vecZ);
1460 EXPECT_TRUE(NearEqual(rsNode->GetStagingProperties().GetRotationX(), angleZero));
1461 EXPECT_TRUE(NearEqual(rsNode->GetStagingProperties().GetRotationY(), angleZero));
1462 EXPECT_TRUE(NearEqual(std::abs(rsNode->GetStagingProperties().GetRotation()), angle));
1463 }
1464
1465 /**
1466 * @tc.name: UpdateTransformScale001
1467 * @tc.desc: Test UpdateTransformScale Func.
1468 * @tc.type: FUNC
1469 */
1470 HWTEST_F(RosenRenderContextTest, UpdateTransformScale001, TestSize.Level1)
1471 {
1472 /**
1473 * @tc.steps: step1. Create node and check basic infomation.
1474 */
__anon099ef3ef3002() 1475 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1476 ASSERT_NE(frameNode, nullptr);
1477 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1478 ASSERT_NE(rosenRenderContext, nullptr);
1479 auto rsNode = rosenRenderContext->rsNode_;
1480 ASSERT_NE(rsNode, nullptr);
1481 constexpr float scale1 = 2.0f;
1482 constexpr float scale2 = -2.0f;
1483 Rosen::Vector2f rsScale;
1484 /**
1485 * @tc.steps: step2. Set positive scale.
1486 * @tc.expected: step2. Scale value in RSNode is correct.
1487 */
1488 VectorF vecScale1 { scale1, scale1 };
1489 rosenRenderContext->UpdateTransformScale(vecScale1);
1490 rsScale = rsNode->GetStagingProperties().GetScale();
1491 EXPECT_TRUE(NearEqual(rsScale[0], scale1));
1492 EXPECT_TRUE(NearEqual(rsScale[1], scale1));
1493 /**
1494 * @tc.steps: step3. Set negative scale.
1495 * @tc.expected: step3. Scale value in RSNode is correct.
1496 */
1497 VectorF vecScale2 { scale2, scale2 };
1498 rosenRenderContext->UpdateTransformScale(vecScale2);
1499 rsScale = rsNode->GetStagingProperties().GetScale();
1500 EXPECT_TRUE(NearEqual(rsScale[0], scale2));
1501 EXPECT_TRUE(NearEqual(rsScale[1], scale2));
1502 }
1503
1504 /**
1505 * @tc.name: SetAlwaysSnapshot001
1506 * @tc.desc: Test SetAlwaysSnapshot Func.
1507 * @tc.type: FUNC
1508 */
1509 HWTEST_F(RosenRenderContextTest, SetAlwaysSnapshot001, TestSize.Level1)
1510 {
1511 auto frameNode =
__anon099ef3ef3102() 1512 FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1513 ASSERT_NE(frameNode, nullptr);
1514 RefPtr<RosenRenderContext> rosenRenderContext =
1515 InitRosenRenderContext(frameNode, RenderContext::ContextType::EFFECT);
1516 ASSERT_NE(rosenRenderContext, nullptr);
1517 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1518
1519 /**
1520 * @tc.steps: step1. Get default value.
1521 * @tc.expected: step1. Default value is false.
1522 */
1523 EXPECT_EQ(rosenRenderContext->rsNode_->GetStagingProperties().GetAlwaysSnapshot(), false);
1524
1525 /**
1526 * @tc.steps: step2. Set value to rsNode_ which context type is EFFECT.
1527 * @tc.expected: step2. Value can be set correctly.
1528 */
1529 rosenRenderContext->SetAlwaysSnapshot(true);
1530 EXPECT_EQ(rosenRenderContext->rsNode_->GetStagingProperties().GetAlwaysSnapshot(), true);
1531
1532 /**
1533 * @tc.steps: step3. Set value to rsNode_ which context type is not EFFECT.
1534 * @tc.expected: step3. Value is always false.
1535 */
1536 rosenRenderContext = InitRosenRenderContext(frameNode);
1537 ASSERT_NE(rosenRenderContext, nullptr);
1538 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1539 rosenRenderContext->SetAlwaysSnapshot(true);
1540 EXPECT_EQ(rosenRenderContext->rsNode_->GetStagingProperties().GetAlwaysSnapshot(), false);
1541 }
1542
1543 /**
1544 * @tc.name: GetWithRange001
1545 * @tc.desc: Test GetWithRange Func.
1546 * @tc.type: FUNC
1547 */
1548 HWTEST_F(RosenRenderContextTest, GetWithRange001, TestSize.Level1)
1549 {
1550 /**
1551 * @tc.steps: step1.Mock data.
1552 */
1553 NodeIdentity startID;
1554 NodeIdentity endID;
1555 startID.first = "test1";
1556 endID.first = "test2";
1557 bool isStartRect = true;
1558 int32_t errorCode = 0;
1559 ComponentSnapshot::JsCallback callback = [&](std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode,
__anon099ef3ef3202(std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode, std::function<void()> finishCallback) 1560 std::function<void()> finishCallback) {
1561 errorCode = errCode;
1562 };
1563 SnapshotOptions options{};
1564
1565 /**
1566 * @tc.steps: step2. Call ComponentSnapshot::GetWithRange.
1567 * @tc.expected: Check error code.
1568 */
1569 ComponentSnapshot snapshot;
1570 snapshot.GetWithRange(startID, endID, isStartRect, std::move(callback), options);
1571 ASSERT_NE(callback, nullptr);
1572 EXPECT_EQ(errorCode, ERROR_CODE_INTERNAL_ERROR);
1573 }
1574
1575 /**
1576 * @tc.name: GetWithRange002
1577 * @tc.desc: Test GetWithRange Func.
1578 * @tc.type: FUNC
1579 */
1580 HWTEST_F(RosenRenderContextTest, GetWithRange002, TestSize.Level1)
1581 {
1582 /**
1583 * @tc.steps: step1.Mock data.
1584 */
1585 NodeIdentity startID;
1586 NodeIdentity endID;
1587 startID.second = 0;
1588 endID.second = 0;
1589 bool isStartRect = true;
1590 int32_t errorCode = 0;
1591 ComponentSnapshot::JsCallback callback = [&](std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode,
__anon099ef3ef3302(std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode, std::function<void()> finishCallback) 1592 std::function<void()> finishCallback) {
1593 errorCode = errCode;
1594 };
1595 SnapshotOptions options{};
1596
1597 /**
1598 * @tc.steps: step2. Call ComponentSnapshot::GetWithRange.
1599 * @tc.expected: Check error code.
1600 */
1601 ComponentSnapshot snapshot;
1602 snapshot.GetWithRange(startID, endID, isStartRect, std::move(callback), options);
1603 ASSERT_NE(callback, nullptr);
1604 EXPECT_EQ(errorCode, ERROR_CODE_INTERNAL_ERROR);
1605 }
1606
1607 /**
1608 * @tc.name: GetWithRange003
1609 * @tc.desc: Test GetWithRange Func.
1610 * @tc.type: FUNC
1611 */
1612 HWTEST_F(RosenRenderContextTest, GetWithRange003, TestSize.Level1)
1613 {
1614 /**
1615 * @tc.steps: step1.Mock data.
1616 */
1617 NodeIdentity startID;
1618 NodeIdentity endID;
1619 startID.first = "test";
1620 endID.second = 0;
1621 bool isStartRect = true;
1622 int32_t errorCode = 0;
1623 ComponentSnapshot::JsCallback callback = [&](std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode,
__anon099ef3ef3402(std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode, std::function<void()> finishCallback) 1624 std::function<void()> finishCallback) {
1625 errorCode = errCode;
1626 };
1627 SnapshotOptions options{};
1628
1629 /**
1630 * @tc.steps: step2. Call ComponentSnapshot::GetWithRange.
1631 * @tc.expected: Check error code.
1632 */
1633 ComponentSnapshot snapshot;
1634 snapshot.GetWithRange(startID, endID, isStartRect, std::move(callback), options);
1635 ASSERT_NE(callback, nullptr);
1636 EXPECT_EQ(errorCode, ERROR_CODE_INTERNAL_ERROR);
1637 }
1638
1639 /**
1640 * @tc.name: GetWithRange004
1641 * @tc.desc: Test GetWithRange Func.
1642 * @tc.type: FUNC
1643 */
1644 HWTEST_F(RosenRenderContextTest, GetWithRange004, TestSize.Level1)
1645 {
1646 /**
1647 * @tc.steps: step1.Mock data.
1648 */
1649 NodeIdentity startID;
1650 NodeIdentity endID;
1651 startID.second = 0;
1652 endID.first = "test";
1653 bool isStartRect = true;
1654 int32_t errorCode = 0;
1655 ComponentSnapshot::JsCallback callback = [&](std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode,
__anon099ef3ef3502(std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode, std::function<void()> finishCallback) 1656 std::function<void()> finishCallback) {
1657 errorCode = errCode;
1658 };
1659 SnapshotOptions options{};
1660
1661 /**
1662 * @tc.steps: step2. Call ComponentSnapshot::GetWithRange.
1663 * @tc.expected: Check error code.
1664 */
1665 ComponentSnapshot snapshot;
1666 snapshot.GetWithRange(startID, endID, isStartRect, std::move(callback), options);
1667 ASSERT_NE(callback, nullptr);
1668 EXPECT_EQ(errorCode, ERROR_CODE_INTERNAL_ERROR);
1669 }
1670
1671 /**
1672 * @tc.name: GetWithRange005
1673 * @tc.desc: Test GetWithRange Func.
1674 * @tc.type: FUNC
1675 */
1676 HWTEST_F(RosenRenderContextTest, GetWithRange005, TestSize.Level1)
1677 {
1678 /**
1679 * @tc.steps: step1.Mock data.
1680 */
1681 NodeIdentity startID;
1682 NodeIdentity endID;
1683 startID.first = "test1";
1684 startID.second = 0;
1685 endID.first = "test2";
1686 endID.second = 0;
1687 bool isStartRect = true;
1688 int32_t errorCode = 0;
1689 ComponentSnapshot::JsCallback callback = [&](std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode,
__anon099ef3ef3602(std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode, std::function<void()> finishCallback) 1690 std::function<void()> finishCallback) {
1691 errorCode = errCode;
1692 };
1693 SnapshotOptions options{};
1694
1695 /**
1696 * @tc.steps: step2. Call ComponentSnapshot::GetWithRange.
1697 * @tc.expected: Check error code.
1698 */
1699 ComponentSnapshot snapshot;
1700 snapshot.GetWithRange(startID, endID, isStartRect, std::move(callback), options);
1701 ASSERT_NE(callback, nullptr);
1702 EXPECT_EQ(errorCode, ERROR_CODE_INTERNAL_ERROR);
1703 }
1704
1705 /**
1706 * @tc.name: GetWithRange006
1707 * @tc.desc: Test GetWithRange Func.
1708 * @tc.type: FUNC
1709 */
1710 HWTEST_F(RosenRenderContextTest, GetWithRange006, TestSize.Level1)
1711 {
1712 /**
1713 * @tc.steps: step1.Mock data.
1714 */
1715 auto startNode = FrameNode::CreateFrameNode("startNode", -1, AceType::MakeRefPtr<Pattern>());
1716 auto endNode = FrameNode::CreateFrameNode("endNode", -1, AceType::MakeRefPtr<Pattern>());
1717 NodeIdentity startID;
1718 NodeIdentity endID;
1719 bool isStartRect = true;
1720 int32_t errorCode = -1;
1721 ComponentSnapshot::JsCallback callback = [&errorCode](std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode,
__anon099ef3ef3702(std::shared_ptr<Media::PixelMap> pixmap, int32_t errCode, std::function<void()> finishCallback) 1722 std::function<void()> finishCallback) {
1723 errorCode = errCode;
1724 };
1725 SnapshotOptions options{};
1726
1727 /**
1728 * @tc.steps: step2. Call ComponentSnapshot::GetWithRange.
1729 * @tc.expected: Check error code.
1730 */
1731 startID.first = "0";
1732 endID.first = "endNode";
1733 ComponentSnapshot snapshot;
1734 snapshot.GetWithRange(startID, endID, isStartRect, std::move(callback), options);
1735 EXPECT_EQ(errorCode, ERROR_CODE_INTERNAL_ERROR);
1736
1737 errorCode = -1;
1738 startID.first = "startNode";
1739 endID.first = "0";
1740 snapshot.GetWithRange(startID, endID, isStartRect, std::move(callback), options);
1741 EXPECT_EQ(errorCode, ERROR_CODE_INTERNAL_ERROR);
1742 }
1743
1744 /**
1745 * @tc.name: GetRangeIDNode001
1746 * @tc.desc: Test GetRangeIDNode Func.
1747 * @tc.type: FUNC
1748 */
1749 HWTEST_F(RosenRenderContextTest, GetRangeIDNode001, TestSize.Level1)
1750 {
1751 /**
1752 * @tc.steps: step1.Mock data.
1753 */
1754 NodeIdentity startID;
1755 startID.first = "test1";
1756 startID.second = 0;
1757
1758 /**
1759 * @tc.steps: step2. Call ComponentSnapshot::GetRangeIDNode.
1760 * @tc.expected: Check result.
1761 */
1762 ComponentSnapshot snapshot;
1763 auto startNode = snapshot.GetRangeIDNode(startID);
1764 EXPECT_EQ(startNode, nullptr);
1765 }
1766
1767 /**
1768 * @tc.name: GetRangeIDNode002
1769 * @tc.desc: Test GetRangeIDNode Func.
1770 * @tc.type: FUNC
1771 */
1772 HWTEST_F(RosenRenderContextTest, GetRangeIDNode002, TestSize.Level1)
1773 {
1774 /**
1775 * @tc.steps: step1.Mock data.
1776 */
1777 NodeIdentity startID;
1778 startID.first = "";
1779 startID.second = 1;
1780
1781 /**
1782 * @tc.steps: step2. Call ComponentSnapshot::GetRangeIDNode.
1783 * @tc.expected: Check result.
1784 */
1785 ComponentSnapshot snapshot;
1786 auto startNode = snapshot.GetRangeIDNode(startID);
1787 EXPECT_EQ(startNode, nullptr);
1788 }
1789
1790 /**
1791 * @tc.name: GetRangeIDStr001
1792 * @tc.desc: Test GetRangeIDStr Func.
1793 * @tc.type: FUNC
1794 */
1795 HWTEST_F(RosenRenderContextTest, GetRangeIDStr001, TestSize.Level1)
1796 {
1797 /**
1798 * @tc.steps: step1.Mock data.
1799 */
1800 NodeIdentity startID;
1801 startID.first = "test1";
1802 startID.second = 0;
1803
1804 /**
1805 * @tc.steps: step2. Call ComponentSnapshot::GetRangeIDStr.
1806 * @tc.expected: Check result.
1807 */
1808 ComponentSnapshot snapshot;
1809 auto startNode = snapshot.GetRangeIDStr(startID);
1810 EXPECT_EQ(startNode, "test1");
1811 }
1812
1813 /**
1814 * @tc.name: GetRangeIDStr002
1815 * @tc.desc: Test GetRangeIDStr Func.
1816 * @tc.type: FUNC
1817 */
1818 HWTEST_F(RosenRenderContextTest, GetRangeIDStr002, TestSize.Level1)
1819 {
1820 /**
1821 * @tc.steps: step1.Mock data.
1822 */
1823 NodeIdentity startID;
1824 startID.first = "";
1825 startID.second = 1;
1826
1827 /**
1828 * @tc.steps: step2. Call ComponentSnapshot::GetRangeIDStr.
1829 * @tc.expected: Check result.
1830 */
1831 ComponentSnapshot snapshot;
1832 auto startNode = snapshot.GetRangeIDStr(startID);
1833 EXPECT_EQ(startNode, "1");
1834 }
1835
1836 /**
1837 * @tc.name: GetRangeIDStr003
1838 * @tc.desc: Test GetRangeIDStr Func.
1839 * @tc.type: FUNC
1840 */
1841 HWTEST_F(RosenRenderContextTest, GetRangeIDStr003, TestSize.Level1)
1842 {
1843 /**
1844 * @tc.steps: step1.Mock data.
1845 */
1846 NodeIdentity startID;
1847 startID.first = "";
1848 startID.second = 0;
1849
1850 /**
1851 * @tc.steps: step2. Call ComponentSnapshot::GetRangeIDStr.
1852 * @tc.expected: Check result.
1853 */
1854 ComponentSnapshot snapshot;
1855 auto startNode = snapshot.GetRangeIDStr(startID);
1856 EXPECT_EQ(startNode, "0");
1857 }
1858
1859 /**
1860 * @tc.name: CreateBackgroundPixelMap001
1861 * @tc.desc: Test CreateBackgroundPixelMap Func.
1862 * @tc.type: FUNC
1863 */
1864 HWTEST_F(RosenRenderContextTest, CreateBackgroundPixelMap001, TestSize.Level1)
1865 {
__anon099ef3ef3802() 1866 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1867 ASSERT_NE(frameNode, nullptr);
1868 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1869 ASSERT_NE(rosenRenderContext, nullptr);
1870 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1871
1872 /**
1873 * @tc.steps: step1. Call CreateBackgroundPixelMap function.
1874 * @tc.expected: step1. The backgroundTaskId_ can be set correctly.
1875 */
1876 auto backgroundNode =
__anon099ef3ef3902() 1877 FrameNode::GetOrCreateFrameNode("background", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1878 ASSERT_NE(backgroundNode, nullptr);
1879 uint32_t backgroundTaskId = 1;
1880 rosenRenderContext->backgroundTaskId_ = backgroundTaskId;
1881 rosenRenderContext->CreateBackgroundPixelMap(backgroundNode);
1882 EXPECT_EQ(rosenRenderContext->backgroundTaskId_, backgroundTaskId + 1);
1883 }
1884
1885 /**
1886 * @tc.name: OnCustomBackgroundColorUpdate001
1887 * @tc.desc: Test OnCustomBackgroundColorUpdate Func.
1888 * @tc.type: FUNC
1889 */
1890 HWTEST_F(RosenRenderContextTest, OnCustomBackgroundColorUpdate001, TestSize.Level1)
1891 {
__anon099ef3ef3a02() 1892 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1893 ASSERT_NE(frameNode, nullptr);
1894 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1895 ASSERT_NE(rosenRenderContext, nullptr);
1896 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1897 auto transitionModifier = rosenRenderContext->GetOrCreateTransitionModifier();
1898 ASSERT_NE(transitionModifier, nullptr);
1899
1900 /**
1901 * @tc.steps: step1. Set custom background color.
1902 * @tc.expected: step1. Custom background color can be set correctly.
1903 */
1904 Color color = Color::BLUE;
1905 rosenRenderContext->OnCustomBackgroundColorUpdate(color);
1906 EXPECT_EQ(transitionModifier->backgroundColor_.GetValue(), color.GetValue());
1907
1908 /**
1909 * @tc.steps: step2. Set custom background color while rsNode_ is null.
1910 * @tc.expected: step2. Custom background color set failed.
1911 */
1912 rosenRenderContext->rsNode_ = nullptr;
1913 rosenRenderContext->OnCustomBackgroundColorUpdate(Color::GREEN);
1914 EXPECT_EQ(transitionModifier->backgroundColor_.GetValue(), color.GetValue());
1915 }
1916
1917 /**
1918 * @tc.name: OnBuilderBackgroundFlagUpdate001
1919 * @tc.desc: Test OnBuilderBackgroundFlagUpdate Func.
1920 * @tc.type: FUNC
1921 */
1922 HWTEST_F(RosenRenderContextTest, OnBuilderBackgroundFlagUpdate001, TestSize.Level1)
1923 {
__anon099ef3ef3b02() 1924 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1925 ASSERT_NE(frameNode, nullptr);
1926 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1927 ASSERT_NE(rosenRenderContext, nullptr);
1928 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1929 auto transitionModifier = rosenRenderContext->GetOrCreateTransitionModifier();
1930 ASSERT_NE(transitionModifier, nullptr);
1931
1932 /**
1933 * @tc.steps: step1. Set BuilderBackgroundFlag.
1934 * @tc.expected: step1. BuilderBackgroundFlag can be set correctly.
1935 */
1936 rosenRenderContext->OnBuilderBackgroundFlagUpdate(true);
1937 EXPECT_TRUE(transitionModifier->isBuilderBackground_);
1938
1939 /**
1940 * @tc.steps: step2. Set BuilderBackgroundFlag while rsNode_ is null.
1941 * @tc.expected: step2. BuilderBackgroundFlag set failed.
1942 */
1943 rosenRenderContext->rsNode_ = nullptr;
1944 rosenRenderContext->OnBuilderBackgroundFlagUpdate(false);
1945 EXPECT_TRUE(transitionModifier->isBuilderBackground_);
1946 }
1947
1948 /**
1949 * @tc.name: OnBackgroundAlignUpdate001
1950 * @tc.desc: Test OnBackgroundAlignUpdate Func.
1951 * @tc.type: FUNC
1952 */
1953 HWTEST_F(RosenRenderContextTest, OnBackgroundAlignUpdate001, TestSize.Level1)
1954 {
__anon099ef3ef3c02() 1955 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1956 ASSERT_NE(frameNode, nullptr);
1957 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1958 ASSERT_NE(rosenRenderContext, nullptr);
1959 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1960 auto transitionModifier = rosenRenderContext->GetOrCreateTransitionModifier();
1961 ASSERT_NE(transitionModifier, nullptr);
1962 auto backgroundModifier = rosenRenderContext->GetOrCreateBackgroundModifier();
1963 ASSERT_NE(backgroundModifier, nullptr);
1964
1965 /**
1966 * @tc.steps: step1. Set alignment.
1967 * @tc.expected: step1. alignment can be set correctly.
1968 */
1969 Alignment align = Alignment::TOP_CENTER;
1970 rosenRenderContext->OnBackgroundAlignUpdate(align);
1971 EXPECT_EQ(transitionModifier->align_.ToString(), align.ToString());
1972 EXPECT_EQ(backgroundModifier->align_.ToString(), align.ToString());
1973
1974 /**
1975 * @tc.steps: step2. Set alignment while rsNode_ is null.
1976 * @tc.expected: step2. alignment set failed.
1977 */
1978 rosenRenderContext->rsNode_ = nullptr;
1979 rosenRenderContext->OnBackgroundAlignUpdate(Alignment::BOTTOM_RIGHT);
1980 EXPECT_EQ(transitionModifier->align_.ToString(), align.ToString());
1981 EXPECT_EQ(backgroundModifier->align_.ToString(), align.ToString());
1982 }
1983
1984 /**
1985 * @tc.name: OnBackgroundPixelMapUpdate001
1986 * @tc.desc: Test OnBackgroundPixelMapUpdate Func.
1987 * @tc.type: FUNC
1988 */
1989 HWTEST_F(RosenRenderContextTest, OnBackgroundPixelMapUpdate001, TestSize.Level1)
1990 {
1991 const float EXPECT_WIDTH = 100.0f;
1992 const float EXPECT_HEIGHT = 150.0f;
__anon099ef3ef3d02() 1993 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
1994 ASSERT_NE(frameNode, nullptr);
1995 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
1996 ASSERT_NE(rosenRenderContext, nullptr);
1997 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
1998 auto transitionModifier = rosenRenderContext->GetOrCreateTransitionModifier();
1999 ASSERT_NE(transitionModifier, nullptr);
2000 auto backgroundModifier = rosenRenderContext->GetOrCreateBackgroundModifier();
2001 ASSERT_NE(backgroundModifier, nullptr);
2002
2003 /**
2004 * @tc.steps: step1. Set alignment.
2005 * @tc.expected: step1. alignment can be set correctly.
2006 */
2007 RefPtr<PixelMap> pixelMap = AceType::MakeRefPtr<MockPixelMap>();
2008 auto geometryNode = frameNode->GetGeometryNode();
2009 ASSERT_NE(geometryNode, nullptr);
2010 geometryNode->SetFrameSize(SizeF(EXPECT_WIDTH, EXPECT_HEIGHT));
2011 rosenRenderContext->OnBackgroundPixelMapUpdate(pixelMap);
2012 RectF backgroundRegion = frameNode->GetBackGroundAccumulatedSafeAreaExpand();
2013 EXPECT_EQ(transitionModifier->initialBackgroundRegion_.ToString(), backgroundRegion.ToString());
2014 EXPECT_EQ(backgroundModifier->initialNodeWidth_, EXPECT_WIDTH);
2015 EXPECT_EQ(backgroundModifier->initialNodeHeight_, EXPECT_HEIGHT);
2016
2017 /**
2018 * @tc.steps: step2. Set PixelMap while rsNode_ is null.
2019 * @tc.expected: step2. PixelMap set failed.
2020 */
2021 rosenRenderContext->rsNode_ = nullptr;
2022 transitionModifier->pixelMap_ = nullptr;
2023 backgroundModifier->pixelMap_ = nullptr;
2024 rosenRenderContext->OnBackgroundPixelMapUpdate(pixelMap);
2025 EXPECT_EQ(transitionModifier->pixelMap_, nullptr);
2026 EXPECT_EQ(backgroundModifier->pixelMap_, nullptr);
2027 }
2028
2029 /**
2030 * @tc.name: UpdateCustomBackground001
2031 * @tc.desc: Test UpdateCustomBackground Func.
2032 * @tc.type: FUNC
2033 */
2034 HWTEST_F(RosenRenderContextTest, UpdateCustomBackground001, TestSize.Level1)
2035 {
__anon099ef3ef3e02() 2036 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
2037 ASSERT_NE(frameNode, nullptr);
2038 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
2039 ASSERT_NE(rosenRenderContext, nullptr);
2040 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
2041
2042 /**
2043 * @tc.steps: step1. Create transition modifier and get the modifier flag.
2044 * @tc.expected: step1. Creation successful.
2045 */
2046 rosenRenderContext->UpdateIsTransitionBackground(true);
2047 auto transitionModifier = rosenRenderContext->GetOrCreateTransitionModifier();
2048 ASSERT_NE(transitionModifier, nullptr);
2049 transitionModifier->Modify();
2050 ASSERT_NE(transitionModifier->flag_, nullptr);
2051 bool flag = transitionModifier->flag_->Get();
2052
2053 /**
2054 * @tc.steps: step2. Call UpdateCustomBackground function.
2055 * @tc.expected: step2. The modifier flag is changed.
2056 */
2057 rosenRenderContext->UpdateCustomBackground();
2058 EXPECT_NE(transitionModifier->flag_->Get(), flag);
2059 }
2060
2061 /**
2062 * @tc.name: OnTransform3DMatrixUpdate001
2063 * @tc.desc: Test OnTransform3DMatrixUpdate Func.
2064 * @tc.type: FUNC
2065 */
2066 HWTEST_F(RosenRenderContextTest, OnTransform3DMatrixUpdate001, TestSize.Level1)
2067 {
__anon099ef3ef3f02() 2068 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
2069 ASSERT_NE(frameNode, nullptr);
2070 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
2071 ASSERT_NE(rosenRenderContext, nullptr);
2072 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
2073 float INDEX_0 = 0.0f;
2074 float INDEX_1 = 1.0f;
2075 float INDEX_100 = 100.0f;
2076 Matrix4 matrix4(INDEX_1, INDEX_0, INDEX_0, INDEX_0, INDEX_0, INDEX_1, INDEX_0, INDEX_0, INDEX_0, INDEX_0, INDEX_1,
2077 INDEX_0, INDEX_100, INDEX_0, INDEX_0, INDEX_1);
2078 rosenRenderContext->OnTransform3DMatrixUpdate(matrix4);
2079 auto perspectiveValue = rosenRenderContext->transformModifier_->GetPersp();
2080 auto xyTranslateValue = rosenRenderContext->transformModifier_->GetTranslate();
2081 auto translateZValue = rosenRenderContext->transformModifier_->GetTranslateZ();
2082 auto scaleXYValue = rosenRenderContext->transformModifier_->GetScale();
2083 auto scaleZValue = rosenRenderContext->transformModifier_->GetScaleZ();
2084 auto skewValue = rosenRenderContext->transformModifier_->GetSkew();
2085 auto quaternionValue = rosenRenderContext->transformModifier_->GetQuaternion();
2086 EXPECT_NE(perspectiveValue[0], 0);
2087 EXPECT_EQ(perspectiveValue[1], 0);
2088 EXPECT_EQ(perspectiveValue[2], 0);
2089 EXPECT_NE(perspectiveValue[3], 0);
2090 EXPECT_EQ(xyTranslateValue[0], 0);
2091 EXPECT_EQ(perspectiveValue[1], 0);
2092 EXPECT_EQ(translateZValue, 0);
2093 EXPECT_NE(scaleXYValue[0], 0);
2094 EXPECT_NE(scaleXYValue[1], 0);
2095 EXPECT_NE(scaleZValue, 0);
2096 EXPECT_EQ(skewValue[0], 0);
2097 EXPECT_EQ(skewValue[1], 0);
2098 EXPECT_EQ(skewValue[2], 0);
2099 EXPECT_EQ(quaternionValue[0], 0);
2100 EXPECT_EQ(quaternionValue[1], 0);
2101 EXPECT_EQ(quaternionValue[2], 0);
2102 EXPECT_NE(quaternionValue[3], 0);
2103 }
2104
2105 /**
2106 * @tc.name: ClearModifiers001
2107 * @tc.desc: Test cast to RosenRenderContextTest
2108 * @tc.type: FUNC
2109 */
2110 HWTEST_F(RosenRenderContextTest, ClearModifiers001, TestSize.Level1)
2111 {
2112 /**
2113 * @tc.steps: step1. Build a object renderContext.
2114 */
__anon099ef3ef4002() 2115 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
2116 ASSERT_NE(frameNode, nullptr);
2117 RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
2118 ASSERT_NE(rosenRenderContext, nullptr);
2119 auto rsNode = rosenRenderContext->rsNode_;
2120 ASSERT_NE(rsNode, nullptr);
2121
2122 /**
2123 * @tc.steps: step2. set rotateZ is 90.
2124 * @tc.expected: GetRotation is 90.
2125 */
2126 auto angle = 90;
2127 rosenRenderContext->SetRotation(0, 0, angle);
2128 auto rotateZ = rsNode->GetStagingProperties().GetRotation();
2129 EXPECT_EQ(rotateZ, angle);
2130
2131 /**
2132 * @tc.steps: step3. ClearModifiers.
2133 * @tc.expected: GetRotation is default value.
2134 */
2135 rosenRenderContext->ClearModifiers();
2136 rotateZ = rsNode->GetStagingProperties().GetRotation();
2137 EXPECT_EQ(rotateZ, 0);
2138 }
2139
2140 /**
2141 * @tc.name: GetBitmapTest001
2142 * @tc.desc: Test RosenRenderContext GetBitmap with rsNode_ is nullptr
2143 * @tc.type: FUNC
2144 * @tc.require: issueICK0X0
2145 */
2146 HWTEST_F(RosenRenderContextTest, GetBitmapTest001, TestSize.Level1)
2147 {
2148 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
2149 RenderContext::ContextParam contextParam;
2150 contextParam.type = RenderContext::ContextType::CANVAS;
2151 contextParam.surfaceName.emplace("test");
2152
2153 rosenRenderContext->rsNode_ = nullptr;
2154 RSBitmap bitmap;
2155 bool ret = rosenRenderContext->GetBitmap(bitmap, nullptr);
2156 EXPECT_EQ(ret, false);
2157 }
2158
2159 /**
2160 * @tc.name: GetBitmapTest002
2161 * @tc.desc: Test RosenRenderContext GetBitmap with rsNode_ is not nullptr
2162 * @tc.type: FUNC
2163 * @tc.require: issueICK0X0
2164 */
2165 HWTEST_F(RosenRenderContextTest, GetBitmapTest002, TestSize.Level1)
2166 {
2167 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
2168 RenderContext::ContextParam contextParam;
2169 contextParam.type = RenderContext::ContextType::CANVAS;
2170 contextParam.surfaceName.emplace("test");
2171 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
2172 rosenRenderContext->InitContext(true, contextParamValue);
2173 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
2174
2175 RSBitmap bitmap;
2176 bool ret = rosenRenderContext->GetBitmap(bitmap, nullptr);
2177 EXPECT_EQ(ret, false);
2178 }
2179
2180 /**
2181 * @tc.name: GetPixelMapTest001
2182 * @tc.desc: Test RosenRenderContext GetPixelMap with rsNode_ is nullptr
2183 * @tc.type: FUNC
2184 * @tc.require: issueICK0X0
2185 */
2186 HWTEST_F(RosenRenderContextTest, GetPixelMapTest001, TestSize.Level1)
2187 {
2188 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
2189 RenderContext::ContextParam contextParam;
2190 contextParam.type = RenderContext::ContextType::CANVAS;
2191 contextParam.surfaceName.emplace("test");
2192
2193 rosenRenderContext->rsNode_ = nullptr;
2194 RSBitmap bitmap;
2195 bool ret = rosenRenderContext->GetPixelMap(nullptr, nullptr, nullptr);
2196 EXPECT_EQ(ret, false);
2197 }
2198
2199 /**
2200 * @tc.name: GetPixelMapTest002
2201 * @tc.desc: Test RosenRenderContext GetPixelMap with rsNode_ is not nullptr
2202 * @tc.type: FUNC
2203 * @tc.require: issueICK0X0
2204 */
2205 HWTEST_F(RosenRenderContextTest, GetPixelMapTest002, TestSize.Level1)
2206 {
2207 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
2208 RenderContext::ContextParam contextParam;
2209 contextParam.type = RenderContext::ContextType::CANVAS;
2210 contextParam.surfaceName.emplace("test");
2211 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
2212 rosenRenderContext->InitContext(true, contextParamValue);
2213 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
2214
2215 RSBitmap bitmap;
2216 bool ret = rosenRenderContext->GetPixelMap(nullptr, nullptr, nullptr);
2217 EXPECT_EQ(ret, false);
2218 }
2219
2220 /**
2221 * @tc.name: RemoveFromTreeTest001
2222 * @tc.desc: Test RosenRenderContext RemoveFromTree
2223 * @tc.type: FUNC
2224 */
2225 HWTEST_F(RosenRenderContextTest, RemoveFromTreeTest001, TestSize.Level1)
2226 {
2227 /**
2228 * @tc.steps: step1. construct a rosenRenderContext
2229 */
2230 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
2231 ASSERT_NE(rosenRenderContext, nullptr);
2232 ASSERT_EQ(rosenRenderContext->rsNode_, nullptr);
2233
2234 /**
2235 * @tc.steps: step2. test RemoveFromTree function
2236 */
2237 rosenRenderContext->RemoveFromTree();
2238 ASSERT_EQ(rosenRenderContext->rsNode_, nullptr);
2239 }
2240
2241 /**
2242 * @tc.name: RemoveFromTreeTest002
2243 * @tc.desc: Test RosenRenderContext RemoveFromTree
2244 * @tc.type: FUNC
2245 */
2246 HWTEST_F(RosenRenderContextTest, RemoveFromTreeTest002, TestSize.Level1)
2247 {
2248 /**
2249 * @tc.steps: step1. construct a RemoveFromTree
2250 */
2251 auto rosenRenderContext = AceType::MakeRefPtr<RosenRenderContext>();
2252 RenderContext::ContextParam contextParam;
2253 contextParam.type = RenderContext::ContextType::CANVAS;
2254 contextParam.surfaceName.emplace("test");
2255 std::optional<RenderContext::ContextParam> contextParamValue = std::make_optional(contextParam);
2256 rosenRenderContext->InitContext(true, contextParamValue);
2257 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
2258
2259 /**
2260 * @tc.steps: step2. test RemoveFromTree function
2261 */
2262 rosenRenderContext->RemoveFromTree();
2263 EXPECT_EQ(rosenRenderContext->rsNode_ != nullptr, true);
2264 EXPECT_EQ(rosenRenderContext->rsNode_->isOnTheTreeInit_, true);
2265 EXPECT_EQ(rosenRenderContext->rsNode_->isOnTheTree_, false);
2266 }
2267
2268 class MockRosenRenderContext : public RosenRenderContext {
2269 public:
2270 MOCK_METHOD1(SetNeedUseCmdlistDrawRegion, void(bool needUseCmdlistDrawRegion));
2271 };
2272
2273 /**
2274 * @tc.name: SetNeedUseCmdlistDrawRegion001
2275 * @tc.desc: Test RosenRenderContext SetNeedUseCmdlistDrawRegion
2276 * @tc.type: FUNC
2277 */
2278 HWTEST_F(RosenRenderContextTest, SetNeedUseCmdlistDrawRegion001, TestSize.Level1)
2279 {
2280 auto mockRosenRenderContext = AceType::MakeRefPtr<MockRosenRenderContext>();
2281 EXPECT_CALL(*mockRosenRenderContext, SetNeedUseCmdlistDrawRegion(_)).Times(2);
2282 mockRosenRenderContext->SetNeedUseCmdlistDrawRegion(true);
2283 mockRosenRenderContext->SetNeedUseCmdlistDrawRegion(false);
2284 }
2285
2286 /**
2287 * @tc.name: ShouldSkipAffineTransformation001
2288 * @tc.desc: Test ShouldSkipAffineTransformation Func.
2289 * @tc.type: FUNC
2290 */
2291 HWTEST_F(RosenRenderContextTest, ShouldSkipAffineTransformation001, TestSize.Level1)
2292 {
__anon099ef3ef4102() 2293 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
2294 ASSERT_NE(frameNode, nullptr);
2295 RefPtr rosenRenderContext = InitRosenRenderContext(frameNode);
2296 ASSERT_NE(rosenRenderContext, nullptr);
2297 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
2298 rosenRenderContext->rsNode_->SetDrawNodeType(Rosen::DrawNodeType::DrawPropertyType);
2299 bool res = rosenRenderContext->ShouldSkipAffineTransformation(rosenRenderContext->rsNode_);
2300 rosenRenderContext->rsNode_->SetDrawNodeType(Rosen::DrawNodeType::GeometryPropertyType);
2301 res = rosenRenderContext->ShouldSkipAffineTransformation(rosenRenderContext->rsNode_);
2302 ASSERT_EQ(res, false);
2303 rosenRenderContext->rsNode_ = nullptr;
2304 ASSERT_EQ(rosenRenderContext->rsNode_, nullptr);
2305 }
2306
2307 /**
2308 * @tc.name: ShouldSkipAffineTransformation002
2309 * @tc.desc: Test ShouldSkipAffineTransformation Func.
2310 * @tc.type: FUNC
2311 */
2312 HWTEST_F(RosenRenderContextTest, ShouldSkipAffineTransformation002, TestSize.Level1)
2313 {
__anon099ef3ef4202() 2314 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
2315 ASSERT_NE(frameNode, nullptr);
2316 RefPtr rosenRenderContext = InitRosenRenderContext(frameNode);
2317 ASSERT_NE(rosenRenderContext, nullptr);
2318 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
2319 rosenRenderContext->paintRect_ = RectT<float>(1.0f, 1.0f, -1.0f, 1.0f);
2320 rosenRenderContext->GetPaintRectWithTransform();
2321 rosenRenderContext->GetPaintRectWithTransformWithoutDegree();
2322 ASSERT_EQ(rosenRenderContext->paintRect_, RectT<float>(1.0f, 1.0f, -1.0f, 1.0f));
2323 rosenRenderContext->paintRect_ = RectT<float>(1.0f, 1.0f, 1.0f, -1.0f);
2324 rosenRenderContext->GetPaintRectWithTransform();
2325 rosenRenderContext->GetPaintRectWithTransformWithoutDegree();
2326 ASSERT_EQ(rosenRenderContext->paintRect_, RectT<float>(1.0f, 1.0f, 1.0f, -1.0f));
2327 rosenRenderContext->paintRect_ = RectT<float>(1.0f, 1.0f, 1.0f, 1.0f);
2328 rosenRenderContext->GetPaintRectWithTransform();
2329 rosenRenderContext->GetPaintRectWithTransformWithoutDegree();
2330 ASSERT_EQ(rosenRenderContext->paintRect_, RectT<float>(1.0f, 1.0f, 1.0f, 1.0f));
2331 rosenRenderContext->rsNode_ = nullptr;
2332 ASSERT_EQ(rosenRenderContext->rsNode_, nullptr);
2333 }
2334
2335 /**
2336 * @tc.name: RSUIContext001
2337 * @tc.desc: Test RSUIContext001 Func.
2338 * @tc.type: FUNC
2339 */
2340 HWTEST_F(RosenRenderContextTest, RSUIContext001, TestSize.Level1)
2341 {
__anon099ef3ef4302() 2342 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
2343 ASSERT_NE(frameNode, nullptr);
2344 ComponentSnapshot snapshot;
2345 snapshot.SetRSUIContext(frameNode, nullptr);
2346 auto pipeline = MockPipelineContext::GetCurrentContext();
2347 auto rsUIContext = snapshot.GetRSUIContext(pipeline);
2348 EXPECT_EQ(rsUIContext, nullptr);
2349 }
2350
2351 /**
2352 * @tc.name: OnZindexUpdate001
2353 * @tc.desc: Test OnZindexUpdate Func.
2354 * @tc.type: FUNC
2355 */
2356 HWTEST_F(RosenRenderContextTest, OnZindexUpdate001, TestSize.Level1)
2357 {
__anon099ef3ef4402() 2358 auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
2359 ASSERT_NE(frameNode, nullptr);
2360 RefPtr rosenRenderContext = InitRosenRenderContext(frameNode);
2361 ASSERT_NE(rosenRenderContext, nullptr);
2362 ASSERT_NE(rosenRenderContext->rsNode_, nullptr);
2363
2364 /**
2365 * @tc.steps: step1. Set zIndex.
2366 * @tc.expected: step1. zIndex set success.
2367 */
2368 rosenRenderContext->OnZIndexUpdate(2);
2369 auto rsNdoe = rosenRenderContext->GetRSNode();
2370 auto stagingProperties = rsNdoe->GetStagingProperties();
2371 auto positionZ = stagingProperties.GetPositionZ();
2372 EXPECT_EQ(positionZ, 2);
2373
2374 /**
2375 * @tc.steps: step2. Set Layouting and zIndex.
2376 * @tc.expected: step2. zIndex set success.
2377 */
2378 auto pipeline = MockPipelineContext::GetCurrentContext();
2379 pipeline->SetIsLayouting(true);
2380 rosenRenderContext->OnZIndexUpdate(3);
2381 pipeline->taskScheduler_->FlushTask();
2382 positionZ = stagingProperties.GetPositionZ();
2383 EXPECT_EQ(positionZ, 3);
2384 }
2385 } // namespace OHOS::Ace::NG
2386
