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
18 #include "gtest/gtest.h"
19 #include "limit_number.h"
20 #include "mock/mock_matrix.h"
21 #include "rs_test_util.h"
22 #include "system/rs_system_parameters.h"
23
24 #include "draw/color.h"
25 #include "pipeline/rs_base_render_node.h"
26 #include "pipeline/rs_context.h"
27 #include "pipeline/rs_display_render_node.h"
28 #include "pipeline/rs_effect_render_node.h"
29 #include "pipeline/rs_main_thread.h"
30 #include "pipeline/rs_processor_factory.h"
31 #include "pipeline/rs_proxy_render_node.h"
32 #include "pipeline/rs_render_node.h"
33 #include "pipeline/rs_render_thread.h"
34 #include "pipeline/rs_root_render_node.h"
35 #include "pipeline/rs_surface_render_node.h"
36 #include "pipeline/rs_uni_render_engine.h"
37 #include "pipeline/rs_uni_render_judgement.h"
38 #include "pipeline/rs_uni_render_thread.h"
39 #include "pipeline/rs_uni_render_util.h"
40 #include "pipeline/rs_uni_render_visitor.h"
41
42 using namespace testing;
43 using namespace testing::ext;
44
45 namespace {
46 const std::string DEFAULT_NODE_NAME = "1";
47 const std::string INVALID_NODE_NAME = "2";
48 const int DEFAULT_DIRTY_REGION_WIDTH = 10;
49 const int DEFAULT_DIRTY_REGION_HEIGHT = 10;
50 constexpr uint32_t DEFAULT_CANVAS_WIDTH = 800;
51 constexpr uint32_t DEFAULT_CANVAS_HEIGHT = 600;
52 constexpr uint32_t RECT_DEFAULT_SIZE = 100;
53 constexpr int ROTATION_90 = 90;
54 const OHOS::Rosen::RectI DEFAULT_RECT = {0, 80, 1000, 1000};
55 const OHOS::Rosen::RectI DEFAULT_FILTER_RECT = {0, 0, 500, 500};
56 const std::string CAPTURE_WINDOW_NAME = "CapsuleWindow";
57 constexpr int MAX_ALPHA = 255;
58 constexpr OHOS::Rosen::NodeId DEFAULT_NODE_ID = 100;
59 }
60
61 namespace OHOS::Rosen {
62 class RSUniRenderVisitorTest : public testing::Test {
63 public:
64 static void SetUpTestCase();
65 static void TearDownTestCase();
66 void SetUp() override;
67 void TearDown() override;
68
69 static inline Mock::MatrixMock* matrixMock_;
70 };
71
SetUpTestCase()72 void RSUniRenderVisitorTest::SetUpTestCase()
73 {
74 matrixMock_ = Mock::MatrixMock::GetInstance();
75 EXPECT_CALL(*matrixMock_, GetMinMaxScales(_)).WillOnce(testing::Return(false));
76 RSTestUtil::InitRenderNodeGC();
77 }
TearDownTestCase()78 void RSUniRenderVisitorTest::TearDownTestCase() {}
SetUp()79 void RSUniRenderVisitorTest::SetUp()
80 {
81 if (RSUniRenderJudgement::IsUniRender()) {
82 auto& uniRenderThread = RSUniRenderThread::Instance();
83 uniRenderThread.uniRenderEngine_ = std::make_shared<RSUniRenderEngine>();
84 }
85 }
TearDown()86 void RSUniRenderVisitorTest::TearDown()
87 {
88 system::SetParameter("rosen.dirtyregiondebug.enabled", "0");
89 system::SetParameter("rosen.uni.partialrender.enabled", "4");
90 system::GetParameter("rosen.dirtyregiondebug.surfacenames", "0");
91 }
92
93 /*
94 * @tc.name: UpdateSurfaceRenderNodeScaleTest
95 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSurfaceRenderNodeScaleTest
96 * @tc.type: FUNC
97 * @tc.require: issueI79U8E
98 */
99 HWTEST_F(RSUniRenderVisitorTest, UpdateSurfaceRenderNodeScaleTest, TestSize.Level2)
100 {
101 auto rsContext = std::make_shared<RSContext>();
102 ASSERT_NE(rsContext, nullptr);
103 RSSurfaceRenderNodeConfig config;
104 config.id = 11; // leash window config id
105 config.name = "leashWindowNode";
106 auto leashWindowNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
107 ASSERT_NE(leashWindowNode, nullptr);
108 leashWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
109
110 auto deviceTypeStr = system::GetParameter("const.product.devicetype", "pc");
111 system::SetParameter("const.product.devicetype", "pc");
112 RSMainThread::Instance()->SetDeviceType();
113 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
114 ASSERT_NE(rsUniRenderVisitor, nullptr);
115 rsUniRenderVisitor->UpdateSurfaceRenderNodeScale(*leashWindowNode);
116 system::SetParameter("const.product.devicetype", deviceTypeStr);
117 RSMainThread::Instance()->SetDeviceType();
118 }
119
120 /*
121 * @tc.name: CheckLuminanceStatusChangeTest
122 * @tc.desc: Test RSUniRenderVisitorTest.CheckLuminanceStatusChangeTest
123 * @tc.type: FUNC
124 * @tc.require: issueI79U8E
125 */
126 HWTEST_F(RSUniRenderVisitorTest, CheckLuminanceStatusChangeTest, TestSize.Level2)
127 {
128 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
129 ASSERT_NE(rsUniRenderVisitor, nullptr);
130 RSMainThread::Instance()->SetLuminanceChangingStatus(true);
131 ASSERT_EQ(rsUniRenderVisitor->CheckLuminanceStatusChange(), true);
132 RSMainThread::Instance()->SetLuminanceChangingStatus(false);
133 ASSERT_EQ(rsUniRenderVisitor->CheckLuminanceStatusChange(), false);
134 }
135
136 /*
137 * @tc.name: PrepareCanvasRenderNodeTest
138 * @tc.desc: Test RSUniRenderVisitorTest.PrepareCanvasRenderNodeTest
139 * @tc.type: FUNC
140 * @tc.require: issueI79U8E
141 */
142 HWTEST_F(RSUniRenderVisitorTest, PrepareCanvasRenderNodeTest, TestSize.Level2)
143 {
144 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
145 ASSERT_NE(rsUniRenderVisitor, nullptr);
146 auto rsContext = std::make_shared<RSContext>();
147 ASSERT_NE(rsContext, nullptr);
148 auto rsCanvasRenderNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
149 ASSERT_NE(rsCanvasRenderNode, nullptr);
150 rsCanvasRenderNode->stagingRenderParams_ = std::make_unique<RSRenderParams>(rsCanvasRenderNode->GetId());
151
152 RSSurfaceRenderNodeConfig config;
153 config.id = 10;
154 config.name = "scbScreenNode";
155 auto scbScreenNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
156 ASSERT_NE(scbScreenNode, nullptr);
157 scbScreenNode->SetSurfaceNodeType(RSSurfaceNodeType::SCB_SCREEN_NODE);
158 scbScreenNode->stagingRenderParams_ = std::make_unique<RSRenderParams>(scbScreenNode->GetId());
159
160 config.id = 11;
161 config.name = "leashWindowNode";
162 auto leashWindowNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
163 ASSERT_NE(leashWindowNode, nullptr);
164 leashWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
165 leashWindowNode->stagingRenderParams_ = std::make_unique<RSRenderParams>(leashWindowNode->GetId());
166
167 rsCanvasRenderNode->SetParent(std::weak_ptr<RSSurfaceRenderNode>(leashWindowNode));
168 rsUniRenderVisitor->PrepareCanvasRenderNode(*rsCanvasRenderNode);
169
170 rsCanvasRenderNode->SetParent(std::weak_ptr<RSSurfaceRenderNode>(scbScreenNode));
171 RSDisplayNodeConfig displayConfig;
172 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
173 rsUniRenderVisitor->curDisplayDirtyManager_ = rsDisplayRenderNode->GetDirtyManager();
174 rsUniRenderVisitor->currentVisitDisplay_ = 0;
175 rsUniRenderVisitor->PrepareCanvasRenderNode(*rsCanvasRenderNode);
176 }
177
178 /*
179 * @tc.name: DrawCacheRegionForDFX001
180 * @tc.desc: Test RSUniRenderVisitorTest.DrawCacheRegionForDFX001
181 * @tc.type: FUNC
182 * @tc.require: issueI79U8E
183 */
184 HWTEST_F(RSUniRenderVisitorTest, DrawCacheRegionForDFX001, TestSize.Level2)
185 {
186 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
187 ASSERT_NE(rsUniRenderVisitor, nullptr);
188 RectI rect(0, 0, 0, 0);
189 std::map<NodeId, RectI> dirtyRects;
190 dirtyRects[0] = rect;
191 rsUniRenderVisitor->DrawCacheRegionForDFX(dirtyRects);
192 }
193
194 /*
195 * @tc.name: DrawEffectRenderNodeForDFX003
196 * @tc.desc: Test RSUniRenderVisitorTest.DrawEffectRenderNodeForDFX003
197 * @tc.type: FUNC
198 * @tc.require: issueI79U8E
199 */
200 HWTEST_F(RSUniRenderVisitorTest, DrawEffectRenderNodeForDFX003, TestSize.Level2)
201 {
202 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
203 ASSERT_NE(rsUniRenderVisitor, nullptr);
204 RectI rect(0, 0, 0, 0);
205 std::vector<RectI> nodesUseEffectFallbackForDfx;
206 nodesUseEffectFallbackForDfx.push_back(rect);
207 std::vector<RectI> nodesUseEffectForDfx;
208 nodesUseEffectForDfx.push_back(rect);
209 NodeId id = 0;
210 std::weak_ptr<RSContext> context;
211 std::shared_ptr<RSEffectRenderNode> node = std::make_shared<RSEffectRenderNode>(id, context);
212 ASSERT_NE(node, nullptr);
213 rsUniRenderVisitor->effectNodeMapForDfx_[node->GetId()].first = nodesUseEffectForDfx;
214 rsUniRenderVisitor->effectNodeMapForDfx_[node->GetId()].second = nodesUseEffectFallbackForDfx;
215 RSMainThread::Instance()->GetContext().GetMutableNodeMap().RegisterRenderNode(node);
216 rsUniRenderVisitor->DrawEffectRenderNodeForDFX();
217 }
218
219 /*
220 * @tc.name: PrepareChildren001
221 * @tc.desc: PrepareChildren Test
222 * @tc.type: FUNC
223 * @tc.require: issueI79U8E
224 */
225 HWTEST_F(RSUniRenderVisitorTest, PrepareChildren001, TestSize.Level1)
226 {
227 auto rsContext = std::make_shared<RSContext>();
228 auto rsBaseRenderNode = std::make_shared<RSBaseRenderNode>(10, rsContext->weak_from_this());
229 rsBaseRenderNode->InitRenderParams();
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 rsSurfaceRenderNode->InitRenderParams();
264 rsDisplayRenderNode->InitRenderParams();
265 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
266 rsSurfaceRenderNode->SetSrcRect(RectI(0, 0, 10, 10));
267 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
268 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
269 sptr<RSScreenManager> screenManager = CreateOrGetScreenManager();
270 ASSERT_NE(screenManager, nullptr);
271 rsDisplayRenderNode->SetScreenId(0);
272 auto rsScreen = std::make_unique<impl::RSScreen>(0, false, HdiOutput::CreateHdiOutput(0), nullptr);
273 screenManager->MockHdiScreenConnected(rsScreen);
274 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
275 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
276 system::SetParameter("rosen.uni.opaqueregiondebug", "0");
277 }
278
279 /*
280 * @tc.name: DrawTargetSurfaceDirtyRegionForDFX001
281 * @tc.desc: DrawTargetSurfaceDirtyRegionForDFX Test
282 * @tc.type: FUNC
283 * @tc.require: issueI79U8E
284 */
285 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceDirtyRegionForDFX001, TestSize.Level1)
286 {
287 auto rsContext = std::make_shared<RSContext>();
288 RSSurfaceRenderNodeConfig config;
289 RSDisplayNodeConfig displayConfig;
290 config.name = "SurfaceDirtyDFX";
291 config.id = 10;
292 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
293 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
294 rsSurfaceRenderNode->InitRenderParams();
295 rsDisplayRenderNode->InitRenderParams();
296 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
297 rsSurfaceRenderNode->SetSrcRect(RectI(0, 0, 10, 10));
298 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
299 sptr<RSScreenManager> screenManager = CreateOrGetScreenManager();
300 ASSERT_NE(screenManager, nullptr);
301 rsDisplayRenderNode->SetScreenId(0);
302 auto rsScreen = std::make_unique<impl::RSScreen>(0, false, HdiOutput::CreateHdiOutput(0), nullptr);
303 screenManager->MockHdiScreenConnected(rsScreen);
304 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
305 system::SetParameter("rosen.dirtyregiondebug.surfacenames", "SurfaceDirtyDFX");
306 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
307 system::SetParameter("rosen.dirtyregiondebug.surfacenames", "0");
308 }
309
310 HWTEST_F(RSUniRenderVisitorTest, PrepareProxyRenderNode001, TestSize.Level1)
311 {
312 RSSurfaceRenderNodeConfig config;
313 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config);
314 std::weak_ptr<RSSurfaceRenderNode> rsSurfaceRenderNodeW(rsSurfaceRenderNode);
315 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
316 auto rsContext = std::make_shared<RSContext>();
317
318 NodeId id = 0;
319 NodeId targetID = 0;
320 std::shared_ptr<RSProxyRenderNode> rsProxyRenderNode(
321 new RSProxyRenderNode(id, rsSurfaceRenderNodeW, targetID, rsContext->weak_from_this()));
322 rsUniRenderVisitor->PrepareProxyRenderNode(*rsProxyRenderNode);
323 rsUniRenderVisitor->ProcessProxyRenderNode(*rsProxyRenderNode);
324
325 config.id = 1;
326 auto rsSurfaceRenderNodeS = std::make_shared<RSSurfaceRenderNode>(config);
327 rsSurfaceRenderNodeS->AddChild(rsProxyRenderNode, 1);
328 rsProxyRenderNode->Prepare(rsUniRenderVisitor);
329 }
330
331 HWTEST_F(RSUniRenderVisitorTest, RSDisplayRenderNode001, TestSize.Level1)
332 {
333 RSDisplayNodeConfig config;
334 auto rsContext = std::make_shared<RSContext>();
335 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(0, config, rsContext->weak_from_this());
336 rsDisplayRenderNode->InitRenderParams();
337 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
338
339 rsDisplayRenderNode->Prepare(rsUniRenderVisitor);
340 rsDisplayRenderNode->Process(rsUniRenderVisitor);
341 }
342
343 /*
344 * @tc.name: CheckQuickSkipPrepareParamSetAndGetValid001
345 * @tc.desc: Check if param set and get apis are valid.
346 * @tc.type: FUNC
347 * @tc.require: I67FKA
348 */
349 HWTEST_F(RSUniRenderVisitorTest, CheckQuickSkipPrepareParamSetAndGetValid001, TestSize.Level1)
350 {
351 int defaultParam = (int)RSSystemParameters::GetQuickSkipPrepareType();
352 (void)system::SetParameter("rosen.quickskipprepare.enabled", "0");
353 int param = (int)RSSystemParameters::GetQuickSkipPrepareType();
354 ASSERT_EQ(param, 0);
355 (void)system::SetParameter("rosen.quickskipprepare.enabled", "1");
356 param = (int)RSSystemParameters::GetQuickSkipPrepareType();
357 ASSERT_EQ(param, 1);
358
359 NodeId testId = 10;
360 pid_t pid = ExtractPid(testId);
361 ASSERT_EQ(pid, 0);
362 const int paddingDigit = 32;
363 NodeId testPid = testId << paddingDigit;
364 pid = ExtractPid(testPid);
365 ASSERT_EQ(pid, testId);
366 (void)system::SetParameter("rosen.quickskipprepare.enabled", std::to_string(defaultParam));
367 }
368
369 /*
370 * @tc.name: CheckSurfaceRenderNodeNotStatic001
371 * @tc.desc: Generate not static surface render node(self drawing, leash window) and execute preparation step.
372 * Get trace and check corresponding node's preparation exists and no 'Skip' info.
373 * @tc.type: FUNC
374 * @tc.require: I67FKA
375 */
376 HWTEST_F(RSUniRenderVisitorTest, CheckSurfaceRenderNodeNotStatic001, TestSize.Level1)
377 {
378 int defaultParam = (int)RSSystemParameters::GetQuickSkipPrepareType();
379 (void)system::SetParameter("rosen.quickskipprepare.enabled", "1");
380
381 auto rsContext = std::make_shared<RSContext>();
382 RSSurfaceRenderNodeConfig config;
383 config.id = 10;
384 config.name = "selfDrawTestNode";
385 auto selfDrawSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
386 selfDrawSurfaceRenderNode->SetSurfaceNodeType(RSSurfaceNodeType::SELF_DRAWING_NODE);
387 selfDrawSurfaceRenderNode->InitRenderParams();
388 config.id = 11;
389 config.name = "leashWindowTestNode";
390 auto leashWindowNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
391 leashWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
392 leashWindowNode->InitRenderParams();
393
394 RSDisplayNodeConfig displayConfig;
395 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(12, displayConfig, rsContext->weak_from_this());
396 rsDisplayRenderNode->InitRenderParams();
397 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
398 rsDisplayRenderNode->AddChild(selfDrawSurfaceRenderNode, -1);
399 rsDisplayRenderNode->AddChild(leashWindowNode, -1);
400 // execute add child
401 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
402 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
403 // test if skip testNode
404 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
405 (void)system::SetParameter("rosen.quickskipprepare.enabled", std::to_string(defaultParam));
406 }
407
408 /*
409 * @tc.name: CheckSurfaceRenderNodeStatic001
410 * @tc.desc: Generate static surface render node(app window node) and execute preparation step.
411 * Get trace and check corresponding node's preparation and 'Skip' info exist.
412 * @tc.type: FUNC
413 * @tc.require: I67FKA
414 */
415 HWTEST_F(RSUniRenderVisitorTest, CheckSurfaceRenderNodeStatic001, TestSize.Level1)
416 {
417 int defaultParam = (int)RSSystemParameters::GetQuickSkipPrepareType();
418 (void)system::SetParameter("rosen.quickskipprepare.enabled", "1");
419
420 auto rsContext = std::make_shared<RSContext>();
421 RSSurfaceRenderNodeConfig config;
422 config.id = 10;
423 config.name = "appWindowTestNode";
424 auto defaultSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
425 defaultSurfaceRenderNode->InitRenderParams();
426 defaultSurfaceRenderNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
427
428 RSDisplayNodeConfig displayConfig;
429 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
430 rsDisplayRenderNode->InitRenderParams();
431 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
432 rsDisplayRenderNode->AddChild(defaultSurfaceRenderNode, -1);
433 // execute add child
434 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
435 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
436 // test if skip testNode
437 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
438 (void)system::SetParameter("rosen.quickskipprepare.enabled", std::to_string(defaultParam));
439 }
440
441 HWTEST_F(RSUniRenderVisitorTest, ProcessRootRenderNode001, TestSize.Level1)
442 {
443 auto rsContext = std::make_shared<RSContext>();
444 auto rsRootRenderNode = std::make_shared<RSRootRenderNode>(0, rsContext->weak_from_this());
445 rsRootRenderNode->InitRenderParams();
446 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
447 rsUniRenderVisitor->curSurfaceNode_ = RSTestUtil::CreateSurfaceNode();
448 rsUniRenderVisitor->PrepareRootRenderNode(*rsRootRenderNode);
449 rsUniRenderVisitor->ProcessRootRenderNode(*rsRootRenderNode);
450
451 auto& property = rsRootRenderNode->GetMutableRenderProperties();
452 property.SetVisible(false);
453 rsUniRenderVisitor->PrepareRootRenderNode(*rsRootRenderNode);
454
455 rsUniRenderVisitor->dirtyFlag_ = true;
456 rsUniRenderVisitor->ProcessRootRenderNode(*rsRootRenderNode);
457 }
458
459 /*
460 * @tc.name: CalcDirtyDisplayRegion
461 * @tc.desc: Set surface to transparent, add a canvas node to create a transparent dirty region
462 * @tc.type: FUNC
463 * @tc.require: I68IPR
464 */
465 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion, TestSize.Level1)
466 {
467 auto rsContext = std::make_shared<RSContext>();
468 RSSurfaceRenderNodeConfig config;
469 RSDisplayNodeConfig displayConfig;
470 config.id = 10;
471 auto rsCanvasRenderNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
472 rsCanvasRenderNode->InitRenderParams();
473 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
474 rsSurfaceRenderNode->InitRenderParams();
475 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
476 rsDisplayRenderNode->InitRenderParams();
477 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
478
479 Occlusion::Rect rect{0, 80, 2560, 1600};
480 Occlusion::Region region{rect};
481 VisibleData vData;
482 std::map<NodeId, RSVisibleLevel> pidVisMap;
483
484 auto partialRenderType = RSSystemProperties::GetUniPartialRenderEnabled();
485 auto isPartialRenderEnabled = (partialRenderType != PartialRenderType::DISABLED);
486 ASSERT_EQ(isPartialRenderEnabled, true);
487
488 // set surface to transparent, add a canvas node to create a transparent dirty region
489 rsSurfaceRenderNode->SetAbilityBGAlpha(0);
490 rsSurfaceRenderNode->SetSrcRect(RectI(0, 80, 2560, 1600));
491 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
492 rsSurfaceRenderNode->AddChild(rsCanvasRenderNode, -1);
493
494 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
495 rsSurfaceRenderNode->SetVisibleRegionRecursive(region, vData, pidVisMap);
496 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
497 }
498
499 /*
500 * @tc.name: CalcDirtyRegionForFilterNode
501 * @tc.desc: Create a filter effect to test filter node
502 * @tc.type: FUNC
503 * @tc.require: I68IPR
504 */
505 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode, TestSize.Level1)
506 {
507 auto rsContext = std::make_shared<RSContext>();
508 RSSurfaceRenderNodeConfig config;
509 RSDisplayNodeConfig displayConfig;
510 config.id = 10;
511 auto rsCanvasRenderNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
512 rsCanvasRenderNode->InitRenderParams();
513 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
514 rsSurfaceRenderNode->InitRenderParams();
515 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
516 rsDisplayRenderNode->InitRenderParams();
517 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
518
519 rsSurfaceRenderNode->SetAbilityBGAlpha(0);
520 rsSurfaceRenderNode->SetSrcRect(RectI(0, 80, 2560, 1600));
521 // create a filter effect
522 float blurRadiusX = 30.0f;
523 float blurRadiusY = 30.0f;
524 auto filter = RSFilter::CreateBlurFilter(blurRadiusX, blurRadiusY);
525 rsCanvasRenderNode->GetMutableRenderProperties().SetFilter(filter);
526 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
527 rsSurfaceRenderNode->AddChild(rsCanvasRenderNode, -1);
528 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
529 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
530 }
531
532 /*
533 * @tc.name: SetSurfafaceGlobalDirtyRegion
534 * @tc.desc: Add two surfacenode child to test global dirty region
535 * @tc.type: FUNC
536 * @tc.require: I68IPR
537 */
538 HWTEST_F(RSUniRenderVisitorTest, SetSurfafaceGlobalDirtyRegion, TestSize.Level1)
539 {
540 auto rsContext = std::make_shared<RSContext>();
541 RSSurfaceRenderNodeConfig config;
542 config.id = 10;
543 auto rsSurfaceRenderNode1 = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
544 rsSurfaceRenderNode1->InitRenderParams();
545 Occlusion::Rect rect{0, 80, 2560, 1600};
546 Occlusion::Region region{rect};
547 VisibleData vData;
548 std::map<NodeId, RSVisibleLevel> pidVisMap;
549 rsSurfaceRenderNode1->SetVisibleRegionRecursive(region, vData, pidVisMap);
550
551 config.id = 11;
552 auto rsSurfaceRenderNode2 = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
553 rsSurfaceRenderNode2->InitRenderParams();
554 Occlusion::Rect rect2{100, 100, 500, 1500};
555 Occlusion::Region region2{rect2};
556 rsSurfaceRenderNode2->SetVisibleRegionRecursive(region2, vData, pidVisMap);
557
558 RSDisplayNodeConfig displayConfig;
559 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(9, displayConfig, rsContext->weak_from_this());
560 rsDisplayRenderNode->InitRenderParams();
561 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode1, -1);
562 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode2, -1);
563
564 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
565 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
566 rsUniRenderVisitor->ProcessDisplayRenderNode(*rsDisplayRenderNode);
567 }
568
569 /**
570 * @tc.name: CopyVisitorInfosTest
571 * @tc.desc: Test RSUniRenderVisitorTest.CopyVisitorInfosTest
572 * @tc.type: FUNC
573 * @tc.require: issueI79KM8
574 */
575 HWTEST_F(RSUniRenderVisitorTest, CopyVisitorInfosTest, TestSize.Level1)
576 {
577 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
578 auto newRsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
579 newRsUniRenderVisitor->CopyVisitorInfos(rsUniRenderVisitor);
580 ASSERT_EQ(rsUniRenderVisitor->currentVisitDisplay_, newRsUniRenderVisitor->currentVisitDisplay_);
581 }
582
583 /**
584 * @tc.name: ClearTransparentBeforeSaveLayerTest
585 * @tc.desc: Test RSUniRenderVisitorTest.ClearTransparentBeforeSaveLayerTest
586 * @tc.type: FUNC
587 * @tc.require: issueI79KM8
588 */
589 HWTEST_F(RSUniRenderVisitorTest, ClearTransparentBeforeSaveLayerTest, TestSize.Level1)
590 {
591 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
592 ASSERT_NE(rsUniRenderVisitor, nullptr);
593 rsUniRenderVisitor->isHardwareForcedDisabled_ = true;
594 rsUniRenderVisitor->doAnimate_ = false;
595 rsUniRenderVisitor->ClearTransparentBeforeSaveLayer();
596 ASSERT_EQ(false, rsUniRenderVisitor->IsHardwareComposerEnabled());
597
598 auto rsUniRenderVisitor2 = std::make_shared<RSUniRenderVisitor>();
599 ASSERT_NE(rsUniRenderVisitor2, nullptr);
600 rsUniRenderVisitor2->isHardwareForcedDisabled_ = true;
601 rsUniRenderVisitor2->doAnimate_ = false;
602 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
603 ASSERT_NE(drawingCanvas, nullptr);
604 rsUniRenderVisitor2->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
605 RSSurfaceRenderNodeConfig config;
606 std::vector<std::shared_ptr<RSSurfaceRenderNode>> hardwareEnabledNodes;
607 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(config);
608 ASSERT_NE(node, nullptr);
609 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
610 node->SetDstRect(DstRect);
611 hardwareEnabledNodes.emplace_back(node);
612 std::shared_ptr<RSSurfaceRenderNode> node2 = std::make_shared<RSSurfaceRenderNode>(config);
613 ASSERT_NE(node2, nullptr);
614 hardwareEnabledNodes.emplace_back(node2);
615 std::shared_ptr<RSSurfaceRenderNode> node3 = std::make_shared<RSSurfaceRenderNode>(config);
616 ASSERT_NE(node3, nullptr);
617 node3->shouldPaint_ = false;
618 hardwareEnabledNodes.emplace_back(node3);
619 rsUniRenderVisitor2->SetHardwareEnabledNodes(hardwareEnabledNodes);
620 rsUniRenderVisitor->ClearTransparentBeforeSaveLayer();
621 }
622
623 /**
624 * @tc.name: MarkSubHardwareEnableNodeStateTest001
625 * @tc.desc: Test RSUniRenderVisitorTest.MarkSubHardwareEnableNodeStateTest
626 * @tc.type: FUNC
627 * @tc.require: issueI79KM8
628 */
629 HWTEST_F(RSUniRenderVisitorTest, MarkSubHardwareEnableNodeStateTest001, TestSize.Level1)
630 {
631 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
632 ASSERT_NE(rsUniRenderVisitor, nullptr);
633 auto rsContext = std::make_shared<RSContext>();
634 RSSurfaceRenderNodeConfig config;
635 config.id = 10;
636 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
637 ASSERT_NE(rsSurfaceRenderNode, nullptr);
638 rsSurfaceRenderNode->InitRenderParams();
639 rsSurfaceRenderNode->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
640 rsSurfaceRenderNode->name_ = "";
641 rsUniRenderVisitor->MarkSubHardwareEnableNodeState(*rsSurfaceRenderNode);
642 }
643
644 /**
645 * @tc.name: MarkSubHardwareEnableNodeStateTest002
646 * @tc.desc: Test RSUniRenderVisitorTest.MarkSubHardwareEnableNodeStateTest
647 * @tc.type: FUNC
648 * @tc.require: issueI79KM8
649 */
650 HWTEST_F(RSUniRenderVisitorTest, MarkSubHardwareEnableNodeStateTest002, TestSize.Level1)
651 {
652 RSSurfaceRenderNodeConfig config;
653 config.id = 10;
654 auto rsContext = std::make_shared<RSContext>();
655 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
656 rsSurfaceRenderNode->nodeType_ = RSSurfaceNodeType::ABILITY_COMPONENT_NODE;
657 ASSERT_EQ(true, rsSurfaceRenderNode->IsAbilityComponent());
658
659 auto newRsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
660 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
661 rsUniRenderVisitor->hardwareEnabledNodes_.emplace_back(newRsSurfaceRenderNode);
662 rsUniRenderVisitor->MarkSubHardwareEnableNodeState(*rsSurfaceRenderNode);
663 }
664
665 /**
666 * @tc.name: DrawAllSurfaceOpaqueRegionForDFX002
667 * @tc.desc: Test RSUniRenderVisitorTest.DrawAllSurfaceOpaqueRegionForDFX when nodetype is SELF_DRAWING_NODE
668 * @tc.type: FUNC
669 * @tc.require: issueI79KM8
670 */
671 HWTEST_F(RSUniRenderVisitorTest, DrawAllSurfaceOpaqueRegionForDFX002, TestSize.Level1)
672 {
673 NodeId id = 0;
674 RSDisplayNodeConfig config;
675 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
676 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
677 ASSERT_NE(surfaceNodeMain, nullptr);
678 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
679 node->curAllSurfaces_.push_back(surfaceNodeMain);
680 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
681 ASSERT_NE(surfaceNode, nullptr);
682 surfaceNode->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
683 node->curAllSurfaces_.push_back(surfaceNode);
684 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
685 rsUniRenderVisitor->DrawAllSurfaceOpaqueRegionForDFX(*node);
686 }
687
688 /**
689 * @tc.name: DrawAndTraceSingleDirtyRegionTypeForDFX001
690 * @tc.desc: Test RSUniRenderVisitorTest.DrawAndTraceSingleDirtyRegionTypeForDFX when dirtyType is out of range
691 * @tc.type: FUNC
692 * @tc.require: issueI79KM8
693 */
694 HWTEST_F(RSUniRenderVisitorTest, DrawAndTraceSingleDirtyRegionTypeForDFX001, TestSize.Level1)
695 {
696 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
697 ASSERT_NE(surfaceNodeMain, nullptr);
698 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
699 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
700 ASSERT_NE(dirtyManager, nullptr);
701 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
702 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
703 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
704 rsUniRenderVisitor->DrawAndTraceSingleDirtyRegionTypeForDFX(*surfaceNodeMain, DirtyRegionType::TYPE_AMOUNT, true);
705 }
706
707 /**
708 * @tc.name: DrawAndTraceSingleDirtyRegionTypeForDFX002
709 * @tc.desc: Test RSUniRenderVisitorTest.DrawAndTraceSingleDirtyRegionTypeForDFX when dirtyManager is nullptr
710 * @tc.type: FUNC
711 * @tc.require: issueI79KM8
712 */
713 HWTEST_F(RSUniRenderVisitorTest, DrawAndTraceSingleDirtyRegionTypeForDFX002, TestSize.Level1)
714 {
715 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
716 ASSERT_NE(surfaceNodeMain, nullptr);
717 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
718 surfaceNodeMain->dirtyManager_ = nullptr;
719 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
720 ASSERT_EQ(dirtyManager, nullptr);
721 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
722 rsUniRenderVisitor->DrawAndTraceSingleDirtyRegionTypeForDFX(*surfaceNodeMain,
723 DirtyRegionType::UPDATE_DIRTY_REGION, true);
724 }
725
726 /**
727 * @tc.name: DrawAndTraceSingleDirtyRegionTypeForDFX003
728 * @tc.desc: Test RSUniRenderVisitorTest.DrawAndTraceSingleDirtyRegionTypeForDFX when isDrawn is true
729 * @tc.type: FUNC
730 * @tc.require: issueI79KM8
731 */
732 HWTEST_F(RSUniRenderVisitorTest, DrawAndTraceSingleDirtyRegionTypeForDFX003, TestSize.Level1)
733 {
734 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
735 ASSERT_NE(surfaceNodeMain, nullptr);
736 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
737 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
738 ASSERT_NE(dirtyManager, nullptr);
739 NodeId id = 0;
740 RectI rect(0, 0, 0, 0);
741 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
742 dirtyManager->dirtyCanvasNodeInfo_[DirtyRegionType::UPDATE_DIRTY_REGION].emplace(std::make_pair(id, rect));
743 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
744 dirtyManager->dirtySurfaceNodeInfo_[DirtyRegionType::UPDATE_DIRTY_REGION].emplace(std::make_pair(id, rect));
745 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
746 rsUniRenderVisitor->DrawAndTraceSingleDirtyRegionTypeForDFX(*surfaceNodeMain,
747 DirtyRegionType::UPDATE_DIRTY_REGION, true);
748 }
749
750 /**
751 * @tc.name: DrawAndTraceSingleDirtyRegionTypeForDFX004
752 * @tc.desc: Test RSUniRenderVisitorTest.DrawAndTraceSingleDirtyRegionTypeForDFX when isDrawn is false
753 * @tc.type: FUNC
754 * @tc.require: issueI79KM8
755 */
756 HWTEST_F(RSUniRenderVisitorTest, DrawAndTraceSingleDirtyRegionTypeForDFX004, TestSize.Level1)
757 {
758 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
759 ASSERT_NE(surfaceNodeMain, nullptr);
760 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
761 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
762 ASSERT_NE(dirtyManager, nullptr);
763 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
764 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
765 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
766 rsUniRenderVisitor->DrawAndTraceSingleDirtyRegionTypeForDFX(*surfaceNodeMain,
767 DirtyRegionType::UPDATE_DIRTY_REGION, false);
768 }
769
770 /**
771 * @tc.name: DrawDetailedTypesOfDirtyRegionForDFX001
772 * @tc.desc: Test RSUniRenderVisitorTest.DrawDetailedTypesOfDirtyRegionForDFX
773 * @tc.type: FUNC
774 * @tc.require: issueI79KM8
775 */
776 HWTEST_F(RSUniRenderVisitorTest, DrawDetailedTypesOfDirtyRegionForDFX001, TestSize.Level1)
777 {
778 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
779 ASSERT_NE(surfaceNodeMain, nullptr);
780 auto dirtyManager = surfaceNodeMain->GetDirtyManager();
781 ASSERT_NE(dirtyManager, nullptr);
782 dirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
783 dirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
784 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
785 rsUniRenderVisitor->dirtyRegionDebugType_ = DirtyRegionDebugType::DISABLED;
786 ASSERT_EQ(false, rsUniRenderVisitor->DrawDetailedTypesOfDirtyRegionForDFX(*surfaceNodeMain));
787 rsUniRenderVisitor->dirtyRegionDebugType_ = DirtyRegionDebugType::CUR_DIRTY_DETAIL_ONLY_TRACE;
788 ASSERT_EQ(true, rsUniRenderVisitor->DrawDetailedTypesOfDirtyRegionForDFX(*surfaceNodeMain));
789 rsUniRenderVisitor->dirtyRegionDebugType_ = DirtyRegionDebugType::UPDATE_DIRTY_REGION;
790 ASSERT_EQ(true, rsUniRenderVisitor->DrawDetailedTypesOfDirtyRegionForDFX(*surfaceNodeMain));
791 }
792
793 /**
794 * @tc.name: CalcDirtyRegionForFilterNode001
795 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyRegionForFilterNode when dirtyManager_ of displayNode is nullptr
796 * @tc.type: FUNC
797 * @tc.require: issueI79KM8
798 */
799 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode001, TestSize.Level1)
800 {
801 NodeId id = 0;
802 RSDisplayNodeConfig config;
803 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
804 ASSERT_NE(node, nullptr);
805 node->dirtyManager_ = nullptr;
806 ASSERT_EQ(node->GetDirtyManager(), nullptr);
807 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
808 ASSERT_NE(surfaceNode, nullptr);
809 surfaceNode->dirtyManager_ = nullptr;
810 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
811 RectI rect(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
812 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
813 }
814
815 /**
816 * @tc.name: CalcDirtyRegionForFilterNode002
817 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyRegionForFilterNode when dirtyManager_ of surfaceNode is nullptr
818 * @tc.type: FUNC
819 * @tc.require: issueI79KM8
820 */
821 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode002, TestSize.Level1)
822 {
823 NodeId id = 0;
824 RSDisplayNodeConfig config;
825 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
826 ASSERT_NE(node, nullptr);
827 ASSERT_NE(node->GetDirtyManager(), nullptr);
828 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
829 ASSERT_NE(surfaceNode, nullptr);
830 surfaceNode->dirtyManager_ = nullptr;
831 ASSERT_EQ(surfaceNode->GetDirtyManager(), nullptr);
832 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
833 RectI rect(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
834 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
835 }
836
837 /**
838 * @tc.name: CalcDirtyRegionForFilterNode003
839 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyRegionForFilterNode
840 * @tc.type: FUNC
841 * @tc.require: issueI79KM8
842 */
843 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode003, TestSize.Level1)
844 {
845 NodeId id = 0;
846 RSDisplayNodeConfig config;
847 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
848 ASSERT_NE(node, nullptr);
849 auto dpDirtyManager = node->GetDirtyManager();
850 ASSERT_NE(dpDirtyManager, nullptr);
851 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
852 ASSERT_NE(surfaceNode, nullptr);
853 auto sfDirtyManager = surfaceNode->GetDirtyManager();
854 ASSERT_NE(sfDirtyManager, nullptr);
855 sfDirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
856 sfDirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
857 dpDirtyManager->dirtyRegion_ = RectI(0, 0, 0, 0);
858 sfDirtyManager->dirtyRegion_ = RectI(0, 0, 0, 0);
859 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
860 RectI rect(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
861 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
862 dpDirtyManager->dirtyRegion_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
863 sfDirtyManager->dirtyRegion_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
864 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
865 dpDirtyManager->dirtyRegion_ = RectI(0, 0, 0, 0);
866 std::shared_ptr<RSSurfaceRenderNode> surfaceNodeNull = nullptr;
867 node->curAllSurfaces_.push_back(surfaceNodeNull);
868 auto surfaceNodeNotApp = RSTestUtil::CreateSurfaceNode();
869 ASSERT_NE(surfaceNodeNotApp, nullptr);
870 surfaceNodeNotApp->nodeType_ = RSSurfaceNodeType::ABILITY_COMPONENT_NODE;
871 node->curAllSurfaces_.push_back(surfaceNodeNotApp);
872 auto surfaceNodeAppWithEmptyRegion = RSTestUtil::CreateSurfaceNode();
873 ASSERT_NE(surfaceNodeAppWithEmptyRegion, nullptr);
874 surfaceNodeAppWithEmptyRegion->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
875 ASSERT_NE(surfaceNodeAppWithEmptyRegion->GetDirtyManager(), nullptr);
876 surfaceNodeAppWithEmptyRegion->GetDirtyManager()->dirtyRegion_ = RectI(0, 0, 0, 0);
877 node->curAllSurfaces_.push_back(surfaceNodeAppWithEmptyRegion);
878 auto surfaceNodeApp = RSTestUtil::CreateSurfaceNode();
879 ASSERT_NE(surfaceNodeApp, nullptr);
880 surfaceNodeApp->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
881 ASSERT_NE(surfaceNodeApp->GetDirtyManager(), nullptr);
882 surfaceNodeApp->GetDirtyManager()->dirtyRegion_ =
883 RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
884 node->curAllSurfaces_.push_back(surfaceNodeApp);
885 node->curAllSurfaces_.push_back(surfaceNode);
886 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
887 }
888
889 /**
890 * @tc.name: CalcDirtyRegionForFilterNode004
891 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyRegionForFilterNode
892 * @tc.type: FUNC
893 * @tc.require: issueI79KM8
894 */
895 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyRegionForFilterNode004, 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 auto dpDirtyManager = node->GetDirtyManager();
902 ASSERT_NE(dpDirtyManager, nullptr);
903 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
904 ASSERT_NE(surfaceNode, nullptr);
905 auto sfDirtyManager = surfaceNode->GetDirtyManager();
906 ASSERT_NE(sfDirtyManager, nullptr);
907 sfDirtyManager->dirtyCanvasNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
908 sfDirtyManager->dirtySurfaceNodeInfo_.resize(DirtyRegionType::TYPE_AMOUNT);
909 RectI rect(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
910 sfDirtyManager->dirtyRegion_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
911 dpDirtyManager->dirtyRegion_ = RectI(0, 0, 0, 0);
912 auto surfaceNodeApp = RSTestUtil::CreateSurfaceNode();
913 ASSERT_NE(surfaceNodeApp, nullptr);
914 surfaceNodeApp->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
915 ASSERT_NE(surfaceNodeApp->GetDirtyManager(), nullptr);
916 surfaceNodeApp->GetDirtyManager()->dirtyRegion_ =
917 RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
918 surfaceNodeApp->visibleRegion_ = Occlusion::Region(RectI(0, 0, 0, 0));
919 node->curAllSurfaces_.push_back(surfaceNodeApp);
920
921 auto surfaceNodeAppOutOfRange = RSTestUtil::CreateSurfaceNode();
922 ASSERT_NE(surfaceNodeAppOutOfRange, nullptr);
923 surfaceNodeAppOutOfRange->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
924 ASSERT_NE(surfaceNodeAppOutOfRange->GetDirtyManager(), nullptr);
925 surfaceNodeAppOutOfRange->GetDirtyManager()->dirtyRegion_ = RectI(DEFAULT_DIRTY_REGION_WIDTH,
926 DEFAULT_DIRTY_REGION_HEIGHT, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
927 surfaceNodeAppOutOfRange->visibleRegion_ =
928 Occlusion::Region(RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT));
929 node->curAllSurfaces_.push_back(surfaceNodeAppOutOfRange);
930 auto dRect = surfaceNodeAppOutOfRange->GetDirtyManager()->GetDirtyRegion();
931
932 auto surfaceNodeAppIntersect = RSTestUtil::CreateSurfaceNode();
933 ASSERT_NE(surfaceNodeAppIntersect, nullptr);
934 surfaceNodeAppIntersect->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
935 ASSERT_NE(surfaceNodeAppIntersect->GetDirtyManager(), nullptr);
936 surfaceNodeAppIntersect->GetDirtyManager()->dirtyRegion_ =
937 RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
938 surfaceNodeAppIntersect->visibleRegion_ =
939 Occlusion::Region(RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT));
940 node->curAllSurfaces_.push_back(surfaceNodeAppIntersect);
941 dRect = surfaceNodeAppIntersect->GetDirtyManager()->GetDirtyRegion();
942 node->curAllSurfaces_.push_back(surfaceNode);
943 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
944 rsUniRenderVisitor->CalcDirtyRegionForFilterNode(rect, surfaceNode, node);
945 }
946
947 /*
948 * @tc.name: IsWatermarkFlagChanged
949 * @tc.desc: Test RSUniRenderVisitorTest.IsWatermarkFlagChanged test
950 * @tc.type: FUNC
951 * @tc.require: issuesIA8LNR
952 */
953 HWTEST_F(RSUniRenderVisitorTest, IsWatermarkFlagChanged, TestSize.Level1)
954 {
955 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
956 ASSERT_NE(rsUniRenderVisitor, nullptr);
957 rsUniRenderVisitor->IsWatermarkFlagChanged();
958 }
959
960 /**
961 * @tc.name: CalcDirtyFilterRegion001
962 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyFilterRegion when disPlayNode or disPlayNode.dirtyManager_ is null
963 * @tc.type: FUNC
964 * @tc.require: issueI79KM8
965 */
966 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyFilterRegion001, TestSize.Level1)
967 {
968 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
969 NodeId id = 0;
970 RSDisplayNodeConfig config;
971 std::shared_ptr<RSDisplayRenderNode> node = nullptr;
972 rsUniRenderVisitor->CalcDirtyFilterRegion(node);
973 node = std::make_shared<RSDisplayRenderNode>(id, config);
974 ASSERT_NE(node, nullptr);
975 node->dirtyManager_ = nullptr;
976 rsUniRenderVisitor->CalcDirtyFilterRegion(node);
977 }
978
979 /**
980 * @tc.name: CalcDirtyFilterRegion002
981 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyFilterRegion when disPlayNode or disPlayNode.dirtyManager_ is null
982 * @tc.type: FUNC
983 * @tc.require: issueI79KM8
984 */
985 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyFilterRegion002, TestSize.Level1)
986 {
987 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
988 NodeId id = 0;
989 RSDisplayNodeConfig config;
990 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
991 std::shared_ptr<RSSurfaceRenderNode> surfaceNodeNull = nullptr;
992 node->curAllSurfaces_.push_back(surfaceNodeNull);
993 auto surfaceNodeMain = RSTestUtil::CreateSurfaceNode();
994 ASSERT_NE(surfaceNodeMain, nullptr);
995 surfaceNodeMain->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
996 auto surfaceNodeChild = RSTestUtil::CreateSurfaceNode();
997 ASSERT_NE(surfaceNodeChild, nullptr);
998 surfaceNodeChild->oldDirtyInSurface_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
999 surfaceNodeMain->visibleRegion_ =
1000 Occlusion::Region(RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT));
1001 surfaceNodeMain->AddChildHardwareEnabledNode(surfaceNodeChild);
1002 auto surfaceNodeDirtyNull = RSTestUtil::CreateSurfaceNode();
1003 surfaceNodeDirtyNull->dirtyManager_ = nullptr;
1004 surfaceNodeDirtyNull->oldDirtyInSurface_ = RectI(0, 0, DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1005 surfaceNodeMain->AddChildHardwareEnabledNode(surfaceNodeDirtyNull);
1006 auto surfaceNodeChildLastFrame = RSTestUtil::CreateSurfaceNode();
1007 surfaceNodeChildLastFrame->isLastFrameHardwareEnabled_ = true;
1008 surfaceNodeChildLastFrame->oldDirtyInSurface_ = RectI(0, 0,
1009 DEFAULT_DIRTY_REGION_WIDTH, DEFAULT_DIRTY_REGION_HEIGHT);
1010 surfaceNodeMain->AddChildHardwareEnabledNode(surfaceNodeChildLastFrame);
1011 node->curAllSurfaces_.push_back(surfaceNodeMain);
1012 rsUniRenderVisitor->CalcDirtyFilterRegion(node);
1013 }
1014
1015 /**
1016 * @tc.name: ProcessSurfaceRenderNode001
1017 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode when displaynode is null
1018 * @tc.type: FUNC
1019 * @tc.require: issueI79KM8
1020 */
1021 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode001, TestSize.Level1)
1022 {
1023 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1024 ASSERT_NE(rsUniRenderVisitor, nullptr);
1025 rsUniRenderVisitor->isUIFirst_ = true;
1026 rsUniRenderVisitor->isSubThread_ = true;
1027 std::shared_ptr<RSDisplayRenderNode> node = nullptr;
1028
1029 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1030 ASSERT_NE(surfaceNode, nullptr);
1031 surfaceNode->SetParent(node);
1032 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1033 ASSERT_NE(drawingCanvas, nullptr);
1034 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1035 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1036 }
1037
1038 /**
1039 * @tc.name: ProcessSurfaceRenderNode002
1040 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode with isSubThread_ and isUIFirst_
1041 * @tc.type: FUNC
1042 * @tc.require: issueI79KM8
1043 */
1044 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode002, TestSize.Level1)
1045 {
1046 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1047 ASSERT_NE(rsUniRenderVisitor, nullptr);
1048 rsUniRenderVisitor->isUIFirst_ = true;
1049 rsUniRenderVisitor->isSubThread_ = true;
1050 NodeId id = 0;
1051 RSDisplayNodeConfig config;
1052 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1053
1054 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1055 ASSERT_NE(surfaceNode, nullptr);
1056 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1057 ASSERT_NE(drawingCanvas, nullptr);
1058 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1059 surfaceNode->SetParent(node);
1060 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1061 rsUniRenderVisitor->isSubThread_ = false;
1062 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1063 rsUniRenderVisitor->isUIFirst_ = false;
1064 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1065 }
1066
1067 /**
1068 * @tc.name: ProcessSurfaceRenderNode003
1069 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode with skipLayer
1070 * @tc.type: FUNC
1071 * @tc.require: issueI80HL4
1072 */
1073 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode003, TestSize.Level1)
1074 {
1075 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1076 ASSERT_NE(rsUniRenderVisitor, nullptr);
1077 rsUniRenderVisitor->isUIFirst_ = true;
1078 rsUniRenderVisitor->isSubThread_ = true;
1079 NodeId id = 0;
1080 RSDisplayNodeConfig config;
1081 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1082 node->SetSecurityDisplay(true);
1083 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1084 ASSERT_NE(surfaceNode, nullptr);
1085 surfaceNode->SetSkipLayer(true);
1086 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1087 ASSERT_NE(drawingCanvas, nullptr);
1088 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1089 surfaceNode->SetParent(node);
1090 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1091 }
1092
1093 /**
1094 * @tc.name: ProcessSurfaceRenderNode004
1095 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode with securityLayer
1096 * @tc.type: FUNC
1097 * @tc.require: issueI80HL4
1098 */
1099 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode004, TestSize.Level1)
1100 {
1101 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1102 ASSERT_NE(rsUniRenderVisitor, nullptr);
1103 rsUniRenderVisitor->isUIFirst_ = true;
1104 rsUniRenderVisitor->isSubThread_ = true;
1105 NodeId id = 0;
1106 RSDisplayNodeConfig config;
1107 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1108 node->SetSecurityDisplay(true);
1109 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1110 ASSERT_NE(surfaceNode, nullptr);
1111 surfaceNode->SetSecurityLayer(true);
1112 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1113 ASSERT_NE(drawingCanvas, nullptr);
1114 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1115 surfaceNode->SetParent(node);
1116 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1117 }
1118
1119 /**
1120 * @tc.name: ProcessSurfaceRenderNode005
1121 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode with capture window in directly render
1122 * @tc.type: FUNC
1123 * @tc.require: issueI80HL4
1124 */
1125 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode005, TestSize.Level1)
1126 {
1127 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1128 ASSERT_NE(rsUniRenderVisitor, nullptr);
1129 rsUniRenderVisitor->isUIFirst_ = true;
1130 rsUniRenderVisitor->isSubThread_ = true;
1131 NodeId id = 0;
1132 RSDisplayNodeConfig config;
1133 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1134 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1135 ASSERT_NE(surfaceNode, nullptr);
1136 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1137 ASSERT_NE(drawingCanvas, nullptr);
1138 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1139 surfaceNode->SetParent(node);
1140 surfaceNode->name_ = CAPTURE_WINDOW_NAME;
1141 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1142 }
1143
1144 /**
1145 * @tc.name: ProcessSurfaceRenderNode006
1146 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode with capture window in offscreen render
1147 * @tc.type: FUNC
1148 * @tc.require: issueI80HL4
1149 */
1150 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode006, TestSize.Level1)
1151 {
1152 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1153 ASSERT_NE(rsUniRenderVisitor, nullptr);
1154 rsUniRenderVisitor->isUIFirst_ = true;
1155 rsUniRenderVisitor->isSubThread_ = true;
1156 NodeId id = 0;
1157 RSDisplayNodeConfig config;
1158 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1159 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1160 ASSERT_NE(surfaceNode, nullptr);
1161 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1162 ASSERT_NE(drawingCanvas, nullptr);
1163 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1164 surfaceNode->SetParent(node);
1165 surfaceNode->name_ = CAPTURE_WINDOW_NAME;
1166 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1167 }
1168
1169 /**
1170 * @tc.name: ProcessSurfaceRenderNode007
1171 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode while surface node has protected layer
1172 * @tc.type: FUNC
1173 * @tc.require: issueI7ZSC2
1174 */
1175 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode007, TestSize.Level1)
1176 {
1177 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1178 ASSERT_NE(rsUniRenderVisitor, nullptr);
1179
1180 rsUniRenderVisitor->isUIFirst_ = true;
1181 rsUniRenderVisitor->isSubThread_ = true;
1182 NodeId id = 0;
1183 RSDisplayNodeConfig config;
1184 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1185 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1186 ASSERT_NE(surfaceNode, nullptr);
1187
1188 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1189 ASSERT_NE(drawingCanvas, nullptr);
1190 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1191 surfaceNode->SetParent(node);
1192 surfaceNode->SetProtectedLayer(true);
1193 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1194 }
1195
1196 /**
1197 * @tc.name: ProcessSurfaceRenderNode008
1198 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSurfaceRenderNode while surface node does not have protected layer
1199 * @tc.type: FUNC
1200 * @tc.require: issueI7ZSC2
1201 */
1202 HWTEST_F(RSUniRenderVisitorTest, ProcessSurfaceRenderNode008, TestSize.Level1)
1203 {
1204 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1205 ASSERT_NE(rsUniRenderVisitor, nullptr);
1206
1207 rsUniRenderVisitor->isUIFirst_ = true;
1208 rsUniRenderVisitor->isSubThread_ = true;
1209 NodeId id = 0;
1210 RSDisplayNodeConfig config;
1211 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1212 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1213 ASSERT_NE(surfaceNode, nullptr);
1214
1215 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1216 ASSERT_NE(drawingCanvas, nullptr);
1217 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1218 surfaceNode->SetParent(node);
1219 surfaceNode->SetProtectedLayer(false);
1220 rsUniRenderVisitor->ProcessSurfaceRenderNode(*surfaceNode);
1221 }
1222
1223 /**
1224 * @tc.name: GenerateNodeContentCache001
1225 * @tc.desc: Test RSUniRenderVisitorTest.GenerateNodeContentCache when surfaceNode is null
1226 * @tc.type: FUNC
1227 * @tc.require: issueI79KM8
1228 */
1229 HWTEST_F(RSUniRenderVisitorTest, GenerateNodeContentCache001, TestSize.Level1)
1230 {
1231 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1232 ASSERT_NE(rsUniRenderVisitor, nullptr);
1233
1234 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1235 ASSERT_NE(surfaceNode, nullptr);
1236 surfaceNode->drawingCacheType_ = RSDrawingCacheType::DISABLED_CACHE;
1237 ASSERT_EQ(rsUniRenderVisitor->GenerateNodeContentCache(*surfaceNode), false);
1238 }
1239
1240 /**
1241 * @tc.name: GenerateNodeContentCache002
1242 * @tc.desc: Test RSUniRenderVisitorTest.GenerateNodeContentCache with isOnTheTree_
1243 * @tc.type: FUNC
1244 * @tc.require: issueI79KM8
1245 */
1246 HWTEST_F(RSUniRenderVisitorTest, GenerateNodeContentCache002, TestSize.Level1)
1247 {
1248 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1249 ASSERT_NE(rsUniRenderVisitor, nullptr);
1250
1251 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1252 ASSERT_NE(surfaceNode, nullptr);
1253 surfaceNode->isOnTheTree_ = true;
1254 ASSERT_EQ(rsUniRenderVisitor->GenerateNodeContentCache(*surfaceNode), false);
1255
1256 auto surfaceNode2 = RSTestUtil::CreateSurfaceNode();
1257 ASSERT_NE(surfaceNode2, nullptr);
1258 surfaceNode2->isOnTheTree_ = false;
1259 ASSERT_EQ(rsUniRenderVisitor->GenerateNodeContentCache(*surfaceNode2), false);
1260 }
1261
1262 /**
1263 * @tc.name: PrepareEffectRenderNode001
1264 * @tc.desc: Test RSUniRenderVisitorTest.PrepareEffectRenderNode api
1265 * @tc.type: FUNC
1266 * @tc.require: issueI79KM8
1267 */
1268 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectRenderNode001, TestSize.Level1)
1269 {
1270 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1271 ASSERT_NE(rsUniRenderVisitor, nullptr);
1272 NodeId id1 = 1;
1273 RSDisplayNodeConfig displayConfig;
1274 auto rsContext = std::make_shared<RSContext>();
1275 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(id1,
1276 displayConfig, rsContext->weak_from_this());
1277 rsUniRenderVisitor->curDisplayNode_->InitRenderParams();
1278 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
1279 NodeId id2 = 2;
1280 auto node = std::make_shared<RSEffectRenderNode>(id2, rsContext->weak_from_this());
1281 node->InitRenderParams();
1282 rsUniRenderVisitor->PrepareEffectRenderNode(*node);
1283 }
1284
1285 /**
1286 * @tc.name: DrawDirtyRectForDFX001
1287 * @tc.desc: Test RSUniRenderVisitorTest.DrawDirtyRectForDFX api
1288 * @tc.type: FUNC
1289 * @tc.require: issueI79KM8
1290 */
1291 HWTEST_F(RSUniRenderVisitorTest, DrawDirtyRectForDFX001, TestSize.Level1)
1292 {
1293 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1294 ASSERT_NE(rsUniRenderVisitor, nullptr);
1295 RectI rect(0, 0, 0, 0);
1296 Drawing::Color color;
1297 RSUniRenderVisitor::RSPaintStyle fillType = RSUniRenderVisitor::RSPaintStyle::FILL;
1298 rsUniRenderVisitor->DrawDirtyRectForDFX(rect, color, fillType, 0, 0);
1299 }
1300
1301 /**
1302 * @tc.name: DrawDirtyRegionForDFX001
1303 * @tc.desc: Test RSUniRenderVisitorTest.DrawDirtyRegionForDFX api
1304 * @tc.type: FUNC
1305 * @tc.require: issueI79KM8
1306 */
1307 HWTEST_F(RSUniRenderVisitorTest, DrawDirtyRegionForDFX001, TestSize.Level1)
1308 {
1309 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1310 ASSERT_NE(rsUniRenderVisitor, nullptr);
1311 RectI rect(0, 0, 0, 0);
1312 std::vector<RectI> dirtyRects;
1313 dirtyRects.push_back(rect);
1314 rsUniRenderVisitor->DrawDirtyRegionForDFX(dirtyRects);
1315 }
1316
1317 /**
1318 * @tc.name: DrawAllSurfaceDirtyRegionForDFX001
1319 * @tc.desc: Test RSUniRenderVisitorTest.DrawAllSurfaceDirtyRegionForDFX api
1320 * @tc.type: FUNC
1321 * @tc.require: issueI79KM8
1322 */
1323 HWTEST_F(RSUniRenderVisitorTest, DrawAllSurfaceDirtyRegionForDFX001, TestSize.Level1)
1324 {
1325 NodeId id = 0;
1326 RSDisplayNodeConfig config;
1327 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1328 ASSERT_NE(node, nullptr);
1329
1330 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1331 ASSERT_NE(rsUniRenderVisitor, nullptr);
1332 Occlusion::Region region(RectI(0, 0, 0, 0));
1333 rsUniRenderVisitor->DrawAllSurfaceDirtyRegionForDFX(*node, region);
1334 }
1335
1336 /**
1337 * @tc.name: DrawSurfaceOpaqueRegionForDFX001
1338 * @tc.desc: Test RSUniRenderVisitorTest.DrawSurfaceOpaqueRegionForDFX api
1339 * @tc.type: FUNC
1340 * @tc.require: issueI79KM8
1341 */
1342 HWTEST_F(RSUniRenderVisitorTest, DrawSurfaceOpaqueRegionForDFX001, TestSize.Level1)
1343 {
1344 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1345 ASSERT_NE(rsUniRenderVisitor, nullptr);
1346 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1347 ASSERT_NE(surfaceNode, nullptr);
1348 Occlusion::Rect rect{0, 0, 0, 0};
1349 Occlusion::Region region{rect};
1350 surfaceNode->opaqueRegion_ = region;
1351 rsUniRenderVisitor->DrawSurfaceOpaqueRegionForDFX(*surfaceNode);
1352 }
1353
1354 /**
1355 * @tc.name: DrawSpherize001
1356 * @tc.desc: Test RSUniRenderVisitorTest.DrawSpherize api
1357 * @tc.type: FUNC
1358 * @tc.require: issueI79KM8
1359 */
1360 HWTEST_F(RSUniRenderVisitorTest, DrawSpherize001, TestSize.Level1)
1361 {
1362 NodeId id = 0;
1363 RSDisplayNodeConfig config;
1364 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1365 node->InitRenderParams();
1366 ASSERT_NE(node, nullptr);
1367 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1368 ASSERT_NE(drawingCanvas, nullptr);
1369 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1370 ASSERT_NE(rsUniRenderVisitor, nullptr);
1371 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1372 rsUniRenderVisitor->DrawSpherize(*node);
1373 }
1374
1375 /**
1376 * @tc.name: InitNodeCache001
1377 * @tc.desc: Test RSUniRenderVisitorTest.InitNodeCache api
1378 * @tc.type: FUNC
1379 * @tc.require: issueI79KM8
1380 */
1381 HWTEST_F(RSUniRenderVisitorTest, InitNodeCache001, TestSize.Level1)
1382 {
1383 NodeId id = 0;
1384 RSDisplayNodeConfig config;
1385 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1386 node->InitRenderParams();
1387 ASSERT_NE(node, nullptr);
1388
1389 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1390 ASSERT_NE(rsUniRenderVisitor, nullptr);
1391 rsUniRenderVisitor->InitNodeCache(*node);
1392 }
1393
1394 /**
1395 * @tc.name: UpdateCacheRenderNodeMap001
1396 * @tc.desc: Test RSUniRenderVisitorTest.UpdateCacheRenderNodeMap api
1397 * @tc.type: FUNC
1398 * @tc.require: issueI79KM8
1399 */
1400 HWTEST_F(RSUniRenderVisitorTest, UpdateCacheRenderNodeMap001, TestSize.Level1)
1401 {
1402 auto rsContext = std::make_shared<RSContext>();
1403 auto canvasNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
1404 ASSERT_NE(canvasNode, nullptr);
1405 canvasNode->InitRenderParams();
1406
1407 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1408 ASSERT_NE(rsUniRenderVisitor, nullptr);
1409 rsUniRenderVisitor->UpdateCacheRenderNodeMap(*canvasNode);
1410 }
1411
1412 /**
1413 * @tc.name: ProcessEffectRenderNode001
1414 * @tc.desc: Test RSUniRenderVisitorTest.ProcessEffectRenderNode api
1415 * @tc.type: FUNC
1416 * @tc.require: issueI79KM8
1417 */
1418 HWTEST_F(RSUniRenderVisitorTest, ProcessEffectRenderNode001, TestSize.Level1)
1419 {
1420 NodeId id = 0;
1421 RSEffectRenderNode node(id);
1422 node.stagingRenderParams_ = std::make_unique<RSRenderParams>(node.GetId());
1423 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1424 ASSERT_NE(rsUniRenderVisitor, nullptr);
1425 rsUniRenderVisitor->ProcessEffectRenderNode(node);
1426 }
1427
1428 /**
1429 * @tc.name: ClosePartialRenderWhenAnimatingWindows001
1430 * @tc.desc: Test RSUniRenderVisitorTest.ClosePartialRenderWhenAnimatingWindows api
1431 * @tc.type: FUNC
1432 * @tc.require: issueI79KM8
1433 */
1434 HWTEST_F(RSUniRenderVisitorTest, ClosePartialRenderWhenAnimatingWindows001, TestSize.Level1)
1435 {
1436 NodeId id = 0;
1437 RSDisplayNodeConfig config;
1438 auto node = std::make_shared<RSDisplayRenderNode>(id, config);
1439 node->InitRenderParams();
1440 ASSERT_NE(node, nullptr);
1441
1442 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1443 ASSERT_NE(rsUniRenderVisitor, nullptr);
1444 rsUniRenderVisitor->ClosePartialRenderWhenAnimatingWindows(node);
1445 }
1446
1447 /**
1448 * @tc.name: CheckColorSpace001
1449 * @tc.desc: Test RSUniRenderVisitorTest.CheckColorSpace while
1450 * app Window node's color space is not equal to GRAPHIC_COLOR_GAMUT_SRGB
1451 * @tc.type: FUNC
1452 * @tc.require: issueI7O6WO
1453 */
1454 HWTEST_F(RSUniRenderVisitorTest, CheckColorSpace001, TestSize.Level2)
1455 {
1456 auto appWindowNode = RSTestUtil::CreateSurfaceNode();
1457 ASSERT_NE(appWindowNode, nullptr);
1458 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
1459 appWindowNode->SetColorSpace(GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DISPLAY_P3);
1460
1461 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1462 ASSERT_NE(rsUniRenderVisitor, nullptr);
1463 rsUniRenderVisitor->colorGamutModes_.push_back(
1464 static_cast<ScreenColorGamut>(GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DISPLAY_P3));
1465 rsUniRenderVisitor->CheckColorSpace(*appWindowNode);
1466 ASSERT_EQ(rsUniRenderVisitor->newColorSpace_, appWindowNode->GetColorSpace());
1467 }
1468
1469 /**
1470 * @tc.name: DoDirectComposition001
1471 * @tc.desc: Test RSUniRenderVisitorTest.DoDirectComposition while the render visitor is hardware disabled
1472 * @tc.type: FUNC
1473 * @tc.require: issueI7O6WO
1474 */
1475 HWTEST_F(RSUniRenderVisitorTest, DoDirectComposition001, TestSize.Level2)
1476 {
1477 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
1478 const std::shared_ptr<RSBaseRenderNode> rootNode = context->GetGlobalRootRenderNode();
1479 ASSERT_NE(rootNode, nullptr);
1480
1481 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1482 ASSERT_NE(rsUniRenderVisitor, nullptr);
1483 ASSERT_EQ(rsUniRenderVisitor->DoDirectComposition(rootNode), false);
1484 }
1485
1486 /**
1487 * @tc.name: DoDirectComposition002
1488 * @tc.desc: Test RSUniRenderVisitorTest.DoDirectComposition while the root node doesn't have child
1489 * @tc.type: FUNC
1490 * @tc.require: issueI7O6WO
1491 */
1492 HWTEST_F(RSUniRenderVisitorTest, DoDirectComposition002, TestSize.Level2)
1493 {
1494 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
1495 const std::shared_ptr<RSBaseRenderNode> rootNode = context->GetGlobalRootRenderNode();
1496 ASSERT_NE(rootNode, nullptr);
1497
1498 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1499 ASSERT_NE(rsUniRenderVisitor, nullptr);
1500 ASSERT_EQ(rsUniRenderVisitor->DoDirectComposition(rootNode), false);
1501 }
1502
1503 /**
1504 * @tc.name: DoDirectComposition003
1505 * @tc.desc: Test RSUniRenderVisitorTest.DoDirectComposition while the root node has child
1506 * @tc.type: FUNC
1507 * @tc.require: issueI7O6WO
1508 */
1509 HWTEST_F(RSUniRenderVisitorTest, DoDirectComposition003, TestSize.Level2)
1510 {
1511 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
1512 const std::shared_ptr<RSBaseRenderNode> rootNode = context->GetGlobalRootRenderNode();
1513 NodeId id = 1;
1514 RSDisplayNodeConfig config;
1515 auto childDisplayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1516 ASSERT_NE(rootNode, nullptr);
1517 ASSERT_NE(childDisplayNode, nullptr);
1518 rootNode->AddChild(childDisplayNode, 0);
1519 childDisplayNode->SetCompositeType(RSDisplayRenderNode::CompositeType::SOFTWARE_COMPOSITE);
1520
1521 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1522 ASSERT_NE(rsUniRenderVisitor, nullptr);
1523 ASSERT_EQ(rsUniRenderVisitor->DoDirectComposition(rootNode), false);
1524 }
1525
1526 /**
1527 * @tc.name: DoDirectComposition004
1528 * @tc.desc: Test RSUniRenderVisitorTest.DoDirectComposition while
1529 * the display node's composite type is UNI_RENDER_COMPOSITE
1530 * @tc.type: FUNC
1531 * @tc.require: issueI7O6WO
1532 */
1533 HWTEST_F(RSUniRenderVisitorTest, DoDirectComposition004, TestSize.Level2)
1534 {
1535 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
1536 const std::shared_ptr<RSBaseRenderNode> rootNode = context->GetGlobalRootRenderNode();
1537 NodeId id = 1;
1538 RSDisplayNodeConfig config;
1539 auto childDisplayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1540 ASSERT_NE(rootNode, nullptr);
1541 ASSERT_NE(childDisplayNode, nullptr);
1542 rootNode->AddChild(childDisplayNode, 0);
1543 childDisplayNode->SetCompositeType(RSDisplayRenderNode::CompositeType::UNI_RENDER_COMPOSITE);
1544
1545 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1546 ASSERT_NE(rsUniRenderVisitor, nullptr);
1547 ASSERT_EQ(rsUniRenderVisitor->DoDirectComposition(rootNode), false);
1548 }
1549
1550 /**
1551 * @tc.name: AdjustLocalZOrder001
1552 * @tc.desc: Test RSUniRenderVisitorTest.AdjustLocalZOrder for HardwareEnabled node
1553 * @tc.type: FUNC
1554 * @tc.require: issuesI7RNL4
1555 */
1556 HWTEST_F(RSUniRenderVisitorTest, AdjustLocalZOrder001, TestSize.Level2)
1557 {
1558 auto appWindowNode = RSTestUtil::CreateSurfaceNode();
1559 auto ChildHardwareEnabledNode = RSTestUtil::CreateSurfaceNode();
1560 ASSERT_NE(appWindowNode, nullptr);
1561 ASSERT_NE(ChildHardwareEnabledNode, nullptr);
1562 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
1563 appWindowNode->AddChildHardwareEnabledNode(ChildHardwareEnabledNode);
1564
1565 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1566 ASSERT_NE(rsUniRenderVisitor, nullptr);
1567
1568 rsUniRenderVisitor->CollectAppNodeForHwc(appWindowNode);
1569 ASSERT_NE(rsUniRenderVisitor->appWindowNodesInZOrder_.size(), 0);
1570 }
1571
1572 /**
1573 * @tc.name: UpdateHardwareEnableList001
1574 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareEnableList while filterRects is empty
1575 * @tc.type: FUNC
1576 * @tc.require: issuesI7RNL4
1577 */
1578 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareEnableList001, TestSize.Level2)
1579 {
1580 auto firstNode = RSTestUtil::CreateSurfaceNode();
1581 auto secondNode = RSTestUtil::CreateSurfaceNode();
1582 ASSERT_NE(firstNode, nullptr);
1583 ASSERT_NE(secondNode, nullptr);
1584 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1585 firstNode->SetDstRect(DstRect);
1586
1587 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>;
1588 vector<SurfaceDirtyMgrPair> validHwcNodes;
1589 vector<RectI> filterRects;
1590 validHwcNodes.push_back({firstNode, secondNode});
1591
1592 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1593 ASSERT_NE(rsUniRenderVisitor, nullptr);
1594 ASSERT_TRUE(rsUniRenderVisitor->UpdateHardwareEnableList(filterRects, validHwcNodes).IsEmpty());
1595 }
1596
1597 /**
1598 * @tc.name: UpdateHardwareEnableList002
1599 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareEnableList while
1600 * filterRects doesn't intersect with HWC node's rect
1601 * @tc.type: FUNC
1602 * @tc.require: issuesI7RNL4
1603 */
1604 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareEnableList002, TestSize.Level2)
1605 {
1606 auto firstNode = RSTestUtil::CreateSurfaceNode();
1607 auto secondNode = RSTestUtil::CreateSurfaceNode();
1608 ASSERT_NE(firstNode, nullptr);
1609 ASSERT_NE(secondNode, nullptr);
1610 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1611 firstNode->SetDstRect(DstRect);
1612
1613 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>;
1614 vector<SurfaceDirtyMgrPair> validHwcNodes;
1615 vector<RectI> filterRects;
1616 validHwcNodes.push_back({firstNode, secondNode});
1617 RectI filterRect(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1618 filterRects.push_back(filterRect);
1619
1620 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1621 ASSERT_NE(rsUniRenderVisitor, nullptr);
1622 ASSERT_TRUE(rsUniRenderVisitor->UpdateHardwareEnableList(filterRects, validHwcNodes).IsEmpty());
1623 }
1624
1625 /**
1626 * @tc.name: UpdateHardwareEnableList003
1627 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareEnableList while
1628 * filterRects intersects with with HWC node's rect
1629 * @tc.type: FUNC
1630 * @tc.require: issuesI7RNL4
1631 */
1632 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareEnableList003, TestSize.Level2)
1633 {
1634 auto firstNode = RSTestUtil::CreateSurfaceNode();
1635 auto secondNode = RSTestUtil::CreateSurfaceNode();
1636 ASSERT_NE(firstNode, nullptr);
1637 ASSERT_NE(secondNode, nullptr);
1638 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1639 firstNode->SetDstRect(DstRect);
1640
1641 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>;
1642 vector<SurfaceDirtyMgrPair> validHwcNodes;
1643 vector<RectI> filterRects;
1644 validHwcNodes.push_back({firstNode, secondNode});
1645 RectI filterRect = DstRect;
1646 filterRects.push_back(filterRect);
1647
1648 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1649 ASSERT_NE(rsUniRenderVisitor, nullptr);
1650 ASSERT_FALSE(rsUniRenderVisitor->UpdateHardwareEnableList(filterRects, validHwcNodes).IsEmpty());
1651 }
1652
1653 /**
1654 * @tc.name: UpdateHardwareEnableList004
1655 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareEnableList while
1656 * filterRects intersects with LastFrameHardwareEnabled node's rect
1657 * @tc.type: FUNC
1658 * @tc.require: issuesI7RNL4
1659 */
1660 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareEnableList004, TestSize.Level2)
1661 {
1662 auto firstNode = RSTestUtil::CreateSurfaceNode();
1663 auto secondNode = RSTestUtil::CreateSurfaceNode();
1664 ASSERT_NE(firstNode, nullptr);
1665 ASSERT_NE(secondNode, nullptr);
1666 RectI DstRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1667 firstNode->SetDstRect(DstRect);
1668 firstNode->isLastFrameHardwareEnabled_ = true;
1669
1670 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>;
1671 vector<SurfaceDirtyMgrPair> validHwcNodes;
1672 vector<RectI> filterRects;
1673 validHwcNodes.push_back({firstNode, secondNode});
1674 RectI filterRect = DstRect;
1675 filterRects.push_back(filterRect);
1676
1677 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1678 ASSERT_NE(rsUniRenderVisitor, nullptr);
1679 NodeId id = 1;
1680 RSDisplayNodeConfig config;
1681 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(id, config);
1682 rsUniRenderVisitor->UpdateHardwareEnableList(filterRects, validHwcNodes);
1683 }
1684
1685 /**
1686 * @tc.name: AddContainerDirtyToGlobalDirty001
1687 * @tc.desc: Test RSUniRenderVisitorTest.AddContainerDirtyToGlobalDirty while
1688 currentFrameDirtyRegion_ doesn't intersect with containerRegion_
1689 * @tc.type: FUNC
1690 * @tc.require: issuesI7RNL4
1691 */
1692 HWTEST_F(RSUniRenderVisitorTest, AddContainerDirtyToGlobalDirty001, TestSize.Level2)
1693 {
1694 NodeId id = 1;
1695 RSDisplayNodeConfig config;
1696 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1697 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1698 ASSERT_NE(displayNode, nullptr);
1699 ASSERT_NE(surfaceNode, nullptr);
1700 displayNode->InitRenderParams();
1701 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
1702 surfaceNode->containerConfig_.hasContainerWindow_ = true;
1703 Occlusion::Rect rect = Occlusion::Rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1704 surfaceNode->GetContainerRegion().GetBoundRef() = rect;
1705
1706 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1707 ASSERT_NE(rsUniRenderVisitor, nullptr);
1708 rsUniRenderVisitor->AddContainerDirtyToGlobalDirty(displayNode);
1709 ASSERT_TRUE(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty());
1710 }
1711
1712 /**
1713 * @tc.name: AddContainerDirtyToGlobalDirty002
1714 * @tc.desc: Test RSUniRenderVisitorTest.AddContainerDirtyToGlobalDirty while
1715 * currentFrameDirtyRegion_ intersect with containerRegion_
1716 * @tc.type: FUNC
1717 * @tc.require: issuesI7RNL4
1718 */
1719 HWTEST_F(RSUniRenderVisitorTest, AddContainerDirtyToGlobalDirty002, TestSize.Level2)
1720 {
1721 NodeId id = 1;
1722 RSDisplayNodeConfig config;
1723 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1724 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1725 ASSERT_NE(displayNode, nullptr);
1726 ASSERT_NE(surfaceNode, nullptr);
1727 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
1728 surfaceNode->containerConfig_.hasContainerWindow_ = true;
1729 Occlusion::Rect rect = Occlusion::Rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1730 surfaceNode->GetContainerRegion().GetBoundRef() = rect;
1731 surfaceNode->GetContainerRegion().GetRegionRectsRef().push_back(rect);
1732 surfaceNode->GetDirtyManager()->MergeDirtyRect(RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT));
1733
1734 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1735 ASSERT_NE(rsUniRenderVisitor, nullptr);
1736 rsUniRenderVisitor->AddContainerDirtyToGlobalDirty(displayNode);
1737 ASSERT_FALSE(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty());
1738 }
1739
1740 /**
1741 * @tc.name: CheckIfSurfaceRenderNodeNeedProcess001
1742 * @tc.desc: Test RSUniRenderVisitorTest.CheckIfSurfaceRenderNodeNeedProcess for skip layer
1743 * @tc.type: FUNC
1744 * @tc.require: issuesI7RNL4
1745 */
1746 HWTEST_F(RSUniRenderVisitorTest, CheckIfSurfaceRenderNodeNeedProcess001, TestSize.Level2)
1747 {
1748 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1749 ASSERT_NE(surfaceNode, nullptr);
1750 surfaceNode->SetSkipLayer(true);
1751
1752 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1753 ASSERT_NE(rsUniRenderVisitor, nullptr);
1754 rsUniRenderVisitor->isSecurityDisplay_ = true;
1755 bool keepFilterCache = false;
1756 ASSERT_FALSE(rsUniRenderVisitor->CheckIfSurfaceRenderNodeNeedProcess(*surfaceNode, keepFilterCache));
1757 }
1758
1759 /**
1760 * @tc.name: CheckIfSurfaceRenderNodeNeedProcess002
1761 * @tc.desc: Test RSUniRenderVisitorTest.CheckIfSurfaceRenderNodeNeedProcess for empty ability component
1762 * @tc.type: FUNC
1763 * @tc.require: issuesI7RNL4
1764 */
1765 HWTEST_F(RSUniRenderVisitorTest, CheckIfSurfaceRenderNodeNeedProcess002, TestSize.Level2)
1766 {
1767 auto abilityComponentNode = RSTestUtil::CreateSurfaceNode();
1768 ASSERT_NE(abilityComponentNode, nullptr);
1769 abilityComponentNode->GetMutableRenderProperties().SetVisible(true);
1770 abilityComponentNode->SetSurfaceNodeType(RSSurfaceNodeType::ABILITY_COMPONENT_NODE);
1771
1772 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1773 ASSERT_NE(rsUniRenderVisitor, nullptr);
1774 bool keepFilterCache = false;
1775 ASSERT_FALSE(rsUniRenderVisitor->CheckIfSurfaceRenderNodeNeedProcess(*abilityComponentNode, keepFilterCache));
1776 }
1777
1778 /**
1779 * @tc.name: ClosePartialRenderWhenAnimatingWindows002
1780 * @tc.desc: Test RSUniRenderVisitorTest.ClosePartialRenderWhenAnimatingWindows while
1781 * appWindowNum_ isn't bigger than PHONE_MAX_APP_WINDOW_NUM
1782 * @tc.type: FUNC
1783 * @tc.require: issuesI7SAJC
1784 */
1785 HWTEST_F(RSUniRenderVisitorTest, ClosePartialRenderWhenAnimatingWindows002, TestSize.Level2)
1786 {
1787 NodeId id = 0;
1788 RSDisplayNodeConfig config;
1789 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1790 ASSERT_NE(displayNode, nullptr);
1791 RectI rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1792 displayNode->GetDirtyManager()->surfaceRect_ = rect;
1793
1794 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1795 ASSERT_NE(rsUniRenderVisitor, nullptr);
1796 rsUniRenderVisitor->SetAnimateState(true);
1797 rsUniRenderVisitor->SetAppWindowNum(1);
1798 rsUniRenderVisitor->ClosePartialRenderWhenAnimatingWindows(displayNode);
1799 ASSERT_TRUE(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty());
1800 }
1801
1802 /**
1803 * @tc.name: ClosePartialRenderWhenAnimatingWindows003
1804 * @tc.desc: Test RSUniRenderVisitorTest.ClosePartialRenderWhenAnimatingWindows while
1805 * appWindowNum_ is bigger than PHONE_MAX_APP_WINDOW_NUM
1806 * @tc.type: FUNC
1807 * @tc.require: issuesI7SAJC
1808 */
1809 HWTEST_F(RSUniRenderVisitorTest, ClosePartialRenderWhenAnimatingWindows003, TestSize.Level2)
1810 {
1811 NodeId id = 0;
1812 RSDisplayNodeConfig config;
1813 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
1814 ASSERT_NE(displayNode, nullptr);
1815 RectI rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1816 displayNode->GetDirtyManager()->surfaceRect_ = rect;
1817
1818 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1819 ASSERT_NE(rsUniRenderVisitor, nullptr);
1820 rsUniRenderVisitor->SetAnimateState(true);
1821 rsUniRenderVisitor->SetAppWindowNum(2);
1822 rsUniRenderVisitor->ClosePartialRenderWhenAnimatingWindows(displayNode);
1823 ASSERT_EQ(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion(), rect);
1824 }
1825
1826 /**
1827 * @tc.name: DrawChildRenderNode001
1828 * @tc.desc: Test RSUniRenderVisitorTest.DrawChildRenderNode api while
1829 * the canvas node's cacheType_ is ANIMATE_PROPERTY
1830 * @tc.type: FUNC
1831 * @tc.require: issuesI7SAJC
1832 */
1833 HWTEST_F(RSUniRenderVisitorTest, DrawChildRenderNode001, TestSize.Level2)
1834 {
1835 auto rsContext = std::make_shared<RSContext>();
1836 auto canvasNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
1837 ASSERT_NE(canvasNode, nullptr);
1838 canvasNode->SetCacheType(CacheType::ANIMATE_PROPERTY);
1839
1840 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1841 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
1842 ASSERT_NE(rsUniRenderVisitor, nullptr);
1843 ASSERT_NE(drawingCanvas, nullptr);
1844 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
1845 rsUniRenderVisitor->DrawChildRenderNode(*canvasNode);
1846 }
1847
1848 /*
1849 * @tc.name: MarkSubHardwareEnableNodeState003
1850 * @tc.desc: Test RSUniRenderVisitorTest.MarkSubHardwareEnableNodeStateTest for self drawing node
1851 * @tc.type: FUNC
1852 * @tc.require: issuesI7SAJC
1853 */
1854 HWTEST_F(RSUniRenderVisitorTest, MarkSubHardwareEnableNodeState003, TestSize.Level2)
1855 {
1856 auto selfDrawingNode = RSTestUtil::CreateSurfaceNode();
1857 ASSERT_NE(selfDrawingNode, nullptr);
1858 selfDrawingNode->SetSurfaceNodeType(RSSurfaceNodeType::SELF_DRAWING_NODE);
1859 selfDrawingNode->SetHardwareEnabled(true);
1860
1861 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1862 ASSERT_NE(rsUniRenderVisitor, nullptr);
1863 rsUniRenderVisitor->MarkSubHardwareEnableNodeState(*selfDrawingNode);
1864 ASSERT_TRUE(selfDrawingNode->IsHardwareForcedDisabled());
1865 }
1866
1867 /*
1868 * @tc.name: MarkSubHardwareEnableNodeState004
1869 * @tc.desc: Test RSUniRenderVisitorTest.MarkSubHardwareEnableNodeStateTest for app window node's child
1870 * @tc.type: FUNC
1871 * @tc.require: issuesI7SAJC
1872 */
1873 HWTEST_F(RSUniRenderVisitorTest, MarkSubHardwareEnableNodeState004, TestSize.Level2)
1874 {
1875 auto appWindowNode = RSTestUtil::CreateSurfaceNode();
1876 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNode();
1877 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
1878 appWindowNode->AddChildHardwareEnabledNode(hardwareEnabledNode);
1879
1880 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1881 ASSERT_NE(rsUniRenderVisitor, nullptr);
1882 rsUniRenderVisitor->MarkSubHardwareEnableNodeState(*appWindowNode);
1883 ASSERT_TRUE(hardwareEnabledNode->IsHardwareForcedDisabled());
1884 }
1885
1886 /*
1887 * @tc.name: PrepareTypesOfSurfaceRenderNodeBeforeUpdate001
1888 * @tc.desc: Test RSUniRenderVisitorTest.PrepareTypesOfSurfaceRenderNodeBeforeUpdateTest for DFX enabled
1889 * @tc.type: FUNC
1890 * @tc.require: issuesI7SAJC
1891 */
1892 HWTEST_F(RSUniRenderVisitorTest, PrepareTypesOfSurfaceRenderNodeBeforeUpdate001, TestSize.Level2)
1893 {
1894 auto leashWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
1895 ASSERT_NE(leashWindowNode, nullptr);
1896 leashWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
1897
1898 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1899 ASSERT_NE(rsUniRenderVisitor, nullptr);
1900 rsUniRenderVisitor->isTargetDirtyRegionDfxEnabled_ = true;
1901 rsUniRenderVisitor->dfxTargetSurfaceNames_.push_back(leashWindowNode->GetName());
1902 rsUniRenderVisitor->PrepareTypesOfSurfaceRenderNodeBeforeUpdate(*leashWindowNode);
1903 ASSERT_TRUE(rsUniRenderVisitor->curSurfaceDirtyManager_->IsTargetForDfx());
1904 }
1905
1906 /*
1907 * @tc.name: PrepareTypesOfSurfaceRenderNodeBeforeUpdate002
1908 * @tc.desc: Test RSUniRenderVisitorTest.PrepareTypesOfSurfaceRenderNodeBeforeUpdateTest for self drawing node
1909 * @tc.type: FUNC
1910 * @tc.require: issuesI7SAJC
1911 */
1912 HWTEST_F(RSUniRenderVisitorTest, PrepareTypesOfSurfaceRenderNodeBeforeUpdate002, TestSize.Level2)
1913 {
1914 auto selfDrawingNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
1915 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
1916 ASSERT_NE(selfDrawingNode, nullptr);
1917 ASSERT_NE(surfaceNode, nullptr);
1918 selfDrawingNode->SetSurfaceNodeType(RSSurfaceNodeType::SELF_DRAWING_NODE);
1919 selfDrawingNode->SetHardwareEnabled(true);
1920
1921 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1922 ASSERT_NE(rsUniRenderVisitor, nullptr);
1923 rsUniRenderVisitor->curSurfaceNode_ = surfaceNode;
1924
1925 rsUniRenderVisitor->PrepareTypesOfSurfaceRenderNodeBeforeUpdate(*selfDrawingNode);
1926 ASSERT_FALSE(rsUniRenderVisitor->curSurfaceNode_->GetChildHardwareEnabledNodes().empty());
1927 }
1928
1929 /**
1930 * @tc.name: CheckColorSpaceWithSelfDrawingNode001
1931 * @tc.desc: Test RSUniRenderVisitorTest.CheckColorSpaceWithSelfDrawingNode while
1932 * selfDrawingNode's color space is not equal to GRAPHIC_COLOR_GAMUT_SRGB,
1933 * and this node will be drawn with gpu
1934 * @tc.type: FUNC
1935 * @tc.require: issueIAW3W0
1936 */
1937 HWTEST_F(RSUniRenderVisitorTest, CheckColorSpaceWithSelfDrawingNode001, TestSize.Level2)
1938 {
1939 auto selfDrawingNode = RSTestUtil::CreateSurfaceNode();
1940 ASSERT_NE(selfDrawingNode, nullptr);
1941 selfDrawingNode->SetHardwareForcedDisabledState(true);
1942 selfDrawingNode->SetColorSpace(GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DISPLAY_P3);
1943 selfDrawingNode->SetIsOnTheTree(true);
1944
1945 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1946 ASSERT_NE(rsUniRenderVisitor, nullptr);
1947 rsUniRenderVisitor->CheckColorSpaceWithSelfDrawingNode(*selfDrawingNode);
1948 ASSERT_EQ(rsUniRenderVisitor->newColorSpace_, selfDrawingNode->GetColorSpace());
1949 }
1950
1951 /**
1952 * @tc.name: CheckColorSpaceWithSelfDrawingNode002
1953 * @tc.desc: Test RSUniRenderVisitorTest.CheckColorSpaceWithSelfDrawingNode while
1954 * selfDrawingNode's color space is not equal to GRAPHIC_COLOR_GAMUT_SRGB,
1955 * and this node will not be drawn with gpu
1956 * @tc.type: FUNC
1957 * @tc.require: issueIAW3W0
1958 */
1959 HWTEST_F(RSUniRenderVisitorTest, CheckColorSpaceWithSelfDrawingNode002, TestSize.Level2)
1960 {
1961 auto selfDrawingNode = RSTestUtil::CreateSurfaceNode();
1962 ASSERT_NE(selfDrawingNode, nullptr);
1963 selfDrawingNode->SetProtectedLayer(true);
1964 selfDrawingNode->SetColorSpace(GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DISPLAY_P3);
1965 selfDrawingNode->SetIsOnTheTree(true);
1966
1967 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
1968 ASSERT_NE(rsUniRenderVisitor, nullptr);
1969 rsUniRenderVisitor->CheckColorSpaceWithSelfDrawingNode(*selfDrawingNode);
1970 ASSERT_NE(rsUniRenderVisitor->newColorSpace_, selfDrawingNode->GetColorSpace());
1971 }
1972
1973
1974 #ifndef ROSEN_CROSS_PLATFORM
1975 /**
1976 * @tc.name: UpdateColorSpaceWithMetadata
1977 * @tc.desc: test results of UpdateColorSpaceWithMetadata, if node has no buffer
1978 * @tc.type: FUNC
1979 * @tc.require: issueIAW3W0
1980 */
1981 HWTEST_F(RSUniRenderVisitorTest, UpdateColorSpaceWithMetadata001, TestSize.Level1)
1982 {
1983 // register instance root node
1984 auto instanceRootNode = RSTestUtil::CreateSurfaceNode();
1985 ASSERT_NE(instanceRootNode, nullptr);
1986 auto rsContext = std::make_shared<RSContext>();
1987 auto& nodeMap = rsContext->GetMutableNodeMap();
1988 nodeMap.renderNodeMap_[instanceRootNode->GetId()] = instanceRootNode;
1989 // create subsurface node
1990 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
1991 ASSERT_NE(surfaceNode, nullptr);
1992 surfaceNode->context_ = rsContext;
1993 surfaceNode->instanceRootNodeId_ = instanceRootNode->GetId();
1994
1995 ASSERT_NE(surfaceNode->GetInstanceRootNode(), nullptr);
1996 surfaceNode->UpdateColorSpaceWithMetadata();
1997 ASSERT_EQ(surfaceNode->GetColorSpace(), GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB);
1998 }
1999
2000 /**
2001 * @tc.name: UpdateColorSpaceWithMetadata
2002 * @tc.desc: test results of UpdateColorSpaceWithMetadata, if node has buffer
2003 * @tc.type: FUNC
2004 * @tc.require: issueIAW3W0
2005 */
2006 HWTEST_F(RSUniRenderVisitorTest, UpdateColorSpaceWithMetadata002, TestSize.Level1)
2007 {
2008 // register instance root node
2009 auto instanceRootNode = RSTestUtil::CreateSurfaceNode();
2010 ASSERT_NE(instanceRootNode, nullptr);
2011 auto rsContext = std::make_shared<RSContext>();
2012 auto& nodeMap = rsContext->GetMutableNodeMap();
2013 nodeMap.renderNodeMap_[instanceRootNode->GetId()] = instanceRootNode;
2014 // create subsurface node
2015 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2016 ASSERT_NE(surfaceNode, nullptr);
2017 const sptr<SurfaceBuffer>& buffer = surfaceNode->GetRSSurfaceHandler()->GetBuffer();
2018 ASSERT_NE(buffer, nullptr);
2019 surfaceNode->context_ = rsContext;
2020 surfaceNode->instanceRootNodeId_ = instanceRootNode->GetId();
2021
2022 ASSERT_NE(surfaceNode->GetInstanceRootNode(), nullptr);
2023 surfaceNode->UpdateColorSpaceWithMetadata();
2024 ASSERT_EQ(surfaceNode->GetColorSpace(), GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB);
2025 }
2026 #endif
2027
2028 /*
2029 * @tc.name: UpdateColorSpaceAfterHwcCalc_001
2030 * @tc.desc: Test UpdateColorSpaceAfterHwcCalc when there is a P3 selfDrawingNode.
2031 * @tc.type: FUNC
2032 * @tc.require: issueIAW3W0
2033 */
2034 HWTEST_F(RSUniRenderVisitorTest, UpdateColorSpaceAfterHwcCalc_001, TestSize.Level2)
2035 {
2036 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2037 ASSERT_NE(rsUniRenderVisitor, nullptr);
2038 auto selfDrawingNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2039 ASSERT_NE(selfDrawingNode, nullptr);
2040 NodeId id = 0;
2041 RSDisplayNodeConfig config;
2042 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2043 ASSERT_NE(displayNode, nullptr);
2044 selfDrawingNode->SetAncestorDisplayNode(displayNode);
2045 selfDrawingNode->SetHardwareForcedDisabledState(true);
2046 selfDrawingNode->SetColorSpace(GraphicColorGamut::GRAPHIC_COLOR_GAMUT_DISPLAY_P3);
2047
2048 rsUniRenderVisitor->UpdateColorSpaceAfterHwcCalc(*displayNode);
2049 ASSERT_EQ(rsUniRenderVisitor->newColorSpace_, GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB);
2050 }
2051
2052 /*
2053 * @tc.name: ResetCurSurfaceInfoAsUpperSurfaceParent001
2054 * @tc.desc: Reset but keep single node's surfaceInfo
2055 * @tc.type: FUNC
2056 * @tc.require: issuesI8MQCS
2057 */
2058 HWTEST_F(RSUniRenderVisitorTest, ResetCurSurfaceInfoAsUpperSurfaceParent001, TestSize.Level2)
2059 {
2060 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2061 auto upperSurfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2062 ASSERT_NE(surfaceNode, nullptr);
2063 ASSERT_NE(upperSurfaceNode, nullptr);
2064 surfaceNode->SetParent(upperSurfaceNode);
2065
2066 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2067 ASSERT_NE(rsUniRenderVisitor, nullptr);
2068 rsUniRenderVisitor->curSurfaceNode_ = surfaceNode;
2069
2070 NodeId id = 0;
2071 RSDisplayNodeConfig config;
2072 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2073
2074 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2075 rsUniRenderVisitor->ResetCurSurfaceInfoAsUpperSurfaceParent(*surfaceNode);
2076 ASSERT_EQ(rsUniRenderVisitor->curSurfaceNode_, surfaceNode);
2077 }
2078
2079 /*
2080 * @tc.name: ResetCurSurfaceInfoAsUpperSurfaceParent002
2081 * @tc.desc: Reset but keep node's surfaceInfo since upper surface's InstanceRootNode is not registered
2082 * @tc.type: FUNC
2083 * @tc.require: issuesI8MQCS
2084 */
2085 HWTEST_F(RSUniRenderVisitorTest, ResetCurSurfaceInfoAsUpperSurfaceParent002, TestSize.Level2)
2086 {
2087 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2088 auto upperSurfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2089 ASSERT_NE(surfaceNode, nullptr);
2090 ASSERT_NE(upperSurfaceNode, nullptr);
2091 upperSurfaceNode->instanceRootNodeId_ = upperSurfaceNode->GetId();
2092 ASSERT_EQ(upperSurfaceNode->GetInstanceRootNode(), nullptr);
2093 surfaceNode->SetParent(std::weak_ptr<RSSurfaceRenderNode>(upperSurfaceNode));
2094
2095 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2096 ASSERT_NE(rsUniRenderVisitor, nullptr);
2097 rsUniRenderVisitor->curSurfaceNode_ = surfaceNode;
2098
2099 NodeId id = 0;
2100 RSDisplayNodeConfig config;
2101 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2102
2103 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2104 rsUniRenderVisitor->ResetCurSurfaceInfoAsUpperSurfaceParent(*surfaceNode);
2105 ASSERT_EQ(rsUniRenderVisitor->curSurfaceNode_, surfaceNode);
2106 }
2107
2108 /*
2109 * @tc.name: UpdateHwcNodeEnableByNodeBelow
2110 * @tc.desc: Test RSUniRenderVistorTest.UpdateHwcNodeEnableByNodeBelow
2111 * @tc.type: FUNC
2112 * @tc.require: issuesI8MQCS
2113 */
2114 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeEnableByNodeBelow, TestSize.Level2)
2115 {
2116 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2117 ASSERT_NE(rsUniRenderVisitor, nullptr);
2118 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2119 ASSERT_NE(surfaceNode, nullptr);
2120
2121 NodeId displayNodeId = 1;
2122 RSDisplayNodeConfig config;
2123 auto displayNode = std::make_shared<RSDisplayRenderNode>(displayNodeId, config);
2124
2125 RSSurfaceRenderNodeConfig surfaceConfig;
2126 surfaceConfig.id = 1;
2127 auto hwcNode1 = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
2128 ASSERT_NE(hwcNode1, nullptr);
2129 surfaceConfig.id = 2;
2130 auto hwcNode2 = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
2131 ASSERT_NE(hwcNode2, nullptr);
2132 hwcNode1->SetIsOnTheTree(true);
2133 hwcNode2->SetIsOnTheTree(false);
2134 surfaceNode->AddChildHardwareEnabledNode(hwcNode1);
2135 surfaceNode->AddChildHardwareEnabledNode(hwcNode2);
2136
2137 displayNode->curMainAndLeashSurfaceNodes_.push_back(surfaceNode);
2138 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2139 rsUniRenderVisitor->UpdateHwcNodeEnableByNodeBelow();
2140 }
2141
2142 /*
2143 * @tc.name: PrepareSurfaceRenderNode001
2144 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSurfaceRenderNode while surface node has security layer
2145 * @tc.type: FUNC
2146 * @tc.require: issuesI7SAJC
2147 */
2148 HWTEST_F(RSUniRenderVisitorTest, PrepareSurfaceRenderNode001, TestSize.Level2)
2149 {
2150 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2151 ASSERT_NE(surfaceNode, nullptr);
2152 surfaceNode->SetSecurityLayer(true);
2153 surfaceNode->SetIsOnTheTree(true, surfaceNode->GetId(), surfaceNode->GetId());
2154 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2155
2156 NodeId id = 0;
2157 RSDisplayNodeConfig config;
2158 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2159 ASSERT_NE(displayNode, nullptr);
2160 displayNode->InitRenderParams();
2161
2162 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2163 ASSERT_NE(rsUniRenderVisitor, nullptr);
2164 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2165 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2166 rsUniRenderVisitor->displayHasSecSurface_[rsUniRenderVisitor->currentVisitDisplay_] = false;
2167 rsUniRenderVisitor->PrepareSurfaceRenderNode(*surfaceNode);
2168 ASSERT_EQ(rsUniRenderVisitor->displayHasSecSurface_[rsUniRenderVisitor->currentVisitDisplay_], true);
2169 }
2170
2171 /*
2172 * @tc.name: PrepareSurfaceRenderNode002
2173 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSurfaceRenderNode while surface node has skip layer
2174 * @tc.type: FUNC
2175 * @tc.require: issuesI7SAJC
2176 */
2177 HWTEST_F(RSUniRenderVisitorTest, PrepareSurfaceRenderNode002, TestSize.Level2)
2178 {
2179 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2180 ASSERT_NE(surfaceNode, nullptr);
2181 surfaceNode->SetSkipLayer(true);
2182 surfaceNode->SetIsOnTheTree(true, surfaceNode->GetId(), surfaceNode->GetId());
2183 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2184
2185 NodeId id = 0;
2186 RSDisplayNodeConfig config;
2187 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2188 ASSERT_NE(displayNode, nullptr);
2189 displayNode->InitRenderParams();
2190
2191 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2192 ASSERT_NE(rsUniRenderVisitor, nullptr);
2193 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2194 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2195 rsUniRenderVisitor->displayHasSkipSurface_[rsUniRenderVisitor->currentVisitDisplay_] = false;
2196 rsUniRenderVisitor->PrepareSurfaceRenderNode(*surfaceNode);
2197 ASSERT_EQ(rsUniRenderVisitor->displayHasSkipSurface_[rsUniRenderVisitor->currentVisitDisplay_], true);
2198 }
2199
2200 /*
2201 * @tc.name: PrepareSurfaceRenderNode003
2202 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSurfaceRenderNode while surface node is capture window
2203 * @tc.type: FUNC
2204 * @tc.require: issuesI7SAJC
2205 */
2206 HWTEST_F(RSUniRenderVisitorTest, PrepareSurfaceRenderNode003, TestSize.Level2)
2207 {
2208 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2209 ASSERT_NE(surfaceNode, nullptr);
2210 surfaceNode->SetIsOnTheTree(true, surfaceNode->GetId(), surfaceNode->GetId());
2211 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2212 surfaceNode->name_ = CAPTURE_WINDOW_NAME;
2213
2214 NodeId id = 0;
2215 RSDisplayNodeConfig config;
2216 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2217 ASSERT_NE(displayNode, nullptr);
2218
2219 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2220 ASSERT_NE(rsUniRenderVisitor, nullptr);
2221 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2222 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2223 rsUniRenderVisitor->hasCaptureWindow_[rsUniRenderVisitor->currentVisitDisplay_] = false;
2224 rsUniRenderVisitor->PrepareSurfaceRenderNode(*surfaceNode);
2225 ASSERT_EQ(rsUniRenderVisitor->hasCaptureWindow_[rsUniRenderVisitor->currentVisitDisplay_], true);
2226 }
2227
2228 /*
2229 * @tc.name: PrepareSurfaceRenderNode004
2230 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSurfaceRenderNode while surface node has protected layer
2231 * @tc.type: FUNC
2232 * @tc.require: issueI7ZSC2
2233 */
2234 HWTEST_F(RSUniRenderVisitorTest, PrepareSurfaceRenderNode004, TestSize.Level2)
2235 {
2236 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2237 ASSERT_NE(surfaceNode, nullptr);
2238 surfaceNode->SetIsOnTheTree(true, surfaceNode->GetId(), surfaceNode->GetId());
2239 surfaceNode->SetProtectedLayer(true);
2240
2241 NodeId id = 0;
2242 RSDisplayNodeConfig config;
2243 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2244 ASSERT_NE(displayNode, nullptr);
2245 displayNode->InitRenderParams();
2246 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2247 ASSERT_NE(rsUniRenderVisitor, nullptr);
2248 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2249 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2250 rsUniRenderVisitor->displayHasProtectedSurface_[rsUniRenderVisitor->currentVisitDisplay_] = true;
2251 rsUniRenderVisitor->PrepareSurfaceRenderNode(*surfaceNode);
2252 }
2253
2254 /*
2255 * @tc.name: PrepareSurfaceRenderNode005
2256 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSurfaceRenderNode while surface node does not have protected layer
2257 * @tc.type: FUNC
2258 * @tc.require: issueI7ZSC2
2259 */
2260 HWTEST_F(RSUniRenderVisitorTest, PrepareSurfaceRenderNode005, TestSize.Level2)
2261 {
2262 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2263 ASSERT_NE(surfaceNode, nullptr);
2264
2265 surfaceNode->SetIsOnTheTree(true, surfaceNode->GetId(), surfaceNode->GetId());
2266 surfaceNode->SetProtectedLayer(false);
2267
2268 NodeId id = 0;
2269 RSDisplayNodeConfig config;
2270 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2271 ASSERT_NE(displayNode, nullptr);
2272 displayNode->InitRenderParams();
2273 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2274 ASSERT_NE(rsUniRenderVisitor, nullptr);
2275 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2276 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2277 rsUniRenderVisitor->displayHasProtectedSurface_[rsUniRenderVisitor->currentVisitDisplay_] = false;
2278 rsUniRenderVisitor->PrepareSurfaceRenderNode(*surfaceNode);
2279 }
2280
2281 /*
2282 * @tc.name: PrepareDisplayRenderNode001
2283 * @tc.desc: Test RSUniRenderVisitorTest.PrepareDisplayRenderNode while dsiplay node has security surface
2284 * @tc.type: FUNC
2285 * @tc.require: issuesI7SAJC
2286 */
2287 HWTEST_F(RSUniRenderVisitorTest, PrepareDisplayRenderNode001, TestSize.Level2)
2288 {
2289 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2290 ASSERT_NE(surfaceNode, nullptr);
2291 surfaceNode->SetSecurityLayer(true);
2292 surfaceNode->SetIsOnTheTree(true, surfaceNode->GetId(), surfaceNode->GetId());
2293 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2294
2295 NodeId id = 0;
2296 RSDisplayNodeConfig config;
2297 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2298 ASSERT_NE(displayNode, nullptr);
2299 displayNode->InitRenderParams();
2300 ASSERT_NE(displayNode->GetDirtyManager(), nullptr);
2301 displayNode->AddChild(surfaceNode, 0);
2302 displayNode->GenerateFullChildrenList();
2303
2304 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2305 ASSERT_NE(rsUniRenderVisitor, nullptr);
2306 ASSERT_NE(CreateOrGetScreenManager(), nullptr);
2307 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2308 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2309 rsUniRenderVisitor->displayHasSecSurface_[rsUniRenderVisitor->currentVisitDisplay_] = false;
2310
2311 rsUniRenderVisitor->PrepareDisplayRenderNode(*displayNode);
2312 ASSERT_EQ(rsUniRenderVisitor->displayHasSecSurface_[rsUniRenderVisitor->currentVisitDisplay_], true);
2313 }
2314
2315 /*
2316 * @tc.name: PrepareDisplayRenderNode002
2317 * @tc.desc: Test RSUniRenderVisitorTest.PrepareDisplayRenderNode while dsiplay node has skip surface
2318 * @tc.type: FUNC
2319 * @tc.require: issuesI7SAJC
2320 */
2321 HWTEST_F(RSUniRenderVisitorTest, PrepareDisplayRenderNode002, TestSize.Level2)
2322 {
2323 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2324 ASSERT_NE(surfaceNode, nullptr);
2325 surfaceNode->SetSkipLayer(true);
2326 surfaceNode->SetIsOnTheTree(true, surfaceNode->GetId(), surfaceNode->GetId());
2327 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2328
2329 NodeId id = 0;
2330 RSDisplayNodeConfig config;
2331 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2332 ASSERT_NE(displayNode, nullptr);
2333 displayNode->InitRenderParams();
2334 ASSERT_NE(displayNode->GetDirtyManager(), nullptr);
2335 displayNode->AddChild(surfaceNode, 0);
2336 displayNode->GenerateFullChildrenList();
2337
2338 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2339 ASSERT_NE(rsUniRenderVisitor, nullptr);
2340 ASSERT_NE(CreateOrGetScreenManager(), nullptr);
2341 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2342 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2343 rsUniRenderVisitor->displayHasSkipSurface_[rsUniRenderVisitor->currentVisitDisplay_] = false;
2344
2345 rsUniRenderVisitor->PrepareDisplayRenderNode(*displayNode);
2346 ASSERT_EQ(rsUniRenderVisitor->displayHasSkipSurface_[rsUniRenderVisitor->currentVisitDisplay_], true);
2347 }
2348
2349 /*
2350 * @tc.name: PrepareDisplayRenderNode003
2351 * @tc.desc: Test RSUniRenderVisitorTest.PrepareDisplayRenderNode while dsiplay node has capture window surface
2352 * @tc.type: FUNC
2353 * @tc.require: issuesI7SAJC
2354 */
2355 HWTEST_F(RSUniRenderVisitorTest, PrepareDisplayRenderNode003, TestSize.Level2)
2356 {
2357 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2358 ASSERT_NE(surfaceNode, nullptr);
2359 surfaceNode->SetIsOnTheTree(true, surfaceNode->GetId(), surfaceNode->GetId());
2360 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2361 surfaceNode->name_ = CAPTURE_WINDOW_NAME;
2362
2363 NodeId id = 0;
2364 RSDisplayNodeConfig config;
2365 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2366 ASSERT_NE(displayNode, nullptr);
2367 displayNode->InitRenderParams();
2368 ASSERT_NE(displayNode->GetDirtyManager(), nullptr);
2369 displayNode->AddChild(surfaceNode, 0);
2370 displayNode->GenerateFullChildrenList();
2371
2372 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2373 ASSERT_NE(rsUniRenderVisitor, nullptr);
2374 ASSERT_NE(CreateOrGetScreenManager(), nullptr);
2375 rsUniRenderVisitor->isQuickSkipPreparationEnabled_ = true;
2376 rsUniRenderVisitor->curDisplayNode_ = displayNode;
2377 rsUniRenderVisitor->hasCaptureWindow_[rsUniRenderVisitor->currentVisitDisplay_] = false;
2378
2379 rsUniRenderVisitor->PrepareDisplayRenderNode(*displayNode);
2380 ASSERT_EQ(rsUniRenderVisitor->hasCaptureWindow_[rsUniRenderVisitor->currentVisitDisplay_], true);
2381 }
2382
2383 /*
2384 * @tc.name: AssignGlobalZOrderAndCreateLayer001
2385 * @tc.desc: Test RSUniRenderVisitorTest.AssignGlobalZOrderAndCreateLayerTest
2386 * while appWindowNodesInZOrder_ is empty
2387 * @tc.type: FUNC
2388 * @tc.require: issuesI7SAJC
2389 */
2390 HWTEST_F(RSUniRenderVisitorTest, AssignGlobalZOrderAndCreateLayer001, TestSize.Level2)
2391 {
2392 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2393 ASSERT_NE(hardwareEnabledNode, nullptr);
2394 hardwareEnabledNode->InitRenderParams();
2395
2396 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2397 ASSERT_NE(rsUniRenderVisitor, nullptr);
2398 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(hardwareEnabledNode);
2399
2400 std::vector<std::shared_ptr<RSSurfaceRenderNode>> nodeList;
2401 auto oldZOrder = rsUniRenderVisitor->globalZOrder_;
2402 rsUniRenderVisitor->AssignGlobalZOrderAndCreateLayer(nodeList);
2403 ASSERT_EQ(rsUniRenderVisitor->globalZOrder_, oldZOrder);
2404 }
2405
2406 /*
2407 * @tc.name: AssignGlobalZOrderAndCreateLayer002
2408 * @tc.desc: Test RSUniRenderVisitorTest.AssignGlobalZOrderAndCreateLayerTest
2409 * while app window nodes don't have child
2410 * @tc.type: FUNC
2411 * @tc.require: issuesI7SAJC
2412 */
2413 HWTEST_F(RSUniRenderVisitorTest, AssignGlobalZOrderAndCreateLayer002, TestSize.Level2)
2414 {
2415 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2416 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2417 ASSERT_NE(hardwareEnabledNode, nullptr);
2418 ASSERT_NE(appWindowNode, nullptr);
2419 hardwareEnabledNode->InitRenderParams();
2420 appWindowNode->InitRenderParams();
2421 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2422
2423 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2424 ASSERT_NE(rsUniRenderVisitor, nullptr);
2425 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(hardwareEnabledNode);
2426
2427 std::vector<std::shared_ptr<RSSurfaceRenderNode>> nodeList;
2428 nodeList.push_back(appWindowNode);
2429 auto oldZOrder = rsUniRenderVisitor->globalZOrder_;
2430 rsUniRenderVisitor->AssignGlobalZOrderAndCreateLayer(nodeList);
2431 ASSERT_EQ(rsUniRenderVisitor->globalZOrder_, oldZOrder);
2432 }
2433
2434 /*
2435 * @tc.name: AssignGlobalZOrderAndCreateLayer003
2436 * @tc.desc: Test RSUniRenderVisitorTest.AssignGlobalZOrderAndCreateLayerTest
2437 * while app window nodes's child is HardwareForcedDisabled
2438 * @tc.type: FUNC
2439 * @tc.require: issuesI7SAJC
2440 */
2441 HWTEST_F(RSUniRenderVisitorTest, AssignGlobalZOrderAndCreateLayer003, TestSize.Level2)
2442 {
2443 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2444 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2445 auto childNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2446 ASSERT_NE(hardwareEnabledNode, nullptr);
2447 ASSERT_NE(appWindowNode, nullptr);
2448 ASSERT_NE(childNode, nullptr);
2449 hardwareEnabledNode->InitRenderParams();
2450 appWindowNode->InitRenderParams();
2451 childNode->InitRenderParams();
2452 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2453 appWindowNode->AddChildHardwareEnabledNode(childNode);
2454
2455 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2456 ASSERT_NE(rsUniRenderVisitor, nullptr);
2457 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(hardwareEnabledNode);
2458
2459 std::vector<std::shared_ptr<RSSurfaceRenderNode>> nodeList;
2460 nodeList.push_back(appWindowNode);
2461 auto oldZOrder = rsUniRenderVisitor->globalZOrder_;
2462 rsUniRenderVisitor->AssignGlobalZOrderAndCreateLayer(nodeList);
2463 ASSERT_EQ(rsUniRenderVisitor->globalZOrder_, oldZOrder);
2464 }
2465
2466 /*
2467 * @tc.name: AssignGlobalZOrderAndCreateLayer004
2468 * @tc.desc: Test RSUniRenderVisitorTest.AssignGlobalZOrderAndCreateLayerTest
2469 * while app window nodes's child isn't HardwareForcedDisabled
2470 * @tc.type: FUNC
2471 * @tc.require: issuesI7SAJC
2472 */
2473 HWTEST_F(RSUniRenderVisitorTest, AssignGlobalZOrderAndCreateLayer004, TestSize.Level2)
2474 {
2475 auto hardwareEnabledNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2476 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2477 auto childNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2478 ASSERT_NE(hardwareEnabledNode, nullptr);
2479 ASSERT_NE(appWindowNode, nullptr);
2480 ASSERT_NE(childNode, nullptr);
2481 hardwareEnabledNode->InitRenderParams();
2482 appWindowNode->InitRenderParams();
2483 childNode->InitRenderParams();
2484 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2485 appWindowNode->AddChildHardwareEnabledNode(childNode);
2486 childNode->dstRect_ = RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2487 childNode->isOnTheTree_ = true;
2488
2489 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2490 ASSERT_NE(rsUniRenderVisitor, nullptr);
2491 rsUniRenderVisitor->processor_ = RSProcessorFactory::CreateProcessor(
2492 RSDisplayRenderNode::CompositeType::UNI_RENDER_COMPOSITE);
2493 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(hardwareEnabledNode);
2494
2495 std::vector<std::shared_ptr<RSSurfaceRenderNode>> nodeList;
2496 nodeList.push_back(appWindowNode);
2497 auto oldZOrder = rsUniRenderVisitor->globalZOrder_;
2498 rsUniRenderVisitor->AssignGlobalZOrderAndCreateLayer(nodeList);
2499 ASSERT_NE(rsUniRenderVisitor->globalZOrder_, oldZOrder);
2500 }
2501
2502 /*
2503 * @tc.name: CalcDirtyDisplayRegion002
2504 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyDisplayRegion while surface node's shadow is valid
2505 * @tc.type: FUNC
2506 * @tc.require: issuesI7T9RE
2507 */
2508 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion002, TestSize.Level2)
2509 {
2510 NodeId id = 0;
2511 RSDisplayNodeConfig config;
2512 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2513 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2514 ASSERT_NE(displayNode, nullptr);
2515 ASSERT_NE(surfaceNode, nullptr);
2516 displayNode->InitRenderParams();
2517 surfaceNode->InitRenderParams();
2518 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
2519 surfaceNode->GetMutableRenderProperties().SetShadowRadius(1.0f);
2520
2521 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2522 ASSERT_NE(rsUniRenderVisitor, nullptr);
2523 rsUniRenderVisitor->CalcDirtyDisplayRegion(displayNode);
2524 ASSERT_FALSE(surfaceNode->IsShadowValidLastFrame());
2525 }
2526
2527 /*
2528 * @tc.name: CalcDirtyDisplayRegion003
2529 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyDisplayRegion while
2530 * surface node's shadow is valid and its shadow dirty rect isn't empty
2531 * @tc.type: FUNC
2532 * @tc.require: issuesI7T9RE
2533 */
2534 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion003, TestSize.Level2)
2535 {
2536 NodeId id = 0;
2537 RSDisplayNodeConfig config;
2538 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2539 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2540 ASSERT_NE(displayNode, nullptr);
2541 ASSERT_NE(surfaceNode, nullptr);
2542 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
2543 surfaceNode->GetMutableRenderProperties().SetShadowRadius(1.0f);
2544 RectI rect=RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2545 surfaceNode->oldDirtyInSurface_ = rect;
2546 surfaceNode->GetDirtyManager()->MergeDirtyRect(rect);
2547
2548 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2549 ASSERT_NE(rsUniRenderVisitor, nullptr);
2550 rsUniRenderVisitor->CalcDirtyDisplayRegion(displayNode);
2551 ASSERT_EQ(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion(), rect);
2552 }
2553
2554 /*
2555 * @tc.name: CalcDirtyDisplayRegion004
2556 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyDisplayRegion while
2557 * surface node is shadow valid last frame
2558 * @tc.type: FUNC
2559 * @tc.require: issuesI7T9RE
2560 */
2561 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion004, TestSize.Level2)
2562 {
2563 NodeId id = 0;
2564 RSDisplayNodeConfig config;
2565 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2566 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2567 ASSERT_NE(displayNode, nullptr);
2568 ASSERT_NE(surfaceNode, nullptr);
2569 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
2570 surfaceNode->SetShadowValidLastFrame(true);
2571
2572 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2573 ASSERT_NE(rsUniRenderVisitor, nullptr);
2574 rsUniRenderVisitor->CalcDirtyDisplayRegion(displayNode);
2575 ASSERT_FALSE(surfaceNode->IsShadowValidLastFrame());
2576 }
2577
2578 /*
2579 * @tc.name: CalcDirtyDisplayRegion005
2580 * @tc.desc: Test RSUniRenderVisitorTest.CalcDirtyDisplayRegion while
2581 * surface node is shadow valid last frame and its shadow dirty rect isn't empty
2582 * @tc.type: FUNC
2583 * @tc.require: issuesI7T9RE
2584 */
2585 HWTEST_F(RSUniRenderVisitorTest, CalcDirtyDisplayRegion005, TestSize.Level2)
2586 {
2587 NodeId id = 0;
2588 RSDisplayNodeConfig config;
2589 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2590 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2591 ASSERT_NE(displayNode, nullptr);
2592 ASSERT_NE(surfaceNode, nullptr);
2593 displayNode->GetCurAllSurfaces().push_back(surfaceNode);
2594 surfaceNode->SetShadowValidLastFrame(true);
2595 RectI rect=RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2596 surfaceNode->oldDirtyInSurface_ = rect;
2597 surfaceNode->GetDirtyManager()->MergeDirtyRect(rect);
2598
2599 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2600 ASSERT_NE(rsUniRenderVisitor, nullptr);
2601 rsUniRenderVisitor->CalcDirtyDisplayRegion(displayNode);
2602 ASSERT_EQ(displayNode->GetDirtyManager()->GetCurrentFrameDirtyRegion(), rect);
2603 }
2604
2605 /*
2606 * @tc.name: UpdateHardwareNodeStatusBasedOnFilter001
2607 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareNodeStatusBasedOnFilter while
2608 * prevHwcEnabledNodes first node's rect intersect app window node's is empty
2609 * @tc.type: FUNC
2610 * @tc.require: issuesI7T9RE
2611 */
2612 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareNodeStatusBasedOnFilter001, TestSize.Level2)
2613 {
2614 NodeId id = 0;
2615 RSDisplayNodeConfig config;
2616 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2617 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2618 auto childNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2619 ASSERT_NE(displayNode, nullptr);
2620 ASSERT_NE(appWindowNode, nullptr);
2621 ASSERT_NE(childNode, nullptr);
2622 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2623 appWindowNode->AddChildHardwareEnabledNode(childNode);
2624 auto dirtyManager = displayNode->GetDirtyManager();
2625
2626 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>,
2627 std::shared_ptr<RSSurfaceRenderNode>>;
2628 vector<SurfaceDirtyMgrPair> prevHwcEnabledNodes;
2629 auto firstNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2630 auto secondNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2631 ASSERT_NE(firstNode, nullptr);
2632 ASSERT_NE(secondNode, nullptr);
2633 prevHwcEnabledNodes.push_back({firstNode, secondNode});
2634
2635 appWindowNode->visibleRegion_ =
2636 Occlusion::Rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2637 RectI rect=RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2638 childNode->oldDirtyInSurface_ = rect;
2639
2640 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2641 ASSERT_NE(rsUniRenderVisitor, nullptr);
2642 rsUniRenderVisitor->UpdateHardwareNodeStatusBasedOnFilter(appWindowNode,
2643 prevHwcEnabledNodes, dirtyManager);
2644 ASSERT_NE(prevHwcEnabledNodes.size(), 1);
2645 }
2646
2647 /*
2648 * @tc.name: UpdateHardwareNodeStatusBasedOnFilter002
2649 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHardwareNodeStatusBasedOnFilter while
2650 * prevHwcEnabledNodes first node's rect intersect app window node's isn't empty
2651 * @tc.type: FUNC
2652 * @tc.require: issuesI7T9RE
2653 */
2654 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareNodeStatusBasedOnFilter002, TestSize.Level2)
2655 {NodeId id = 0;
2656 RSDisplayNodeConfig config;
2657 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2658 auto appWindowNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2659 auto childNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2660 ASSERT_NE(displayNode, nullptr);
2661 ASSERT_NE(appWindowNode, nullptr);
2662 ASSERT_NE(childNode, nullptr);
2663 appWindowNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
2664 appWindowNode->AddChildHardwareEnabledNode(childNode);
2665 auto dirtyManager = displayNode->GetDirtyManager();
2666
2667 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>,
2668 std::shared_ptr<RSSurfaceRenderNode>>;
2669 vector<SurfaceDirtyMgrPair> prevHwcEnabledNodes;
2670 auto firstNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2671 auto secondNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2672 ASSERT_NE(firstNode, nullptr);
2673 ASSERT_NE(secondNode, nullptr);
2674 prevHwcEnabledNodes.push_back({firstNode, secondNode});
2675
2676 appWindowNode->visibleRegion_ =
2677 Occlusion::Rect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2678 RectI rect=RectI(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2679 childNode->oldDirtyInSurface_ = rect;
2680 childNode->SetDstRect(rect);
2681 firstNode->SetDstRect(rect);
2682
2683 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2684 ASSERT_NE(rsUniRenderVisitor, nullptr);
2685 rsUniRenderVisitor->UpdateHardwareNodeStatusBasedOnFilter(appWindowNode,
2686 prevHwcEnabledNodes, dirtyManager);
2687 ASSERT_EQ(prevHwcEnabledNodes.size(), 1);
2688 }
2689
2690 /**
2691 * @tc.name: UpdateSubTreeInCache001
2692 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSubTreeInCache while
2693 * node doesn't have Child
2694 * @tc.type: FUNC
2695 * @tc.require: issueI7UGLR
2696 */
2697 HWTEST_F(RSUniRenderVisitorTest, UpdateSubTreeInCache001, TestSize.Level2)
2698 {
2699 NodeId id = 0;
2700 auto node = std::make_shared<RSRenderNode>(id);
2701
2702 ASSERT_NE(node, nullptr);
2703 node->InitRenderParams();
2704 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2705 ASSERT_NE(rsUniRenderVisitor, nullptr);
2706 rsUniRenderVisitor->UpdateSubTreeInCache(node, *node->GetSortedChildren());
2707 ASSERT_EQ(node->GetDrawingCacheChanged(), false);
2708 }
2709
2710 /**
2711 * @tc.name: UpdateSubTreeInCache002
2712 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSubTreeInCache while
2713 * node has Child
2714 * @tc.type: FUNC
2715 * @tc.require: issueI7UGLR
2716 */
2717 HWTEST_F(RSUniRenderVisitorTest, UpdateSubTreeInCache002, TestSize.Level2)
2718 {
2719 NodeId id = 0;
2720 auto node = std::make_shared<RSRenderNode>(id);
2721 ASSERT_NE(node, nullptr);
2722 node->InitRenderParams();
2723 NodeId id2 = 1;
2724 auto child = std::make_shared<RSRenderNode>(id2);
2725 ASSERT_NE(child, nullptr);
2726
2727 node->AddChild(child);
2728 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2729 ASSERT_NE(rsUniRenderVisitor, nullptr);
2730 rsUniRenderVisitor->UpdateSubTreeInCache(node, *node->GetSortedChildren());
2731 ASSERT_EQ(node->GetDrawingCacheChanged(), false);
2732 }
2733
2734
2735 /**
2736 * @tc.name: DrawTargetSurfaceVisibleRegionForDFX001
2737 * @tc.desc: Test RSUniRenderVisitorTest.DrawTargetSurfaceVisibleRegionForDFX while
2738 * RSDisplayRenderNode is the same as displafConfig set
2739 * @tc.type: FUNC
2740 * @tc.require: issueI7UGLR
2741 */
2742 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceVisibleRegionForDFX001, TestSize.Level2)
2743 {
2744 RSDisplayNodeConfig displayConfig;
2745 auto rsContext = std::make_shared<RSContext>();
2746 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
2747 ASSERT_NE(rsDisplayRenderNode, nullptr);
2748 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
2749 ASSERT_NE(surfaceNode, nullptr);
2750 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2751 rsDisplayRenderNode->GetCurAllSurfaces().push_back(surfaceNode);
2752 rsDisplayRenderNode->GetCurAllSurfaces().push_back(nullptr);
2753
2754 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2755 ASSERT_NE(rsUniRenderVisitor, nullptr);
2756 rsUniRenderVisitor->dfxTargetSurfaceNames_.emplace_back(surfaceNode->GetName());
2757 Occlusion::Rect rect{0, 0, 0, 0};
2758 Occlusion::Region region{rect};
2759 surfaceNode->visibleRegion_ = region;
2760 rsUniRenderVisitor->DrawTargetSurfaceVisibleRegionForDFX(*rsDisplayRenderNode);
2761 }
2762
2763 /**
2764 * @tc.name: DrawCurrentRefreshRate001
2765 * @tc.desc: Test RSUniRenderVisitorTest.DrawCurrentRefreshRate while
2766 * currentRefreshRate is equal to 0
2767 * @tc.type: FUNC
2768 * @tc.require: issueI7UGLR
2769 */
2770 HWTEST_F(RSUniRenderVisitorTest, DrawCurrentRefreshRate001, TestSize.Level2)
2771 {
2772 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2773
2774 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2775 ASSERT_NE(rsUniRenderVisitor, nullptr);
2776
2777 RSDisplayNodeConfig displayConfig;
2778 auto rsContext = std::make_shared<RSContext>();
2779 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
2780 ASSERT_NE(rsDisplayRenderNode, nullptr);
2781
2782 ASSERT_NE(drawingCanvas, nullptr);
2783 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
2784 rsUniRenderVisitor->DrawCurrentRefreshRate(0, 0, *rsDisplayRenderNode);
2785 }
2786
2787
2788 /**
2789 * @tc.name: ProcessChildrenForScreenRecordingOptimization001
2790 * @tc.desc: Test RSUniRenderVisitorTest.ProcessChildrenForScreenRecordingOptimization while
2791 * isSubThread_ is equal to false
2792 * @tc.type: FUNC
2793 * @tc.require: issueI7UGLR
2794 */
2795 HWTEST_F(RSUniRenderVisitorTest, ProcessChildrenForScreenRecordingOptimization001, TestSize.Level2)
2796 {
2797 NodeId id = 0;
2798 RSDisplayNodeConfig displayConfig;
2799 auto rsContext = std::make_shared<RSContext>();
2800 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
2801 ASSERT_NE(rsDisplayRenderNode, nullptr);
2802
2803 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2804 ASSERT_NE(rsUniRenderVisitor, nullptr);
2805 rsUniRenderVisitor->ProcessChildrenForScreenRecordingOptimization(*rsDisplayRenderNode, id);
2806 }
2807
2808 /**
2809 * @tc.name: ProcessChildrenForScreenRecordingOptimization002
2810 * @tc.desc: Test RSUniRenderVisitorTest.ProcessChildrenForScreenRecordingOptimization while
2811 * isSubThread_ is equal to true
2812 * @tc.type: FUNC
2813 * @tc.require: issueI7UGLR
2814 */
2815 HWTEST_F(RSUniRenderVisitorTest, ProcessChildrenForScreenRecordingOptimization002, TestSize.Level2)
2816 {
2817 NodeId id = 0;
2818 RSDisplayNodeConfig displayConfig;
2819 auto rsContext = std::make_shared<RSContext>();
2820 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(20, displayConfig, rsContext->weak_from_this());
2821 ASSERT_NE(rsDisplayRenderNode, nullptr);
2822
2823 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2824 rsUniRenderVisitor->isSubThread_ = true;
2825 ASSERT_NE(rsUniRenderVisitor, nullptr);
2826 rsUniRenderVisitor->ProcessChildrenForScreenRecordingOptimization(*rsDisplayRenderNode, id);
2827 }
2828
2829 /**
2830 * @tc.name: ProcessChildInner001
2831 * @tc.desc: Test RSUniRenderVisitorTest.ProcessChildInner while
2832 * node has child
2833 * @tc.type: FUNC
2834 * @tc.require: issueI7UGLR
2835 */
2836 HWTEST_F(RSUniRenderVisitorTest, ProcessChildInner001, TestSize.Level2)
2837 {
2838 NodeId id = 0;
2839 NodeId id2 = 1;
2840 RSRenderNode *node = new RSRenderNode(id2);
2841 auto child = std::make_shared<RSRenderNode>(id);
2842 ASSERT_NE(child, nullptr);
2843
2844 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2845 ASSERT_NE(rsUniRenderVisitor, nullptr);
2846 rsUniRenderVisitor->ProcessChildInner(*node, child);
2847 }
2848
2849 /**
2850 * @tc.name: SwitchColorFilterDrawing001
2851 * @tc.desc: Test RSUniRenderVisitorTest.SwitchColorFilterDrawing while
2852 * currentSaveCount == 0
2853 * @tc.type: FUNC
2854 * @tc.require: issueI7UGLR
2855 */
2856 HWTEST_F(RSUniRenderVisitorTest, SwitchColorFilterDrawing001, TestSize.Level2)
2857 {
2858 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2859 ASSERT_NE(rsUniRenderVisitor, nullptr);
2860 rsUniRenderVisitor->SwitchColorFilterDrawing(0);
2861 }
2862
2863 /**
2864 * @tc.name: FindInstanceChildOfDisplay001
2865 * @tc.desc: Test FindInstanceChildOfDisplay while node is nullptr
2866 * @tc.type: FUNC
2867 * @tc.require: issueI904G4
2868 */
2869 HWTEST_F(RSUniRenderVisitorTest, FindInstanceChildOfDisplay001, TestSize.Level2)
2870 {
2871 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2872 ASSERT_NE(rsUniRenderVisitor, nullptr);
2873 ASSERT_EQ(rsUniRenderVisitor->FindInstanceChildOfDisplay(nullptr), INVALID_NODEID);
2874 }
2875
2876 /**
2877 * @tc.name: FindInstanceChildOfDisplay002
2878 * @tc.desc: Test FindInstanceChildOfDisplay while node's parent is nullptr
2879 * @tc.type: FUNC
2880 * @tc.require: issueI904G4
2881 */
2882 HWTEST_F(RSUniRenderVisitorTest, FindInstanceChildOfDisplay002, TestSize.Level2)
2883 {
2884 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2885 ASSERT_NE(surfaceNode, nullptr);
2886 surfaceNode->GetParent().reset();
2887
2888 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2889 ASSERT_NE(rsUniRenderVisitor, nullptr);
2890 ASSERT_EQ(rsUniRenderVisitor->FindInstanceChildOfDisplay(surfaceNode), INVALID_NODEID);
2891 }
2892
2893 /**
2894 * @tc.name: FindInstanceChildOfDisplay003
2895 * @tc.desc: Test FindInstanceChildOfDisplay while node's parent is display node
2896 * @tc.type: FUNC
2897 * @tc.require: issueI904G4
2898 */
2899 HWTEST_F(RSUniRenderVisitorTest, FindInstanceChildOfDisplay003, TestSize.Level2)
2900 {
2901 NodeId id = 0;
2902 RSDisplayNodeConfig config;
2903 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2904 ASSERT_NE(displayNode, nullptr);
2905 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2906 ASSERT_NE(surfaceNode, nullptr);
2907 displayNode->AddChild(surfaceNode);
2908
2909 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2910 ASSERT_NE(rsUniRenderVisitor, nullptr);
2911 ASSERT_EQ(rsUniRenderVisitor->FindInstanceChildOfDisplay(surfaceNode), surfaceNode->GetId());
2912 }
2913
2914 /**
2915 * @tc.name: FindInstanceChildOfDisplay004
2916 * @tc.desc: Test FindInstanceChildOfDisplay while node's parent isn't display node
2917 * @tc.type: FUNC
2918 * @tc.require: issueI904G4
2919 */
2920 HWTEST_F(RSUniRenderVisitorTest, FindInstanceChildOfDisplay004, TestSize.Level2)
2921 {
2922 RSDisplayNodeConfig config;
2923 NodeId id = 0;
2924 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, config);
2925 auto canvasNode = std::make_shared<RSCanvasRenderNode>(id++);
2926 auto surfaceNode = RSTestUtil::CreateSurfaceNodeWithBuffer();
2927 ASSERT_NE(displayNode, nullptr);
2928 ASSERT_NE(canvasNode, nullptr);
2929 ASSERT_NE(surfaceNode, nullptr);
2930
2931 displayNode->AddChild(canvasNode);
2932 canvasNode->AddChild(surfaceNode);
2933
2934 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2935 ASSERT_NE(rsUniRenderVisitor, nullptr);
2936 ASSERT_EQ(rsUniRenderVisitor->FindInstanceChildOfDisplay(surfaceNode), canvasNode->GetId());
2937 }
2938
2939 /**
2940 * @tc.name: CheckIfNeedResetRotate001
2941 * @tc.desc: Test CheckIfNeedResetRotate while canvas is null
2942 * @tc.type: FUNC
2943 * @tc.require: issueI981R9
2944 */
2945 HWTEST_F(RSUniRenderVisitorTest, CheckIfNeedResetRotate001, TestSize.Level2)
2946 {
2947 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2948 ASSERT_NE(rsUniRenderVisitor, nullptr);
2949
2950 rsUniRenderVisitor->canvas_ = nullptr;
2951 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
2952 }
2953
2954 /**
2955 * @tc.name: CheckIfNeedResetRotate002
2956 * @tc.desc: Test CheckIfNeedResetRotate for different rotate degree in canvas
2957 * @tc.type: FUNC
2958 * @tc.require: issueI981R9
2959 */
2960 HWTEST_F(RSUniRenderVisitorTest, CheckIfNeedResetRotate002, TestSize.Level2)
2961 {
2962 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2963 ASSERT_NE(rsUniRenderVisitor, nullptr);
2964 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2965 ASSERT_NE(drawingCanvas, nullptr);
2966 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
2967
2968 // canvas rotate degree = 0
2969 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), false);
2970 // canvas rotate degree = 90
2971 rsUniRenderVisitor->canvas_->Rotate(ROTATION_90, 0, 0);
2972 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
2973 // canvas rotate degree = 180
2974 rsUniRenderVisitor->canvas_->Rotate(ROTATION_90, 0, 0);
2975 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
2976 // canvas rotate degree = 270
2977 rsUniRenderVisitor->canvas_->Rotate(ROTATION_90, 0, 0);
2978 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
2979 // canvas rotate degree = 360
2980 rsUniRenderVisitor->canvas_->Rotate(ROTATION_90, 0, 0);
2981 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), false);
2982 }
2983
2984 /**
2985 * @tc.name: CheckIfNeedResetRotate003
2986 * @tc.desc: Test CheckIfNeedResetRotate for different rotate degree in display node
2987 * @tc.type: FUNC
2988 * @tc.require: issueI981R9
2989 */
2990 HWTEST_F(RSUniRenderVisitorTest, CheckIfNeedResetRotate003, TestSize.Level2)
2991 {
2992 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
2993 ASSERT_NE(rsUniRenderVisitor, nullptr);
2994 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
2995 ASSERT_NE(drawingCanvas, nullptr);
2996 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
2997
2998 // display node rotate degree = 0
2999 rsUniRenderVisitor->displayNodeMatrix_ = Drawing::Matrix();
3000 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), false);
3001 // display node rotate degree = 90
3002 rsUniRenderVisitor->displayNodeMatrix_.value().PostRotate(ROTATION_90, 0, 0);
3003 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
3004 // display node rotate degree = 180
3005 rsUniRenderVisitor->displayNodeMatrix_.value().PostRotate(ROTATION_90, 0, 0);
3006 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
3007 // display node rotate degree = 270
3008 rsUniRenderVisitor->displayNodeMatrix_.value().PostRotate(ROTATION_90, 0, 0);
3009 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
3010 // display node rotate degree = 360
3011 rsUniRenderVisitor->displayNodeMatrix_.value().PostRotate(ROTATION_90, 0, 0);
3012 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), false);
3013 }
3014
3015 /**
3016 * @tc.name: CheckIfNeedResetRotate004
3017 * @tc.desc: Test CheckIfNeedResetRotate for different rotate degree in canvas and display node
3018 * @tc.type: FUNC
3019 * @tc.require: issueI981R9
3020 */
3021 HWTEST_F(RSUniRenderVisitorTest, CheckIfNeedResetRotate004, TestSize.Level2)
3022 {
3023 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3024 ASSERT_NE(rsUniRenderVisitor, nullptr);
3025 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3026 ASSERT_NE(drawingCanvas, nullptr);
3027 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
3028
3029 // canvas rotate degree = 90
3030 rsUniRenderVisitor->canvas_->Rotate(ROTATION_90, 0, 0);
3031
3032 // display node rotate degree = 0
3033 rsUniRenderVisitor->displayNodeMatrix_ = Drawing::Matrix();
3034 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
3035 // display node rotate degree = 90
3036 rsUniRenderVisitor->displayNodeMatrix_.value().PostRotate(ROTATION_90, 0, 0);
3037 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
3038 // display node rotate degree = 180
3039 rsUniRenderVisitor->displayNodeMatrix_.value().PostRotate(ROTATION_90, 0, 0);
3040 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), true);
3041 // display node rotate degree = 270
3042 rsUniRenderVisitor->displayNodeMatrix_.value().PostRotate(ROTATION_90, 0, 0);
3043 ASSERT_EQ(rsUniRenderVisitor->CheckIfNeedResetRotate(), false);
3044 }
3045
3046 /**
3047 * @tc.name: DrawEffectRenderNodeForDFX001
3048 * @tc.desc: Test RSUniRenderVisitorTest.DrawEffectRenderNodeForDFX while
3049 * rect map is empty.
3050 * @tc.type: FUNC
3051 * @tc.require: issueI8WJXC
3052 */
3053 HWTEST_F(RSUniRenderVisitorTest, DrawEffectRenderNodeForDFX001, TestSize.Level2)
3054 {
3055 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3056 ASSERT_NE(rsUniRenderVisitor, nullptr);
3057 rsUniRenderVisitor->DrawEffectRenderNodeForDFX();
3058 }
3059
3060 /**
3061 * @tc.name: ProcessShadowFirst001
3062 * @tc.desc: Test RSUniRenderVisitorTest.ProcessShadowFirst while SetUseShadowBatching true.
3063 * @tc.type:FUNC
3064 * @tc.require:issueI8WJXC
3065 */
3066 HWTEST_F(RSUniRenderVisitorTest, ProcessShadowFirst001, TestSize.Level1)
3067 {
3068 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3069 ASSERT_NE(rsUniRenderVisitor, nullptr);
3070
3071 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3072 ASSERT_NE(drawingCanvas, nullptr);
3073 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
3074
3075 NodeId id = 0;
3076 auto node = std::make_shared<RSCanvasRenderNode>(id);
3077 ASSERT_NE(node, nullptr);
3078 node->InitRenderParams();
3079 NodeId id1 = 1;
3080 auto child1 = std::make_shared<RSCanvasRenderNode>(id1);
3081 ASSERT_NE(child1, nullptr);
3082 NodeId id2 = 2;
3083 auto child2 = std::make_shared<RSCanvasRenderNode>(id2);
3084 ASSERT_NE(child2, nullptr);
3085 node->AddChild(child1);
3086 node->AddChild(child2);
3087
3088 auto& prop1 = child1->GetMutableRenderProperties();
3089 prop1.SetShadowRadius(100.0);
3090
3091 auto& prop2 = child2->GetMutableRenderProperties();
3092 prop2.SetShadowRadius(100.0);
3093
3094 auto& property = node->GetMutableRenderProperties();
3095 property.SetUseShadowBatching(true);
3096 const auto& prop = node->GetRenderProperties();
3097 ASSERT_TRUE(prop.GetUseShadowBatching());
3098 rsUniRenderVisitor->ProcessShadowFirst(*node, true);
3099 }
3100
3101 /**
3102 * @tc.name: UpdateSubTreeInCache003
3103 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSubTreeInCache, with diffrent children type
3104 * @tc.type: FUNC
3105 * @tc.require: issueI7UGLR
3106 */
3107 HWTEST_F(RSUniRenderVisitorTest, UpdateSubTreeInCache003, TestSize.Level2)
3108 {
3109 NodeId id = 0;
3110 auto node = std::make_shared<RSRenderNode>(id);
3111 node->InitRenderParams();
3112 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3113 ASSERT_NE(rsUniRenderVisitor, nullptr);
3114 // prepare child lists
3115 auto child1 = std::make_shared<RSSurfaceRenderNode>(++id);
3116 auto child2 = std::make_shared<RSEffectRenderNode>(++id);
3117 std::shared_ptr<RSRenderNode> child3 = nullptr;
3118 std::vector<RSRenderNode::SharedPtr> children;
3119 children.push_back(child1);
3120 children.push_back(child2);
3121 children.push_back(child3);
3122 rsUniRenderVisitor->UpdateSubTreeInCache(node, *node->GetSortedChildren());
3123 }
3124
3125 /**
3126 * @tc.name: PrepareEffectNodeIfCacheReuse001
3127 * @tc.desc: Test PrepareEffectNodeIfCacheReuse, effectNode nullptr
3128 * @tc.type: FUNC
3129 * @tc.require: issueI7UGLR
3130 */
3131 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectNodeIfCacheReuse001, TestSize.Level2)
3132 {
3133 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3134 ASSERT_NE(rsUniRenderVisitor, nullptr);
3135 RSDisplayNodeConfig displayConfig;
3136 auto rsContext = std::make_shared<RSContext>();
3137 NodeId id = 1;
3138 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(++id,
3139 displayConfig, rsContext->weak_from_this());
3140 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
3141 // prepare node
3142 auto node = std::make_shared<RSRenderNode>(++id);
3143 node->InitRenderParams();
3144 std::shared_ptr<RSEffectRenderNode> effectNode = nullptr;
3145 rsUniRenderVisitor->PrepareEffectNodeIfCacheReuse(node, effectNode);
3146 }
3147
3148 /**
3149 * @tc.name: PrepareEffectNodeIfCacheReuse002
3150 * @tc.desc: Test RSUniRenderVisitorTest.PrepareEffectNodeIfCacheReuse002, with dirty manager
3151 * @tc.type: FUNC
3152 * @tc.require: issueI7UGLR
3153 */
3154 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectNodeIfCacheReuse002, TestSize.Level2)
3155 {
3156 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3157 ASSERT_NE(rsUniRenderVisitor, nullptr);
3158 RSDisplayNodeConfig displayConfig;
3159 auto rsContext = std::make_shared<RSContext>();
3160 NodeId id = 1;
3161 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(++id,
3162 displayConfig, rsContext->weak_from_this());
3163 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
3164 // prepare node
3165 auto node = std::make_shared<RSRenderNode>(++id);
3166 node->InitRenderParams();
3167 rsUniRenderVisitor->curSurfaceDirtyManager_ = std::make_shared<RSDirtyRegionManager>();
3168 auto effectNode = std::make_shared<RSEffectRenderNode>(++id);
3169 rsUniRenderVisitor->PrepareEffectNodeIfCacheReuse(node, effectNode);
3170 }
3171
3172 /**
3173 * @tc.name: PrepareEffectNodeIfCacheReuse003
3174 * @tc.desc: Test RSUniRenderVisitorTest.PrepareEffectNodeIfCacheReuse003, needFilter_ equals true
3175 * @tc.type: FUNC
3176 * @tc.require: issueI7UGLR
3177 */
3178 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectNodeIfCacheReuse003, TestSize.Level2)
3179 {
3180 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3181 ASSERT_NE(rsUniRenderVisitor, nullptr);
3182 RSDisplayNodeConfig displayConfig;
3183 auto rsContext = std::make_shared<RSContext>();
3184 NodeId id = 1;
3185 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(++id,
3186 displayConfig, rsContext->weak_from_this());
3187 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
3188 // prepare node
3189 auto node = std::make_shared<RSRenderNode>(++id);
3190 node->InitRenderParams();
3191 rsUniRenderVisitor->curSurfaceDirtyManager_ = std::make_shared<RSDirtyRegionManager>();
3192 auto effectNode = std::make_shared<RSEffectRenderNode>(++id);
3193 effectNode->GetMutableRenderProperties().needFilter_ = true;
3194 rsUniRenderVisitor->PrepareEffectNodeIfCacheReuse(node, effectNode);
3195 }
3196
3197 /**
3198 * @tc.name: PrepareEffectNodeIfCacheReuse004
3199 * @tc.desc: Test RSUniRenderVisitorTest.PrepareEffectNodeIfCacheReuse004
3200 * curSurfaceNode_->GetId() equals effectNode->GetInstanceRootNodeId()
3201 * @tc.type: FUNC
3202 * @tc.require: issueI7UGLR
3203 */
3204 HWTEST_F(RSUniRenderVisitorTest, PrepareEffectNodeIfCacheReuse004, TestSize.Level2)
3205 {
3206 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3207 ASSERT_NE(rsUniRenderVisitor, nullptr);
3208 RSDisplayNodeConfig displayConfig;
3209 auto rsContext = std::make_shared<RSContext>();
3210 NodeId id = 1;
3211 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(++id,
3212 displayConfig, rsContext->weak_from_this());
3213 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
3214 // prepare node
3215 auto node = std::make_shared<RSRenderNode>(++id);
3216 node->InitRenderParams();
3217 rsUniRenderVisitor->curSurfaceDirtyManager_ = std::make_shared<RSDirtyRegionManager>();
3218 auto effectNode = std::make_shared<RSEffectRenderNode>(++id);
3219 effectNode->GetMutableRenderProperties().needFilter_ = true;
3220 id = 0x0FFF;
3221 effectNode->instanceRootNodeId_ = id;
3222 rsUniRenderVisitor->curSurfaceNode_ = std::make_shared<RSSurfaceRenderNode>(id);
3223 rsUniRenderVisitor->PrepareEffectNodeIfCacheReuse(node, effectNode);
3224 }
3225
3226 /**
3227 * @tc.name: DisableNodeCacheInSetting001
3228 * @tc.desc: Test RSUniRenderVisitorTest.DisableNodeCacheInSetting001
3229 * @tc.type: FUNC
3230 * @tc.require: issueI7UGLR
3231 */
3232 HWTEST_F(RSUniRenderVisitorTest, DisableNodeCacheInSetting001, TestSize.Level2)
3233 {
3234 NodeId id = 0;
3235 auto node = std::make_shared<RSRenderNode>(id);
3236 node->InitRenderParams();
3237 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3238 ASSERT_NE(rsUniRenderVisitor, nullptr);
3239 rsUniRenderVisitor->DisableNodeCacheInSetting(*node);
3240 }
3241
3242 /**
3243 * @tc.name: DisableNodeCacheInSetting002
3244 * @tc.desc: Test RSUniRenderVisitorTest.DisableNodeCacheInSetting002, TARGETED_CACHE
3245 * @tc.type: FUNC
3246 * @tc.require: issueI7UGLR
3247 */
3248 HWTEST_F(RSUniRenderVisitorTest, DisableNodeCacheInSetting002, TestSize.Level2)
3249 {
3250 NodeId id = 0;
3251 auto node = std::make_shared<RSRenderNode>(id);
3252 node->InitRenderParams();
3253 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3254 ASSERT_NE(rsUniRenderVisitor, nullptr);
3255 node->drawingCacheType_ = RSDrawingCacheType::TARGETED_CACHE;
3256 rsUniRenderVisitor->DisableNodeCacheInSetting(*node);
3257 }
3258
3259 /**
3260 * @tc.name: DisableNodeCacheInSetting003
3261 * @tc.desc: Test RSUniRenderVisitorTest.DisableNodeCacheInSetting003
3262 * firstVisitedCache_ = INVALID_NODEID
3263 * @tc.type: FUNC
3264 * @tc.require: issueI7UGLR
3265 */
3266 HWTEST_F(RSUniRenderVisitorTest, DisableNodeCacheInSetting003, TestSize.Level2)
3267 {
3268 NodeId id = 0;
3269 auto node = std::make_shared<RSRenderNode>(id);
3270 node->InitRenderParams();
3271 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3272 ASSERT_NE(rsUniRenderVisitor, nullptr);
3273 rsUniRenderVisitor->firstVisitedCache_ = INVALID_NODEID;
3274 node->drawingCacheType_ = RSDrawingCacheType::TARGETED_CACHE;
3275 rsUniRenderVisitor->DisableNodeCacheInSetting(*node);
3276 }
3277
3278 /**
3279 * @tc.name: IsFirstVisitedCacheForced
3280 * @tc.desc: Test RSUniRenderVisitorTest.IsFirstVisitedCacheForced
3281 * @tc.type: FUNC
3282 * @tc.require: issueI7UGLR
3283 */
3284 HWTEST_F(RSUniRenderVisitorTest, IsFirstVisitedCacheForced, TestSize.Level2)
3285 {
3286 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3287 ASSERT_NE(rsUniRenderVisitor, nullptr);
3288 rsUniRenderVisitor->firstVisitedCache_ = INVALID_NODEID;
3289 ASSERT_FALSE(rsUniRenderVisitor->IsFirstVisitedCacheForced());
3290 rsUniRenderVisitor->firstVisitedCache_ = 1;
3291 ASSERT_FALSE(rsUniRenderVisitor->IsFirstVisitedCacheForced());
3292 }
3293
3294 /**
3295 * @tc.name: SaveCurSurface
3296 * @tc.desc: Test RSUniRenderVisitorTest.SaveCurSurface
3297 * @tc.type: FUNC
3298 * @tc.require: issueI7UGLR
3299 */
3300 HWTEST_F(RSUniRenderVisitorTest, SaveCurSurface, TestSize.Level2)
3301 {
3302 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3303 ASSERT_NE(rsUniRenderVisitor, nullptr);
3304 rsUniRenderVisitor->isSubSurfaceEnabled_ = true;
3305 rsUniRenderVisitor->curSurfaceDirtyManager_ = std::make_shared<RSDirtyRegionManager>();
3306 rsUniRenderVisitor->curSurfaceNode_ = std::make_shared<RSSurfaceRenderNode>(1);
3307 rsUniRenderVisitor->SaveCurSurface();
3308 }
3309
3310 /**
3311 * @tc.name: RestoreCurSurface
3312 * @tc.desc: Test RSUniRenderVisitorTest.RestoreCurSurface
3313 * @tc.type: FUNC
3314 * @tc.require: issueI7UGLR
3315 */
3316 HWTEST_F(RSUniRenderVisitorTest, RestoreCurSurface, TestSize.Level2)
3317 {
3318 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3319 ASSERT_NE(rsUniRenderVisitor, nullptr);
3320 rsUniRenderVisitor->isSubSurfaceEnabled_ = true;
3321 rsUniRenderVisitor->curSurfaceDirtyManager_ = std::make_shared<RSDirtyRegionManager>();
3322 rsUniRenderVisitor->curSurfaceNode_ = std::make_shared<RSSurfaceRenderNode>(1);
3323 rsUniRenderVisitor->SaveCurSurface();
3324 rsUniRenderVisitor->RestoreCurSurface();
3325 }
3326
3327 /**
3328 * @tc.name: PrepareSubSurfaceNodes
3329 * @tc.desc: Test RSUniRenderVisitorTest.PrepareSubSurfaceNodes
3330 * @tc.type: FUNC
3331 * @tc.require: issueI7UGLR
3332 */
3333 HWTEST_F(RSUniRenderVisitorTest, PrepareSubSurfaceNodes, TestSize.Level2)
3334 {
3335 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3336 ASSERT_NE(rsUniRenderVisitor, nullptr);
3337 rsUniRenderVisitor->isSubSurfaceEnabled_ = true;
3338 NodeId id = 1;
3339 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3340 node->InitRenderParams();
3341 std::vector<std::weak_ptr<RSRenderNode>> ptrs;
3342 id = 2;
3343 auto subNode1 = std::make_shared<RSSurfaceRenderNode>(id);
3344 RSDisplayNodeConfig config;
3345 id = 3;
3346 auto subNode2 = std::make_shared<RSDisplayRenderNode>(id, config);
3347 ptrs.push_back(subNode1);
3348 ptrs.push_back(subNode2);
3349 node->subSurfaceNodes_[1] = ptrs;
3350 rsUniRenderVisitor->PrepareSubSurfaceNodes(*node);
3351 }
3352
3353 /**
3354 * @tc.name: ProcessSubSurfaceNodes
3355 * @tc.desc: Test RSUniRenderVisitorTest.ProcessSubSurfaceNodes
3356 * @tc.type: FUNC
3357 * @tc.require: issueI7UGLR
3358 */
3359 HWTEST_F(RSUniRenderVisitorTest, ProcessSubSurfaceNodes, TestSize.Level2)
3360 {
3361 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3362 ASSERT_NE(rsUniRenderVisitor, nullptr);
3363 rsUniRenderVisitor->isSubSurfaceEnabled_ = true;
3364 NodeId id = 1;
3365 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3366 node->InitRenderParams();
3367 std::vector<std::weak_ptr<RSRenderNode>> ptrs;
3368 id = 2;
3369 auto subNode1 = std::make_shared<RSSurfaceRenderNode>(id);
3370 RSDisplayNodeConfig config;
3371 id = 3;
3372 auto subNode2 = std::make_shared<RSDisplayRenderNode>(id, config);
3373 ptrs.push_back(subNode1);
3374 ptrs.push_back(subNode2);
3375 node->subSurfaceNodes_[node->GetId()] = ptrs;
3376 rsUniRenderVisitor->ProcessSubSurfaceNodes(*node);
3377 }
3378
3379 /**
3380 * @tc.name: SetNodeCacheChangeStatus
3381 * @tc.desc: Test RSUniRenderVisitorTest.SetNodeCacheChangeStatus
3382 * node doesn't have Child
3383 * @tc.type: FUNC
3384 * @tc.require: issueI7UGLR
3385 */
3386 HWTEST_F(RSUniRenderVisitorTest, SetNodeCacheChangeStatus, TestSize.Level2)
3387 {
3388 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3389 ASSERT_NE(rsUniRenderVisitor, nullptr);
3390 NodeId id = 1;
3391 auto parent = std::make_shared<RSSurfaceRenderNode>(id);
3392 auto child = std::make_shared<RSSurfaceRenderNode>(++id);
3393 parent->InitRenderParams();
3394 child->InitRenderParams();
3395 parent->AddChild(child);
3396 child->SetChildHasVisibleFilter(true);
3397 rsUniRenderVisitor->isDrawingCacheEnabled_ = true;
3398 child->SetDrawingCacheType(RSDrawingCacheType::TARGETED_CACHE);
3399 rsUniRenderVisitor->curCacheFilterRects_.push({});
3400 rsUniRenderVisitor->SetNodeCacheChangeStatus(*child);
3401 }
3402
3403 /**
3404 * @tc.name: ClearTransparentBeforeSaveLayerTest002
3405 * @tc.desc: Test RSUniRenderVisitorTest.ClearTransparentBeforeSaveLayerTest002
3406 * @tc.type: FUNC
3407 * @tc.require: issueI7UGLR
3408 */
3409 HWTEST_F(RSUniRenderVisitorTest, ClearTransparentBeforeSaveLayerTest002, TestSize.Level2)
3410 {
3411 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3412 ASSERT_NE(rsUniRenderVisitor, nullptr);
3413 rsUniRenderVisitor->isHardwareForcedDisabled_ = false;
3414 NodeId id = 1;
3415 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3416 node->InitRenderParams();
3417 rsUniRenderVisitor->hardwareEnabledNodes_.push_back(node);
3418 rsUniRenderVisitor->ClearTransparentBeforeSaveLayer();
3419 }
3420
3421 /**
3422 * @tc.name: CheckIfUIFirstSurfaceContentReusable001
3423 * @tc.desc: Test CheckIfUIFirstSurfaceContentReusable001, nullptr
3424 * @tc.type: FUNC
3425 * @tc.require: issueI7UGLR
3426 */
3427 HWTEST_F(RSUniRenderVisitorTest, CheckIfUIFirstSurfaceContentReusable001, TestSize.Level2)
3428 {
3429 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3430 ASSERT_NE(rsUniRenderVisitor, nullptr);
3431 bool assigned = false;
3432 std::shared_ptr<RSSurfaceRenderNode> node = nullptr;
3433 rsUniRenderVisitor->CheckIfUIFirstSurfaceContentReusable(node, assigned);
3434 }
3435
3436 /**
3437 * @tc.name: CheckIfUIFirstSurfaceContentReusable002
3438 * @tc.desc: Test CheckIfUIFirstSurfaceContentReusable002, without UIFirst
3439 * @tc.type: FUNC
3440 * @tc.require: issueI7UGLR
3441 */
3442 HWTEST_F(RSUniRenderVisitorTest, CheckIfUIFirstSurfaceContentReusable002, TestSize.Level2)
3443 {
3444 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3445 ASSERT_NE(rsUniRenderVisitor, nullptr);
3446 rsUniRenderVisitor->isUIFirst_ = false;
3447 bool assigned = false;
3448 NodeId id = 1;
3449 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3450 node->InitRenderParams();
3451 rsUniRenderVisitor->CheckIfUIFirstSurfaceContentReusable(node, assigned);
3452 }
3453
3454 /**
3455 * @tc.name: PrepareTypesOfSurfaceRenderNodeAfterUpdate001
3456 * @tc.desc: Test PrepareTypesOfSurfaceRenderNodeAfterUpdate001
3457 * @tc.type: FUNC
3458 * @tc.require: issueI7UGLR
3459 */
3460 HWTEST_F(RSUniRenderVisitorTest, PrepareTypesOfSurfaceRenderNodeAfterUpdate001, TestSize.Level2)
3461 {
3462 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3463 ASSERT_NE(rsUniRenderVisitor, nullptr);
3464 NodeId id = 1;
3465 auto node = std::make_shared<RSSurfaceRenderNode>(id);
3466 node->InitRenderParams();
3467 rsUniRenderVisitor->PrepareTypesOfSurfaceRenderNodeAfterUpdate(*node);
3468 }
3469
3470 /**
3471 * @tc.name: PrepareTypesOfSurfaceRenderNodeAfterUpdate002
3472 * @tc.desc: Test PrepareTypesOfSurfaceRenderNodeAfterUpdate002, with non empty parent
3473 * @tc.type: FUNC
3474 * @tc.require: issueI7UGLR
3475 */
3476 HWTEST_F(RSUniRenderVisitorTest, PrepareTypesOfSurfaceRenderNodeAfterUpdate002, TestSize.Level2)
3477 {
3478 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3479 ASSERT_NE(rsUniRenderVisitor, nullptr);
3480 NodeId id = 1;
3481 auto parent = std::make_shared<RSSurfaceRenderNode>(id);
3482 auto child = std::make_shared<RSSurfaceRenderNode>(id+1);
3483 parent->InitRenderParams();
3484 child->InitRenderParams();
3485 parent->AddChild(child);
3486 child->GetMutableRenderProperties().needFilter_ = true;
3487 rsUniRenderVisitor->PrepareTypesOfSurfaceRenderNodeAfterUpdate(*child);
3488 }
3489
3490 /**
3491 * @tc.name: DrawTargetSurfaceVisibleRegionForDFX002
3492 * @tc.desc: Test DrawTargetSurfaceVisibleRegionForDFX, with non empty curAllSurfaces_
3493 * @tc.type: FUNC
3494 * @tc.require: issueI7UGLR
3495 */
3496 HWTEST_F(RSUniRenderVisitorTest, DrawTargetSurfaceVisibleRegionForDFX002, TestSize.Level2)
3497 {
3498 RSDisplayNodeConfig config;
3499 auto rsContext = std::make_shared<RSContext>();
3500 NodeId id = 1;
3501 auto node = std::make_shared<RSDisplayRenderNode>(id, config, rsContext->weak_from_this());
3502 node->InitRenderParams();
3503 // prepare curAllsurfaces_
3504 node->curAllSurfaces_.push_back(nullptr);
3505 auto node2 = RSTestUtil::CreateSurfaceNode();
3506 node2->InitRenderParams();
3507 node->curAllSurfaces_.push_back(node2);
3508 auto node3 = RSTestUtil::CreateSurfaceNode();
3509 node3->InitRenderParams();
3510 node3->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
3511 node->curAllSurfaces_.push_back(node3);
3512 // run
3513 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3514 ASSERT_NE(rsUniRenderVisitor, nullptr);
3515 rsUniRenderVisitor->DrawTargetSurfaceVisibleRegionForDFX(*node);
3516 }
3517
3518 /**
3519 * @tc.name: IsNotDirtyHardwareEnabledTopSurface
3520 * @tc.desc: Test IsNotDirtyHardwareEnabledTopSurface, SELF_DRAWING_WINDOW_NODE
3521 * @tc.type: FUNC
3522 * @tc.require: issueI7UGLR
3523 */
3524 HWTEST_F(RSUniRenderVisitorTest, IsNotDirtyHardwareEnabledTopSurface, TestSize.Level2)
3525 {
3526 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3527 ASSERT_NE(rsUniRenderVisitor, nullptr);
3528 auto node = RSTestUtil::CreateSurfaceNode();
3529 node->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
3530 node->name_ = "pointer window";
3531 // run
3532 rsUniRenderVisitor->IsNotDirtyHardwareEnabledTopSurface(node);
3533 }
3534
3535 /**
3536 * @tc.name: CalcChildFilterNodeDirtyRegion001
3537 * @tc.desc: Test CalcChildFilterNodeDirtyRegion, with two nullptr
3538 * @tc.type: FUNC
3539 * @tc.require: issueI7UGLR
3540 */
3541 HWTEST_F(RSUniRenderVisitorTest, CalcChildFilterNodeDirtyRegion001, TestSize.Level2)
3542 {
3543 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3544 ASSERT_NE(rsUniRenderVisitor, nullptr);
3545 std::shared_ptr<RSSurfaceRenderNode> node1 = nullptr;
3546 std::shared_ptr<RSDisplayRenderNode> node2 = nullptr;
3547 rsUniRenderVisitor->CalcChildFilterNodeDirtyRegion(node1, node2);
3548 }
3549
3550 /**
3551 * @tc.name: CalcChildFilterNodeDirtyRegion002
3552 * @tc.desc: Test CalcChildFilterNodeDirtyRegion, with two nullptr
3553 * @tc.type: FUNC
3554 * @tc.require: issueI7UGLR
3555 */
3556 HWTEST_F(RSUniRenderVisitorTest, CalcChildFilterNodeDirtyRegion002, TestSize.Level2)
3557 {
3558 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3559 ASSERT_NE(rsUniRenderVisitor, nullptr);
3560 RSSurfaceRenderNodeConfig surfaceConfig;
3561 RSDisplayNodeConfig displayConfig;
3562 surfaceConfig.id = 1;
3563 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
3564 surfaceNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
3565 RectI rect{0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT};
3566 surfaceNode->childrenFilterRects_.push_back(rect);
3567 NodeId id = 2;
3568 auto childNode = std::make_shared<RSRenderNode>(id);
3569 surfaceNode->AddChild(childNode);
3570 auto displayNode = std::make_shared<RSDisplayRenderNode>(++id, displayConfig);
3571 rsUniRenderVisitor->CalcChildFilterNodeDirtyRegion(surfaceNode, displayNode);
3572 }
3573
3574 /**
3575 * @tc.name: CalcSurfaceFilterNodeDirtyRegion001
3576 * @tc.desc: Test CalcChildFilterNodeDirtyRegion001, with nullptr
3577 * @tc.type: FUNC
3578 * @tc.require: issueI7UGLR
3579 */
3580 HWTEST_F(RSUniRenderVisitorTest, CalcSurfaceFilterNodeDirtyRegion001, TestSize.Level2)
3581 {
3582 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3583 ASSERT_NE(rsUniRenderVisitor, nullptr);
3584 std::shared_ptr<RSSurfaceRenderNode> node1 = nullptr;
3585 std::shared_ptr<RSDisplayRenderNode> node2 = nullptr;
3586 rsUniRenderVisitor->CalcSurfaceFilterNodeDirtyRegion(node1, node2);
3587 }
3588
3589 /**
3590 * @tc.name: CalcSurfaceFilterNodeDirtyRegion002
3591 * @tc.desc: Test CalcChildFilterNodeDirtyRegion002
3592 * @tc.type: FUNC
3593 * @tc.require: issueI7UGLR
3594 */
3595 HWTEST_F(RSUniRenderVisitorTest, CalcSurfaceFilterNodeDirtyRegion002, TestSize.Level2)
3596 {
3597 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3598 ASSERT_NE(rsUniRenderVisitor, nullptr);
3599 RSSurfaceRenderNodeConfig surfaceConfig;
3600 RSDisplayNodeConfig displayConfig;
3601 surfaceConfig.id = 1;
3602 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
3603 surfaceNode->GetMutableRenderProperties().needFilter_ = true;
3604 NodeId id = 2;
3605 auto displayNode = std::make_shared<RSDisplayRenderNode>(id, displayConfig);
3606 rsUniRenderVisitor->CalcSurfaceFilterNodeDirtyRegion(surfaceNode, displayNode);
3607 }
3608
3609 /**
3610 * @tc.name: SetHasSharedTransitionNode001
3611 * @tc.desc: Test SetHasSharedTransitionNode for leash window node
3612 * @tc.type: FUNC
3613 * @tc.require: issueI98VTC
3614 */
3615 HWTEST_F(RSUniRenderVisitorTest, SetHasSharedTransitionNode001, TestSize.Level2)
3616 {
3617 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
3618 ASSERT_NE(surfaceNode, nullptr);
3619 surfaceNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
3620
3621 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3622 ASSERT_NE(rsUniRenderVisitor, nullptr);
3623 rsUniRenderVisitor->SetHasSharedTransitionNode(*surfaceNode, true);
3624 ASSERT_FALSE(surfaceNode->GetHasSharedTransitionNode());
3625 }
3626
3627 /**
3628 * @tc.name: SetHasSharedTransitionNode002
3629 * @tc.desc: Test SetHasSharedTransitionNode for app window node
3630 * @tc.type: FUNC
3631 * @tc.require: issueI98VTC
3632 */
3633 HWTEST_F(RSUniRenderVisitorTest, SetHasSharedTransitionNode002, TestSize.Level2)
3634 {
3635 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
3636 ASSERT_NE(surfaceNode, nullptr);
3637 surfaceNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
3638
3639 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3640 ASSERT_NE(rsUniRenderVisitor, nullptr);
3641 rsUniRenderVisitor->SetHasSharedTransitionNode(*surfaceNode, true);
3642 ASSERT_TRUE(surfaceNode->GetHasSharedTransitionNode());
3643 }
3644
3645 /**
3646 * @tc.name: SetHasSharedTransitionNode003
3647 * @tc.desc: Test SetHasSharedTransitionNode while node's parent isn't leash window node
3648 * @tc.type: FUNC
3649 * @tc.require: issueI98VTC
3650 */
3651 HWTEST_F(RSUniRenderVisitorTest, SetHasSharedTransitionNode003, TestSize.Level2)
3652 {
3653 auto parentNode = RSTestUtil::CreateSurfaceNode();
3654 auto node = RSTestUtil::CreateSurfaceNode();
3655 ASSERT_NE(parentNode, nullptr);
3656 ASSERT_NE(node, nullptr);
3657 parentNode->AddChild(node);
3658
3659 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3660 ASSERT_NE(rsUniRenderVisitor, nullptr);
3661 rsUniRenderVisitor->SetHasSharedTransitionNode(*node, true);
3662 ASSERT_FALSE(parentNode->GetHasSharedTransitionNode());
3663 }
3664
3665 /**
3666 * @tc.name: SetHasSharedTransitionNode004
3667 * @tc.desc: Test SetHasSharedTransitionNode while node's parent is leash window node
3668 * @tc.type: FUNC
3669 * @tc.require: issueI98VTC
3670 */
3671 HWTEST_F(RSUniRenderVisitorTest, SetHasSharedTransitionNode004, TestSize.Level2)
3672 {
3673 auto parentNode = RSTestUtil::CreateSurfaceNode();
3674 auto node = RSTestUtil::CreateSurfaceNode();
3675 ASSERT_NE(parentNode, nullptr);
3676 ASSERT_NE(node, nullptr);
3677 parentNode->AddChild(node);
3678 parentNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
3679
3680 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3681 ASSERT_NE(rsUniRenderVisitor, nullptr);
3682 rsUniRenderVisitor->SetHasSharedTransitionNode(*node, true);
3683 ASSERT_TRUE(parentNode->GetHasSharedTransitionNode());
3684 }
3685
3686 /**
3687 * @tc.name: DrawCurtainScreen001
3688 * @tc.desc: Test DrawCurtainScreen while curtain screen is on
3689 * @tc.type: FUNC
3690 * @tc.require: issueI9ABGS
3691 */
3692 HWTEST_F(RSUniRenderVisitorTest, DrawCurtainScreen001, TestSize.Level2)
3693 {
3694 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3695 ASSERT_NE(rsUniRenderVisitor, nullptr);
3696 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3697 ASSERT_NE(drawingCanvas, nullptr);
3698
3699 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
3700 rsUniRenderVisitor->isCurtainScreenOn_ = true;
3701 rsUniRenderVisitor->DrawCurtainScreen();
3702 }
3703
3704 /**
3705 * @tc.name: DrawCurtainScreen002
3706 * @tc.desc: Test DrawCurtainScreen while curtain screen is off
3707 * @tc.type: FUNC
3708 * @tc.require: issueI9ABGS
3709 */
3710 HWTEST_F(RSUniRenderVisitorTest, DrawCurtainScreen002, TestSize.Level2)
3711 {
3712 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3713 ASSERT_NE(rsUniRenderVisitor, nullptr);
3714 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3715 ASSERT_NE(drawingCanvas, nullptr);
3716
3717 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
3718 rsUniRenderVisitor->isCurtainScreenOn_ = false;
3719 rsUniRenderVisitor->DrawCurtainScreen();
3720 }
3721
3722 /**
3723 * @tc.name: ClipRegion001
3724 * @tc.desc: Test ClipRegion, with empty region
3725 * @tc.type: FUNC
3726 * @tc.require: issueI9ABGS
3727 */
3728 HWTEST_F(RSUniRenderVisitorTest, ClipRegion001, TestSize.Level2)
3729 {
3730 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3731 ASSERT_NE(rsUniRenderVisitor, nullptr);
3732 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3733 ASSERT_NE(drawingCanvas, nullptr);
3734 auto paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
3735 Drawing::Region region;
3736 rsUniRenderVisitor->ClipRegion(paintFilterCanvas, region);
3737 }
3738
3739 /**
3740 * @tc.name: ClipRegion002
3741 * @tc.desc: Test ClipRegion, with rect region
3742 * @tc.type: FUNC
3743 * @tc.require: issueI9ABGS
3744 */
3745 HWTEST_F(RSUniRenderVisitorTest, ClipRegion002, TestSize.Level2)
3746 {
3747 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3748 ASSERT_NE(rsUniRenderVisitor, nullptr);
3749 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3750 ASSERT_NE(drawingCanvas, nullptr);
3751 auto paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
3752
3753 Drawing::Region rectRegion;
3754 constexpr int rectWidth = 100;
3755 constexpr int rectHeight = 100;
3756 rectRegion.SetRect(Drawing::RectI(0, 0, rectWidth, rectHeight));
3757 Drawing::Region region;
3758 region.Op(rectRegion, Drawing::RegionOp::UNION);
3759
3760 rsUniRenderVisitor->ClipRegion(paintFilterCanvas, region);
3761 }
3762
3763 /**
3764 * @tc.name: ClipRegion003
3765 * @tc.desc: Test ClipRegion, with non-rect region
3766 * @tc.type: FUNC
3767 * @tc.require: issueI9ABGS
3768 */
3769 HWTEST_F(RSUniRenderVisitorTest, ClipRegion003, TestSize.Level2)
3770 {
3771 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3772 ASSERT_NE(rsUniRenderVisitor, nullptr);
3773 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
3774 ASSERT_NE(drawingCanvas, nullptr);
3775 auto paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
3776
3777 Drawing::Region region;
3778 Drawing::Region firstRectRegion;
3779 constexpr int firstRectWidth = 100;
3780 constexpr int firstRectHeight = 100;
3781 firstRectRegion.SetRect(Drawing::RectI(0, 0, firstRectWidth, firstRectHeight));
3782 region.Op(firstRectRegion, Drawing::RegionOp::UNION);
3783 Drawing::Region secondRectRegion;
3784 constexpr int secondRectWidth = 200;
3785 constexpr int secondRectHeight = 50;
3786 secondRectRegion.SetRect(Drawing::RectI(0, 0, secondRectWidth, secondRectHeight));
3787 region.Op(secondRectRegion, Drawing::RegionOp::UNION);
3788
3789 rsUniRenderVisitor->ClipRegion(paintFilterCanvas, region);
3790 }
3791
3792 /*
3793 * @tc.name: CheckMergeFilterDirtyByIntersectWithDirty001
3794 * @tc.desc: Test CheckMergeFilterDirtyByIntersectWithDirty
3795 * @tc.type: FUNC
3796 * @tc.require: issueIAO5GW
3797 */
3798 HWTEST_F(RSUniRenderVisitorTest, CheckMergeFilterDirtyByIntersectWithDirty001, TestSize.Level1)
3799 {
3800 auto rsContext = std::make_shared<RSContext>();
3801 RSDisplayNodeConfig displayConfig;
3802 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(DEFAULT_NODE_ID,
3803 displayConfig, rsContext->weak_from_this());
3804 ASSERT_NE(rsDisplayRenderNode, nullptr);
3805 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
3806 rsDisplayRenderNode->InitRenderParams();
3807 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3808 rsUniRenderVisitor->InitDisplayInfo(*rsDisplayRenderNode);
3809
3810 OcclusionRectISet filterSet;
3811 NodeId filterNodeId = DEFAULT_NODE_ID;
3812 // 1.filterSet not empty, currentFrameDirty empty
3813 filterSet.insert({filterNodeId, DEFAULT_RECT});
3814 rsUniRenderVisitor->CheckMergeFilterDirtyByIntersectWithDirty(filterSet, true);
3815 ASSERT_EQ(rsDisplayRenderNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty(), true);
3816
3817 // 2.filterSet not empty and intersect with currentFrameDirty dirty not changed after merge
3818 filterSet.insert({filterNodeId, DEFAULT_RECT});
3819 rsDisplayRenderNode->GetDirtyManager()->MergeDirtyRect(DEFAULT_RECT);
3820 rsUniRenderVisitor->CheckMergeFilterDirtyByIntersectWithDirty(filterSet, true);
3821 ASSERT_EQ(rsDisplayRenderNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty(), false);
3822
3823 // 3.filterSet not empty and intersect with currentFrameDirty, dirty changed after merge
3824 filterSet.insert({filterNodeId, DEFAULT_FILTER_RECT});
3825 rsUniRenderVisitor->CheckMergeFilterDirtyByIntersectWithDirty(filterSet, true);
3826 bool isRectEqual = (rsDisplayRenderNode->GetDirtyManager()->GetCurrentFrameDirtyRegion() == DEFAULT_RECT);
3827 ASSERT_EQ(isRectEqual, false);
3828 }
3829
3830 /*
3831 * @tc.name: CheckMergeSurfaceDirtysForDisplay001
3832 * @tc.desc: Test CheckMergeSurfaceDirtysForDisplay with transparent node
3833 * @tc.type: FUNC
3834 * @tc.require: issueI9RR2Y
3835 */
3836 HWTEST_F(RSUniRenderVisitorTest, CheckMergeSurfaceDirtysForDisplay001, TestSize.Level1)
3837 {
3838 auto rsContext = std::make_shared<RSContext>();
3839 RSSurfaceRenderNodeConfig config;
3840 RSDisplayNodeConfig displayConfig;
3841 config.id = 10; // 10 non-zero dummy configId
3842 auto rsCanvasRenderNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
3843 ASSERT_NE(rsCanvasRenderNode, nullptr);
3844 rsCanvasRenderNode->InitRenderParams();
3845 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
3846 ASSERT_NE(rsSurfaceRenderNode, nullptr);
3847 rsSurfaceRenderNode->InitRenderParams();
3848 // 11 non-zero node id
3849 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
3850 ASSERT_NE(rsDisplayRenderNode, nullptr);
3851 rsDisplayRenderNode->InitRenderParams();
3852 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3853
3854 // set surface to transparent, add a canvas node to create a transparent dirty region
3855 rsSurfaceRenderNode->SetAbilityBGAlpha(0);
3856 // 80, 2560, 1600. dummy value used to create rectangle with non-zero dimension
3857 rsSurfaceRenderNode->SetSrcRect(RectI(0, 80, 2560, 1600));
3858 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
3859 rsSurfaceRenderNode->AddChild(rsCanvasRenderNode, -1);
3860
3861 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
3862
3863 rsUniRenderVisitor->CheckMergeSurfaceDirtysForDisplay(rsSurfaceRenderNode);
3864 ASSERT_EQ(rsUniRenderVisitor->curDisplayDirtyManager_->dirtyRegion_.left_, 0);
3865 }
3866
3867
3868 /*
3869 * @tc.name: UpdateDisplayDirtyAndExtendVisibleRegion
3870 * @tc.desc: Test UpdateDisplayDirtyAndExtendVisibleRegion
3871 * @tc.type: FUNC
3872 * @tc.require: issueIAN75I
3873 */
3874 HWTEST_F(RSUniRenderVisitorTest, UpdateDisplayDirtyAndExtendVisibleRegion, TestSize.Level1)
3875 {
3876 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3877 rsUniRenderVisitor->UpdateDisplayDirtyAndExtendVisibleRegion();
3878
3879 RSDisplayNodeConfig displayConfig;
3880 auto rsContext = std::make_shared<RSContext>();
3881 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(5, displayConfig, rsContext->weak_from_this());
3882 ASSERT_NE(rsDisplayRenderNode, nullptr);
3883 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
3884 rsDisplayRenderNode->InitRenderParams();
3885 rsUniRenderVisitor->QuickPrepareDisplayRenderNode(*rsDisplayRenderNode);
3886 RSSurfaceRenderNodeConfig surfaceConfig;
3887 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
3888 ASSERT_NE(surfaceNode, nullptr);
3889 surfaceNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
3890 rsDisplayRenderNode->RecordMainAndLeashSurfaces(surfaceNode);
3891
3892 auto canvasNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
3893 ASSERT_NE(canvasNode, nullptr);
3894 auto& property = canvasNode->GetMutableRenderProperties();
3895 property.SetLightUpEffect(0.2f);
3896 property.UpdateFilter();
3897 surfaceNode->UpdateVisibleFilterChild(*canvasNode);
3898 auto visibleFilterChildren = surfaceNode->GetVisibleFilterChild();
3899 ASSERT_NE(visibleFilterChildren.size(), 0);
3900 rsUniRenderVisitor->UpdateDisplayDirtyAndExtendVisibleRegion();
3901
3902 auto& nodeMap = RSMainThread::Instance()->GetContext().GetMutableNodeMap();
3903 nodeMap.RegisterRenderNode(canvasNode);
3904 auto& filterNode = nodeMap.GetRenderNode<RSRenderNode>(canvasNode->GetId());
3905 ASSERT_NE(filterNode, nullptr);
3906 rsUniRenderVisitor->UpdateDisplayDirtyAndExtendVisibleRegion();
3907
3908 Occlusion::Region region{ Occlusion::Rect{ 0, 0, 100, 100 } };
3909 surfaceNode->SetVisibleRegion(region);
3910 canvasNode->SetOldDirtyInSurface({ 50, 50, 70, 70 });
3911 rsUniRenderVisitor->UpdateDisplayDirtyAndExtendVisibleRegion();
3912 }
3913
3914 /*
3915 * @tc.name: CheckMergeDisplayDirtyByTransparent001
3916 * @tc.desc: Test CheckMergeDisplayDirtyByTransparent with transparent node
3917 * @tc.type: FUNC
3918 * @tc.require: issueIAD6OW
3919 */
3920 HWTEST_F(RSUniRenderVisitorTest, CheckMergeDisplayDirtyByTransparent001, TestSize.Level1)
3921 {
3922 auto rsContext = std::make_shared<RSContext>();
3923 RSSurfaceRenderNodeConfig config;
3924 RSDisplayNodeConfig displayConfig;
3925 config.id = 10; // 10 non-zero dummy configId
3926 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
3927 ASSERT_NE(rsSurfaceRenderNode, nullptr);
3928 ASSERT_NE(rsSurfaceRenderNode->GetDirtyManager(), nullptr);
3929 rsSurfaceRenderNode->InitRenderParams();
3930 // 11 non-zero node id
3931 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
3932 ASSERT_NE(rsDisplayRenderNode, nullptr);
3933 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
3934 rsDisplayRenderNode->InitRenderParams();
3935 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
3936 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3937 rsUniRenderVisitor->curDisplayNode_ = rsDisplayRenderNode;
3938 // set surfaceNode to transparent, create a transparent dirty region
3939 rsSurfaceRenderNode->SetAbilityBGAlpha(0);
3940 rsSurfaceRenderNode->SetSrcRect(DEFAULT_RECT);
3941 rsSurfaceRenderNode->GetDirtyManager()->MergeDirtyRect(DEFAULT_RECT);
3942 rsSurfaceRenderNode->oldDirtyInSurface_ = DEFAULT_RECT;
3943
3944 rsUniRenderVisitor->CheckMergeDisplayDirtyByTransparent(*rsSurfaceRenderNode);
3945 ASSERT_EQ(rsDisplayRenderNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty(), false);
3946 }
3947
3948 /*
3949 * @tc.name: CheckMergeDisplayDirtyByZorderChanged001
3950 * @tc.desc: Test CheckMergeDisplayDirtyByZorderChanged with Z order change node
3951 * @tc.type: FUNC
3952 * @tc.require: issueIAD6OW
3953 */
3954 HWTEST_F(RSUniRenderVisitorTest, CheckMergeDisplayDirtyByZorderChanged001, TestSize.Level1)
3955 {
3956 auto rsContext = std::make_shared<RSContext>();
3957 RSSurfaceRenderNodeConfig config;
3958 RSDisplayNodeConfig displayConfig;
3959 config.id = 10; // 10 non-zero dummy configId
3960 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
3961 ASSERT_NE(rsSurfaceRenderNode, nullptr);
3962 ASSERT_NE(rsSurfaceRenderNode->GetDirtyManager(), nullptr);
3963 rsSurfaceRenderNode->InitRenderParams();
3964 // 11 non-zero node id
3965 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
3966 ASSERT_NE(rsDisplayRenderNode, nullptr);
3967 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
3968 rsDisplayRenderNode->InitRenderParams();
3969 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
3970 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
3971 rsUniRenderVisitor->curDisplayNode_ = rsDisplayRenderNode;
3972 // set surfaceNode Zorder change
3973 rsSurfaceRenderNode->zOrderChanged_ = true;
3974 rsSurfaceRenderNode->oldDirtyInSurface_ = DEFAULT_RECT;
3975
3976 rsUniRenderVisitor->CheckMergeDisplayDirtyByZorderChanged(*rsSurfaceRenderNode);
3977 ASSERT_EQ(rsDisplayRenderNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty(), false);
3978 }
3979
3980 /*
3981 * @tc.name: CheckMergeDisplayDirtyByPosChanged001
3982 * @tc.desc: Test CheckMergeDisplayDirtyByPosChanged with position change
3983 * @tc.type: FUNC
3984 * @tc.require: issueIAD6OW
3985 */
3986 HWTEST_F(RSUniRenderVisitorTest, CheckMergeDisplayDirtyByPosChanged001, TestSize.Level1)
3987 {
3988 auto rsContext = std::make_shared<RSContext>();
3989 RSSurfaceRenderNodeConfig config;
3990 RSDisplayNodeConfig displayConfig;
3991 config.id = 10; // 10 non-zero dummy configId
3992 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
3993 ASSERT_NE(rsSurfaceRenderNode, nullptr);
3994 ASSERT_NE(rsSurfaceRenderNode->GetDirtyManager(), nullptr);
3995 rsSurfaceRenderNode->InitRenderParams();
3996 // 11 non-zero node id
3997 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
3998 ASSERT_NE(rsDisplayRenderNode, nullptr);
3999 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
4000 rsDisplayRenderNode->InitRenderParams();
4001 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
4002 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4003 rsUniRenderVisitor->curDisplayNode_ = rsDisplayRenderNode;
4004 // set surfaceNode pos change
4005 rsDisplayRenderNode->UpdateSurfaceNodePos(config.id, RectI());
4006 rsDisplayRenderNode->ClearCurrentSurfacePos();
4007 rsDisplayRenderNode->UpdateSurfaceNodePos(config.id, DEFAULT_RECT);
4008
4009 rsUniRenderVisitor->CheckMergeDisplayDirtyByPosChanged(*rsSurfaceRenderNode);
4010 ASSERT_EQ(rsDisplayRenderNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty(), false);
4011 }
4012
4013 /*
4014 * @tc.name: CheckMergeDisplayDirtyByShadowChanged001
4015 * @tc.desc: Test CheckMergeDisplayDirtyByShadowChanged with shadow change
4016 * @tc.type: FUNC
4017 * @tc.require: issueIAD6OW
4018 */
4019 HWTEST_F(RSUniRenderVisitorTest, CheckMergeDisplayDirtyByShadowChanged001, TestSize.Level1)
4020 {
4021 auto rsContext = std::make_shared<RSContext>();
4022 RSSurfaceRenderNodeConfig config;
4023 RSDisplayNodeConfig displayConfig;
4024 config.id = 10; // 10 non-zero dummy configId
4025 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
4026 ASSERT_NE(rsSurfaceRenderNode, nullptr);
4027 ASSERT_NE(rsSurfaceRenderNode->GetDirtyManager(), nullptr);
4028 rsSurfaceRenderNode->InitRenderParams();
4029 // 11 non-zero node id
4030 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
4031 ASSERT_NE(rsDisplayRenderNode, nullptr);
4032 ASSERT_NE(rsDisplayRenderNode->GetDirtyManager(), nullptr);
4033 rsDisplayRenderNode->InitRenderParams();
4034 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
4035 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4036 rsUniRenderVisitor->curDisplayNode_ = rsDisplayRenderNode;
4037 // set surfaceNode shadow change
4038 rsSurfaceRenderNode->isShadowValidLastFrame_ = true;
4039 rsSurfaceRenderNode->GetDirtyManager()->MergeDirtyRect(DEFAULT_RECT);
4040 rsSurfaceRenderNode->oldDirtyInSurface_ = DEFAULT_RECT;
4041
4042 rsUniRenderVisitor->CheckMergeDisplayDirtyByShadowChanged(*rsSurfaceRenderNode);
4043 ASSERT_EQ(rsDisplayRenderNode->GetDirtyManager()->GetCurrentFrameDirtyRegion().IsEmpty(), false);
4044 }
4045
4046 /*
4047 * @tc.name: UpdateSurfaceDirtyAndGlobalDirty001
4048 * @tc.desc: Test UpdateSurfaceDirtyAndGlobalDirty
4049 * @tc.type: FUNC
4050 * @tc.require: issueI9RR2Y
4051 */
4052 HWTEST_F(RSUniRenderVisitorTest, UpdateSurfaceDirtyAndGlobalDirty001, TestSize.Level1)
4053 {
4054 auto rsContext = std::make_shared<RSContext>();
4055 RSSurfaceRenderNodeConfig config;
4056 RSDisplayNodeConfig displayConfig;
4057 config.id = 10;
4058 auto rsCanvasRenderNode = std::make_shared<RSCanvasRenderNode>(1, rsContext->weak_from_this());
4059 ASSERT_NE(rsCanvasRenderNode, nullptr);
4060 rsCanvasRenderNode->InitRenderParams();
4061 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
4062 ASSERT_NE(rsSurfaceRenderNode, nullptr);
4063 rsSurfaceRenderNode->InitRenderParams();
4064 // 11 non-zero node id
4065 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
4066 ASSERT_NE(rsDisplayRenderNode, nullptr);
4067 rsDisplayRenderNode->InitRenderParams();
4068 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4069
4070 // set surface to transparent, add a canvas node to create a transparent dirty region
4071 rsSurfaceRenderNode->SetAbilityBGAlpha(0);
4072 // 80, 2560, 1600. dummy value used to create rectangle with non-zero dimension
4073 rsSurfaceRenderNode->SetSrcRect(RectI(0, 80, 2560, 1600));
4074 rsDisplayRenderNode->AddChild(rsSurfaceRenderNode, -1);
4075 rsSurfaceRenderNode->AddChild(rsCanvasRenderNode, -1);
4076
4077 rsUniRenderVisitor->PrepareDisplayRenderNode(*rsDisplayRenderNode);
4078
4079 rsUniRenderVisitor->UpdateSurfaceDirtyAndGlobalDirty();
4080 ASSERT_EQ(rsUniRenderVisitor->curDisplayDirtyManager_->dirtyRegion_.left_, 0);
4081 }
4082
4083 /**
4084 * @tc.name: UpdateHwcNodeEnableByRotateAndAlpha001
4085 * @tc.desc: Test UpdateHwcNodeEnableByRotateAndAlpha for empty node
4086 * @tc.type: FUNC
4087 * @tc.require: issueI9RR2Y
4088 */
4089 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeEnableByRotateAndAlpha001, TestSize.Level2)
4090 {
4091 auto node = RSTestUtil::CreateSurfaceNode();
4092 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4093
4094 rsUniRenderVisitor->UpdateHwcNodeEnableByRotateAndAlpha(node);
4095 ASSERT_FALSE(node->isHardwareForcedDisabled_);
4096 }
4097
4098 /**
4099 * @tc.name: UpdateHwcNodeEnableByHwcNodeBelowSelfInApp001
4100 * @tc.desc: Test UpdateHwcNodeEnableByHwcNodeBelowSelfInApp with empty Rect
4101 * @tc.type: FUNC
4102 * @tc.require: issueI9RR2Y
4103 */
4104 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeEnableByHwcNodeBelowSelfInApp001, TestSize.Level2)
4105 {
4106 auto node = RSTestUtil::CreateSurfaceNode();
4107 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4108 std::vector<RectI> hwcRects;
4109 hwcRects.emplace_back(0, 0, 0, 0);
4110 rsUniRenderVisitor->UpdateHwcNodeEnableByHwcNodeBelowSelfInApp(hwcRects, node);
4111 ASSERT_FALSE(node->isHardwareForcedDisabled_);
4112 }
4113
4114 /**
4115 * @tc.name: UpdateHwcNodeEnableBySrcRect001
4116 * @tc.desc: Test UpdateHwcNodeEnableBySrcRect with empty node
4117 * @tc.type: FUNC
4118 * @tc.require: issueI9RR2Y
4119 */
4120 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeEnableBySrcRect001, TestSize.Level2)
4121 {
4122 auto node = RSTestUtil::CreateSurfaceNode();
4123 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4124
4125 rsUniRenderVisitor->UpdateHwcNodeEnableBySrcRect(*node);
4126 ASSERT_FALSE(node->isHardwareForcedDisabledBySrcRect_);
4127 }
4128
4129 /**
4130 * @tc.name: UpdateDstRect001
4131 * @tc.desc: Test UpdateDstRect with empty rect
4132 * @tc.type: FUNC
4133 * @tc.require: issueI9RR2Y
4134 */
4135 HWTEST_F(RSUniRenderVisitorTest, UpdateDstRect001, TestSize.Level2)
4136 {
4137 auto rsContext = std::make_shared<RSContext>();
4138 RSSurfaceRenderNodeConfig config;
4139 RSDisplayNodeConfig displayConfig;
4140 config.id = 10;
4141 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
4142 ASSERT_NE(rsSurfaceRenderNode, nullptr);
4143 rsSurfaceRenderNode->InitRenderParams();
4144 // 11 non-zero node id
4145 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
4146 rsDisplayRenderNode->InitRenderParams();
4147 ASSERT_NE(rsDisplayRenderNode, nullptr);
4148 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4149 rsUniRenderVisitor->InitDisplayInfo(*rsDisplayRenderNode);
4150
4151 RectI absRect(0, 0, 0, 0);
4152 RectI clipRect(0, 0, 0, 0);
4153 rsUniRenderVisitor->UpdateDstRect(*rsSurfaceRenderNode, absRect, clipRect);
4154 ASSERT_EQ(rsSurfaceRenderNode->GetDstRect().left_, 0);
4155 }
4156
4157 /**
4158 * @tc.name: UpdateSrcRect001
4159 * @tc.desc: Test UpdateSrcRect with empty matrix
4160 * @tc.type: FUNC
4161 * @tc.require: issueI9RR2Y
4162 */
4163 HWTEST_F(RSUniRenderVisitorTest, UpdateSrcRect001, TestSize.Level2)
4164 {
4165 auto rsContext = std::make_shared<RSContext>();
4166 RSSurfaceRenderNodeConfig config;
4167 RSDisplayNodeConfig displayConfig;
4168 config.id = 10;
4169 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
4170 ASSERT_NE(rsSurfaceRenderNode, nullptr);
4171 rsSurfaceRenderNode->InitRenderParams();
4172 // 11 non-zero node id
4173 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
4174 ASSERT_NE(rsDisplayRenderNode, nullptr);
4175 rsDisplayRenderNode->InitRenderParams();
4176 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4177 rsUniRenderVisitor->InitDisplayInfo(*rsDisplayRenderNode);
4178
4179 Drawing::Matrix absMatrix;
4180 RectI absRect(0, 0, 0, 0);
4181 rsSurfaceRenderNode->GetMutableRenderProperties().SetBounds({0, 0, 0, 0});
4182 rsUniRenderVisitor->UpdateSrcRect(*rsSurfaceRenderNode, absMatrix, absRect);
4183 ASSERT_EQ(rsSurfaceRenderNode->GetSrcRect().left_, 0);
4184 }
4185
4186 /**
4187 * @tc.name: BeforeUpdateSurfaceDirtyCalc001
4188 * @tc.desc: Test BeforeUpdateSurfaceDirtyCalc with empty node
4189 * @tc.type: FUNC
4190 * @tc.require: issueIABP1V
4191 */
4192 HWTEST_F(RSUniRenderVisitorTest, BeforeUpdateSurfaceDirtyCalc001, TestSize.Level2)
4193 {
4194 auto node = RSTestUtil::CreateSurfaceNode();
4195 ASSERT_NE(node, nullptr);
4196 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4197 ASSERT_NE(rsUniRenderVisitor, nullptr);
4198
4199 ASSERT_TRUE(rsUniRenderVisitor->BeforeUpdateSurfaceDirtyCalc(*node));
4200 }
4201
4202 /**
4203 * @tc.name: BeforeUpdateSurfaceDirtyCalc002
4204 * @tc.desc: Test BeforeUpdateSurfaceDirtyCalc with nonEmpty node
4205 * @tc.type: FUNC
4206 * @tc.require: issueIABP1V
4207 */
4208 HWTEST_F(RSUniRenderVisitorTest, BeforeUpdateSurfaceDirtyCalc002, TestSize.Level2)
4209 {
4210 auto node = RSTestUtil::CreateSurfaceNode();
4211 ASSERT_NE(node, nullptr);
4212 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4213 ASSERT_NE(rsUniRenderVisitor, nullptr);
4214 node->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
4215 ASSERT_TRUE(rsUniRenderVisitor->BeforeUpdateSurfaceDirtyCalc(*node));
4216 node->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
4217 ASSERT_TRUE(rsUniRenderVisitor->BeforeUpdateSurfaceDirtyCalc(*node));
4218 node->SetNodeName("CapsuleWindow");
4219 ASSERT_TRUE(rsUniRenderVisitor->BeforeUpdateSurfaceDirtyCalc(*node));
4220 }
4221
4222 /**
4223 * @tc.name: SurfaceOcclusionCallbackToWMS001
4224 * @tc.desc: Test SurfaceOcclusionCallbackToWMS with default constructed visitor
4225 * @tc.type: FUNC
4226 * @tc.require: issueIABP1V
4227 */
4228 HWTEST_F(RSUniRenderVisitorTest, SurfaceOcclusionCallbackToWMS001, TestSize.Level2)
4229 {
4230 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4231 ASSERT_NE(rsUniRenderVisitor, nullptr);
4232 rsUniRenderVisitor->SurfaceOcclusionCallbackToWMS();
4233 }
4234
4235 /**
4236 * @tc.name: GetCurrentBlackList001
4237 * @tc.desc: Test GetCurrentBlackList with default constructed visitor
4238 * @tc.type: FUNC
4239 * @tc.require: issuesIAMODH
4240 */
4241 HWTEST_F(RSUniRenderVisitorTest, GetCurrentBlackList001, TestSize.Level2)
4242 {
4243 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4244 ASSERT_NE(rsUniRenderVisitor, nullptr);
4245 EXPECT_TRUE(rsUniRenderVisitor->GetCurrentBlackList().empty());
4246 }
4247
4248 /**
4249 * @tc.name: GetCurrentBlackList
4250 * @tc.desc: Test GetCurrentBlackList002, screenManager_ && curDisplayNode_ != nullptr
4251 * @tc.type: FUNC
4252 * @tc.require: issueIAMODH
4253 */
4254 HWTEST_F(RSUniRenderVisitorTest, GetCurrentBlackList002, TestSize.Level1)
4255 {
4256 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4257 rsUniRenderVisitor->screenManager_ = CreateOrGetScreenManager();
4258 ASSERT_NE(rsUniRenderVisitor, nullptr);
4259 NodeId displayNodeId = 3;
4260 RSDisplayNodeConfig config;
4261 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(displayNodeId, config);
4262 rsUniRenderVisitor->curDisplayNode_->InitRenderParams();
4263 ASSERT_EQ(rsUniRenderVisitor->GetCurrentBlackList().size(), 0);
4264 }
4265
4266 /**
4267 * @tc.name: NeedPrepareChindrenInReverseOrder001
4268 * @tc.desc: Test NeedPrepareChindrenInReverseOrder with default constructed visitor
4269 * @tc.type: FUNC
4270 * @tc.require: issueIABP1V
4271 */
4272 HWTEST_F(RSUniRenderVisitorTest, NeedPrepareChindrenInReverseOrder001, TestSize.Level2)
4273 {
4274 auto rsContext = std::make_shared<RSContext>();
4275 ASSERT_NE(rsContext, nullptr);
4276 auto rsBaseRenderNode = std::make_shared<RSBaseRenderNode>(10, rsContext->weak_from_this());
4277 ASSERT_NE(rsBaseRenderNode, nullptr);
4278 rsBaseRenderNode->InitRenderParams();
4279 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4280 ASSERT_NE(rsUniRenderVisitor, nullptr);
4281 ASSERT_FALSE(rsUniRenderVisitor->NeedPrepareChindrenInReverseOrder(*rsBaseRenderNode));
4282 }
4283
4284 /**
4285 * @tc.name: NeedPrepareChindrenInReverseOrder002
4286 * @tc.desc: Test NeedPrepareChindrenInReverseOrder with different type nodes
4287 * @tc.type: FUNC
4288 * @tc.require: issueIABP1V
4289 */
4290 HWTEST_F(RSUniRenderVisitorTest, NeedPrepareChindrenInReverseOrder002, TestSize.Level2)
4291 {
4292 auto rsContext = std::make_shared<RSContext>();
4293 ASSERT_NE(rsContext, nullptr);
4294 auto rsBaseRenderNode = std::make_shared<RSBaseRenderNode>(10, rsContext->weak_from_this());
4295 ASSERT_NE(rsBaseRenderNode, nullptr);
4296 rsBaseRenderNode->InitRenderParams();
4297 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4298 ASSERT_NE(rsUniRenderVisitor, nullptr);
4299
4300 auto node1 = RSTestUtil::CreateSurfaceNode();
4301 ASSERT_NE(node1, nullptr);
4302 node1->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
4303
4304 node1->AddChild(rsBaseRenderNode);
4305 ASSERT_TRUE(rsUniRenderVisitor->NeedPrepareChindrenInReverseOrder(*node1));
4306
4307 auto node2 = RSTestUtil::CreateSurfaceNode();
4308 ASSERT_NE(node2, nullptr);
4309 node2->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
4310
4311 node1->RemoveChild(rsBaseRenderNode);
4312 node1->AddChild(node2);
4313 ASSERT_TRUE(rsUniRenderVisitor->NeedPrepareChindrenInReverseOrder(*node1));
4314
4315 node1->AddChild(rsBaseRenderNode);
4316 ASSERT_TRUE(rsUniRenderVisitor->NeedPrepareChindrenInReverseOrder(*node1));
4317 }
4318
4319 /**
4320 * @tc.name: IsLeashAndHasMainSubNode001
4321 * @tc.desc: Test IsLeashAndHasMainSubNode with empty node
4322 * @tc.type: FUNC
4323 * @tc.require: issueI9RR2Y
4324 */
4325 HWTEST_F(RSUniRenderVisitorTest, IsLeashAndHasMainSubNode001, TestSize.Level2)
4326 {
4327 auto node = RSTestUtil::CreateSurfaceNode();
4328 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4329
4330 ASSERT_FALSE(rsUniRenderVisitor->IsLeashAndHasMainSubNode(*node));
4331 }
4332
4333 /**
4334 * @tc.name: CalculateOcclusion001
4335 * @tc.desc: Test CalculateOcclusion with empty node
4336 * @tc.type: FUNC
4337 * @tc.require: issueI9RR2Y
4338 */
4339 HWTEST_F(RSUniRenderVisitorTest, CalculateOcclusion001, TestSize.Level2)
4340 {
4341 auto rsContext = std::make_shared<RSContext>();
4342 RSSurfaceRenderNodeConfig config;
4343 RSDisplayNodeConfig displayConfig;
4344 config.id = 10;
4345 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
4346 rsSurfaceRenderNode->InitRenderParams();
4347 // 11 non-zero node id
4348 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
4349 rsDisplayRenderNode->InitRenderParams();
4350 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4351 rsUniRenderVisitor->InitDisplayInfo(*rsDisplayRenderNode);
4352
4353 rsUniRenderVisitor->CalculateOcclusion(*rsSurfaceRenderNode);
4354 ASSERT_FALSE(rsUniRenderVisitor->needRecalculateOcclusion_);
4355 }
4356
4357 /**
4358 * @tc.name: QuickPrepareDisplayRenderNode001
4359 * @tc.desc: Test QuickPrepareDisplayRenderNode with display node
4360 * @tc.type: FUNC
4361 * @tc.require: issueI9RR2Y
4362 */
4363 HWTEST_F(RSUniRenderVisitorTest, QuickPrepareDisplayRenderNode001, TestSize.Level2)
4364 {
4365 auto rsContext = std::make_shared<RSContext>();
4366 RSDisplayNodeConfig displayConfig;
4367 // 11 non-zero node id
4368 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(11, displayConfig, rsContext->weak_from_this());
4369 rsDisplayRenderNode->InitRenderParams();
4370
4371 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4372
4373 rsUniRenderVisitor->QuickPrepareDisplayRenderNode(*rsDisplayRenderNode);
4374 ASSERT_FALSE(rsUniRenderVisitor->ancestorNodeHasAnimation_);
4375 }
4376
4377 /**
4378 * @tc.name: IsSubTreeOccluded001
4379 * @tc.desc: Test IsSubTreeOccluded with empty node
4380 * @tc.type: FUNC
4381 * @tc.require: issueI9RR2Y
4382 */
4383 HWTEST_F(RSUniRenderVisitorTest, IsSubTreeOccluded001, TestSize.Level2)
4384 {
4385 auto node = RSTestUtil::CreateSurfaceNode();
4386 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4387
4388 rsUniRenderVisitor->IsSubTreeOccluded(*node);
4389 ASSERT_EQ(node->dirtyStatus_, RSRenderNode::NodeDirty::CLEAN);
4390 }
4391
4392 /**
4393 * @tc.name: UpdateSurfaceRenderNodeRotate001
4394 * @tc.desc: Test UpdateSurfaceRenderNodeRotate with empty node
4395 * @tc.type: FUNC
4396 * @tc.require: issueI9RR2Y
4397 */
4398 HWTEST_F(RSUniRenderVisitorTest, UpdateSurfaceRenderNodeRotate001, TestSize.Level2)
4399 {
4400 auto node = RSTestUtil::CreateSurfaceNode();
4401 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4402
4403 rsUniRenderVisitor->UpdateSurfaceRenderNodeRotate(*node);
4404 ASSERT_FALSE(node->isRotating_);
4405 }
4406
4407 /*
4408 * @tc.name: IsOutOfScreenRegion001
4409 * @tc.desc: Test RSUniRenderVisitorTest.IsOutOfScreenRegion while UniRenderVisitor has no canvas
4410 * @tc.type: FUNC
4411 * @tc.require: issuesI9SIK7
4412 */
4413 HWTEST_F(RSUniRenderVisitorTest, IsOutOfScreenRegion001, TestSize.Level2)
4414 {
4415 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4416 ASSERT_NE(rsUniRenderVisitor, nullptr);
4417 RectI rect(0, 0, 0, 0);
4418
4419 ASSERT_FALSE(rsUniRenderVisitor->IsOutOfScreenRegion(rect));
4420 }
4421
4422 /*
4423 * @tc.name: IsOutOfScreenRegion002
4424 * @tc.desc: Test RSUniRenderVisitorTest.IsOutOfScreenRegion while canvas within screen
4425 * @tc.type: FUNC
4426 * @tc.require: issuesI9SIK7
4427 */
4428 HWTEST_F(RSUniRenderVisitorTest, IsOutOfScreenRegion002, TestSize.Level2)
4429 {
4430 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4431 ASSERT_NE(rsUniRenderVisitor, nullptr);
4432 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4433 ASSERT_NE(drawingCanvas, nullptr);
4434 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
4435
4436 RectI rect(0, 0, RECT_DEFAULT_SIZE, RECT_DEFAULT_SIZE);
4437 ASSERT_FALSE(rsUniRenderVisitor->IsOutOfScreenRegion(rect));
4438 }
4439
4440 /*
4441 * @tc.name: PrepareIsOutOfScreenRegion003
4442 * @tc.desc: Test RSUniRenderVisitorTest.IsOutOfScreenRegion while cavas's position out of screen
4443 * @tc.type: FUNC
4444 * @tc.require: issuesI9SIK7
4445 */
4446 HWTEST_F(RSUniRenderVisitorTest, IsOutOfScreenRegion003, TestSize.Level2)
4447 {
4448 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4449 ASSERT_NE(rsUniRenderVisitor, nullptr);
4450 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4451 ASSERT_NE(drawingCanvas, nullptr);
4452 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
4453
4454 RectI rect(1000, 1000, RECT_DEFAULT_SIZE, RECT_DEFAULT_SIZE);
4455 ASSERT_TRUE(rsUniRenderVisitor->IsOutOfScreenRegion(rect));
4456 }
4457
4458 /*
4459 * @tc.name: PrepareIsOutOfScreenRegion004
4460 * @tc.desc: Test RSUniRenderVisitorTest.IsOutOfScreenRegion while cavas width out screen
4461 * @tc.type: FUNC
4462 * @tc.require: issuesI9SIK7
4463 */
4464 HWTEST_F(RSUniRenderVisitorTest, IsOutOfScreenRegion004, TestSize.Level2)
4465 {
4466 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4467 ASSERT_NE(rsUniRenderVisitor, nullptr);
4468 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4469 ASSERT_NE(drawingCanvas, nullptr);
4470 rsUniRenderVisitor->canvas_ = std::make_unique<RSPaintFilterCanvas>(drawingCanvas.get());
4471
4472 int leftPos = 800;
4473 int topPos = 1000;
4474 int widthValue = 1000;
4475 int heightValue = 300;
4476 RectI rect(leftPos, topPos, widthValue, heightValue);
4477 ASSERT_TRUE(rsUniRenderVisitor->IsOutOfScreenRegion(rect));
4478 }
4479
4480 /*
4481 * @tc.name: ScaleMirrorIfNeedForWiredScreen
4482 * @tc.desc: Test RSUniRenderVisitorTest.ScaleMirrorIfNeedForWiredScreen while rotation true
4483 * @tc.type: FUNC
4484 * @tc.require: issuesI9SIK7
4485 */
4486 HWTEST_F(RSUniRenderVisitorTest, ScaleMirrorIfNeedForWiredScreen001, TestSize.Level2)
4487 {
4488 auto rsContext = std::make_shared<RSContext>();
4489 RSDisplayNodeConfig displayConfig;
4490 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(10, displayConfig, rsContext->weak_from_this());
4491 ASSERT_NE(rsDisplayRenderNode, nullptr);
4492 rsDisplayRenderNode->InitRenderParams();
4493
4494 auto screenManager = CreateOrGetScreenManager();
4495 ASSERT_NE(screenManager, nullptr);
4496 std::string name = "virtualScreen";
4497 uint32_t width = 480;
4498 uint32_t height = 320;
4499 uint32_t mirrorHeight = 800;
4500 uint32_t mirrorWidth = 600;
4501
4502 auto csurface = IConsumerSurface::Create();
4503 ASSERT_NE(csurface, nullptr);
4504 auto producer = csurface->GetProducer();
4505 auto psurface = Surface::CreateSurfaceAsProducer(producer);
4506 ASSERT_NE(psurface, nullptr);
4507 auto id = screenManager->CreateVirtualScreen(name, width, height, psurface);
4508 ASSERT_NE(INVALID_SCREEN_ID, id);
4509
4510 RSDisplayNodeConfig config1;
4511 auto mirrorNode = std::make_shared<RSDisplayRenderNode>(id, config1);
4512 ASSERT_NE(mirrorNode, nullptr);
4513 mirrorNode->SetScreenRotation(ScreenRotation::ROTATION_0);
4514 ASSERT_NE(mirrorNode->renderContent_, nullptr);
4515 mirrorNode->renderContent_->renderProperties_.SetBoundsHeight(mirrorHeight);
4516 mirrorNode->renderContent_->renderProperties_.SetBoundsWidth(mirrorWidth);
4517 rsDisplayRenderNode->mirrorSource_ = mirrorNode;
4518
4519 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4520 ASSERT_NE(rsUniRenderVisitor, nullptr);
4521 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4522 ASSERT_NE(drawingCanvas, nullptr);
4523 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4524 rsUniRenderVisitor->ScaleMirrorIfNeedForWiredScreen(*rsDisplayRenderNode, true);
4525
4526 screenManager->RemoveVirtualScreen(id);
4527 }
4528
4529 /*
4530 * @tc.name: ScaleMirrorIfNeedForWiredScreen
4531 * @tc.desc: Test RSUniRenderVisitorTest.ScaleMirrorIfNeedForWiredScreen while rotation false
4532 * @tc.type: FUNC
4533 * @tc.require: issuesI9SIK7
4534 */
4535 HWTEST_F(RSUniRenderVisitorTest, ScaleMirrorIfNeedForWiredScreen002, TestSize.Level2)
4536 {
4537 auto rsContext = std::make_shared<RSContext>();
4538 RSDisplayNodeConfig displayConfig;
4539 NodeId displayId = 10;
4540 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(displayId, displayConfig,
4541 rsContext->weak_from_this());
4542 ASSERT_NE(rsDisplayRenderNode, nullptr);
4543 rsDisplayRenderNode->InitRenderParams();
4544
4545 auto screenManager = CreateOrGetScreenManager();
4546 ASSERT_NE(screenManager, nullptr);
4547 std::string name = "virtualScreen";
4548 uint32_t width = 480;
4549 uint32_t height = 320;
4550
4551 auto csurface = IConsumerSurface::Create();
4552 ASSERT_NE(csurface, nullptr);
4553 auto producer = csurface->GetProducer();
4554 auto psurface = Surface::CreateSurfaceAsProducer(producer);
4555 ASSERT_NE(psurface, nullptr);
4556 auto id = screenManager->CreateVirtualScreen(name, width, height, psurface);
4557 ASSERT_NE(INVALID_SCREEN_ID, id);
4558
4559 RSDisplayNodeConfig config1;
4560 auto mirrorNode = std::make_shared<RSDisplayRenderNode>(id, config1);
4561 ASSERT_NE(mirrorNode, nullptr);
4562 mirrorNode->SetScreenRotation(ScreenRotation::ROTATION_0);
4563 ASSERT_NE(mirrorNode->renderContent_, nullptr);
4564 mirrorNode->renderContent_->renderProperties_.SetBoundsHeight(800);
4565 mirrorNode->renderContent_->renderProperties_.SetBoundsWidth(600);
4566 rsDisplayRenderNode->mirrorSource_ = mirrorNode;
4567
4568 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4569 ASSERT_NE(rsUniRenderVisitor, nullptr);
4570 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4571 ASSERT_NE(drawingCanvas, nullptr);
4572 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4573 rsUniRenderVisitor->ScaleMirrorIfNeedForWiredScreen(*rsDisplayRenderNode, false);
4574
4575 screenManager->RemoveVirtualScreen(id);
4576 }
4577
4578 /*
4579 * @tc.name: RotateMirrorCanvasIfNeedForWiredScreen
4580 * @tc.desc: Test RSUniRenderVisitorTest.RotateMirrorCanvasIfNeedForWiredScreen with rotation_90
4581 * @tc.type: FUNC
4582 * @tc.require: issuesI9SIK7
4583 */
4584 HWTEST_F(RSUniRenderVisitorTest, RotateMirrorCanvasIfNeedForWiredScreen001, TestSize.Level2)
4585 {
4586 auto rsContext = std::make_shared<RSContext>();
4587 RSDisplayNodeConfig displayConfig;
4588 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(10, displayConfig, rsContext->weak_from_this());
4589 rsDisplayRenderNode->InitRenderParams();
4590 ASSERT_NE(rsDisplayRenderNode, nullptr);
4591
4592 auto screenManager = CreateOrGetScreenManager();
4593 ASSERT_NE(screenManager, nullptr);
4594 std::string name = "virtualScreen";
4595 uint32_t width = 480;
4596 uint32_t height = 320;
4597
4598 auto csurface = IConsumerSurface::Create();
4599 ASSERT_NE(csurface, nullptr);
4600 auto producer = csurface->GetProducer();
4601 auto psurface = Surface::CreateSurfaceAsProducer(producer);
4602 ASSERT_NE(psurface, nullptr);
4603 auto id = screenManager->CreateVirtualScreen(name, width, height, psurface);
4604 ASSERT_NE(INVALID_SCREEN_ID, id);
4605
4606 RSDisplayNodeConfig config1;
4607 auto mirrorNode = std::make_shared<RSDisplayRenderNode>(id, config1);
4608 ASSERT_NE(mirrorNode, nullptr);
4609 mirrorNode->SetScreenRotation(ScreenRotation::ROTATION_90);
4610 rsDisplayRenderNode->mirrorSource_ = mirrorNode;
4611
4612 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4613 ASSERT_NE(rsUniRenderVisitor, nullptr);
4614 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4615 ASSERT_NE(drawingCanvas, nullptr);
4616 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4617 rsUniRenderVisitor->RotateMirrorCanvasIfNeedForWiredScreen(*rsDisplayRenderNode);
4618
4619 mirrorNode->SetScreenRotation(ScreenRotation::ROTATION_180);
4620 rsDisplayRenderNode->mirrorSource_ = mirrorNode;
4621 rsUniRenderVisitor->RotateMirrorCanvasIfNeedForWiredScreen(*rsDisplayRenderNode);
4622
4623 mirrorNode->SetScreenRotation(ScreenRotation::ROTATION_270);
4624 rsDisplayRenderNode->mirrorSource_ = mirrorNode;
4625 rsUniRenderVisitor->RotateMirrorCanvasIfNeedForWiredScreen(*rsDisplayRenderNode);
4626
4627 screenManager->RemoveVirtualScreen(id);
4628 }
4629
4630 /*
4631 * @tc.name: ScaleMirrorIfNeed
4632 * @tc.desc: Test ScaleMirrorIfNeed with cavasRotation_true ScreenScaleMode::FILL_MODE and rotation_90
4633 * @tc.type: FUNC
4634 * @tc.require: issuesI9SIK7
4635 */
4636 HWTEST_F(RSUniRenderVisitorTest, ScaleMirrorIfNeed001, TestSize.Level2)
4637 {
4638 auto rsContext = std::make_shared<RSContext>();
4639 RSDisplayNodeConfig displayConfig;
4640 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(10, displayConfig, rsContext->weak_from_this());
4641 rsDisplayRenderNode->InitRenderParams();
4642 ASSERT_NE(rsDisplayRenderNode, nullptr);
4643
4644 auto screenManager = CreateOrGetScreenManager();
4645 ASSERT_NE(screenManager, nullptr);
4646 std::string name = "virtualScreen";
4647 uint32_t width = 480;
4648 uint32_t height = 320;
4649
4650 auto csurface = IConsumerSurface::Create();
4651 ASSERT_NE(csurface, nullptr);
4652 auto producer = csurface->GetProducer();
4653 auto psurface = Surface::CreateSurfaceAsProducer(producer);
4654 ASSERT_NE(psurface, nullptr);
4655 auto id = screenManager->CreateVirtualScreen(name, width, height, psurface);
4656 ASSERT_NE(INVALID_SCREEN_ID, id);
4657 screenManager->SetVirtualMirrorScreenScaleMode(rsDisplayRenderNode->GetScreenId(), ScreenScaleMode::FILL_MODE);
4658
4659 RSDisplayNodeConfig config1;
4660 auto mirrorNode = std::make_shared<RSDisplayRenderNode>(id, config1);
4661 ASSERT_NE(mirrorNode, nullptr);
4662 mirrorNode->SetScreenRotation(ScreenRotation::ROTATION_90);
4663 ASSERT_NE(mirrorNode->renderContent_, nullptr);
4664 mirrorNode->renderContent_->renderProperties_.SetBoundsHeight(800);
4665 mirrorNode->renderContent_->renderProperties_.SetBoundsWidth(600);
4666 rsDisplayRenderNode->mirrorSource_ = mirrorNode;
4667
4668 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4669 ASSERT_NE(rsUniRenderVisitor, nullptr);
4670 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4671 ASSERT_NE(drawingCanvas, nullptr);
4672 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4673 rsUniRenderVisitor->ScaleMirrorIfNeed(*rsDisplayRenderNode, true);
4674
4675 screenManager->RemoveVirtualScreen(id);
4676 }
4677
4678 /*
4679 * @tc.name: ScaleMirrorIfNeed
4680 * @tc.desc: Test ScaleMirrorIfNeed with cavasRotation_false ScreenScaleMode::FILL_MODE and rotation_90
4681 * @tc.type: FUNC
4682 * @tc.require: issuesI9SIK7
4683 */
4684 HWTEST_F(RSUniRenderVisitorTest, ScaleMirrorIfNeed002, TestSize.Level2)
4685 {
4686 auto rsContext = std::make_shared<RSContext>();
4687 RSDisplayNodeConfig displayConfig;
4688 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(10, displayConfig, rsContext->weak_from_this());
4689 rsDisplayRenderNode->InitRenderParams();
4690 ASSERT_NE(rsDisplayRenderNode, nullptr);
4691
4692 auto screenManager = CreateOrGetScreenManager();
4693 ASSERT_NE(screenManager, nullptr);
4694 std::string name = "virtualScreen";
4695 uint32_t width = 480;
4696 uint32_t height = 320;
4697
4698 auto csurface = IConsumerSurface::Create();
4699 ASSERT_NE(csurface, nullptr);
4700 auto producer = csurface->GetProducer();
4701 auto psurface = Surface::CreateSurfaceAsProducer(producer);
4702 ASSERT_NE(psurface, nullptr);
4703 auto id = screenManager->CreateVirtualScreen(name, width, height, psurface);
4704 ASSERT_NE(INVALID_SCREEN_ID, id);
4705 screenManager->SetVirtualMirrorScreenScaleMode(rsDisplayRenderNode->GetScreenId(), ScreenScaleMode::FILL_MODE);
4706
4707 RSDisplayNodeConfig config1;
4708 auto mirrorNode = std::make_shared<RSDisplayRenderNode>(id, config1);
4709 ASSERT_NE(mirrorNode, nullptr);
4710 mirrorNode->SetScreenRotation(ScreenRotation::ROTATION_90);
4711 ASSERT_NE(mirrorNode->renderContent_, nullptr);
4712 mirrorNode->renderContent_->renderProperties_.SetBoundsHeight(800);
4713 mirrorNode->renderContent_->renderProperties_.SetBoundsWidth(600);
4714 rsDisplayRenderNode->mirrorSource_ = mirrorNode;
4715
4716 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4717 ASSERT_NE(rsUniRenderVisitor, nullptr);
4718 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4719 ASSERT_NE(drawingCanvas, nullptr);
4720 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4721 rsUniRenderVisitor->ScaleMirrorIfNeed(*rsDisplayRenderNode, false);
4722
4723 screenManager->RemoveVirtualScreen(id);
4724 }
4725
4726 /*
4727 * @tc.name: ScaleMirrorIfNeed
4728 * @tc.desc: Test ScaleMirrorIfNeed with cavasRotation_false ScreenScaleMode::UNISCALE_MODE and rotation_270
4729 * @tc.type: FUNC
4730 * @tc.require: issuesI9SIK7
4731 */
4732 HWTEST_F(RSUniRenderVisitorTest, ScaleMirrorIfNeed003, TestSize.Level2)
4733 {
4734 auto rsContext = std::make_shared<RSContext>();
4735 RSDisplayNodeConfig displayConfig;
4736 auto rsDisplayRenderNode = std::make_shared<RSDisplayRenderNode>(10, displayConfig, rsContext->weak_from_this());
4737 rsDisplayRenderNode->InitRenderParams();
4738 ASSERT_NE(rsDisplayRenderNode, nullptr);
4739
4740 auto screenManager = CreateOrGetScreenManager();
4741 ASSERT_NE(screenManager, nullptr);
4742 std::string name = "virtualScreen";
4743 uint32_t width = 480;
4744 uint32_t height = 320;
4745
4746 auto csurface = IConsumerSurface::Create();
4747 ASSERT_NE(csurface, nullptr);
4748 auto producer = csurface->GetProducer();
4749 auto psurface = Surface::CreateSurfaceAsProducer(producer);
4750 ASSERT_NE(psurface, nullptr);
4751 auto id = screenManager->CreateVirtualScreen(name, width, height, psurface);
4752 ASSERT_NE(INVALID_SCREEN_ID, id);
4753 screenManager->SetVirtualMirrorScreenScaleMode(rsDisplayRenderNode->GetScreenId(), ScreenScaleMode::UNISCALE_MODE);
4754
4755 RSDisplayNodeConfig config1;
4756 auto mirrorNode = std::make_shared<RSDisplayRenderNode>(id, config1);
4757 ASSERT_NE(mirrorNode, nullptr);
4758 mirrorNode->SetScreenRotation(ScreenRotation::ROTATION_90);
4759 ASSERT_NE(mirrorNode->renderContent_, nullptr);
4760 mirrorNode->renderContent_->renderProperties_.SetBoundsHeight(800);
4761 mirrorNode->renderContent_->renderProperties_.SetBoundsWidth(600);
4762 rsDisplayRenderNode->mirrorSource_ = mirrorNode;
4763
4764 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4765 ASSERT_NE(rsUniRenderVisitor, nullptr);
4766 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4767 ASSERT_NE(drawingCanvas, nullptr);
4768 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4769 rsUniRenderVisitor->ScaleMirrorIfNeed(*rsDisplayRenderNode, true);
4770
4771 screenManager->RemoveVirtualScreen(id);
4772 }
4773
4774 /*
4775 * @tc.name: UpdateSrcRectForHwcNode
4776 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSrcRectForHwcNode while GRAPHIC_FLIP_H_ROT90 and isProtected_true
4777 * @tc.type: FUNC
4778 * @tc.require: issuesI9V0N7
4779 */
4780 HWTEST_F(RSUniRenderVisitorTest, UpdateSrcRectForHwcNode001, TestSize.Level2)
4781 {
4782 auto rsSurfaceRenderNode = RSTestUtil::CreateSurfaceNode();
4783 ASSERT_NE(rsSurfaceRenderNode, nullptr);
4784 ASSERT_NE(rsSurfaceRenderNode->GetRSSurfaceHandler()->GetConsumer(), nullptr);
4785 uint32_t left = 0;
4786 uint32_t top = 0;
4787 uint32_t width = 400;
4788 uint32_t height = 600;
4789 RectI dstRect{left, top, width, height};
4790 rsSurfaceRenderNode->SetSrcRect(dstRect);
4791 rsSurfaceRenderNode->GetRSSurfaceHandler()->
4792 GetConsumer()->SetTransform(GraphicTransformType::GRAPHIC_FLIP_H_ROT90);
4793
4794 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4795 ASSERT_NE(rsUniRenderVisitor, nullptr);
4796 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4797 ASSERT_NE(drawingCanvas, nullptr);
4798 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4799 ASSERT_TRUE(rsUniRenderVisitor->UpdateSrcRectForHwcNode(*rsSurfaceRenderNode, true));
4800 }
4801
4802 /*
4803 * @tc.name: UpdateSrcRectForHwcNode
4804 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSrcRectForHwcNode while GRAPHIC_FLIP_H_ROT90 and isProtected_false
4805 * @tc.type: FUNC
4806 * @tc.require: issuesI9V0N7
4807 */
4808 HWTEST_F(RSUniRenderVisitorTest, UpdateSrcRectForHwcNode002, TestSize.Level2)
4809 {
4810 auto rsSurfaceRenderNode = RSTestUtil::CreateSurfaceNode();
4811 ASSERT_NE(rsSurfaceRenderNode, nullptr);
4812 ASSERT_NE(rsSurfaceRenderNode->GetRSSurfaceHandler()->GetConsumer(), nullptr);
4813 uint32_t left = 0;
4814 uint32_t top = 0;
4815 uint32_t width = 400;
4816 uint32_t height = 600;
4817 RectI dstRect{left, top, width, height};
4818 rsSurfaceRenderNode->SetSrcRect(dstRect);
4819 rsSurfaceRenderNode->GetRSSurfaceHandler()->
4820 GetConsumer()->SetTransform(GraphicTransformType::GRAPHIC_FLIP_H_ROT90);
4821
4822 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4823 ASSERT_NE(rsUniRenderVisitor, nullptr);
4824 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4825 ASSERT_NE(drawingCanvas, nullptr);
4826 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4827 ASSERT_TRUE(rsUniRenderVisitor->UpdateSrcRectForHwcNode(*rsSurfaceRenderNode, false));
4828 }
4829
4830 /*
4831 * @tc.name: UpdateSrcRectForHwcNode
4832 * @tc.desc: Test RSUniRenderVisitorTest.UpdateSrcRectForHwcNode while GRAPHIC_FLIP_H_ROT180 and isProtected_false
4833 * @tc.type: FUNC
4834 * @tc.require: issuesI9V0N7
4835 */
4836 HWTEST_F(RSUniRenderVisitorTest, UpdateSrcRectForHwcNode003, TestSize.Level2)
4837 {
4838 auto rsSurfaceRenderNode = RSTestUtil::CreateSurfaceNode();
4839 ASSERT_NE(rsSurfaceRenderNode, nullptr);
4840 ASSERT_NE(rsSurfaceRenderNode->GetRSSurfaceHandler()->GetConsumer(), nullptr);
4841 uint32_t left = 0;
4842 uint32_t top = 0;
4843 uint32_t width = 400;
4844 uint32_t height = 600;
4845 RectI dstRect{left, top, width, height};
4846 rsSurfaceRenderNode->SetSrcRect(dstRect);
4847 rsSurfaceRenderNode->GetRSSurfaceHandler()->
4848 GetConsumer()->SetTransform(GraphicTransformType::GRAPHIC_FLIP_H_ROT180);
4849
4850 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4851 ASSERT_NE(rsUniRenderVisitor, nullptr);
4852 auto drawingCanvas = std::make_shared<Drawing::Canvas>(DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT);
4853 ASSERT_NE(drawingCanvas, nullptr);
4854 rsUniRenderVisitor->canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas.get());
4855 ASSERT_TRUE(rsUniRenderVisitor->UpdateSrcRectForHwcNode(*rsSurfaceRenderNode, false));
4856 }
4857
4858 /*
4859 * @tc.name: CheckAndSetNodeCacheType
4860 * @tc.desc: Test RSUniRenderVisitorTest.CheckAndSetNodeCacheType with CacheType::NONE
4861 * @tc.type: FUNC
4862 * @tc.require: issuesI9V0N7
4863 */
4864 HWTEST_F(RSUniRenderVisitorTest, CheckAndSetNodeCacheType001, TestSize.Level2)
4865 {
4866 NodeId id = 0;
4867 auto node = std::make_shared<RSRenderNode>(id);
4868 ASSERT_NE(node, nullptr);
4869 node->InitRenderParams();
4870 node->SetCacheType(CacheType::CONTENT);
4871
4872 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4873 ASSERT_NE(rsUniRenderVisitor, nullptr);
4874 rsUniRenderVisitor->CheckAndSetNodeCacheType(*node);
4875 ASSERT_EQ(node->GetCacheType(), CacheType::NONE);
4876 }
4877
4878 /*
4879 * @tc.name: UpdateHwcNodeEnableByFilterRect
4880 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHwcNodeEnableByFilterRect with intersect rect
4881 * @tc.type: FUNC
4882 * @tc.require: issuesI9V0N7
4883 */
4884 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeEnableByFilterRect001, TestSize.Level2)
4885 {
4886 RSSurfaceRenderNodeConfig surfaceConfig;
4887 surfaceConfig.id = 1;
4888 auto surfaceNode1 = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
4889 ASSERT_NE(surfaceNode1, nullptr);
4890 surfaceConfig.id = 2;
4891 auto surfaceNode2 = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
4892 ASSERT_NE(surfaceNode2, nullptr);
4893
4894 uint32_t left = 0;
4895 uint32_t top = 0;
4896 uint32_t width = 300;
4897 uint32_t height = 300;
4898 RectI rect{left, top, width, height};
4899 surfaceNode2->SetDstRect(rect);
4900 surfaceNode1->AddChildHardwareEnabledNode(surfaceNode2);
4901
4902 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4903 ASSERT_NE(rsUniRenderVisitor, nullptr);
4904 rsUniRenderVisitor->UpdateHwcNodeEnableByFilterRect(surfaceNode1, rect);
4905 ASSERT_TRUE(surfaceNode2->IsHardwareForcedDisabled());
4906 }
4907
4908 /*
4909 * @tc.name: UpdateHwcNodeEnableByFilterRect
4910 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHwcNodeEnableByFilterRect with empty rect
4911 * @tc.type: FUNC
4912 * @tc.require: issuesI9V0N7
4913 */
4914 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeEnableByFilterRect002, TestSize.Level2)
4915 {
4916 RSSurfaceRenderNodeConfig surfaceConfig;
4917 surfaceConfig.id = 1;
4918 auto surfaceNode1 = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
4919 ASSERT_NE(surfaceNode1, nullptr);
4920
4921 uint32_t left = 0;
4922 uint32_t top = 0;
4923 uint32_t width = 0;
4924 uint32_t height = 0;
4925 RectI rect{left, top, width, height};
4926 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4927 ASSERT_NE(rsUniRenderVisitor, nullptr);
4928 rsUniRenderVisitor->UpdateHwcNodeEnableByFilterRect(surfaceNode1, rect);
4929 }
4930
4931 /*
4932 * @tc.name: UpdateHwcNodeEnableByFilterRect
4933 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHwcNodeEnableByFilterRect with no hwcNode
4934 * @tc.type: FUNC
4935 * @tc.require: issuesI9V0N7
4936 */
4937 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeEnableByFilterRect003, TestSize.Level2)
4938 {
4939 RSSurfaceRenderNodeConfig surfaceConfig;
4940 surfaceConfig.id = 1;
4941 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
4942 ASSERT_NE(surfaceNode, nullptr);
4943
4944 uint32_t left = 0;
4945 uint32_t top = 0;
4946 uint32_t width = 300;
4947 uint32_t height = 300;
4948 RectI rect{left, top, width, height};
4949 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4950 ASSERT_NE(rsUniRenderVisitor, nullptr);
4951 rsUniRenderVisitor->UpdateHwcNodeEnableByFilterRect(surfaceNode, rect);
4952 }
4953
4954 /*
4955 * @tc.name: CheckMergeGlobalFilterForDisplay
4956 * @tc.desc: Test RSUniRenderVisitorTest.CheckMergeGlobalFilterForDisplay
4957 * @tc.type: FUNC
4958 * @tc.require: issuesI9V0N7
4959 */
4960 HWTEST_F(RSUniRenderVisitorTest, CheckMergeGlobalFilterForDisplay001, TestSize.Level2)
4961 {
4962 auto& nodeMap = RSMainThread::Instance()->GetContext().GetMutableNodeMap();
4963 NodeId id0 = 0;
4964 nodeMap.renderNodeMap_[id0] = nullptr;
4965 NodeId id1 = 1;
4966 auto node1 = std::make_shared<RSRenderNode>(id1);
4967 nodeMap.renderNodeMap_[id1] = node1;
4968 NodeId id2 = 2;
4969 auto node2 = std::make_shared<RSRenderNode>(id2);
4970 nodeMap.renderNodeMap_[id2] = node2;
4971
4972 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4973 ASSERT_NE(rsUniRenderVisitor, nullptr);
4974 uint32_t left = 0;
4975 uint32_t top = 0;
4976 uint32_t width = 300;
4977 uint32_t height = 300;
4978 RectI rect{left, top, width, height};
4979 rsUniRenderVisitor->containerFilter_.insert({node2->GetId(), rect});
4980 NodeId displayNodeId = 3;
4981 RSDisplayNodeConfig config;
4982 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(displayNodeId, config);
4983 auto dirtyRegion = Occlusion::Region{ Occlusion::Rect{ rect } };
4984 rsUniRenderVisitor->CheckMergeGlobalFilterForDisplay(dirtyRegion);
4985 }
4986
4987 /*
4988 * @tc.name: UpdateOccludedStatusWithFilterNode
4989 * @tc.desc: Test RSUniRenderVisitorTest.UpdateOccludedStatusWithFilterNode while surface node nullptr
4990 * @tc.type: FUNC
4991 * @tc.require: issuesI9V0N7
4992 */
4993 HWTEST_F(RSUniRenderVisitorTest, UpdateOccludedStatusWithFilterNode001, TestSize.Level2)
4994 {
4995 std::shared_ptr<RSSurfaceRenderNode> surfaceNode = nullptr;
4996 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
4997 ASSERT_NE(rsUniRenderVisitor, nullptr);
4998 rsUniRenderVisitor->UpdateOccludedStatusWithFilterNode(surfaceNode);
4999 }
5000
5001 /*
5002 * @tc.name: UpdateOccludedStatusWithFilterNode
5003 * @tc.desc: Test RSUniRenderVisitorTest.UpdateOccludedStatusWithFilterNode with surfaceNode
5004 * @tc.type: FUNC
5005 * @tc.require: issuesI9V0N7
5006 */
5007 HWTEST_F(RSUniRenderVisitorTest, UpdateOccludedStatusWithFilterNode002, TestSize.Level2)
5008 {
5009 RSSurfaceRenderNodeConfig surfaceConfig;
5010 surfaceConfig.id = 1;
5011 auto surfaceNode1 = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
5012 ASSERT_NE(surfaceNode1, nullptr);
5013 std::shared_ptr<RSFilter> filter = RSFilter::CreateBlurFilter(1.0f, 1.0f);
5014 ASSERT_NE(surfaceNode1->renderContent_, nullptr);
5015 surfaceNode1->renderContent_->renderProperties_.SetBackgroundFilter(filter);
5016 surfaceNode1->isOccludedByFilterCache_ = true;
5017 auto& nodeMap = RSMainThread::Instance()->GetContext().GetMutableNodeMap();
5018 NodeId id1 = 2;
5019 auto filterNode1 = std::make_shared<RSRenderNode>(id1);
5020 ASSERT_NE(filterNode1, nullptr);
5021 nodeMap.renderNodeMap_[id1] = filterNode1;
5022 NodeId id2 = 3;
5023 auto filterNode2 = std::make_shared<RSRenderNode>(id2);
5024 ASSERT_NE(filterNode2, nullptr);
5025 ASSERT_NE(filterNode2->renderContent_, nullptr);
5026 filterNode2->renderContent_->renderProperties_.SetBackgroundFilter(filter);
5027 nodeMap.renderNodeMap_[id2] = filterNode2;
5028 surfaceNode1->visibleFilterChild_.emplace_back(filterNode1->GetId());
5029 surfaceNode1->visibleFilterChild_.emplace_back(filterNode2->GetId());
5030
5031 ASSERT_FALSE(filterNode1->isOccluded_);
5032 ASSERT_FALSE(filterNode2->isOccluded_);
5033 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5034 ASSERT_NE(rsUniRenderVisitor, nullptr);
5035 rsUniRenderVisitor->UpdateOccludedStatusWithFilterNode(surfaceNode1);
5036 ASSERT_TRUE(filterNode2->isOccluded_);
5037 }
5038
5039 /*
5040 * @tc.name: MarkBlurIntersectWithDRM
5041 * @tc.desc: Test RSUniRenderVisitorTest.MarkBlurIntersectWithDRM001 while surface node nullptr
5042 * @tc.type: FUNC
5043 * @tc.require: issuesIAQZ4I
5044 */
5045 HWTEST_F(RSUniRenderVisitorTest, MarkBlurIntersectWithDRM001, TestSize.Level2)
5046 {
5047 RSSurfaceRenderNodeConfig surfaceConfig;
5048 surfaceConfig.id = 1;
5049 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
5050 ASSERT_NE(surfaceNode, nullptr);
5051 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5052 ASSERT_NE(rsUniRenderVisitor, nullptr);
5053 rsUniRenderVisitor->MarkBlurIntersectWithDRM(surfaceNode);
5054 }
5055
5056 /*
5057 * @tc.name: CheckMergeDisplayDirtyByTransparentFilter
5058 * @tc.desc: Test RSUniRenderVisitorTest.CheckMergeDisplayDirtyByTransparentFilter with mainWindow
5059 * @tc.type: FUNC
5060 * @tc.require: issuesI9V0N7
5061 */
5062 HWTEST_F(RSUniRenderVisitorTest, CheckMergeDisplayDirtyByTransparentFilter001, TestSize.Level2)
5063 {
5064 RSSurfaceRenderNodeConfig surfaceConfig;
5065 surfaceConfig.id = 1;
5066 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
5067 ASSERT_NE(surfaceNode, nullptr);
5068 surfaceNode->SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
5069 ASSERT_TRUE(surfaceNode->GetVisibleRegion().IsEmpty());
5070
5071 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5072 ASSERT_NE(rsUniRenderVisitor, nullptr);
5073 uint32_t left = 0;
5074 uint32_t top = 0;
5075 uint32_t width = 260;
5076 uint32_t height = 600;
5077 RectI rect{left, top, width, height};
5078 Occlusion::Region region{rect};
5079 NodeId displayNodeId = 2;
5080 RSDisplayNodeConfig config;
5081 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(displayNodeId, config);
5082 rsUniRenderVisitor->curDisplayNode_->InitRenderParams();
5083 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
5084 rsUniRenderVisitor->CheckMergeDisplayDirtyByTransparentFilter(surfaceNode, region);
5085 }
5086
5087 /*
5088 * @tc.name: CheckMergeDisplayDirtyByTransparentFilter
5089 * @tc.desc: Test RSUniRenderVisitorTest.CheckMergeDisplayDirtyByTransparentFilter
5090 * @tc.type: FUNC
5091 * @tc.require: issuesI9V0N7
5092 */
5093 HWTEST_F(RSUniRenderVisitorTest, CheckMergeDisplayDirtyByTransparentFilter002, TestSize.Level2)
5094 {
5095 RSSurfaceRenderNodeConfig surfaceConfig;
5096 surfaceConfig.id = 1;
5097 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
5098 ASSERT_NE(surfaceNode, nullptr);
5099 surfaceNode->SetSurfaceNodeType(RSSurfaceNodeType::ABILITY_COMPONENT_NODE);
5100 auto& nodeMap = RSMainThread::Instance()->GetContext().GetMutableNodeMap();
5101 NodeId id0 = 0;
5102 nodeMap.renderNodeMap_[id0] = nullptr;
5103 NodeId id1 = 1;
5104 auto node1 = std::make_shared<RSRenderNode>(id1);
5105 nodeMap.renderNodeMap_[id1] = node1;
5106 NodeId id2 = 2;
5107 auto node2 = std::make_shared<RSRenderNode>(id2);
5108 nodeMap.renderNodeMap_[id2] = node2;
5109
5110 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5111 ASSERT_NE(rsUniRenderVisitor, nullptr);
5112 uint32_t left1 = 0;
5113 uint32_t top1 = 0;
5114 uint32_t width1 = 260;
5115 uint32_t height1 = 600;
5116 RectI rect1{left1, top1, width1, height1};
5117 Occlusion::Region region1{rect1};
5118 uint32_t left2 = 0;
5119 uint32_t top2 = 0;
5120 uint32_t width2 = 200;
5121 uint32_t height2 = 300;
5122 RectI rect2{left2, top2, width2, height2};
5123 rsUniRenderVisitor->transparentCleanFilter_[surfaceNode->GetId()].push_back({id0, rect2});
5124 rsUniRenderVisitor->transparentCleanFilter_[surfaceNode->GetId()].push_back({id1, rect2});
5125 rsUniRenderVisitor->transparentCleanFilter_[surfaceNode->GetId()].push_back({id2, rect2});
5126 float blurRadiusX = 1.0f;
5127 float blurRadiusY = 1.0f;
5128 std::shared_ptr<RSFilter> filter = RSFilter::CreateBlurFilter(blurRadiusX, blurRadiusY);
5129 ASSERT_NE(node2->renderContent_, nullptr);
5130 node2->renderContent_->renderProperties_.SetBackgroundFilter(filter);
5131 node2->renderContent_->renderProperties_.SetFilter(filter);
5132 NodeId displayNodeId = 3;
5133 RSDisplayNodeConfig config;
5134 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(displayNodeId, config);
5135 rsUniRenderVisitor->curDisplayNode_->InitRenderParams();
5136 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
5137
5138 rsUniRenderVisitor->CheckMergeDisplayDirtyByTransparentFilter(surfaceNode, region1);
5139 }
5140
5141 /*
5142 * @tc.name: CheckMergeDisplayDirtyByTransparentRegions
5143 * @tc.desc: Test RSUniRenderVisitorTest.CheckMergeDisplayDirtyByTransparentRegions with container window
5144 * @tc.type: FUNC
5145 * @tc.require: issuesI9V0N7
5146 */
5147 HWTEST_F(RSUniRenderVisitorTest, CheckMergeDisplayDirtyByTransparentRegions001, TestSize.Level2)
5148 {
5149 RSSurfaceRenderNodeConfig surfaceConfig;
5150 surfaceConfig.id = 1;
5151 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
5152 ASSERT_NE(surfaceNode, nullptr);
5153 uint32_t left1 = 0;
5154 uint32_t top1 = 0;
5155 uint32_t width1 = 200;
5156 uint32_t height1 = 300;
5157 RectI rect{left1, top1, width1, height1};
5158 surfaceNode->GetDirtyManager()->SetCurrentFrameDirtyRect(rect);
5159 surfaceNode->containerConfig_.hasContainerWindow_ = true;
5160 uint32_t left2 = 0;
5161 uint32_t top2 = 0;
5162 uint32_t width2 = 260;
5163 uint32_t height2 = 600;
5164 RectI rect1{left2, top2, width2, height2};
5165 Occlusion::Region region1{rect1};
5166 surfaceNode->containerRegion_ = region1;
5167
5168 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5169 ASSERT_NE(rsUniRenderVisitor, nullptr);
5170 NodeId displayNodeId = 3;
5171 RSDisplayNodeConfig config;
5172 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(displayNodeId, config);
5173 rsUniRenderVisitor->curDisplayNode_->InitRenderParams();
5174 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
5175 rsUniRenderVisitor->CheckMergeDisplayDirtyByTransparentRegions(*surfaceNode);
5176 }
5177
5178 /*
5179 * @tc.name: CheckMergeDisplayDirtyByTransparentRegions
5180 * @tc.desc: Test RSUniRenderVisitorTest.CheckMergeDisplayDirtyByTransparentRegions with no container window
5181 * @tc.type: FUNC
5182 * @tc.require: issuesI9V0N7
5183 */
5184 HWTEST_F(RSUniRenderVisitorTest, CheckMergeDisplayDirtyByTransparentRegions002, TestSize.Level2)
5185 {
5186 RSSurfaceRenderNodeConfig surfaceConfig;
5187 surfaceConfig.id = 1;
5188 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceConfig);
5189 ASSERT_NE(surfaceNode, nullptr);
5190 surfaceNode->isNodeDirty_ = true;
5191 uint32_t left = 0;
5192 uint32_t top = 0;
5193 uint32_t width = 260;
5194 uint32_t height = 600;
5195 Occlusion::Rect rect1{left, top, width, height};
5196 Occlusion::Region region1{rect1};
5197 surfaceNode->transparentRegion_ = region1;
5198
5199 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5200 ASSERT_NE(rsUniRenderVisitor, nullptr);
5201 NodeId displayNodeId = 3;
5202 RSDisplayNodeConfig config;
5203 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(displayNodeId, config);
5204 rsUniRenderVisitor->curDisplayNode_->InitRenderParams();
5205 ASSERT_NE(rsUniRenderVisitor->curDisplayNode_, nullptr);
5206 rsUniRenderVisitor->CheckMergeDisplayDirtyByTransparentRegions(*surfaceNode);
5207 }
5208
5209 /**
5210 * @tc.name: UpdateHwcNodeInfoForAppNode
5211 * @tc.desc: Test RSUniRenderVisitorTest.UpdateHwcNodeInfoForAppNode with not nullptr
5212 * @tc.type: FUNC
5213 * @tc.require: issuesIAE6YM
5214 */
5215 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeInfoForAppNode, TestSize.Level2)
5216 {
5217 auto rsSurfaceRenderNode = RSTestUtil::CreateSurfaceNode();
5218 ASSERT_NE(rsSurfaceRenderNode, nullptr);
5219
5220 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5221 ASSERT_NE(rsUniRenderVisitor, nullptr);
5222 rsUniRenderVisitor->UpdateHwcNodeInfoForAppNode(*rsSurfaceRenderNode);
5223 }
5224
5225 /**
5226 * @tc.name: UpdateHwcNodeRectInSkippedSubTree
5227 * @tc.desc: Test RSUnitRenderVisitorTest.UpdateHwcNodeRectInSkippedSubTree with not nullptr
5228 * @tc.type: FUNC
5229 * @tc.require: issuesIAE6YM
5230 */
5231 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeRectInSkippedSubTree, TestSize.Level2)
5232 {
5233 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5234 ASSERT_NE(rsUniRenderVisitor, nullptr);
5235
5236 int id = 0;
5237 auto node = std::make_shared<RSRenderNode>(id);
5238 rsUniRenderVisitor->UpdateHwcNodeRectInSkippedSubTree(*node);
5239 }
5240
5241 /**
5242 * @tc.name: UpdateHwcNodeEnableByGlobalFilter
5243 * @tc.desc: Test RSUnitRenderVisitorTest.UpdateHwcNodeEnableByGlobalFilter with not nullptr
5244 * @tc.type: FUNC
5245 * @tc.require: issuesIAE6YM
5246 */
5247 HWTEST_F(RSUniRenderVisitorTest, UpdateHwcNodeEnableByGlobalFilter, TestSize.Level2)
5248 {
5249 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5250 ASSERT_NE(rsUniRenderVisitor, nullptr);
5251
5252 NodeId id = 0;
5253 std::weak_ptr<RSContext> context;
5254 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
5255 ASSERT_NE(node, nullptr);
5256 NodeId displayNodeId = 3;
5257 RSDisplayNodeConfig config;
5258 rsUniRenderVisitor->curDisplayNode_ = std::make_shared<RSDisplayRenderNode>(displayNodeId, config);
5259 rsUniRenderVisitor->curDisplayNode_->InitRenderParams();
5260
5261 rsUniRenderVisitor->UpdateHwcNodeEnableByGlobalFilter(node);
5262 }
5263
5264 /**
5265 * @tc.name: CollectEffectInfo001
5266 * @tc.desc: Test RSUnitRenderVisitorTest.CollectEffectInfo with not parent node.
5267 * @tc.type: FUNC
5268 * @tc.require: issueIAG8BF
5269 */
5270 HWTEST_F(RSUniRenderVisitorTest, CollectEffectInfo001, TestSize.Level2)
5271 {
5272 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5273 ASSERT_NE(rsUniRenderVisitor, nullptr);
5274 constexpr NodeId nodeId = 1;
5275 auto node = std::make_shared<RSRenderNode>(nodeId);
5276 ASSERT_NE(node, nullptr);
5277 rsUniRenderVisitor->CollectEffectInfo(*node);
5278 }
5279
5280 /**
5281 * @tc.name: CollectEffectInfo002
5282 * @tc.desc: Test RSUnitRenderVisitorTest.CollectEffectInfo with parent node, need filter
5283 * @tc.type: FUNC
5284 * @tc.require: issueIAG8BF
5285 */
5286 HWTEST_F(RSUniRenderVisitorTest, CollectEffectInfo002, TestSize.Level2)
5287 {
5288 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5289 ASSERT_NE(rsUniRenderVisitor, nullptr);
5290 constexpr NodeId nodeId = 1;
5291 constexpr NodeId parentNodeId = 2;
5292 auto node = std::make_shared<RSRenderNode>(nodeId);
5293 ASSERT_NE(node, nullptr);
5294 auto parent = std::make_shared<RSRenderNode>(parentNodeId);
5295 ASSERT_NE(parent, nullptr);
5296 node->InitRenderParams();
5297 parent->InitRenderParams();
5298 parent->AddChild(node);
5299 node->GetMutableRenderProperties().needFilter_ = true;
5300 rsUniRenderVisitor->CollectEffectInfo(*node);
5301 ASSERT_TRUE(parent->ChildHasVisibleFilter());
5302 }
5303
5304 /**
5305 * @tc.name: CollectEffectInfo003
5306 * @tc.desc: Test RSUnitRenderVisitorTest.CollectEffectInfo with parent node, useEffect
5307 * @tc.type: FUNC
5308 * @tc.require: issueIAG8BF
5309 */
5310 HWTEST_F(RSUniRenderVisitorTest, CollectEffectInfo003, TestSize.Level2)
5311 {
5312 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5313 ASSERT_NE(rsUniRenderVisitor, nullptr);
5314 constexpr NodeId nodeId = 1;
5315 constexpr NodeId parentNodeId = 2;
5316 auto node = std::make_shared<RSRenderNode>(nodeId);
5317 ASSERT_NE(node, nullptr);
5318 auto parent = std::make_shared<RSRenderNode>(parentNodeId);
5319 ASSERT_NE(parent, nullptr);
5320 node->InitRenderParams();
5321 parent->InitRenderParams();
5322 parent->AddChild(node);
5323 node->GetMutableRenderProperties().useEffect_ = true;
5324 rsUniRenderVisitor->CollectEffectInfo(*node);
5325 ASSERT_TRUE(parent->ChildHasVisibleEffect());
5326 }
5327
5328 /*
5329 * @tc.name: CheckIsGpuOverDrawBufferOptimizeNode001
5330 * @tc.desc: Verify function CheckIsGpuOverDrawBufferOptimizeNode while node has no child
5331 * @tc.type: FUNC
5332 * @tc.require: issuesIAE0Q3
5333 */
5334 HWTEST_F(RSUniRenderVisitorTest, CheckIsGpuOverDrawBufferOptimizeNode001, TestSize.Level2)
5335 {
5336 auto rsContext = std::make_shared<RSContext>();
5337 ASSERT_NE(rsContext, nullptr);
5338 RSSurfaceRenderNodeConfig config;
5339 config.id = 1;
5340 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
5341 ASSERT_NE(surfaceNode, nullptr);
5342
5343 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5344 ASSERT_NE(rsUniRenderVisitor, nullptr);
5345 rsUniRenderVisitor->CheckIsGpuOverDrawBufferOptimizeNode(*surfaceNode);
5346 ASSERT_FALSE(surfaceNode->IsGpuOverDrawBufferOptimizeNode());
5347 }
5348
5349 /*
5350 * @tc.name: CheckIsGpuOverDrawBufferOptimizeNode002
5351 * @tc.desc: Verify function CheckIsGpuOverDrawBufferOptimizeNode while node has child
5352 * @tc.type: FUNC
5353 * @tc.require: issuesIAE0Q3
5354 */
5355 HWTEST_F(RSUniRenderVisitorTest, CheckIsGpuOverDrawBufferOptimizeNode002, TestSize.Level2)
5356 {
5357 auto rsContext = std::make_shared<RSContext>();
5358 ASSERT_NE(rsContext, nullptr);
5359 RSSurfaceRenderNodeConfig config;
5360 config.id = 1;
5361 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(config, rsContext->weak_from_this());
5362 ASSERT_NE(surfaceNode, nullptr);
5363 surfaceNode->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
5364 surfaceNode->SetIsScale(true);
5365
5366 NodeId childNodeId = config.id + 1;
5367 auto childNode = std::make_shared<RSSurfaceRenderNode>(childNodeId);
5368 surfaceNode->AddChild(childNode, -1);
5369 surfaceNode->GenerateFullChildrenList();
5370
5371 NodeId rootNodeId = childNodeId + 1;
5372 auto rootNode = std::make_shared<RSRenderNode>(rootNodeId);
5373 childNode->AddChild(rootNode, -1);
5374
5375 NodeId canvasNodeId = rootNodeId + 1;
5376 auto canvasNode = std::make_shared<RSRenderNode>(canvasNodeId);
5377 auto& properties = canvasNode->GetMutableRenderProperties();
5378 Color color(0, 0, 0, MAX_ALPHA);
5379 properties.SetBackgroundColor(color);
5380 rootNode->AddChild(canvasNode, -1);
5381
5382 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5383 ASSERT_NE(rsUniRenderVisitor, nullptr);
5384 rsUniRenderVisitor->curCornerRadius_ = {1.0f, 1.0f, 1.0f, 1.0f};
5385 rsUniRenderVisitor->CheckIsGpuOverDrawBufferOptimizeNode(*surfaceNode);
5386 ASSERT_TRUE(surfaceNode->IsGpuOverDrawBufferOptimizeNode());
5387 }
5388
5389 /*
5390 * @tc.name: CollectFilterInfoAndUpdateDirty001
5391 * @tc.desc: Verify function CollectFilterInfoAndUpdateDirty without curSurfaceNode_
5392 * @tc.type: FUNC
5393 * @tc.require: issuesIAE0Q3
5394 */
5395 HWTEST_F(RSUniRenderVisitorTest, CollectFilterInfoAndUpdateDirty001, TestSize.Level2)
5396 {
5397 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5398 ASSERT_NE(rsUniRenderVisitor, nullptr);
5399
5400 auto surfaceNode = RSTestUtil::CreateSurfaceNode();
5401 ASSERT_NE(surfaceNode, nullptr);
5402 auto dirtyManager = surfaceNode->GetDirtyManager();
5403 ASSERT_NE(dirtyManager, nullptr);
5404 NodeId nodeId = 1;
5405 auto node = std::make_shared<RSRenderNode>(nodeId);
5406 RectI rect(0, 0, 0, 0);
5407
5408 ASSERT_TRUE(rsUniRenderVisitor->containerFilter_.empty());
5409 rsUniRenderVisitor->CollectFilterInfoAndUpdateDirty(*node, *dirtyManager, rect);
5410 ASSERT_FALSE(rsUniRenderVisitor->containerFilter_.empty());
5411 }
5412
5413 /*
5414 * @tc.name: CollectFilterInfoAndUpdateDirty002
5415 * @tc.desc: Verify function CollectFilterInfoAndUpdateDirty with non-transparent curSurfaceNode_
5416 * @tc.type: FUNC
5417 * @tc.require: issuesIAE0Q3
5418 */
5419 HWTEST_F(RSUniRenderVisitorTest, CollectFilterInfoAndUpdateDirty002, TestSize.Level2)
5420 {
5421 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5422 ASSERT_NE(rsUniRenderVisitor, nullptr);
5423 NodeId surfaceNodeId = 1;
5424 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceNodeId);
5425 surfaceNode->SetAbilityBGAlpha(MAX_ALPHA);
5426 rsUniRenderVisitor->curSurfaceNode_ = surfaceNode;
5427
5428 auto dirtyManager = surfaceNode->GetDirtyManager();
5429 ASSERT_NE(dirtyManager, nullptr);
5430 NodeId nodeId = surfaceNodeId + 1;
5431 auto node = std::make_shared<RSRenderNode>(nodeId);
5432 RectI rect(0, 0, 0, 0);
5433
5434 ASSERT_TRUE(rsUniRenderVisitor->globalFilter_.empty());
5435 rsUniRenderVisitor->CollectFilterInfoAndUpdateDirty(*node, *dirtyManager, rect);
5436 ASSERT_FALSE(rsUniRenderVisitor->globalFilter_.empty());
5437 }
5438
5439 /*
5440 * @tc.name: CollectFilterInfoAndUpdateDirty003
5441 * @tc.desc: Verify function CollectFilterInfoAndUpdateDirty with transparent curSurfaceNode_
5442 * @tc.type: FUNC
5443 * @tc.require: issuesIAE0Q3
5444 */
5445 HWTEST_F(RSUniRenderVisitorTest, CollectFilterInfoAndUpdateDirty003, TestSize.Level2)
5446 {
5447 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5448 ASSERT_NE(rsUniRenderVisitor, nullptr);
5449 NodeId surfaceNodeId = 1;
5450 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(surfaceNodeId);
5451 surfaceNode->SetAbilityBGAlpha(0);
5452 rsUniRenderVisitor->curSurfaceNode_ = surfaceNode;
5453
5454 auto dirtyManager = surfaceNode->GetDirtyManager();
5455 ASSERT_NE(dirtyManager, nullptr);
5456 NodeId nodeId = surfaceNodeId + 1;
5457 auto node = std::make_shared<RSRenderNode>(nodeId);
5458 RectI rect(0, 0, 0, 0);
5459
5460 ASSERT_TRUE(rsUniRenderVisitor->transparentCleanFilter_.empty());
5461 rsUniRenderVisitor->CollectFilterInfoAndUpdateDirty(*node, *dirtyManager, rect);
5462 ASSERT_FALSE(rsUniRenderVisitor->transparentCleanFilter_.empty());
5463 }
5464
5465 /**
5466 * @tc.name: UpdateHardwareStateByHwcNodeBackgroundAlpha
5467 * @tc.desc: Test RSUnitRenderVisitorTest.UpdateHardwareStateByHwcNodeBackgroundAlpha
5468 * @tc.type: FUNC
5469 * @tc.require: IAHFXD
5470 */
5471 HWTEST_F(RSUniRenderVisitorTest, UpdateHardwareStateByHwcNodeBackgroundAlpha, TestSize.Level1)
5472 {
5473 std::vector<std::weak_ptr<RSSurfaceRenderNode>> hwcNodes;
5474 std::weak_ptr<RSSurfaceRenderNode> hwcNode;
5475 hwcNodes.push_back(hwcNode);
5476 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5477 rsUniRenderVisitor->UpdateHardwareStateByHwcNodeBackgroundAlpha(hwcNodes);
5478 }
5479
5480 /**
5481 * @tc.name: IsNodeAboveInsideOfNodeBelow
5482 * @tc.desc: Test RSUnitRenderVisitorTest.IsNodeAboveInsideOfNodeBelow
5483 * @tc.type: FUNC
5484 * @tc.require: IAHFXD
5485 */
5486 HWTEST_F(RSUniRenderVisitorTest, IsNodeAboveInsideOfNodeBelow, TestSize.Level1)
5487 {
5488 const RectI rectAbove;
5489 std::list<RectI> hwcNodeRectList;
5490 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5491 rsUniRenderVisitor->IsNodeAboveInsideOfNodeBelow(rectAbove, hwcNodeRectList);
5492 }
5493
5494 /**
5495 * @tc.name: IsFirstFrameOfOverdrawSwitch
5496 * @tc.desc: Test IsFirstFrameOfOverdrawSwitch
5497 * @tc.type: FUNC
5498 * @tc.require: issueIAJSIS
5499 */
5500 HWTEST_F(RSUniRenderVisitorTest, IsFirstFrameOfOverdrawSwitch, TestSize.Level1)
5501 {
5502 auto rsUniRenderVisitor = std::make_shared<RSUniRenderVisitor>();
5503 ASSERT_NE(rsUniRenderVisitor, nullptr);
5504 ASSERT_EQ(rsUniRenderVisitor->IsFirstFrameOfOverdrawSwitch(), false);
5505 }
5506
5507 } // OHOS::Rosen