1 /*
2 * Copyright (c) 2022-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, Hardware
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "common/rs_obj_abs_geometry.h"
19 #include "drawable/rs_property_drawable_foreground.h"
20 #include "offscreen_render/rs_offscreen_render_thread.h"
21 #include "params/rs_render_params.h"
22 #include "pipeline/rs_context.h"
23 #include "pipeline/rs_canvas_render_node.h"
24 #include "pipeline/rs_dirty_region_manager.h"
25 #include "pipeline/rs_render_node.h"
26 #include "pipeline/rs_surface_render_node.h"
27 #include "skia_adapter/skia_canvas.h"
28 #include "parameters.h"
29 #ifdef NEW_SKIA
30 #include "include/gpu/GrDirectContext.h"
31 #else
32 #include "third_party/flutter/skia/include/gpu/GrContext.h"
33 #endif
34
35 using namespace testing;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace Rosen {
40 const std::string OUT_STR1 =
41 "DISPLAY_NODERS_NODESURFACE_NODECANVAS_NODEROOT_NODEPROXY_NODECANVAS_DRAWING_NODEEFFECT_NODEUNKNOWN_NODE";
42 const std::string OUT_STR2 =
43 "| RS_NODE[0], instanceRootNodeId[0], SharedTransitionParam: [0 -> 0], [nodeGroup1], uifirstRootNodeId_: 1, "
44 "Properties: Bounds[-inf -inf -inf -inf] Frame[-inf -inf -inf -inf], GetBootAnimation: true, "
45 "isContainBootAnimation: true, isNodeDirty: 1, isPropertyDirty: true, isSubTreeDirty: true, IsPureContainer: true, "
46 "Children list needs update, current count: 0 expected count: 0, disappearingChildren: 1\n"
47 " | RS_NODE[0], instanceRootNodeId[0], Properties: Bounds[-inf -inf -inf -inf] Frame[-inf -inf -inf -inf], "
48 "IsPureContainer: true\n";
49 const int DEFAULT_BOUNDS_SIZE = 10;
50 const int DEFAULT_NODE_ID = 1;
51 class RSRenderNodeDrawableAdapterBoy : public DrawableV2::RSRenderNodeDrawableAdapter {
52 public:
RSRenderNodeDrawableAdapterBoy(std::shared_ptr<const RSRenderNode> node)53 explicit RSRenderNodeDrawableAdapterBoy(std::shared_ptr<const RSRenderNode> node)
54 : RSRenderNodeDrawableAdapter(std::move(node))
55 {
56 renderParams_ = std::make_unique<RSRenderParams>(renderNode_.lock()->GetId());
57 uifirstRenderParams_ = std::make_unique<RSRenderParams>(renderNode_.lock()->GetId());
58 }
59 ~RSRenderNodeDrawableAdapterBoy() override = default;
60
Draw(Drawing::Canvas & canvas)61 void Draw(Drawing::Canvas& canvas) override
62 {
63 printf("Draw:GetRecordingState: %d \n", canvas.GetRecordingState());
64 }
65 };
66
67 class RSRenderNodeTest : public testing::Test {
68 public:
69 constexpr static float floatData[] = {
70 0.0f,
71 485.44f,
72 -34.4f,
73 std::numeric_limits<float>::max(),
74 std::numeric_limits<float>::min(),
75 };
76 static void SetUpTestCase();
77 static void TearDownTestCase();
78 void SetUp() override;
79 void TearDown() override;
80 static inline NodeId id;
81 static inline std::weak_ptr<RSContext> context = {};
82 static inline RSPaintFilterCanvas* canvas_;
83 static inline Drawing::Canvas drawingCanvas_;
84 };
85
86 class PropertyDrawableTest : public RSPropertyDrawable {
87 public:
Draw(const RSRenderContent & content,RSPaintFilterCanvas & canvas) const88 void Draw(const RSRenderContent& content, RSPaintFilterCanvas& canvas) const override
89 {
90 return;
91 }
Update(const RSRenderContent & content)92 bool Update(const RSRenderContent& content) override
93 {
94 return false;
95 };
96 };
97
98 class DrawableTest : public RSDrawable {
99 public:
OnUpdate(const RSRenderNode & content)100 bool OnUpdate(const RSRenderNode& content) override
101 {
102 return true;
103 }
CreateDrawFunc() const104 Drawing::RecordingCanvas::DrawFunc CreateDrawFunc() const override
105 {
106 return nullptr;
107 }
OnSync()108 void OnSync() override
109 {
110 return;
111 }
112 };
113
SetUpTestCase()114 void RSRenderNodeTest::SetUpTestCase()
115 {
116 canvas_ = new RSPaintFilterCanvas(&drawingCanvas_);
117 }
TearDownTestCase()118 void RSRenderNodeTest::TearDownTestCase()
119 {
120 delete canvas_;
121 canvas_ = nullptr;
122 }
SetUp()123 void RSRenderNodeTest::SetUp() {}
TearDown()124 void RSRenderNodeTest::TearDown() {}
125
126 /**
127 * @tc.name: UpdateRenderStatus001
128 * @tc.desc: test
129 * @tc.type:FUNC
130 * @tc.require:
131 */
132 HWTEST_F(RSRenderNodeTest, UpdateRenderStatus001, TestSize.Level1)
133 {
134 RSSurfaceRenderNode node(id, context);
135 RectI dirtyRegion;
136 bool isPartialRenderEnabled = false;
137 node.UpdateRenderStatus(dirtyRegion, isPartialRenderEnabled);
138 }
139
140 /**
141 * @tc.name: UpdateParentChildrenRectTest
142 * @tc.desc: test
143 * @tc.type:FUNC
144 * @tc.require:
145 */
146 HWTEST_F(RSRenderNodeTest, UpdateParentChildrenRectTest, TestSize.Level1)
147 {
148 RSRenderNode node(id, context);
149 std::shared_ptr<RSBaseRenderNode> parentNode;
150 node.UpdateParentChildrenRect(parentNode);
151 RSBaseRenderNode rsBaseRenderNode(id, context);
152 ASSERT_FALSE(rsBaseRenderNode.HasChildrenOutOfRect());
153 }
154
155 /**
156 * @tc.name: ProcessTransitionBeforeChildrenTest
157 * @tc.desc: test
158 * @tc.type:FUNC
159 * @tc.require:
160 */
161 HWTEST_F(RSRenderNodeTest, ProcessTransitionBeforeChildrenTest, TestSize.Level1)
162 {
163 RSRenderNode node(id, context);
164 node.ProcessTransitionBeforeChildren(*canvas_);
165 }
166
167 /**
168 * @tc.name: ProcessTransitionBeforeChildrenTest
169 * @tc.desc: test
170 * @tc.type:FUNC
171 * @tc.require:
172 */
173 HWTEST_F(RSRenderNodeTest, AddModifierTest, TestSize.Level1)
174 {
175 std::shared_ptr<RSRenderModifier> modifier = nullptr;
176 RSRenderNode node(id, context);
177 node.AddModifier(modifier);
178 ASSERT_FALSE(node.IsDirty());
179 }
180
181 /**
182 * @tc.name: InitCacheSurfaceTest
183 * @tc.desc: test
184 * @tc.type:FUNC
185 * @tc.require:
186 */
187 HWTEST_F(RSRenderNodeTest, InitCacheSurfaceTest, TestSize.Level1)
188 {
189 RSRenderNode node(id, context);
190 CacheType type = CacheType::ANIMATE_PROPERTY;
191 node.SetCacheType(type);
192 node.InitCacheSurface(canvas_->GetGPUContext().get());
193 }
194
195 /**
196 * @tc.name: DrawCacheSurfaceTest
197 * @tc.desc: test
198 * @tc.type:FUNC
199 * @tc.require:
200 */
201 HWTEST_F(RSRenderNodeTest, DrawCacheSurfaceTest001, TestSize.Level1)
202 {
203 RSRenderNode node(id, context);
204 bool isSubThreadNode = false;
205 node.DrawCacheSurface(*canvas_, isSubThreadNode);
206 if (node.GetCompletedCacheSurface() == nullptr) {
207 ASSERT_EQ(NULL, node.GetCacheSurface());
208 }
209 }
210
211 /**
212 * @tc.name: DrawCacheSurfaceTest002
213 * @tc.desc: test
214 * @tc.type:FUNC
215 * @tc.require:
216 */
217 HWTEST_F(RSRenderNodeTest, DrawCacheSurfaceTest002, TestSize.Level1)
218 {
219 RSRenderNode node(id, context);
220 bool isSubThreadNode = false;
221 CacheType type = CacheType::ANIMATE_PROPERTY;
222 node.SetCacheType(type);
223 node.DrawCacheSurface(*canvas_, isSubThreadNode);
224 ASSERT_EQ(node.GetCompletedCacheSurface(), NULL);
225 }
226
227 /**
228 * @tc.name: SetDrawingCacheTypeTest
229 * @tc.desc: test SetDrawingCacheType for all drawing cache types
230 * @tc.type: FUNC
231 * @tc.require: issueI84LBZ
232 */
233 HWTEST_F(RSRenderNodeTest, SetDrawingCacheTypeTest, TestSize.Level2)
234 {
235 RSRenderNode node(id, context);
236 node.SetDrawingCacheType(RSDrawingCacheType::DISABLED_CACHE);
237 ASSERT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::DISABLED_CACHE);
238 node.SetDrawingCacheType(RSDrawingCacheType::FORCED_CACHE);
239 ASSERT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::FORCED_CACHE);
240 node.SetDrawingCacheType(RSDrawingCacheType::TARGETED_CACHE);
241 ASSERT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::TARGETED_CACHE);
242 }
243
244 /**
245 * @tc.name: ResetFilterRectsInCacheTest
246 * @tc.desc: test ResetFilterRectsInCache api
247 * @tc.type: FUNC
248 * @tc.require: issueI84LBZ
249 */
250 HWTEST_F(RSRenderNodeTest, ResetFilterRectsInCacheTest, TestSize.Level2)
251 {
252 RSRenderNode node(id, context);
253 RSRenderNode cacheNode(id + 1, context);
254 std::unordered_set<NodeId> setRects = {};
255 std::unordered_map<NodeId, std::unordered_set<NodeId>> getRects = {};
256 setRects.insert(cacheNode.GetId());
257
258 node.ResetFilterRectsInCache(setRects);
259 node.GetFilterRectsInCache(getRects);
260 ASSERT_NE(getRects[node.GetId()].size(), 0);
261 }
262
263 /**
264 * @tc.name: ManageDrawingCacheTest001
265 * @tc.desc: SetDrawingCacheChanged and ResetDrawingCacheNeedUpdate test
266 * @tc.type: FUNC
267 * @tc.require: issueI9US6V
268 */
269 HWTEST_F(RSRenderNodeTest, ManageDrawingCacheTest001, TestSize.Level2)
270 {
271 // SetDrawingCacheChanged test
272 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
273 EXPECT_NE(nodeTest, nullptr);
274 std::unique_ptr<RSRenderParams> stagingRenderParams = std::make_unique<RSRenderParams>(0);
275 EXPECT_NE(stagingRenderParams, nullptr);
276 nodeTest->stagingRenderParams_ = std::move(stagingRenderParams);
277
278 nodeTest->lastFrameSynced_ = true;
279 nodeTest->stagingRenderParams_->needSync_ = false;
280 nodeTest->stagingRenderParams_->isDrawingCacheChanged_ = true;
281 nodeTest->SetDrawingCacheChanged(true);
282 EXPECT_TRUE(nodeTest->stagingRenderParams_->needSync_);
283
284 nodeTest->SetDrawingCacheChanged(false);
285 EXPECT_FALSE(nodeTest->stagingRenderParams_->isDrawingCacheChanged_);
286
287 nodeTest->lastFrameSynced_ = false;
288 nodeTest->stagingRenderParams_->needSync_ = false;
289 nodeTest->SetDrawingCacheChanged(true);
290 EXPECT_TRUE(nodeTest->stagingRenderParams_->needSync_);
291 EXPECT_TRUE(nodeTest->stagingRenderParams_->isDrawingCacheChanged_);
292
293 // ResetDrawingCacheNeedUpdate test
294 nodeTest->drawingCacheNeedUpdate_ = true;
295 nodeTest->ResetDrawingCacheNeedUpdate();
296 EXPECT_FALSE(nodeTest->drawingCacheNeedUpdate_);
297
298 // GetDrawingCacheChanged test
299 EXPECT_TRUE(nodeTest->GetDrawingCacheChanged());
300 }
301
302 /**
303 * @tc.name: ResetDrawingCacheNeedUpdateTest001
304 * @tc.desc: test ResetDrawingCacheNeedUpdateTest api
305 * @tc.type: FUNC
306 * @tc.require: issueI84LBZ
307 */
308 HWTEST_F(RSRenderNodeTest, ResetDrawingCacheNeedUpdateTest001, TestSize.Level2)
309 {
310 auto node = std::make_shared<RSRenderNode>(id, context);
311 node->InitRenderParams();
312 bool isDrawingCacheChanged = true;
313
314 node->SetDrawingCacheChanged(isDrawingCacheChanged);
315 node->ResetDrawingCacheNeedUpdate();
316 ASSERT_EQ(node->drawingCacheNeedUpdate_, false);
317 }
318
319 /**
320 * @tc.name: ResetDrawingCacheNeedUpdateTest002
321 * @tc.desc: don't reset DrawingCacheNeedUpdate after set DrawingCacheChanged
322 * @tc.type: FUNC
323 * @tc.require: issueI84LBZ
324 */
325 HWTEST_F(RSRenderNodeTest, ResetDrawingCacheNeedUpdateTest002, TestSize.Level2)
326 {
327 auto node = std::make_shared<RSRenderNode>(id, context);
328 node->InitRenderParams();
329 node->SetDrawingCacheChanged(true);
330 ASSERT_EQ(node->GetDrawingCacheChanged(), true);
331 }
332
333 /**
334 * @tc.name: SetVisitedCacheRootIdsTest
335 * @tc.desc: test SetVisitedCacheRootIds api
336 * @tc.type: FUNC
337 * @tc.require: issueI84LBZ
338 */
339 HWTEST_F(RSRenderNodeTest, SetVisitedCacheRootIdsTest, TestSize.Level2)
340 {
341 RSRenderNode node(id, context);
342 RSRenderNode cacheNode(id + 1, context);
343 std::unordered_set<NodeId> VisitedIds = {};
344 VisitedIds.insert(cacheNode.GetId());
345
346 node.SetVisitedCacheRootIds(VisitedIds);
347 ASSERT_NE(node.GetVisitedCacheRootIds().size(), 0);
348 }
349
350 /**
351 * @tc.name: SetDrawingCacheRootIdTest
352 * @tc.desc: test SetDrawingCacheRootId api
353 * @tc.type: FUNC
354 * @tc.require: issueI84LBZ
355 */
356 HWTEST_F(RSRenderNodeTest, SetDrawingCacheRootIdTest, TestSize.Level2)
357 {
358 RSRenderNode node(id, context);
359 RSRenderNode drawingCacheRootNode(id + 1, context);
360
361 node.SetDrawingCacheRootId(drawingCacheRootNode.GetId());
362 ASSERT_EQ(node.GetDrawingCacheRootId(), drawingCacheRootNode.GetId());
363 }
364
365 /**
366 * @tc.name: SetGeoUpdateDelay01
367 * @tc.desc: test SetGeoUpdateDelay once
368 * @tc.type: FUNC
369 * @tc.require: issueI8JMN8
370 */
371 HWTEST_F(RSRenderNodeTest, SetGeoUpdateDelay01, TestSize.Level2)
372 {
373 RSRenderNode node(id, context);
374 // test default value
375 ASSERT_EQ(node.GetGeoUpdateDelay(), false);
376
377 node.SetGeoUpdateDelay(true);
378 ASSERT_EQ(node.GetGeoUpdateDelay(), true);
379 }
380
381 /**
382 * @tc.name: SetGeoUpdateDelay02
383 * @tc.desc: test SetGeoUpdateDelay would not be covered by later setting
384 * @tc.type: FUNC
385 * @tc.require: issueI8JMN8
386 */
387 HWTEST_F(RSRenderNodeTest, SetGeoUpdateDelay02, TestSize.Level2)
388 {
389 RSRenderNode node(id, context);
390 node.SetGeoUpdateDelay(true);
391 node.SetGeoUpdateDelay(false);
392 ASSERT_EQ(node.GetGeoUpdateDelay(), true);
393 }
394
395 /**
396 * @tc.name: ResetGeoUpdateDelay01
397 * @tc.desc: test SetGeoUpdateDelay would be reset
398 * @tc.type: FUNC
399 * @tc.require: issueI8JMN8
400 */
401 HWTEST_F(RSRenderNodeTest, ResetGeoUpdateDelay01, TestSize.Level2)
402 {
403 RSRenderNode node(id, context);
404 node.SetGeoUpdateDelay(true);
405 node.ResetGeoUpdateDelay();
406 ASSERT_EQ(node.GetGeoUpdateDelay(), false);
407 }
408
409 /**
410 * @tc.name: SetBootAnimationTest
411 * @tc.desc: SetBootAnimation and GetBootAnimation
412 * @tc.type:FUNC
413 * @tc.require:SR000HSUII
414 */
415 HWTEST_F(RSRenderNodeTest, SetBootAnimationTest, TestSize.Level1)
416 {
417 RSRenderNode node(id, context);
418 node.SetBootAnimation(true);
419 ASSERT_EQ(node.GetBootAnimation(), true);
420 node.SetBootAnimation(false);
421 ASSERT_FALSE(node.GetBootAnimation());
422 }
423
424 /**
425 * @tc.name: OnlyBasicGeoTransfromTest01
426 * @tc.desc: Check node only contains BasicGeoTransfrom by default
427 * @tc.type: FUNC
428 * @tc.require: issueI8IXTX
429 */
430 HWTEST_F(RSRenderNodeTest, OnlyBasicGeoTransfromTest01, TestSize.Level1)
431 {
432 RSRenderNode node(id, context);
433 ASSERT_EQ(node.IsOnlyBasicGeoTransform(), true);
434 }
435
436 /**
437 * @tc.name: OnlyBasicGeoTransfromTest02
438 * @tc.desc: Check node contains more than BasicGeoTransfrom if content dirty
439 * @tc.type: FUNC
440 * @tc.require: issueI8IXTX
441 */
442 HWTEST_F(RSRenderNodeTest, OnlyBasicGeoTransfromTest02, TestSize.Level1)
443 {
444 RSRenderNode node(id, context);
445 node.SetContentDirty();
446 ASSERT_EQ(node.IsContentDirty(), true);
447 ASSERT_EQ(node.IsOnlyBasicGeoTransform(), false);
448 }
449
450 /**
451 * @tc.name: OnlyBasicGeoTransfromTest03
452 * @tc.desc: Check node resets BasicGeoTransfrom as true
453 * @tc.type: FUNC
454 * @tc.require: issueI8KEUU
455 */
456 HWTEST_F(RSRenderNodeTest, OnlyBasicGeoTransfromTest03, TestSize.Level1)
457 {
458 RSRenderNode node(id, context);
459 node.SetContentDirty();
460 ASSERT_EQ(node.IsOnlyBasicGeoTransform(), false);
461 node.ResetIsOnlyBasicGeoTransform();
462 ASSERT_EQ(node.IsOnlyBasicGeoTransform(), true);
463 }
464
465 /**
466 * @tc.name: UpdateDirtyRegionTest01
467 * @tc.desc: check dirty region not join when not dirty
468 * @tc.type: FUNC
469 * @tc.require: issueI97LXT
470 */
471 HWTEST_F(RSRenderNodeTest, UpdateDirtyRegionTest01, TestSize.Level1)
472 {
473 RSRenderNode node(id, context);
474 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
475 RectI clipRect{0, 0, 1000, 1000};
476 bool geoDirty = false;
477 node.UpdateDirtyRegion(*rsDirtyManager, geoDirty, clipRect);
478 ASSERT_EQ(rsDirtyManager->GetCurrentFrameDirtyRegion().IsEmpty(), true);
479 }
480
481 /**
482 * @tc.name: UpdateDirtyRegionTest02
483 * @tc.desc: check dirty region not join when not geometry dirty
484 * @tc.type: FUNC
485 * @tc.require: issueI97LXT
486 */
487 HWTEST_F(RSRenderNodeTest, UpdateDirtyRegionTest02, TestSize.Level1)
488 {
489 RSRenderNode node(id, context);
490 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
491 RectI clipRect{0, 0, 1000, 1000};
492 node.SetDirty();
493 node.geometryChangeNotPerceived_ = false;
494 bool geoDirty = false;
495 node.UpdateDirtyRegion(*rsDirtyManager, geoDirty, clipRect);
496 ASSERT_EQ(rsDirtyManager->GetCurrentFrameDirtyRegion().IsEmpty(), true);
497 }
498
499 /**
500 * @tc.name: UpdateDirtyRegionTest03
501 * @tc.desc: check dirty region add successfully
502 * @tc.type: FUNC
503 * @tc.require: issueI97LXT
504 */
505 HWTEST_F(RSRenderNodeTest, UpdateDirtyRegionTest03, TestSize.Level1)
506 {
507 RSRenderNode node(id, context);
508 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
509 rsDirtyManager->SetSurfaceSize(1000, 1000);
510 RectI clipRect{0, 0, 1000, 1000};
511 node.SetDirty();
512 node.shouldPaint_ = true;
513 RectI absRect = RectI{0, 0, 100, 100};
514 auto& properties = node.GetMutableRenderProperties();
515 properties.boundsGeo_ = std::make_shared<RSObjAbsGeometry>();
516 properties.boundsGeo_->absRect_ = absRect;
517 properties.clipToBounds_ = true;
518 bool geoDirty = true;
519 node.UpdateDirtyRegion(*rsDirtyManager, geoDirty, clipRect);
520 bool isDirtyRectCorrect = (rsDirtyManager->GetCurrentFrameDirtyRegion() == absRect);
521 ASSERT_EQ(isDirtyRectCorrect, true);
522 }
523
524 /**
525 * @tc.name: UpdateDirtyRegionTest04
526 * @tc.desc: check shadow dirty region add successfully
527 * @tc.type: FUNC
528 * @tc.require: issueI97LXT
529 */
530 HWTEST_F(RSRenderNodeTest, UpdateDirtyRegionTest04, TestSize.Level1)
531 {
532 RSRenderNode node(id, context);
533 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
534 rsDirtyManager->SetSurfaceSize(1000, 1000);
535 RectI clipRect{0, 0, 1000, 1000};
536 node.SetDirty();
537 node.shouldPaint_ = true;
538 RectI absRect = RectI{0, 0, 100, 100};
539 auto& properties = node.GetMutableRenderProperties();
540 properties.boundsGeo_ = std::make_shared<RSObjAbsGeometry>();
541 properties.boundsGeo_->absRect_ = absRect;
542 properties.clipToBounds_ = true;
543 properties.SetShadowOffsetX(10.0f);
544 properties.SetShadowOffsetY(10.0f);
545 properties.SetShadowRadius(10.0f);
546 bool geoDirty = true;
547 node.UpdateDirtyRegion(*rsDirtyManager, geoDirty, clipRect);
548 ASSERT_EQ(rsDirtyManager->GetCurrentFrameDirtyRegion().IsEmpty(), false);
549 }
550
551 /**
552 * @tc.name: UpdateDirtyRegionTest05
553 * @tc.desc: check outline dirty region add successfully
554 * @tc.type: FUNC
555 * @tc.require: issueI97LXT
556 */
557 HWTEST_F(RSRenderNodeTest, UpdateDirtyRegionTest05, TestSize.Level1)
558 {
559 RSRenderNode node(id, context);
560 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
561 rsDirtyManager->SetSurfaceSize(1000, 1000);
562 RectI clipRect{0, 0, 1000, 1000};
563 node.SetDirty();
564 node.shouldPaint_ = true;
565 RectI absRect = RectI{0, 0, 100, 100};
566 auto& properties = node.GetMutableRenderProperties();
567 properties.boundsGeo_ = std::make_shared<RSObjAbsGeometry>();
568 properties.boundsGeo_->absRect_ = absRect;
569 properties.clipToBounds_ = true;
570 properties.SetOutlineWidth(10.0f);
571 properties.SetOutlineStyle((uint32_t)BorderStyle::SOLID);
572 properties.SetOutlineColor(RSColor(UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX));
573 bool geoDirty = true;
574 node.UpdateDirtyRegion(*rsDirtyManager, geoDirty, clipRect);
575 ASSERT_EQ(rsDirtyManager->GetCurrentFrameDirtyRegion().IsEmpty(), false);
576 }
577
578 /**
579 * @tc.name: GetFilterRectsInCacheTest
580 * @tc.desc:
581 * @tc.type: FUNC
582 * @tc.require: issueI9T3XY
583 */
584 HWTEST_F(RSRenderNodeTest, GetFilterRectsInCacheTest, TestSize.Level1)
585 {
586 RSRenderNode node(id, context);
587 std::unordered_set<NodeId> curRects = { 0, 1 };
588 node.ResetFilterRectsInCache(curRects);
589 EXPECT_TRUE(!node.curCacheFilterRects_.empty());
590 std::unordered_map<NodeId, std::unordered_set<NodeId>> allRects;
591 node.GetFilterRectsInCache(allRects);
592 EXPECT_FALSE(allRects.empty());
593 }
594
595 /**
596 * @tc.name: GetFilterRectTest
597 * @tc.desc:
598 * @tc.type: FUNC
599 * @tc.require: issueI9T3XY
600 */
601 HWTEST_F(RSRenderNodeTest, GetFilterRectTest, TestSize.Level1)
602 {
603 RSRenderNode node(id, context);
604 auto rect = node.GetFilterRect();
605 EXPECT_TRUE(rect.ToString().compare("[0, 0, 0, 0]") == 0);
606
607 std::shared_ptr<RSPath> rsPath = std::make_shared<RSPath>();
608 node.renderContent_->renderProperties_.SetClipBounds(rsPath);
609 auto rect1 = node.GetFilterRect();
610 EXPECT_TRUE(rect1.ToString().compare("[0, 0, 0, 0]") == 0);
611
612 node.renderContent_->renderProperties_.boundsGeo_ = nullptr;
613 auto rect2 = node.GetFilterRect();
614 EXPECT_TRUE(rect2.ToString().compare("[0, 0, 0, 0]") == 0);
615 }
616
617 /**
618 * @tc.name: CalVisibleFilterRectTest
619 * @tc.desc:
620 * @tc.type: FUNC
621 * @tc.require: issueI9T3XY
622 */
623 HWTEST_F(RSRenderNodeTest, CalVisibleFilterRectTest, TestSize.Level1)
624 {
625 RSRenderNode node(id, context);
626 RectI prepareClipRect { 1, 1, 1, 1 };
627 node.CalVisibleFilterRect(prepareClipRect);
628 EXPECT_TRUE(node.filterRegion_.ToString().compare("[0, 0, 0, 0]") == 0);
629 }
630
631 /**
632 * @tc.name: OnTreeStateChangedTest
633 * @tc.desc:
634 * @tc.type: FUNC
635 * @tc.require: issueI9T3XY
636 */
637 HWTEST_F(RSRenderNodeTest, OnTreeStateChangedTest, TestSize.Level1)
638 {
639 RSRenderNode node(id, context); // isOnTheTree_ false
640 std::shared_ptr<RSFilter> filter = RSFilter::CreateBlurFilter(floatData[0], floatData[1]);
641 node.renderContent_->renderProperties_.SetFilter(filter);
642 node.OnTreeStateChanged();
643 EXPECT_FALSE(node.isOnTheTree_);
644 EXPECT_TRUE(node.HasBlurFilter());
645
646 std::shared_ptr<RSRenderNode> inNode = std::make_shared<RSBaseRenderNode>(id, context);
647 std::shared_ptr<RSRenderNode> outNode = std::make_shared<RSBaseRenderNode>(id + 1, context);
648 auto sharedTransitionParam = std::make_shared<SharedTransitionParam>(inNode, outNode);
649 node.SetSharedTransitionParam(sharedTransitionParam);
650 node.OnTreeStateChanged();
651 EXPECT_FALSE(node.sharedTransitionParam_->paired_);
652
653 node.isOnTheTree_ = true;
654 node.OnTreeStateChanged();
655 EXPECT_TRUE(node.IsDirty());
656 }
657
658 /**
659 * @tc.name: HasDisappearingTransitionTest
660 * @tc.desc:
661 * @tc.type: FUNC
662 * @tc.require: issueI9T3XY
663 */
664 HWTEST_F(RSRenderNodeTest, HasDisappearingTransitionTest, TestSize.Level1)
665 {
666 auto node = std::make_shared<RSRenderNode>(id, context);
667 node->disappearingTransitionCount_ = 1;
668 node->isOnTheTree_ = true;
669 EXPECT_TRUE(node->HasDisappearingTransition(true));
670 node->disappearingTransitionCount_ = 0;
671 EXPECT_FALSE(node->HasDisappearingTransition(false));
672 auto node1 = std::make_shared<RSRenderNode>(id + 1, context);
673 auto parent = node1->weak_from_this();
674 node->SetParent(parent);
675 EXPECT_FALSE(node->HasDisappearingTransition(true));
676 }
677
678 /**
679 * @tc.name: GenerateFullChildrenListTest
680 * @tc.desc:
681 * @tc.type: FUNC
682 * @tc.require: issueI9T3XY
683 */
684 HWTEST_F(RSRenderNodeTest, GenerateFullChildrenListTest, TestSize.Level1)
685 {
686 auto node = std::make_shared<RSRenderNode>(id, context);
687 node->GenerateFullChildrenList();
688 EXPECT_TRUE(node->isChildrenSorted_ && node->children_.empty() && node->disappearingChildren_.empty());
689
690 // children_ isn't empty
691 std::weak_ptr<RSRenderNode> wNode1;
692 node->children_.emplace_back(wNode1); // wNode1 is nullptr
693 node->GenerateFullChildrenList();
694 EXPECT_TRUE(node->children_.empty());
695 std::shared_ptr<RSRenderNode> sNode1 = std::make_shared<RSRenderNode>(id, context);
696 sNode1->isBootAnimation_ = false;
697 wNode1 = sNode1;
698 node->children_.emplace_back(wNode1); // wNode1 isn't nullptr
699
700 node->isContainBootAnimation_ = true;
701 node->GenerateFullChildrenList();
702 EXPECT_TRUE(!node->children_.empty());
703
704 node->isContainBootAnimation_ = false;
705 node->GenerateFullChildrenList();
706 EXPECT_TRUE(!node->children_.empty());
707
708 // disappearingChildren_ isn't empty
709 node->disappearingChildren_.emplace_back(sNode1, id);
710 node->GenerateFullChildrenList();
711 EXPECT_FALSE(node->isContainBootAnimation_);
712
713 node->isContainBootAnimation_ = true;
714 node->GenerateFullChildrenList();
715 EXPECT_TRUE(node->isContainBootAnimation_);
716 }
717
718 /**
719 * @tc.name: ResortChildrenTest
720 * @tc.desc:
721 * @tc.type: FUNC
722 * @tc.require: issueI9T3XY
723 */
724 HWTEST_F(RSRenderNodeTest, ResortChildrenTest, TestSize.Level1)
725 {
726 auto node = std::make_shared<RSRenderNode>(id, context);
727 auto node1 = std::make_shared<RSRenderNode>(id + 1, context);
728 auto node2 = std::make_shared<RSRenderNode>(id + 2, context);
729 auto fullChildrenList = std::make_shared<std::vector<std::shared_ptr<RSRenderNode>>>();
730 fullChildrenList->emplace_back(std::move(node1));
731 fullChildrenList->emplace_back(std::move(node2));
732 node->fullChildrenList_ = fullChildrenList;
733 node->isChildrenSorted_ = false;
734 EXPECT_TRUE(!node->fullChildrenList_->empty());
735 node->ResortChildren();
736 EXPECT_TRUE(node->isChildrenSorted_);
737 }
738
739 /**
740 * @tc.name: HasChildrenOutOfRectTest
741 * @tc.desc:
742 * @tc.type: FUNC
743 * @tc.require: issueI9T3XY
744 */
745 HWTEST_F(RSRenderNodeTest, HasChildrenOutOfRectTest, TestSize.Level1)
746 {
747 auto node = std::make_shared<RSRenderNode>(id, context);
748 node->hasChildrenOutOfRect_ = true;
749 EXPECT_TRUE(node->HasChildrenOutOfRect());
750 node->renderContent_->renderProperties_.clipToBounds_ = true;
751 EXPECT_TRUE(node->GetRenderProperties().GetClipToBounds());
752 EXPECT_FALSE(node->HasChildrenOutOfRect());
753 }
754
755 /**
756 * @tc.name: UpdateVisibleFilterChildTest
757 * @tc.desc:
758 * @tc.type: FUNC
759 * @tc.require: issueI9T3XY
760 */
761 HWTEST_F(RSRenderNodeTest, UpdateVisibleFilterChildTest, TestSize.Level1)
762 {
763 auto node = std::make_shared<RSRenderNode>(id, context);
764 auto childNode = std::make_shared<RSRenderNode>(id + 1, context);
765 childNode->GetMutableRenderProperties().needFilter_ = true;
766 EXPECT_TRUE(childNode->GetRenderProperties().NeedFilter());
767 node->UpdateVisibleFilterChild(*childNode);
768 EXPECT_TRUE(!node->visibleFilterChild_.empty());
769 }
770
771 /**
772 * @tc.name: UpdateVisibleEffectChildTest
773 * @tc.desc:
774 * @tc.type: FUNC
775 * @tc.require: issueI9T3XY
776 */
777 HWTEST_F(RSRenderNodeTest, UpdateVisibleEffectChildTest, TestSize.Level1)
778 {
779 auto node = std::make_shared<RSRenderNode>(id, context);
780 auto childNode = std::make_shared<RSRenderNode>(id + 1, context);
781 childNode->GetMutableRenderProperties().useEffect_ = true;
782 EXPECT_TRUE(childNode->GetRenderProperties().GetUseEffect());
783 node->UpdateVisibleEffectChild(*childNode);
784 EXPECT_TRUE(!node->visibleEffectChild_.empty());
785 }
786
787 /**
788 * @tc.name: GetInstanceRootNodeTest
789 * @tc.desc:
790 * @tc.type: FUNC
791 * @tc.require: issueI9T3XY
792 */
793 HWTEST_F(RSRenderNodeTest, GetInstanceRootNodeTest, TestSize.Level1)
794 {
795 auto node = std::make_shared<RSRenderNode>(id, context);
796 auto retNode = node->GetInstanceRootNode();
797 EXPECT_TRUE(retNode == nullptr);
798 auto sContext = std::make_shared<RSContext>();
799 node->context_ = sContext;
800 node->GetInstanceRootNode();
801 EXPECT_TRUE(node->GetContext().lock() != nullptr);
802 }
803
804 /**
805 * @tc.name: UpdateTreeUifirstRootNodeIdTest
806 * @tc.desc:
807 * @tc.type: FUNC
808 * @tc.require: issueI9T3XY
809 */
810 HWTEST_F(RSRenderNodeTest, UpdateTreeUifirstRootNodeIdTest, TestSize.Level1)
811 {
812 auto node = std::make_shared<RSRenderNode>(id, context);
813 auto childId = id + 1;
814 auto childNode = std::make_shared<RSRenderNode>(childId, context);
815 auto fullChildrenList = std::make_shared<std::vector<std::shared_ptr<RSRenderNode>>>();
816 fullChildrenList->emplace_back(std::move(childNode));
817 node->fullChildrenList_ = fullChildrenList;
818 node->UpdateTreeUifirstRootNodeId(childId);
819 EXPECT_TRUE(node->uifirstRootNodeId_ == childId);
820 for (auto& child : *node->GetChildren()) {
821 EXPECT_TRUE(child != nullptr);
822 }
823 }
824
825 /**
826 * @tc.name: GetFirstLevelNodeTest
827 * @tc.desc:
828 * @tc.type: FUNC
829 * @tc.require: issueI9T3XY
830 */
831 HWTEST_F(RSRenderNodeTest, GetFirstLevelNodeTest, TestSize.Level1)
832 {
833 auto node = std::make_shared<RSRenderNode>(id, context);
834 auto retNode = node->GetFirstLevelNode();
835 EXPECT_TRUE(retNode == nullptr);
836 auto sContext = std::make_shared<RSContext>();
837 node->context_ = sContext;
838 node->GetFirstLevelNode();
839 EXPECT_TRUE(node->GetContext().lock() != nullptr);
840 }
841
842 /**
843 * @tc.name: UpdateCompletedCacheSurfaceTest
844 * @tc.desc:
845 * @tc.type: FUNC
846 * @tc.require: issueI9T3XY
847 */
848 HWTEST_F(RSRenderNodeTest, UpdateCompletedCacheSurfaceTest, TestSize.Level1)
849 {
850 auto node = std::make_shared<RSRenderNode>(id, context);
851 auto cacheId = 1;
852 auto completeId = 2;
853 node->cacheSurfaceThreadIndex_ = cacheId;
854 node->completedSurfaceThreadIndex_ = completeId;
855 node->UpdateCompletedCacheSurface();
856 EXPECT_TRUE(cacheId == node->completedSurfaceThreadIndex_);
857 }
858
859 /**
860 * @tc.name: ClearCacheSurfaceTest
861 * @tc.desc:
862 * @tc.type: FUNC
863 * @tc.require: issueI9T3XY
864 */
865 HWTEST_F(RSRenderNodeTest, ClearCacheSurfaceTest, TestSize.Level1)
866 {
867 auto node = std::make_shared<RSRenderNode>(id, context);
868 node->cacheCompletedSurface_ = std::make_shared<Drawing::Surface>();
869 node->ClearCacheSurface();
870 EXPECT_TRUE(node->cacheCompletedSurface_ == nullptr);
871 }
872
873 /**
874 * @tc.name: SetGeoUpdateDelayTest
875 * @tc.desc:
876 * @tc.type: FUNC
877 * @tc.require: issueI9T3XY
878 */
879 HWTEST_F(RSRenderNodeTest, SetGeoUpdateDelayTest, TestSize.Level1)
880 {
881 auto node = std::make_shared<RSRenderNode>(id, context);
882 EXPECT_FALSE(node->geoUpdateDelay_);
883 node->SetGeoUpdateDelay(true);
884 EXPECT_TRUE(node->geoUpdateDelay_);
885 }
886
887 /**
888 * @tc.name: StoreMustRenewedInfoTest
889 * @tc.desc:
890 * @tc.type: FUNC
891 * @tc.require: issueI9T3XY
892 */
893 HWTEST_F(RSRenderNodeTest, StoreMustRenewedInfoTest, TestSize.Level1)
894 {
895 auto node = std::make_shared<RSRenderNode>(id, context);
896 node->hasHardwareNode_ = true;
897 EXPECT_FALSE(node->mustRenewedInfo_);
898 node->StoreMustRenewedInfo();
899 EXPECT_TRUE(node->mustRenewedInfo_);
900
901 node->mustRenewedInfo_ = false;
902 node->hasHardwareNode_ = false;
903 node->childHasVisibleFilter_ = true;
904 node->StoreMustRenewedInfo();
905 EXPECT_TRUE(node->mustRenewedInfo_);
906
907 node->mustRenewedInfo_ = false;
908 node->childHasVisibleFilter_ = false;
909 node->childHasVisibleEffect_ = true;
910 node->StoreMustRenewedInfo();
911 EXPECT_TRUE(node->mustRenewedInfo_);
912 }
913
914 /**
915 * @tc.name: UpdateSubSurfaceCntTest
916 * @tc.desc: test addChild and removeChild
917 * @tc.type: FUNC
918 * @tc.require: issueBAYJG
919 */
920 HWTEST_F(RSRenderNodeTest, UpdateSubSurfaceCntTest001, TestSize.Level1)
921 {
922 const int cnt = 0;
923 auto rootNode = std::make_shared<RSRenderNode>(DEFAULT_NODE_ID);
924
925 auto leashNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_NODE_ID + 1);
926 leashNode->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
927 rootNode->AddChild(leashNode);
928 rootNode->UpdateSubSurfaceCnt(leashNode->subSurfaceCnt_);
929 EXPECT_EQ(rootNode->subSurfaceCnt_, cnt + 1);
930
931 auto selfDrawNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_NODE_ID + 2);
932 selfDrawNode->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
933 leashNode->AddChild(selfDrawNode);
934 leashNode->UpdateSubSurfaceCnt(selfDrawNode->subSurfaceCnt_);
935 EXPECT_EQ(rootNode->subSurfaceCnt_, cnt + 1);
936
937 rootNode->RemoveChild(leashNode);
938 rootNode->UpdateSubSurfaceCnt(-leashNode->subSurfaceCnt_);
939 EXPECT_EQ(rootNode->subSurfaceCnt_, cnt);
940 }
941
942 /**
943 * @tc.name: UpdateSubSurfaceCntTest
944 * @tc.desc: test addChild and loop
945 * @tc.type: FUNC
946 * @tc.require: issueBAYJG
947 */
948 HWTEST_F(RSRenderNodeTest, UpdateSubSurfaceCntTest002, TestSize.Level1)
949 {
950 const int cnt = 0;
951 auto rootNode = std::make_shared<RSRenderNode>(DEFAULT_NODE_ID);
952
953 auto leashNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_NODE_ID + 1);
954 leashNode->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
955 rootNode->AddChild(leashNode);
956 rootNode->UpdateSubSurfaceCnt(leashNode->subSurfaceCnt_);
957 EXPECT_EQ(rootNode->subSurfaceCnt_, cnt + 1);
958
959 auto appNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_NODE_ID + 2);
960 appNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
961 leashNode->AddChild(appNode);
962 leashNode->UpdateSubSurfaceCnt(appNode->subSurfaceCnt_);
963 EXPECT_EQ(rootNode->subSurfaceCnt_, cnt + 2);
964
965 auto antherApp = std::make_shared<RSSurfaceRenderNode>(DEFAULT_NODE_ID + 3);
966 antherApp->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
967 appNode->AddChild(antherApp);
968 appNode->UpdateSubSurfaceCnt(antherApp->subSurfaceCnt_);
969 EXPECT_EQ(rootNode->subSurfaceCnt_, cnt + 3);
970
971 // loop tree
972 antherApp->AddChild(leashNode);
973 antherApp->UpdateSubSurfaceCnt(antherApp->subSurfaceCnt_);
974 EXPECT_EQ(rootNode->subSurfaceCnt_, cnt + 3);
975 }
976
977 /**
978 * @tc.name: GetNodeGroupTypeTest
979 * @tc.desc:
980 * @tc.type: FUNC
981 * @tc.require: issueI9T3XY
982 */
983 HWTEST_F(RSRenderNodeTest, GetNodeGroupTypeTest, TestSize.Level1)
984 {
985 auto node = std::make_shared<RSRenderNode>(id, context);
986 auto retType = node->GetNodeGroupType();
987 EXPECT_EQ(retType, RSRenderNode::NodeGroupType::NONE);
988 node->nodeGroupType_ = RSRenderNode::NodeGroupType::GROUP_TYPE_BUTT;
989 retType = node->GetNodeGroupType();
990 EXPECT_EQ(retType, RSRenderNode::NodeGroupType::GROUP_TYPE_BUTT);
991 }
992
993 /**
994 * @tc.name: InitRenderParamsTest
995 * @tc.desc:
996 * @tc.type: FUNC
997 * @tc.require: issueI9T3XY
998 */
999 HWTEST_F(RSRenderNodeTest, InitRenderParamsTest, TestSize.Level1)
1000 {
1001 auto node = std::make_shared<RSRenderNode>(id, context);
1002 node->InitRenderParams();
1003 EXPECT_TRUE(node->renderDrawable_ == nullptr);
1004 }
1005
1006 /**
1007 * @tc.name: UpdateRenderParamsTest
1008 * @tc.desc:
1009 * @tc.type: FUNC
1010 * @tc.require: issueI9T3XY
1011 */
1012 HWTEST_F(RSRenderNodeTest, UpdateRenderParamsTest, TestSize.Level1)
1013 {
1014 auto node = std::make_shared<RSRenderNode>(id, context);
1015
1016 node->stagingRenderParams_ = std::make_unique<RSRenderParams>(node->id_);
1017 node->UpdateRenderParams();
1018 EXPECT_TRUE(node->GetRenderProperties().GetSandBox() == std::nullopt);
1019
1020 node->GetMutableRenderProperties().sandbox_ = std::make_unique<Sandbox>();
1021 Vector2f vec2f(floatData[0], floatData[1]);
1022 node->GetMutableRenderProperties().sandbox_->position_ = vec2f;
1023 node->UpdateRenderParams();
1024 EXPECT_TRUE(node->GetRenderProperties().GetSandBox() != std::nullopt);
1025
1026 node->GetMutableRenderProperties().boundsGeo_ = nullptr;
1027 node->UpdateRenderParams();
1028 EXPECT_TRUE(node->GetRenderProperties().GetBoundsGeometry() == nullptr);
1029 }
1030
1031 /**
1032 * @tc.name: UpdateCurCornerRadiusTest
1033 * @tc.desc:
1034 * @tc.type: FUNC
1035 * @tc.require: issueI9T3XY
1036 */
1037 HWTEST_F(RSRenderNodeTest, UpdateCurCornerRadiusTest, TestSize.Level1)
1038 {
1039 auto node = std::make_shared<RSRenderNode>(id, context);
1040 auto maxFloatData = std::numeric_limits<float>::max();
1041 auto minFloatData = std::numeric_limits<float>::min();
1042 Vector4f curCornerRadius(floatData[0], floatData[1], floatData[2], minFloatData);
1043 Vector4f cornerRadius(floatData[0], floatData[1], floatData[2], maxFloatData);
1044 node->GetMutableRenderProperties().SetCornerRadius(cornerRadius);
1045 node->UpdateCurCornerRadius(curCornerRadius);
1046 EXPECT_TRUE(curCornerRadius[3] == maxFloatData);
1047 }
1048
1049 /**
1050 * @tc.name: UpdateSrcOrClipedAbsDrawRectChangeStateTest
1051 * @tc.desc:
1052 * @tc.type: FUNC
1053 * @tc.require: issueIAZV18
1054 */
1055 HWTEST_F(RSRenderNodeTest, UpdateSrcOrClipedAbsDrawRectChangeStateTest, TestSize.Level1)
1056 {
1057 auto node = std::make_shared<RSRenderNode>(id, context);
1058 auto left = 0;
1059 auto top = 0;
1060 auto width = 1920;
1061 auto height = 1048;
1062 RectI rectI(left, top, width, height);
1063
1064 node->srcOrClipedAbsDrawRectChangeFlag_ = true;
1065 node->UpdateSrcOrClipedAbsDrawRectChangeState(rectI);
1066 EXPECT_FALSE(node->geometryChangeNotPerceived_);
1067
1068 EXPECT_EQ(RSSystemProperties::GetSkipGeometryNotChangeEnabled(), true);
1069 node->srcOrClipedAbsDrawRectChangeFlag_ = true;
1070 node->geometryChangeNotPerceived_ = true;
1071 node->UpdateSrcOrClipedAbsDrawRectChangeState(rectI);
1072 EXPECT_FALSE(node->srcOrClipedAbsDrawRectChangeFlag_);
1073 }
1074
1075 /**
1076 * @tc.name: OnSyncTest
1077 * @tc.desc: OnSync Test
1078 * @tc.type: FUNC
1079 * @tc.require: issueIA5Y41
1080 */
1081 HWTEST_F(RSRenderNodeTest, OnSyncTest, TestSize.Level1)
1082 {
1083 std::shared_ptr<RSRenderNode> node = std::make_shared<RSRenderNode>(0);
1084 EXPECT_NE(node, nullptr);
1085 node->renderDrawable_ = nullptr;
1086 node->OnSync();
1087
1088 std::shared_ptr<RSRenderNode> child = std::make_shared<RSRenderNode>(0);
1089 EXPECT_NE(child, nullptr);
1090
1091 node->renderDrawable_ = std::make_shared<RSRenderNodeDrawableAdapterBoy>(child);
1092 EXPECT_NE(node->renderDrawable_, nullptr);
1093
1094 node->drawCmdListNeedSync_ = true;
1095 node->stagingRenderParams_ = std::make_unique<RSRenderParams>(0);
1096 EXPECT_NE(node->stagingRenderParams_, nullptr);
1097
1098 node->stagingRenderParams_->needSync_ = true;
1099 node->renderDrawable_->renderParams_ = std::make_unique<RSRenderParams>(0);
1100 EXPECT_NE(node->renderDrawable_->renderParams_, nullptr);
1101
1102 node->uifirstNeedSync_ = true;
1103 node->renderDrawable_->uifirstRenderParams_ = std::make_unique<RSRenderParams>(0);
1104 EXPECT_NE(node->renderDrawable_->uifirstRenderParams_, nullptr);
1105
1106 node->uifirstSkipPartialSync_ = false;
1107 node->dirtySlots_.emplace(RSDrawableSlot::BACKGROUND_FILTER);
1108 auto drawableFilter = std::make_shared<DrawableV2::RSForegroundFilterDrawable>();
1109 EXPECT_NE(drawableFilter, nullptr);
1110
1111 node->drawableVec_[static_cast<uint32_t>(RSDrawableSlot::BACKGROUND_FILTER)] = drawableFilter;
1112 node->drawingCacheType_ = RSDrawingCacheType::FORCED_CACHE;
1113 node->stagingRenderParams_->freezeFlag_ = true;
1114 node->needClearSurface_ = true;
__anond072ea200102() 1115 std::function<void()> clearTask = []() { printf("ClearSurfaceTask CallBack\n"); };
1116 node->isOpincRootFlag_ = true;
1117 node->OnSync();
1118 EXPECT_TRUE(node->dirtySlots_.empty());
1119 EXPECT_FALSE(node->drawCmdListNeedSync_);
1120 EXPECT_FALSE(node->uifirstNeedSync_);
1121 EXPECT_FALSE(node->needClearSurface_);
1122 }
1123
1124 /**
1125 * @tc.name: ValidateLightResourcesTest
1126 * @tc.desc:
1127 * @tc.type: FUNC
1128 * @tc.require: issueI9T3XY
1129 */
1130 HWTEST_F(RSRenderNodeTest, ValidateLightResourcesTest, TestSize.Level1)
1131 {
1132 auto node = std::make_shared<RSRenderNode>(id, context);
1133 auto& properties = node->GetMutableRenderProperties();
1134 properties.lightSourcePtr_ = std::make_shared<RSLightSource>();
1135 properties.lightSourcePtr_->intensity_ = floatData[1];
1136 EXPECT_TRUE(properties.lightSourcePtr_->IsLightSourceValid());
1137 properties.illuminatedPtr_ = std::make_shared<RSIlluminated>();
1138 properties.illuminatedPtr_->illuminatedType_ = IlluminatedType::BORDER;
1139 EXPECT_TRUE(properties.illuminatedPtr_->IsIlluminatedValid());
1140 node->ValidateLightResources();
1141 }
1142
1143 /**
1144 * @tc.name: UpdatePointLightDirtySlotTest
1145 * @tc.desc:
1146 * @tc.type: FUNC
1147 * @tc.require: issueI9T3XY
1148 */
1149 HWTEST_F(RSRenderNodeTest, UpdatePointLightDirtySlotTest, TestSize.Level1)
1150 {
1151 RSRenderNode node(id, context);
1152 EXPECT_TRUE(node.dirtySlots_.empty());
1153 node.UpdateDirtySlotsAndPendingNodes(RSDrawableSlot::MASK);
1154 EXPECT_FALSE(node.dirtySlots_.empty());
1155 }
1156 /**
1157 * @tc.name: AddToPendingSyncListTest
1158 * @tc.desc:
1159 * @tc.type: FUNC
1160 * @tc.require: issueI9T3XY
1161 */
1162 HWTEST_F(RSRenderNodeTest, AddToPendingSyncListTest, TestSize.Level1)
1163 {
1164 auto sContext = std::make_shared<RSContext>();
1165 context = sContext;
1166 auto node = std::make_shared<RSRenderNode>(id, context);
1167 node->addedToPendingSyncList_ = true;
1168 node->AddToPendingSyncList();
1169 EXPECT_TRUE(node->addedToPendingSyncList_);
1170 node->addedToPendingSyncList_ = false;
1171 node->AddToPendingSyncList();
1172 EXPECT_TRUE(node->addedToPendingSyncList_);
1173 node->context_.reset();
1174 node->addedToPendingSyncList_ = false;
1175 node->AddToPendingSyncList();
1176 EXPECT_FALSE(node->addedToPendingSyncList_);
1177 }
1178
1179 /**
1180 * @tc.name: SetChildrenHasSharedTransitionTest
1181 * @tc.desc:
1182 * @tc.type: FUNC
1183 * @tc.require: issueI9T3XY
1184 */
1185 HWTEST_F(RSRenderNodeTest, SetChildrenHasSharedTransitionTest, TestSize.Level1)
1186 {
1187 RSRenderNode node(id, context);
1188 node.SetChildrenHasSharedTransition(true);
1189 EXPECT_TRUE(node.childrenHasSharedTransition_);
1190 }
1191
1192 /**
1193 * @tc.name: GetPairedNodeTest
1194 * @tc.desc:
1195 * @tc.type: FUNC
1196 * @tc.require: issueI9T3XY
1197 */
1198 HWTEST_F(RSRenderNodeTest, GetPairedNodeTest, TestSize.Level1)
1199 {
1200 std::shared_ptr<RSRenderNode> inNode = std::make_shared<RSBaseRenderNode>(id + 1, context);
1201 std::shared_ptr<RSRenderNode> outNode = std::make_shared<RSBaseRenderNode>(id + 2, context);
1202 auto sharedTransitionParam = std::make_shared<SharedTransitionParam>(inNode, outNode);
1203 auto ptr = sharedTransitionParam->GetPairedNode(id + 1);
1204 EXPECT_TRUE(ptr == outNode);
1205 ptr = sharedTransitionParam->GetPairedNode(id + 2);
1206 EXPECT_TRUE(ptr == inNode);
1207 ptr = sharedTransitionParam->GetPairedNode(id);
1208 EXPECT_FALSE(ptr);
1209 }
1210
1211 /**
1212 @tc.name: UpdateAbsDrawRect
1213 @tc.desc: update node absrect.
1214 @tc.type: FUNC
1215 @tc.require: issueIAL4RE
1216 */
1217 HWTEST_F(RSRenderNodeTest, UpdateAbsDrawRect, TestSize.Level1)
1218 {
1219 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1220 EXPECT_NE(nodeTest, nullptr);
1221 std::unique_ptr<RSRenderParams> stagingRenderParams = std::make_unique<RSRenderParams>(0);
1222 EXPECT_NE(stagingRenderParams, nullptr);
1223 nodeTest->stagingRenderParams_ = std::move(stagingRenderParams);
1224 RectI absRect = {10, 10, 10, 10};
1225 nodeTest->stagingRenderParams_->SetAbsDrawRect(absRect);
1226 ASSERT_TRUE(true);
1227 }
1228
1229 /**
1230 * @tc.name: UpdateHierarchyAndReturnIsLowerTest
1231 * @tc.desc:
1232 * @tc.type: FUNC
1233 * @tc.require: issueI9T3XY
1234 */
1235 HWTEST_F(RSRenderNodeTest, UpdateHierarchyAndReturnIsLowerTest, TestSize.Level1)
1236 {
1237 auto inNodeId = id + 1;
1238 auto outNodeId = id + 2;
1239 auto otherNodeId = id + 3;
1240 std::shared_ptr<RSRenderNode> inNode = std::make_shared<RSBaseRenderNode>(inNodeId, context);
1241 std::shared_ptr<RSRenderNode> outNode = std::make_shared<RSBaseRenderNode>(outNodeId, context);
1242 auto sharedTransitionParam = std::make_shared<SharedTransitionParam>(inNode, outNode);
1243 sharedTransitionParam->relation_ = SharedTransitionParam::NodeHierarchyRelation::IN_NODE_BELOW_OUT_NODE;
1244 auto ret = sharedTransitionParam->UpdateHierarchyAndReturnIsLower(inNodeId);
1245 EXPECT_TRUE(ret);
1246 sharedTransitionParam->relation_ = SharedTransitionParam::NodeHierarchyRelation::IN_NODE_ABOVE_OUT_NODE;
1247 ret = sharedTransitionParam->UpdateHierarchyAndReturnIsLower(outNodeId);
1248 EXPECT_TRUE(ret);
1249 sharedTransitionParam->relation_ = SharedTransitionParam::NodeHierarchyRelation::UNKNOWN;
1250 ret = sharedTransitionParam->UpdateHierarchyAndReturnIsLower(otherNodeId);
1251 EXPECT_FALSE(ret);
1252 EXPECT_EQ(sharedTransitionParam->relation_, SharedTransitionParam::NodeHierarchyRelation::UNKNOWN);
1253
1254 ret = sharedTransitionParam->UpdateHierarchyAndReturnIsLower(outNodeId);
1255 EXPECT_EQ(sharedTransitionParam->relation_, SharedTransitionParam::NodeHierarchyRelation::IN_NODE_ABOVE_OUT_NODE);
1256
1257 sharedTransitionParam->relation_ = SharedTransitionParam::NodeHierarchyRelation::UNKNOWN;
1258 ret = sharedTransitionParam->UpdateHierarchyAndReturnIsLower(inNodeId);
1259 EXPECT_EQ(sharedTransitionParam->relation_, SharedTransitionParam::NodeHierarchyRelation::IN_NODE_BELOW_OUT_NODE);
1260 }
1261
1262 /**
1263 * @tc.name: ResetRelation
1264 * @tc.desc:
1265 * @tc.type: FUNC
1266 * @tc.require: issueI9T3XY
1267 */
1268 HWTEST_F(RSRenderNodeTest, ResetRelationTest, TestSize.Level1)
1269 {
1270 std::shared_ptr<RSRenderNode> inNode = std::make_shared<RSBaseRenderNode>(id + 1, context);
1271 std::shared_ptr<RSRenderNode> outNode = std::make_shared<RSBaseRenderNode>(id + 2, context);
1272 auto sharedTransitionParam = std::make_shared<SharedTransitionParam>(inNode, outNode);
1273
1274 (void)sharedTransitionParam->UpdateHierarchyAndReturnIsLower(inNode->GetId());
1275 EXPECT_NE(sharedTransitionParam->relation_, SharedTransitionParam::NodeHierarchyRelation::UNKNOWN);
1276
1277 sharedTransitionParam->ResetRelation();
1278 EXPECT_EQ(sharedTransitionParam->relation_, SharedTransitionParam::NodeHierarchyRelation::UNKNOWN);
1279 }
1280
1281 /**
1282 * @tc.name: DumpTest
1283 * @tc.desc:
1284 * @tc.type: FUNC
1285 * @tc.require: issueI9T3XY
1286 */
1287 HWTEST_F(RSRenderNodeTest, DumpTest, TestSize.Level1)
1288 {
1289 std::shared_ptr<RSRenderNode> inNode = std::make_shared<RSBaseRenderNode>(id + 1, context);
1290 std::shared_ptr<RSRenderNode> outNode = std::make_shared<RSBaseRenderNode>(id + 2, context);
1291 auto sharedTransitionParam = std::make_shared<SharedTransitionParam>(inNode, outNode);
1292 auto dumpStr = sharedTransitionParam->Dump();
1293
1294 EXPECT_FALSE(dumpStr.empty());
1295 }
1296
1297 /**
1298 * @tc.name: InternalUnregisterSelfTest
1299 * @tc.desc:
1300 * @tc.type: FUNC
1301 * @tc.require: issueI9T3XY
1302 */
1303 HWTEST_F(RSRenderNodeTest, InternalUnregisterSelfTest, TestSize.Level1)
1304 {
1305 std::shared_ptr<RSRenderNode> inNode = std::make_shared<RSBaseRenderNode>(id + 1, context);
1306 std::shared_ptr<RSRenderNode> outNode = std::make_shared<RSBaseRenderNode>(id + 2, context);
1307 auto sharedTransitionParam = std::make_shared<SharedTransitionParam>(inNode, outNode);
1308 sharedTransitionParam->InternalUnregisterSelf();
1309
1310 ASSERT_FALSE(inNode->sharedTransitionParam_);
1311 ASSERT_FALSE(outNode->sharedTransitionParam_);
1312 }
1313
1314 /**
1315 * @tc.name: RSRenderNodeDirtyTest001
1316 * @tc.desc: SetDirty OnRegisterTest SetParentSubTreeDirty and InitRenderParams test
1317 * @tc.type: FUNC
1318 * @tc.require: issueI9US6V
1319 */
1320 HWTEST_F(RSRenderNodeTest, RSRenderNodeDirtyTest001, TestSize.Level1)
1321 {
1322 std::shared_ptr<RSContext> contextTest1 = nullptr;
1323 RSRenderNode nodetest1(0, contextTest1);
1324 // SetDirty test
1325 std::shared_ptr<RSRenderNode> parent = std::make_shared<RSRenderNode>(0);
1326 EXPECT_NE(parent, nullptr);
1327 parent->isSubTreeDirty_ = false;
1328 nodetest1.parent_ = parent;
1329 nodetest1.dirtyStatus_ = RSRenderNode::NodeDirty::CLEAN;
1330 // dirtyStatus_ is NodeDirty::CLEAN
1331 nodetest1.SetDirty(true);
1332 EXPECT_EQ(nodetest1.dirtyStatus_, RSRenderNode::NodeDirty::DIRTY);
1333 // dirtyStatus_ is not NodeDirty::CLEAN
1334 nodetest1.SetDirty(true);
1335 EXPECT_TRUE(parent->isSubTreeDirty_);
1336
1337 // OnRegister and InitRenderParams test
1338 std::shared_ptr<RSContext> contextTest2 = std::make_shared<RSContext>();
1339 EXPECT_NE(contextTest2, nullptr);
1340 std::shared_ptr<RSRenderNode> nodeTest2 = std::make_shared<RSRenderNode>(0, contextTest2);
1341 EXPECT_NE(nodeTest2, nullptr);
1342 nodeTest2->renderDrawable_ = nullptr;
1343 std::shared_ptr<RSContext> contextTest3 = std::make_shared<RSContext>();
1344 EXPECT_NE(contextTest3, nullptr);
1345 nodeTest2->OnRegister(contextTest3);
1346 EXPECT_EQ(nodeTest2->renderContent_->type_, nodeTest2->GetType());
1347 }
1348
1349 /**
1350 * @tc.name: RSRenderNodeDumpTest002
1351 * @tc.desc: DumpNodeType DumpTree and DumpSubClassNode test
1352 * @tc.type: FUNC
1353 * @tc.require: issueI9US6V
1354 */
1355 HWTEST_F(RSRenderNodeTest, RSRenderNodeDumpTest002, TestSize.Level1)
1356 {
1357 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1358 EXPECT_NE(nodeTest, nullptr);
1359
1360 std::string outTest1 = "";
1361 nodeTest->DumpNodeType(RSRenderNodeType::DISPLAY_NODE, outTest1);
1362 nodeTest->DumpNodeType(RSRenderNodeType::RS_NODE, outTest1);
1363 nodeTest->DumpNodeType(RSRenderNodeType::SURFACE_NODE, outTest1);
1364 nodeTest->DumpNodeType(RSRenderNodeType::CANVAS_NODE, outTest1);
1365 nodeTest->DumpNodeType(RSRenderNodeType::ROOT_NODE, outTest1);
1366 nodeTest->DumpNodeType(RSRenderNodeType::PROXY_NODE, outTest1);
1367 nodeTest->DumpNodeType(RSRenderNodeType::CANVAS_DRAWING_NODE, outTest1);
1368 nodeTest->DumpNodeType(RSRenderNodeType::EFFECT_NODE, outTest1);
1369 nodeTest->DumpNodeType(RSRenderNodeType::UNKNOW, outTest1);
1370 EXPECT_EQ(outTest1, OUT_STR1);
1371
1372 std::string outTest2 = "";
1373 std::shared_ptr<RSRenderNode> inNode = std::make_shared<RSRenderNode>(0);
1374 EXPECT_NE(inNode, nullptr);
1375 std::shared_ptr<RSRenderNode> outNode = std::make_shared<RSRenderNode>(0);
1376 EXPECT_NE(outNode, nullptr);
1377 nodeTest->sharedTransitionParam_ = std::make_shared<SharedTransitionParam>(inNode, outNode);
1378 EXPECT_NE(nodeTest->sharedTransitionParam_, nullptr);
1379 nodeTest->nodeGroupType_ = RSRenderNode::GROUPED_BY_ANIM;
1380 nodeTest->uifirstRootNodeId_ = 1;
1381 nodeTest->SetBootAnimation(true);
1382 nodeTest->SetContainBootAnimation(true);
1383 nodeTest->dirtyStatus_ = RSRenderNode::NodeDirty::DIRTY;
1384 nodeTest->renderContent_->renderProperties_.isDirty_ = true;
1385 nodeTest->isSubTreeDirty_ = true;
1386 nodeTest->renderContent_->renderProperties_.isDrawn_ = false;
1387 nodeTest->renderContent_->renderProperties_.alphaNeedApply_ = false;
1388 nodeTest->renderContent_->drawCmdModifiers_.clear();
1389 nodeTest->isFullChildrenListValid_ = false;
1390 nodeTest->disappearingChildren_.emplace_back(std::make_shared<RSRenderNode>(0), 0);
1391 nodeTest->DumpTree(0, outTest2);
1392 EXPECT_EQ(outTest2, OUT_STR2);
1393
1394 std::string outTest3 = "";
1395 nodeTest->DumpSubClassNode(outTest3);
1396 EXPECT_EQ(outTest3, "");
1397 }
1398
1399 /**
1400 * @tc.name: IsContentNodeTest003
1401 * @tc.desc: IsContentNode test
1402 * @tc.type: FUNC
1403 * @tc.require: issueI9US6V
1404 */
1405 HWTEST_F(RSRenderNodeTest, IsContentNodeTest003, TestSize.Level1)
1406 {
1407 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1408 EXPECT_NE(nodeTest, nullptr);
1409 nodeTest->renderContent_->drawCmdModifiers_.clear();
1410 nodeTest->renderContent_->renderProperties_.isDrawn_ = false;
1411 EXPECT_TRUE(nodeTest->IsContentNode());
1412 std::shared_ptr<RSRenderProperty<Drawing::DrawCmdListPtr>> property =
1413 std::make_shared<RSRenderProperty<Drawing::DrawCmdListPtr>>();
1414 nodeTest->renderContent_->drawCmdModifiers_[RSModifierType::CONTENT_STYLE].emplace_back(
1415 std::make_shared<RSDrawCmdListRenderModifier>(property));
1416 EXPECT_TRUE(nodeTest->IsContentNode());
1417 }
1418
1419 /**
1420 * @tc.name: AddChildTest004
1421 * @tc.desc: AddChild test
1422 * @tc.type: FUNC
1423 * @tc.require: issueI9US6V
1424 */
1425 HWTEST_F(RSRenderNodeTest, AddChildTest004, TestSize.Level1)
1426 {
1427 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1428 EXPECT_NE(nodeTest, nullptr);
1429 std::shared_ptr<RSRenderNode> childTest1 = nullptr;
1430 nodeTest->AddChild(childTest1, 0);
1431
1432 childTest1 = std::make_shared<RSRenderNode>(0);
1433 nodeTest->AddChild(childTest1, 0);
1434
1435 std::shared_ptr<RSRenderNode> childTest2 = std::make_shared<RSRenderNode>(1);
1436 EXPECT_NE(childTest2, nullptr);
1437 std::shared_ptr<RSRenderNode> parent = nullptr;
1438 childTest2->parent_ = parent;
1439 nodeTest->isOnTheTree_ = false;
1440 nodeTest->isFullChildrenListValid_ = true;
1441 nodeTest->AddChild(childTest2, -1);
1442 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1443
1444 nodeTest->isFullChildrenListValid_ = true;
1445 nodeTest->AddChild(childTest2, 1);
1446 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1447
1448 parent = std::make_shared<RSRenderNode>(0);
1449 nodeTest->isFullChildrenListValid_ = true;
1450 nodeTest->isOnTheTree_ = true;
1451 nodeTest->AddChild(childTest2, 1);
1452 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1453 }
1454
1455 /**
1456 * @tc.name: MoveChildTest005
1457 * @tc.desc: MoveChild test
1458 * @tc.type: FUNC
1459 * @tc.require: issueI9US6V
1460 */
1461 HWTEST_F(RSRenderNodeTest, MoveChildTest005, TestSize.Level1)
1462 {
1463 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1464 EXPECT_NE(nodeTest, nullptr);
1465
1466 std::shared_ptr<RSRenderNode> childTest = nullptr;
1467 nodeTest->MoveChild(childTest, 0);
1468
1469 childTest = std::make_shared<RSRenderNode>(0);
1470 nodeTest->isFullChildrenListValid_ = true;
1471 std::shared_ptr<RSRenderNode> parent = std::make_shared<RSRenderNode>(0);
1472 childTest->parent_ = parent;
1473 nodeTest->MoveChild(childTest, 0);
1474 EXPECT_TRUE(nodeTest->isFullChildrenListValid_);
1475
1476 std::shared_ptr<RSRenderNode> child1 = std::make_shared<RSRenderNode>(1);
1477 std::shared_ptr<RSRenderNode> child2 = std::make_shared<RSRenderNode>(2);
1478 std::shared_ptr<RSRenderNode> child3 = std::make_shared<RSRenderNode>(3);
1479 nodeTest->AddChild(child1);
1480 nodeTest->AddChild(child2);
1481 nodeTest->AddChild(child3);
1482 nodeTest->isFullChildrenListValid_ = true;
1483 nodeTest->MoveChild(child2, 3);
1484 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1485 nodeTest->isFullChildrenListValid_ = true;
1486 nodeTest->MoveChild(child2, -1);
1487 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1488 nodeTest->isFullChildrenListValid_ = true;
1489 nodeTest->MoveChild(child2, 4);
1490 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1491 }
1492
1493 /**
1494 * @tc.name: ParentChildRelationshipTest006
1495 * @tc.desc: RemoveChild and ResetClearSurfaeFunc test
1496 * @tc.type: FUNC
1497 * @tc.require: issueI9US6V
1498 */
1499 HWTEST_F(RSRenderNodeTest, ParentChildRelationshipTest006, TestSize.Level1)
1500 {
1501 // RemoveChild test
1502 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1503 EXPECT_NE(nodeTest, nullptr);
1504
1505 std::shared_ptr<RSRenderNode> childTest = nullptr;
1506 nodeTest->RemoveChild(childTest, false);
1507
1508 childTest = std::make_shared<RSRenderNode>(0);
1509 std::shared_ptr<RSRenderNode> parent = std::make_shared<RSRenderNode>(0);
1510 childTest->parent_ = parent;
1511 nodeTest->isFullChildrenListValid_ = true;
1512 nodeTest->RemoveChild(childTest, false);
1513 EXPECT_TRUE(nodeTest->isFullChildrenListValid_);
1514
1515 nodeTest->isFullChildrenListValid_ = true;
1516 nodeTest->disappearingTransitionCount_ = 1;
1517 nodeTest->isBootAnimation_ = true;
1518
1519 std::shared_ptr<RSRenderNode> child1 = std::make_shared<RSRenderNode>(1);
1520 std::shared_ptr<RSRenderNode> child2 = std::make_shared<RSRenderNode>(2);
1521 std::shared_ptr<RSRenderNode> child3 = std::make_shared<RSRenderNode>(3);
1522 nodeTest->AddChild(child1);
1523 nodeTest->AddChild(child2);
1524 nodeTest->AddChild(child3);
1525 nodeTest->RemoveChild(child1, false);
1526 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1527
1528 nodeTest->isFullChildrenListValid_ = true;
1529 nodeTest->RemoveChild(child2, true);
1530 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1531 }
1532
1533 /**
1534 * @tc.name: RSRenderNodeTreeTest007
1535 * @tc.desc: SetIsOnTheTree ResetChildRelevantFlags and UpdateChildrenRect test
1536 * @tc.type: FUNC
1537 * @tc.require: issueI9US6V
1538 */
1539 HWTEST_F(RSRenderNodeTest, RSRenderNodeTreeTest007, TestSize.Level1)
1540 {
1541 // SetIsOnTheTree test
1542 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1543 EXPECT_NE(nodeTest, nullptr);
1544
1545 nodeTest->isOnTheTree_ = false;
1546 nodeTest->SetIsOnTheTree(false, 0, 1, 1, 1);
1547
1548 nodeTest->isOnTheTree_ = true;
1549 nodeTest->SetIsOnTheTree(false, 0, 1, 1, 1);
1550 EXPECT_FALSE(nodeTest->isOnTheTree_);
1551
1552 nodeTest->children_.emplace_back(std::make_shared<RSRenderNode>(0));
1553 nodeTest->children_.emplace_back(std::make_shared<RSRenderNode>(0));
1554 std::shared_ptr<RSRenderNode> renderNodeTest = nullptr;
1555 nodeTest->children_.emplace_back(renderNodeTest);
1556
1557 nodeTest->disappearingChildren_.emplace_back(std::make_shared<RSRenderNode>(0), 0);
1558 nodeTest->SetIsOnTheTree(true, 0, 1, 1, 1);
1559 EXPECT_TRUE(nodeTest->isOnTheTree_);
1560
1561 // ResetChildRelevantFlags test
1562 nodeTest->ResetChildRelevantFlags();
1563 EXPECT_FALSE(nodeTest->hasChildrenOutOfRect_);
1564
1565 // UpdateChildrenRect test
1566 RectI subRect = RectI { 0, 0, 1, 1 };
1567 nodeTest->childrenRect_.Clear();
1568 nodeTest->UpdateChildrenRect(subRect);
1569 nodeTest->UpdateChildrenRect(subRect);
1570 }
1571
1572 /**
1573 * @tc.name: AddCrossParentChildTest008
1574 * @tc.desc: AddCrossParentChild test
1575 * @tc.type: FUNC
1576 * @tc.require: issueI9US6V
1577 */
1578 HWTEST_F(RSRenderNodeTest, AddCrossParentChildTest008, TestSize.Level1)
1579 {
1580 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1581 EXPECT_NE(nodeTest, nullptr);
1582 nodeTest->isOnTheTree_ = false;
1583 std::shared_ptr<RSRenderNode> childTest = nullptr;
1584 nodeTest->AddCrossParentChild(childTest, -1);
1585
1586 std::shared_ptr<RSRenderNode> child1 = std::make_shared<RSRenderNode>(1);
1587 std::shared_ptr<RSRenderNode> child2 = std::make_shared<RSRenderNode>(2);
1588 std::shared_ptr<RSRenderNode> child3 = std::make_shared<RSRenderNode>(3);
1589 nodeTest->isFullChildrenListValid_ = true;
1590 nodeTest->AddCrossParentChild(child1, -1);
1591 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1592
1593 nodeTest->isFullChildrenListValid_ = true;
1594 nodeTest->AddCrossParentChild(child2, 3);
1595 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1596
1597 nodeTest->isOnTheTree_ = true;
1598 nodeTest->isFullChildrenListValid_ = true;
1599 nodeTest->AddCrossParentChild(child3, 4);
1600 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1601 }
1602
1603 /**
1604 * @tc.name: RemoveCrossParentChildTest009
1605 * @tc.desc: RemoveCrossParentChild test
1606 * @tc.type: FUNC
1607 * @tc.require: issueI9US6V
1608 */
1609 HWTEST_F(RSRenderNodeTest, RemoveCrossParentChild009, TestSize.Level1)
1610 {
1611 // RemoveChild test
1612 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1613 EXPECT_NE(nodeTest, nullptr);
1614
1615 std::shared_ptr<RSRenderNode> newParent1 = std::make_shared<RSRenderNode>(1);
1616 std::shared_ptr<RSRenderNode> newParent2 = std::make_shared<RSRenderNode>(2);
1617 std::shared_ptr<RSRenderNode> childTest = nullptr;
1618 nodeTest->RemoveCrossParentChild(childTest, newParent1);
1619
1620 childTest = std::make_shared<RSRenderNode>(0);
1621 std::shared_ptr<RSRenderNode> parent = std::make_shared<RSRenderNode>(0);
1622 childTest->parent_ = parent;
1623 nodeTest->isFullChildrenListValid_ = true;
1624 nodeTest->RemoveCrossParentChild(childTest, newParent1);
1625 EXPECT_TRUE(nodeTest->isFullChildrenListValid_);
1626
1627 nodeTest->isFullChildrenListValid_ = true;
1628 nodeTest->disappearingTransitionCount_ = 1;
1629
1630 std::shared_ptr<RSRenderNode> child1 = std::make_shared<RSRenderNode>(1);
1631 std::shared_ptr<RSRenderNode> child2 = std::make_shared<RSRenderNode>(2);
1632 nodeTest->AddCrossParentChild(child1);
1633 nodeTest->AddCrossParentChild(child2);
1634
1635 nodeTest->RemoveCrossParentChild(child1, newParent1);
1636 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1637
1638 nodeTest->disappearingTransitionCount_ = 0;
1639 parent = nullptr;
1640 nodeTest->isFullChildrenListValid_ = true;
1641 nodeTest->RemoveCrossParentChild(child2, newParent2);
1642 EXPECT_FALSE(nodeTest->isFullChildrenListValid_);
1643 }
1644
1645 /**
1646 * @tc.name: RemoveFromTreeTest010
1647 * @tc.desc: RemoveFromTree test
1648 * @tc.type: FUNC
1649 * @tc.require: issueIA5Y41
1650 */
1651 HWTEST_F(RSRenderNodeTest, RemoveFromTreeTest010, TestSize.Level1)
1652 {
1653 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1654 EXPECT_NE(nodeTest, nullptr);
1655
1656 std::shared_ptr<RSRenderNode> parentTest1 = nullptr;
1657 nodeTest->parent_ = parentTest1;
1658 nodeTest->RemoveFromTree(false);
1659
1660 std::shared_ptr<RSRenderNode> parentTest2 = std::make_shared<RSRenderNode>(0);
1661 EXPECT_NE(parentTest2, nullptr);
1662
1663 nodeTest->parent_ = parentTest2;
1664 parentTest2->isFullChildrenListValid_ = true;
1665 nodeTest->isFullChildrenListValid_ = true;
1666 nodeTest->RemoveFromTree(false);
1667 EXPECT_TRUE(parentTest2->isFullChildrenListValid_);
1668
1669 parentTest2->isFullChildrenListValid_ = true;
1670 nodeTest->isFullChildrenListValid_ = true;
1671 nodeTest->RemoveFromTree(true);
1672 EXPECT_FALSE(parentTest2->isFullChildrenListValid_);
1673 }
1674
1675 /**
1676 * @tc.name: ClearChildrenTest011
1677 * @tc.desc: ClearChildren test
1678 * @tc.type: FUNC
1679 * @tc.require: issueI9US6V
1680 */
1681 HWTEST_F(RSRenderNodeTest, ClearChildrenTest011, TestSize.Level1)
1682 {
1683 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1684 EXPECT_NE(nodeTest, nullptr);
1685
1686 nodeTest->children_.clear();
1687 nodeTest->ClearChildren();
1688
1689 nodeTest->disappearingTransitionCount_ = 1;
1690 nodeTest->children_.emplace_back(std::make_shared<RSRenderNode>(0));
1691 nodeTest->children_.emplace_back(std::make_shared<RSRenderNode>(0));
1692 std::shared_ptr<RSRenderNode> renderNodeTest1 = nullptr;
1693 nodeTest->children_.emplace_back(renderNodeTest1);
1694 EXPECT_EQ(nodeTest->children_.size(), 3);
1695 nodeTest->ClearChildren();
1696 EXPECT_EQ(nodeTest->children_.size(), 0);
1697
1698 nodeTest->disappearingTransitionCount_ = 0;
1699 std::shared_ptr<RSRenderNode> renderNodeTest2 = std::make_shared<RSRenderNode>(0);
1700 EXPECT_NE(renderNodeTest2, nullptr);
1701 renderNodeTest2->disappearingTransitionCount_ = 1;
1702 nodeTest->children_.emplace_back(renderNodeTest2);
1703 EXPECT_EQ(nodeTest->children_.size(), 1);
1704 nodeTest->ClearChildren();
1705 EXPECT_EQ(nodeTest->children_.size(), 0);
1706
1707 std::shared_ptr<RSRenderNode> renderNodeTest3 = std::make_shared<RSRenderNode>(0);
1708 EXPECT_NE(renderNodeTest3, nullptr);
1709 renderNodeTest3->disappearingTransitionCount_ = 0;
1710 nodeTest->children_.emplace_back(renderNodeTest3);
1711 EXPECT_EQ(nodeTest->children_.size(), 1);
1712 nodeTest->ClearChildren();
1713 EXPECT_EQ(nodeTest->children_.size(), 0);
1714 }
1715
1716 /**
1717 * @tc.name: DrawSurfaceNodesTest012
1718 * @tc.desc: IsFirstLevelNode SubSurfaceNodeNeedDraw test
1719 * @tc.type: FUNC
1720 * @tc.require: issueI9US6V
1721 */
1722 HWTEST_F(RSRenderNodeTest, DrawSurfaceNodesTest012, TestSize.Level1)
1723 {
1724 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1725 EXPECT_NE(nodeTest, nullptr);
1726 nodeTest->firstLevelNodeId_ = 0;
1727 EXPECT_TRUE(nodeTest->IsFirstLevelNode());
1728
1729 std::vector<std::weak_ptr<RSRenderNode>> subSurfaceNodesTest1;
1730 std::shared_ptr<RSSurfaceRenderNode> surfaceTest1 = std::make_shared<RSSurfaceRenderNode>(0);
1731 EXPECT_NE(surfaceTest1, nullptr);
1732 surfaceTest1->SetOldDirtyInSurface(RectI { 0, 0, 1, 1 });
1733 surfaceTest1->visibleRegion_.rects_.emplace_back(RectI { 0, 0, 2, 2 });
1734 subSurfaceNodesTest1.emplace_back(surfaceTest1);
1735 nodeTest->subSurfaceNodes_.emplace(0, subSurfaceNodesTest1);
1736 nodeTest->subSurfaceNodes_.clear();
1737
1738 std::vector<std::weak_ptr<RSRenderNode>> subSurfaceNodesTest2;
1739 std::shared_ptr<RSSurfaceRenderNode> surfaceTest2 = std::make_shared<RSSurfaceRenderNode>(0);
1740 EXPECT_NE(surfaceTest2, nullptr);
1741 surfaceTest2->SetOldDirtyInSurface(RectI { 0, 0, 1, 1 });
1742 surfaceTest2->visibleRegion_.rects_.clear();
1743 std::vector<std::weak_ptr<RSRenderNode>> subSurfaceNodesTest3;
1744 std::shared_ptr<RSSurfaceRenderNode> surfaceTest3 = std::make_shared<RSSurfaceRenderNode>(0);
1745 EXPECT_NE(surfaceTest3, nullptr);
1746 surfaceTest3->SetOldDirtyInSurface(RectI { 0, 0, 1, 1 });
1747 surfaceTest3->visibleRegion_.rects_.emplace_back(RectI { 0, 0, 2, 2 });
1748 subSurfaceNodesTest3.emplace_back(surfaceTest3);
1749 surfaceTest2->subSurfaceNodes_.emplace(0, subSurfaceNodesTest3);
1750 subSurfaceNodesTest2.emplace_back(surfaceTest2);
1751 nodeTest->subSurfaceNodes_.emplace(0, subSurfaceNodesTest2);
1752 nodeTest->subSurfaceNodes_.clear();
1753 }
1754
1755 /**
1756 * @tc.name: UpdateDrawingCacheInfoBeforeChildrenTest013
1757 * @tc.desc: CheckDrawingCacheType and UpdateDrawingCacheInfoBeforeChildren test
1758 * @tc.type: FUNC
1759 * @tc.require: issueI9US6V
1760 */
1761 HWTEST_F(RSRenderNodeTest, UpdateDrawingCacheInfoBeforeChildrenTest013, TestSize.Level1)
1762 {
1763 RSRenderNode node(0);
1764
1765 // CheckDrawingCacheType test
1766 node.nodeGroupType_ = RSRenderNode::NONE;
1767 node.CheckDrawingCacheType();
1768 EXPECT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::DISABLED_CACHE);
1769 node.nodeGroupType_ = RSRenderNode::GROUPED_BY_USER;
1770 node.CheckDrawingCacheType();
1771 EXPECT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::FORCED_CACHE);
1772 node.nodeGroupType_ = RSRenderNode::GROUPED_BY_ANIM;
1773 node.CheckDrawingCacheType();
1774 EXPECT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::TARGETED_CACHE);
1775
1776 // UpdateDrawingCacheInfoBeforeChildren test
1777 // shouldPaint_ is false
1778 node.shouldPaint_ = false;
1779 node.UpdateDrawingCacheInfoBeforeChildren(false);
1780 EXPECT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::DISABLED_CACHE);
1781 // shouldPaint_ is true
1782 node.shouldPaint_ = true;
1783 node.UpdateDrawingCacheInfoBeforeChildren(true);
1784 EXPECT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::DISABLED_CACHE);
1785 // isScreenRotation is true
1786 node.nodeGroupType_ = RSRenderNode::NONE;
1787 node.UpdateDrawingCacheInfoBeforeChildren(false);
1788 EXPECT_EQ(node.GetDrawingCacheType(), RSDrawingCacheType::DISABLED_CACHE);
1789
1790 // isScreenRotation is false
1791 node.nodeGroupType_ = RSRenderNode::GROUPED_BY_ANIM;
1792 std::unique_ptr<RSRenderParams> stagingRenderParams = std::make_unique<RSRenderParams>(0);
1793 EXPECT_NE(stagingRenderParams, nullptr);
1794 node.stagingRenderParams_ = std::move(stagingRenderParams);
1795 node.UpdateDrawingCacheInfoBeforeChildren(false);
1796 EXPECT_FALSE(node.stagingRenderParams_->needSync_);
1797 }
1798
1799 /**
1800 * @tc.name: RemoveModifierTest014
1801 * @tc.desc: RemoveModifier test
1802 * @tc.type: FUNC
1803 * @tc.require: issueI9US6V
1804 */
1805 HWTEST_F(RSRenderNodeTest, ProcessTest014, TestSize.Level1)
1806 {
1807 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1808 EXPECT_NE(nodeTest, nullptr);
1809
1810 std::shared_ptr<RSRenderProperty<Drawing::DrawCmdListPtr>> propertyTest1 =
1811 std::make_shared<RSRenderProperty<Drawing::DrawCmdListPtr>>();
1812 std::shared_ptr<RSDrawCmdListRenderModifier> modifier1 =
1813 std::make_shared<RSDrawCmdListRenderModifier>(propertyTest1);
1814 std::shared_ptr<RSRenderProperty<Drawing::DrawCmdListPtr>> propertyTest2 =
1815 std::make_shared<RSRenderProperty<Drawing::DrawCmdListPtr>>();
1816 std::shared_ptr<RSDrawCmdListRenderModifier> modifier2 =
1817 std::make_shared<RSDrawCmdListRenderModifier>(propertyTest2);
1818
1819 nodeTest->modifiers_.emplace(0, modifier1);
1820 nodeTest->modifiers_.emplace(1, modifier2);
1821
1822 EXPECT_EQ(nodeTest->modifiers_.size(), 2);
1823 nodeTest->RemoveModifier(1);
1824 EXPECT_EQ(nodeTest->modifiers_.size(), 1);
1825 nodeTest->RemoveModifier(1);
1826 EXPECT_EQ(nodeTest->modifiers_.size(), 1);
1827 }
1828
1829 /**
1830 * @tc.name: AccmulateDirtyInOcclusionTest015
1831 * @tc.desc: AccmulateDirtyInOcclusion
1832 * @tc.type: FUNC
1833 * @tc.require: issueI9US6V
1834 */
1835 HWTEST_F(RSRenderNodeTest, AccmulateDirtyInOcclusionTest015, TestSize.Level1)
1836 {
1837 // AccmulateDirtyInOcclusion AccmulateDirtyTypes AccmulateDirtyStatus GetMutableRenderProperties
1838 // ResetAccmulateDirtyTypes ResetAccmulateDirtyStatus RecordCurDirtyTypes test
1839 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1840 EXPECT_NE(nodeTest, nullptr);
1841 nodeTest->curDirtyTypes_.set(static_cast<size_t>(RSModifierType::PIVOT_Z), true);
1842 nodeTest->curDirtyTypes_.set(static_cast<size_t>(RSModifierType::PERSP), true);
1843
1844 nodeTest->AccmulateDirtyInOcclusion(true);
1845 nodeTest->AccmulateDirtyInOcclusion(false);
1846
1847 nodeTest->dirtyTypes_.set(static_cast<size_t>(RSModifierType::PIVOT_Z), true);
1848 nodeTest->dirtyTypes_.set(static_cast<size_t>(RSModifierType::PERSP), true);
1849 nodeTest->RecordCurDirtyTypes();
1850 }
1851
1852 /**
1853 * @tc.name: GenerateFullChildrenListTest016
1854 * @tc.desc: RemoveModifier and ApplyPositionZModifier test
1855 * @tc.type: FUNC
1856 * @tc.require: issueI9US6V
1857 */
1858 HWTEST_F(RSRenderNodeTest, GenerateFullChildrenListTest016, TestSize.Level1)
1859 {
1860 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1861 EXPECT_NE(nodeTest, nullptr);
1862
1863 nodeTest->isFullChildrenListValid_ = false;
1864 nodeTest->GenerateFullChildrenList();
1865 EXPECT_TRUE(nodeTest->isFullChildrenListValid_);
1866
1867 std::shared_ptr<RSRenderNode> childrenTest1 = nullptr;
1868 std::shared_ptr<RSRenderNode> childrenTest2 = std::make_shared<RSRenderNode>(0);
1869 EXPECT_NE(childrenTest2, nullptr);
1870 std::shared_ptr<RSRenderNode> childrenTest3 = std::make_shared<RSRenderNode>(0);
1871 EXPECT_NE(childrenTest3, nullptr);
1872 nodeTest->children_.emplace_back(childrenTest1);
1873 nodeTest->isContainBootAnimation_ = true;
1874 childrenTest2->isBootAnimation_ = false;
1875 childrenTest2->isBootAnimation_ = true;
1876 nodeTest->children_.emplace_back(childrenTest2);
1877
1878 std::shared_ptr<RSRenderNode> disappearingChildrenTest1 = std::make_shared<RSRenderNode>(0);
1879 EXPECT_NE(disappearingChildrenTest1, nullptr);
1880 std::shared_ptr<RSRenderNode> disappearingChildrenTest2 = std::make_shared<RSRenderNode>(1);
1881 EXPECT_NE(disappearingChildrenTest2, nullptr);
1882 disappearingChildrenTest1->isBootAnimation_ = false;
1883 nodeTest->disappearingChildren_.emplace_back(std::pair(disappearingChildrenTest1, 0));
1884 nodeTest->disappearingChildren_.emplace_back(std::pair(disappearingChildrenTest2, 1));
1885
1886 // ApplyPositionZModifier test
1887 disappearingChildrenTest1->dirtyTypes_.set(static_cast<size_t>(RSModifierType::POSITION_Z), false);
1888 std::shared_ptr<RSRenderProperty<Drawing::DrawCmdListPtr>> propertyTest1 =
1889 std::make_shared<RSRenderProperty<Drawing::DrawCmdListPtr>>();
1890 EXPECT_NE(propertyTest1, nullptr);
1891 std::shared_ptr<RSDrawCmdListRenderModifier> modifier1 =
1892 std::make_shared<RSDrawCmdListRenderModifier>(propertyTest1);
1893 EXPECT_NE(modifier1, nullptr);
1894 modifier1->SetType(RSModifierType::POSITION_Z);
1895 disappearingChildrenTest2->modifiers_.emplace(0, modifier1);
1896
1897 nodeTest->isChildrenSorted_ = false;
1898 nodeTest->GenerateFullChildrenList();
1899 EXPECT_TRUE(nodeTest->isChildrenSorted_);
1900
1901 disappearingChildrenTest2->dirtyTypes_.set(static_cast<size_t>(RSModifierType::POSITION_Z), true);
1902 nodeTest->isChildrenSorted_ = false;
1903 nodeTest->GenerateFullChildrenList();
1904 EXPECT_TRUE(nodeTest->isChildrenSorted_);
1905 }
1906
1907 /**
1908 * @tc.name: ApplyModifiersTest017
1909 * @tc.desc: ApplyModifiers test
1910 * @tc.type: FUNC
1911 * @tc.require: issueI9US6V
1912 */
1913 HWTEST_F(RSRenderNodeTest, ApplyModifiersTest017, TestSize.Level1)
1914 {
1915 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1916 EXPECT_NE(nodeTest, nullptr);
1917 std::shared_ptr<RSRenderProperty<Drawing::DrawCmdListPtr>> propertyTest1 =
1918 std::make_shared<RSRenderProperty<Drawing::DrawCmdListPtr>>();
1919 EXPECT_NE(propertyTest1, nullptr);
1920 std::shared_ptr<RSDrawCmdListRenderModifier> modifier1 =
1921 std::make_shared<RSDrawCmdListRenderModifier>(propertyTest1);
1922 EXPECT_NE(modifier1, nullptr);
1923 modifier1->SetType(RSModifierType::POSITION_Z);
1924 nodeTest->dirtyTypes_.set(static_cast<size_t>(RSModifierType::POSITION_Z), false);
1925 nodeTest->dirtyTypes_.set(static_cast<size_t>(RSModifierType::SANDBOX), true);
1926 nodeTest->modifiers_.emplace(0, modifier1);
1927 nodeTest->isFullChildrenListValid_ = false;
1928 nodeTest->renderContent_->renderProperties_.alpha_ = 0.0f;
1929 RSRenderNode::SharedPtr inNode = std::make_shared<RSRenderNode>(0);
1930 RSRenderNode::SharedPtr outNode = std::make_shared<RSRenderNode>(0);
1931 std::shared_ptr<SharedTransitionParam> sharedTransitionParam =
1932 std::make_shared<SharedTransitionParam>(inNode, outNode);
1933 nodeTest->sharedTransitionParam_ = sharedTransitionParam;
1934 nodeTest->GenerateFullChildrenList();
1935 EXPECT_TRUE(nodeTest->isFullChildrenListValid_);
1936
1937 nodeTest->modifiers_.clear();
1938 nodeTest->isChildrenSorted_ = false;
1939 nodeTest->GenerateFullChildrenList();
1940
1941 nodeTest->isChildrenSorted_ = true;
1942 nodeTest->childrenHasSharedTransition_ = true;
1943 nodeTest->GenerateFullChildrenList();
1944
1945 nodeTest->dirtyTypes_.reset();
1946 EXPECT_TRUE(nodeTest->dirtyTypes_.none());
1947 nodeTest->childrenHasSharedTransition_ = false;
1948 nodeTest->GenerateFullChildrenList();
1949 }
1950
1951 /**
1952 * @tc.name: InvalidateHierarchyTest018
1953 * @tc.desc: MarkParentNeedRegenerateChildren and UpdateDrawableVec UpdateDrawableVecInternal test
1954 * @tc.type: FUNC
1955 * @tc.require: issueI9US6V
1956 */
1957 HWTEST_F(RSRenderNodeTest, InvalidateHierarchyTest018, TestSize.Level1)
1958 {
1959 std::shared_ptr<RSRenderNode> nodeTest1 = std::make_shared<RSRenderNode>(0);
1960 EXPECT_NE(nodeTest1, nullptr);
1961
1962 std::shared_ptr<RSRenderNode> parentTest1 = nullptr;
1963 nodeTest1->parent_ = parentTest1;
1964 nodeTest1->MarkParentNeedRegenerateChildren();
1965 std::shared_ptr<RSRenderNode> parentTest2 = std::make_shared<RSRenderNode>(0);
1966 EXPECT_NE(parentTest2, nullptr);
1967 nodeTest1->parent_ = parentTest2;
1968 nodeTest1->MarkParentNeedRegenerateChildren();
1969 EXPECT_FALSE(parentTest2->isChildrenSorted_);
1970
1971 nodeTest1->SetIsUsedBySubThread(false);
1972 nodeTest1->renderContent_->renderProperties_.pixelStretch_ = 1.0f;
1973 nodeTest1->dirtyTypes_.set(static_cast<size_t>(RSModifierType::BOUNDS), true);
1974 nodeTest1->dirtyTypes_.set(static_cast<size_t>(RSModifierType::SCALE), true);
1975 std::unique_ptr<PropertyDrawableTest> property = std::make_unique<PropertyDrawableTest>();
1976 nodeTest1->renderContent_->propertyDrawablesVec_.at(0) = std::move(property);
1977 nodeTest1->UpdateDrawableVec();
1978
1979 std::shared_ptr<RSRenderNode> nodeTest2 = std::make_shared<RSRenderNode>(0);
1980 EXPECT_NE(nodeTest2, nullptr);
1981 nodeTest2->SetIsUsedBySubThread(true);
1982 std::shared_ptr<RSContext> contextTest = std::make_shared<RSContext>();
1983 nodeTest2->context_ = contextTest;
1984 nodeTest2->UpdateDrawableVec();
1985 }
1986
1987 /**
1988 * @tc.name: UpdateDrawableVecV2Test019
1989 * @tc.desc: UpdateDrawableVecV2 test
1990 * @tc.type: FUNC
1991 * @tc.require: issueI9US6V
1992 */
1993 HWTEST_F(RSRenderNodeTest, UpdateDrawableVecV2Test019, TestSize.Level1)
1994 {
1995 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
1996 EXPECT_NE(nodeTest, nullptr);
1997
1998 nodeTest->UpdateDrawableVecV2();
1999
2000 nodeTest->dirtyTypes_.set(static_cast<size_t>(RSModifierType::BOUNDS), true);
2001 nodeTest->dirtyTypes_.set(static_cast<size_t>(RSModifierType::ROTATION_X), true);
2002 std::shared_ptr<DrawableTest> drawableTest1 = std::make_shared<DrawableTest>();
2003 nodeTest->drawableVec_.at(1) = drawableTest1;
2004 EXPECT_TRUE(nodeTest->dirtySlots_.empty());
2005
2006 nodeTest->stagingRenderParams_ = std::make_unique<RSRenderParams>(0);
2007 nodeTest->UpdateDrawableVecV2();
2008 auto sum = nodeTest->dirtySlots_.size();
2009 EXPECT_NE(nodeTest->dirtySlots_.size(), 0);
2010
2011 nodeTest->dirtyTypes_.set(static_cast<size_t>(RSModifierType::PIVOT), true);
2012 std::shared_ptr<DrawableTest> drawableTest2 = std::make_shared<DrawableTest>();
2013 nodeTest->drawableVec_.at(4) = drawableTest2;
2014 RSShadow rsShadow;
2015 std::optional<RSShadow> shadow(rsShadow);
2016 shadow->colorStrategy_ = SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_AVERAGE;
2017 nodeTest->renderContent_->renderProperties_.shadow_ = shadow;
2018 RRect rrect;
2019 nodeTest->renderContent_->renderProperties_.rrect_ = rrect;
2020 nodeTest->UpdateDrawableVecV2();
2021 EXPECT_NE(nodeTest->dirtySlots_.size(), sum);
2022 }
2023
2024 /**
2025 * @tc.name: UpdateDisplayListTest020
2026 * @tc.desc: UpdateDisplayList test
2027 * @tc.type: FUNC
2028 * @tc.require: issueI9V3BK
2029 */
2030 HWTEST_F(RSRenderNodeTest, UpdateDisplayListTest020, TestSize.Level1)
2031 {
2032 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2033 EXPECT_NE(nodeTest, nullptr);
2034
2035 // UpdateDisplayList test
2036 std::unique_ptr<RSRenderParams> stagingRenderParams = std::make_unique<RSRenderParams>(0);
2037 EXPECT_NE(stagingRenderParams, nullptr);
2038 nodeTest->stagingRenderParams_ = std::move(stagingRenderParams);
2039 nodeTest->drawCmdListNeedSync_ = false;
2040 nodeTest->UpdateDisplayList();
2041 EXPECT_TRUE(nodeTest->drawCmdListNeedSync_);
2042
2043 nodeTest->drawableVecStatus_ = 48;
2044 std::shared_ptr<DrawableTest> drawableTest1 = std::make_shared<DrawableTest>();
2045 nodeTest->drawableVec_.at(1) = drawableTest1;
2046 nodeTest->drawCmdListNeedSync_ = false;
2047 nodeTest->UpdateDisplayList();
2048 EXPECT_TRUE(nodeTest->drawCmdListNeedSync_);
2049
2050 nodeTest->drawableVecStatus_ = 32;
2051 nodeTest->UpdateDisplayList();
2052 EXPECT_EQ(nodeTest->stagingDrawCmdIndex_.contentIndex_, -1);
2053 }
2054
2055 /**
2056 * @tc.name: UpdateRenderingTest021
2057 * @tc.desc: UpdateEffectRegion GetModifier UpdateShouldPaint SetSharedTransitionParam test
2058 * @tc.type: FUNC
2059 * @tc.require: issueI9V3BK
2060 */
2061 HWTEST_F(RSRenderNodeTest, UpdateRenderingTest021, TestSize.Level1)
2062 {
2063 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2064 EXPECT_NE(nodeTest, nullptr);
2065
2066 // UpdateEffectRegion test
2067 std::optional<Drawing::RectI> region = std::nullopt;
2068 nodeTest->UpdateEffectRegion(region, false);
2069 Drawing::RectI rectI;
2070 region = rectI;
2071 nodeTest->UpdateEffectRegion(region, false);
2072 nodeTest->renderContent_->renderProperties_.useEffect_ = true;
2073 std::shared_ptr<RSObjAbsGeometry> boundsGeo = std::make_shared<RSObjAbsGeometry>();
2074 nodeTest->renderContent_->renderProperties_.boundsGeo_ = boundsGeo;
2075 nodeTest->UpdateEffectRegion(region, true);
2076
2077 // GetModifier test
2078 std::shared_ptr<RSDrawCmdListRenderModifier> modifier = nullptr;
2079 nodeTest->modifiers_.emplace(0, modifier);
2080 EXPECT_EQ(nodeTest->GetModifier(0), nullptr);
2081 EXPECT_EQ(nodeTest->GetModifier(1), nullptr);
2082 std::shared_ptr<RSRenderProperty<Drawing::DrawCmdListPtr>> propertyTest =
2083 std::make_shared<RSRenderProperty<Drawing::DrawCmdListPtr>>();
2084 EXPECT_NE(propertyTest, nullptr);
2085 std::shared_ptr<RSDrawCmdListRenderModifier> drawCmdModifiersTest =
2086 std::make_shared<RSDrawCmdListRenderModifier>(propertyTest);
2087 EXPECT_NE(drawCmdModifiersTest, nullptr);
2088 drawCmdModifiersTest->property_->id_ = 1;
2089 nodeTest->renderContent_->drawCmdModifiers_[RSModifierType::BOUNDS].emplace_back(drawCmdModifiersTest);
2090 EXPECT_NE(nodeTest->GetModifier(1), nullptr);
2091
2092 // FilterModifiersByPid test
2093 nodeTest->FilterModifiersByPid(1);
2094
2095 // UpdateShouldPaint test
2096 nodeTest->renderContent_->renderProperties_.alpha_ = -1.0f;
2097 std::shared_ptr<RSFilter> filter = RSFilter::CreateBlurFilter(0.0f, 0.1f);
2098 nodeTest->renderContent_->renderProperties_.filter_ = filter;
2099 nodeTest->sharedTransitionParam_ = nullptr;
2100 nodeTest->UpdateShouldPaint();
2101
2102 // SetSharedTransitionParam test
2103 std::shared_ptr<SharedTransitionParam> sharedTransitionParam = nullptr;
2104 nodeTest->sharedTransitionParam_ = nullptr;
2105 nodeTest->SetSharedTransitionParam(sharedTransitionParam);
2106 RSRenderNode::SharedPtr inNode = std::make_shared<RSRenderNode>(0);
2107 EXPECT_NE(inNode, nullptr);
2108 RSRenderNode::SharedPtr outNode = std::make_shared<RSRenderNode>(0);
2109 EXPECT_NE(outNode, nullptr);
2110 sharedTransitionParam = std::make_shared<SharedTransitionParam>(inNode, outNode);
2111 EXPECT_NE(sharedTransitionParam, nullptr);
2112 nodeTest->parent_ = std::make_shared<RSRenderNode>(0);
2113 nodeTest->SetSharedTransitionParam(sharedTransitionParam);
2114 EXPECT_NE(nodeTest->sharedTransitionParam_, nullptr);
2115 }
2116
2117 /**
2118 * @tc.name: ManageRenderingResourcesTest022
2119 * @tc.desc: SetGlobalAlpha NeedInitCacheSurface GetOptionalBufferSize test
2120 * @tc.type: FUNC
2121 * @tc.require: issueIA61E9
2122 */
2123 HWTEST_F(RSRenderNodeTest, ManageRenderingResourcesTest022, TestSize.Level1)
2124 {
2125 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2126 EXPECT_NE(nodeTest, nullptr);
2127 nodeTest->InitRenderParams();
2128 // SetGlobalAlpha test
2129 nodeTest->SetGlobalAlpha(1.0f);
2130 EXPECT_EQ(nodeTest->globalAlpha_, 1.0f);
2131 nodeTest->SetGlobalAlpha(1.01f);
2132 EXPECT_EQ(nodeTest->globalAlpha_, 1.01f);
2133
2134 // NeedInitCacheSurface and GetOptionalBufferSize test
2135 nodeTest->SetCacheType(CacheType::ANIMATE_PROPERTY);
2136 RSShadow rsShadow;
2137 std::optional<RSShadow> shadow(rsShadow);
2138 nodeTest->renderContent_->renderProperties_.shadow_ = shadow;
2139 nodeTest->renderContent_->renderProperties_.shadow_->radius_ = 1.0f;
2140 nodeTest->renderContent_->renderProperties_.isSpherizeValid_ = true;
2141 nodeTest->renderContent_->renderProperties_.isAttractionValid_ = true;
2142 nodeTest->cacheSurface_ = nullptr;
2143 EXPECT_TRUE(nodeTest->NeedInitCacheSurface());
2144
2145 nodeTest->boundsModifier_ = nullptr;
2146 nodeTest->frameModifier_ = nullptr;
2147 nodeTest->SetCacheType(CacheType::CONTENT);
2148 EXPECT_TRUE(nodeTest->NeedInitCacheSurface());
2149
2150 nodeTest->boundsModifier_ = nullptr;
2151 auto propertyTest = std::make_shared<RSRenderProperty<Drawing::DrawCmdListPtr>>();
2152 EXPECT_NE(propertyTest, nullptr);
2153 auto frameModifier = std::make_shared<RSDrawCmdListRenderModifier>(propertyTest);
2154 EXPECT_NE(frameModifier, nullptr);
2155 frameModifier->property_ = std::make_shared<RSRenderProperty<Drawing::DrawCmdListPtr>>();
2156 EXPECT_NE(frameModifier->property_, nullptr);
2157 frameModifier->property_->GetRef() = std::make_shared<Drawing::DrawCmdList>(10, 10);
2158 frameModifier->SetType(RSModifierType::FRAME);
2159 nodeTest->frameModifier_ = frameModifier;
2160 nodeTest->cacheSurface_ = std::make_shared<Drawing::Surface>();
2161 EXPECT_NE(nodeTest->cacheSurface_, nullptr);
2162 nodeTest->cacheSurface_->cachedCanvas_ = nullptr;
2163 EXPECT_TRUE(nodeTest->NeedInitCacheSurface());
2164 nodeTest->cacheSurface_->cachedCanvas_ = std::make_shared<Drawing::Canvas>();
2165 EXPECT_NE(nodeTest, nullptr);
2166 }
2167
2168 /**
2169 * @tc.name: NeedInitCacheCompletedSurfaceTest023
2170 * @tc.desc: NeedInitCacheCompletedSurface test
2171 * @tc.type: FUNC
2172 * @tc.require: issueI9V3BK
2173 */
2174 HWTEST_F(RSRenderNodeTest, NeedInitCacheCompletedSurfaceTest023, TestSize.Level1)
2175 {
2176 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2177 EXPECT_NE(nodeTest, nullptr);
2178
2179 // NeedInitCacheCompletedSurface test
2180 nodeTest->boundsModifier_ = nullptr;
2181 nodeTest->frameModifier_ = nullptr;
2182 nodeTest->cacheCompletedSurface_ = nullptr;
2183 EXPECT_TRUE(nodeTest->NeedInitCacheCompletedSurface());
2184 nodeTest->cacheCompletedSurface_ = std::make_shared<Drawing::Surface>();
2185 EXPECT_NE(nodeTest->cacheCompletedSurface_, nullptr);
2186 nodeTest->cacheCompletedSurface_->cachedCanvas_ = nullptr;
2187 EXPECT_TRUE(nodeTest->NeedInitCacheCompletedSurface());
2188 nodeTest->cacheCompletedSurface_->cachedCanvas_ = std::make_shared<Drawing::Canvas>();
2189 EXPECT_NE(nodeTest->cacheCompletedSurface_->cachedCanvas_, nullptr);
2190 EXPECT_FALSE(nodeTest->NeedInitCacheCompletedSurface());
2191 }
2192
2193 /**
2194 * @tc.name: InitCacheSurfaceTest024
2195 * @tc.desc: InitCacheSurface test
2196 * @tc.type: FUNC
2197 * @tc.require: issueI9V3BK
2198 */
2199 HWTEST_F(RSRenderNodeTest, InitCacheSurfaceTest024, TestSize.Level1)
2200 {
2201 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2202 EXPECT_NE(nodeTest, nullptr);
2203 nodeTest->boundsModifier_ = nullptr;
2204 nodeTest->frameModifier_ = nullptr;
2205
2206 RSRenderNode::ClearCacheSurfaceFunc funcTest1 = nullptr;
2207 Drawing::GPUContext gpuContextTest1;
2208 nodeTest->cacheType_ = CacheType::ANIMATE_PROPERTY;
2209 RSShadow rsShadow;
2210 std::optional<RSShadow> shadow(rsShadow);
2211 nodeTest->renderContent_->renderProperties_.shadow_ = shadow;
2212 nodeTest->renderContent_->renderProperties_.shadow_->radius_ = 1.0f;
2213 nodeTest->renderContent_->renderProperties_.isSpherizeValid_ = false;
2214 nodeTest->renderContent_->renderProperties_.isAttractionValid_ = false;
2215 nodeTest->cacheSurface_ = nullptr;
2216 nodeTest->InitCacheSurface(&gpuContextTest1, funcTest1, 1);
2217 EXPECT_EQ(nodeTest->cacheSurface_, nullptr);
2218
2219 nodeTest->cacheSurface_ = std::make_shared<Drawing::Surface>();
2220 EXPECT_NE(nodeTest->cacheSurface_, nullptr);
2221 nodeTest->cacheSurfaceThreadIndex_ = 1;
2222 nodeTest->completedSurfaceThreadIndex_ = 1;
2223 Drawing::GPUContext gpuContextTest2;
2224 nodeTest->cacheType_ = CacheType::CONTENT;
2225 std::shared_ptr<Drawing::Surface> surfaceTest1 = std::make_shared<Drawing::Surface>();
2226 EXPECT_NE(surfaceTest1, nullptr);
2227 std::shared_ptr<Drawing::Surface> surfaceTest2 = std::make_shared<Drawing::Surface>();
2228 EXPECT_NE(surfaceTest2, nullptr);
2229 RSRenderNode::ClearCacheSurfaceFunc funcTest2 = [surfaceTest1, surfaceTest2](std::shared_ptr<Drawing::Surface>&& s1,
2230 std::shared_ptr<Drawing::Surface>&& s2, uint32_t w,
__anond072ea200202(std::shared_ptr<Drawing::Surface>&& s1, std::shared_ptr<Drawing::Surface>&& s2, uint32_t w, uint32_t h) 2231 uint32_t h) {};
2232 nodeTest->InitCacheSurface(&gpuContextTest2, funcTest2, 1);
2233 EXPECT_EQ(nodeTest->cacheSurface_, nullptr);
2234
2235 Drawing::GPUContext* gpuContextTest3 = nullptr;
2236 std::shared_ptr<Drawing::Surface> surfaceTest3 = std::make_shared<Drawing::Surface>();
2237 EXPECT_NE(surfaceTest3, nullptr);
2238 std::shared_ptr<Drawing::Surface> surfaceTest4 = std::make_shared<Drawing::Surface>();
2239 EXPECT_NE(surfaceTest4, nullptr);
2240 RSRenderNode::ClearCacheSurfaceFunc funcTest3 = [surfaceTest3, surfaceTest4](std::shared_ptr<Drawing::Surface>&& s1,
2241 std::shared_ptr<Drawing::Surface>&& s2, uint32_t w,
__anond072ea200302(std::shared_ptr<Drawing::Surface>&& s1, std::shared_ptr<Drawing::Surface>&& s2, uint32_t w, uint32_t h) 2242 uint32_t h) {};
2243 nodeTest->clearCacheSurfaceFunc_ = nullptr;
2244 nodeTest->cacheSurfaceThreadIndex_ = 1;
2245 nodeTest->completedSurfaceThreadIndex_ = 1;
2246 nodeTest->InitCacheSurface(gpuContextTest3, funcTest3, 1);
2247 EXPECT_EQ(nodeTest->cacheSurface_, nullptr);
2248 }
2249
2250 /**
2251 * @tc.name: DrawCacheSurfaceTest025
2252 * @tc.desc: DrawCacheSurface test
2253 * @tc.type: FUNC
2254 * @tc.require: issueIA61E9
2255 */
2256 HWTEST_F(RSRenderNodeTest, DrawCacheSurfaceTest025, TestSize.Level1)
2257 {
2258 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2259 EXPECT_NE(nodeTest, nullptr);
2260 nodeTest->boundsModifier_ = nullptr;
2261 nodeTest->frameModifier_ = nullptr;
2262 Drawing::Canvas canvasTest1;
2263 std::shared_ptr<Drawing::GPUContext> gpuContextTest1 = std::make_shared<Drawing::GPUContext>();
2264 canvasTest1.gpuContext_ = gpuContextTest1;
2265 RSPaintFilterCanvas paintFilterCanvasTest1(&canvasTest1);
2266
2267 nodeTest->boundsWidth_ = 0.0f;
2268 nodeTest->DrawCacheSurface(paintFilterCanvasTest1, 0, true);
2269 nodeTest->boundsWidth_ = 10.0f;
2270 nodeTest->DrawCacheSurface(paintFilterCanvasTest1, 0, false);
2271
2272 nodeTest->boundsWidth_ = 10.0f;
2273 nodeTest->boundsHeight_ = 10.0f;
2274 nodeTest->cacheCompletedBackendTexture_.isValid_ = false;
2275 paintFilterCanvasTest1.canvas_->paintBrush_.hasFilter_ = true;
2276 nodeTest->DrawCacheSurface(paintFilterCanvasTest1, 0, true);
2277 EXPECT_TRUE(paintFilterCanvasTest1.canvas_->paintBrush_.hasFilter_);
2278
2279 // RSSystemPrperties:GetRecordongEnabled() is false
2280 nodeTest->cacheCompletedBackendTexture_.isValid_ = true;
2281 RSShadow rsShadow;
2282 std::optional <RSShadow>shadow(rsShadow);
2283 nodeTest->renderContent_->renderProperties_.shadow_ = shadow;
2284 nodeTest->renderContent_->renderProperties_.shadow_->radius_ = 1.0f;
2285 nodeTest->cacheType_ = CacheType::ANIMATE_PROPERTY;
2286 Drawing::Canvas canvasTest2;
2287 std::shared_ptr<Drawing::GPUContext> gpuContextTest2 = std::make_shared<Drawing::GPUContext>();
2288 canvasTest2.gpuContext_ = gpuContextTest2;
2289 RSPaintFilterCanvas paintFilterCanvasTest2(&canvasTest2);
2290 std::shared_ptr<Drawing::SkiaCanvas> implTest1 = std::make_shared<Drawing::SkiaCanvas>();
2291 implTest1->skCanvas_ = nullptr;
2292 paintFilterCanvasTest2.canvas_->impl_ = implTest1;
2293 paintFilterCanvasTest2.canvas_->paintBrush_.hasFilter_ = true;
2294 nodeTest->DrawCacheSurface(paintFilterCanvasTest2, 0, true);
2295 EXPECT_NE(paintFilterCanvasTest2.canvas_, nullptr);
2296
2297 // RSSystemPrperties::GetRecordongEnabled() is false
2298 // cacheCompletedSurface_->GetImageSnapshot() and RSSystemProperties::GetRecordingEnabled() is false
2299 // so isUIFirst only is true
2300
2301 nodeTest->cacheType_ = CacheType::CONTENT;
2302 Drawing::Canvas canvasTest3;
2303 std::shared_ptr<Drawing::GPUContext> gpuContextTest3 = std::make_shared<Drawing::GPUContext>();
2304 canvasTest3.gpuContext_ = gpuContextTest3;
2305 RSPaintFilterCanvas paintFilterCanvasTest3(&canvasTest3);
2306 std::shared_ptr<Drawing::SkiaCanvas> implTest2 = std::make_shared<Drawing::SkiaCanvas>();
2307 implTest2->skCanvas_ = nullptr;
2308 paintFilterCanvasTest3.canvas_->impl_ = implTest2;
2309 paintFilterCanvasTest3.canvas_->paintBrush_.hasFilter_ = true;
2310 nodeTest->DrawCacheSurface(paintFilterCanvasTest3, 0, true);
2311 EXPECT_NE(paintFilterCanvasTest3.canvas_, nullptr);
2312 }
2313
2314 /**
2315 * @tc.name: GetCompletedImageTest026
2316 * @tc.desc: GetCompletedImage test
2317 * @tc.type: FUNC
2318 * @tc.require: issueI9V3BK
2319 */
2320 HWTEST_F(RSRenderNodeTest, GetCompletedImageTest026, TestSize.Level1)
2321 {
2322 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2323 EXPECT_NE(nodeTest, nullptr);
2324
2325 Drawing::Canvas canvastest;
2326 std::shared_ptr<Drawing::GPUContext> gpuContext = std::make_shared<Drawing::GPUContext>();
2327 EXPECT_NE(gpuContext, nullptr);
2328 canvastest.gpuContext_ = gpuContext;
2329 RSPaintFilterCanvas canvas(&canvastest);
2330
2331 std::shared_ptr<Drawing::Surface> cacheCompletedSurface = std::make_shared<Drawing::Surface>();
2332 EXPECT_NE(cacheCompletedSurface, nullptr);
2333 nodeTest->cacheCompletedSurface_ = cacheCompletedSurface;
2334
2335 nodeTest->cacheCompletedBackendTexture_.isValid_ = false;
2336 EXPECT_EQ(nodeTest->GetCompletedImage(canvas, 0, true), nullptr);
2337
2338 nodeTest->cacheCompletedBackendTexture_.isValid_ = true;
2339 #ifdef RS_ENABLE_VK
2340 // nullptr as cacheCompletedCleanupHelper_ is false
2341 nodeTest->GetCompletedImage(canvas, 0, true);
2342 #else
2343 EXPECT_NE(nodeTest->GetCompletedImage(canvas, 0, true), nullptr);
2344 #endif
2345
2346 // cacheCompletedSurface_->GetImageSnapshot() is false
2347 EXPECT_EQ(nodeTest->GetCompletedImage(canvas, 0, false), nullptr);
2348
2349 nodeTest->cacheCompletedSurface_ = nullptr;
2350 EXPECT_EQ(nodeTest->GetCompletedImage(canvas, 0, false), nullptr);
2351 }
2352
2353 /**
2354 * @tc.name: ManageCachingTest027
2355 * @tc.desc: GetCompletedCacheSurface GetCacheSurface MarkNodeGroup test
2356 * @tc.type: FUNC
2357 * @tc.require: issueI9V3BK
2358 */
2359 HWTEST_F(RSRenderNodeTest, ManageCachingTest027, TestSize.Level1)
2360 {
2361 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2362 EXPECT_NE(nodeTest, nullptr);
2363 nodeTest->InitRenderParams();
2364 // GetCompletedCacheSurface test
2365 nodeTest->cacheCompletedSurface_ = nullptr;
2366 EXPECT_EQ(nodeTest->GetCompletedCacheSurface(0, true, true), nullptr);
2367 EXPECT_EQ(nodeTest->GetCompletedCacheSurface(0, true, false), nullptr);
2368 std::shared_ptr<Drawing::Surface> cacheCompletedSurface = std::make_shared<Drawing::Surface>();
2369 EXPECT_NE(cacheCompletedSurface, nullptr);
2370 nodeTest->cacheCompletedSurface_ = cacheCompletedSurface;
2371
2372 EXPECT_NE(nodeTest->cacheCompletedSurface_, nullptr);
2373 EXPECT_NE(nodeTest->cacheCompletedSurface_, nullptr);
2374 EXPECT_EQ(nodeTest->GetCompletedCacheSurface(0, true, false), nullptr);
2375 EXPECT_EQ(nodeTest->GetCompletedCacheSurface(0, false, false), nullptr);
2376 nodeTest->completedSurfaceThreadIndex_ = 0;
2377 EXPECT_EQ(nodeTest->GetCompletedCacheSurface(0, true, false), nullptr);
2378 // GetCacheSurface test
2379 nodeTest->cacheSurface_ = nullptr;
2380 EXPECT_EQ(nodeTest->GetCacheSurface(0, true, true), nullptr);
2381 EXPECT_EQ(nodeTest->GetCacheSurface(0, true, false), nullptr);
2382 std::shared_ptr<Drawing::Surface> cacheSurface = std::make_shared<Drawing::Surface>();
2383 nodeTest->cacheSurface_ = cacheSurface;
2384 EXPECT_NE(nodeTest->cacheSurface_, nullptr);
2385 EXPECT_EQ(nodeTest->GetCacheSurface(0, true, false), nullptr);
2386 EXPECT_EQ(nodeTest->GetCacheSurface(0, false, false), nullptr);
2387 nodeTest->completedSurfaceThreadIndex_ = 0;
2388 EXPECT_EQ(nodeTest->GetCacheSurface(0, true, false), nullptr);
2389
2390 // MarkNodeGroup test
2391 nodeTest->nodeGroupIncludeProperty_ = false;
2392 nodeTest->nodeGroupType_ = RSRenderNode::NONE;
2393 std::shared_ptr<RSContext> contextTest = std::make_shared<RSContext>();
2394 contextTest->nodeMap.residentSurfaceNodeMap_.emplace(
2395 std::make_pair(0, std::make_shared<RSSurfaceRenderNode>(0, std::make_shared<RSContext>())));
2396 nodeTest->context_ = contextTest;
2397 nodeTest->MarkNodeGroup(RSRenderNode::GROUPED_BY_UI, true, true);
2398 EXPECT_EQ(nodeTest->nodeGroupType_, RSRenderNode::GROUPED_BY_UI);
2399 EXPECT_TRUE(nodeTest->nodeGroupIncludeProperty_);
2400
2401 nodeTest->MarkNodeGroup(RSRenderNode::NONE, true, true);
2402 EXPECT_TRUE(nodeTest->nodeGroupIncludeProperty_);
2403 nodeTest->MarkNodeGroup(RSRenderNode::NONE, false, true);
2404 EXPECT_TRUE(nodeTest->nodeGroupIncludeProperty_);
2405 }
2406
2407 /**
2408 * @tc.name: CheckGroupableAnimationTest028
2409 * @tc.desc: CheckGroupableAnimation test
2410 * @tc.type: FUNC
2411 * @tc.require: issueI9V3BK
2412 */
2413 HWTEST_F(RSRenderNodeTest, CheckGroupableAnimationTest028, TestSize.Level1)
2414 {
2415 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2416 EXPECT_NE(nodeTest, nullptr);
2417
2418 nodeTest->CheckGroupableAnimation(0, true);
2419
2420 nodeTest->CheckGroupableAnimation(1, true);
2421
2422 std::shared_ptr<RSCanvasRenderNode> canvasRenderNodeTest = std::make_shared<RSCanvasRenderNode>(0);
2423 EXPECT_NE(canvasRenderNodeTest, nullptr);
2424 std::shared_ptr<RSContext> context = nullptr;
2425 nodeTest->context_ = context;
2426 // RSSystemProperties::GetAnimationCacheEnabled() is false
2427 canvasRenderNodeTest->CheckGroupableAnimation(1, true);
2428 }
2429
2430 /**
2431 * @tc.name: ClearCacheSurfaceInThreadTest029
2432 * @tc.desc: ClearCacheSurfaceInThread test
2433 * @tc.type: FUNC
2434 * @tc.require: issueI9V3BK
2435 */
2436 HWTEST_F(RSRenderNodeTest, ClearCacheSurfaceInThreadTest029, TestSize.Level1)
2437 {
2438 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2439 EXPECT_NE(nodeTest, nullptr);
2440
2441 std::shared_ptr<Drawing::Surface> surfaceTest1 = std::make_shared<Drawing::Surface>();
2442 EXPECT_NE(surfaceTest1, nullptr);
2443 std::shared_ptr<Drawing::Surface> surfaceTest2 = std::make_shared<Drawing::Surface>();
2444 EXPECT_NE(surfaceTest2, nullptr);
2445 nodeTest->clearCacheSurfaceFunc_ = [surfaceTest1, surfaceTest2](std::shared_ptr<Drawing::Surface>&& s1,
__anond072ea200402(std::shared_ptr<Drawing::Surface>&& s1, std::shared_ptr<Drawing::Surface>&& s2, uint32_t w, uint32_t h) 2446 std::shared_ptr<Drawing::Surface>&& s2, uint32_t w, uint32_t h) {};
2447 nodeTest->ClearCacheSurfaceInThread();
2448 }
2449
2450 /**
2451 * @tc.name: MarkFilterCacheFlags001
2452 * @tc.desc: test
2453 * @tc.type: FUNC
2454 * @tc.require: issueI9T3XY
2455 */
2456 HWTEST_F(RSRenderNodeTest, MarkFilterCacheFlags001, TestSize.Level1)
2457 {
2458 RSRenderNode node(id, context);
2459 bool needRequestNextVsync = true;
2460 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
2461 std::shared_ptr<DrawableV2::RSFilterDrawable> filterDrawable = std::make_shared<DrawableV2::RSFilterDrawable>();
2462 filterDrawable->stagingForceClearCache_ = true;
2463 filterDrawable->stagingForceUseCache_ = true;
2464 filterDrawable->pendingPurge_ = true;
2465 auto& properties = node.GetMutableRenderProperties();
2466 properties.backgroundFilter_ = std::make_shared<RSFilter>();
2467 properties.filter_ = std::make_shared<RSFilter>();
2468 node.MarkFilterCacheFlags(filterDrawable, *rsDirtyManager, needRequestNextVsync);
2469 ASSERT_TRUE(true);
2470 }
2471
2472 /**
2473 * @tc.name: MarkFilterCacheFlags002
2474 * @tc.desc: test
2475 * @tc.type: FUNC
2476 * @tc.require: issueI9T3XY
2477 */
2478 HWTEST_F(RSRenderNodeTest, MarkFilterCacheFlags002, TestSize.Level1)
2479 {
2480 RSRenderNode node(id, context);
2481 bool needRequestNextVsync = false;
2482 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
2483 std::shared_ptr<DrawableV2::RSFilterDrawable> filterDrawable = std::make_shared<DrawableV2::RSFilterDrawable>();
2484 filterDrawable->stagingForceClearCache_ = true;
2485 filterDrawable->stagingForceUseCache_ = true;
2486 filterDrawable->stagingFilterInteractWithDirty_ = true;
2487 filterDrawable->cacheUpdateInterval_ = 1;
2488 auto& properties = node.GetMutableRenderProperties();
2489 properties.backgroundFilter_ = std::make_shared<RSFilter>();
2490 properties.filter_ = std::make_shared<RSFilter>();
2491 node.MarkFilterCacheFlags(filterDrawable, *rsDirtyManager, needRequestNextVsync);
2492 ASSERT_TRUE(true);
2493 }
2494
2495 /**
2496 * @tc.name: CheckFilterCacheAndUpdateDirtySlots
2497 * @tc.desc: test
2498 * @tc.type: FUNC
2499 * @tc.require: issueI9T3XY
2500 */
2501 HWTEST_F(RSRenderNodeTest, CheckFilterCacheAndUpdateDirtySlots, TestSize.Level1)
2502 {
2503 RSRenderNode node(id, context);
2504 std::shared_ptr<DrawableV2::RSFilterDrawable> filterDrawable = std::make_shared<DrawableV2::RSFilterDrawable>();
2505 RSDrawableSlot slot = RSDrawableSlot::SHADOW;
2506 node.CheckFilterCacheAndUpdateDirtySlots(filterDrawable, slot);
2507 ASSERT_TRUE(true);
2508 }
2509
2510 /**
2511 * @tc.name: MarkForceClearFilterCacheWithInvisible
2512 * @tc.desc: test
2513 * @tc.type: FUNC
2514 * @tc.require: issueI9T3XY
2515 */
2516 HWTEST_F(RSRenderNodeTest, MarkForceClearFilterCacheWithInvisible, TestSize.Level1)
2517 {
2518 RSRenderNode node(id, context);
2519 auto& properties = node.GetMutableRenderProperties();
2520 properties.backgroundFilter_ = std::make_shared<RSFilter>();
2521 properties.filter_ = std::make_shared<RSFilter>();
2522 node.MarkForceClearFilterCacheWithInvisible();
2523 ASSERT_TRUE(true);
2524 }
2525
2526 /**
2527 * @tc.name: SetOccludedStatus
2528 * @tc.desc: test
2529 * @tc.type: FUNC
2530 * @tc.require: issueI9T3XY
2531 */
2532 HWTEST_F(RSRenderNodeTest, SetOccludedStatus, TestSize.Level1)
2533 {
2534 RSRenderNode node(id, context);
2535 auto& properties = node.GetMutableRenderProperties();
2536 properties.backgroundFilter_ = std::make_shared<RSFilter>();
2537 properties.filter_ = std::make_shared<RSFilter>();
2538 bool occluded = true;
2539 node.SetOccludedStatus(occluded);
2540 ASSERT_TRUE(true);
2541 }
2542
2543 /**
2544 * @tc.name: RenderTraceDebug
2545 * @tc.desc: test
2546 * @tc.type: FUNC
2547 * @tc.require: issueI9T3XY
2548 */
2549 HWTEST_F(RSRenderNodeTest, RenderTraceDebug, TestSize.Level1)
2550 {
2551 RSRenderNode node(id, context);
2552 node.RenderTraceDebug();
2553 ASSERT_TRUE(true);
2554 }
2555
2556 /**
2557 * @tc.name: ApplyBoundsGeometry
2558 * @tc.desc: test
2559 * @tc.type: FUNC
2560 * @tc.require: issueI9T3XY
2561 */
2562 HWTEST_F(RSRenderNodeTest, ApplyBoundsGeometry, TestSize.Level1)
2563 {
2564 RSRenderNode node(id, context);
2565 node.ApplyBoundsGeometry(*canvas_);
2566 ASSERT_TRUE(true);
2567 }
2568
2569 /**
2570 * @tc.name: ApplyAlpha
2571 * @tc.desc: test
2572 * @tc.type: FUNC
2573 * @tc.require: issueI9T3XY
2574 */
2575 HWTEST_F(RSRenderNodeTest, ApplyAlpha, TestSize.Level1)
2576 {
2577 RSRenderNode node(id, context);
2578 node.ApplyAlpha(*canvas_);
2579 ASSERT_TRUE(true);
2580 }
2581
2582 /**
2583 * @tc.name: ProcessRenderBeforeChildren
2584 * @tc.desc: test
2585 * @tc.type: FUNC
2586 * @tc.require: issueI9T3XY
2587 */
2588 HWTEST_F(RSRenderNodeTest, ProcessRenderBeforeChildren, TestSize.Level1)
2589 {
2590 RSRenderNode node(id, context);
2591 node.ProcessRenderBeforeChildren(*canvas_);
2592 ASSERT_TRUE(true);
2593 }
2594
2595 /**
2596 * @tc.name: ProcessTransitionAfterChildren
2597 * @tc.desc: test
2598 * @tc.type: FUNC
2599 * @tc.require: issueI9T3XY
2600 */
2601 HWTEST_F(RSRenderNodeTest, ProcessTransitionAfterChildren, TestSize.Level1)
2602 {
2603 RSRenderNode node(id, context);
2604 node.ProcessTransitionAfterChildren(*canvas_);
2605 ASSERT_TRUE(true);
2606 }
2607
2608 /**
2609 * @tc.name: UpdateDirtyRegionInfoForDFX001
2610 * @tc.desc: test if subTreeDirtyRegion can be correctly collected.
2611 * @tc.type: FUNC
2612 * @tc.require: issueA7UVD
2613 */
2614 HWTEST_F(RSRenderNodeTest, UpdateDirtyRegionInfoForDFX001, TestSize.Level1)
2615 {
2616 bool isPropertyChanged = false;
2617 if (RSSystemProperties::GetDirtyRegionDebugType() == DirtyRegionDebugType::DISABLED) {
2618 system::SetParameter("rosen.dirtyregiondebug.enabled", "1");
2619 ASSERT_NE(RSSystemProperties::GetDirtyRegionDebugType(), DirtyRegionDebugType::DISABLED);
2620 isPropertyChanged = true;
2621 }
2622 auto canvasNode = std::make_shared<RSCanvasRenderNode>(DEFAULT_NODE_ID, context);
2623 canvasNode->InitRenderParams();
2624 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
2625 canvasNode->lastFrameSubTreeSkipped_ = true;
2626 canvasNode->subTreeDirtyRegion_ = RectI(0, 0, DEFAULT_BOUNDS_SIZE, DEFAULT_BOUNDS_SIZE);
2627 // 'resize' added to avoid segmentation fault crash in
2628 // the RSDirtyRegionManager::UpdateDirtyRegionInfoForDfx() in line
2629 // dirtyCanvasNodeInfo_[dirtyType].emplace(std::make_pair(id, rect))
2630 rsDirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
2631 canvasNode->UpdateDirtyRegionInfoForDFX(*rsDirtyManager);
2632 EXPECT_FALSE(rsDirtyManager->dirtyCanvasNodeInfo_.empty());
2633 if (isPropertyChanged) {
2634 system::SetParameter("rosen.dirtyregiondebug.enabled", "0");
2635 ASSERT_EQ(RSSystemProperties::GetDirtyRegionDebugType(), DirtyRegionDebugType::DISABLED);
2636 }
2637 }
2638
2639 /**
2640 * @tc.name: UpdateDirtyRegionInfoForDFX002
2641 * @tc.desc: test if absDrawRect can be correctly collected when clip property is true.
2642 * @tc.type: FUNC
2643 * @tc.require: issueA7UVD
2644 */
2645 HWTEST_F(RSRenderNodeTest, UpdateDirtyRegionInfoForDFX002, TestSize.Level1)
2646 {
2647 bool isPropertyChanged = false;
2648 if (RSSystemProperties::GetDirtyRegionDebugType() == DirtyRegionDebugType::DISABLED) {
2649 system::SetParameter("rosen.dirtyregiondebug.enabled", "1");
2650 ASSERT_NE(RSSystemProperties::GetDirtyRegionDebugType(), DirtyRegionDebugType::DISABLED);
2651 isPropertyChanged = true;
2652 }
2653 auto canvasNode = std::make_shared<RSCanvasRenderNode>(DEFAULT_NODE_ID, context);
2654 canvasNode->InitRenderParams();
2655 std::shared_ptr<RSDirtyRegionManager> rsDirtyManager = std::make_shared<RSDirtyRegionManager>();
2656 auto& properties = canvasNode->GetMutableRenderProperties();
2657 properties.clipToBounds_ = true;
2658 canvasNode->absDrawRect_ = RectI(0, 0, DEFAULT_BOUNDS_SIZE, DEFAULT_BOUNDS_SIZE);
2659 // 'resize' added to avoid segmentation fault crash in
2660 // the RSDirtyRegionManager::UpdateDirtyRegionInfoForDfx() in line
2661 // dirtyCanvasNodeInfo_[dirtyType].emplace(std::make_pair(id, rect))
2662 rsDirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
2663 canvasNode->UpdateDirtyRegionInfoForDFX(*rsDirtyManager);
2664 EXPECT_FALSE(rsDirtyManager->dirtyCanvasNodeInfo_.empty());
2665 if (isPropertyChanged) {
2666 system::SetParameter("rosen.dirtyregiondebug.enabled", "0");
2667 ASSERT_EQ(RSSystemProperties::GetDirtyRegionDebugType(), DirtyRegionDebugType::DISABLED);
2668 }
2669 }
2670
2671 } // namespace Rosen
2672 } // namespace OHOS
2673