• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #define private public
17 #define protected public
18 
19 #include "test/unittest/core/rosen/rosen_render_context_test.h"
20 #include "core/components_ng/render/drawing.h"
21 
22 #include "core/components_ng/pattern/stage/page_pattern.h"
23 #undef private
24 #undef protected
25 
26 using namespace testing;
27 using namespace testing::ext;
28 
29 namespace OHOS::Ace::NG {
30 namespace {} // namespace
31 
32 /**
33  * @tc.name: RosenRenderContextTestNew001
34  * @tc.desc: OnAttractionEffectUpdate().
35  * @tc.type: FUNC
36  */
37 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew001, TestSize.Level1)
38 {
__anond49572760202() 39     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
40     auto rosenRenderContext = InitRosenRenderContext(frameNode);
41     auto pipelineContext = rosenRenderContext->GetPipelineContext();
42     EXPECT_NE(pipelineContext, nullptr);
43     rosenRenderContext->SuggestOpIncNode(false, true);
44     AttractionEffect effect;
45     effect.fraction = 1.0f;
46     effect.destinationX = Dimension(1.0, DimensionUnit::PX);
47     effect.destinationY = Dimension(1.0, DimensionUnit::PX);
48     rosenRenderContext->OnAttractionEffectUpdate(effect);
49     Rosen::Vector2f dstPoint = { 1.0, 1.0 };
50     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetAttractionFractionValue(), 1.0);
51     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetAttractionDstPointValue(), dstPoint);
52 }
53 
54 /**
55  * @tc.name: RosenRenderContextTestNew002
56  * @tc.desc: NotifyHostTransformUpdated().
57  * @tc.type: FUNC
58  */
59 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew002, TestSize.Level1)
60 {
__anond49572760302() 61     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
62     auto rosenRenderContext = InitRosenRenderContext(frameNode);
63     rosenRenderContext->SyncPartialRsProperties();
64     std::shared_ptr<Rosen::RectF> drawRect = std::make_shared<Rosen::RectF>(1.0, 1.0, 1.0, 1.0);
65     rosenRenderContext->UpdateDrawRegion(5, drawRect); // 5 is the index of drawRegionRects_
66     rosenRenderContext->NotifyHostTransformUpdated(false);
67     EXPECT_FALSE(frameNode->isTransformNotChanged_);
68 }
69 
70 /**
71  * @tc.name: RosenRenderContextTestNew003
72  * @tc.desc: SavePaintRect().
73  * @tc.type: FUNC
74  */
75 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew003, TestSize.Level1)
76 {
__anond49572760402() 77     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
78     auto rosenRenderContext = InitRosenRenderContext(frameNode);
79     rosenRenderContext->ResetSurface(1, 0);
80     rosenRenderContext->SetMarkNodeGroup(false);
81     rosenRenderContext->SavePaintRect(true, 0);
82     EXPECT_EQ(rosenRenderContext->paintRect_, RectF(0.0, 0.0, 0.0, 0.0));
83     rosenRenderContext->SavePaintRect(false, 0);
84     EXPECT_EQ(rosenRenderContext->paintRect_, RectF(0.0, 0.0, 0.0, 0.0));
85     int32_t rollbackApiVersion = MockContainer::Current()->GetApiTargetVersion();
86     int32_t setApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_TWELVE);
87     MockContainer::Current()->SetApiTargetVersion(setApiVersion);
88     rosenRenderContext->SavePaintRect(true, 0);
89     EXPECT_EQ(rosenRenderContext->paintRect_, RectF(0.0, 0.0, 0.0, 0.0));
90     rosenRenderContext->SavePaintRect(false, 0);
91     MockContainer::Current()->SetApiTargetVersion(rollbackApiVersion);
92     EXPECT_EQ(rosenRenderContext->paintRect_, RectF(0.0, 0.0, 0.0, 0.0));
93 }
94 
95 /**
96  * @tc.name: RosenRenderContextTestNew004
97  * @tc.desc: UpdatePaintRect().
98  * @tc.type: FUNC
99  */
100 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew004, TestSize.Level1)
101 {
__anond49572760502() 102     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
103     auto rosenRenderContext = InitRosenRenderContext(frameNode);
104     rosenRenderContext->UpdatePaintRect(RectF(1.0, 1.0, 1.0, 1.0));
105     EXPECT_EQ(rosenRenderContext->paintRect_, RectF(1.0, 1.0, 1.0, 1.0));
106 }
107 
108 /**
109  * @tc.name: RosenRenderContextTestNew005
110  * @tc.desc: SetCommandPathMask().
111  * @tc.type: FUNC
112  */
113 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew005, TestSize.Level1)
114 {
115     std::string commands = "abcd";
116     RSPath path;
117     path.BuildFromSVGString(commands);
118     ShapeMaskProperty property;
119     property.fillColor = SHAPE_MASK_DEFAULT_COLOR;
120     property.strokeColor = SHAPE_MASK_DEFAULT_COLOR;
121     property.strokeWidth = 0.0f;
122     RSColor color;
123     color.SetColorQuad(property.fillColor);
124     RSBrush brush(color);
125     RSColor rsStrokeColor;
126     rsStrokeColor.SetColorQuad(property.strokeColor);
127     RSPen pen;
128     pen.SetColor(rsStrokeColor);
129     pen.SetWidth(property.strokeWidth);
130     std::shared_ptr<Rosen::RSMask> mask = Rosen::RSMask::CreatePathMask(path, pen, brush);
__anond49572760602() 131     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
132     auto rosenRenderContext = InitRosenRenderContext(frameNode);
133     rosenRenderContext->SetCommandPathMask(commands, property);
134     rosenRenderContext->SetClipBoundsWithCommands(commands);
135     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetMask()->GetMaskPen().GetColor(),
136         mask->GetMaskPen().GetColor());
137 }
138 
139 /**
140  * @tc.name: RosenRenderContextTestNew006
141  * @tc.desc: SetOvalMask().
142  * @tc.type: FUNC
143  */
144 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew006, TestSize.Level1)
145 {
146     auto rect = RectF(1.0, 1.0, 1.0, 1.0);
147     RSRect rsRect(rect.Left(), rect.Top(), rect.Right(), rect.Bottom());
148     RSPath path;
149     path.AddOval(rsRect);
150     ShapeMaskProperty property;
151     property.fillColor = SHAPE_MASK_DEFAULT_COLOR;
152     property.strokeColor = SHAPE_MASK_DEFAULT_COLOR;
153     property.strokeWidth = 0.0f;
154     RSColor color;
155     color.SetColorQuad(property.fillColor);
156     RSBrush brush(color);
157     RSColor rsStrokeColor;
158     rsStrokeColor.SetColorQuad(property.strokeColor);
159     RSPen pen;
160     pen.SetColor(rsStrokeColor);
161     pen.SetWidth(property.strokeWidth);
162     std::shared_ptr<Rosen::RSMask> mask = Rosen::RSMask::CreatePathMask(path, pen, brush);
__anond49572760702() 163     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
164     auto rosenRenderContext = InitRosenRenderContext(frameNode);
165     rosenRenderContext->SetOvalMask(rect, property);
166     rosenRenderContext->ClipWithRect(rect);
167     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetMask()->GetMaskPen().GetColor(),
168         mask->GetMaskPen().GetColor());
169 }
170 
171 /**
172  * @tc.name: RosenRenderContextTestNew007
173  * @tc.desc: SetRoundRectMask().
174  * @tc.type: FUNC
175  */
176 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew007, TestSize.Level1)
177 {
178     auto rect = RectF(1.0, 1.0, 1.0, 1.0);
179     RSRoundRect rsRoundRect;
180     RoundRect roundRect;
181     roundRect.SetRect(rect);
182     roundRect.SetCornerRadius(1.0);
183     RSRect rsRect(roundRect.GetRect().Left(), roundRect.GetRect().Top(), roundRect.GetRect().Right(),
184         roundRect.GetRect().Bottom());
185     rsRoundRect.SetRect(rsRect);
186     EdgeF edge = roundRect.GetCornerRadius(RoundRect::TOP_LEFT_POS);
187     rsRoundRect.SetCornerRadius(RSRoundRect::TOP_LEFT_POS, edge.x, edge.y);
188     edge = roundRect.GetCornerRadius(RoundRect::TOP_RIGHT_POS);
189     rsRoundRect.SetCornerRadius(RSRoundRect::TOP_RIGHT_POS, edge.x, edge.y);
190     edge = roundRect.GetCornerRadius(RoundRect::BOTTOM_LEFT_POS);
191     rsRoundRect.SetCornerRadius(RSRoundRect::BOTTOM_LEFT_POS, edge.x, edge.y);
192     edge = roundRect.GetCornerRadius(RoundRect::BOTTOM_RIGHT_POS);
193     rsRoundRect.SetCornerRadius(RSRoundRect::BOTTOM_RIGHT_POS, edge.x, edge.y);
194     RSPath path;
195     path.AddRoundRect(rsRoundRect);
196     ShapeMaskProperty property;
197     property.fillColor = SHAPE_MASK_DEFAULT_COLOR;
198     property.strokeColor = SHAPE_MASK_DEFAULT_COLOR;
199     property.strokeWidth = 0.0f;
200     RSColor color;
201     color.SetColorQuad(property.fillColor);
202     RSBrush brush(color);
203     RSColor rsStrokeColor;
204     rsStrokeColor.SetColorQuad(property.strokeColor);
205     RSPen pen;
206     pen.SetColor(rsStrokeColor);
207     pen.SetWidth(property.strokeWidth);
208     std::shared_ptr<Rosen::RSMask> mask = Rosen::RSMask::CreatePathMask(path, pen, brush);
__anond49572760802() 209     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
210     auto rosenRenderContext = InitRosenRenderContext(frameNode);
211     rosenRenderContext->SetRoundRectMask(roundRect, property);
212     rosenRenderContext->ClipWithRoundRect(roundRect);
213     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetMask()->GetMaskPen().GetColor(),
214         mask->GetMaskPen().GetColor());
215 }
216 
217 /**
218  * @tc.name: RosenRenderContextTestNew008
219  * @tc.desc: SetCircleMask().
220  * @tc.type: FUNC
221  */
222 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew008, TestSize.Level1)
223 {
224     Circle circle;
225     circle.SetAxisX(Dimension(1.0));
226     circle.SetAxisY(Dimension(0.0));
227     circle.SetRadius(Dimension(1.0));
228     RSPath path;
229     path.AddCircle(circle.GetAxisX().Value(), circle.GetAxisY().Value(), circle.GetRadius().Value());
230     ShapeMaskProperty property;
231     property.fillColor = SHAPE_MASK_DEFAULT_COLOR;
232     property.strokeColor = SHAPE_MASK_DEFAULT_COLOR;
233     property.strokeWidth = 0.0f;
234     RSColor color;
235     color.SetColorQuad(property.fillColor);
236     RSBrush brush(color);
237     RSColor rsStrokeColor;
238     rsStrokeColor.SetColorQuad(property.strokeColor);
239     RSPen pen;
240     pen.SetColor(rsStrokeColor);
241     pen.SetWidth(property.strokeWidth);
242     std::shared_ptr<Rosen::RSMask> mask = Rosen::RSMask::CreatePathMask(path, pen, brush);
__anond49572760902() 243     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
244     auto rosenRenderContext = InitRosenRenderContext(frameNode);
245     rosenRenderContext->SetCircleMask(circle, property);
246     rosenRenderContext->SetOpacityMultiplier(1.0);
247     rosenRenderContext->ClipWithCircle(circle);
248     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetMask()->GetMaskPen().GetColor(),
249         mask->GetMaskPen().GetColor());
250 }
251 
252 /**
253  * @tc.name: RosenRenderContextTestNew009
254  * @tc.desc: SetRectMask().
255  * @tc.type: FUNC
256  */
257 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew009, TestSize.Level1)
258 {
259     auto rect = RectF(1.0, 1.0, 1.0, 1.0);
260     RSPath path;
261     path.AddRect(rect.Left(), rect.Top(), rect.Right(), rect.Bottom());
262     ShapeMaskProperty property;
263     property.fillColor = SHAPE_MASK_DEFAULT_COLOR;
264     property.strokeColor = SHAPE_MASK_DEFAULT_COLOR;
265     property.strokeWidth = 0.0f;
266     RSColor color;
267     color.SetColorQuad(property.fillColor);
268     RSBrush brush(color);
269     RSColor rsStrokeColor;
270     rsStrokeColor.SetColorQuad(property.strokeColor);
271     RSPen pen;
272     pen.SetColor(rsStrokeColor);
273     pen.SetWidth(property.strokeWidth);
274     std::shared_ptr<Rosen::RSMask> mask = Rosen::RSMask::CreatePathMask(path, pen, brush);
__anond49572760a02() 275     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
276     auto rosenRenderContext = InitRosenRenderContext(frameNode);
277     rosenRenderContext->SetRectMask(rect, property);
278     rosenRenderContext->SetTranslate(0.0, 1.0, 0.0);
279     rosenRenderContext->ClipWithOval(rect);
280     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetMask()->GetMaskPen().GetColor(),
281         mask->GetMaskPen().GetColor());
282 }
283 
284 /**
285  * @tc.name: RosenRenderContextTestNew010
286  * @tc.desc: SetTransitionUserCallback().
287  * @tc.type: FUNC
288  */
289 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew010, TestSize.Level1)
290 {
__anond49572760b02() 291     auto frameNode = FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
292     auto rosenRenderContext = InitRosenRenderContext(frameNode);
__anond49572760c02() 293     auto parentNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
294     parentNode->AddChild(frameNode);
295 
296     bool userFlag = false;
__anond49572760d02(bool ret) 297     TransitionFinishCallback userCallback = [&userFlag](bool ret) { userFlag = !userFlag; };
298     rosenRenderContext->SetTransitionUserCallback(std::move(userCallback));
299     rosenRenderContext->FireTransitionUserCallback(true);
300     rosenRenderContext->InitEventClickEffect();
301     EXPECT_TRUE(userFlag);
302 
303     bool outFlag = false;
__anond49572760e02() 304     auto outCallback = [&outFlag]() { outFlag = !outFlag; };
305     rosenRenderContext->SetTransitionOutCallback(std::move(outCallback));
306     auto property = AceType::MakeRefPtr<NodeAnimatablePropertyBase>();
307     rosenRenderContext->AttachNodeAnimatableProperty(property);
308     auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>();
309     layoutProperty->propVisibility_ = VisibleType::INVISIBLE;
310     frameNode->SetLayoutProperty(layoutProperty);
311     frameNode->isDisappearing_ = false;
312     frameNode->onMainTree_ = true;
313     rosenRenderContext->DetachNodeAnimatableProperty(property);
314     rosenRenderContext->OnTransitionOutFinish();
315     EXPECT_TRUE(outFlag);
316 
317     bool inFlag = false;
__anond49572760f02() 318     auto inCallback = [&inFlag]() { inFlag = !inFlag; };
319     rosenRenderContext->SetTransitionInCallback(std::move(inCallback));
320     rosenRenderContext->PostTransitionUserOutCallback();
321     frameNode->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
322     rosenRenderContext->OnTransitionInFinish();
323     EXPECT_TRUE(inFlag);
324 }
325 
326 /**
327  * @tc.name: RosenRenderContextTestNew011
328  * @tc.desc: SetOpacity().
329  * @tc.type: FUNC
330  */
331 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew011, TestSize.Level1)
332 {
__anond49572761002() 333     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
334     auto rosenRenderContext = InitRosenRenderContext(frameNode);
335     EXPECT_FALSE(rosenRenderContext->IsUniRenderEnabled());
336     rosenRenderContext->SetOpacity(1.0);
337     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetAlpha(), 1.0);
338     rosenRenderContext->SetFrame(0.0, 1.0, 0.0, 1.0);
339     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame().data_[1], 1.0);
340     rosenRenderContext->SetRenderPivot(1.0, 0.0);
341     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 1.0);
342     rosenRenderContext->SetBackgroundColor(SHAPE_MASK_DEFAULT_COLOR);
343     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBackgroundColor(),
344         OHOS::Rosen::RSColor::FromArgbInt(SHAPE_MASK_DEFAULT_COLOR));
345     rosenRenderContext->SetScale(1.0, 0.0);
346     rosenRenderContext->PaintPixmapBgImage();
347     rosenRenderContext->PaintRSBgImage();
348     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetScale().data_[0], 1.0);
349     rosenRenderContext->SetRenderFrameOffset(OffsetF(1.0, 0.0));
350     EXPECT_EQ(rosenRenderContext->frameOffset_, OffsetF(1.0, 0.0));
351     rosenRenderContext->SetShadowRadius(1.0);
352     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowRadius(), 1.0);
353     rosenRenderContext->SetShadowElevation(1.0);
354     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowElevation(), 1.0);
355     rosenRenderContext->SetShadowAlpha(1.0);
356     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowAlpha(), 1.0);
357     rosenRenderContext->SetShadowOffset(1.0, 0.0);
358     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowOffsetX(), 1.0);
359     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowOffsetY(), 0.0);
360     rosenRenderContext->SetShadowColor(SHAPE_MASK_DEFAULT_COLOR);
361     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowColor(),
362         OHOS::Rosen::RSColor::FromArgbInt(SHAPE_MASK_DEFAULT_COLOR));
363     rosenRenderContext->SetRotation(1.0, 0.0, 1.0);
364     rosenRenderContext->DumpInfo();
365     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetRotationX(), 1.0);
366     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetRotationY(), 0.0);
367     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetRotation(), 1.0);
368 }
369 
370 /**
371  * @tc.name: RosenRenderContextTestNew012
372  * @tc.desc: SetContentRectToFrame().
373  * @tc.type: FUNC
374  */
375 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew012, TestSize.Level1)
376 {
__anond49572761102() 377     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
378     auto rosenRenderContext = InitRosenRenderContext(frameNode);
379     rosenRenderContext->OnRenderGroupUpdate(true);
380     rosenRenderContext->OnSuggestedRenderGroupUpdate(true);
381     rosenRenderContext->UpdateRenderGroup(true, false, true);
__anond49572761202(std::vector<float>& param) 382     auto updateCallback = [](std::vector<float>& param) {};
383     rosenRenderContext->AddUpdateCallBack(std::move(updateCallback));
__anond49572761302(int64_t param, bool ret) 384     auto attachCallback = [](int64_t param, bool ret) {};
385     rosenRenderContext->AddAttachCallBack(std::move(attachCallback));
386     rosenRenderContext->MarkNewFrameAvailable(nullptr);
387     rosenRenderContext->OnRenderFitUpdate(RenderFit::BOTTOM_LEFT);
388     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrameGravity(), Rosen::Gravity::BOTTOM_LEFT);
389     std::string id = "id";
390     rosenRenderContext->OnNodeNameUpdate(id);
391     rosenRenderContext->SetContentRectToFrame(RectF(0.0, 1.0, 0.0, 1.0));
392     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame().data_[1], 1.0);
393 }
394 
395 /**
396  * @tc.name: RosenRenderContextTestNew013
397  * @tc.desc: UpdatePlayAnimationValue().
398  * @tc.type: FUNC
399  */
400 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew013, TestSize.Level1)
401 {
__anond49572761402() 402     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
403     auto rosenRenderContext = InitRosenRenderContext(frameNode);
404     auto context = AceType::MakeRefPtr<RenderContext>();
405     rosenRenderContext->RegisterSharedTransition(context, true);
406     float scaleValue = 1.0; // 4.0 is the value of scaleValue
407     rosenRenderContext->UpdatePlayAnimationValue(ClickEffectLevel::LIGHT, scaleValue);
408     EXPECT_EQ(scaleValue, 1.0);
409     ClickEffectInfo effectInfo;
410     effectInfo.level = ClickEffectLevel::LIGHT;
411     rosenRenderContext->UpdateClickEffectLevel(effectInfo);
412     rosenRenderContext->ClickEffectPlayAnimation(TouchType::DOWN);
413     EXPECT_FALSE(rosenRenderContext->isTouchUpFinished_);
414     rosenRenderContext->UnregisterSharedTransition(context);
415     BorderRadiusProperty property;
416     property.SetRadius(Dimension(1.0_px));
417     rosenRenderContext->UpdateBorderRadius(property);
418     rosenRenderContext->SetActualForegroundColor(Color(SHAPE_MASK_DEFAULT_COLOR));
419     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetForegroundColor(),
420         OHOS::Rosen::RSColor::FromArgbInt(SHAPE_MASK_DEFAULT_COLOR));
421 }
422 
423 /**
424  * @tc.name: RosenRenderContextTestNew014
425  * @tc.desc: UpdateChainedTransition().
426  * @tc.type: FUNC
427  */
428 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew014, TestSize.Level1)
429 {
__anond49572761502() 430     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
431     auto rosenRenderContext = InitRosenRenderContext(frameNode);
432     rosenRenderContext->transitionEffect_ = AceType::MakeRefPtr<RosenTransitionEffect>();
433     rosenRenderContext->NotifyTransition(true);
434     rosenRenderContext->OnMouseSelectUpdate(true, Color(SHAPE_MASK_DEFAULT_COLOR), Color(SHAPE_MASK_DEFAULT_COLOR));
435     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetModifierIds().size(), 1);
436     rosenRenderContext->MarkDrivenRenderFramePaintState(true);
437     rosenRenderContext->MarkDrivenRenderItemIndex(1);
438     rosenRenderContext->MarkDrivenRender(true);
439     rosenRenderContext->MarkContentChanged(true);
440     RefPtr<NG::ChainedTransitionEffect> effect = AceType::MakeRefPtr<NG::ChainedOpacityEffect>(1.0);
441     rosenRenderContext->UpdateChainedTransition(effect);
442     EXPECT_FALSE(rosenRenderContext->hasDefaultTransition_);
443 }
444 
445 /**
446  * @tc.name: RosenRenderContextTestNew015
447  * @tc.desc: SetFrameGravity().
448  * @tc.type: FUNC
449  */
450 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew015, TestSize.Level1)
451 {
__anond49572761602() 452     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
453     auto rosenRenderContext = InitRosenRenderContext(frameNode);
454     rosenRenderContext->UpdateBackgroundAlign(Alignment::BOTTOM_LEFT);
455     rosenRenderContext->UpdateLightUpEffect(1);
456     rosenRenderContext->DumpAdvanceInfo();
457     std::shared_ptr<RSNode> externalNode = rosenRenderContext->GetRSNode();
458     rosenRenderContext->SetRSNode(externalNode);
459     ASSERT_NE(rosenRenderContext->GetRSNode(), nullptr);
460     rosenRenderContext->ClearDrawCommands();
461     rosenRenderContext->SetSurfaceRotation(false);
462     rosenRenderContext->rsTextureExport_ = std::make_shared<Rosen::RSTextureExport>(externalNode, 1);
463     EXPECT_TRUE(rosenRenderContext->StopTextureExport());
464     EXPECT_FALSE(rosenRenderContext->DoTextureExport(1));
465     std::string scene = "scene";
466     EXPECT_EQ(rosenRenderContext->CalcExpectedFrameRate(scene, 1.0), 0);
467     rosenRenderContext->SetFrameGravity(OHOS::Rosen::Gravity::BOTTOM_LEFT);
468     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrameGravity(), Rosen::Gravity::BOTTOM_LEFT);
469 }
470 
471 /**
472  * @tc.name: RosenRenderContextTestNew016
473  * @tc.desc: SetBounds().
474  * @tc.type: FUNC
475  */
476 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew016, TestSize.Level1)
477 {
__anond49572761702() 478     auto frameNode = FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<Pattern>(); });
479     auto rosenRenderContext = InitRosenRenderContext(frameNode);
480     rosenRenderContext->SetUsingContentRectForRenderFrame(false, true);
481     EXPECT_TRUE(rosenRenderContext->adjustRSFrameByContentRect_);
482     EXPECT_FALSE(rosenRenderContext->useContentRectForRSFrame_);
483     rosenRenderContext->SetSharedTranslate(1.0, 1.0);
484     rosenRenderContext->ResetSharedTranslate();
485     auto childContextOne = AceType::MakeRefPtr<RosenRenderContext>();
486     auto childContextTwo = AceType::MakeRefPtr<RosenRenderContext>();
487     rosenRenderContext->AddChild(childContextOne, 0);
488     rosenRenderContext->AddChild(childContextTwo, 1);
489     rosenRenderContext->RemoveChild(childContextOne);
490     rosenRenderContext->ClearChildren();
491     EXPECT_EQ(rosenRenderContext->GetRSNode()->children_.size(), 0);
492     rosenRenderContext->SetBounds(1.0, 0.0, 1.0, 0.0);
493     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds().data_[0], 1.0);
494     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBounds().data_[1], 0.0);
495 }
496 
497 /**
498  * @tc.name: RosenRenderContextTestNew017
499  * @tc.desc: OnBloomUpdate().
500  * @tc.type: FUNC
501  */
502 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew017, TestSize.Level1)
503 {
504     auto frameNode =
__anond49572761802() 505         FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
506     auto rosenRenderContext = InitRosenRenderContext(frameNode);
507     SafeAreaInsets::Inset left { 0, 1 };
508     SafeAreaInsets::Inset top { 0, 1 };
509     SafeAreaInsets::Inset right { 0, 1 };
510     SafeAreaInsets::Inset bottom { 0, 1 };
511     SafeAreaInsets safeAreaInsets(left, top, right, bottom);
512     auto context = PipelineContext::GetCurrentContext();
513     context->UpdateSystemSafeArea(safeAreaInsets);
514     rosenRenderContext->paintRect_ = RectF(1.0, 1.0, 1.0, 1.0);
515     OverlayOptions overlay;
516     overlay.x = Dimension(1.0_px);
517     rosenRenderContext->OnOverlayTextUpdate(overlay);
518     rosenRenderContext->OnBloomUpdate(false);
519     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBloom(), false);
520     rosenRenderContext->OnIlluminatedBorderWidthUpdate(Dimension(1.0_px));
521     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetIlluminatedBorderWidth(), 1.0);
522     rosenRenderContext->OnLightIlluminatedUpdate(1);
523     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetIlluminatedType(), 1);
524     rosenRenderContext->OnLightColorUpdate(Color(SHAPE_MASK_DEFAULT_COLOR));
525     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetLightColor(),
526         OHOS::Rosen::RSColor::FromArgbInt(SHAPE_MASK_DEFAULT_COLOR));
527     MotionPathOption motionPathOption("test");
528     rosenRenderContext->OnMotionPathUpdate(motionPathOption);
529     rosenRenderContext->OnLightIntensityUpdate(1.0);
530     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetLightIntensity(), 1.0);
531     TranslateOptions translate { Dimension(1.0_px), Dimension(0.0_px), Dimension(1.0_px) };
532     rosenRenderContext->OnLightPositionUpdate(translate);
533     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetLightPosition().data_[0], 1.0);
534     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetLightPosition().data_[1], 0.0);
535 }
536 
537 /**
538  * @tc.name: RosenRenderContextTestNew018
539  * @tc.desc: OnClipEdgeUpdate().
540  * @tc.type: FUNC
541  */
542 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew018, TestSize.Level1)
543 {
544     auto frameNode =
__anond49572761902() 545         FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
546     auto rosenRenderContext = InitRosenRenderContext(frameNode);
547     auto pattern = frameNode->GetPattern<PagePattern>();
548     PageTransitionOption option;
549     option.routeType = RouteType::PUSH;
550     auto effect = AceType::MakeRefPtr<PageTransitionEffect>(PageTransitionType::EXIT, option);
551     pattern->AddPageTransition(effect);
552     rosenRenderContext->paintRect_ = RectF(1.0, 1.0, 1.0, 1.0);
553     auto basicShape = AceType::MakeRefPtr<BasicShape>(BasicShapeType::CIRCLE);
554     rosenRenderContext->UpdateClipShape(basicShape);
555     rosenRenderContext->UpdateClipMask(basicShape);
556     rosenRenderContext->OnClipMaskUpdate(basicShape);
557     rosenRenderContext->OnClipShapeUpdate(basicShape);
558     rosenRenderContext->PaintClip(SizeF(1.0, 1.0));
559     rosenRenderContext->RemoveClipWithRRect();
560     RefPtr<NG::ProgressMaskProperty> progress = AceType::MakeRefPtr<NG::ProgressMaskProperty>();
561     progress->SetColor(Color::BLUE);
562     rosenRenderContext->UpdateProgressMask(progress);
563     rosenRenderContext->OnProgressMaskUpdate(progress);
564     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetClipToBounds(), true);
565     rosenRenderContext->OnClipEdgeUpdate(false);
566     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetClipToBounds(), false);
567 }
568 
569 /**
570  * @tc.name: RosenRenderContextTestNew019
571  * @tc.desc: PaintGradient().
572  * @tc.type: FUNC
573  */
574 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew019, TestSize.Level1)
575 {
576     auto frameNode =
__anond49572761a02() 577         FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
578     auto rosenRenderContext = InitRosenRenderContext(frameNode);
579     rosenRenderContext->paintRect_ = RectF(1.0, 1.0, 1.0, 1.0);
580     NG::Gradient gradient;
581     GradientColor color(Color::BLACK);
582     gradient.AddColor(color);
583     rosenRenderContext->UpdateLinearGradient(gradient);
584     rosenRenderContext->UpdateSweepGradient(gradient);
585     rosenRenderContext->UpdateRadialGradient(gradient);
586     rosenRenderContext->SetOpacity(1.0);
587     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetAlpha(), 1.0);
588     rosenRenderContext->OnLinearGradientUpdate(gradient);
589     rosenRenderContext->OnSweepGradientUpdate(gradient);
590     rosenRenderContext->OnRadialGradientUpdate(gradient);
591     rosenRenderContext->PaintGradient(SizeF(1.0, 0.0));
592     auto shader = std::make_shared<Rosen::RSShader>();
593     rosenRenderContext->SetBackgroundShader(shader);
594     TransitionOptions options;
595     options.Type = TransitionType::APPEARING;
596     auto optionsPtr = std::make_unique<TransitionOptions>(options);
597     rosenRenderContext->UpdateTransition(options);
598     EXPECT_NE(rosenRenderContext->GetRSTransitionWithoutType(optionsPtr, SizeF(0.0, 1.0)), nullptr);
599     rosenRenderContext->CleanTransition();
600     rosenRenderContext->SetShadowAlpha(1.0);
601     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowAlpha(), 1.0);
602     rosenRenderContext->SetShadowOffset(1.0, 0.0);
603     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowOffsetX(), 1.0);
604     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowOffsetY(), 0.0);
605 }
606 
607 /**
608  * @tc.name: RosenRenderContextTestNew020
609  * @tc.desc: OnClipEdgeUpdate().
610  * @tc.type: FUNC
611  */
612 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew020, TestSize.Level1)
613 {
614     auto frameNode =
__anond49572761b02() 615         FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
616     auto rosenRenderContext = InitRosenRenderContext(frameNode);
617     auto property = std::make_shared<Rosen::RSPropertyBase>();
618     std::shared_ptr<Rosen::RSModifier> modifier = std::make_shared<Rosen::RSBackgroundShaderModifier>(property);
619     rosenRenderContext->AddModifier(modifier);
620     rosenRenderContext->paintRect_ = RectF(1.0, 1.0, 1.0, 1.0);
621     BrightnessOption option;
622     std::optional<BrightnessOption> brightnessOption = std::make_optional(option);
623     rosenRenderContext->OnFgDynamicBrightnessOptionUpdate(brightnessOption);
624     rosenRenderContext->OnBgDynamicBrightnessOptionUpdate(brightnessOption);
625     rosenRenderContext->OnDynamicLightUpDegreeUpdate(0.0);
626     rosenRenderContext->OnDynamicLightUpRateUpdate(1.0);
627     rosenRenderContext->OnDynamicDimDegreeUpdate(0.0);
628     rosenRenderContext->SetRenderFrameOffset(OffsetF(1.0, 0.0));
629     EXPECT_EQ(rosenRenderContext->frameOffset_, OffsetF(1.0, 0.0));
630     std::vector<std::pair<float, float>> fractionStops;
631     fractionStops.push_back(std::pair<float, float>(0.0f, 1.0f));
632     CalcDimension dimensionRadius(0.0);
633     NG::LinearGradientBlurPara blurPara(dimensionRadius, fractionStops, NG::GradientDirection::LEFT);
634     rosenRenderContext->OnLinearGradientBlurUpdate(blurPara);
635     rosenRenderContext->SetShadowRadius(1.0);
636     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowRadius(), 1.0);
637     rosenRenderContext->OnSystemBarEffectUpdate(false);
638     rosenRenderContext->RemoveModifier(modifier);
639     rosenRenderContext->UpdateFrontGrayScale(1.0_vp);
640     rosenRenderContext->UpdateFrontBrightness(1.0_vp);
641     rosenRenderContext->UpdateFrontContrast(1.0_vp);
642     rosenRenderContext->UpdateFrontSaturate(1.0_vp);
643     rosenRenderContext->UpdateFrontSepia(1.0_vp);
644     InvertVariant invert = 0.0f;
645     rosenRenderContext->UpdateFrontInvert(invert);
646     rosenRenderContext->UpdateFrontHueRotate(0.0);
647     rosenRenderContext->UpdateFrontColorBlend(Color::GRAY);
648     rosenRenderContext->PaintGraphics();
649     rosenRenderContext->SetRotation(1.0, 0.0, 1.0);
650     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetRotationX(), 1.0);
651     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetRotationY(), 0.0);
652     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetRotation(), 1.0);
653 }
654 
655 /**
656  * @tc.name: RosenRenderContextTestNew021
657  * @tc.desc: OnBackBlendApplyTypeUpdate().
658  * @tc.type: FUNC
659  */
660 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew021, TestSize.Level1)
661 {
662     auto frameNode =
__anond49572761c02() 663         FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
664     auto rosenRenderContext = InitRosenRenderContext(frameNode);
665     auto property = std::make_shared<Rosen::RSPropertyBase>();
666     std::shared_ptr<Rosen::RSModifier> modifier = std::make_shared<Rosen::RSBackgroundShaderModifier>(property);
667     rosenRenderContext->AddModifier(modifier);
668     rosenRenderContext->paintRect_ = RectF(1.0, 1.0, 1.0, 1.0);
669     rosenRenderContext->OnBackBlendApplyTypeUpdate(BlendApplyType::OFFSCREEN);
670     rosenRenderContext->OnBackBlendModeUpdate(BlendMode::SATURATION);
671     rosenRenderContext->AnimateHoverEffectScale(true);
672     EXPECT_FALSE(rosenRenderContext->isHoveredScale_);
673     MotionBlurOption motionBlurOption;
674     motionBlurOption.radius = 5;
675     rosenRenderContext->UpdateMotionBlur(motionBlurOption);
676     rosenRenderContext->AnimateHoverEffectBoard(true);
677     EXPECT_FALSE(rosenRenderContext->isHoveredBoard_);
678     rosenRenderContext->UpdateFrontBlurRadius(0.0_px);
679     EXPECT_EQ(rosenRenderContext->GetFrontBlurRadius().value(), 0.0_px);
680     BlurOption blurOption;
681     blurOption.grayscale.emplace_back(0.0);
682     blurOption.grayscale.emplace_back(1.0);
683     rosenRenderContext->UpdateFrontBlur(1.0_px, blurOption);
684     EXPECT_EQ(rosenRenderContext->GetFrontBlurRadius().value(), 1.0_px);
685     rosenRenderContext->UpdateBackBlurRadius(0.0_px);
686     EXPECT_EQ(rosenRenderContext->GetBackBlurRadius().value(), 0.0_px);
687     rosenRenderContext->UpdateBackBlur(1.0_px, blurOption);
688     EXPECT_EQ(rosenRenderContext->GetBackBlurRadius().value(), 1.0_px);
689 }
690 
691 /**
692  * @tc.name: RosenRenderContextTestNew022
693  * @tc.desc: OnBackShadowUpdate().
694  * @tc.type: FUNC
695  */
696 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew022, TestSize.Level1)
697 {
698     auto frameNode =
__anond49572761d02() 699         FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
700     auto rosenRenderContext = InitRosenRenderContext(frameNode);
701     auto childNode =
__anond49572761e02() 702         FrameNode::GetOrCreateFrameNode("child", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
703     auto childRenderContext = InitRosenRenderContext(childNode);
__anond49572761f02() 704     auto nodeOne = FrameNode::GetOrCreateFrameNode("nodeOne", 0, []() { return AceType::MakeRefPtr<Pattern>(); });
__anond49572762002() 705     auto nodeTwo = FrameNode::GetOrCreateFrameNode("nodeTwo", 1, []() { return AceType::MakeRefPtr<Pattern>(); });
__anond49572762102() 706     auto nodeThree = FrameNode::GetOrCreateFrameNode("nodeThree", 0, []() { return AceType::MakeRefPtr<Pattern>(); });
707     std::list<RefPtr<FrameNode>> childrenOne;
708     childrenOne.emplace_back(nodeOne);
709     childrenOne.emplace_back(nodeTwo);
710     std::list<RefPtr<FrameNode>> childrenTwo;
711     childrenTwo.emplace_back(nodeTwo);
712     childrenTwo.emplace_back(nodeThree);
713     rosenRenderContext->AddFrameChildren(nullptr, childrenOne);
714     rosenRenderContext->RebuildFrame(nullptr, childrenTwo);
715     rosenRenderContext->RemoveFrameChildren(nullptr, childrenTwo);
716     EXPECT_NE(childRenderContext, nullptr);
717     rosenRenderContext->MoveFrame(nullptr, childNode, 0);
718     Shadow shadow(1.0, Offset(1.0, 0.0), Color(SHAPE_MASK_DEFAULT_COLOR), ShadowStyle::None);
719     shadow.SetIsFilled(true);
720     shadow.SetShadowType(ShadowType::COLOR);
721     shadow.SetShadowColorStrategy(ShadowColorStrategy::NONE);
722     rosenRenderContext->OnBackShadowUpdate(shadow);
723     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowOffsetX(), 1.0);
724     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowOffsetY(), 0.0);
725     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowColor(),
726         OHOS::Rosen::RSColor::FromArgbInt(SHAPE_MASK_DEFAULT_COLOR));
727     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowMask(), false);
728     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowIsFilled(), true);
729     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowColorStrategy(),
730         Rosen::SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_NONE);
731 }
732 
733 /**
734  * @tc.name: RosenRenderContextTestNew023
735  * @tc.desc: OnBackBlendApplyTypeUpdate().
736  * @tc.type: FUNC
737  */
738 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew023, TestSize.Level1)
739 {
740     auto frameNode =
__anond49572762202() 741         FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
742     RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
743     auto fgModifier = AceType::MakeRefPtr<Modifier>();
744     rosenRenderContext->FlushForegroundModifier(fgModifier);
745     auto overlayModifier = AceType::MakeRefPtr<Modifier>();
746     rosenRenderContext->FlushOverlayModifier(overlayModifier);
__anond49572762302(RSCanvas& canvas) 747     std::function<void(RSCanvas & canvas)> func = [](RSCanvas& canvas) {};
748     rosenRenderContext->FlushOverlayDrawFunction(std::move(func));
749     auto rect = RectF(1.0, 1.0, 1.0, 1.0);
750     RoundRect roundRect;
751     roundRect.SetRect(rect);
752     roundRect.SetCornerRadius(1.0);
753     rosenRenderContext->PaintFocusState(roundRect, Color::BLUE, 1.0_vp, true, true);
754     rosenRenderContext->SetShadowRadius(1.0);
755     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowRadius(), 1.0);
756     rosenRenderContext->SetShadowElevation(1.0);
757     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetShadowElevation(), 1.0);
758     rosenRenderContext->FlushForegroundDrawFunction(std::move(func));
759     auto contentModifier = AceType::MakeRefPtr<Modifier>();
760     rosenRenderContext->FlushContentModifier(contentModifier);
761     rosenRenderContext->FlushContentDrawFunction(std::move(func));
762     rosenRenderContext->ClearFocusState();
763     rosenRenderContext->PaintFocusState(1.0_vp, Color::BLACK, 0.0_vp, false);
764     EXPECT_FALSE(rosenRenderContext->IsUniRenderEnabled());
765     rosenRenderContext->SetOpacity(1.0);
766     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetAlpha(), 1.0);
767     rosenRenderContext->PaintAccessibilityFocus();
768     rosenRenderContext->PaintFocusState(1.0_vp, Color::BLACK, 0.0_vp, true);
769     rosenRenderContext->SetFrame(0.0, 1.0, 0.0, 1.0);
770     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetFrame().data_[1], 1.0);
771     rosenRenderContext->SetRenderPivot(1.0, 0.0);
772     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetPivot().x_, 1.0);
773 }
774 
775 /**
776  * @tc.name: RosenRenderContextTestNew024
777  * @tc.desc: AdjustPaintRect().
778  * @tc.type: FUNC
779  */
780 HWTEST_F(RosenRenderContextTest, RosenRenderContextTestNew024, TestSize.Level1)
781 {
782     auto frameNode =
__anond49572762402() 783         FrameNode::GetOrCreateFrameNode("frame", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
784     RefPtr<RosenRenderContext> rosenRenderContext = InitRosenRenderContext(frameNode);
785     auto parentNode =
__anond49572762502() 786         FrameNode::GetOrCreateFrameNode("parent", -1, []() { return AceType::MakeRefPtr<PagePattern>(nullptr); });
787     parentNode->AddChild(frameNode);
788     rosenRenderContext->OnZIndexUpdate(1);
789     auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>();
790     layoutProperty->SetUsingPosition(true);
791     frameNode->SetLayoutProperty(layoutProperty);
792     rosenRenderContext->RecalculatePosition();
793     auto geometryNode = frameNode->GetGeometryNode();
794     geometryNode->frame_.rect_ = RectF(1.0, 1.0, 1.0, 1.0);
795     auto offset = OffsetT<Dimension>(Dimension(1), Dimension(1));
796     EdgesParam edges;
797     CalcDimension top(1.0, DimensionUnit::VP);
798     edges.SetTop(top);
799     rosenRenderContext->UpdateOffsetEdges(edges);
800     rosenRenderContext->OnPositionEdgesUpdate(edges);
801     rosenRenderContext->UpdateOffset(offset);
802     rosenRenderContext->RecalculatePosition();
803     rosenRenderContext->ResetBlendBorderColor();
804     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBorderColor().data_[0],
805         OHOS::Rosen::RSColor::FromArgbInt((Color::TRANSPARENT).GetValue()));
806     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBorderColor().data_[1],
807         OHOS::Rosen::RSColor::FromArgbInt((Color::TRANSPARENT).GetValue()));
808     rosenRenderContext->UpdatePositionEdges(edges);
809     rosenRenderContext->OnOffsetEdgesUpdate(edges);
810     rosenRenderContext->UpdatePosition(offset);
811     rosenRenderContext->OnAnchorUpdate(offset);
812     rosenRenderContext->BlendBorderColor(Color::BLUE);
813     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBorderColor().data_[0],
814         OHOS::Rosen::RSColor::FromArgbInt((Color::BLUE).GetValue()));
815     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBorderColor().data_[1],
816         OHOS::Rosen::RSColor::FromArgbInt((Color::BLUE).GetValue()));
817     rosenRenderContext->OnOffsetUpdate(offset);
818     rosenRenderContext->OnPositionUpdate(offset);
819     rosenRenderContext->ResetBlendBgColor();
820     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBackgroundColor(),
821         OHOS::Rosen::RSColor::FromArgbInt((Color::TRANSPARENT).GetValue()));
822     rosenRenderContext->BlendBgColor(Color::BLACK);
823     EXPECT_EQ(rosenRenderContext->GetRSNode()->GetStagingProperties().GetBackgroundColor(),
824         OHOS::Rosen::RSColor::FromArgbInt((Color::BLACK).GetValue()));
825 }
826 } // namespace OHOS::Ace::NG