1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <memory>
17 #include "gtest/gtest.h"
18 #include "limit_number.h"
19 #include "pipeline/rs_uni_render_visitor.h"
20 #include "pipeline/rs_render_node.h"
21 #include "pipeline/rs_root_render_node.h"
22 #include "pipeline/rs_base_render_node.h"
23 #include "pipeline/rs_proxy_render_node.h"
24 #include "pipeline/rs_surface_render_node.h"
25 #include "pipeline/rs_display_render_node.h"
26 #include "pipeline/rs_context.h"
27 #include "pipeline/rs_uni_render_engine.h"
28 #include "pipeline/rs_uni_render_judgement.h"
29 #include "pipeline/rs_effect_render_node.h"
30 #include "pipeline/rs_processor_factory.h"
31 #include "pipeline/rs_uni_render_util.h"
32 #include "rs_test_util.h"
33 #include "system/rs_system_parameters.h"
34 #include "draw/color.h"
35 #include "pipeline/rs_main_thread.h"
36 #include "mock/mock_matrix.h"
37
38 using namespace testing;
39 using namespace testing::ext;
40
41 namespace {
42 const std::string DEFAULT_NODE_NAME = "1";
43 const std::string INVALID_NODE_NAME = "2";
44 const int DEFAULT_DIRTY_REGION_WIDTH = 10;
45 const int DEFAULT_DIRTY_REGION_HEIGHT = 10;
46 constexpr uint32_t DEFAULT_CANVAS_WIDTH = 800;
47 constexpr uint32_t DEFAULT_CANVAS_HEIGHT = 600;
48 }
49
50 namespace OHOS::Rosen {
51 class RSUniRenderVisitorTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp() override;
56 void TearDown() override;
57
58 static inline Mock::MatrixMock* matrixMock_;
59 };
60
SetUpTestCase()61 void RSUniRenderVisitorTest::SetUpTestCase()
62 {
63 matrixMock_ = Mock::MatrixMock::GetInstance();
64 EXPECT_CALL(*matrixMock_, GetMinMaxScales(_)).WillOnce(testing::Return(false));
65 }
TearDownTestCase()66 void RSUniRenderVisitorTest::TearDownTestCase() {}
SetUp()67 void RSUniRenderVisitorTest::SetUp() {}
TearDown()68 void RSUniRenderVisitorTest::TearDown()
69 {
70 system::SetParameter("rosen.dirtyregiondebug.enabled", "0");
71 system::SetParameter("rosen.uni.partialrender.enabled", "4");
72 system::GetParameter("rosen.dirtyregiondebug.surfacenames", "0");
73 }
74
75 /*
76 * @tc.name: UpdateSurfaceRenderNodeScaleTest
77 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSurfaceRenderNodeScaleTest
78 * @tc.type: FUNC
79 * @tc.require: issueI79U8E
80 */
81 HWTEST_F(RSUniRenderVisitorTest, UpdateSurfaceRenderNodeScaleTest, TestSize.Level2)
82 {
83 auto rsContext = std::make_shared<RSContext>();
84 ASSERT_NE(rsContext, nullptr);
85 RSSurfaceRenderNodeConfig config;
86 config.id = 11; // leash window config id
87 config.name = "leashWindowNode";
88 auto leashWindowNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
89 ASSERT_NE(leashWindowNode, nullptr);
90 leashWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
91
92 auto deviceTypeStr = system::GetParameter("const.product.devicetype", "pc");
93 system::SetParameter("const.product.devicetype", "pc");
94 RSMainThread::Instance()->SetDeviceType();
95 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
96 ASSERT_NE(rsUniRenderVisitor, nullptr);
97 rsUniRenderVisitor->UpdateSurfaceRenderNodeScale(*leashWindowNode);
98 system::SetParameter("const.product.devicetype", deviceTypeStr);
99 RSMainThread::Instance()->SetDeviceType();
100 }
101
102 /*
103 * @tc.name: PrepareRootRenderNodeTest
104 * @tc.desc: Test RSUniRenderVisitorTest.PrepareRootRenderNodeTest
105 * @tc.type: FUNC
106 * @tc.require: issueI79U8E
107 */
108 HWTEST_F(RSUniRenderVisitorTest, PrepareRootRenderNodeTest, TestSize.Level2)
109 {
110 auto rsContext = std::make_shared<RSContext>();
111 ASSERT_NE(rsContext, nullptr);
112 auto rsRootRenderNode = std::make_shared<RSRootRenderNode>(0, rsContext->weak_from_this());
113 ASSERT_NE(rsRootRenderNode, nullptr);
114 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
115 ASSERT_NE(rsUniRenderVisitor, nullptr);
116 rsUniRenderVisitor->drivenInfo_ = std::make_unique<DrivenInfo>();
117 ASSERT_NE(rsUniRenderVisitor->drivenInfo_, nullptr);
118
119 rsUniRenderVisitor->PrepareRootRenderNode(*rsRootRenderNode);
120 rsUniRenderVisitor->drivenInfo_->drivenUniTreePrepareMode = DrivenUniTreePrepareMode::PREPARE_DRIVEN_NODE_AFTER;
121 rsUniRenderVisitor->PrepareRootRenderNode(*rsRootRenderNode);
122 rsUniRenderVisitor->curSurfaceDirtyManager_ = nullptr;
123 rsUniRenderVisitor->PrepareRootRenderNode(*rsRootRenderNode);
124 }
125
126 /*
127 * @tc.name: PrepareCanvasRenderNodeTest
128 * @tc.desc: Test RSUniRenderVisitorTest.PrepareCanvasRenderNodeTest
129 * @tc.type: FUNC
130 * @tc.require: issueI79U8E
131 */
132 HWTEST_F(RSUniRenderVisitorTest, PrepareCanvasRenderNodeTest, TestSize.Level2)
133 {
134 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
135 ASSERT_NE(rsUniRenderVisitor, nullptr);
136 auto rsContext = std::make_shared<RSContext>();
137 ASSERT_NE(rsContext, nullptr);
138 auto rsCanvasRenderNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
139 ASSERT_NE(rsCanvasRenderNode, nullptr);
140
141 RSSurfaceRenderNodeConfig config;
142 config.id = 10;
143 config.name = "scbScreenNode";
144 auto scbScreenNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
145 ASSERT_NE(scbScreenNode, nullptr);
146 scbScreenNode->SetSurfaceNodeType(RSSurfaceNodeType::SCB_SCREEN_NODE);
147
148 config.id = 11;
149 config.name = "leashWindowNode";
150 auto leashWindowNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
151 ASSERT_NE(leashWindowNode, nullptr);
152 leashWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
153
154 rsCanvasRenderNode->SetParent(std::weak_ptr<RSSurfaceRenderNode>(leashWindowNode));
155 rsUniRenderVisitor->PrepareCanvasRenderNode(*rsCanvasRenderNode);
156
157 rsCanvasRenderNode->SetParent(std::weak_ptr<RSSurfaceRenderNode>(scbScreenNode));
158 RSDisplayNodeConfig displayConfig;
159 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
160 rsUniRenderVisitor->curDisplayDirtyManager_ = rsDisplayRenderNode->GetDirtyManager();
161 auto pairedNode = RSTestUtil::CreateSurfaceNode();
162 rsCanvasRenderNode->sharedTransitionParam_ = {rsCanvasRenderNode->GetId(), pairedNode};
163 rsUniRenderVisitor->drivenInfo_ = std::make_unique<DrivenInfo>();
164 ASSERT_NE(rsUniRenderVisitor->drivenInfo_, nullptr);
165 rsUniRenderVisitor->currentVisitDisplay_ = 0;
166 rsUniRenderVisitor->drivenInfo_->isPrepareLeashWinSubTree = true;
167 rsCanvasRenderNode->isMarkDriven_ = true;
168 rsCanvasRenderNode->isMarkDrivenRender_ = true;
169 rsCanvasRenderNode->isContentChanged_ = true;
170 rsUniRenderVisitor->PrepareCanvasRenderNode(*rsCanvasRenderNode);
171
172 rsUniRenderVisitor->drivenInfo_->drivenUniTreePrepareMode = DrivenUniTreePrepareMode::PREPARE_DRIVEN_NODE_AFTER;
173 rsUniRenderVisitor->PrepareCanvasRenderNode(*rsCanvasRenderNode);
174
175 rsUniRenderVisitor->drivenInfo_->drivenUniTreePrepareMode = DrivenUniTreePrepareMode::PREPARE_DRIVEN_NODE_BEFORE;
176 rsUniRenderVisitor->PrepareCanvasRenderNode(*rsCanvasRenderNode);
177 }
178
179 /*
180 * @tc.name: DrawCacheRegionForDFX001
181 * @tc.desc: Test RSUniRenderVisitorTest.DrawCacheRegionForDFX001
182 * @tc.type: FUNC
183 * @tc.require: issueI79U8E
184 */
185 HWTEST_F(RSUniRenderVisitorTest, DrawCacheRegionForDFX001, TestSize.Level2)
186 {
187 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
188 ASSERT_NE(rsUniRenderVisitor, nullptr);
189 RectI rect(0, 0, 0, 0);
190 std::vector<RectI> dirtyRects;
191 dirtyRects.push_back(rect);
192 rsUniRenderVisitor->DrawCacheRegionForDFX(dirtyRects);
193 }
194
195 /*
196 * @tc.name: DrawEffectRenderNodeForDFX003
197 * @tc.desc: Test RSUniRenderVisitorTest.DrawEffectRenderNodeForDFX003
198 * @tc.type: FUNC
199 * @tc.require: issueI79U8E
200 */
201 HWTEST_F(RSUniRenderVisitorTest, DrawEffectRenderNodeForDFX003, TestSize.Level2)
202 {
203 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
204 ASSERT_NE(rsUniRenderVisitor, nullptr);
205 RectI rect(0, 0, 0, 0);
206 std::vector<RectI> nodesUseEffectFallbackForDfx;
207 nodesUseEffectFallbackForDfx.push_back(rect);
208 std::vector<RectI> nodesUseEffectForDfx;
209 nodesUseEffectForDfx.push_back(rect);
210 NodeId id = 0;
211 std::weak_ptr<RSContext> context;
212 std::shared_ptr<RSEffectRenderNode> node = std::make_shared<RSEffectRenderNode>(id, context);
213 ASSERT_NE(node, nullptr);
214 rsUniRenderVisitor->effectNodeMapForDfx_[node->GetId()].first = nodesUseEffectForDfx;
215 rsUniRenderVisitor->effectNodeMapForDfx_[node->GetId()].second = nodesUseEffectFallbackForDfx;
216 RSMainThread::Instance()->GetContext().GetMutableNodeMap().RegisterRenderNode(node);
217 rsUniRenderVisitor->DrawEffectRenderNodeForDFX();
218 }
219
220 /*
221 * @tc.name: PrepareChildren001
222 * @tc.desc: PrepareChildren Test
223 * @tc.type: FUNC
224 * @tc.require: issueI79U8E
225 */
226 HWTEST_F(RSUniRenderVisitorTest, PrepareChildren001, TestSize.Level1)
227 {
228 auto rsContext = std::make_shared<RSContext>();
229 auto rsBaseRenderNode = std::make_shared<RSBaseRenderNode>(10, rsContext->weak_from_this());
230 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
231 rsUniRenderVisitor->PrepareChildren(*rsBaseRenderNode);
232 }
233
234 /*
235 * @tc.name: SetHardwareEnabledNodes001
236 * @tc.desc: SetHardwareEnabledNodes Test
237 * @tc.type: FUNC
238 * @tc.require: issueI79U8E
239 */
240 HWTEST_F(RSUniRenderVisitorTest, SetHardwareEnabledNodes001, TestSize.Level1)
241 {
242 auto rsContext = std::make_shared<RSContext>();
243 auto rsRootRenderNode = std::make_shared<RSRootRenderNode>(10, rsContext->weak_from_this());
244 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
245 rsUniRenderVisitor->DoDirectComposition(rsRootRenderNode);
246 }
247
248 /*
249 * @tc.name: DrawAllSurfaceOpaqueRegionForDFX001
250 * @tc.desc: DrawAllSurfaceOpaqueRegionForDFX Test
251 * @tc.type: FUNC
252 * @tc.require: issueI79U8E
253 */
254 HWTEST_F(RSUniRenderVisitorTest, DrawAllSurfaceOpaqueRegionForDFX001, TestSize.Level1)
255 {
256 system::SetParameter("rosen.uni.opaqueregiondebug", "1");
257 auto rsContext = std::make_shared<RSContext>();
258 RSSurfaceRenderNodeConfig config;
259 RSDisplayNodeConfig displayConfig;
260 config.id = 10;
261 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
262 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
263 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
264 rsSurfaceRenderNode->SetSrcRect(RectI(0, 0, 10, 10));
265 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
266 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
267 sptr<RSScreenManager> screenManager = CreateOrGetScreenManager();
268 ASSERT_NE(screenManager, nullptr);
269 rsDisplayRenderNode->SetScreenId(0);
270 auto rsScreen = std::make_unique<impl::RSScreen>(0, false, HdiOutput::CreateHdiOutput(0), nullptr);
271 screenManager->MockHdiScreenConnected(rsScreen);
272 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
273 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
274 system::SetParameter("rosen.uni.opaqueregiondebug", "0");
275 }
276
277 /*
278 * @tc.name: DrawTargetSurfaceDirtyRegionForDFX001
279 * @tc.desc: DrawTargetSurfaceDirtyRegionForDFX Test
280 * @tc.type: FUNC
281 * @tc.require: issueI79U8E
282 */
283 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceDirtyRegionForDFX001, TestSize.Level1)
284 {
285 auto rsContext = std::make_shared<RSContext>();
286 RSSurfaceRenderNodeConfig config;
287 RSDisplayNodeConfig displayConfig;
288 config.name = "SurfaceDirtyDFX";
289 config.id = 10;
290 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
291 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
292 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
293 rsSurfaceRenderNode->SetSrcRect(RectI(0, 0, 10, 10));
294 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
295 sptr<RSScreenManager> screenManager = CreateOrGetScreenManager();
296 ASSERT_NE(screenManager, nullptr);
297 rsDisplayRenderNode->SetScreenId(0);
298 auto rsScreen = std::make_unique<impl::RSScreen>(0, false, HdiOutput::CreateHdiOutput(0), nullptr);
299 screenManager->MockHdiScreenConnected(rsScreen);
300 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
301 system::SetParameter("rosen.dirtyregiondebug.surfacenames", "SurfaceDirtyDFX");
302 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
303 system::SetParameter("rosen.dirtyregiondebug.surfacenames", "0");
304 }
305
306 HWTEST_F(RSUniRenderVisitorTest, PrepareProxyRenderNode001, TestSize.Level1)
307 {
308 RSSurfaceRenderNodeConfig config;
309 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config);
310 std::weak_ptr<RSSurfaceRenderNode> rsSurfaceRenderNodeW(rsSurfaceRenderNode);
311 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
312 auto rsContext = std::make_shared<RSContext>();
313
314 NodeId id = 0;
315 NodeId targetID = 0;
316 std::shared_ptr<RSProxyRenderNode> rsProxyRenderNode(
317 new RSProxyRenderNode(id, rsSurfaceRenderNodeW, targetID, rsContext->weak_from_this()));
318 rsUniRenderVisitor->dirtyFlag_ = true;
319 auto rsBaseRenderNode = std::make_shared<RSBaseRenderNode>(10, rsContext->weak_from_this());
320 rsUniRenderVisitor->logicParentNode_ = rsBaseRenderNode->weak_from_this();
321 rsUniRenderVisitor->PrepareProxyRenderNode(*rsProxyRenderNode);
322 #ifndef USE_ROSEN_DRAWING
323 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
324 ASSERT_NE(skCanvas, nullptr);
325 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
326 #else
327 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
328 ASSERT_NE(drawingCanvas, nullptr);
329 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
330 #endif
331 system::SetParameter("persist.sys.graphic.proxyNodeDebugEnabled", "0");
332 rsUniRenderVisitor->ProcessProxyRenderNode(*rsProxyRenderNode);
333
334 config.id = 1;
335 auto rsSurfaceRenderNodeS = std::make_shared<RSSurfaceRenderNode>(config);
336 rsSurfaceRenderNodeS->AddChild(rsProxyRenderNode, 1);
337 rsProxyRenderNode->Prepare(rsUniRenderVisitor);
338 }
339
340 HWTEST_F(RSUniRenderVisitorTest, RSDisplayRenderNode001, TestSize.Level1)
341 {
342 RSDisplayNodeConfig config;
343 auto rsContext = std::make_shared<RSContext>();
344 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(0, config, rsContext->weak_from_this());
345 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
346
347 rsDisplayRenderNode->Prepare(rsUniRenderVisitor);
348 rsDisplayRenderNode->Process(rsUniRenderVisitor);
349 }
350
351 /*
352 * @tc.name: CheckQuickSkipPrepareParamSetAndGetValid001
353 * @tc.desc: Check if param set and get apis are valid.
354 * @tc.type: FUNC
355 * @tc.require: I67FKA
356 */
357 HWTEST_F(RSUniRenderVisitorTest, CheckQuickSkipPrepareParamSetAndGetValid001, TestSize.Level1)
358 {
359 int defaultParam = (int)RSSystemParameters::GetQuickSkipPrepareType();
360 (void)system::SetParameter("rosen.quickskipprepare.enabled", "0");
361 int param = (int)RSSystemParameters::GetQuickSkipPrepareType();
362 ASSERT_EQ(param, 0);
363 (void)system::SetParameter("rosen.quickskipprepare.enabled", "1");
364 param = (int)RSSystemParameters::GetQuickSkipPrepareType();
365 ASSERT_EQ(param, 1);
366
367 NodeId testId = 10;
368 pid_t pid = ExtractPid(testId);
369 ASSERT_EQ(pid, 0);
370 const int paddingDigit = 32;
371 NodeId testPid = testId << paddingDigit;
372 pid = ExtractPid(testPid);
373 ASSERT_EQ(pid, testId);
374 (void)system::SetParameter("rosen.quickskipprepare.enabled", std::to_string(defaultParam));
375 }
376
377 /*
378 * @tc.name: CheckSurfaceRenderNodeNotStatic001
379 * @tc.desc: Generate not static surface render node(self drawing, leash window) and execute preparation step.
380 * Get trace and check corresponding node's preparation exists and no 'Skip' info.
381 * @tc.type: FUNC
382 * @tc.require: I67FKA
383 */
384 HWTEST_F(RSUniRenderVisitorTest, CheckSurfaceRenderNodeNotStatic001, TestSize.Level1)
385 {
386 int defaultParam = (int)RSSystemParameters::GetQuickSkipPrepareType();
387 (void)system::SetParameter("rosen.quickskipprepare.enabled", "1");
388
389 auto rsContext = std::make_shared<RSContext>();
390 RSSurfaceRenderNodeConfig config;
391 config.id = 10;
392 config.name = "selfDrawTestNode";
393 auto selfDrawSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
394 selfDrawSurfaceRenderNode->SetSurfaceNodeType(RSSurfaceNodeType::SELF_DRAWING_NODE);
395 config.id = 11;
396 config.name = "leashWindowTestNode";
397 auto leashWindowNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
398 leashWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
399
400 RSDisplayNodeConfig displayConfig;
401 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(12, displayConfig, rsContext->weak_from_this());
402 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
403 rsDisplayRenderNode->AddChild(selfDrawSurfaceRenderNode, -1);
404 rsDisplayRenderNode->AddChild(leashWindowNode, -1);
405 // execute add child
406 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
407 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
408 // test if skip testNode
409 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
410 (void)system::SetParameter("rosen.quickskipprepare.enabled", std::to_string(defaultParam));
411 }
412
413 /*
414 * @tc.name: CheckSurfaceRenderNodeStatic001
415 * @tc.desc: Generate static surface render node(app window node) and execute preparation step.
416 * Get trace and check corresponding node's preparation and 'Skip' info exist.
417 * @tc.type: FUNC
418 * @tc.require: I67FKA
419 */
420 HWTEST_F(RSUniRenderVisitorTest, CheckSurfaceRenderNodeStatic001, TestSize.Level1)
421 {
422 int defaultParam = (int)RSSystemParameters::GetQuickSkipPrepareType();
423 (void)system::SetParameter("rosen.quickskipprepare.enabled", "1");
424
425 auto rsContext = std::make_shared<RSContext>();
426 RSSurfaceRenderNodeConfig config;
427 config.id = 10;
428 config.name = "appWindowTestNode";
429 auto defaultSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
430 defaultSurfaceRenderNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
431
432 RSDisplayNodeConfig displayConfig;
433 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
434 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
435 rsDisplayRenderNode->AddChild(defaultSurfaceRenderNode, -1);
436 // execute add child
437 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
438 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
439 // test if skip testNode
440 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
441 (void)system::SetParameter("rosen.quickskipprepare.enabled", std::to_string(defaultParam));
442 }
443
444 HWTEST_F(RSUniRenderVisitorTest, ProcessRootRenderNode001, TestSize.Level1)
445 {
446 auto rsContext = std::make_shared<RSContext>();
447 auto rsRootRenderNode = std::make_shared<RSRootRenderNode>(0, rsContext->weak_from_this());
448 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
449
450 rsUniRenderVisitor->PrepareRootRenderNode(*rsRootRenderNode);
451 rsUniRenderVisitor->ProcessRootRenderNode(*rsRootRenderNode);
452
453 auto& property = rsRootRenderNode->GetMutableRenderProperties();
454 property.SetVisible(false);
455 rsUniRenderVisitor->PrepareRootRenderNode(*rsRootRenderNode);
456
457 rsUniRenderVisitor->dirtyFlag_ = true;
458 rsUniRenderVisitor->ProcessRootRenderNode(*rsRootRenderNode);
459 }
460
461 /*
462 * @tc.name: CalcDirtyDisplayRegion
463 * @tc.desc: Set surface to transparent, add a canvas node to create a transparent dirty region
464 * @tc.type: FUNC
465 * @tc.require: I68IPR
466 */
467 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion, TestSize.Level1)
468 {
469 auto rsContext = std::make_shared<RSContext>();
470 RSSurfaceRenderNodeConfig config;
471 RSDisplayNodeConfig displayConfig;
472 config.id = 10;
473 auto rsCanvasRenderNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
474 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
475 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
476 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
477
478 Occlusion::Rect rect{0, 80, 2560, 1600};
479 Occlusion::Region region{rect};
480 VisibleData vData;
481 std::map<uint32_t, RSVisibleLevel> pidVisMap;
482
483 auto partialRenderType = RSSystemProperties::GetUniPartialRenderEnabled();
484 auto isPartialRenderEnabled = (partialRenderType != PartialRenderType::DISABLED);
485 ASSERT_EQ(isPartialRenderEnabled, true);
486
487 // set surface to transparent, add a canvas node to create a transparent dirty region
488 rsSurfaceRenderNode->SetAbilityBGAlpha(0);
489 rsSurfaceRenderNode->SetSrcRect(RectI(0, 80, 2560, 1600));
490 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
491 rsSurfaceRenderNode->AddChild(rsCanvasRenderNode, -1);
492
493 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
494 rsSurfaceRenderNode->SetVisibleRegionRecursive(region, vData, pidVisMap);
495 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
496 }
497
498 /*
499 * @tc.name: CalcDirtyRegionForFilterNode
500 * @tc.desc: Create a filter effect to test filter node
501 * @tc.type: FUNC
502 * @tc.require: I68IPR
503 */
504 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode, TestSize.Level1)
505 {
506 auto rsContext = std::make_shared<RSContext>();
507 RSSurfaceRenderNodeConfig config;
508 RSDisplayNodeConfig displayConfig;
509 config.id = 10;
510 auto rsCanvasRenderNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
511 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
512 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
513 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
514
515 rsSurfaceRenderNode->SetAbilityBGAlpha(0);
516 rsSurfaceRenderNode->SetSrcRect(RectI(0, 80, 2560, 1600));
517 // create a filter effect
518 float blurRadiusX = 30.0f;
519 float blurRadiusY = 30.0f;
520 auto filter = RSFilter::CreateBlurFilter(blurRadiusX, blurRadiusY);
521 rsCanvasRenderNode->GetMutableRenderProperties().SetFilter(filter);
522 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
523 rsSurfaceRenderNode->AddChild(rsCanvasRenderNode, -1);
524 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
525 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
526 }
527
528 /*
529 * @tc.name: SetSurfafaceGlobalDirtyRegion
530 * @tc.desc: Add two surfacenode child to test global dirty region
531 * @tc.type: FUNC
532 * @tc.require: I68IPR
533 */
534 HWTEST_F(RSUniRenderVisitorTest, SetSurfafaceGlobalDirtyRegion, TestSize.Level1)
535 {
536 auto rsContext = std::make_shared<RSContext>();
537 RSSurfaceRenderNodeConfig config;
538 config.id = 10;
539 auto rsSurfaceRenderNode1 = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
540 Occlusion::Rect rect{0, 80, 2560, 1600};
541 Occlusion::Region region{rect};
542 VisibleData vData;
543 std::map<uint32_t, RSVisibleLevel> pidVisMap;
544 rsSurfaceRenderNode1->SetVisibleRegionRecursive(region, vData, pidVisMap);
545
546 config.id = 11;
547 auto rsSurfaceRenderNode2 = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
548 Occlusion::Rect rect2{100, 100, 500, 1500};
549 Occlusion::Region region2{rect2};
550 rsSurfaceRenderNode2->SetVisibleRegionRecursive(region2, vData, pidVisMap);
551
552 RSDisplayNodeConfig displayConfig;
553 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(9, displayConfig, rsContext->weak_from_this());
554 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode1, -1);
555 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode2, -1);
556
557 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
558 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
559 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
560 }
561
562 /**
563 * @tc.name: CopyVisitorInfosTest
564 * @tc.desc: Test RSUniRenderVisitorTest.CopyVisitorInfosTest
565 * @tc.type: FUNC
566 * @tc.require: issueI79KM8
567 */
568 HWTEST_F(RSUniRenderVisitorTest, CopyVisitorInfosTest, TestSize.Level1)
569 {
570 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
571 auto newRsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
572 newRsUniRenderVisitor->CopyVisitorInfos(rsUniRenderVisitor);
573 ASSERT_EQ(rsUniRenderVisitor->currentVisitDisplay_, newRsUniRenderVisitor->currentVisitDisplay_);
574 }
575
576 /**
577 * @tc.name: CopyPropertyForParallelVisitorTest
578 * @tc.desc: Test RSUniRenderVisitorTest.CopyPropertyForParallelVisitorTest
579 * @tc.type: FUNC
580 * @tc.require: issueI79KM8
581 */
582 HWTEST_F(RSUniRenderVisitorTest, CopyPropertyForParallelVisitorTest, TestSize.Level1)
583 {
584 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
585 auto newRsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
586 newRsUniRenderVisitor->CopyPropertyForParallelVisitor(rsUniRenderVisitor.get());
587 ASSERT_EQ(rsUniRenderVisitor->doAnimate_, newRsUniRenderVisitor->doAnimate_);
588 }
589
590 /**
591 * @tc.name: ClearTransparentBeforeSaveLayerTest
592 * @tc.desc: Test RSUniRenderVisitorTest.ClearTransparentBeforeSaveLayerTest
593 * @tc.type: FUNC
594 * @tc.require: issueI79KM8
595 */
596 HWTEST_F(RSUniRenderVisitorTest, ClearTransparentBeforeSaveLayerTest, TestSize.Level1)
597 {
598 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
599 ASSERT_NE(rsUniRenderVisitor, nullptr);
600 rsUniRenderVisitor->isHardwareForcedDisabled_ = true;
601 rsUniRenderVisitor->doAnimate_ = false;
602 rsUniRenderVisitor->ClearTransparentBeforeSaveLayer();
603 ASSERT_EQ(false, rsUniRenderVisitor->IsHardwareComposerEnabled());
604
605 auto rsUniRenderVisitor2 = std::make_shared<RSUniRenderVisitor>();
606 ASSERT_NE(rsUniRenderVisitor2, nullptr);
607 rsUniRenderVisitor2->isHardwareForcedDisabled_ = true;
608 rsUniRenderVisitor2->doAnimate_ = false;
609 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
610 ASSERT_NE(drawingCanvas, nullptr);
611 rsUniRenderVisitor2->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
612 RSSurfaceRenderNodeConfig config;
613 std::vector<std::shared_ptr<RSSurfaceRenderNode>> hardwareEnabledNodes;
614 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(config);
615 ASSERT_NE(node, nullptr);
616 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
617 node->SetDstRect(DstRect);
618 hardwareEnabledNodes.emplace_back(node);
619 std::shared_ptr<RSSurfaceRenderNode> node2 = std::make_shared<RSSurfaceRenderNode>(config);
620 ASSERT_NE(node2, nullptr);
621 hardwareEnabledNodes.emplace_back(node2);
622 std::shared_ptr<RSSurfaceRenderNode> node3 = std::make_shared<RSSurfaceRenderNode>(config);
623 ASSERT_NE(node3, nullptr);
624 node3->shouldPaint_ = false;
625 hardwareEnabledNodes.emplace_back(node3);
626 rsUniRenderVisitor2->SetHardwareEnabledNodes(hardwareEnabledNodes);
627 rsUniRenderVisitor->ClearTransparentBeforeSaveLayer();
628 }
629
630 /**
631 * @tc.name: MarkSubHardwareEnableNodeStateTest001
632 * @tc.desc: Test RSUniRenderVisitorTest.MarkSubHardwareEnableNodeStateTest
633 * @tc.type: FUNC
634 * @tc.require: issueI79KM8
635 */
636 HWTEST_F(RSUniRenderVisitorTest, MarkSubHardwareEnableNodeStateTest001, TestSize.Level1)
637 {
638 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
639 ASSERT_NE(rsUniRenderVisitor, nullptr);
640 auto rsContext = std::make_shared<RSContext>();
641 RSSurfaceRenderNodeConfig config;
642 config.id = 10;
643 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
644 ASSERT_NE(rsSurfaceRenderNode, nullptr);
645 rsSurfaceRenderNode->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
646 rsSurfaceRenderNode->name_ = "";
647 rsUniRenderVisitor->MarkSubHardwareEnableNodeState(*rsSurfaceRenderNode);
648 }
649
650 /**
651 * @tc.name: MarkSubHardwareEnableNodeStateTest002
652 * @tc.desc: Test RSUniRenderVisitorTest.MarkSubHardwareEnableNodeStateTest
653 * @tc.type: FUNC
654 * @tc.require: issueI79KM8
655 */
656 HWTEST_F(RSUniRenderVisitorTest, MarkSubHardwareEnableNodeStateTest002, TestSize.Level1)
657 {
658 RSSurfaceRenderNodeConfig config;
659 config.id = 10;
660 auto rsContext = std::make_shared<RSContext>();
661 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
662 rsSurfaceRenderNode->nodeType_ = RSSurfaceNodeType::ABILITY_COMPONENT_NODE;
663 ASSERT_EQ(true, rsSurfaceRenderNode->IsAbilityComponent());
664
665 auto newRsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
666 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
667 rsUniRenderVisitor->hardwareEnabledNodes_.emplace_back(newRsSurfaceRenderNode);
668 rsUniRenderVisitor->MarkSubHardwareEnableNodeState(*rsSurfaceRenderNode);
669 }
670
671 /**
672 * @tc.name: DrawAllSurfaceOpaqueRegionForDFX002
673 * @tc.desc: Test RSUniRenderVisitorTest.DrawAllSurfaceOpaqueRegionForDFX when nodetype is SELF_DRAWING_NODE
674 * @tc.type: FUNC
675 * @tc.require: issueI79KM8
676 */
677 HWTEST_F(RSUniRenderVisitorTest, DrawAllSurfaceOpaqueRegionForDFX002, TestSize.Level1)
678 {
679 NodeId id = 0;
680 RSDisplayNodeConfig config;
681 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
682 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
683 ASSERT_NE(surfaceNodeMain, nullptr);
684 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
685 node->curAllSurfaces_.push_back(surfaceNodeMain);
686 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
687 ASSERT_NE(surfaceNode, nullptr);
688 surfaceNode->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
689 node->curAllSurfaces_.push_back(surfaceNode);
690 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
691 rsUniRenderVisitor->DrawAllSurfaceOpaqueRegionForDFX(*node);
692 }
693
694 /**
695 * @tc.name: DrawTargetSurfaceDirtyRegionForDFX002
696 * @tc.desc: Test RSUniRenderVisitorTest.DrawTargetSurfaceDirtyRegionForDFX
697 * @tc.type: FUNC
698 * @tc.require: issueI79KM8
699 */
700 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceDirtyRegionForDFX002, TestSize.Level1)
701 {
702 NodeId id = 0;
703 RSDisplayNodeConfig config;
704 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
705 auto surfaceNodeNull = RSTestUtil::CreateSurfaceNode();
706 ASSERT_NE(surfaceNodeNull, nullptr);
707 surfaceNodeNull = nullptr;
708 node->curAllSurfaces_.push_back(surfaceNodeNull);
709 auto surfaceNodeNotApp = RSTestUtil::CreateSurfaceNode();
710 ASSERT_NE(surfaceNodeNotApp, nullptr);
711 surfaceNodeNotApp->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
712 node->curAllSurfaces_.push_back(surfaceNodeNotApp);
713 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
714 ASSERT_NE(surfaceNodeMain, nullptr);
715 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
716 surfaceNodeMain->name_ = DEFAULT_NODE_NAME;
717 node->curAllSurfaces_.push_back(surfaceNodeMain);
718 auto surfaceNodeMain2 = RSTestUtil::CreateSurfaceNode();
719 ASSERT_NE(surfaceNodeMain2, nullptr);
720 surfaceNodeMain2->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
721 surfaceNodeMain2->name_ = INVALID_NODE_NAME;
722 node->curAllSurfaces_.push_back(surfaceNodeMain2);
723
724 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
725 auto& vs = rsUniRenderVisitor->dfxTargetSurfaceNames_;
726 vs.push_back(DEFAULT_NODE_NAME);
727 ASSERT_EQ(true, rsUniRenderVisitor->CheckIfSurfaceTargetedForDFX(surfaceNodeMain->name_));
728 ASSERT_EQ(false, rsUniRenderVisitor->CheckIfSurfaceTargetedForDFX(surfaceNodeMain2->name_));
729 rsUniRenderVisitor->DrawTargetSurfaceDirtyRegionForDFX(*node);
730 }
731
732 /**
733 * @tc.name: DrawTargetSurfaceDirtyRegionForDFX003
734 * @tc.desc: Test RSUniRenderVisitorTest.DrawTargetSurfaceDirtyRegionForDFX
735 * @tc.type: FUNC
736 * @tc.require: issueI79KM8
737 */
738 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceDirtyRegionForDFX003, TestSize.Level1)
739 {
740 NodeId id = 0;
741 RSDisplayNodeConfig config;
742 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
743 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
744 ASSERT_NE(surfaceNodeMain, nullptr);
745 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
746 surfaceNodeMain->name_ = DEFAULT_NODE_NAME;
747 node->curAllSurfaces_.push_back(surfaceNodeMain);
748 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
749 auto& vs = rsUniRenderVisitor->dfxTargetSurfaceNames_;
750 vs.push_back(DEFAULT_NODE_NAME);
751 ASSERT_EQ(true, rsUniRenderVisitor->CheckIfSurfaceTargetedForDFX(surfaceNodeMain->name_));
752 rsUniRenderVisitor->dirtyRegionDebugType_ = DirtyRegionDebugType::DISABLED;
753 rsUniRenderVisitor->DrawTargetSurfaceDirtyRegionForDFX(*node);
754 }
755
756 /**
757 * @tc.name: DrawTargetSurfaceDirtyRegionForDFX004
758 * @tc.desc: Test RSUniRenderVisitorTest.DrawTargetSurfaceDirtyRegionForDFX
759 * @tc.type: FUNC
760 * @tc.require: issueI79KM8
761 */
762 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceDirtyRegionForDFX004, TestSize.Level1)
763 {
764 NodeId id = 0;
765 RSDisplayNodeConfig config;
766 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
767 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
768 ASSERT_NE(surfaceNodeMain, nullptr);
769 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
770 surfaceNodeMain->name_ = DEFAULT_NODE_NAME;
771 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
772 ASSERT_NE(dirtyManager, nullptr);
773 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
774 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
775 node->curAllSurfaces_.push_back(surfaceNodeMain);
776 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
777 auto& vs = rsUniRenderVisitor->dfxTargetSurfaceNames_;
778 vs.push_back(DEFAULT_NODE_NAME);
779 ASSERT_EQ(true, rsUniRenderVisitor->CheckIfSurfaceTargetedForDFX(surfaceNodeMain->name_));
780 rsUniRenderVisitor->dirtyRegionDebugType_ = DirtyRegionDebugType::UPDATE_DIRTY_REGION;
781 rsUniRenderVisitor->DrawTargetSurfaceDirtyRegionForDFX(*node);
782 }
783
784 /**
785 * @tc.name: DrawAndTraceSingleDirtyRegionTypeForDFX001
786 * @tc.desc: Test RSUniRenderVisitorTest.DrawAndTraceSingleDirtyRegionTypeForDFX when dirtyType is out of range
787 * @tc.type: FUNC
788 * @tc.require: issueI79KM8
789 */
790 HWTEST_F(RSUniRenderVisitorTest, DrawAndTraceSingleDirtyRegionTypeForDFX001, TestSize.Level1)
791 {
792 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
793 ASSERT_NE(surfaceNodeMain, nullptr);
794 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
795 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
796 ASSERT_NE(dirtyManager, nullptr);
797 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
798 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
799 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
800 rsUniRenderVisitor->DrawAndTraceSingleDirtyRegionTypeForDFX(*surfaceNodeMain, DirtyRegionType::TYPE_AMOUNT, true);
801 }
802
803 /**
804 * @tc.name: DrawAndTraceSingleDirtyRegionTypeForDFX002
805 * @tc.desc: Test RSUniRenderVisitorTest.DrawAndTraceSingleDirtyRegionTypeForDFX when dirtyManager is nullptr
806 * @tc.type: FUNC
807 * @tc.require: issueI79KM8
808 */
809 HWTEST_F(RSUniRenderVisitorTest, DrawAndTraceSingleDirtyRegionTypeForDFX002, TestSize.Level1)
810 {
811 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
812 ASSERT_NE(surfaceNodeMain, nullptr);
813 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
814 surfaceNodeMain->dirtyManager_ = nullptr;
815 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
816 ASSERT_EQ(dirtyManager, nullptr);
817 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
818 rsUniRenderVisitor->DrawAndTraceSingleDirtyRegionTypeForDFX(*surfaceNodeMain,
819 DirtyRegionType::UPDATE_DIRTY_REGION, true);
820 }
821
822 /**
823 * @tc.name: DrawAndTraceSingleDirtyRegionTypeForDFX003
824 * @tc.desc: Test RSUniRenderVisitorTest.DrawAndTraceSingleDirtyRegionTypeForDFX when isDrawn is true
825 * @tc.type: FUNC
826 * @tc.require: issueI79KM8
827 */
828 HWTEST_F(RSUniRenderVisitorTest, DrawAndTraceSingleDirtyRegionTypeForDFX003, TestSize.Level1)
829 {
830 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
831 ASSERT_NE(surfaceNodeMain, nullptr);
832 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
833 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
834 ASSERT_NE(dirtyManager, nullptr);
835 NodeId id = 0;
836 RectI rect(0, 0, 0, 0);
837 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
838 dirtyManager->dirtyCanvasNodeInfo_[DirtyRegionType::UPDATE_DIRTY_REGION].emplace(std::make_pair(id, rect));
839 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
840 dirtyManager->dirtySurfaceNodeInfo_[DirtyRegionType::UPDATE_DIRTY_REGION].emplace(std::make_pair(id, rect));
841 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
842 rsUniRenderVisitor->DrawAndTraceSingleDirtyRegionTypeForDFX(*surfaceNodeMain,
843 DirtyRegionType::UPDATE_DIRTY_REGION, true);
844 }
845
846 /**
847 * @tc.name: DrawAndTraceSingleDirtyRegionTypeForDFX004
848 * @tc.desc: Test RSUniRenderVisitorTest.DrawAndTraceSingleDirtyRegionTypeForDFX when isDrawn is false
849 * @tc.type: FUNC
850 * @tc.require: issueI79KM8
851 */
852 HWTEST_F(RSUniRenderVisitorTest, DrawAndTraceSingleDirtyRegionTypeForDFX004, TestSize.Level1)
853 {
854 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
855 ASSERT_NE(surfaceNodeMain, nullptr);
856 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
857 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
858 ASSERT_NE(dirtyManager, nullptr);
859 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
860 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
861 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
862 rsUniRenderVisitor->DrawAndTraceSingleDirtyRegionTypeForDFX(*surfaceNodeMain,
863 DirtyRegionType::UPDATE_DIRTY_REGION, false);
864 }
865
866 /**
867 * @tc.name: DrawDetailedTypesOfDirtyRegionForDFX001
868 * @tc.desc: Test RSUniRenderVisitorTest.DrawDetailedTypesOfDirtyRegionForDFX
869 * @tc.type: FUNC
870 * @tc.require: issueI79KM8
871 */
872 HWTEST_F(RSUniRenderVisitorTest, DrawDetailedTypesOfDirtyRegionForDFX001, TestSize.Level1)
873 {
874 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
875 ASSERT_NE(surfaceNodeMain, nullptr);
876 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
877 ASSERT_NE(dirtyManager, nullptr);
878 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
879 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
880 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
881 rsUniRenderVisitor->dirtyRegionDebugType_ = DirtyRegionDebugType::DISABLED;
882 ASSERT_EQ(false, rsUniRenderVisitor->DrawDetailedTypesOfDirtyRegionForDFX(*surfaceNodeMain));
883 rsUniRenderVisitor->dirtyRegionDebugType_ = DirtyRegionDebugType::CUR_DIRTY_DETAIL_ONLY_TRACE;
884 ASSERT_EQ(true, rsUniRenderVisitor->DrawDetailedTypesOfDirtyRegionForDFX(*surfaceNodeMain));
885 rsUniRenderVisitor->dirtyRegionDebugType_ = DirtyRegionDebugType::UPDATE_DIRTY_REGION;
886 ASSERT_EQ(true, rsUniRenderVisitor->DrawDetailedTypesOfDirtyRegionForDFX(*surfaceNodeMain));
887 }
888
889 /**
890 * @tc.name: CalcDirtyRegionForFilterNode001
891 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyRegionForFilterNode when dirtyManager_ of displayNode is nullptr
892 * @tc.type: FUNC
893 * @tc.require: issueI79KM8
894 */
895 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode001, TestSize.Level1)
896 {
897 NodeId id = 0;
898 RSDisplayNodeConfig config;
899 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
900 ASSERT_NE(node, nullptr);
901 node->dirtyManager_ = nullptr;
902 ASSERT_EQ(node->GetDirtyManager(), nullptr);
903 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
904 ASSERT_NE(surfaceNode, nullptr);
905 surfaceNode->dirtyManager_ = nullptr;
906 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
907 RectI rect(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
908 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
909 }
910
911 /**
912 * @tc.name: CalcDirtyRegionForFilterNode002
913 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyRegionForFilterNode when dirtyManager_ of surfaceNode is nullptr
914 * @tc.type: FUNC
915 * @tc.require: issueI79KM8
916 */
917 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode002, TestSize.Level1)
918 {
919 NodeId id = 0;
920 RSDisplayNodeConfig config;
921 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
922 ASSERT_NE(node, nullptr);
923 ASSERT_NE(node->GetDirtyManager(), nullptr);
924 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
925 ASSERT_NE(surfaceNode, nullptr);
926 surfaceNode->dirtyManager_ = nullptr;
927 ASSERT_EQ(surfaceNode->GetDirtyManager(), nullptr);
928 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
929 RectI rect(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
930 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
931 }
932
933 /**
934 * @tc.name: CalcDirtyRegionForFilterNode003
935 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyRegionForFilterNode
936 * @tc.type: FUNC
937 * @tc.require: issueI79KM8
938 */
939 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode003, TestSize.Level1)
940 {
941 NodeId id = 0;
942 RSDisplayNodeConfig config;
943 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
944 ASSERT_NE(node, nullptr);
945 auto dpDirtyManager = node->GetDirtyManager();
946 ASSERT_NE(dpDirtyManager, nullptr);
947 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
948 ASSERT_NE(surfaceNode, nullptr);
949 auto sfDirtyManager = surfaceNode->GetDirtyManager();
950 ASSERT_NE(sfDirtyManager, nullptr);
951 sfDirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
952 sfDirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
953 dpDirtyManager->dirtyRegion_ = RectI(0, 0, 0, 0);
954 sfDirtyManager->dirtyRegion_ = RectI(0, 0, 0, 0);
955 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
956 RectI rect(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
957 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
958 dpDirtyManager->dirtyRegion_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
959 sfDirtyManager->dirtyRegion_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
960 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
961 dpDirtyManager->dirtyRegion_ = RectI(0, 0, 0, 0);
962 std::shared_ptr<RSSurfaceRenderNode> surfaceNodeNull = nullptr;
963 node->curAllSurfaces_.push_back(surfaceNodeNull);
964 auto surfaceNodeNotApp = RSTestUtil::CreateSurfaceNode();
965 ASSERT_NE(surfaceNodeNotApp, nullptr);
966 surfaceNodeNotApp->nodeType_ = RSSurfaceNodeType::ABILITY_COMPONENT_NODE;
967 node->curAllSurfaces_.push_back(surfaceNodeNotApp);
968 auto surfaceNodeAppWithEmptyRegion = RSTestUtil::CreateSurfaceNode();
969 ASSERT_NE(surfaceNodeAppWithEmptyRegion, nullptr);
970 surfaceNodeAppWithEmptyRegion->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
971 ASSERT_NE(surfaceNodeAppWithEmptyRegion->GetDirtyManager(), nullptr);
972 surfaceNodeAppWithEmptyRegion->GetDirtyManager()->dirtyRegion_ = RectI(0, 0, 0, 0);
973 node->curAllSurfaces_.push_back(surfaceNodeAppWithEmptyRegion);
974 auto surfaceNodeApp = RSTestUtil::CreateSurfaceNode();
975 ASSERT_NE(surfaceNodeApp, nullptr);
976 surfaceNodeApp->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
977 ASSERT_NE(surfaceNodeApp->GetDirtyManager(), nullptr);
978 surfaceNodeApp->GetDirtyManager()->dirtyRegion_ =
979 RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
980 node->curAllSurfaces_.push_back(surfaceNodeApp);
981 node->curAllSurfaces_.push_back(surfaceNode);
982 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
983 }
984
985 /**
986 * @tc.name: CalcDirtyRegionForFilterNode004
987 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyRegionForFilterNode
988 * @tc.type: FUNC
989 * @tc.require: issueI79KM8
990 */
991 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode004, TestSize.Level1)
992 {
993 NodeId id = 0;
994 RSDisplayNodeConfig config;
995 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
996 ASSERT_NE(node, nullptr);
997 auto dpDirtyManager = node->GetDirtyManager();
998 ASSERT_NE(dpDirtyManager, nullptr);
999 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1000 ASSERT_NE(surfaceNode, nullptr);
1001 auto sfDirtyManager = surfaceNode->GetDirtyManager();
1002 ASSERT_NE(sfDirtyManager, nullptr);
1003 sfDirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
1004 sfDirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
1005 RectI rect(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1006 sfDirtyManager->dirtyRegion_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1007 dpDirtyManager->dirtyRegion_ = RectI(0, 0, 0, 0);
1008 auto surfaceNodeApp = RSTestUtil::CreateSurfaceNode();
1009 ASSERT_NE(surfaceNodeApp, nullptr);
1010 surfaceNodeApp->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1011 ASSERT_NE(surfaceNodeApp->GetDirtyManager(), nullptr);
1012 surfaceNodeApp->GetDirtyManager()->dirtyRegion_ =
1013 RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1014 surfaceNodeApp->visibleRegion_ = Occlusion::Region(RectI(0, 0, 0, 0));
1015 node->curAllSurfaces_.push_back(surfaceNodeApp);
1016
1017 auto surfaceNodeAppOutOfRange = RSTestUtil::CreateSurfaceNode();
1018 ASSERT_NE(surfaceNodeAppOutOfRange, nullptr);
1019 surfaceNodeAppOutOfRange->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1020 ASSERT_NE(surfaceNodeAppOutOfRange->GetDirtyManager(), nullptr);
1021 surfaceNodeAppOutOfRange->GetDirtyManager()->dirtyRegion_ = RectI(DEFAULT_DIRTY_REGION_WIDTH,
1022 DEFAULT_DIRTY_REGION_HEIGHT, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1023 surfaceNodeAppOutOfRange->visibleRegion_ =
1024 Occlusion::Region(RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT));
1025 node->curAllSurfaces_.push_back(surfaceNodeAppOutOfRange);
1026 auto dRect = surfaceNodeAppOutOfRange->GetDirtyManager()->GetDirtyRegion();
1027
1028 auto surfaceNodeAppIntersect = RSTestUtil::CreateSurfaceNode();
1029 ASSERT_NE(surfaceNodeAppIntersect, nullptr);
1030 surfaceNodeAppIntersect->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1031 ASSERT_NE(surfaceNodeAppIntersect->GetDirtyManager(), nullptr);
1032 surfaceNodeAppIntersect->GetDirtyManager()->dirtyRegion_ =
1033 RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1034 surfaceNodeAppIntersect->visibleRegion_ =
1035 Occlusion::Region(RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT));
1036 node->curAllSurfaces_.push_back(surfaceNodeAppIntersect);
1037 dRect = surfaceNodeAppIntersect->GetDirtyManager()->GetDirtyRegion();
1038 node->curAllSurfaces_.push_back(surfaceNode);
1039 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1040 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
1041 }
1042
1043 /**
1044 * @tc.name: CalcDirtyFilterRegion001
1045 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyFilterRegion when disPlayNode or disPlayNode.dirtyManager_ is null
1046 * @tc.type: FUNC
1047 * @tc.require: issueI79KM8
1048 */
1049 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyFilterRegion001, TestSize.Level1)
1050 {
1051 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1052 NodeId id = 0;
1053 RSDisplayNodeConfig config;
1054 std::shared_ptr<RSDisplayRenderNode> node = nullptr;
1055 rsUniRenderVisitor->CalcDirtyFilterRegion(node);
1056 node = std::make_shared<RSDisplayRenderNode>(id, config);
1057 ASSERT_NE(node, nullptr);
1058 node->dirtyManager_ = nullptr;
1059 rsUniRenderVisitor->CalcDirtyFilterRegion(node);
1060 }
1061
1062 /**
1063 * @tc.name: CalcDirtyFilterRegion002
1064 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyFilterRegion when disPlayNode or disPlayNode.dirtyManager_ is null
1065 * @tc.type: FUNC
1066 * @tc.require: issueI79KM8
1067 */
1068 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyFilterRegion002, TestSize.Level1)
1069 {
1070 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1071 NodeId id = 0;
1072 RSDisplayNodeConfig config;
1073 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1074 std::shared_ptr<RSSurfaceRenderNode> surfaceNodeNull = nullptr;
1075 node->curAllSurfaces_.push_back(surfaceNodeNull);
1076 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
1077 ASSERT_NE(surfaceNodeMain, nullptr);
1078 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1079 auto surfaceNodeChild = RSTestUtil::CreateSurfaceNode();
1080 ASSERT_NE(surfaceNodeChild, nullptr);
1081 surfaceNodeChild->oldDirtyInSurface_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1082 surfaceNodeMain->visibleRegion_ =
1083 Occlusion::Region(RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT));
1084 surfaceNodeMain->AddChildHardwareEnabledNode(surfaceNodeChild);
1085 auto surfaceNodeDirtyNull = RSTestUtil::CreateSurfaceNode();
1086 surfaceNodeDirtyNull->dirtyManager_ = nullptr;
1087 surfaceNodeDirtyNull->oldDirtyInSurface_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1088 surfaceNodeMain->AddChildHardwareEnabledNode(surfaceNodeDirtyNull);
1089 auto surfaceNodeChildLastFrame = RSTestUtil::CreateSurfaceNode();
1090 surfaceNodeChildLastFrame->isLastFrameHardwareEnabled_ = true;
1091 surfaceNodeChildLastFrame->oldDirtyInSurface_ = RectI(0, 0,
1092 DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1093 surfaceNodeMain->AddChildHardwareEnabledNode(surfaceNodeChildLastFrame);
1094 node->curAllSurfaces_.push_back(surfaceNodeMain);
1095 rsUniRenderVisitor->CalcDirtyFilterRegion(node);
1096 }
1097
1098 /**
1099 * @tc.name: SetSurfaceGlobalAlignedDirtyRegion001
1100 * @tc.desc: Test RSUniRenderVisitorTest.SetSurfaceGlobalAlignedDirtyRegion isDirtyRegionAlignedEnable_ is false
1101 * @tc.type: FUNC
1102 * @tc.require: issueI79KM8
1103 */
1104 HWTEST_F(RSUniRenderVisitorTest, SetSurfaceGlobalAlignedDirtyRegion001, TestSize.Level1)
1105 {
1106 NodeId id = 0;
1107 RSDisplayNodeConfig config;
1108 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1109 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1110 rsUniRenderVisitor->isDirtyRegionAlignedEnable_ = false;
1111 rsUniRenderVisitor->SetSurfaceGlobalAlignedDirtyRegion(node, Occlusion::Region(RectI(0, 0, 0, 0)));
1112 }
1113
1114 /**
1115 * @tc.name: SetSurfaceGlobalAlignedDirtyRegion002
1116 * @tc.desc: Test RSUniRenderVisitorTest.SetSurfaceGlobalAlignedDirtyRegion isDirtyRegionAlignedEnable_ is false
1117 * @tc.type: FUNC
1118 * @tc.require: issueI79KM8
1119 */
1120 HWTEST_F(RSUniRenderVisitorTest, SetSurfaceGlobalAlignedDirtyRegion002, TestSize.Level1)
1121 {
1122 NodeId id = 0;
1123 RSDisplayNodeConfig config;
1124 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1125 ASSERT_NE(node, nullptr);
1126 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1127 ASSERT_NE(rsUniRenderVisitor, nullptr);
1128 rsUniRenderVisitor->isDirtyRegionAlignedEnable_ = true;
1129
1130 std::shared_ptr<RSSurfaceRenderNode> surfaceNodeNull = nullptr;
1131 node->curAllSurfaces_.push_back(surfaceNodeNull);
1132
1133 auto surfaceNodeDefault = RSTestUtil::CreateSurfaceNode();
1134 ASSERT_NE(surfaceNodeDefault, nullptr);
1135 surfaceNodeDefault->nodeType_ = RSSurfaceNodeType::DEFAULT;
1136 node->curAllSurfaces_.push_back(surfaceNodeDefault);
1137
1138 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
1139 ASSERT_NE(surfaceNodeMain, nullptr);
1140 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1141 node->curAllSurfaces_.push_back(surfaceNodeMain);
1142
1143 rsUniRenderVisitor->SetSurfaceGlobalAlignedDirtyRegion(node, Occlusion::Region(RectI(0, 0, 0, 0)));
1144 rsUniRenderVisitor->SetSurfaceGlobalAlignedDirtyRegion(node, Occlusion::Region(RectI(0,
1145 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT)));
1146 }
1147
1148 /**
1149 * @tc.name: AlignGlobalAndSurfaceDirtyRegions001
1150 * @tc.desc: Test RSUniRenderVisitorTest.AlignGlobalAndSurfaceDirtyRegions
1151 * @tc.type: FUNC
1152 * @tc.require: issueI79KM8
1153 */
1154 HWTEST_F(RSUniRenderVisitorTest, AlignGlobalAndSurfaceDirtyRegions001, TestSize.Level1)
1155 {
1156 NodeId id = 0;
1157 RSDisplayNodeConfig config;
1158 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1159 ASSERT_NE(node, nullptr);
1160 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1161 ASSERT_NE(rsUniRenderVisitor, nullptr);
1162 rsUniRenderVisitor->isDirtyRegionAlignedEnable_ = true;
1163
1164 std::shared_ptr<RSSurfaceRenderNode> surfaceNodeNull = nullptr;
1165 node->curAllSurfaces_.push_back(surfaceNodeNull);
1166
1167 auto surfaceNodeDefault = RSTestUtil::CreateSurfaceNode();
1168 ASSERT_NE(surfaceNodeDefault, nullptr);
1169 surfaceNodeDefault->nodeType_ = RSSurfaceNodeType::DEFAULT;
1170 node->curAllSurfaces_.push_back(surfaceNodeDefault);
1171
1172 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
1173 ASSERT_NE(surfaceNodeMain, nullptr);
1174 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1175 node->curAllSurfaces_.push_back(surfaceNodeMain);
1176
1177 rsUniRenderVisitor->AlignGlobalAndSurfaceDirtyRegions(node);
1178 }
1179
1180 /**
1181 * @tc.name: ProcessSurfaceRenderNode001
1182 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode when displaynode is null
1183 * @tc.type: FUNC
1184 * @tc.require: issueI79KM8
1185 */
1186 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode001, TestSize.Level1)
1187 {
1188 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1189 ASSERT_NE(rsUniRenderVisitor, nullptr);
1190 rsUniRenderVisitor->isUIFirst_ = true;
1191 rsUniRenderVisitor->isSubThread_ = true;
1192 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
1193 rsUniRenderVisitor->renderEngine_->Init();
1194 std::shared_ptr<RSDisplayRenderNode> node = nullptr;
1195
1196 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1197 ASSERT_NE(surfaceNode, nullptr);
1198 surfaceNode->SetParent(node);
1199 #ifndef USE_ROSEN_DRAWING
1200 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1201 ASSERT_NE(skCanvas, nullptr);
1202 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
1203 #else
1204 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1205 ASSERT_NE(drawingCanvas, nullptr);
1206 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1207 #endif
1208 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1209 }
1210
1211 /**
1212 * @tc.name: ProcessSurfaceRenderNode002
1213 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode with isSubThread_ and isUIFirst_
1214 * @tc.type: FUNC
1215 * @tc.require: issueI79KM8
1216 */
1217 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode002, TestSize.Level1)
1218 {
1219 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1220 ASSERT_NE(rsUniRenderVisitor, nullptr);
1221 rsUniRenderVisitor->isUIFirst_ = true;
1222 rsUniRenderVisitor->isSubThread_ = true;
1223 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
1224 rsUniRenderVisitor->renderEngine_->Init();
1225 NodeId id = 0;
1226 RSDisplayNodeConfig config;
1227 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1228
1229 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1230 ASSERT_NE(surfaceNode, nullptr);
1231 #ifndef USE_ROSEN_DRAWING
1232 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1233 ASSERT_NE(skCanvas, nullptr);
1234 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
1235 #else
1236 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1237 ASSERT_NE(drawingCanvas, nullptr);
1238 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1239 #endif
1240 surfaceNode->SetParent(node);
1241 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1242 rsUniRenderVisitor->isSubThread_ = false;
1243 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1244 rsUniRenderVisitor->isUIFirst_ = false;
1245 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1246 }
1247
1248 /**
1249 * @tc.name: ProcessSurfaceRenderNode003
1250 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode with skipLayer
1251 * @tc.type: FUNC
1252 * @tc.require: issueI80HL4
1253 */
1254 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode003, TestSize.Level1)
1255 {
1256 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1257 ASSERT_NE(rsUniRenderVisitor, nullptr);
1258 rsUniRenderVisitor->isUIFirst_ = true;
1259 rsUniRenderVisitor->isSubThread_ = true;
1260 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
1261 rsUniRenderVisitor->renderEngine_->Init();
1262 NodeId id = 0;
1263 RSDisplayNodeConfig config;
1264 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1265 node->SetSecurityDisplay(true);
1266 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1267 ASSERT_NE(surfaceNode, nullptr);
1268 surfaceNode->SetSkipLayer(true);
1269 #ifndef USE_ROSEN_DRAWING
1270 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1271 ASSERT_NE(skCanvas, nullptr);
1272 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
1273 #else
1274 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1275 ASSERT_NE(drawingCanvas, nullptr);
1276 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1277 #endif
1278 surfaceNode->SetParent(node);
1279 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1280 }
1281
1282 /**
1283 * @tc.name: ProcessSurfaceRenderNode004
1284 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode with securityLayer
1285 * @tc.type: FUNC
1286 * @tc.require: issueI80HL4
1287 */
1288 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode004, TestSize.Level1)
1289 {
1290 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1291 ASSERT_NE(rsUniRenderVisitor, nullptr);
1292 rsUniRenderVisitor->isUIFirst_ = true;
1293 rsUniRenderVisitor->isSubThread_ = true;
1294 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
1295 rsUniRenderVisitor->renderEngine_->Init();
1296 NodeId id = 0;
1297 RSDisplayNodeConfig config;
1298 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1299 node->SetSecurityDisplay(true);
1300 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1301 ASSERT_NE(surfaceNode, nullptr);
1302 surfaceNode->SetSecurityLayer(true);
1303 #ifndef USE_ROSEN_DRAWING
1304 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1305 ASSERT_NE(skCanvas, nullptr);
1306 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
1307 #else
1308 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1309 ASSERT_NE(drawingCanvas, nullptr);
1310 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1311 #endif
1312 surfaceNode->SetParent(node);
1313 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1314 }
1315
1316 /**
1317 * @tc.name: GenerateNodeContentCache001
1318 * @tc.desc: Test RSUniRenderVisitorTest.GenerateNodeContentCache when surfaceNode is null
1319 * @tc.type: FUNC
1320 * @tc.require: issueI79KM8
1321 */
1322 HWTEST_F(RSUniRenderVisitorTest, GenerateNodeContentCache001, TestSize.Level1)
1323 {
1324 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1325 ASSERT_NE(rsUniRenderVisitor, nullptr);
1326 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
1327 rsUniRenderVisitor->renderEngine_->Init();
1328
1329 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1330 ASSERT_NE(surfaceNode, nullptr);
1331 surfaceNode->drawingCacheType_ = RSDrawingCacheType::DISABLED_CACHE;
1332 ASSERT_EQ(rsUniRenderVisitor->GenerateNodeContentCache(*surfaceNode), false);
1333 }
1334
1335 /**
1336 * @tc.name: GenerateNodeContentCache002
1337 * @tc.desc: Test RSUniRenderVisitorTest.GenerateNodeContentCache with isOnTheTree_
1338 * @tc.type: FUNC
1339 * @tc.require: issueI79KM8
1340 */
1341 HWTEST_F(RSUniRenderVisitorTest, GenerateNodeContentCache002, TestSize.Level1)
1342 {
1343 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1344 ASSERT_NE(rsUniRenderVisitor, nullptr);
1345 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
1346 rsUniRenderVisitor->renderEngine_->Init();
1347
1348 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1349 ASSERT_NE(surfaceNode, nullptr);
1350 surfaceNode->isOnTheTree_ = true;
1351 ASSERT_EQ(rsUniRenderVisitor->GenerateNodeContentCache(*surfaceNode), false);
1352
1353 auto surfaceNode2 = RSTestUtil::CreateSurfaceNode();
1354 ASSERT_NE(surfaceNode2, nullptr);
1355 surfaceNode2->isOnTheTree_ = false;
1356 ASSERT_EQ(rsUniRenderVisitor->GenerateNodeContentCache(*surfaceNode2), false);
1357 }
1358
1359 /**
1360 * @tc.name: PrepareEffectRenderNode001
1361 * @tc.desc: Test RSUniRenderVisitorTest.PrepareEffectRenderNode api
1362 * @tc.type: FUNC
1363 * @tc.require: issueI79KM8
1364 */
1365 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectRenderNode001, TestSize.Level1)
1366 {
1367 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1368 ASSERT_NE(rsUniRenderVisitor, nullptr);
1369 NodeId id1 = 1;
1370 RSDisplayNodeConfig displayConfig;
1371 auto rsContext = std::make_shared<RSContext>();
1372 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(id1,
1373 displayConfig, rsContext->weak_from_this());
1374 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
1375 NodeId id2 = 2;
1376 auto node = std::make_shared<RSEffectRenderNode>(id2, rsContext->weak_from_this());
1377 rsUniRenderVisitor->PrepareEffectRenderNode(*node);
1378 }
1379
1380 /**
1381 * @tc.name: CopyForParallelPrepare001
1382 * @tc.desc: Test RSUniRenderVisitorTest.CopyForParallelPrepare api
1383 * @tc.type: FUNC
1384 * @tc.require: issueI79KM8
1385 */
1386 HWTEST_F(RSUniRenderVisitorTest, CopyForParallelPrepare001, TestSize.Level1)
1387 {
1388 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1389 ASSERT_NE(rsUniRenderVisitor, nullptr);
1390 auto rsUniRenderVisitorCopy = std::make_shared<RSUniRenderVisitor>();
1391 ASSERT_NE(rsUniRenderVisitorCopy, nullptr);
1392 auto rsContext = std::make_shared<RSContext>();
1393 RSSurfaceRenderNodeConfig config;
1394 RSDisplayNodeConfig displayConfig;
1395 config.id = 10;
1396 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
1397 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
1398 rsSurfaceRenderNode->SetSrcRect(RectI(0, 0, 10, 10));
1399 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
1400 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
1401 rsUniRenderVisitorCopy->PrepareDisplayRenderNode(*rsDisplayRenderNode);
1402 rsUniRenderVisitorCopy->dirtySurfaceNodeMap_.emplace(rsSurfaceRenderNode->GetId(), rsSurfaceRenderNode);
1403 rsUniRenderVisitor->CopyForParallelPrepare(rsUniRenderVisitorCopy);
1404 }
1405
1406 #ifdef USE_ROSEN_DRAWING
1407 /**
1408 * @tc.name: DrawDirtyRectForDFX001
1409 * @tc.desc: Test RSUniRenderVisitorTest.DrawDirtyRectForDFX api
1410 * @tc.type: FUNC
1411 * @tc.require: issueI79KM8
1412 */
1413 HWTEST_F(RSUniRenderVisitorTest, DrawDirtyRectForDFX001, TestSize.Level1)
1414 {
1415 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1416 ASSERT_NE(rsUniRenderVisitor, nullptr);
1417 RectI rect(0, 0, 0, 0);
1418 Drawing::Color color;
1419 RSUniRenderVisitor::RSPaintStyle fillType = RSUniRenderVisitor::RSPaintStyle::FILL;
1420 rsUniRenderVisitor->DrawDirtyRectForDFX(rect, color, fillType, 0, 0);
1421 }
1422 #endif
1423
1424 /**
1425 * @tc.name: DrawDirtyRegionForDFX001
1426 * @tc.desc: Test RSUniRenderVisitorTest.DrawDirtyRegionForDFX api
1427 * @tc.type: FUNC
1428 * @tc.require: issueI79KM8
1429 */
1430 HWTEST_F(RSUniRenderVisitorTest, DrawDirtyRegionForDFX001, TestSize.Level1)
1431 {
1432 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1433 ASSERT_NE(rsUniRenderVisitor, nullptr);
1434 RectI rect(0, 0, 0, 0);
1435 std::vector<RectI> dirtyRects;
1436 dirtyRects.push_back(rect);
1437 rsUniRenderVisitor->DrawDirtyRegionForDFX(dirtyRects);
1438 }
1439
1440 /**
1441 * @tc.name: DrawAllSurfaceDirtyRegionForDFX001
1442 * @tc.desc: Test RSUniRenderVisitorTest.DrawAllSurfaceDirtyRegionForDFX api
1443 * @tc.type: FUNC
1444 * @tc.require: issueI79KM8
1445 */
1446 HWTEST_F(RSUniRenderVisitorTest, DrawAllSurfaceDirtyRegionForDFX001, TestSize.Level1)
1447 {
1448 NodeId id = 0;
1449 RSDisplayNodeConfig config;
1450 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1451 ASSERT_NE(node, nullptr);
1452
1453 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1454 ASSERT_NE(rsUniRenderVisitor, nullptr);
1455 Occlusion::Region region(RectI(0, 0, 0, 0));
1456 rsUniRenderVisitor->DrawAllSurfaceDirtyRegionForDFX(*node, region);
1457 }
1458
1459 /**
1460 * @tc.name: DrawSurfaceOpaqueRegionForDFX001
1461 * @tc.desc: Test RSUniRenderVisitorTest.DrawSurfaceOpaqueRegionForDFX api
1462 * @tc.type: FUNC
1463 * @tc.require: issueI79KM8
1464 */
1465 HWTEST_F(RSUniRenderVisitorTest, DrawSurfaceOpaqueRegionForDFX001, TestSize.Level1)
1466 {
1467 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1468 ASSERT_NE(rsUniRenderVisitor, nullptr);
1469 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1470 ASSERT_NE(surfaceNode, nullptr);
1471 Occlusion::Rect rect{0, 0, 0, 0};
1472 Occlusion::Region region{rect};
1473 surfaceNode->opaqueRegion_ = region;
1474 rsUniRenderVisitor->DrawSurfaceOpaqueRegionForDFX(*surfaceNode);
1475 }
1476
1477 /**
1478 * @tc.name: ProcessParallelDisplayRenderNode001
1479 * @tc.desc: Test RSUniRenderVisitorTest.ProcessParallelDisplayRenderNode api
1480 * @tc.type: FUNC
1481 * @tc.require: issueI79KM8
1482 */
1483 HWTEST_F(RSUniRenderVisitorTest, ProcessParallelDisplayRenderNode001, TestSize.Level1)
1484 {
1485 NodeId id = 0;
1486 RSDisplayNodeConfig config;
1487 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1488 ASSERT_NE(node, nullptr);
1489
1490 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1491 ASSERT_NE(rsUniRenderVisitor, nullptr);
1492 rsUniRenderVisitor->ProcessParallelDisplayRenderNode(*node);
1493 }
1494
1495 /**
1496 * @tc.name: SetSurfaceGlobalDirtyRegion001
1497 * @tc.desc: Test RSUniRenderVisitorTest.SetSurfaceGlobalDirtyRegion api
1498 * @tc.type: FUNC
1499 * @tc.require: issueI79KM8
1500 */
1501 HWTEST_F(RSUniRenderVisitorTest, SetSurfaceGlobalDirtyRegion001, TestSize.Level1)
1502 {
1503 NodeId id = 0;
1504 RSDisplayNodeConfig config;
1505 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1506 ASSERT_NE(node, nullptr);
1507
1508 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1509 ASSERT_NE(rsUniRenderVisitor, nullptr);
1510 rsUniRenderVisitor->SetSurfaceGlobalDirtyRegion(node);
1511 }
1512
1513 /**
1514 * @tc.name: DrawSpherize001
1515 * @tc.desc: Test RSUniRenderVisitorTest.DrawSpherize api
1516 * @tc.type: FUNC
1517 * @tc.require: issueI79KM8
1518 */
1519 HWTEST_F(RSUniRenderVisitorTest, DrawSpherize001, TestSize.Level1)
1520 {
1521 NodeId id = 0;
1522 RSDisplayNodeConfig config;
1523 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1524 ASSERT_NE(node, nullptr);
1525 #ifndef USE_ROSEN_DRAWING
1526 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1527 ASSERT_NE(skCanvas, nullptr);
1528 #else
1529 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1530 ASSERT_NE(drawingCanvas, nullptr);
1531 #endif
1532 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1533 ASSERT_NE(rsUniRenderVisitor, nullptr);
1534 #ifndef USE_ROSEN_DRAWING
1535 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
1536 #else
1537 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1538 #endif
1539 rsUniRenderVisitor->DrawSpherize(*node);
1540 }
1541
1542 /**
1543 * @tc.name: InitNodeCache001
1544 * @tc.desc: Test RSUniRenderVisitorTest.InitNodeCache api
1545 * @tc.type: FUNC
1546 * @tc.require: issueI79KM8
1547 */
1548 HWTEST_F(RSUniRenderVisitorTest, InitNodeCache001, TestSize.Level1)
1549 {
1550 NodeId id = 0;
1551 RSDisplayNodeConfig config;
1552 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1553 ASSERT_NE(node, nullptr);
1554
1555 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1556 ASSERT_NE(rsUniRenderVisitor, nullptr);
1557 rsUniRenderVisitor->InitNodeCache(*node);
1558 }
1559
1560 /**
1561 * @tc.name: UpdateCacheRenderNodeMap001
1562 * @tc.desc: Test RSUniRenderVisitorTest.UpdateCacheRenderNodeMap api
1563 * @tc.type: FUNC
1564 * @tc.require: issueI79KM8
1565 */
1566 HWTEST_F(RSUniRenderVisitorTest, UpdateCacheRenderNodeMap001, TestSize.Level1)
1567 {
1568 auto rsContext = std::make_shared<RSContext>();
1569 auto canvasNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
1570 ASSERT_NE(canvasNode, nullptr);
1571
1572 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1573 ASSERT_NE(rsUniRenderVisitor, nullptr);
1574 rsUniRenderVisitor->UpdateCacheRenderNodeMap(*canvasNode);
1575 }
1576
1577 /**
1578 * @tc.name: ProcessEffectRenderNode001
1579 * @tc.desc: Test RSUniRenderVisitorTest.ProcessEffectRenderNode api
1580 * @tc.type: FUNC
1581 * @tc.require: issueI79KM8
1582 */
1583 HWTEST_F(RSUniRenderVisitorTest, ProcessEffectRenderNode001, TestSize.Level1)
1584 {
1585 NodeId id = 0;
1586 RSEffectRenderNode node(id);
1587 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1588 ASSERT_NE(rsUniRenderVisitor, nullptr);
1589 rsUniRenderVisitor->ProcessEffectRenderNode(node);
1590 }
1591
1592 /**
1593 * @tc.name: PrepareOffscreenRender001
1594 * @tc.desc: Test RSUniRenderVisitorTest.PrepareOffscreenRender api
1595 * @tc.type: FUNC
1596 * @tc.require: issueI79KM8
1597 */
1598 HWTEST_F(RSUniRenderVisitorTest, PrepareOffscreenRender001, TestSize.Level1)
1599 {
1600 NodeId id = 0;
1601 RSDisplayNodeConfig config;
1602 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1603 ASSERT_NE(node, nullptr);
1604
1605 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1606 ASSERT_NE(rsUniRenderVisitor, nullptr);
1607 rsUniRenderVisitor->PrepareOffscreenRender(*node);
1608 }
1609
1610 /**
1611 * @tc.name: FinishOffscreenRender001
1612 * @tc.desc: Test RSUniRenderVisitorTest.FinishOffscreenRender api
1613 * @tc.type: FUNC
1614 * @tc.require: issueI79KM8
1615 */
1616 HWTEST_F(RSUniRenderVisitorTest, FinishOffscreenRender001, TestSize.Level1)
1617 {
1618 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1619 ASSERT_NE(rsUniRenderVisitor, nullptr);
1620 rsUniRenderVisitor->FinishOffscreenRender(false);
1621
1622 #ifndef USE_ROSEN_DRAWING
1623 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1624 #else
1625 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1626 #endif
1627 #ifndef USE_ROSEN_DRAWING
1628 ASSERT_NE(skCanvas, nullptr);
1629 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
1630 rsUniRenderVisitor->canvasBackup_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
1631 #else
1632 ASSERT_NE(drawingCanvas, nullptr);
1633 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1634 rsUniRenderVisitor->canvasBackup_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1635 #endif
1636 }
1637
1638 /**
1639 * @tc.name: ParallelRenderEnableHardwareComposer001
1640 * @tc.desc: Test RSUniRenderVisitorTest.ParallelRenderEnableHardwareComposer api
1641 * @tc.type: FUNC
1642 * @tc.require: issueI79KM8
1643 */
1644 HWTEST_F(RSUniRenderVisitorTest, ParallelRenderEnableHardwareComposer001, TestSize.Level1)
1645 {
1646 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1647 ASSERT_NE(surfaceNode, nullptr);
1648
1649 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1650 ASSERT_NE(rsUniRenderVisitor, nullptr);
1651 rsUniRenderVisitor->ParallelRenderEnableHardwareComposer(*surfaceNode);
1652 }
1653
1654 /**
1655 * @tc.name: ClosePartialRenderWhenAnimatingWindows001
1656 * @tc.desc: Test RSUniRenderVisitorTest.ClosePartialRenderWhenAnimatingWindows api
1657 * @tc.type: FUNC
1658 * @tc.require: issueI79KM8
1659 */
1660 HWTEST_F(RSUniRenderVisitorTest, ClosePartialRenderWhenAnimatingWindows001, TestSize.Level1)
1661 {
1662 NodeId id = 0;
1663 RSDisplayNodeConfig config;
1664 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1665 ASSERT_NE(node, nullptr);
1666
1667 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1668 ASSERT_NE(rsUniRenderVisitor, nullptr);
1669 rsUniRenderVisitor->ClosePartialRenderWhenAnimatingWindows(node);
1670 }
1671
1672 /**
1673 * @tc.name: CheckColorSpace001
1674 * @tc.desc: Test RSUniRenderVisitorTest.CheckColorSpace while
1675 * app Window node's color space is not equal to GRAPHIC_COLOR_GAMUT_SRGB
1676 * @tc.type: FUNC
1677 * @tc.require: issueI7O6WO
1678 */
1679 HWTEST_F(RSUniRenderVisitorTest, CheckColorSpace001, TestSize.Level2)
1680 {
1681 auto appWindowNode = RSTestUtil::CreateSurfaceNode();
1682 ASSERT_NE(appWindowNode, nullptr);
1683 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
1684 appWindowNode->SetColorSpace(GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DISPLAY_P3);
1685
1686 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1687 ASSERT_NE(rsUniRenderVisitor, nullptr);
1688 rsUniRenderVisitor->colorGamutModes_.push_back(
1689 static_cast<ScreenColorGamut>(GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DISPLAY_P3));
1690 rsUniRenderVisitor->CheckColorSpace(*appWindowNode);
1691 ASSERT_EQ(rsUniRenderVisitor->newColorSpace_, appWindowNode->GetColorSpace());
1692 }
1693
1694 /**
1695 * @tc.name: DoDirectComposition001
1696 * @tc.desc: Test RSUniRenderVisitorTest.DoDirectComposition while the render visitor is hardware disabled
1697 * @tc.type: FUNC
1698 * @tc.require: issueI7O6WO
1699 */
1700 HWTEST_F(RSUniRenderVisitorTest, DoDirectComposition001, TestSize.Level2)
1701 {
1702 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
1703 const std::shared_ptr<RSBaseRenderNode> rootNode = context->GetGlobalRootRenderNode();
1704 ASSERT_NE(rootNode, nullptr);
1705
1706 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1707 ASSERT_NE(rsUniRenderVisitor, nullptr);
1708 ASSERT_EQ(rsUniRenderVisitor->DoDirectComposition(rootNode), false);
1709 }
1710
1711 /**
1712 * @tc.name: DoDirectComposition002
1713 * @tc.desc: Test RSUniRenderVisitorTest.DoDirectComposition while the root node doesn't have child
1714 * @tc.type: FUNC
1715 * @tc.require: issueI7O6WO
1716 */
1717 HWTEST_F(RSUniRenderVisitorTest, DoDirectComposition002, TestSize.Level2)
1718 {
1719 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
1720 const std::shared_ptr<RSBaseRenderNode> rootNode = context->GetGlobalRootRenderNode();
1721 ASSERT_NE(rootNode, nullptr);
1722
1723 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1724 ASSERT_NE(rsUniRenderVisitor, nullptr);
1725 ASSERT_EQ(rsUniRenderVisitor->DoDirectComposition(rootNode), false);
1726 }
1727
1728 /**
1729 * @tc.name: DoDirectComposition003
1730 * @tc.desc: Test RSUniRenderVisitorTest.DoDirectComposition while the root node has child
1731 * @tc.type: FUNC
1732 * @tc.require: issueI7O6WO
1733 */
1734 HWTEST_F(RSUniRenderVisitorTest, DoDirectComposition003, TestSize.Level2)
1735 {
1736 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
1737 const std::shared_ptr<RSBaseRenderNode> rootNode = context->GetGlobalRootRenderNode();
1738 NodeId id = 1;
1739 RSDisplayNodeConfig config;
1740 auto childDisplayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1741 ASSERT_NE(rootNode, nullptr);
1742 ASSERT_NE(childDisplayNode, nullptr);
1743 rootNode->AddChild(childDisplayNode, 0);
1744 childDisplayNode->SetCompositeType(RSDisplayRenderNode::CompositeType::SOFTWARE_COMPOSITE);
1745
1746 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1747 ASSERT_NE(rsUniRenderVisitor, nullptr);
1748 ASSERT_EQ(rsUniRenderVisitor->DoDirectComposition(rootNode), false);
1749 }
1750
1751 /**
1752 * @tc.name: DoDirectComposition004
1753 * @tc.desc: Test RSUniRenderVisitorTest.DoDirectComposition while
1754 * the display node's composite type is UNI_RENDER_COMPOSITE
1755 * @tc.type: FUNC
1756 * @tc.require: issueI7O6WO
1757 */
1758 HWTEST_F(RSUniRenderVisitorTest, DoDirectComposition004, TestSize.Level2)
1759 {
1760 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
1761 const std::shared_ptr<RSBaseRenderNode> rootNode = context->GetGlobalRootRenderNode();
1762 NodeId id = 1;
1763 RSDisplayNodeConfig config;
1764 auto childDisplayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1765 ASSERT_NE(rootNode, nullptr);
1766 ASSERT_NE(childDisplayNode, nullptr);
1767 rootNode->AddChild(childDisplayNode, 0);
1768 childDisplayNode->SetCompositeType(RSDisplayRenderNode::CompositeType::UNI_RENDER_COMPOSITE);
1769
1770 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1771 ASSERT_NE(rsUniRenderVisitor, nullptr);
1772 ASSERT_EQ(rsUniRenderVisitor->DoDirectComposition(rootNode), false);
1773 }
1774
1775 /**
1776 * @tc.name: AdjustLocalZOrder001
1777 * @tc.desc: Test RSUniRenderVisitorTest.AdjustLocalZOrder for HardwareEnabled node
1778 * @tc.type: FUNC
1779 * @tc.require: issuesI7RNL4
1780 */
1781 HWTEST_F(RSUniRenderVisitorTest, AdjustLocalZOrder001, TestSize.Level2)
1782 {
1783 auto appWindowNode = RSTestUtil::CreateSurfaceNode();
1784 auto ChildHardwareEnabledNode = RSTestUtil::CreateSurfaceNode();
1785 ASSERT_NE(appWindowNode, nullptr);
1786 ASSERT_NE(ChildHardwareEnabledNode, nullptr);
1787 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
1788 appWindowNode->AddChildHardwareEnabledNode(ChildHardwareEnabledNode);
1789
1790 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1791 ASSERT_NE(rsUniRenderVisitor, nullptr);
1792 rsUniRenderVisitor->isParallel_ = false;
1793
1794 rsUniRenderVisitor->CollectAppNodeForHwc(appWindowNode);
1795 ASSERT_NE(rsUniRenderVisitor->appWindowNodesInZOrder_.size(), 0);
1796 }
1797
1798 /**
1799 * @tc.name: UpdateHardwareEnableList001
1800 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareEnableList while filterRects is empty
1801 * @tc.type: FUNC
1802 * @tc.require: issuesI7RNL4
1803 */
1804 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareEnableList001, TestSize.Level2)
1805 {
1806 auto firstNode = RSTestUtil::CreateSurfaceNode();
1807 auto secondNode = RSTestUtil::CreateSurfaceNode();
1808 ASSERT_NE(firstNode, nullptr);
1809 ASSERT_NE(secondNode, nullptr);
1810 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1811 firstNode->SetDstRect(DstRect);
1812
1813 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>;
1814 vector<SurfaceDirtyMgrPair> validHwcNodes;
1815 vector<RectI> filterRects;
1816 validHwcNodes.push_back({firstNode, secondNode});
1817
1818 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1819 ASSERT_NE(rsUniRenderVisitor, nullptr);
1820 ASSERT_TRUE(rsUniRenderVisitor->UpdateHardwareEnableList(filterRects, validHwcNodes).IsEmpty());
1821 }
1822
1823 /**
1824 * @tc.name: UpdateHardwareEnableList002
1825 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareEnableList while
1826 * filterRects doesn't intersect with HWC node's rect
1827 * @tc.type: FUNC
1828 * @tc.require: issuesI7RNL4
1829 */
1830 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareEnableList002, TestSize.Level2)
1831 {
1832 auto firstNode = RSTestUtil::CreateSurfaceNode();
1833 auto secondNode = RSTestUtil::CreateSurfaceNode();
1834 ASSERT_NE(firstNode, nullptr);
1835 ASSERT_NE(secondNode, nullptr);
1836 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1837 firstNode->SetDstRect(DstRect);
1838
1839 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>;
1840 vector<SurfaceDirtyMgrPair> validHwcNodes;
1841 vector<RectI> filterRects;
1842 validHwcNodes.push_back({firstNode, secondNode});
1843 RectI filterRect(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1844 filterRects.push_back(filterRect);
1845
1846 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1847 ASSERT_NE(rsUniRenderVisitor, nullptr);
1848 ASSERT_TRUE(rsUniRenderVisitor->UpdateHardwareEnableList(filterRects, validHwcNodes).IsEmpty());
1849 }
1850
1851 /**
1852 * @tc.name: UpdateHardwareEnableList003
1853 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareEnableList while
1854 * filterRects intersects with with HWC node's rect
1855 * @tc.type: FUNC
1856 * @tc.require: issuesI7RNL4
1857 */
1858 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareEnableList003, TestSize.Level2)
1859 {
1860 auto firstNode = RSTestUtil::CreateSurfaceNode();
1861 auto secondNode = RSTestUtil::CreateSurfaceNode();
1862 ASSERT_NE(firstNode, nullptr);
1863 ASSERT_NE(secondNode, nullptr);
1864 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1865 firstNode->SetDstRect(DstRect);
1866
1867 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>;
1868 vector<SurfaceDirtyMgrPair> validHwcNodes;
1869 vector<RectI> filterRects;
1870 validHwcNodes.push_back({firstNode, secondNode});
1871 RectI filterRect = DstRect;
1872 filterRects.push_back(filterRect);
1873
1874 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1875 ASSERT_NE(rsUniRenderVisitor, nullptr);
1876 ASSERT_FALSE(rsUniRenderVisitor->UpdateHardwareEnableList(filterRects, validHwcNodes).IsEmpty());
1877 }
1878
1879 /**
1880 * @tc.name: UpdateHardwareEnableList004
1881 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareEnableList while
1882 * filterRects intersects with LastFrameHardwareEnabled node's rect
1883 * @tc.type: FUNC
1884 * @tc.require: issuesI7RNL4
1885 */
1886 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareEnableList004, TestSize.Level2)
1887 {
1888 auto firstNode = RSTestUtil::CreateSurfaceNode();
1889 auto secondNode = RSTestUtil::CreateSurfaceNode();
1890 ASSERT_NE(firstNode, nullptr);
1891 ASSERT_NE(secondNode, nullptr);
1892 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1893 firstNode->SetDstRect(DstRect);
1894 firstNode->isLastFrameHardwareEnabled_ = true;
1895
1896 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>;
1897 vector<SurfaceDirtyMgrPair> validHwcNodes;
1898 vector<RectI> filterRects;
1899 validHwcNodes.push_back({firstNode, secondNode});
1900 RectI filterRect = DstRect;
1901 filterRects.push_back(filterRect);
1902
1903 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1904 ASSERT_NE(rsUniRenderVisitor, nullptr);
1905 rsUniRenderVisitor->UpdateHardwareEnableList(filterRects, validHwcNodes);
1906 }
1907
1908 /**
1909 * @tc.name: AddContainerDirtyToGlobalDirty001
1910 * @tc.desc: Test RSUniRenderVisitorTest.AddContainerDirtyToGlobalDirty while
1911 currentFrameDirtyRegion_ doesn't intersect with containerRegion_
1912 * @tc.type: FUNC
1913 * @tc.require: issuesI7RNL4
1914 */
1915 HWTEST_F(RSUniRenderVisitorTest, AddContainerDirtyToGlobalDirty001, TestSize.Level2)
1916 {
1917 NodeId id = 1;
1918 RSDisplayNodeConfig config;
1919 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1920 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1921 ASSERT_NE(displayNode, nullptr);
1922 ASSERT_NE(surfaceNode, nullptr);
1923 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
1924 surfaceNode->containerConfig_.hasContainerWindow_ = true;
1925 Occlusion::Rect rect = Occlusion::Rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1926 surfaceNode->GetContainerRegion().GetBoundRef() = rect;
1927
1928 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1929 ASSERT_NE(rsUniRenderVisitor, nullptr);
1930 rsUniRenderVisitor->AddContainerDirtyToGlobalDirty(displayNode);
1931 ASSERT_TRUE(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty());
1932 }
1933
1934 /**
1935 * @tc.name: AddContainerDirtyToGlobalDirty002
1936 * @tc.desc: Test RSUniRenderVisitorTest.AddContainerDirtyToGlobalDirty while
1937 * currentFrameDirtyRegion_ intersect with containerRegion_
1938 * @tc.type: FUNC
1939 * @tc.require: issuesI7RNL4
1940 */
1941 HWTEST_F(RSUniRenderVisitorTest, AddContainerDirtyToGlobalDirty002, TestSize.Level2)
1942 {
1943 NodeId id = 1;
1944 RSDisplayNodeConfig config;
1945 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1946 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1947 ASSERT_NE(displayNode, nullptr);
1948 ASSERT_NE(surfaceNode, nullptr);
1949 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
1950 surfaceNode->containerConfig_.hasContainerWindow_ = true;
1951 Occlusion::Rect rect = Occlusion::Rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1952 surfaceNode->GetContainerRegion().GetBoundRef() = rect;
1953 surfaceNode->GetContainerRegion().GetRegionRectsRef().push_back(rect);
1954 surfaceNode->GetDirtyManager()->MergeDirtyRect(RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT));
1955
1956 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1957 ASSERT_NE(rsUniRenderVisitor, nullptr);
1958 rsUniRenderVisitor->AddContainerDirtyToGlobalDirty(displayNode);
1959 ASSERT_FALSE(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty());
1960 }
1961
1962 /**
1963 * @tc.name: CheckIfSurfaceRenderNodeNeedProcess001
1964 * @tc.desc: Test RSUniRenderVisitorTest.CheckIfSurfaceRenderNodeNeedProcess for skip layer
1965 * @tc.type: FUNC
1966 * @tc.require: issuesI7RNL4
1967 */
1968 HWTEST_F(RSUniRenderVisitorTest, CheckIfSurfaceRenderNodeNeedProcess001, TestSize.Level2)
1969 {
1970 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1971 ASSERT_NE(surfaceNode, nullptr);
1972 surfaceNode->SetSkipLayer(true);
1973
1974 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1975 ASSERT_NE(rsUniRenderVisitor, nullptr);
1976 rsUniRenderVisitor->isSecurityDisplay_ = true;
1977 bool keepFilterCache = false;
1978 ASSERT_FALSE(rsUniRenderVisitor->CheckIfSurfaceRenderNodeNeedProcess(*surfaceNode, keepFilterCache));
1979 }
1980
1981 /**
1982 * @tc.name: CheckIfSurfaceRenderNodeNeedProcess002
1983 * @tc.desc: Test RSUniRenderVisitorTest.CheckIfSurfaceRenderNodeNeedProcess for empty ability component
1984 * @tc.type: FUNC
1985 * @tc.require: issuesI7RNL4
1986 */
1987 HWTEST_F(RSUniRenderVisitorTest, CheckIfSurfaceRenderNodeNeedProcess002, TestSize.Level2)
1988 {
1989 auto abilityComponentNode = RSTestUtil::CreateSurfaceNode();
1990 ASSERT_NE(abilityComponentNode, nullptr);
1991 abilityComponentNode->GetMutableRenderProperties().SetVisible(true);
1992 abilityComponentNode->SetSurfaceNodeType(RSSurfaceNodeType::ABILITY_COMPONENT_NODE);
1993
1994 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1995 ASSERT_NE(rsUniRenderVisitor, nullptr);
1996 bool keepFilterCache = false;
1997 ASSERT_FALSE(rsUniRenderVisitor->CheckIfSurfaceRenderNodeNeedProcess(*abilityComponentNode, keepFilterCache));
1998 }
1999
2000 /**
2001 * @tc.name: CheckIfSurfaceRenderNodeNeedProcess003
2002 * @tc.desc: Test RSUniRenderVisitorTest.CheckIfSurfaceRenderNodeNeedProcess for different types of filteredAppSet
2003 * @tc.type: FUNC
2004 * @tc.require: issueI8FSLX
2005 */
2006 HWTEST_F(RSUniRenderVisitorTest, CheckIfSurfaceRenderNodeNeedProcess003, TestSize.Level2)
2007 {
2008 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2009 ASSERT_NE(surfaceNode, nullptr);
2010 ScreenInfo info;
2011
2012 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2013 ASSERT_NE(rsUniRenderVisitor, nullptr);
2014 rsUniRenderVisitor->screenInfo_ = info;
2015
2016 bool keepFilterCache;
2017 // filteredAppSet is empty
2018 ASSERT_TRUE(rsUniRenderVisitor->CheckIfSurfaceRenderNodeNeedProcess(*surfaceNode, keepFilterCache));
2019 // filteredAppSet isn't empty and don't contain this surface node's id
2020 rsUniRenderVisitor->screenInfo_.filteredAppSet.insert(surfaceNode->GetId() + 1);
2021 ASSERT_FALSE(rsUniRenderVisitor->CheckIfSurfaceRenderNodeNeedProcess(*surfaceNode, keepFilterCache));
2022 // filteredAppSet isn't empty and contain this surface node's id
2023 rsUniRenderVisitor->screenInfo_.filteredAppSet.insert(surfaceNode->GetId());
2024 ASSERT_FALSE(rsUniRenderVisitor->CheckIfSurfaceRenderNodeNeedProcess(*surfaceNode, keepFilterCache));
2025 }
2026
2027 /**
2028 * @tc.name: PrepareSharedTransitionNode001
2029 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSharedTransitionNode while paired node is already destroyed
2030 * @tc.type: FUNC
2031 * @tc.require: issueI8MVJ6
2032 */
2033 HWTEST_F(RSUniRenderVisitorTest, PrepareSharedTransitionNode001, TestSize.Level2)
2034 {
2035 auto node = RSTestUtil::CreateSurfaceNode();
2036 auto pairedNode = RSTestUtil::CreateSurfaceNode();
2037 ASSERT_NE(node, nullptr);
2038 ASSERT_NE(pairedNode, nullptr);
2039
2040 node->sharedTransitionParam_ = {node->GetId(), pairedNode};
2041 pairedNode.reset();
2042
2043 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2044 ASSERT_NE(rsUniRenderVisitor, nullptr);
2045 rsUniRenderVisitor->PrepareSharedTransitionNode(*node);
2046 ASSERT_EQ(node->GetSharedTransitionParam(), std::nullopt);
2047 }
2048
2049 /**
2050 * @tc.name: PrepareSharedTransitionNode002
2051 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSharedTransitionNode while paired node is not a transition node
2052 * @tc.type: FUNC
2053 * @tc.require: issueI8MVJ6
2054 */
2055 HWTEST_F(RSUniRenderVisitorTest, PrepareSharedTransitionNode002, TestSize.Level2)
2056 {
2057 auto node = RSTestUtil::CreateSurfaceNode();
2058 auto pairedNode = RSTestUtil::CreateSurfaceNode();
2059 ASSERT_NE(node, nullptr);
2060 ASSERT_NE(pairedNode, nullptr);
2061
2062 node->sharedTransitionParam_ = {node->GetId(), pairedNode};
2063 pairedNode->SetIsOnTheTree(true);
2064
2065 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2066 ASSERT_NE(rsUniRenderVisitor, nullptr);
2067 rsUniRenderVisitor->PrepareSharedTransitionNode(*node);
2068 ASSERT_EQ(node->GetSharedTransitionParam(), std::nullopt);
2069 }
2070
2071 /**
2072 * @tc.name: PrepareSharedTransitionNode003
2073 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSharedTransitionNode while paired node is not paired with this node
2074 * @tc.type: FUNC
2075 * @tc.require: issueI8MVJ6
2076 */
2077 HWTEST_F(RSUniRenderVisitorTest, PrepareSharedTransitionNode003, TestSize.Level2)
2078 {
2079 auto node = RSTestUtil::CreateSurfaceNode();
2080 auto pairedNode = RSTestUtil::CreateSurfaceNode();
2081 ASSERT_NE(node, nullptr);
2082 ASSERT_NE(pairedNode, nullptr);
2083
2084 node->sharedTransitionParam_ = {node->GetId(), pairedNode};
2085 pairedNode->sharedTransitionParam_ = {pairedNode->GetId(), pairedNode};
2086 pairedNode->SetIsOnTheTree(true);
2087
2088 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2089 ASSERT_NE(rsUniRenderVisitor, nullptr);
2090 rsUniRenderVisitor->PrepareSharedTransitionNode(*node);
2091 ASSERT_EQ(node->GetSharedTransitionParam(), std::nullopt);
2092 }
2093
2094 /**
2095 * @tc.name: PrepareSharedTransitionNode004
2096 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSharedTransitionNode while transition node match
2097 * @tc.type: FUNC
2098 * @tc.require: issueI8MVJ6
2099 */
2100 HWTEST_F(RSUniRenderVisitorTest, PrepareSharedTransitionNode004, TestSize.Level2)
2101 {
2102 auto node = RSTestUtil::CreateSurfaceNode();
2103 auto pairedNode = RSTestUtil::CreateSurfaceNode();
2104 ASSERT_NE(node, nullptr);
2105 ASSERT_NE(pairedNode, nullptr);
2106
2107 node->sharedTransitionParam_ = {node->GetId(), pairedNode};
2108 pairedNode->sharedTransitionParam_ = {node->GetId(), pairedNode};
2109 pairedNode->SetIsOnTheTree(true);
2110
2111 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2112 ASSERT_NE(rsUniRenderVisitor, nullptr);
2113 rsUniRenderVisitor->PrepareSharedTransitionNode(*node);
2114 ASSERT_EQ(rsUniRenderVisitor->prepareClipRect_, RectI(0, 0, INT_MAX, INT_MAX));
2115 }
2116
2117 /**
2118 * @tc.name: PrepareSharedTransitionNode005
2119 * @tc.desc: Test mark curSurfaceNode while PrepareSharedTransitionNode
2120 * @tc.type: FUNC
2121 * @tc.require: issueI8MVJ6
2122 */
2123 HWTEST_F(RSUniRenderVisitorTest, PrepareSharedTransitionNode005, TestSize.Level2)
2124 {
2125 auto node = RSTestUtil::CreateSurfaceNode();
2126 auto pairedNode = RSTestUtil::CreateSurfaceNode();
2127 auto curSurfaceNode = RSTestUtil::CreateSurfaceNode();
2128 ASSERT_NE(node, nullptr);
2129 ASSERT_NE(pairedNode, nullptr);
2130 ASSERT_NE(curSurfaceNode, nullptr);
2131
2132 node->sharedTransitionParam_ = {node->GetId(), pairedNode};
2133 pairedNode->sharedTransitionParam_ = {node->GetId(), pairedNode};
2134 pairedNode->SetIsOnTheTree(true);
2135
2136 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2137 ASSERT_NE(rsUniRenderVisitor, nullptr);
2138 rsUniRenderVisitor->curSurfaceNode_ = curSurfaceNode;
2139 rsUniRenderVisitor->PrepareSharedTransitionNode(*node);
2140 ASSERT_TRUE(curSurfaceNode->GetHasSharedTransitionNode());
2141 }
2142
2143 /**
2144 * @tc.name: PrepareSharedTransitionNode006
2145 * @tc.desc: Test mark curSurfaceNode's parent while PrepareSharedTransitionNode
2146 * @tc.type: FUNC
2147 * @tc.require: issueI8MVJ6
2148 */
2149 HWTEST_F(RSUniRenderVisitorTest, PrepareSharedTransitionNode006, TestSize.Level2)
2150 {
2151 auto node = RSTestUtil::CreateSurfaceNode();
2152 auto pairedNode = RSTestUtil::CreateSurfaceNode();
2153 auto curSurfaceNode = RSTestUtil::CreateSurfaceNode();
2154 auto parentNode = RSTestUtil::CreateSurfaceNode();
2155
2156 ASSERT_NE(node, nullptr);
2157 ASSERT_NE(pairedNode, nullptr);
2158 ASSERT_NE(curSurfaceNode, nullptr);
2159 ASSERT_NE(parentNode, nullptr);
2160
2161 node->sharedTransitionParam_ = {node->GetId(), pairedNode};
2162 pairedNode->sharedTransitionParam_ = {node->GetId(), pairedNode};
2163 pairedNode->SetIsOnTheTree(true);
2164
2165 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2166 ASSERT_NE(rsUniRenderVisitor, nullptr);
2167 rsUniRenderVisitor->curSurfaceNode_ = curSurfaceNode;
2168
2169 parentNode->AddChild(curSurfaceNode);
2170 // while curSurfaceNode's parent isn't LEASH_WINDOW_NODE, shouldn't mark it
2171 rsUniRenderVisitor->PrepareSharedTransitionNode(*node);
2172 ASSERT_FALSE(parentNode->GetHasSharedTransitionNode());
2173 // while curSurfaceNode's parent is LEASH_WINDOW_NODE, should mark it
2174 parentNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
2175 rsUniRenderVisitor->PrepareSharedTransitionNode(*node);
2176 ASSERT_TRUE(parentNode->GetHasSharedTransitionNode());
2177 }
2178
2179 /**
2180 * @tc.name: ClosePartialRenderWhenAnimatingWindows002
2181 * @tc.desc: Test RSUniRenderVisitorTest.ClosePartialRenderWhenAnimatingWindows while
2182 * appWindowNum_ isn't bigger than PHONE_MAX_APP_WINDOW_NUM
2183 * @tc.type: FUNC
2184 * @tc.require: issuesI7SAJC
2185 */
2186 HWTEST_F(RSUniRenderVisitorTest, ClosePartialRenderWhenAnimatingWindows002, TestSize.Level2)
2187 {
2188 NodeId id = 0;
2189 RSDisplayNodeConfig config;
2190 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2191 ASSERT_NE(displayNode, nullptr);
2192 RectI rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2193 displayNode->GetDirtyManager()->surfaceRect_ = rect;
2194
2195 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2196 ASSERT_NE(rsUniRenderVisitor, nullptr);
2197 rsUniRenderVisitor->SetAnimateState(true);
2198 rsUniRenderVisitor->SetAppWindowNum(1);
2199 rsUniRenderVisitor->ClosePartialRenderWhenAnimatingWindows(displayNode);
2200 ASSERT_TRUE(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty());
2201 }
2202
2203 /**
2204 * @tc.name: ClosePartialRenderWhenAnimatingWindows003
2205 * @tc.desc: Test RSUniRenderVisitorTest.ClosePartialRenderWhenAnimatingWindows while
2206 * appWindowNum_ is bigger than PHONE_MAX_APP_WINDOW_NUM
2207 * @tc.type: FUNC
2208 * @tc.require: issuesI7SAJC
2209 */
2210 HWTEST_F(RSUniRenderVisitorTest, ClosePartialRenderWhenAnimatingWindows003, TestSize.Level2)
2211 {
2212 NodeId id = 0;
2213 RSDisplayNodeConfig config;
2214 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2215 ASSERT_NE(displayNode, nullptr);
2216 RectI rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2217 displayNode->GetDirtyManager()->surfaceRect_ = rect;
2218
2219 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2220 ASSERT_NE(rsUniRenderVisitor, nullptr);
2221 rsUniRenderVisitor->SetAnimateState(true);
2222 rsUniRenderVisitor->SetAppWindowNum(2);
2223 rsUniRenderVisitor->ClosePartialRenderWhenAnimatingWindows(displayNode);
2224 ASSERT_EQ(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion(), rect);
2225 }
2226
2227 /**
2228 * @tc.name: DrawChildRenderNode001
2229 * @tc.desc: Test RSUniRenderVisitorTest.DrawChildRenderNode api while
2230 * the canvas node's cacheType_ is ANIMATE_PROPERTY
2231 * @tc.type: FUNC
2232 * @tc.require: issuesI7SAJC
2233 */
2234 HWTEST_F(RSUniRenderVisitorTest, DrawChildRenderNode001, TestSize.Level2)
2235 {
2236 auto rsContext = std::make_shared<RSContext>();
2237 auto canvasNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
2238 ASSERT_NE(canvasNode, nullptr);
2239 canvasNode->SetCacheType(CacheType::ANIMATE_PROPERTY);
2240
2241 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2242 #ifndef USE_ROSEN_DRAWING
2243 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2244 #else
2245 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2246 #endif
2247 ASSERT_NE(rsUniRenderVisitor, nullptr);
2248 #ifndef USE_ROSEN_DRAWING
2249 ASSERT_NE(skCanvas, nullptr);
2250 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
2251 #else
2252 ASSERT_NE(drawingCanvas, nullptr);
2253 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
2254 #endif
2255 rsUniRenderVisitor->DrawChildRenderNode(*canvasNode);
2256 }
2257
2258 /*
2259 * @tc.name: MarkSubHardwareEnableNodeState003
2260 * @tc.desc: Test RSUniRenderVisitorTest.MarkSubHardwareEnableNodeStateTest for self drawing node
2261 * @tc.type: FUNC
2262 * @tc.require: issuesI7SAJC
2263 */
2264 HWTEST_F(RSUniRenderVisitorTest, MarkSubHardwareEnableNodeState003, TestSize.Level2)
2265 {
2266 auto selfDrawingNode = RSTestUtil::CreateSurfaceNode();
2267 ASSERT_NE(selfDrawingNode, nullptr);
2268 selfDrawingNode->SetSurfaceNodeType(RSSurfaceNodeType::SELF_DRAWING_NODE);
2269 selfDrawingNode->SetHardwareEnabled(true);
2270
2271 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2272 ASSERT_NE(rsUniRenderVisitor, nullptr);
2273 rsUniRenderVisitor->MarkSubHardwareEnableNodeState(*selfDrawingNode);
2274 ASSERT_TRUE(selfDrawingNode->IsHardwareForcedDisabled());
2275 }
2276
2277 /*
2278 * @tc.name: MarkSubHardwareEnableNodeState004
2279 * @tc.desc: Test RSUniRenderVisitorTest.MarkSubHardwareEnableNodeStateTest for app window node's child
2280 * @tc.type: FUNC
2281 * @tc.require: issuesI7SAJC
2282 */
2283 HWTEST_F(RSUniRenderVisitorTest, MarkSubHardwareEnableNodeState004, TestSize.Level2)
2284 {
2285 auto appWindowNode = RSTestUtil::CreateSurfaceNode();
2286 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNode();
2287 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2288 appWindowNode->AddChildHardwareEnabledNode(hardwareEnabledNode);
2289
2290 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2291 ASSERT_NE(rsUniRenderVisitor, nullptr);
2292 rsUniRenderVisitor->MarkSubHardwareEnableNodeState(*appWindowNode);
2293 ASSERT_TRUE(hardwareEnabledNode->IsHardwareForcedDisabled());
2294 }
2295
2296 /*
2297 * @tc.name: PrepareTypesOfSurfaceRenderNodeBeforeUpdate001
2298 * @tc.desc: Test RSUniRenderVisitorTest.PrepareTypesOfSurfaceRenderNodeBeforeUpdateTest for DFX enabled
2299 * @tc.type: FUNC
2300 * @tc.require: issuesI7SAJC
2301 */
2302 HWTEST_F(RSUniRenderVisitorTest, PrepareTypesOfSurfaceRenderNodeBeforeUpdate001, TestSize.Level2)
2303 {
2304 auto leashWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2305 ASSERT_NE(leashWindowNode, nullptr);
2306 leashWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
2307
2308 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2309 ASSERT_NE(rsUniRenderVisitor, nullptr);
2310 rsUniRenderVisitor->isTargetDirtyRegionDfxEnabled_ = true;
2311 rsUniRenderVisitor->dfxTargetSurfaceNames_.push_back(leashWindowNode->GetName());
2312 rsUniRenderVisitor->PrepareTypesOfSurfaceRenderNodeBeforeUpdate(*leashWindowNode);
2313 ASSERT_TRUE(rsUniRenderVisitor->curSurfaceDirtyManager_->IsTargetForDfx());
2314 }
2315
2316 /*
2317 * @tc.name: PrepareTypesOfSurfaceRenderNodeBeforeUpdate002
2318 * @tc.desc: Test RSUniRenderVisitorTest.PrepareTypesOfSurfaceRenderNodeBeforeUpdateTest for self drawing node
2319 * @tc.type: FUNC
2320 * @tc.require: issuesI7SAJC
2321 */
2322 HWTEST_F(RSUniRenderVisitorTest, PrepareTypesOfSurfaceRenderNodeBeforeUpdate002, TestSize.Level2)
2323 {
2324 auto selfDrawingNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2325 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2326 ASSERT_NE(selfDrawingNode, nullptr);
2327 ASSERT_NE(surfaceNode, nullptr);
2328 selfDrawingNode->SetSurfaceNodeType(RSSurfaceNodeType::SELF_DRAWING_NODE);
2329 selfDrawingNode->SetHardwareEnabled(true);
2330
2331 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2332 ASSERT_NE(rsUniRenderVisitor, nullptr);
2333 rsUniRenderVisitor->curSurfaceNode_ = surfaceNode;
2334
2335 rsUniRenderVisitor->PrepareTypesOfSurfaceRenderNodeBeforeUpdate(*selfDrawingNode);
2336 ASSERT_FALSE(rsUniRenderVisitor->curSurfaceNode_->GetChildHardwareEnabledNodes().empty());
2337 }
2338
2339 /*
2340 * @tc.name: ResetCurSurfaceInfoAsUpperSurfaceParent001
2341 * @tc.desc: Reset but keep single node's surfaceInfo
2342 * @tc.type: FUNC
2343 * @tc.require: issuesI8MQCS
2344 */
2345 HWTEST_F(RSUniRenderVisitorTest, ResetCurSurfaceInfoAsUpperSurfaceParent001, TestSize.Level2)
2346 {
2347 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2348 std::weak_ptr<RSSurfaceRenderNode> upperSurfaceNode;
2349 ASSERT_NE(surfaceNode, nullptr);
2350 surfaceNode->SetParent(upperSurfaceNode);
2351
2352 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2353 ASSERT_NE(rsUniRenderVisitor, nullptr);
2354 rsUniRenderVisitor->curSurfaceNode_ = surfaceNode;
2355
2356 rsUniRenderVisitor->ResetCurSurfaceInfoAsUpperSurfaceParent(*surfaceNode);
2357 ASSERT_EQ(rsUniRenderVisitor->curSurfaceNode_, surfaceNode);
2358 }
2359
2360 /*
2361 * @tc.name: ResetCurSurfaceInfoAsUpperSurfaceParent002
2362 * @tc.desc: Reset but keep node's surfaceInfo since upper surface's InstanceRootNode is not registered
2363 * @tc.type: FUNC
2364 * @tc.require: issuesI8MQCS
2365 */
2366 HWTEST_F(RSUniRenderVisitorTest, ResetCurSurfaceInfoAsUpperSurfaceParent002, TestSize.Level2)
2367 {
2368 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2369 auto upperSurfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2370 ASSERT_NE(surfaceNode, nullptr);
2371 ASSERT_NE(upperSurfaceNode, nullptr);
2372 upperSurfaceNode->instanceRootNodeId_ = upperSurfaceNode->GetId();
2373 ASSERT_EQ(upperSurfaceNode->GetInstanceRootNode(), nullptr);
2374 surfaceNode->SetParent(std::weak_ptr<RSSurfaceRenderNode>(upperSurfaceNode));
2375
2376 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2377 ASSERT_NE(rsUniRenderVisitor, nullptr);
2378 rsUniRenderVisitor->curSurfaceNode_ = surfaceNode;
2379
2380 rsUniRenderVisitor->ResetCurSurfaceInfoAsUpperSurfaceParent(*surfaceNode);
2381 ASSERT_EQ(rsUniRenderVisitor->curSurfaceNode_, surfaceNode);
2382 }
2383
2384 /*
2385 * @tc.name: PrepareSurfaceRenderNode001
2386 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSurfaceRenderNode while surface node has security layer
2387 * @tc.type: FUNC
2388 * @tc.require: issuesI7SAJC
2389 */
2390 HWTEST_F(RSUniRenderVisitorTest, PrepareSurfaceRenderNode001, TestSize.Level2)
2391 {
2392 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2393 ASSERT_NE(surfaceNode, nullptr);
2394 surfaceNode->SetSecurityLayer(true);
2395 surfaceNode->SetIsOnTheTree(true);
2396 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2397
2398 NodeId id = 0;
2399 RSDisplayNodeConfig config;
2400 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2401 ASSERT_NE(displayNode, nullptr);
2402
2403 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2404 ASSERT_NE(rsUniRenderVisitor, nullptr);
2405 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2406 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2407 rsUniRenderVisitor->displayHasSecSurface_[rsUniRenderVisitor->currentVisitDisplay_] = false;
2408 rsUniRenderVisitor->PrepareSurfaceRenderNode(*surfaceNode);
2409 ASSERT_EQ(rsUniRenderVisitor->displayHasSecSurface_[rsUniRenderVisitor->currentVisitDisplay_], true);
2410 }
2411
2412 /*
2413 * @tc.name: AssignGlobalZOrderAndCreateLayer001
2414 * @tc.desc: Test RSUniRenderVisitorTest.AssignGlobalZOrderAndCreateLayerTest
2415 * while appWindowNodesInZOrder_ is empty
2416 * @tc.type: FUNC
2417 * @tc.require: issuesI7SAJC
2418 */
2419 HWTEST_F(RSUniRenderVisitorTest, AssignGlobalZOrderAndCreateLayer001, TestSize.Level2)
2420 {
2421 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2422 ASSERT_NE(hardwareEnabledNode, nullptr);
2423
2424 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2425 ASSERT_NE(rsUniRenderVisitor, nullptr);
2426 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(hardwareEnabledNode);
2427
2428 std::vector<std::shared_ptr<RSSurfaceRenderNode>> nodeList;
2429 auto oldZOrder = rsUniRenderVisitor->globalZOrder_;
2430 rsUniRenderVisitor->AssignGlobalZOrderAndCreateLayer(nodeList);
2431 ASSERT_EQ(rsUniRenderVisitor->globalZOrder_, oldZOrder);
2432 }
2433
2434 /*
2435 * @tc.name: AssignGlobalZOrderAndCreateLayer002
2436 * @tc.desc: Test RSUniRenderVisitorTest.AssignGlobalZOrderAndCreateLayerTest
2437 * while app window nodes don't have child
2438 * @tc.type: FUNC
2439 * @tc.require: issuesI7SAJC
2440 */
2441 HWTEST_F(RSUniRenderVisitorTest, AssignGlobalZOrderAndCreateLayer002, TestSize.Level2)
2442 {
2443 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2444 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2445 ASSERT_NE(hardwareEnabledNode, nullptr);
2446 ASSERT_NE(appWindowNode, nullptr);
2447 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2448
2449 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2450 ASSERT_NE(rsUniRenderVisitor, nullptr);
2451 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(hardwareEnabledNode);
2452
2453 std::vector<std::shared_ptr<RSSurfaceRenderNode>> nodeList;
2454 nodeList.push_back(appWindowNode);
2455 auto oldZOrder = rsUniRenderVisitor->globalZOrder_;
2456 rsUniRenderVisitor->AssignGlobalZOrderAndCreateLayer(nodeList);
2457 ASSERT_EQ(rsUniRenderVisitor->globalZOrder_, oldZOrder);
2458 }
2459
2460 /*
2461 * @tc.name: AssignGlobalZOrderAndCreateLayer003
2462 * @tc.desc: Test RSUniRenderVisitorTest.AssignGlobalZOrderAndCreateLayerTest
2463 * while app window nodes's child is HardwareForcedDisabled
2464 * @tc.type: FUNC
2465 * @tc.require: issuesI7SAJC
2466 */
2467 HWTEST_F(RSUniRenderVisitorTest, AssignGlobalZOrderAndCreateLayer003, TestSize.Level2)
2468 {
2469 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2470 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2471 auto childNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2472 ASSERT_NE(hardwareEnabledNode, nullptr);
2473 ASSERT_NE(appWindowNode, nullptr);
2474 ASSERT_NE(childNode, nullptr);
2475 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2476 appWindowNode->AddChildHardwareEnabledNode(childNode);
2477
2478 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2479 ASSERT_NE(rsUniRenderVisitor, nullptr);
2480 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(hardwareEnabledNode);
2481
2482 std::vector<std::shared_ptr<RSSurfaceRenderNode>> nodeList;
2483 nodeList.push_back(appWindowNode);
2484 auto oldZOrder = rsUniRenderVisitor->globalZOrder_;
2485 rsUniRenderVisitor->AssignGlobalZOrderAndCreateLayer(nodeList);
2486 ASSERT_EQ(rsUniRenderVisitor->globalZOrder_, oldZOrder);
2487 }
2488
2489 /*
2490 * @tc.name: AssignGlobalZOrderAndCreateLayer004
2491 * @tc.desc: Test RSUniRenderVisitorTest.AssignGlobalZOrderAndCreateLayerTest
2492 * while app window nodes's child isn't HardwareForcedDisabled
2493 * @tc.type: FUNC
2494 * @tc.require: issuesI7SAJC
2495 */
2496 HWTEST_F(RSUniRenderVisitorTest, AssignGlobalZOrderAndCreateLayer004, TestSize.Level2)
2497 {
2498 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2499 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2500 auto childNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2501 ASSERT_NE(hardwareEnabledNode, nullptr);
2502 ASSERT_NE(appWindowNode, nullptr);
2503 ASSERT_NE(childNode, nullptr);
2504 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2505 appWindowNode->AddChildHardwareEnabledNode(childNode);
2506 childNode->dstRect_ = RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2507 childNode->isOnTheTree_ = true;
2508
2509 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2510 ASSERT_NE(rsUniRenderVisitor, nullptr);
2511 rsUniRenderVisitor->processor_ = RSProcessorFactory::CreateProcessor(
2512 RSDisplayRenderNode::CompositeType::UNI_RENDER_COMPOSITE);
2513 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(hardwareEnabledNode);
2514
2515 std::vector<std::shared_ptr<RSSurfaceRenderNode>> nodeList;
2516 nodeList.push_back(appWindowNode);
2517 auto oldZOrder = rsUniRenderVisitor->globalZOrder_;
2518 rsUniRenderVisitor->AssignGlobalZOrderAndCreateLayer(nodeList);
2519 ASSERT_NE(rsUniRenderVisitor->globalZOrder_, oldZOrder);
2520 }
2521
2522 /*
2523 * @tc.name: CalcDirtyDisplayRegion002
2524 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyDisplayRegion while surface node's shadow is valid
2525 * @tc.type: FUNC
2526 * @tc.require: issuesI7T9RE
2527 */
2528 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion002, TestSize.Level2)
2529 {
2530 NodeId id = 0;
2531 RSDisplayNodeConfig config;
2532 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2533 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2534 ASSERT_NE(displayNode, nullptr);
2535 ASSERT_NE(surfaceNode, nullptr);
2536 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
2537 surfaceNode->GetMutableRenderProperties().SetShadowRadius(1.0f);
2538
2539 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2540 ASSERT_NE(rsUniRenderVisitor, nullptr);
2541 rsUniRenderVisitor->CalcDirtyDisplayRegion(displayNode);
2542 ASSERT_FALSE(surfaceNode->IsShadowValidLastFrame());
2543 }
2544
2545 /*
2546 * @tc.name: CalcDirtyDisplayRegion003
2547 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyDisplayRegion while
2548 * surface node's shadow is valid and its shadow dirty rect isn't empty
2549 * @tc.type: FUNC
2550 * @tc.require: issuesI7T9RE
2551 */
2552 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion003, TestSize.Level2)
2553 {
2554 NodeId id = 0;
2555 RSDisplayNodeConfig config;
2556 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2557 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2558 ASSERT_NE(displayNode, nullptr);
2559 ASSERT_NE(surfaceNode, nullptr);
2560 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
2561 surfaceNode->GetMutableRenderProperties().SetShadowRadius(1.0f);
2562 RectI rect=RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2563 surfaceNode->oldDirtyInSurface_ = rect;
2564 surfaceNode->GetDirtyManager()->MergeDirtyRect(rect);
2565
2566 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2567 ASSERT_NE(rsUniRenderVisitor, nullptr);
2568 rsUniRenderVisitor->CalcDirtyDisplayRegion(displayNode);
2569 ASSERT_EQ(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion(), rect);
2570 }
2571
2572 /*
2573 * @tc.name: CalcDirtyDisplayRegion004
2574 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyDisplayRegion while
2575 * surface node is shadow valid last frame
2576 * @tc.type: FUNC
2577 * @tc.require: issuesI7T9RE
2578 */
2579 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion004, TestSize.Level2)
2580 {
2581 NodeId id = 0;
2582 RSDisplayNodeConfig config;
2583 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2584 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2585 ASSERT_NE(displayNode, nullptr);
2586 ASSERT_NE(surfaceNode, nullptr);
2587 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
2588 surfaceNode->SetShadowValidLastFrame(true);
2589
2590 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2591 ASSERT_NE(rsUniRenderVisitor, nullptr);
2592 rsUniRenderVisitor->CalcDirtyDisplayRegion(displayNode);
2593 ASSERT_FALSE(surfaceNode->IsShadowValidLastFrame());
2594 }
2595
2596 /*
2597 * @tc.name: CalcDirtyDisplayRegion005
2598 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyDisplayRegion while
2599 * surface node is shadow valid last frame and its shadow dirty rect isn't empty
2600 * @tc.type: FUNC
2601 * @tc.require: issuesI7T9RE
2602 */
2603 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion005, TestSize.Level2)
2604 {
2605 NodeId id = 0;
2606 RSDisplayNodeConfig config;
2607 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2608 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2609 ASSERT_NE(displayNode, nullptr);
2610 ASSERT_NE(surfaceNode, nullptr);
2611 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
2612 surfaceNode->SetShadowValidLastFrame(true);
2613 RectI rect=RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2614 surfaceNode->oldDirtyInSurface_ = rect;
2615 surfaceNode->GetDirtyManager()->MergeDirtyRect(rect);
2616
2617 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2618 ASSERT_NE(rsUniRenderVisitor, nullptr);
2619 rsUniRenderVisitor->CalcDirtyDisplayRegion(displayNode);
2620 ASSERT_EQ(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion(), rect);
2621 }
2622
2623 /*
2624 * @tc.name: UpdateHardwareNodeStatusBasedOnFilter001
2625 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareNodeStatusBasedOnFilter while
2626 * prevHwcEnabledNodes first node's rect intersect app window node's is empty
2627 * @tc.type: FUNC
2628 * @tc.require: issuesI7T9RE
2629 */
2630 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareNodeStatusBasedOnFilter001, TestSize.Level2)
2631 {
2632 NodeId id = 0;
2633 RSDisplayNodeConfig config;
2634 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2635 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2636 auto childNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2637 ASSERT_NE(displayNode, nullptr);
2638 ASSERT_NE(appWindowNode, nullptr);
2639 ASSERT_NE(childNode, nullptr);
2640 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2641 appWindowNode->AddChildHardwareEnabledNode(childNode);
2642 auto dirtyManager = displayNode->GetDirtyManager();
2643
2644 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>,
2645 std::shared_ptr<RSSurfaceRenderNode>>;
2646 vector<SurfaceDirtyMgrPair> prevHwcEnabledNodes;
2647 auto firstNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2648 auto secondNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2649 ASSERT_NE(firstNode, nullptr);
2650 ASSERT_NE(secondNode, nullptr);
2651 prevHwcEnabledNodes.push_back({firstNode, secondNode});
2652
2653 appWindowNode->visibleRegion_ =
2654 Occlusion::Rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2655 RectI rect=RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2656 childNode->oldDirtyInSurface_ = rect;
2657
2658 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2659 ASSERT_NE(rsUniRenderVisitor, nullptr);
2660 rsUniRenderVisitor->UpdateHardwareNodeStatusBasedOnFilter(appWindowNode,
2661 prevHwcEnabledNodes, dirtyManager);
2662 ASSERT_NE(prevHwcEnabledNodes.size(), 1);
2663 }
2664
2665 /*
2666 * @tc.name: UpdateHardwareNodeStatusBasedOnFilter002
2667 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareNodeStatusBasedOnFilter while
2668 * prevHwcEnabledNodes first node's rect intersect app window node's isn't empty
2669 * @tc.type: FUNC
2670 * @tc.require: issuesI7T9RE
2671 */
2672 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareNodeStatusBasedOnFilter002, TestSize.Level2)
2673 {NodeId id = 0;
2674 RSDisplayNodeConfig config;
2675 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2676 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2677 auto childNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2678 ASSERT_NE(displayNode, nullptr);
2679 ASSERT_NE(appWindowNode, nullptr);
2680 ASSERT_NE(childNode, nullptr);
2681 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2682 appWindowNode->AddChildHardwareEnabledNode(childNode);
2683 auto dirtyManager = displayNode->GetDirtyManager();
2684
2685 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>,
2686 std::shared_ptr<RSSurfaceRenderNode>>;
2687 vector<SurfaceDirtyMgrPair> prevHwcEnabledNodes;
2688 auto firstNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2689 auto secondNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2690 ASSERT_NE(firstNode, nullptr);
2691 ASSERT_NE(secondNode, nullptr);
2692 prevHwcEnabledNodes.push_back({firstNode, secondNode});
2693
2694 appWindowNode->visibleRegion_ =
2695 Occlusion::Rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2696 RectI rect=RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2697 childNode->oldDirtyInSurface_ = rect;
2698 childNode->SetDstRect(rect);
2699 firstNode->SetDstRect(rect);
2700
2701 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2702 ASSERT_NE(rsUniRenderVisitor, nullptr);
2703 rsUniRenderVisitor->UpdateHardwareNodeStatusBasedOnFilter(appWindowNode,
2704 prevHwcEnabledNodes, dirtyManager);
2705 ASSERT_EQ(prevHwcEnabledNodes.size(), 1);
2706 }
2707
2708 /**
2709 * @tc.name: ProcessSharedTransitionNode001
2710 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSharedTransitionNode while
2711 * node's sharedTransitionParam isn't empty
2712 * @tc.type: FUNC
2713 * @tc.require: issueI7UGLR
2714 */
2715 HWTEST_F(RSUniRenderVisitorTest, ProcessSharedTransitionNode001, TestSize.Level2)
2716 {
2717 auto node = RSTestUtil::CreateSurfaceNodeWithBuffer();
2718 auto transitionNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2719 ASSERT_NE(node, nullptr);
2720 ASSERT_NE(transitionNode, nullptr);
2721 node->sharedTransitionParam_ = {transitionNode->GetId(), transitionNode};
2722 transitionNode->SetIsOnTheTree(true);
2723
2724 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2725 #ifndef USE_ROSEN_DRAWING
2726 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2727 #else
2728 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2729 #endif
2730 ASSERT_NE(rsUniRenderVisitor, nullptr);
2731 #ifndef USE_ROSEN_DRAWING
2732 ASSERT_NE(skCanvas, nullptr);
2733 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
2734 #else
2735 ASSERT_NE(drawingCanvas, nullptr);
2736 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
2737 #endif
2738
2739 ASSERT_FALSE(rsUniRenderVisitor->ProcessSharedTransitionNode(*node));
2740 }
2741
2742 /**
2743 * @tc.name: ProcessSharedTransitionNode002
2744 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSharedTransitionNode while
2745 * render visitor just init node cache
2746 * @tc.type: FUNC
2747 * @tc.require: issueI7UGLR
2748 */
2749 HWTEST_F(RSUniRenderVisitorTest, ProcessSharedTransitionNode002, TestSize.Level2)
2750 {
2751 auto node = RSTestUtil::CreateSurfaceNodeWithBuffer();
2752 auto transitionNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2753 ASSERT_NE(node, nullptr);
2754 ASSERT_NE(transitionNode, nullptr);
2755 node->sharedTransitionParam_ = {transitionNode->GetId(), transitionNode};
2756 node->SetDrawingCacheType(RSDrawingCacheType::FORCED_CACHE);
2757 transitionNode->SetIsOnTheTree(true);
2758
2759 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2760 #ifndef USE_ROSEN_DRAWING
2761 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2762 #else
2763 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2764 #endif
2765 ASSERT_NE(rsUniRenderVisitor, nullptr);
2766 #ifndef USE_ROSEN_DRAWING
2767 ASSERT_NE(skCanvas, nullptr);
2768 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
2769 #else
2770 ASSERT_NE(drawingCanvas, nullptr);
2771 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
2772 #endif
2773 rsUniRenderVisitor->InitNodeCache(*node);
2774
2775 ASSERT_FALSE(rsUniRenderVisitor->ProcessSharedTransitionNode(*node));
2776 }
2777
2778 /**
2779 * @tc.name: ProcessSharedTransitionNode003
2780 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSharedTransitionNode while
2781 * transition node's GlobalAlpha equal to zero
2782 * @tc.type: FUNC
2783 * @tc.require: issueI7UGLR
2784 */
2785 HWTEST_F(RSUniRenderVisitorTest, ProcessSharedTransitionNode003, TestSize.Level2)
2786 {
2787 auto node = RSTestUtil::CreateSurfaceNodeWithBuffer();
2788 auto transitionNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2789 ASSERT_NE(node, nullptr);
2790 ASSERT_NE(transitionNode, nullptr);
2791 node->sharedTransitionParam_ = {transitionNode->GetId(), transitionNode};
2792 transitionNode->SetGlobalAlpha(0.0f);
2793
2794 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2795 ASSERT_NE(rsUniRenderVisitor, nullptr);
2796 ASSERT_TRUE(rsUniRenderVisitor->ProcessSharedTransitionNode(*node));
2797 }
2798
2799 /**
2800 * @tc.name: UpdateSubTreeInCache001
2801 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSubTreeInCache while
2802 * node doesn't have Child
2803 * @tc.type: FUNC
2804 * @tc.require: issueI7UGLR
2805 */
2806 HWTEST_F(RSUniRenderVisitorTest, UpdateSubTreeInCache001, TestSize.Level2)
2807 {
2808 NodeId id = 0;
2809 auto node = std::make_shared<RSRenderNode>(id);
2810
2811 ASSERT_NE(node, nullptr);
2812 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2813 ASSERT_NE(rsUniRenderVisitor, nullptr);
2814 rsUniRenderVisitor->UpdateSubTreeInCache(node, *node->GetSortedChildren());
2815 ASSERT_EQ(node->GetDrawingCacheChanged(), false);
2816 }
2817
2818 /**
2819 * @tc.name: UpdateSubTreeInCache002
2820 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSubTreeInCache while
2821 * node has Child
2822 * @tc.type: FUNC
2823 * @tc.require: issueI7UGLR
2824 */
2825 HWTEST_F(RSUniRenderVisitorTest, UpdateSubTreeInCache002, TestSize.Level2)
2826 {
2827 NodeId id = 0;
2828 auto node = std::make_shared<RSRenderNode>(id);
2829 ASSERT_NE(node, nullptr);
2830 NodeId id2 = 1;
2831 auto child = std::make_shared<RSRenderNode>(id2);
2832 ASSERT_NE(child, nullptr);
2833
2834 node->AddChild(child);
2835 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2836 ASSERT_NE(rsUniRenderVisitor, nullptr);
2837 rsUniRenderVisitor->UpdateSubTreeInCache(node, *node->GetSortedChildren());
2838 ASSERT_EQ(node->GetDrawingCacheChanged(), false);
2839 }
2840
2841
2842 /**
2843 * @tc.name: DrawTargetSurfaceVisibleRegionForDFX001
2844 * @tc.desc: Test RSUniRenderVisitorTest.DrawTargetSurfaceVisibleRegionForDFX while
2845 * RSDisplayRenderNode is the same as displafConfig set
2846 * @tc.type: FUNC
2847 * @tc.require: issueI7UGLR
2848 */
2849 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceVisibleRegionForDFX001, TestSize.Level2)
2850 {
2851 RSDisplayNodeConfig displayConfig;
2852 auto rsContext = std::make_shared<RSContext>();
2853 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
2854 ASSERT_NE(rsDisplayRenderNode, nullptr);
2855 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2856 ASSERT_NE(surfaceNode, nullptr);
2857 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2858 rsDisplayRenderNode->GetCurAllSurfaces().push_back(surfaceNode);
2859 rsDisplayRenderNode->GetCurAllSurfaces().push_back(nullptr);
2860
2861 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2862 ASSERT_NE(rsUniRenderVisitor, nullptr);
2863 rsUniRenderVisitor->dfxTargetSurfaceNames_.emplace_back(surfaceNode->GetName());
2864 Occlusion::Rect rect{0, 0, 0, 0};
2865 Occlusion::Region region{rect};
2866 surfaceNode->visibleRegion_ = region;
2867 rsUniRenderVisitor->DrawTargetSurfaceVisibleRegionForDFX(*rsDisplayRenderNode);
2868 }
2869
2870 /**
2871 * @tc.name: DrawCurrentRefreshRate001
2872 * @tc.desc: Test RSUniRenderVisitorTest.DrawCurrentRefreshRate while
2873 * currentRefreshRate is equal to 0
2874 * @tc.type: FUNC
2875 * @tc.require: issueI7UGLR
2876 */
2877 HWTEST_F(RSUniRenderVisitorTest, DrawCurrentRefreshRate001, TestSize.Level2)
2878 {
2879 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2880
2881 #ifndef USE_ROSEN_DRAWING
2882 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2883 #else
2884 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2885 #endif
2886 ASSERT_NE(rsUniRenderVisitor, nullptr);
2887
2888 #ifndef USE_ROSEN_DRAWING
2889 ASSERT_NE(skCanvas, nullptr);
2890 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
2891 #else
2892 ASSERT_NE(drawingCanvas, nullptr);
2893 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
2894 #endif
2895 rsUniRenderVisitor->DrawCurrentRefreshRate(0, 0);
2896 }
2897
2898
2899 /**
2900 * @tc.name: ProcessChildrenForScreenRecordingOptimization001
2901 * @tc.desc: Test RSUniRenderVisitorTest.ProcessChildrenForScreenRecordingOptimization while
2902 * isSubThread_ is equal to false
2903 * @tc.type: FUNC
2904 * @tc.require: issueI7UGLR
2905 */
2906 HWTEST_F(RSUniRenderVisitorTest, ProcessChildrenForScreenRecordingOptimization001, TestSize.Level2)
2907 {
2908 NodeId id = 0;
2909 RSDisplayNodeConfig displayConfig;
2910 auto rsContext = std::make_shared<RSContext>();
2911 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
2912 ASSERT_NE(rsDisplayRenderNode, nullptr);
2913
2914 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2915 ASSERT_NE(rsUniRenderVisitor, nullptr);
2916 rsUniRenderVisitor->ProcessChildrenForScreenRecordingOptimization(*rsDisplayRenderNode, id);
2917 }
2918
2919 /**
2920 * @tc.name: ProcessChildrenForScreenRecordingOptimization002
2921 * @tc.desc: Test RSUniRenderVisitorTest.ProcessChildrenForScreenRecordingOptimization while
2922 * isSubThread_ is equal to true
2923 * @tc.type: FUNC
2924 * @tc.require: issueI7UGLR
2925 */
2926 HWTEST_F(RSUniRenderVisitorTest, ProcessChildrenForScreenRecordingOptimization002, TestSize.Level2)
2927 {
2928 NodeId id = 0;
2929 RSDisplayNodeConfig displayConfig;
2930 auto rsContext = std::make_shared<RSContext>();
2931 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
2932 ASSERT_NE(rsDisplayRenderNode, nullptr);
2933
2934 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2935 rsUniRenderVisitor->isSubThread_ = true;
2936 ASSERT_NE(rsUniRenderVisitor, nullptr);
2937 rsUniRenderVisitor->ProcessChildrenForScreenRecordingOptimization(*rsDisplayRenderNode, id);
2938 }
2939
2940 /**
2941 * @tc.name: ProcessChildInner001
2942 * @tc.desc: Test RSUniRenderVisitorTest.ProcessChildInner while
2943 * node has child
2944 * @tc.type: FUNC
2945 * @tc.require: issueI7UGLR
2946 */
2947 HWTEST_F(RSUniRenderVisitorTest, ProcessChildInner001, TestSize.Level2)
2948 {
2949 NodeId id = 0;
2950 NodeId id2 = 1;
2951 RSRenderNode *node = new RSRenderNode(id2);
2952 auto child = std::make_shared<RSRenderNode>(id);
2953 ASSERT_NE(child, nullptr);
2954
2955 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2956 ASSERT_NE(rsUniRenderVisitor, nullptr);
2957 rsUniRenderVisitor->ProcessChildInner(*node, child);
2958 }
2959
2960 /**
2961 * @tc.name: GetCacheImageFromMirrorNode001
2962 * @tc.desc: Test RSUniRenderVisitorTest.GetCacheImageFromMirrorNode while
2963 * cacheImage == nullptr
2964 * @tc.type: FUNC
2965 * @tc.require: issueI7UGLR
2966 */
2967 HWTEST_F(RSUniRenderVisitorTest, GetCacheImageFromMirrorNode001, TestSize.Level2)
2968 {
2969 RSDisplayNodeConfig displayConfig;
2970 auto rsContext = std::make_shared<RSContext>();
2971 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
2972 ASSERT_NE(rsDisplayRenderNode, nullptr);
2973
2974 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2975 ASSERT_NE(rsUniRenderVisitor, nullptr);
2976 RSMainThread::Instance()->doParallelComposition_ = true;
2977 ASSERT_EQ(rsUniRenderVisitor->GetCacheImageFromMirrorNode(rsDisplayRenderNode), nullptr);
2978 }
2979
2980 /**
2981 * @tc.name: DrawSurfaceLayer001
2982 * @tc.desc: Test RSUniRenderVisitorTest.DrawSurfaceLayer while
2983 * displayNode has child
2984 * @tc.type: FUNC
2985 * @tc.require: issueI7UGLR
2986 */
2987 HWTEST_F(RSUniRenderVisitorTest, DrawSurfaceLayer001, TestSize.Level2)
2988 {
2989 NodeId id = 0;
2990 RSDisplayNodeConfig config;
2991 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2992 ASSERT_NE(displayNode, nullptr);
2993 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2994 ASSERT_NE(surfaceNode, nullptr);
2995 displayNode->AddChild(surfaceNode);
2996
2997 std::list<std::shared_ptr<RSSurfaceRenderNode>> mainThreadNodes;
2998 std::list<std::shared_ptr<RSSurfaceRenderNode>> subThreadNodes;
2999 RSUniRenderUtil::AssignWindowNodes(displayNode, mainThreadNodes, subThreadNodes);
3000
3001 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3002 #ifndef USE_ROSEN_DRAWING
3003 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3004 #else
3005 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3006 #endif
3007 ASSERT_NE(rsUniRenderVisitor, nullptr);
3008
3009 #ifndef USE_ROSEN_DRAWING
3010 ASSERT_NE(skCanvas, nullptr);
3011 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
3012 #else
3013 ASSERT_NE(drawingCanvas, nullptr);
3014 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
3015 #endif
3016 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
3017 rsUniRenderVisitor->renderEngine_->Init();
3018 rsUniRenderVisitor->DrawSurfaceLayer(displayNode, subThreadNodes);
3019 }
3020
3021 /**
3022 * @tc.name: SwitchColorFilterDrawing001
3023 * @tc.desc: Test RSUniRenderVisitorTest.SwitchColorFilterDrawing while
3024 * currentSaveCount == 0
3025 * @tc.type: FUNC
3026 * @tc.require: issueI7UGLR
3027 */
3028 HWTEST_F(RSUniRenderVisitorTest, SwitchColorFilterDrawing001, TestSize.Level2)
3029 {
3030 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3031 ASSERT_NE(rsUniRenderVisitor, nullptr);
3032 rsUniRenderVisitor->SwitchColorFilterDrawing(0);
3033 }
3034
3035 /**
3036 * @tc.name: FindInstanceChildOfDisplay001
3037 * @tc.desc: Test FindInstanceChildOfDisplay while node is nullptr
3038 * @tc.type: FUNC
3039 * @tc.require: issueI904G4
3040 */
3041 HWTEST_F(RSUniRenderVisitorTest, FindInstanceChildOfDisplay001, TestSize.Level2)
3042 {
3043 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3044 ASSERT_NE(rsUniRenderVisitor, nullptr);
3045 ASSERT_EQ(rsUniRenderVisitor->FindInstanceChildOfDisplay(nullptr), INVALID_NODEID);
3046 }
3047
3048 /**
3049 * @tc.name: FindInstanceChildOfDisplay002
3050 * @tc.desc: Test FindInstanceChildOfDisplay while node's parent is nullptr
3051 * @tc.type: FUNC
3052 * @tc.require: issueI904G4
3053 */
3054 HWTEST_F(RSUniRenderVisitorTest, FindInstanceChildOfDisplay002, TestSize.Level2)
3055 {
3056 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
3057 ASSERT_NE(surfaceNode, nullptr);
3058 surfaceNode->GetParent().reset();
3059
3060 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3061 ASSERT_NE(rsUniRenderVisitor, nullptr);
3062 ASSERT_EQ(rsUniRenderVisitor->FindInstanceChildOfDisplay(surfaceNode), INVALID_NODEID);
3063 }
3064
3065 /**
3066 * @tc.name: FindInstanceChildOfDisplay003
3067 * @tc.desc: Test FindInstanceChildOfDisplay while node's parent is display node
3068 * @tc.type: FUNC
3069 * @tc.require: issueI904G4
3070 */
3071 HWTEST_F(RSUniRenderVisitorTest, FindInstanceChildOfDisplay003, TestSize.Level2)
3072 {
3073 NodeId id = 0;
3074 RSDisplayNodeConfig config;
3075 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
3076 ASSERT_NE(displayNode, nullptr);
3077 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
3078 ASSERT_NE(surfaceNode, nullptr);
3079 displayNode->AddChild(surfaceNode);
3080
3081 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3082 ASSERT_NE(rsUniRenderVisitor, nullptr);
3083 ASSERT_EQ(rsUniRenderVisitor->FindInstanceChildOfDisplay(surfaceNode), surfaceNode->GetId());
3084 }
3085
3086 /**
3087 * @tc.name: FindInstanceChildOfDisplay004
3088 * @tc.desc: Test FindInstanceChildOfDisplay while node's parent isn't display node
3089 * @tc.type: FUNC
3090 * @tc.require: issueI904G4
3091 */
3092 HWTEST_F(RSUniRenderVisitorTest, FindInstanceChildOfDisplay004, TestSize.Level2)
3093 {
3094 RSDisplayNodeConfig config;
3095 NodeId id = 0;
3096 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
3097 auto canvasNode = std::make_shared<RSCanvasRenderNode>(id++);
3098 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
3099 ASSERT_NE(displayNode, nullptr);
3100 ASSERT_NE(canvasNode, nullptr);
3101 ASSERT_NE(surfaceNode, nullptr);
3102
3103 displayNode->AddChild(canvasNode);
3104 canvasNode->AddChild(surfaceNode);
3105
3106 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3107 ASSERT_NE(rsUniRenderVisitor, nullptr);
3108 ASSERT_EQ(rsUniRenderVisitor->FindInstanceChildOfDisplay(surfaceNode), canvasNode->GetId());
3109 }
3110
3111 /**
3112 * @tc.name: DrawEffectRenderNodeForDFX001
3113 * @tc.desc: Test RSUniRenderVisitorTest.DrawEffectRenderNodeForDFX while
3114 * rect map is empty.
3115 * @tc.type: FUNC
3116 * @tc.require: issueI8WJXC
3117 */
3118 HWTEST_F(RSUniRenderVisitorTest, DrawEffectRenderNodeForDFX001, TestSize.Level2)
3119 {
3120 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3121 ASSERT_NE(rsUniRenderVisitor, nullptr);
3122 rsUniRenderVisitor->DrawEffectRenderNodeForDFX();
3123 }
3124
3125 /**
3126 * @tc.name: DrawEffectRenderNodeForDFX002
3127 * @tc.desc: Test RSUniRenderVisitorTest.DrawEffectRenderNodeForDFX while
3128 * rect map is not empty.
3129 * @tc.type: FUNC
3130 * @tc.require: issueI8WJXC
3131 */
3132 HWTEST_F(RSUniRenderVisitorTest, DrawEffectRenderNodeForDFX002, TestSize.Level2)
3133 {
3134 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3135 ASSERT_NE(rsUniRenderVisitor, nullptr);
3136
3137 #ifndef USE_ROSEN_DRAWING
3138 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3139 ASSERT_NE(skCanvas, nullptr);
3140 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
3141 #else
3142 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3143 ASSERT_NE(drawingCanvas, nullptr);
3144 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
3145 #endif
3146
3147 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
3148 rsUniRenderVisitor->renderEngine_->Init();
3149
3150 NodeId nodeId = 0;
3151 std::weak_ptr<RSContext> context;
3152 RSEffectRenderNode rsEffectRenderNode(nodeId, context);
3153
3154 RectI rect1(0, 0, 1, 1);
3155 rsUniRenderVisitor->nodesUseEffectForDfx_.emplace_back(rect1);
3156 RectI rect2(2, 2, 3, 3);
3157 rsUniRenderVisitor->nodesUseEffectFallbackForDfx_.emplace_back(rect2);
3158
3159 rsUniRenderVisitor->effectNodeMapForDfx_[nodeId].first = rsUniRenderVisitor->nodesUseEffectForDfx_;
3160 rsUniRenderVisitor->effectNodeMapForDfx_[nodeId].second = rsUniRenderVisitor->nodesUseEffectFallbackForDfx_;
3161
3162 rsUniRenderVisitor->DrawEffectRenderNodeForDFX();
3163 }
3164
3165 /**
3166 * @tc.name: ProcessShadowFirst001
3167 * @tc.desc: Test RSUniRenderVisitorTest.ProcessShadowFirst while SetUseShadowBatching true.
3168 * @tc.type:FUNC
3169 * @tc.require:issueI8WJXC
3170 */
3171 HWTEST_F(RSUniRenderVisitorTest, ProcessShadowFirst001, TestSize.Level1)
3172 {
3173 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3174 ASSERT_NE(rsUniRenderVisitor, nullptr);
3175
3176 #ifndef USE_ROSEN_DRAWING
3177 auto skCanvas = std::make_shared<SkCanvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3178 ASSERT_NE(skCanvas, nullptr);
3179 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(skCanvas.get());
3180 #else
3181 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3182 ASSERT_NE(drawingCanvas, nullptr);
3183 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
3184 #endif
3185
3186 rsUniRenderVisitor->renderEngine_ = std::make_shared<RSUniRenderEngine>();
3187 rsUniRenderVisitor->renderEngine_->Init();
3188
3189 NodeId id = 0;
3190 auto node = std::make_shared<RSCanvasRenderNode>(id);
3191 ASSERT_NE(node, nullptr);
3192 NodeId id1 = 1;
3193 auto child1 = std::make_shared<RSCanvasRenderNode>(id1);
3194 ASSERT_NE(child1, nullptr);
3195 NodeId id2 = 2;
3196 auto child2 = std::make_shared<RSCanvasRenderNode>(id2);
3197 ASSERT_NE(child2, nullptr);
3198 node->AddChild(child1);
3199 node->AddChild(child2);
3200
3201 auto& prop1 = child1->GetMutableRenderProperties();
3202 prop1.SetShadowRadius(100.0);
3203
3204 auto& prop2 = child2->GetMutableRenderProperties();
3205 prop2.SetShadowRadius(100.0);
3206
3207 auto& property = node->GetMutableRenderProperties();
3208 property.SetUseShadowBatching(true);
3209 const auto& prop = node->GetRenderProperties();
3210 ASSERT_TRUE(prop.GetUseShadowBatching());
3211 rsUniRenderVisitor->ProcessShadowFirst(*node, true);
3212 }
3213
3214 /**
3215 * @tc.name: UpdateSubTreeInCache003
3216 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSubTreeInCache, with diffrent children type
3217 * @tc.type: FUNC
3218 * @tc.require: issueI7UGLR
3219 */
3220 HWTEST_F(RSUniRenderVisitorTest, UpdateSubTreeInCache003, TestSize.Level2)
3221 {
3222 NodeId id = 0;
3223 auto node = std::make_shared<RSRenderNode>(id);
3224 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3225 ASSERT_NE(rsUniRenderVisitor, nullptr);
3226 // prepare child lists
3227 auto child1 = std::make_shared<RSSurfaceRenderNode>(++id);
3228 auto child2 = std::make_shared<RSEffectRenderNode>(++id);
3229 std::shared_ptr<RSRenderNode> child3 = nullptr;
3230 std::vector<RSRenderNode::SharedPtr> children;
3231 children.push_back(child1);
3232 children.push_back(child2);
3233 children.push_back(child3);
3234 rsUniRenderVisitor->UpdateSubTreeInCache(node, *node->GetSortedChildren());
3235 }
3236
3237 /**
3238 * @tc.name: PrepareEffectNodeIfCacheReuse001
3239 * @tc.desc: Test PrepareEffectNodeIfCacheReuse, effectNode nullptr
3240 * @tc.type: FUNC
3241 * @tc.require: issueI7UGLR
3242 */
3243 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectNodeIfCacheReuse001, TestSize.Level2)
3244 {
3245 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3246 ASSERT_NE(rsUniRenderVisitor, nullptr);
3247 RSDisplayNodeConfig displayConfig;
3248 auto rsContext = std::make_shared<RSContext>();
3249 NodeId id = 1;
3250 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(++id,
3251 displayConfig, rsContext->weak_from_this());
3252 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
3253 // prepare node
3254 auto node = std::make_shared<RSRenderNode>(++id);
3255 std::shared_ptr<RSEffectRenderNode> effectNode = nullptr;
3256 rsUniRenderVisitor->PrepareEffectNodeIfCacheReuse(node, effectNode);
3257 }
3258
3259 /**
3260 * @tc.name: PrepareEffectNodeIfCacheReuse002
3261 * @tc.desc: Test RSUniRenderVisitorTest.PrepareEffectNodeIfCacheReuse002, with dirty manager
3262 * @tc.type: FUNC
3263 * @tc.require: issueI7UGLR
3264 */
3265 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectNodeIfCacheReuse002, TestSize.Level2)
3266 {
3267 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3268 ASSERT_NE(rsUniRenderVisitor, nullptr);
3269 RSDisplayNodeConfig displayConfig;
3270 auto rsContext = std::make_shared<RSContext>();
3271 NodeId id = 1;
3272 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(++id,
3273 displayConfig, rsContext->weak_from_this());
3274 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
3275 // prepare node
3276 auto node = std::make_shared<RSRenderNode>(++id);
3277 rsUniRenderVisitor->curSurfaceDirtyManager_ = std::make_shared<RSDirtyRegionManager>();
3278 auto effectNode = std::make_shared<RSEffectRenderNode>(++id);
3279 rsUniRenderVisitor->PrepareEffectNodeIfCacheReuse(node, effectNode);
3280 }
3281
3282 /**
3283 * @tc.name: PrepareEffectNodeIfCacheReuse003
3284 * @tc.desc: Test RSUniRenderVisitorTest.PrepareEffectNodeIfCacheReuse003, needFilter_ equals true
3285 * @tc.type: FUNC
3286 * @tc.require: issueI7UGLR
3287 */
3288 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectNodeIfCacheReuse003, TestSize.Level2)
3289 {
3290 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3291 ASSERT_NE(rsUniRenderVisitor, nullptr);
3292 RSDisplayNodeConfig displayConfig;
3293 auto rsContext = std::make_shared<RSContext>();
3294 NodeId id = 1;
3295 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(++id,
3296 displayConfig, rsContext->weak_from_this());
3297 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
3298 // prepare node
3299 auto node = std::make_shared<RSRenderNode>(++id);
3300 rsUniRenderVisitor->curSurfaceDirtyManager_ = std::make_shared<RSDirtyRegionManager>();
3301 auto effectNode = std::make_shared<RSEffectRenderNode>(++id);
3302 effectNode->GetMutableRenderProperties().needFilter_ = true;
3303 rsUniRenderVisitor->PrepareEffectNodeIfCacheReuse(node, effectNode);
3304 }
3305
3306 /**
3307 * @tc.name: PrepareEffectNodeIfCacheReuse004
3308 * @tc.desc: Test RSUniRenderVisitorTest.PrepareEffectNodeIfCacheReuse004
3309 * curSurfaceNode_->GetId() equals effectNode->GetInstanceRootNodeId()
3310 * @tc.type: FUNC
3311 * @tc.require: issueI7UGLR
3312 */
3313 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectNodeIfCacheReuse004, TestSize.Level2)
3314 {
3315 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3316 ASSERT_NE(rsUniRenderVisitor, nullptr);
3317 RSDisplayNodeConfig displayConfig;
3318 auto rsContext = std::make_shared<RSContext>();
3319 NodeId id = 1;
3320 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(++id,
3321 displayConfig, rsContext->weak_from_this());
3322 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
3323 // prepare node
3324 auto node = std::make_shared<RSRenderNode>(++id);
3325 rsUniRenderVisitor->curSurfaceDirtyManager_ = std::make_shared<RSDirtyRegionManager>();
3326 auto effectNode = std::make_shared<RSEffectRenderNode>(++id);
3327 effectNode->GetMutableRenderProperties().needFilter_ = true;
3328 id = 0x0FFF;
3329 effectNode->instanceRootNodeId_ = id;
3330 rsUniRenderVisitor->curSurfaceNode_ = std::make_shared<RSSurfaceRenderNode>(id);
3331 rsUniRenderVisitor->PrepareEffectNodeIfCacheReuse(node, effectNode);
3332 }
3333
3334 /**
3335 * @tc.name: DisableNodeCacheInSetting001
3336 * @tc.desc: Test RSUniRenderVisitorTest.DisableNodeCacheInSetting001
3337 * @tc.type: FUNC
3338 * @tc.require: issueI7UGLR
3339 */
3340 HWTEST_F(RSUniRenderVisitorTest, DisableNodeCacheInSetting001, TestSize.Level2)
3341 {
3342 NodeId id = 0;
3343 auto node = std::make_shared<RSRenderNode>(id);
3344 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3345 ASSERT_NE(rsUniRenderVisitor, nullptr);
3346 rsUniRenderVisitor->DisableNodeCacheInSetting(*node);
3347 }
3348
3349 /**
3350 * @tc.name: DisableNodeCacheInSetting002
3351 * @tc.desc: Test RSUniRenderVisitorTest.DisableNodeCacheInSetting002, TARGETED_CACHE
3352 * @tc.type: FUNC
3353 * @tc.require: issueI7UGLR
3354 */
3355 HWTEST_F(RSUniRenderVisitorTest, DisableNodeCacheInSetting002, TestSize.Level2)
3356 {
3357 NodeId id = 0;
3358 auto node = std::make_shared<RSRenderNode>(id);
3359 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3360 ASSERT_NE(rsUniRenderVisitor, nullptr);
3361 node->drawingCacheType_ = RSDrawingCacheType::TARGETED_CACHE;
3362 rsUniRenderVisitor->DisableNodeCacheInSetting(*node);
3363 }
3364
3365 /**
3366 * @tc.name: DisableNodeCacheInSetting003
3367 * @tc.desc: Test RSUniRenderVisitorTest.DisableNodeCacheInSetting003
3368 * firstVisitedCache_ = INVALID_NODEID
3369 * @tc.type: FUNC
3370 * @tc.require: issueI7UGLR
3371 */
3372 HWTEST_F(RSUniRenderVisitorTest, DisableNodeCacheInSetting003, TestSize.Level2)
3373 {
3374 NodeId id = 0;
3375 auto node = std::make_shared<RSRenderNode>(id);
3376 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3377 ASSERT_NE(rsUniRenderVisitor, nullptr);
3378 rsUniRenderVisitor->firstVisitedCache_ = INVALID_NODEID;
3379 node->drawingCacheType_ = RSDrawingCacheType::TARGETED_CACHE;
3380 rsUniRenderVisitor->DisableNodeCacheInSetting(*node);
3381 }
3382
3383 /**
3384 * @tc.name: IsFirstVisitedCacheForced
3385 * @tc.desc: Test RSUniRenderVisitorTest.IsFirstVisitedCacheForced
3386 * @tc.type: FUNC
3387 * @tc.require: issueI7UGLR
3388 */
3389 HWTEST_F(RSUniRenderVisitorTest, IsFirstVisitedCacheForced, TestSize.Level2)
3390 {
3391 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3392 ASSERT_NE(rsUniRenderVisitor, nullptr);
3393 rsUniRenderVisitor->firstVisitedCache_ = INVALID_NODEID;
3394 ASSERT_FALSE(rsUniRenderVisitor->IsFirstVisitedCacheForced());
3395 rsUniRenderVisitor->firstVisitedCache_ = 1;
3396 ASSERT_FALSE(rsUniRenderVisitor->IsFirstVisitedCacheForced());
3397 }
3398
3399 /**
3400 * @tc.name: SaveCurSurface
3401 * @tc.desc: Test RSUniRenderVisitorTest.SaveCurSurface
3402 * @tc.type: FUNC
3403 * @tc.require: issueI7UGLR
3404 */
3405 HWTEST_F(RSUniRenderVisitorTest, SaveCurSurface, TestSize.Level2)
3406 {
3407 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3408 ASSERT_NE(rsUniRenderVisitor, nullptr);
3409 rsUniRenderVisitor->isSubSurfaceEnabled_ = true;
3410 auto manager = std::make_shared<RSDirtyRegionManager>();
3411 NodeId id = 1;
3412 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3413 rsUniRenderVisitor->SaveCurSurface(manager, node);
3414 }
3415
3416 /**
3417 * @tc.name: RestoreCurSurface
3418 * @tc.desc: Test RSUniRenderVisitorTest.RestoreCurSurface
3419 * @tc.type: FUNC
3420 * @tc.require: issueI7UGLR
3421 */
3422 HWTEST_F(RSUniRenderVisitorTest, RestoreCurSurface, TestSize.Level2)
3423 {
3424 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3425 ASSERT_NE(rsUniRenderVisitor, nullptr);
3426 rsUniRenderVisitor->isSubSurfaceEnabled_ = true;
3427 auto manager = std::make_shared<RSDirtyRegionManager>();
3428 NodeId id = 1;
3429 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3430 rsUniRenderVisitor->SaveCurSurface(manager, node);
3431 rsUniRenderVisitor->RestoreCurSurface(manager, node);
3432 }
3433
3434 /**
3435 * @tc.name: PrepareSubSurfaceNodes
3436 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSubSurfaceNodes
3437 * @tc.type: FUNC
3438 * @tc.require: issueI7UGLR
3439 */
3440 HWTEST_F(RSUniRenderVisitorTest, PrepareSubSurfaceNodes, TestSize.Level2)
3441 {
3442 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3443 ASSERT_NE(rsUniRenderVisitor, nullptr);
3444 rsUniRenderVisitor->isSubSurfaceEnabled_ = true;
3445 NodeId id = 1;
3446 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3447 std::vector<std::weak_ptr<RSRenderNode>> ptrs;
3448 id = 2;
3449 auto subNode1 = std::make_shared<RSSurfaceRenderNode>(id);
3450 RSDisplayNodeConfig config;
3451 id = 3;
3452 auto subNode2 = std::make_shared<RSDisplayRenderNode>(id, config);
3453 ptrs.push_back(subNode1);
3454 ptrs.push_back(subNode2);
3455 node->subSurfaceNodes_[1] = ptrs;
3456 rsUniRenderVisitor->PrepareSubSurfaceNodes(*node);
3457 }
3458
3459 /**
3460 * @tc.name: ProcessSubSurfaceNodes
3461 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSubSurfaceNodes
3462 * @tc.type: FUNC
3463 * @tc.require: issueI7UGLR
3464 */
3465 HWTEST_F(RSUniRenderVisitorTest, ProcessSubSurfaceNodes, TestSize.Level2)
3466 {
3467 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3468 ASSERT_NE(rsUniRenderVisitor, nullptr);
3469 rsUniRenderVisitor->isSubSurfaceEnabled_ = true;
3470 NodeId id = 1;
3471 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3472 std::vector<std::weak_ptr<RSRenderNode>> ptrs;
3473 id = 2;
3474 auto subNode1 = std::make_shared<RSSurfaceRenderNode>(id);
3475 RSDisplayNodeConfig config;
3476 id = 3;
3477 auto subNode2 = std::make_shared<RSDisplayRenderNode>(id, config);
3478 ptrs.push_back(subNode1);
3479 ptrs.push_back(subNode2);
3480 node->subSurfaceNodes_[node->GetId()] = ptrs;
3481 rsUniRenderVisitor->ProcessSubSurfaceNodes(*node);
3482 }
3483
3484 /**
3485 * @tc.name: SetNodeCacheChangeStatus
3486 * @tc.desc: Test RSUniRenderVisitorTest.SetNodeCacheChangeStatus
3487 * node doesn't have Child
3488 * @tc.type: FUNC
3489 * @tc.require: issueI7UGLR
3490 */
3491 HWTEST_F(RSUniRenderVisitorTest, SetNodeCacheChangeStatus, TestSize.Level2)
3492 {
3493 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3494 ASSERT_NE(rsUniRenderVisitor, nullptr);
3495 NodeId id = 1;
3496 auto parent = std::make_shared<RSSurfaceRenderNode>(id);
3497 auto child = std::make_shared<RSSurfaceRenderNode>(++id);
3498 parent->AddChild(child);
3499 child->SetChildHasFilter(true);
3500 rsUniRenderVisitor->isDrawingCacheEnabled_ = true;
3501 child->SetDrawingCacheType(RSDrawingCacheType::TARGETED_CACHE);
3502 rsUniRenderVisitor->curCacheFilterRects_.push({});
3503 rsUniRenderVisitor->SetNodeCacheChangeStatus(*child);
3504 }
3505
3506 /**
3507 * @tc.name: ClearTransparentBeforeSaveLayerTest002
3508 * @tc.desc: Test RSUniRenderVisitorTest.ClearTransparentBeforeSaveLayerTest002
3509 * @tc.type: FUNC
3510 * @tc.require: issueI7UGLR
3511 */
3512 HWTEST_F(RSUniRenderVisitorTest, ClearTransparentBeforeSaveLayerTest002, TestSize.Level2)
3513 {
3514 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3515 ASSERT_NE(rsUniRenderVisitor, nullptr);
3516 rsUniRenderVisitor->isHardwareForcedDisabled_ = false;
3517 NodeId id = 1;
3518 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3519 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(node);
3520 rsUniRenderVisitor->ClearTransparentBeforeSaveLayer();
3521 }
3522
3523 /**
3524 * @tc.name: CheckIfUIFirstSurfaceContentReusable001
3525 * @tc.desc: Test CheckIfUIFirstSurfaceContentReusable001, nullptr
3526 * @tc.type: FUNC
3527 * @tc.require: issueI7UGLR
3528 */
3529 HWTEST_F(RSUniRenderVisitorTest, CheckIfUIFirstSurfaceContentReusable001, TestSize.Level2)
3530 {
3531 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3532 ASSERT_NE(rsUniRenderVisitor, nullptr);
3533 bool assigned = false;
3534 std::shared_ptr<RSSurfaceRenderNode> node = nullptr;
3535 rsUniRenderVisitor->CheckIfUIFirstSurfaceContentReusable(node, assigned);
3536 }
3537
3538 /**
3539 * @tc.name: CheckIfUIFirstSurfaceContentReusable002
3540 * @tc.desc: Test CheckIfUIFirstSurfaceContentReusable002, without UIFirst
3541 * @tc.type: FUNC
3542 * @tc.require: issueI7UGLR
3543 */
3544 HWTEST_F(RSUniRenderVisitorTest, CheckIfUIFirstSurfaceContentReusable002, TestSize.Level2)
3545 {
3546 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3547 ASSERT_NE(rsUniRenderVisitor, nullptr);
3548 rsUniRenderVisitor->isUIFirst_ = false;
3549 bool assigned = false;
3550 NodeId id = 1;
3551 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3552 rsUniRenderVisitor->CheckIfUIFirstSurfaceContentReusable(node, assigned);
3553 }
3554
3555 /**
3556 * @tc.name: PrepareTypesOfSurfaceRenderNodeAfterUpdate001
3557 * @tc.desc: Test PrepareTypesOfSurfaceRenderNodeAfterUpdate001
3558 * @tc.type: FUNC
3559 * @tc.require: issueI7UGLR
3560 */
3561 HWTEST_F(RSUniRenderVisitorTest, PrepareTypesOfSurfaceRenderNodeAfterUpdate001, TestSize.Level2)
3562 {
3563 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3564 ASSERT_NE(rsUniRenderVisitor, nullptr);
3565 NodeId id = 1;
3566 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3567 rsUniRenderVisitor->PrepareTypesOfSurfaceRenderNodeAfterUpdate(*node);
3568 }
3569
3570 /**
3571 * @tc.name: PrepareTypesOfSurfaceRenderNodeAfterUpdate002
3572 * @tc.desc: Test PrepareTypesOfSurfaceRenderNodeAfterUpdate002, with non empty parent
3573 * @tc.type: FUNC
3574 * @tc.require: issueI7UGLR
3575 */
3576 HWTEST_F(RSUniRenderVisitorTest, PrepareTypesOfSurfaceRenderNodeAfterUpdate002, TestSize.Level2)
3577 {
3578 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3579 ASSERT_NE(rsUniRenderVisitor, nullptr);
3580 NodeId id = 1;
3581 auto parent = std::make_shared<RSSurfaceRenderNode>(id);
3582 auto child = std::make_shared<RSSurfaceRenderNode>(id+1);
3583 parent->AddChild(child);
3584 child->GetMutableRenderProperties().needFilter_ = true;
3585 rsUniRenderVisitor->PrepareTypesOfSurfaceRenderNodeAfterUpdate(*child);
3586 }
3587
3588 /**
3589 * @tc.name: DrawTargetSurfaceVisibleRegionForDFX002
3590 * @tc.desc: Test DrawTargetSurfaceVisibleRegionForDFX, with non empty curAllSurfaces_
3591 * @tc.type: FUNC
3592 * @tc.require: issueI7UGLR
3593 */
3594 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceVisibleRegionForDFX002, TestSize.Level2)
3595 {
3596 RSDisplayNodeConfig config;
3597 auto rsContext = std::make_shared<RSContext>();
3598 NodeId id = 1;
3599 auto node = std::make_shared<RSDisplayRenderNode>(id, config, rsContext->weak_from_this());
3600 // prepare curAllsurfaces_
3601 node->curAllSurfaces_.push_back(nullptr);
3602 auto node2 = RSTestUtil::CreateSurfaceNode();
3603 node->curAllSurfaces_.push_back(node2);
3604 auto node3 = RSTestUtil::CreateSurfaceNode();
3605 node3->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
3606 node->curAllSurfaces_.push_back(node3);
3607 // run
3608 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3609 ASSERT_NE(rsUniRenderVisitor, nullptr);
3610 rsUniRenderVisitor->DrawTargetSurfaceVisibleRegionForDFX(*node);
3611 }
3612
3613 /**
3614 * @tc.name: IsNotDirtyHardwareEnabledTopSurface
3615 * @tc.desc: Test IsNotDirtyHardwareEnabledTopSurface, SELF_DRAWING_WINDOW_NODE
3616 * @tc.type: FUNC
3617 * @tc.require: issueI7UGLR
3618 */
3619 HWTEST_F(RSUniRenderVisitorTest, IsNotDirtyHardwareEnabledTopSurface, TestSize.Level2)
3620 {
3621 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3622 ASSERT_NE(rsUniRenderVisitor, nullptr);
3623 auto node = RSTestUtil::CreateSurfaceNode();
3624 node->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
3625 node->name_ = "pointer window";
3626 // run
3627 rsUniRenderVisitor->IsNotDirtyHardwareEnabledTopSurface(node);
3628 }
3629
3630 /**
3631 * @tc.name: CalcChildFilterNodeDirtyRegion001
3632 * @tc.desc: Test CalcChildFilterNodeDirtyRegion, with two nullptr
3633 * @tc.type: FUNC
3634 * @tc.require: issueI7UGLR
3635 */
3636 HWTEST_F(RSUniRenderVisitorTest, CalcChildFilterNodeDirtyRegion001, TestSize.Level2)
3637 {
3638 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3639 ASSERT_NE(rsUniRenderVisitor, nullptr);
3640 std::shared_ptr<RSSurfaceRenderNode> node1 = nullptr;
3641 std::shared_ptr<RSDisplayRenderNode> node2 = nullptr;
3642 rsUniRenderVisitor->CalcChildFilterNodeDirtyRegion(node1, node2);
3643 }
3644
3645 /**
3646 * @tc.name: CalcChildFilterNodeDirtyRegion002
3647 * @tc.desc: Test CalcChildFilterNodeDirtyRegion, with two nullptr
3648 * @tc.type: FUNC
3649 * @tc.require: issueI7UGLR
3650 */
3651 HWTEST_F(RSUniRenderVisitorTest, CalcChildFilterNodeDirtyRegion002, TestSize.Level2)
3652 {
3653 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3654 ASSERT_NE(rsUniRenderVisitor, nullptr);
3655 RSSurfaceRenderNodeConfig surfaceConfig;
3656 RSDisplayNodeConfig displayConfig;
3657 surfaceConfig.id = 1;
3658 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
3659 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
3660 RectI rect{0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT};
3661 surfaceNode->childrenFilterRects_.push_back(rect);
3662 NodeId id = 2;
3663 auto childNode = std::make_shared<RSRenderNode>(id);
3664 surfaceNode->AddChild(childNode);
3665 auto displayNode = std::make_shared<RSDisplayRenderNode>(++id, displayConfig);
3666 rsUniRenderVisitor->CalcChildFilterNodeDirtyRegion(surfaceNode, displayNode);
3667 }
3668
3669 /**
3670 * @tc.name: CalcSurfaceFilterNodeDirtyRegion001
3671 * @tc.desc: Test CalcChildFilterNodeDirtyRegion001, with nullptr
3672 * @tc.type: FUNC
3673 * @tc.require: issueI7UGLR
3674 */
3675 HWTEST_F(RSUniRenderVisitorTest, CalcSurfaceFilterNodeDirtyRegion001, TestSize.Level2)
3676 {
3677 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3678 ASSERT_NE(rsUniRenderVisitor, nullptr);
3679 std::shared_ptr<RSSurfaceRenderNode> node1 = nullptr;
3680 std::shared_ptr<RSDisplayRenderNode> node2 = nullptr;
3681 rsUniRenderVisitor->CalcSurfaceFilterNodeDirtyRegion(node1, node2);
3682 }
3683
3684 /**
3685 * @tc.name: CalcSurfaceFilterNodeDirtyRegion002
3686 * @tc.desc: Test CalcChildFilterNodeDirtyRegion002
3687 * @tc.type: FUNC
3688 * @tc.require: issueI7UGLR
3689 */
3690 HWTEST_F(RSUniRenderVisitorTest, CalcSurfaceFilterNodeDirtyRegion002, TestSize.Level2)
3691 {
3692 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3693 ASSERT_NE(rsUniRenderVisitor, nullptr);
3694 RSSurfaceRenderNodeConfig surfaceConfig;
3695 RSDisplayNodeConfig displayConfig;
3696 surfaceConfig.id = 1;
3697 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
3698 surfaceNode->GetMutableRenderProperties().needFilter_ = true;
3699 NodeId id = 2;
3700 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, displayConfig);
3701 rsUniRenderVisitor->CalcSurfaceFilterNodeDirtyRegion(surfaceNode, displayNode);
3702 }
3703 } // OHOS::Rosen
3704