1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, Hardware
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "pipeline/rs_context.h"
19 #include "params/rs_surface_render_params.h"
20 #include "pipeline/rs_render_thread_visitor.h"
21 #include "pipeline/rs_effect_render_node.h"
22 #include "pipeline/rs_surface_render_node.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 class RSSurfaceRenderNodeTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35 static inline NodeId id;
36 static inline std::weak_ptr<RSContext> context = {};
37 static inline RSPaintFilterCanvas* canvas_;
38 static inline Drawing::Canvas drawingCanvas_;
39 uint8_t MAX_ALPHA = 255;
40 };
41
SetUpTestCase()42 void RSSurfaceRenderNodeTest::SetUpTestCase()
43 {
44 canvas_ = new RSPaintFilterCanvas(&drawingCanvas_);
45 }
TearDownTestCase()46 void RSSurfaceRenderNodeTest::TearDownTestCase()
47 {
48 delete canvas_;
49 canvas_ = nullptr;
50 }
SetUp()51 void RSSurfaceRenderNodeTest::SetUp() {}
TearDown()52 void RSSurfaceRenderNodeTest::TearDown() {}
53
54 /**
55 * @tc.name: SetContextMatrix001
56 * @tc.desc: test
57 * @tc.type:FUNC
58 * @tc.require:
59 */
60 HWTEST_F(RSSurfaceRenderNodeTest, SetContextMatrix001, TestSize.Level1)
61 {
62 RSSurfaceRenderNode surfaceRenderNode(id, context);
63 Drawing::Matrix matrix;
64 bool sendMsg = false;
65 surfaceRenderNode.SetContextMatrix(matrix, sendMsg);
66 }
67
68 /**
69 * @tc.name: SetContextClipRegion001
70 * @tc.desc: test
71 * @tc.type:FUNC
72 * @tc.require:
73 */
74 HWTEST_F(RSSurfaceRenderNodeTest, SetContextClipRegion001, TestSize.Level1)
75 {
76 RSSurfaceRenderNode surfaceRenderNode(id, context);
77 Drawing::Rect clipRegion { 0, 0, 0, 0 };
78 bool sendMsg = false;
79 surfaceRenderNode.SetContextClipRegion(clipRegion, sendMsg);
80 }
81
82 /**
83 * @tc.name: ConnectToNodeInRenderService001
84 * @tc.desc: test
85 * @tc.type:FUNC
86 * @tc.require:
87 */
88 HWTEST_F(RSSurfaceRenderNodeTest, ConnectToNodeInRenderService001, TestSize.Level1)
89 {
90 RSSurfaceRenderNode surfaceRenderNode(id, context);
91 surfaceRenderNode.ConnectToNodeInRenderService();
92 }
93
94 /**
95 * @tc.name: SetSurfaceNodeType001
96 * @tc.desc: Test SetSurfaceNodeType
97 * @tc.type: FUNC
98 * @tc.require: issueIAI1VN
99 */
100 HWTEST_F(RSSurfaceRenderNodeTest, SetSurfaceNodeType001, TestSize.Level1)
101 {
102 NodeId id = 1;
103 RSSurfaceNodeType type = RSSurfaceNodeType::DEFAULT;
104 RSSurfaceRenderNodeConfig config = { .id = id, .nodeType = type };
105 auto node = std::make_shared<RSSurfaceRenderNode>(config);
106 EXPECT_NE(node, nullptr);
107 node->SetSurfaceNodeType(RSSurfaceNodeType::ABILITY_COMPONENT_NODE);
108 bool isSameType = (node->GetSurfaceNodeType() == RSSurfaceNodeType::ABILITY_COMPONENT_NODE);
109 EXPECT_TRUE(isSameType);
110 node->SetSurfaceNodeType(RSSurfaceNodeType::DEFAULT);
111 isSameType = (node->GetSurfaceNodeType() == RSSurfaceNodeType::DEFAULT);
112 EXPECT_FALSE(isSameType);
113 }
114
115 /**
116 * @tc.name: SetSurfaceNodeType002
117 * @tc.desc: Test SetSurfaceNodeType
118 * @tc.type: FUNC
119 * @tc.require: issueIAN19G
120 */
121 HWTEST_F(RSSurfaceRenderNodeTest, SetSurfaceNodeType002, TestSize.Level1)
122 {
123 NodeId id = 1;
124 RSSurfaceNodeType type = RSSurfaceNodeType::DEFAULT;
125 RSSurfaceRenderNodeConfig config = { .id = id, .nodeType = type };
126 auto node = std::make_shared<RSSurfaceRenderNode>(config);
127 EXPECT_NE(node, nullptr);
128 node->SetSurfaceNodeType(RSSurfaceNodeType::UI_EXTENSION_COMMON_NODE);
129 bool isSameType = (node->GetSurfaceNodeType() == RSSurfaceNodeType::DEFAULT);
130 EXPECT_TRUE(isSameType);
131 node->SetSurfaceNodeType(RSSurfaceNodeType::UI_EXTENSION_SECURE_NODE);
132 isSameType = (node->GetSurfaceNodeType() == RSSurfaceNodeType::DEFAULT);
133 EXPECT_TRUE(isSameType);
134 }
135
136 /**
137 * @tc.name: SetSurfaceNodeType003
138 * @tc.desc: Test SetSurfaceNodeType
139 * @tc.type: FUNC
140 * @tc.require: issueIAN19G
141 */
142 HWTEST_F(RSSurfaceRenderNodeTest, SetSurfaceNodeType003, TestSize.Level1)
143 {
144 NodeId id = 1;
145 RSSurfaceNodeType type = RSSurfaceNodeType::UI_EXTENSION_COMMON_NODE;
146 RSSurfaceRenderNodeConfig config = { .id = id, .nodeType = type };
147 auto node = std::make_shared<RSSurfaceRenderNode>(config);
148 EXPECT_NE(node, nullptr);
149 node->SetSurfaceNodeType(RSSurfaceNodeType::DEFAULT);
150 bool isSameType = (node->GetSurfaceNodeType() == RSSurfaceNodeType::UI_EXTENSION_COMMON_NODE);
151 EXPECT_TRUE(isSameType);
152 }
153
154 /**
155 * @tc.name: SetSurfaceNodeType004
156 * @tc.desc: Test SetSurfaceNodeType
157 * @tc.type: FUNC
158 * @tc.require: issueIAN19G
159 */
160 HWTEST_F(RSSurfaceRenderNodeTest, SetSurfaceNodeType004, TestSize.Level1)
161 {
162 NodeId id = 1;
163 RSSurfaceNodeType type = RSSurfaceNodeType::UI_EXTENSION_SECURE_NODE;
164 RSSurfaceRenderNodeConfig config = { .id = id, .nodeType = type };
165 auto node = std::make_shared<RSSurfaceRenderNode>(config);
166 EXPECT_NE(node, nullptr);
167 node->SetSurfaceNodeType(RSSurfaceNodeType::DEFAULT);
168 bool isSameType = (node->GetSurfaceNodeType() == RSSurfaceNodeType::UI_EXTENSION_SECURE_NODE);
169 EXPECT_TRUE(isSameType);
170 }
171
172 /**
173 * @tc.name: ClearChildrenCache001
174 * @tc.desc: test
175 * @tc.type:FUNC
176 * @tc.require:
177 */
178 HWTEST_F(RSSurfaceRenderNodeTest, ClearChildrenCache001, TestSize.Level1)
179 {
180 RSSurfaceRenderNode surfaceRenderNode(id, context);
181 surfaceRenderNode.ResetParent();
182 }
183
184 /**
185 * @tc.name: ResetSurfaceOpaqueRegion02
186 * @tc.desc: function test
187 * @tc.type:FUNC
188 * @tc.require: I6HF6Y
189 */
190 HWTEST_F(RSSurfaceRenderNodeTest, ResetSurfaceOpaqueRegion02, TestSize.Level1)
191 {
192 RSSurfaceRenderNode surfaceRenderNode(id, context);
193 RectI screenRect {0, 0, 2560, 1600};
194 RectI absRect {0, 100, 400, 500};
195 surfaceRenderNode.SetAbilityBGAlpha(0);
196 Vector4f cornerRadius;
197 Vector4f::Max(
198 surfaceRenderNode.GetWindowCornerRadius(), surfaceRenderNode.GetGlobalCornerRadius(), cornerRadius);
199 Vector4<int> dstCornerRadius(static_cast<int>(std::ceil(cornerRadius.x_)),
200 static_cast<int>(std::ceil(cornerRadius.y_)),
201 static_cast<int>(std::ceil(cornerRadius.z_)),
202 static_cast<int>(std::ceil(cornerRadius.w_)));
203 surfaceRenderNode.ResetSurfaceOpaqueRegion(
204 screenRect, absRect, ScreenRotation::ROTATION_0, false, dstCornerRadius);
205 surfaceRenderNode.ResetSurfaceOpaqueRegion(
206 screenRect, absRect, ScreenRotation::ROTATION_0, true, dstCornerRadius);
207 }
208
209 /**
210 * @tc.name: ResetSurfaceOpaqueRegion03
211 * @tc.desc: function test
212 * @tc.type:FUNC
213 * @tc.require: I6HF6Y
214 */
215 HWTEST_F(RSSurfaceRenderNodeTest, ResetSurfaceOpaqueRegion03, TestSize.Level1)
216 {
217 RSSurfaceRenderNode surfaceRenderNode(id, context);
218 RectI screenRect {0, 0, 2560, 1600};
219 RectI absRect {0, 100, 400, 500};
220 surfaceRenderNode.SetAbilityBGAlpha(255);
221 surfaceRenderNode.SetGlobalAlpha(1.0f);
222 surfaceRenderNode.SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
223 surfaceRenderNode.SetContainerWindow(true, 1.0f);
224 Vector4f cornerRadius;
225 Vector4f::Max(
226 surfaceRenderNode.GetWindowCornerRadius(), surfaceRenderNode.GetGlobalCornerRadius(), cornerRadius);
227 Vector4<int> dstCornerRadius(static_cast<int>(std::ceil(cornerRadius.x_)),
228 static_cast<int>(std::ceil(cornerRadius.y_)),
229 static_cast<int>(std::ceil(cornerRadius.z_)),
230 static_cast<int>(std::ceil(cornerRadius.w_)));
231 surfaceRenderNode.ResetSurfaceOpaqueRegion(
232 screenRect, absRect, ScreenRotation::ROTATION_0, false, dstCornerRadius);
233 surfaceRenderNode.ResetSurfaceOpaqueRegion(
234 screenRect, absRect, ScreenRotation::ROTATION_0, true, dstCornerRadius);
235 }
236
237 /**
238 * @tc.name: ResetSurfaceOpaqueRegion04
239 * @tc.desc: function test
240 * @tc.type:FUNC
241 * @tc.require: I6HF6Y
242 */
243 HWTEST_F(RSSurfaceRenderNodeTest, ResetSurfaceOpaqueRegion04, TestSize.Level1)
244 {
245 RSSurfaceRenderNode surfaceRenderNode(id, context);
246 RectI screenRect {0, 0, 2560, 1600};
247 RectI absRect {0, 100, 400, 500};
248 surfaceRenderNode.SetAbilityBGAlpha(255);
249 surfaceRenderNode.SetGlobalAlpha(1.0f);
250 surfaceRenderNode.GetMutableRenderProperties().SetCornerRadius(Vector4f(15.0f));
251 Vector4f cornerRadius;
252 Vector4f::Max(
253 surfaceRenderNode.GetWindowCornerRadius(), surfaceRenderNode.GetGlobalCornerRadius(), cornerRadius);
254 Vector4<int> dstCornerRadius(static_cast<int>(std::ceil(cornerRadius.x_)),
255 static_cast<int>(std::ceil(cornerRadius.y_)),
256 static_cast<int>(std::ceil(cornerRadius.z_)),
257 static_cast<int>(std::ceil(cornerRadius.w_)));
258 surfaceRenderNode.ResetSurfaceOpaqueRegion(
259 screenRect, absRect, ScreenRotation::ROTATION_0, false, dstCornerRadius);
260 surfaceRenderNode.ResetSurfaceOpaqueRegion(
261 screenRect, absRect, ScreenRotation::ROTATION_0, true, dstCornerRadius);
262 }
263
264 /**
265 * @tc.name: ResetSurfaceOpaqueRegion05
266 * @tc.desc: function test
267 * @tc.type:FUNC
268 * @tc.require: I6HF6Y
269 */
270 HWTEST_F(RSSurfaceRenderNodeTest, ResetSurfaceOpaqueRegion05, TestSize.Level1)
271 {
272 RSSurfaceRenderNode surfaceRenderNode(id, context);
273 RectI screenRect {0, 0, 2560, 1600};
274 RectI absRect {0, 100, 400, 500};
275 surfaceRenderNode.SetAbilityBGAlpha(255);
276 surfaceRenderNode.SetGlobalAlpha(1.0f);
277 surfaceRenderNode.SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
278 surfaceRenderNode.SetContainerWindow(true, 1.0f);
279 Vector4f cornerRadius;
280 Vector4f::Max(
281 surfaceRenderNode.GetWindowCornerRadius(), surfaceRenderNode.GetGlobalCornerRadius(), cornerRadius);
282 Vector4<int> dstCornerRadius(static_cast<int>(std::ceil(cornerRadius.x_)),
283 static_cast<int>(std::ceil(cornerRadius.y_)),
284 static_cast<int>(std::ceil(cornerRadius.z_)),
285 static_cast<int>(std::ceil(cornerRadius.w_)));
286 surfaceRenderNode.ResetSurfaceOpaqueRegion(
287 screenRect, absRect, ScreenRotation::ROTATION_90, false, dstCornerRadius);
288 surfaceRenderNode.ResetSurfaceOpaqueRegion(
289 screenRect, absRect, ScreenRotation::ROTATION_90, true, dstCornerRadius);
290 }
291
292 /**
293 * @tc.name: ResetSurfaceOpaqueRegion06
294 * @tc.desc: function test
295 * @tc.type:FUNC
296 * @tc.require: I6HF6Y
297 */
298 HWTEST_F(RSSurfaceRenderNodeTest, ResetSurfaceOpaqueRegion06, TestSize.Level1)
299 {
300 RSSurfaceRenderNode surfaceRenderNode(id, context);
301 RectI screenRect {0, 0, 2560, 1600};
302 RectI absRect {0, 100, 400, 500};
303 surfaceRenderNode.SetAbilityBGAlpha(255);
304 surfaceRenderNode.SetGlobalAlpha(1.0f);
305 surfaceRenderNode.SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
306 surfaceRenderNode.SetContainerWindow(true, 1.0f);
307 Vector4f cornerRadius;
308 Vector4f::Max(
309 surfaceRenderNode.GetWindowCornerRadius(), surfaceRenderNode.GetGlobalCornerRadius(), cornerRadius);
310 Vector4<int> dstCornerRadius(static_cast<int>(std::ceil(cornerRadius.x_)),
311 static_cast<int>(std::ceil(cornerRadius.y_)),
312 static_cast<int>(std::ceil(cornerRadius.z_)),
313 static_cast<int>(std::ceil(cornerRadius.w_)));
314 surfaceRenderNode.ResetSurfaceOpaqueRegion(
315 screenRect, absRect, ScreenRotation::ROTATION_180, false, dstCornerRadius);
316 surfaceRenderNode.ResetSurfaceOpaqueRegion(
317 screenRect, absRect, ScreenRotation::ROTATION_180, true, dstCornerRadius);
318 }
319
320 /**
321 * @tc.name: ResetSurfaceOpaqueRegion07
322 * @tc.desc: function test
323 * @tc.type:FUNC
324 * @tc.require: I6HF6Y
325 */
326 HWTEST_F(RSSurfaceRenderNodeTest, ResetSurfaceOpaqueRegion07, TestSize.Level1)
327 {
328 RSSurfaceRenderNode surfaceRenderNode(id, context);
329 RectI screenRect {0, 0, 2560, 1600};
330 RectI absRect {0, 100, 400, 500};
331 surfaceRenderNode.SetAbilityBGAlpha(255);
332 surfaceRenderNode.SetGlobalAlpha(1.0f);
333 surfaceRenderNode.SetSurfaceNodeType(RSSurfaceNodeType::APP_WINDOW_NODE);
334 surfaceRenderNode.SetContainerWindow(true, 1.0f);
335 Vector4f cornerRadius;
336 Vector4f::Max(
337 surfaceRenderNode.GetWindowCornerRadius(), surfaceRenderNode.GetGlobalCornerRadius(), cornerRadius);
338 Vector4<int> dstCornerRadius(static_cast<int>(std::ceil(cornerRadius.x_)),
339 static_cast<int>(std::ceil(cornerRadius.y_)),
340 static_cast<int>(std::ceil(cornerRadius.z_)),
341 static_cast<int>(std::ceil(cornerRadius.w_)));
342 surfaceRenderNode.ResetSurfaceOpaqueRegion(
343 screenRect, absRect, ScreenRotation::ROTATION_270, false, dstCornerRadius);
344 surfaceRenderNode.ResetSurfaceOpaqueRegion(
345 screenRect, absRect, ScreenRotation::ROTATION_270, true, dstCornerRadius);
346 }
347
348 /**
349 * @tc.name: SetNodeCostTest
350 * @tc.desc: function test
351 * @tc.type:FUNC
352 * @tc.require: issueI6FZHQ
353 */
354 HWTEST_F(RSSurfaceRenderNodeTest, SetNodeCostTest, TestSize.Level1)
355 {
356 RSSurfaceRenderNode surfaceRenderNode(id, context);
357 auto result = surfaceRenderNode.nodeCost_;
358 ASSERT_EQ(0, result);
359 surfaceRenderNode.SetNodeCost(6);
360 result = surfaceRenderNode.nodeCost_;
361 ASSERT_EQ(6, result);
362 }
363
364 /**
365 * @tc.name: GetNodeCostTest
366 * @tc.desc: function test
367 * @tc.type:FUNC
368 * @tc.require: issueI6FZHQ
369 */
370 HWTEST_F(RSSurfaceRenderNodeTest, GetNodeCostTest, TestSize.Level1)
371 {
372 RSSurfaceRenderNode surfaceRenderNode(id, context);
373 auto result = surfaceRenderNode.nodeCost_;
374 ASSERT_EQ(0, result);
375 surfaceRenderNode.SetNodeCost(6);
376 result = surfaceRenderNode.GetNodeCost();
377 ASSERT_EQ(6, result);
378 }
379
380 /**
381 * @tc.name: Fingerprint Test
382 * @tc.desc: SetFingerprint and GetFingerprint
383 * @tc.type:FUNC
384 * @tc.require: issueI6Z3YK
385 */
386 HWTEST_F(RSSurfaceRenderNodeTest, FingerprintTest, TestSize.Level1)
387 {
388 RSSurfaceRenderNode surfaceRenderNode(id, context);
389 surfaceRenderNode.SetFingerprint(true);
390 auto result = surfaceRenderNode.GetFingerprint();
391 ASSERT_EQ(true, result);
392 surfaceRenderNode.SetFingerprint(false);
393 result = surfaceRenderNode.GetFingerprint();
394 ASSERT_EQ(false, result);
395 }
396
397 /**
398 * @tc.name: ShouldPrepareSubnodesTest
399 * @tc.desc: function test
400 * @tc.type:FUNC
401 * @tc.require:
402 */
403 HWTEST_F(RSSurfaceRenderNodeTest, ShouldPrepareSubnodesTest, TestSize.Level1)
404 {
405 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
406 node->ShouldPrepareSubnodes();
407 ASSERT_TRUE(node->ShouldPrepareSubnodes());
408 }
409
410 /**
411 * @tc.name: CollectSurfaceTest001
412 * @tc.desc: function test
413 * @tc.type:FUNC
414 * @tc.require:
415 */
416 HWTEST_F(RSSurfaceRenderNodeTest, CollectSurfaceTest001, TestSize.Level1)
417 {
418 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
419 std::shared_ptr<RSBaseRenderNode> rsBaseRenderNode;
420 std::vector<RSBaseRenderNode::SharedPtr> vec;
421 bool isUniRender = true;
422 node->nodeType_ = RSSurfaceNodeType::STARTING_WINDOW_NODE;
423 node->CollectSurface(rsBaseRenderNode, vec, isUniRender, false);
424 ASSERT_FALSE(vec.empty());
425 }
426
427 /**
428 * @tc.name: CollectSurfaceTest
429 * @tc.desc: function test
430 * @tc.type:FUNC
431 * @tc.require:
432 */
433 HWTEST_F(RSSurfaceRenderNodeTest, CollectSurfaceTest002, TestSize.Level1)
434 {
435 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
436 std::shared_ptr<RSBaseRenderNode> rsBaseRenderNode;
437 std::vector<RSBaseRenderNode::SharedPtr> vec;
438 bool isUniRender = true;
439 node->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
440 node->CollectSurface(rsBaseRenderNode, vec, isUniRender, true);
441 ASSERT_FALSE(vec.empty());
442 }
443
444 /**
445 * @tc.name: ProcessAnimatePropertyBeforeChildrenTest
446 * @tc.desc: function test
447 * @tc.type:FUNC
448 * @tc.require:
449 */
450 HWTEST_F(RSSurfaceRenderNodeTest, ProcessAnimatePropertyBeforeChildrenTest, TestSize.Level1)
451 {
452 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
453 node->ProcessAnimatePropertyBeforeChildren(*canvas_, true);
454 }
455
456 /**
457 * @tc.name: ProcessAnimatePropertyAfterChildrenTest
458 * @tc.desc: function test
459 * @tc.type:FUNC
460 * @tc.require:
461 */
462 HWTEST_F(RSSurfaceRenderNodeTest, ProcessAnimatePropertyAfterChildrenTest, TestSize.Level1)
463 {
464 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
465 node->ProcessAnimatePropertyAfterChildren(*canvas_);
466 }
467
468 /**
469 * @tc.name: SetContextMatrixTest
470 * @tc.desc: function test
471 * @tc.type:FUNC
472 * @tc.require:
473 */
474 HWTEST_F(RSSurfaceRenderNodeTest, SetContextMatrixTest, TestSize.Level1)
475 {
476 std::optional<Drawing::Matrix> matrix;
477 bool sendMsg = false;
478 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
479 node->SetContextMatrix(matrix, sendMsg);
480 }
481
482 /**
483 * @tc.name: RegisterBufferAvailableListenerTest
484 * @tc.desc: function test
485 * @tc.type:FUNC
486 * @tc.require:
487 */
488 HWTEST_F(RSSurfaceRenderNodeTest, RegisterBufferAvailableListenerTest, TestSize.Level1)
489 {
490 sptr<RSIBufferAvailableCallback> callback;
491 bool isFromRenderThread = true;
492 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
493 node->RegisterBufferAvailableListener(callback, isFromRenderThread);
494 }
495
496 /**
497 * @tc.name: SetBootAnimationTest
498 * @tc.desc: SetBootAnimation and GetBootAnimation
499 * @tc.type:FUNC
500 * @tc.require:SR000HSUII
501 */
502 HWTEST_F(RSSurfaceRenderNodeTest, SetBootAnimationTest, TestSize.Level1)
503 {
504 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
505 node->SetBootAnimation(true);
506 ASSERT_EQ(node->GetBootAnimation(), true);
507 node->SetBootAnimation(false);
508 ASSERT_FALSE(node->GetBootAnimation());
509 }
510
511 /**
512 * @tc.name: AncestorDisplayNodeTest
513 * @tc.desc: SetAncestorDisplayNode and GetAncestorDisplayNode
514 * @tc.type:FUNC
515 * @tc.require:
516 */
517 HWTEST_F(RSSurfaceRenderNodeTest, AncestorDisplayNodeTest, TestSize.Level1)
518 {
519 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
520 auto displayNode = std::make_shared<RSBaseRenderNode>(0, context);
521 node->SetAncestorDisplayNode(displayNode);
522 ASSERT_EQ(node->GetAncestorDisplayNode().lock(), displayNode);
523 }
524
525 /**
526 * @tc.name: UpdateSurfaceCacheContentStatic
527 * @tc.desc: Set dirty subnode and check if surfacenode static
528 * @tc.type:FUNC
529 * @tc.require:I8W7ZS
530 */
531 HWTEST_F(RSSurfaceRenderNodeTest, UpdateSurfaceCacheContentStatic, TestSize.Level1)
532 {
533 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
534 auto subnode = std::make_shared<RSRenderNode>(id + 1, context);
535 if (node == nullptr || subnode == nullptr) {
536 return;
537 }
538 node->AddChild(subnode, 0);
539 subnode->isContentDirty_ = true;
540 std::unordered_map<NodeId, std::weak_ptr<RSRenderNode>> activeNodeIds = {{subnode->GetId(), subnode}};
541 node->UpdateSurfaceCacheContentStatic(activeNodeIds);
542 ASSERT_EQ(node->GetSurfaceCacheContentStatic(), false);
543 ASSERT_EQ(node->IsContentDirtyNodeLimited(), true);
544 }
545
546 /**
547 * @tc.name: IsContentDirtyNodeLimited
548 * @tc.desc: Set content dirty subnode new on the tree and check if it is in count
549 * @tc.type:FUNC
550 * @tc.require:I8XIJH
551 */
552 HWTEST_F(RSSurfaceRenderNodeTest, IsContentDirtyNodeLimited, TestSize.Level1)
553 {
554 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
555 auto subnode = std::make_shared<RSRenderNode>(id + 1, context);
556 if (node == nullptr || subnode == nullptr) {
557 return;
558 }
559 node->AddChild(subnode, 0);
560 subnode->isContentDirty_ = true;
561 subnode->isNewOnTree_ = true;
562 std::unordered_map<NodeId, std::weak_ptr<RSRenderNode>> activeNodeIds = {{subnode->GetId(), subnode}};
563 node->UpdateSurfaceCacheContentStatic(activeNodeIds);
564 ASSERT_EQ(node->IsContentDirtyNodeLimited(), false);
565 }
566
567 /**
568 * @tc.name: SetSkipLayer001
569 * @tc.desc: Test SetSkipLayer for single surface node which is skip layer
570 * @tc.type: FUNC
571 * @tc.require: issueI9ABGS
572 */
573 HWTEST_F(RSSurfaceRenderNodeTest, SetSkipLayer001, TestSize.Level2)
574 {
575 auto rsContext = std::make_shared<RSContext>();
576 ASSERT_NE(rsContext, nullptr);
577 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
578 ASSERT_NE(node, nullptr);
579
580 node->SetSkipLayer(true);
581 ASSERT_TRUE(node->GetSkipLayer());
582 }
583
584 /**
585 * @tc.name: SetSkipLayer002
586 * @tc.desc: Test SetSkipLayer for surface node while skip Layer isn't first level node
587 * @tc.type: FUNC
588 * @tc.require: issueI9ABGS
589 */
590 HWTEST_F(RSSurfaceRenderNodeTest, SetSkipLayer002, TestSize.Level2)
591 {
592 auto rsContext = std::make_shared<RSContext>();
593 ASSERT_NE(rsContext, nullptr);
594 auto parentNode = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
595 auto skipLayerNode = std::make_shared<RSSurfaceRenderNode>(id + 1, rsContext);
596 ASSERT_NE(parentNode, nullptr);
597 ASSERT_NE(skipLayerNode, nullptr);
598
599 NodeId parentNodeId = parentNode->GetId();
600 pid_t parentNodePid = ExtractPid(parentNodeId);
601 NodeId skipLayerNodeId = skipLayerNode->GetId();
602 pid_t skipLayerNodePid = ExtractPid(skipLayerNodeId);
603 rsContext->GetMutableNodeMap().renderNodeMap_[parentNodePid][parentNodePid] = parentNode;
604 rsContext->GetMutableNodeMap().renderNodeMap_[skipLayerNodePid][skipLayerNodeId] = skipLayerNode;
605
606 parentNode->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
607 parentNode->AddChild(skipLayerNode);
608 parentNode->SetIsOnTheTree(true);
609 skipLayerNode->SetSkipLayer(true);
610
611 ASSERT_TRUE(parentNode->GetHasSkipLayer());
612 }
613
614 /**
615 * @tc.name: SetSecurityLayer001
616 * @tc.desc: Test SetSecurityLayer for single surface node which is security layer
617 * @tc.type: FUNC
618 * @tc.require: issueI9ABGS
619 */
620 HWTEST_F(RSSurfaceRenderNodeTest, SetSecurityLayer001, TestSize.Level2)
621 {
622 auto rsContext = std::make_shared<RSContext>();
623 ASSERT_NE(rsContext, nullptr);
624 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
625 ASSERT_NE(node, nullptr);
626
627 node->SetSecurityLayer(true);
628 ASSERT_TRUE(node->GetSecurityLayer());
629 }
630
631 /**
632 * @tc.name: SetSecurityLayer002
633 * @tc.desc: Test SetSecurityLayer for surface node while security Layer isn't first level node
634 * @tc.type: FUNC
635 * @tc.require: issueI9ABGS
636 */
637 HWTEST_F(RSSurfaceRenderNodeTest, SetSecurityLayer002, TestSize.Level2)
638 {
639 auto rsContext = std::make_shared<RSContext>();
640 ASSERT_NE(rsContext, nullptr);
641 auto parentNode = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
642 auto securityLayerNode = std::make_shared<RSSurfaceRenderNode>(id + 1, rsContext);
643 ASSERT_NE(parentNode, nullptr);
644 ASSERT_NE(securityLayerNode, nullptr);
645
646 NodeId parentNodeId = parentNode->GetId();
647 pid_t parentNodePid = ExtractPid(parentNodeId);
648 NodeId secLayerNodeId = securityLayerNode->GetId();
649 pid_t secLayerNodePid = ExtractPid(secLayerNodeId);
650 rsContext->GetMutableNodeMap().renderNodeMap_[parentNodePid][parentNodeId] = parentNode;
651 rsContext->GetMutableNodeMap().renderNodeMap_[secLayerNodePid][secLayerNodeId] = securityLayerNode;
652
653 parentNode->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
654 parentNode->AddChild(securityLayerNode);
655 parentNode->SetIsOnTheTree(true);
656 securityLayerNode->SetSecurityLayer(true);
657
658 ASSERT_TRUE(parentNode->GetHasSecurityLayer());
659 }
660
661 /**
662 * @tc.name: StoreMustRenewedInfo001
663 * @tc.desc: Test StoreMustRenewedInfo while has filter
664 * @tc.type: FUNC
665 * @tc.require: issueI9ABGS
666 */
667 HWTEST_F(RSSurfaceRenderNodeTest, StoreMustRenewedInfo001, TestSize.Level2)
668 {
669 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
670 ASSERT_NE(node, nullptr);
671 node->InitRenderParams();
672 node->SetChildHasVisibleFilter(true);
673 node->RSRenderNode::StoreMustRenewedInfo();
674 node->StoreMustRenewedInfo();
675 ASSERT_TRUE(node->HasMustRenewedInfo());
676 }
677
678 /**
679 * @tc.name: StoreMustRenewedInfo002
680 * @tc.desc: Test StoreMustRenewedInfo while has effect node
681 * @tc.type: FUNC
682 * @tc.require: issueI9ABGS
683 */
684 HWTEST_F(RSSurfaceRenderNodeTest, StoreMustRenewedInfo002, TestSize.Level2)
685 {
686 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
687 ASSERT_NE(node, nullptr);
688
689 node->InitRenderParams();
690 node->SetChildHasVisibleEffect(true);
691 node->RSRenderNode::StoreMustRenewedInfo();
692 node->StoreMustRenewedInfo();
693 ASSERT_TRUE(node->HasMustRenewedInfo());
694 }
695
696 /**
697 * @tc.name: StoreMustRenewedInfo003
698 * @tc.desc: Test StoreMustRenewedInfo while has hardware node
699 * @tc.type: FUNC
700 * @tc.require: issueI9ABGS
701 */
702 HWTEST_F(RSSurfaceRenderNodeTest, StoreMustRenewedInfo003, TestSize.Level2)
703 {
704 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
705 ASSERT_NE(node, nullptr);
706
707 node->SetHasHardwareNode(true);
708 node->RSRenderNode::StoreMustRenewedInfo();
709 node->StoreMustRenewedInfo();
710 ASSERT_TRUE(node->HasMustRenewedInfo());
711 }
712
713 /**
714 * @tc.name: StoreMustRenewedInfo004
715 * @tc.desc: Test StoreMustRenewedInfo while is skip layer
716 * @tc.type: FUNC
717 * @tc.require: issueI9ABGS
718 */
719 HWTEST_F(RSSurfaceRenderNodeTest, StoreMustRenewedInfo004, TestSize.Level2)
720 {
721 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
722 ASSERT_NE(node, nullptr);
723
724 node->SetSkipLayer(true);
725 node->RSRenderNode::StoreMustRenewedInfo();
726 node->StoreMustRenewedInfo();
727 ASSERT_TRUE(node->HasMustRenewedInfo());
728 }
729
730 /**
731 * @tc.name: StoreMustRenewedInfo005
732 * @tc.desc: Test StoreMustRenewedInfo while is security layer
733 * @tc.type: FUNC
734 * @tc.require: issueI9ABGS
735 */
736 HWTEST_F(RSSurfaceRenderNodeTest, StoreMustRenewedInfo005, TestSize.Level2)
737 {
738 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
739 ASSERT_NE(node, nullptr);
740
741 node->SetSecurityLayer(true);
742 node->RSRenderNode::StoreMustRenewedInfo();
743 node->StoreMustRenewedInfo();
744 ASSERT_TRUE(node->HasMustRenewedInfo());
745 }
746
747 /**
748 * @tc.name: StoreMustRenewedInfo006
749 * @tc.desc: Test StoreMustRenewedInfo while is protected layer
750 * @tc.type: FUNC
751 * @tc.require: issueI7ZSC2
752 */
753 HWTEST_F(RSSurfaceRenderNodeTest, StoreMustRenewedInfo006, TestSize.Level2)
754 {
755 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
756 ASSERT_NE(node, nullptr);
757
758 node->SetProtectedLayer(true);
759 node->RSRenderNode::StoreMustRenewedInfo();
760 node->StoreMustRenewedInfo();
761 ASSERT_TRUE(node->HasMustRenewedInfo());
762 }
763
764 /**
765 * @tc.name: CornerRadiusInfoForDRMTest
766 * @tc.desc: Test SetCornerRadiusInfoForDRM and GetCornerRadiusInfoForDRM
767 * @tc.type: FUNC
768 * @tc.require: issueIAX2NE
769 */
770 HWTEST_F(RSSurfaceRenderNodeTest, CornerRadiusInfoForDRMTest, TestSize.Level2)
771 {
772 auto rsContext = std::make_shared<RSContext>();
773 ASSERT_NE(rsContext, nullptr);
774 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
775 ASSERT_NE(node, nullptr);
776 std::vector<float> cornerRadiusInfo = {};
777 node->SetCornerRadiusInfoForDRM(cornerRadiusInfo);
778 ASSERT_TRUE(node->GetCornerRadiusInfoForDRM().empty());
779 }
780
781 /**
782 * @tc.name: GetFirstLevelNodeId001
783 * @tc.desc: Test GetFirstLevelNode for single app window node
784 * @tc.type: FUNC
785 * @tc.require: issueI9ABGS
786 */
787 HWTEST_F(RSSurfaceRenderNodeTest, GetFirstLevelNodeId001, TestSize.Level2)
788 {
789 auto rsContext = std::make_shared<RSContext>();
790 ASSERT_NE(rsContext, nullptr);
791 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
792 ASSERT_NE(node, nullptr);
793 NodeId nodeId = node->GetId();
794 pid_t pid = ExtractPid(nodeId);
795 rsContext->GetMutableNodeMap().renderNodeMap_[pid][nodeId] = node;
796 node->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
797 node->SetIsOnTheTree(true);
798 ASSERT_EQ(node->GetFirstLevelNodeId(), node->GetId());
799 }
800
801 /**
802 * @tc.name: GetFirstLevelNodeId002
803 * @tc.desc: Test GetFirstLevelNode for app window node which parent is leash window node
804 * @tc.type: FUNC
805 * @tc.require: issueI9ABGS
806 */
807 HWTEST_F(RSSurfaceRenderNodeTest, GetFirstLevelNodeId002, TestSize.Level2)
808 {
809 auto rsContext = std::make_shared<RSContext>();
810 ASSERT_NE(rsContext, nullptr);
811 auto childNode = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
812 auto parentNode = std::make_shared<RSSurfaceRenderNode>(id + 1, rsContext);
813 ASSERT_NE(childNode, nullptr);
814 ASSERT_NE(parentNode, nullptr);
815
816 NodeId childNodeId = childNode->GetId();
817 pid_t childNodePid = ExtractPid(childNodeId);
818 NodeId parentNodeId = parentNode->GetId();
819 pid_t parentNodePid = ExtractPid(parentNodeId);
820 rsContext->GetMutableNodeMap().renderNodeMap_[childNodePid][childNodeId] = childNode;
821 rsContext->GetMutableNodeMap().renderNodeMap_[parentNodePid][parentNodeId] = parentNode;
822
823 parentNode->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
824 childNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
825 parentNode->AddChild(childNode);
826 parentNode->SetIsOnTheTree(true);
827 ASSERT_EQ(childNode->GetFirstLevelNodeId(), parentNode->GetId());
828 }
829
830 /**
831 * @tc.name: SetHasSharedTransitionNode
832 * @tc.desc: Test SetHasSharedTransitionNode
833 * @tc.type: FUNC
834 * @tc.require: issueI98VTC
835 */
836 HWTEST_F(RSSurfaceRenderNodeTest, SetHasSharedTransitionNode, TestSize.Level2)
837 {
838 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
839 ASSERT_NE(node, nullptr);
840 node->SetHasSharedTransitionNode(true);
841
842 ASSERT_EQ(node->GetHasSharedTransitionNode(), true);
843 }
844
845 /**
846 * @tc.name: QuerySubAssignable001
847 * @tc.desc: Test QuerySubAssignable
848 * @tc.type: FUNC
849 * @tc.require: issueI98VTC
850 */
851 HWTEST_F(RSSurfaceRenderNodeTest, QuerySubAssignable001, TestSize.Level2)
852 {
853 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
854 ASSERT_NE(node, nullptr);
855
856 ASSERT_EQ(node->QuerySubAssignable(false), true);
857 }
858
859 /**
860 * @tc.name: QuerySubAssignable002
861 * @tc.desc: Test QuerySubAssignable while has filter
862 * @tc.type: FUNC
863 * @tc.require: issueI9LOXQ
864 */
865 HWTEST_F(RSSurfaceRenderNodeTest, QuerySubAssignable002, TestSize.Level2)
866 {
867 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
868 ASSERT_NE(node, nullptr);
869
870 if (RSUniRenderJudgement::IsUniRender()) {
871 node->InitRenderParams();
872 }
873 node->SetHasFilter(true);
874
875 ASSERT_EQ(node->QuerySubAssignable(false), false);
876 }
877
878 /**
879 * @tc.name: QuerySubAssignable003
880 * @tc.desc: Test QuerySubAssignable while node's child has filter and child is transparent
881 * @tc.type: FUNC
882 * @tc.require: issueI9LOXQ
883 */
884 HWTEST_F(RSSurfaceRenderNodeTest, QuerySubAssignable003, TestSize.Level2)
885 {
886 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
887 auto childNode = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
888 ASSERT_NE(node, nullptr);
889 ASSERT_NE(childNode, nullptr);
890 RSUniRenderJudgement::uniRenderEnabledType_ = UniRenderEnabledType::UNI_RENDER_ENABLED_FOR_ALL;
891 if (RSUniRenderJudgement::IsUniRender()) {
892 node->InitRenderParams();
893 childNode->InitRenderParams();
894 }
895 childNode->SetHasFilter(true);
896 node->SetChildHasVisibleFilter(true);
897
898 ASSERT_EQ(node->QuerySubAssignable(false), false);
899 }
900
901 /**
902 * @tc.name: QuerySubAssignable004
903 * @tc.desc: Test QuerySubAssignable while node's child has filter and is not transparent
904 * @tc.type: FUNC
905 * @tc.require: issueI9LOXQ
906 */
907 HWTEST_F(RSSurfaceRenderNodeTest, QuerySubAssignable004, TestSize.Level2)
908 {
909 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
910 auto childNode = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
911 ASSERT_NE(node, nullptr);
912 ASSERT_NE(childNode, nullptr);
913
914 RSUniRenderJudgement::uniRenderEnabledType_ = UniRenderEnabledType::UNI_RENDER_ENABLED_FOR_ALL;
915 if (RSUniRenderJudgement::IsUniRender()) {
916 node->InitRenderParams();
917 childNode->InitRenderParams();
918 }
919 childNode->SetHasFilter(true);
920 node->SetChildHasVisibleFilter(true);
921 node->SetAbilityBGAlpha(MAX_ALPHA);
922
923 ASSERT_EQ(node->QuerySubAssignable(false), true);
924 }
925
926 /**
927 * @tc.name: SetForceHardwareAndFixRotation001
928 * @tc.desc: Test SetForceHardwareAndFixRotation true
929 * @tc.type: FUNC
930 * @tc.require: issueI9HWLB
931 */
932 HWTEST_F(RSSurfaceRenderNodeTest, SetForceHardwareAndFixRotation001, TestSize.Level2)
933 {
934 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
935 ASSERT_NE(node, nullptr);
936
937 node->InitRenderParams();
938 node->SetForceHardwareAndFixRotation(true);
939 ASSERT_EQ(node->isFixRotationByUser_, true);
940 }
941
942 /**
943 * @tc.name: SetForceHardwareAndFixRotation002
944 * @tc.desc: Test SetForceHardwareAndFixRotation false
945 * @tc.type: FUNC
946 * @tc.require: issueI9HWLB
947 */
948 HWTEST_F(RSSurfaceRenderNodeTest, SetForceHardwareAndFixRotation002, TestSize.Level2)
949 {
950 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
951 ASSERT_NE(node, nullptr);
952
953 node->InitRenderParams();
954 node->SetForceHardwareAndFixRotation(false);
955 ASSERT_EQ(node->isFixRotationByUser_, false);
956 }
957
958 /**
959 * @tc.name: UpdateSrcRectTest
960 * @tc.desc: test results of UpdateSrcRect
961 * @tc.type: FUNC
962 * @tc.require: issueI9JAFQ
963 */
964 HWTEST_F(RSSurfaceRenderNodeTest, UpdateSrcRectTest, TestSize.Level1)
965 {
966 Drawing::Canvas canvas;
967 Drawing::RectI dstRect(0, 0, 100, 100);
968 bool hasRotation = false;
969
970 auto renderNode = std::make_shared<RSSurfaceRenderNode>(id, context);
971 renderNode->UpdateSrcRect(canvas, dstRect, hasRotation);
972 ASSERT_TRUE(true);
973 }
974
975 /**
976 * @tc.name: UpdateHwcDisabledBySrcRectTest
977 * @tc.desc: test results of UpdateHwcDisabledBySrcRect
978 * @tc.type: FUNC
979 * @tc.require: issueI9JAFQ
980 */
981 HWTEST_F(RSSurfaceRenderNodeTest, UpdateHwcDisabledBySrcRectTest, TestSize.Level1)
982 {
983 bool hasRotation = false;
984 auto buffer = SurfaceBuffer::Create();
985 auto renderNode = std::make_shared<RSSurfaceRenderNode>(id, context);
986 renderNode->UpdateHwcDisabledBySrcRect(hasRotation);
987
988 renderNode->GetRSSurfaceHandler()->buffer_.buffer = buffer;
989 renderNode->UpdateHwcDisabledBySrcRect(hasRotation);
990 ASSERT_FALSE(renderNode->isHardwareForcedDisabledBySrcRect_);
991 }
992
993 /**
994 * @tc.name: IsYUVBufferFormatTest
995 * @tc.desc: test results of IsYUVBufferFormat
996 * @tc.type: FUNC
997 * @tc.require: issueI9JAFQ
998 */
999 HWTEST_F(RSSurfaceRenderNodeTest, IsYUVBufferFormatTest, TestSize.Level1)
1000 {
1001 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1002 EXPECT_FALSE(testNode->IsYUVBufferFormat());
1003
1004 auto buffer = SurfaceBuffer::Create();
1005 testNode->GetRSSurfaceHandler()->buffer_.buffer = buffer;
1006 EXPECT_NE(testNode->GetRSSurfaceHandler()->GetBuffer(), nullptr);
1007 EXPECT_FALSE(testNode->IsYUVBufferFormat());
1008 }
1009
1010 /**
1011 * @tc.name: ShouldPrepareSubnodesTest001
1012 * @tc.desc: test results of ShouldPrepareSubnodes
1013 * @tc.type: FUNC
1014 * @tc.require: issueI9JAFQ
1015 */
1016 HWTEST_F(RSSurfaceRenderNodeTest, ShouldPrepareSubnodesTest001, TestSize.Level1)
1017 {
1018 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1019 testNode->SetDstRect(RectI());
1020 testNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1021 EXPECT_FALSE(testNode->ShouldPrepareSubnodes());
1022
1023 testNode->SetDstRect(RectI(0, 0, 100, 100));
1024 testNode->nodeType_ = RSSurfaceNodeType::SCB_SCREEN_NODE;
1025 EXPECT_TRUE(testNode->ShouldPrepareSubnodes());
1026 }
1027
1028 /**
1029 * @tc.name: DirtyRegionDumpTest
1030 * @tc.desc: test results of DirtyRegionDump
1031 * @tc.type: FUNC
1032 * @tc.require: issueI9JAFQ
1033 */
1034 HWTEST_F(RSSurfaceRenderNodeTest, DirtyRegionDumpTest, TestSize.Level1)
1035 {
1036 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id, context);
1037 node->DirtyRegionDump();
1038
1039 node->dirtyManager_.reset();
1040 std::string dump = node->DirtyRegionDump();
1041 ASSERT_NE(dump, "");
1042 }
1043
1044 /**
1045 * @tc.name: PrepareRenderBeforeChildren
1046 * @tc.desc: test results of PrepareRenderBeforeChildren
1047 * @tc.type: FUNC
1048 * @tc.require: issueI9JAFQ
1049 */
1050 HWTEST_F(RSSurfaceRenderNodeTest, PrepareRenderBeforeChildren, TestSize.Level1)
1051 {
1052 Drawing::Canvas canvas;
1053 RSPaintFilterCanvas rsPaintFilterCanvas(&canvas);
1054 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id, context);
1055 node->InitRenderParams();
1056 node->PrepareRenderBeforeChildren(rsPaintFilterCanvas);
1057 ASSERT_NE(node->GetRenderProperties().GetBoundsGeometry(), nullptr);
1058 }
1059
1060 /**
1061 * @tc.name: CollectSurfaceTest
1062 * @tc.desc: test results of CollectSurface
1063 * @tc.type: FUNC
1064 * @tc.require: issueI9JAFQ
1065 */
1066 HWTEST_F(RSSurfaceRenderNodeTest, CollectSurfaceTest, TestSize.Level1)
1067 {
1068 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1069
1070 testNode->nodeType_ = RSSurfaceNodeType::SCB_SCREEN_NODE;
1071 auto node = std::make_shared<RSBaseRenderNode>(id, context);
1072 Drawing::Canvas canvasArgs;
1073 RSPaintFilterCanvas canvas(&canvasArgs);
1074 std::vector<std::shared_ptr<RSRenderNode>> vec;
1075 testNode->CollectSurface(node, vec, true, false);
1076
1077 testNode->nodeType_ = RSSurfaceNodeType::STARTING_WINDOW_NODE;
1078 testNode->CollectSurface(node, vec, true, false);
1079 testNode->CollectSurface(node, vec, false, false);
1080 testNode->nodeType_ = RSSurfaceNodeType::SCB_SCREEN_NODE;
1081 testNode->CollectSurface(node, vec, true, false);
1082 testNode->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
1083 testNode->CollectSurface(node, vec, true, true);
1084 ASSERT_FALSE(testNode->isSubSurfaceEnabled_);
1085 }
1086
1087 /**
1088 * @tc.name: CollectSurfaceForUIFirstSwitchTest
1089 * @tc.desc: test results of CollectSurfaceForUIFirstSwitchTest
1090 * @tc.type: FUNC
1091 * @tc.require: issueI9JAFQ
1092 */
1093 HWTEST_F(RSSurfaceRenderNodeTest, CollectSurfaceForUIFirstSwitchTest, TestSize.Level1)
1094 {
1095 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1096 uint32_t leashWindowCount = 0;
1097 uint32_t minNodeNum = 5;
1098 testNode->CollectSurfaceForUIFirstSwitch(leashWindowCount, minNodeNum);
1099 ASSERT_EQ(leashWindowCount, 0);
1100 }
1101
1102 /**
1103 * @tc.name: ClearChildrenCache
1104 * @tc.desc: test results of ClearChildrenCache
1105 * @tc.type: FUNC
1106 * @tc.require: issueI9JAFQ
1107 */
1108 HWTEST_F(RSSurfaceRenderNodeTest, ClearChildrenCache, TestSize.Level1)
1109 {
1110 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1111 testNode->ClearChildrenCache();
1112 ASSERT_EQ(testNode->nodeType_, RSSurfaceNodeType::DEFAULT);
1113 }
1114
1115 /**
1116 * @tc.name: OnTreeStateChangedTest
1117 * @tc.desc: test results of OnTreeStateChanged
1118 * @tc.type: FUNC
1119 * @tc.require: issueI9JAFQ
1120 */
1121 HWTEST_F(RSSurfaceRenderNodeTest, OnTreeStateChangedTest, TestSize.Level1)
1122 {
1123 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id, context);
1124 node->OnTreeStateChanged();
1125 node->nodeType_ = RSSurfaceNodeType::ABILITY_COMPONENT_NODE;
1126 node->OnTreeStateChanged();
1127 ASSERT_EQ(node->nodeType_, RSSurfaceNodeType::ABILITY_COMPONENT_NODE);
1128 }
1129
1130 /**
1131 * @tc.name: OnResetParentTest
1132 * @tc.desc: test results of OnResetParent
1133 * @tc.type: FUNC
1134 * @tc.require: issueI9JAFQ
1135 */
1136 HWTEST_F(RSSurfaceRenderNodeTest, OnResetParentTest, TestSize.Level1)
1137 {
1138 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id, context);
1139
1140 node->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
1141 node->OnResetParent();
1142
1143 node->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
1144 node->OnResetParent();
1145 ASSERT_EQ(node->nodeType_, RSSurfaceNodeType::SELF_DRAWING_NODE);
1146 }
1147
1148 /**
1149 * @tc.name: SetIsNotifyUIBufferAvailableTest
1150 * @tc.desc: test results of SetIsNotifyUIBufferAvailable
1151 * @tc.type: FUNC
1152 * @tc.require: issueI9JAFQ
1153 */
1154 HWTEST_F(RSSurfaceRenderNodeTest, SetIsNotifyUIBufferAvailableTest, TestSize.Level1)
1155 {
1156 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id, context);
1157 node->SetIsNotifyUIBufferAvailable(true);
1158 ASSERT_TRUE(node->isNotifyUIBufferAvailable_.load());
1159 }
1160
1161 /**
1162 * @tc.name: IsSubTreeNeedPrepareTest
1163 * @tc.desc: test results of IsSubTreeNeedPrepare
1164 * @tc.type: FUNC
1165 * @tc.require: issueI9JAFQ
1166 */
1167 HWTEST_F(RSSurfaceRenderNodeTest, IsSubTreeNeedPrepareTest, TestSize.Level1)
1168 {
1169 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id, context);
1170 node->IsSubTreeNeedPrepare(false, false);
1171 node->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
1172 EXPECT_TRUE(node->IsSubTreeNeedPrepare(true, true));
1173 }
1174
1175 /**
1176 * @tc.name: PrepareTest
1177 * @tc.desc: test results of QuickPrepare
1178 * @tc.type: FUNC
1179 * @tc.require: issueI9JAFQ
1180 */
1181 HWTEST_F(RSSurfaceRenderNodeTest, PrepareTest, TestSize.Level1)
1182 {
1183 std::shared_ptr<RSRenderThreadVisitor> visitor;
1184 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1185 surfaceNode->QuickPrepare(visitor);
1186
1187 visitor = std::make_shared<RSRenderThreadVisitor>();
1188 surfaceNode->QuickPrepare(visitor);
1189 ASSERT_EQ(surfaceNode->nodeType_, RSSurfaceNodeType::DEFAULT);
1190 }
1191
1192 /**
1193 * @tc.name: PrepareTest
1194 * @tc.desc: test results of Process
1195 * @tc.type: FUNC
1196 * @tc.require: issueI9JAFQ
1197 */
1198 HWTEST_F(RSSurfaceRenderNodeTest, ProcessTest, TestSize.Level1)
1199 {
1200 std::shared_ptr<RSRenderThreadVisitor> visitor;
1201 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1202 surfaceNode->Process(visitor);
1203 visitor = std::make_shared<RSRenderThreadVisitor>();
1204 surfaceNode->Process(visitor);
1205 ASSERT_EQ(surfaceNode->nodeType_, RSSurfaceNodeType::DEFAULT);
1206 }
1207
1208 /**
1209 * @tc.name: ProcessAnimatePropertyBeforeChildren
1210 * @tc.desc: test results of ProcessAnimatePropertyBeforeChildren
1211 * @tc.type: FUNC
1212 * @tc.require: issueI9JAFQ
1213 */
1214 HWTEST_F(RSSurfaceRenderNodeTest, ProcessAnimatePropertyBeforeChildren, TestSize.Level1)
1215 {
1216 Drawing::Canvas canvasArgs;
1217 auto canvas = std::make_shared<RSPaintFilterCanvas>(&canvasArgs);
1218 auto surfaceNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1219 surfaceNode->InitRenderParams();
1220 surfaceNode->ProcessAnimatePropertyBeforeChildren(*canvas, true);
1221 surfaceNode->cacheType_ = CacheType::ANIMATE_PROPERTY;
1222 surfaceNode->needDrawAnimateProperty_ = true;
1223 surfaceNode->ProcessAnimatePropertyBeforeChildren(*canvas, true);
1224 ASSERT_EQ(surfaceNode->nodeType_, RSSurfaceNodeType::DEFAULT);
1225 }
1226
1227 /**
1228 * @tc.name: ProcessRenderAfterChildrenTest
1229 * @tc.desc: test results of ProcessRenderAfterChildren
1230 * @tc.type: FUNC
1231 * @tc.require: issueI9JAFQ
1232 */
1233 HWTEST_F(RSSurfaceRenderNodeTest, ProcessRenderAfterChildrenTest, TestSize.Level1)
1234 {
1235 Drawing::Canvas canvasArgs;
1236 auto canvas = std::make_shared<RSPaintFilterCanvas>(&canvasArgs);
1237 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
1238 node->ProcessRenderAfterChildren(*canvas);
1239 EXPECT_FALSE(node->needDrawAnimateProperty_);
1240 }
1241
1242 /**
1243 * @tc.name: SetContextAlphaTest
1244 * @tc.desc: test results of SetContextAlpha
1245 * @tc.type: FUNC
1246 * @tc.require: issueI9JAFQ
1247 */
1248 HWTEST_F(RSSurfaceRenderNodeTest, SetContextAlphaTest, TestSize.Level1)
1249 {
1250 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1251 testNode->SetContextAlpha(1.0f, true);
1252 testNode->SetContextAlpha(0.5f, true);
1253 testNode->SetContextAlpha(0.5f, false);
1254 EXPECT_EQ(testNode->contextAlpha_, 0.5f);
1255 }
1256
1257 /**
1258 * @tc.name: SetContextClipRegionTest
1259 * @tc.desc: test results of GetContextClipRegion
1260 * @tc.type: FUNC
1261 * @tc.require: issueI9JAFQ
1262 */
1263 HWTEST_F(RSSurfaceRenderNodeTest, SetContextClipRegionTest, TestSize.Level1)
1264 {
1265 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1266 Drawing::Rect rect(0, 0, 100, 100);
1267 testNode->SetContextClipRegion(rect, true);
1268 testNode->SetContextClipRegion(rect, false);
1269 EXPECT_EQ(testNode->contextClipRect_->left_, rect.left_);
1270 testNode->SetContextClipRegion(Drawing::Rect(1, 1, 1, 1), true);
1271 EXPECT_NE(testNode->contextClipRect_->left_, rect.left_);
1272 }
1273
1274 /**
1275 * @tc.name: SetSkipLayerTest
1276 * @tc.desc: test results of SetSkipLayer
1277 * @tc.type: FUNC
1278 * @tc.require: issueI9JAFQ
1279 */
1280 HWTEST_F(RSSurfaceRenderNodeTest, SetSkipLayerTest, TestSize.Level1)
1281 {
1282 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id, context);
1283 node->SetSkipLayer(true);
1284 EXPECT_TRUE(node->isSkipLayer_);
1285 node->SetSkipLayer(false);
1286 EXPECT_FALSE(node->isSkipLayer_);
1287 }
1288
1289 /**
1290 * @tc.name: SyncSecurityInfoToFirstLevelNodeTest
1291 * @tc.desc: test results of SyncSecurityInfoToFirstLevelNode
1292 * @tc.type: FUNC
1293 * @tc.require: issueI9JAFQ
1294 */
1295 HWTEST_F(RSSurfaceRenderNodeTest, SyncSecurityInfoToFirstLevelNodeTest, TestSize.Level1)
1296 {
1297 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
1298 node->SyncSecurityInfoToFirstLevelNode();
1299 EXPECT_FALSE(node->isSkipLayer_);
1300 }
1301
1302 /**
1303 * @tc.name: SyncSkipInfoToFirstLevelNode
1304 * @tc.desc: test results of SyncSkipInfoToFirstLevelNode
1305 * @tc.type: FUNC
1306 * @tc.require: issueI9JAFQ
1307 */
1308 HWTEST_F(RSSurfaceRenderNodeTest, SyncSkipInfoToFirstLevelNode, TestSize.Level1)
1309 {
1310 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
1311 node->SyncSkipInfoToFirstLevelNode();
1312 EXPECT_FALSE(node->isSkipLayer_);
1313 }
1314
1315 /**
1316 * @tc.name: NotifyTreeStateChange
1317 * @tc.desc: test results of NotifyTreeStateChange
1318 * @tc.type: FUNC
1319 * @tc.require: issueI9JAFQ
1320 */
1321 HWTEST_F(RSSurfaceRenderNodeTest, NotifyTreeStateChange, TestSize.Level1)
1322 {
1323 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
1324 node->NotifyTreeStateChange();
1325 bool callbackCalled = false;
1326 node->RegisterTreeStateChangeCallback(
__anon2ddb6cc80102(const RSSurfaceRenderNode& node) 1327 [&callbackCalled](const RSSurfaceRenderNode& node) { callbackCalled = true; });
1328 node->NotifyTreeStateChange();
1329 EXPECT_TRUE(callbackCalled);
1330 }
1331
1332 /**
1333 * @tc.name: UpdateSurfaceDefaultSize
1334 * @tc.desc: test results of UpdateSurfaceDefaultSize
1335 * @tc.type: FUNC
1336 * @tc.require: issueI9JAFQ
1337 */
1338 HWTEST_F(RSSurfaceRenderNodeTest, UpdateSurfaceDefaultSize, TestSize.Level1)
1339 {
1340 auto context = std::make_shared<RSContext>();
1341 auto node = std::make_shared<RSSurfaceRenderNode>(1, context, true);
1342 node->UpdateSurfaceDefaultSize(1920.0f, 1080.0f);
1343 node->GetRSSurfaceHandler()->consumer_ = IConsumerSurface::Create();
1344 node->UpdateSurfaceDefaultSize(1920.0f, 1080.0f);
1345 ASSERT_NE(node->GetRSSurfaceHandler()->consumer_, nullptr);
1346 }
1347
1348 /**
1349 * @tc.name: NeedClearBufferCache
1350 * @tc.desc: test results of NeedClearBufferCache
1351 * @tc.type: FUNC
1352 * @tc.require: issueI9JAFQ
1353 */
1354 HWTEST_F(RSSurfaceRenderNodeTest, NeedClearBufferCache, TestSize.Level1)
1355 {
1356 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1357 testNode->InitRenderParams();
1358 testNode->addedToPendingSyncList_ = true;
1359 testNode->NeedClearBufferCache();
1360 EXPECT_FALSE(testNode->isSkipLayer_);
1361 }
1362
1363 /**
1364 * @tc.name: RegisterBufferAvailableListenerTest001
1365 * @tc.desc: test results of RegisterBufferAvailableListener
1366 * @tc.type: FUNC
1367 * @tc.require: issueI9JAFQ
1368 */
1369 HWTEST_F(RSSurfaceRenderNodeTest, RegisterBufferAvailableListenerTest001, TestSize.Level1)
1370 {
1371 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1372 sptr<RSIBufferAvailableCallback> callback;
1373 bool isFromRenderThread = false;
1374 testNode->RegisterBufferAvailableListener(callback, isFromRenderThread);
1375 EXPECT_FALSE(testNode->isSkipLayer_);
1376 }
1377
1378 /**
1379 * @tc.name: SetNotifyRTBufferAvailable
1380 * @tc.desc: test results of SetNotifyRTBufferAvailable
1381 * @tc.type: FUNC
1382 * @tc.require: issueI9JAFQ
1383 */
1384 HWTEST_F(RSSurfaceRenderNodeTest, SetNotifyRTBufferAvailable, TestSize.Level1)
1385 {
1386 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1387 testNode->SetNotifyRTBufferAvailable(true);
1388 ASSERT_TRUE(testNode->isNotifyRTBufferAvailable_);
1389 }
1390
1391 /**
1392 * @tc.name: ConnectToNodeInRenderServiceTest
1393 * @tc.desc: test results of ConnectToNodeInRenderService
1394 * @tc.type: FUNC
1395 * @tc.require: issueI9JAFQ
1396 */
1397 HWTEST_F(RSSurfaceRenderNodeTest, ConnectToNodeInRenderServiceTest, TestSize.Level1)
1398 {
1399 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1400 testNode->ConnectToNodeInRenderService();
1401 EXPECT_FALSE(testNode->isSkipLayer_);
1402 }
1403
1404 /**
1405 * @tc.name: NotifyRTBufferAvailable
1406 * @tc.desc: test results of NotifyRTBufferAvailable
1407 * @tc.type: FUNC
1408 * @tc.require: issueI9JAFQ
1409 */
1410 HWTEST_F(RSSurfaceRenderNodeTest, NotifyRTBufferAvailable, TestSize.Level1)
1411 {
1412 auto testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1413 testNode->NotifyRTBufferAvailable(false);
1414 ASSERT_FALSE(testNode->isNotifyRTBufferAvailablePre_);
1415 testNode->NotifyRTBufferAvailable(true);
1416 testNode->isRefresh_ = true;
1417 testNode->NotifyRTBufferAvailable(true);
1418 ASSERT_FALSE(testNode->isNotifyRTBufferAvailable_);
1419 }
1420
1421 /**
1422 * @tc.name: NotifyRTBufferAvailable
1423 * @tc.desc: test results of NotifyRTBufferAvailable
1424 * @tc.type: FUNC
1425 * @tc.require: issueI9JAFQ
1426 */
1427 HWTEST_F(RSSurfaceRenderNodeTest, NotifyUIBufferAvailable, TestSize.Level1)
1428 {
1429 auto testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1430 testNode->NotifyUIBufferAvailable();
1431 testNode->isNotifyUIBufferAvailable_ = false;
1432 testNode->NotifyUIBufferAvailable();
1433 ASSERT_TRUE(testNode->isNotifyUIBufferAvailable_);
1434 }
1435
1436 /**
1437 * @tc.name: UpdateDirtyIfFrameBufferConsumed
1438 * @tc.desc: test results of UpdateDirtyIfFrameBufferConsumed
1439 * @tc.type: FUNC
1440 * @tc.require: issueI9JAFQ
1441 */
1442 HWTEST_F(RSSurfaceRenderNodeTest, UpdateDirtyIfFrameBufferConsumed, TestSize.Level1)
1443 {
1444 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1445 testNode->GetRSSurfaceHandler()->isCurrentFrameBufferConsumed_ = true;
1446 bool resultOne = testNode->UpdateDirtyIfFrameBufferConsumed();
1447 EXPECT_TRUE(resultOne);
1448
1449 testNode->GetRSSurfaceHandler()->isCurrentFrameBufferConsumed_ = false;
1450 bool resultTwo = testNode->UpdateDirtyIfFrameBufferConsumed();
1451 EXPECT_FALSE(resultTwo);
1452 }
1453
1454 /**
1455 * @tc.name: IsSurfaceInStartingWindowStage
1456 * @tc.desc: test results of IsSurfaceInStartingWindowStage
1457 * @tc.type: FUNC
1458 * @tc.require: issueI9JAFQ
1459 */
1460 HWTEST_F(RSSurfaceRenderNodeTest, IsSurfaceInStartingWindowStage, TestSize.Level1)
1461 {
1462 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1463 auto parentSurfaceNode = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
1464 EXPECT_FALSE(testNode->IsSurfaceInStartingWindowStage());
1465
1466 testNode->SetParent(parentSurfaceNode);
1467 testNode->isNotifyUIBufferAvailable_ = false;
1468 testNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
1469 bool resultOne = testNode->IsSurfaceInStartingWindowStage();
1470 EXPECT_FALSE(resultOne);
1471
1472 parentSurfaceNode->SetSurfaceNodeType(RSSurfaceNodeType::SURFACE_TEXTURE_NODE);
1473 bool resultTwo = testNode->IsSurfaceInStartingWindowStage();
1474 EXPECT_FALSE(resultTwo);
1475 }
1476
1477 /**
1478 * @tc.name: IsParentLeashWindowInScale
1479 * @tc.desc: test results of IsParentLeashWindowInScale
1480 * @tc.type: FUNC
1481 * @tc.require: issueI9JAFQ
1482 */
1483 HWTEST_F(RSSurfaceRenderNodeTest, IsParentLeashWindowInScale, TestSize.Level1)
1484 {
1485 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1486 std::shared_ptr<RSSurfaceRenderNode> parentSurfaceNode = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
1487 testNode->SetParent(parentSurfaceNode);
1488
1489 bool resultOne = testNode->IsParentLeashWindowInScale();
1490 EXPECT_FALSE(resultOne);
1491
1492 parentSurfaceNode->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
1493 parentSurfaceNode->isScale_ = true;
1494 bool resultTwo = testNode->IsParentLeashWindowInScale();
1495 EXPECT_TRUE(resultTwo);
1496 }
1497
1498 /**
1499 * @tc.name: GetSurfaceOcclusionRect
1500 * @tc.desc: test results of GetSurfaceOcclusionRect
1501 * @tc.type: FUNC
1502 * @tc.require: issueI9JAFQ
1503 */
1504 HWTEST_F(RSSurfaceRenderNodeTest, GetSurfaceOcclusionRect, TestSize.Level1)
1505 {
1506 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1507 bool isUniRender = true;
1508 Occlusion::Rect expectedRect1 = testNode->GetOldDirtyInSurface();
1509 Occlusion::Rect resultOne = testNode->GetSurfaceOcclusionRect(isUniRender);
1510 EXPECT_EQ(expectedRect1, resultOne);
1511
1512 isUniRender = false;
1513 Occlusion::Rect expectedRect2 = testNode->GetDstRect();
1514 Occlusion::Rect resultTwo = testNode->GetSurfaceOcclusionRect(isUniRender);
1515 EXPECT_EQ(expectedRect2, resultTwo);
1516 }
1517
1518 /**
1519 * @tc.name: QueryIfAllHwcChildrenForceDisabledByFilter
1520 * @tc.desc: test results of QueryIfAllHwcChildrenForceDisabledByFilter
1521 * @tc.type: FUNC
1522 * @tc.require: issueI9JAFQ
1523 */
1524 HWTEST_F(RSSurfaceRenderNodeTest, QueryIfAllHwcChildrenForceDisabledByFilter, TestSize.Level1)
1525 {
1526 auto testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1527 EXPECT_TRUE(testNode->QueryIfAllHwcChildrenForceDisabledByFilter());
1528
1529 auto childNode1 = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
1530 auto childNode2 = std::make_shared<RSSurfaceRenderNode>(id + 2, context);
1531 testNode->AddChildHardwareEnabledNode(childNode1);
1532 testNode->AddChildHardwareEnabledNode(childNode2);
1533 childNode1->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1534 EXPECT_TRUE(testNode->QueryIfAllHwcChildrenForceDisabledByFilter());
1535 }
1536
1537 /**
1538 * @tc.name: AccumulateOcclusionRegion
1539 * @tc.desc: test results of AccumulateOcclusionRegion
1540 * @tc.type: FUNC
1541 * @tc.require: issueI9JAFQ
1542 */
1543 HWTEST_F(RSSurfaceRenderNodeTest, AccumulateOcclusionRegion, TestSize.Level1)
1544 {
1545 auto testNode = std::make_shared<RSSurfaceRenderNode>(id, context);
1546
1547 Occlusion::Region accumulatedRegion;
1548 Occlusion::Region curRegion;
1549 bool hasFilterCacheOcclusion = false;
1550 bool isUniRender = true;
1551 bool filterCacheOcclusionEnabled = true;
1552
1553 testNode->isNotifyUIBufferAvailable_ = false;
1554 testNode->SetSurfaceNodeType(RSSurfaceNodeType::LEASH_WINDOW_NODE);
1555 testNode->isNotifyUIBufferAvailable_ = false;
1556 testNode->AccumulateOcclusionRegion(
1557 accumulatedRegion, curRegion, hasFilterCacheOcclusion, isUniRender, filterCacheOcclusionEnabled);
1558 EXPECT_TRUE(accumulatedRegion.IsEmpty());
1559
1560 auto parentSurfaceNode = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
1561 testNode->SetParent(parentSurfaceNode);
1562 testNode->isOcclusionInSpecificScenes_ = true;
1563 testNode->AccumulateOcclusionRegion(
1564 accumulatedRegion, curRegion, hasFilterCacheOcclusion, isUniRender, filterCacheOcclusionEnabled);
1565 EXPECT_FALSE(hasFilterCacheOcclusion);
1566 }
1567
1568 /**
1569 * @tc.name: GetVisibleLevelForWMS
1570 * @tc.desc: test results of GetVisibleLevelForWMS
1571 * @tc.type: FUNC
1572 * @tc.require: issueIA61E9
1573 */
1574 HWTEST_F(RSSurfaceRenderNodeTest, GetVisibleLevelForWMS, TestSize.Level1)
1575 {
1576 RSSurfaceRenderNode node(id);
1577
1578 EXPECT_EQ(node.GetVisibleLevelForWMS(RSVisibleLevel::RS_INVISIBLE), WINDOW_LAYER_INFO_TYPE::INVISIBLE);
1579
1580 EXPECT_EQ(node.GetVisibleLevelForWMS(RSVisibleLevel::RS_ALL_VISIBLE), WINDOW_LAYER_INFO_TYPE::ALL_VISIBLE);
1581
1582 EXPECT_EQ(
1583 node.GetVisibleLevelForWMS(RSVisibleLevel::RS_SEMI_NONDEFAULT_VISIBLE), WINDOW_LAYER_INFO_TYPE::SEMI_VISIBLE);
1584
1585 EXPECT_EQ(
1586 node.GetVisibleLevelForWMS(RSVisibleLevel::RS_SEMI_DEFAULT_VISIBLE), WINDOW_LAYER_INFO_TYPE::SEMI_VISIBLE);
1587
1588 EXPECT_EQ(
1589 node.GetVisibleLevelForWMS(RSVisibleLevel::RS_UNKNOW_VISIBLE_LEVEL), WINDOW_LAYER_INFO_TYPE::SEMI_VISIBLE);
1590 }
1591
1592 /**
1593 * @tc.name: SetVisibleRegionRecursive
1594 * @tc.desc: test results of SetVisibleRegionRecursive
1595 * @tc.type: FUNC
1596 * @tc.require: issueI9JAFQ
1597 */
1598 HWTEST_F(RSSurfaceRenderNodeTest, SetVisibleRegionRecursive, TestSize.Level1)
1599 {
1600 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
1601 Occlusion::Rect rect(1, 1, 1, 1);
1602 Occlusion::Region region(rect);
1603 VisibleData visibleVec;
1604 std::map<NodeId, RSVisibleLevel> visMapForVsyncRate;
1605 bool needSetVisibleRegion = true;
1606 RSVisibleLevel visibleLevel = RSVisibleLevel::RS_ALL_VISIBLE;
1607 bool isSystemAnimatedScenes = false;
1608
1609 node->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
1610 node->SetVisibleRegionRecursive(
1611 region, visibleVec, visMapForVsyncRate, needSetVisibleRegion, visibleLevel, isSystemAnimatedScenes);
1612 node->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1613
1614 node->SetVisibleRegionRecursive(
1615 region, visibleVec, visMapForVsyncRate, needSetVisibleRegion, visibleLevel, isSystemAnimatedScenes);
1616
1617 needSetVisibleRegion = false;
1618 node->SetVisibleRegionRecursive(
1619 region, visibleVec, visMapForVsyncRate, needSetVisibleRegion, visibleLevel, isSystemAnimatedScenes);
1620 ASSERT_TRUE(node->visibleRegionForCallBack_.IsEmpty());
1621 }
1622
1623 /**
1624 * @tc.name: CalcFilterCacheValidForOcclusion
1625 * @tc.desc: test results of CalcFilterCacheValidForOcclusion
1626 * @tc.type: FUNC
1627 * @tc.require: issueI9JAFQ
1628 */
1629 HWTEST_F(RSSurfaceRenderNodeTest, CalcFilterCacheValidForOcclusionTest, TestSize.Level1)
1630 {
1631 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
1632 node->isFilterCacheFullyCovered_ = true;
1633 node->dirtyManager_ = std::make_shared<RSDirtyRegionManager>();
1634 node->CalcFilterCacheValidForOcclusion();
1635 EXPECT_TRUE(node->isFilterCacheStatusChanged_);
1636
1637 node->isFilterCacheFullyCovered_ = false;
1638 node->isFilterCacheValidForOcclusion_ = false;
1639 node->CalcFilterCacheValidForOcclusion();
1640 EXPECT_FALSE(node->isFilterCacheStatusChanged_);
1641 }
1642
1643 /**
1644 * @tc.name: CalcFilterCacheValidForOcclusion
1645 * @tc.desc: test results of CalcFilterCacheValidForOcclusion
1646 * @tc.type: FUNC
1647 * @tc.require: issueI9JAFQ
1648 */
1649 HWTEST_F(RSSurfaceRenderNodeTest, UpdateFilterNodesTest, TestSize.Level1)
1650 {
1651 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
1652 std::shared_ptr<RSRenderNode> renderNode;
1653 node->UpdateFilterNodes(renderNode);
1654
1655 renderNode = std::make_shared<RSRenderNode>(id + 1);
1656 node->UpdateFilterNodes(renderNode);
1657 EXPECT_EQ(node->filterNodes_.size(), 1);
1658 }
1659
1660 /**
1661 * @tc.name: CalcFilterCacheValidForOcclusion
1662 * @tc.desc: test results of CalcFilterCacheValidForOcclusion
1663 * @tc.type: FUNC
1664 * @tc.require: issueI9JAFQ
1665 */
1666 HWTEST_F(RSSurfaceRenderNodeTest, CheckValidFilterCacheFullyCoverTargetTest, TestSize.Level1)
1667 {
1668 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
1669 RSRenderNode filterNode(id + 1);
1670 RectI targetRect;
1671 node->CheckValidFilterCacheFullyCoverTarget(filterNode, targetRect);
1672 EXPECT_FALSE(node->isFilterCacheStatusChanged_);
1673 }
1674
1675 /**
1676 * @tc.name: UpdateSurfaceCacheContentStaticFlag
1677 * @tc.desc: test results of UpdateSurfaceCacheContentStaticFlag
1678 * @tc.type: FUNC
1679 * @tc.require: issueI9JAFQ
1680 */
1681 HWTEST_F(RSSurfaceRenderNodeTest, UpdateSurfaceCacheContentStaticFlag, TestSize.Level1)
1682 {
1683 auto node = std::make_shared<RSSurfaceRenderNode>(id);
1684 node->InitRenderParams();
1685 node->addedToPendingSyncList_ = true;
1686 node->UpdateSurfaceCacheContentStaticFlag();
1687
1688 node->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
1689 node->UpdateSurfaceCacheContentStaticFlag();
1690 EXPECT_EQ(node->nodeType_, RSSurfaceNodeType::LEASH_WINDOW_NODE);
1691 }
1692
1693 /**
1694 * @tc.name: UpdateSurfaceSubTreeDirtyFlag
1695 * @tc.desc: test results of UpdateSurfaceSubTreeDirtyFlag
1696 * @tc.type: FUNC
1697 * @tc.require: issueI9JAFQ
1698 */
1699 HWTEST_F(RSSurfaceRenderNodeTest, UpdateSurfaceSubTreeDirtyFlag, TestSize.Level1)
1700 {
1701 auto node = std::make_shared<RSSurfaceRenderNode>(id);
1702 node->stagingRenderParams_ = std::make_unique<RSSurfaceRenderParams>(id + 1);
1703 node->addedToPendingSyncList_ = true;
1704 node->UpdateSurfaceSubTreeDirtyFlag();
1705 ASSERT_NE(node->stagingRenderParams_, nullptr);
1706 }
1707
1708 /**
1709 * @tc.name: UpdateDrawingCacheNodes
1710 * @tc.desc: test results of UpdateDrawingCacheNodes
1711 * @tc.type: FUNC
1712 * @tc.require: issueI9JAFQ
1713 */
1714 HWTEST_F(RSSurfaceRenderNodeTest, UpdateDrawingCacheNodes, TestSize.Level1)
1715 {
1716 auto node = std::make_shared<RSSurfaceRenderNode>(id);
1717 auto renderNode = std::make_shared<RSRenderNode>(id + 1);
1718 node->UpdateDrawingCacheNodes(renderNode);
1719 node->UpdateDrawingCacheNodes(nullptr);
1720 EXPECT_EQ(node->drawingCacheNodes_.size(), 1);
1721 }
1722
1723 /**
1724 * @tc.name: ResetDrawingCacheStatusIfNodeStatic
1725 * @tc.desc: test results of ResetDrawingCacheStatusIfNodeStatic
1726 * @tc.type: FUNC
1727 * @tc.require: issueI9JAFQ
1728 */
1729 HWTEST_F(RSSurfaceRenderNodeTest, ResetDrawingCacheStatusIfNodeStatic, TestSize.Level1)
1730 {
1731 auto renderNode = std::make_shared<RSSurfaceRenderNode>(id);
1732 std::unordered_map<NodeId, std::unordered_set<NodeId>> allRects;
1733 renderNode->ResetDrawingCacheStatusIfNodeStatic(allRects);
1734 EXPECT_EQ(renderNode->drawingCacheNodes_.size(), 0);
1735 }
1736
1737 /**
1738 * @tc.name: UpdateFilterCacheStatusWithVisible
1739 * @tc.desc: test results of UpdateFilterCacheStatusWithVisible
1740 * @tc.type: FUNC
1741 * @tc.require: issueI9JAFQ
1742 */
1743 HWTEST_F(RSSurfaceRenderNodeTest, UpdateFilterCacheStatusWithVisible, TestSize.Level1)
1744 {
1745 auto renderNode = std::make_shared<RSSurfaceRenderNode>(id);
1746 bool visible = true;
1747 renderNode->UpdateFilterCacheStatusWithVisible(visible);
1748 renderNode->UpdateFilterCacheStatusWithVisible(visible);
1749 ASSERT_TRUE(renderNode->prevVisible_);
1750 }
1751
1752 /**
1753 * @tc.name: UpdateFilterCacheStatusIfNodeStatic
1754 * @tc.desc: test results of UpdateFilterCacheStatusIfNodeStatic
1755 * @tc.type: FUNC
1756 * @tc.require: issueI9JAFQ
1757 */
1758 HWTEST_F(RSSurfaceRenderNodeTest, UpdateFilterCacheStatusIfNodeStatic, TestSize.Level1)
1759 {
1760 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
1761 node->UpdateFilterCacheStatusIfNodeStatic(RectI(0, 0, 100, 100), true);
1762
1763 std::shared_ptr<RSRenderNode> mockNode = std::make_shared<RSEffectRenderNode>(id);
1764 node->filterNodes_.emplace_back(mockNode);
1765 node->UpdateFilterCacheStatusIfNodeStatic(RectI(0, 0, 100, 100), false);
1766 ASSERT_NE(node->filterNodes_.size(), 0);
1767 }
1768
1769 /**
1770 * @tc.name: ResetOpaqueRegion
1771 * @tc.desc: test results of ResetOpaqueRegion
1772 * @tc.type: FUNC
1773 * @tc.require: issueI9JAFQ
1774 */
1775 HWTEST_F(RSSurfaceRenderNodeTest, ResetOpaqueRegion, TestSize.Level1)
1776 {
1777 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id);
1778 RectI absRect { 0, 0, 100, 100 };
1779 ScreenRotation screenRotation = ScreenRotation::ROTATION_0;
1780 bool isFocusWindow = true;
1781 Occlusion::Region res= testNode->ResetOpaqueRegion(absRect, screenRotation, isFocusWindow);
1782 EXPECT_NE(res.rects_.size(), 0);
1783 isFocusWindow = false;
1784 res =testNode->ResetOpaqueRegion(absRect, screenRotation, isFocusWindow);
1785 EXPECT_NE(res.rects_.size(), 0);
1786 }
1787
1788 /**
1789 * @tc.name: SetUnfocusedWindowOpaqueRegion
1790 * @tc.desc: test results of SetUnfocusedWindowOpaqueRegion
1791 * @tc.type: FUNC
1792 * @tc.require: issueI9JAFQ
1793 */
1794 HWTEST_F(RSSurfaceRenderNodeTest, SetUnfocusedWindowOpaqueRegion, TestSize.Level1)
1795 {
1796 std::shared_ptr<RSSurfaceRenderNode> surfaceNode = std::make_shared<RSSurfaceRenderNode>(id);
1797 RectI absRect { 0, 0, 100, 100 };
1798 ScreenRotation rotationCases[] = { ScreenRotation::ROTATION_0, ScreenRotation::ROTATION_90,
1799 ScreenRotation::ROTATION_180, ScreenRotation::ROTATION_270, ScreenRotation::INVALID_SCREEN_ROTATION };
1800 for (ScreenRotation rotation : rotationCases) {
1801 Occlusion::Region opaqueRegion = surfaceNode->SetUnfocusedWindowOpaqueRegion(absRect, rotation);
1802 EXPECT_NE(opaqueRegion.rects_.size(), 0);
1803 }
1804 }
1805
1806 /**
1807 * @tc.name: SetFocusedWindowOpaqueRegion
1808 * @tc.desc: test results of SetFocusedWindowOpaqueRegion
1809 * @tc.type: FUNC
1810 * @tc.require: issueI9JAFQ
1811 */
1812 HWTEST_F(RSSurfaceRenderNodeTest, SetFocusedWindowOpaqueRegion, TestSize.Level1)
1813 {
1814 std::shared_ptr<RSSurfaceRenderNode> renderNode = std::make_shared<RSSurfaceRenderNode>(id);
1815 RectI absRect { 0, 0, 100, 100 };
1816 ScreenRotation rotationCases[] = { ScreenRotation::ROTATION_0, ScreenRotation::ROTATION_90,
1817 ScreenRotation::ROTATION_180, ScreenRotation::ROTATION_270, ScreenRotation::INVALID_SCREEN_ROTATION };
1818 for (ScreenRotation rotation : rotationCases) {
1819 Occlusion::Region opaqueRegion = renderNode->SetFocusedWindowOpaqueRegion(absRect, rotation);
1820 EXPECT_NE(opaqueRegion.rects_.size(), 0);
1821 }
1822 }
1823
1824 /**
1825 * @tc.name: ResetSurfaceContainerRegion
1826 * @tc.desc: test results of ResetSurfaceContainerRegion
1827 * @tc.type: FUNC
1828 * @tc.require: issueI9JAFQ
1829 */
1830 HWTEST_F(RSSurfaceRenderNodeTest, ResetSurfaceContainerRegion, TestSize.Level1)
1831 {
1832 std::shared_ptr<RSSurfaceRenderNode> renderNode = std::make_shared<RSSurfaceRenderNode>(id);
1833 RectI screeninfo { 0, 0, 100, 100 };
1834 RectI absRect { 0, 0, 50, 50 };
1835 ScreenRotation rotationCases[] = { ScreenRotation::ROTATION_0, ScreenRotation::ROTATION_90,
1836 ScreenRotation::ROTATION_180, ScreenRotation::ROTATION_270, ScreenRotation::INVALID_SCREEN_ROTATION };
1837 renderNode->ResetSurfaceContainerRegion(screeninfo, absRect, rotationCases[0]);
1838 renderNode->containerConfig_.hasContainerWindow_ = true;
1839 for (ScreenRotation rotation : rotationCases) {
1840 renderNode->ResetSurfaceContainerRegion(screeninfo, absRect, rotation);
1841 EXPECT_FALSE(renderNode->containerRegion_.IsEmpty());
1842 }
1843 }
1844
1845 /**
1846 * @tc.name: OnSync
1847 * @tc.desc: test results of OnSync
1848 * @tc.type: FUNC
1849 * @tc.require: issueI9L0VL
1850 */
1851 HWTEST_F(RSSurfaceRenderNodeTest, OnSync, TestSize.Level1)
1852 {
1853 std::shared_ptr<RSSurfaceRenderNode> surfaceNode = std::make_shared<RSSurfaceRenderNode>(id);
1854 surfaceNode->InitRenderParams();
1855 surfaceNode->OnSync();
1856 ASSERT_NE(surfaceNode->stagingRenderParams_, nullptr);
1857 }
1858
1859 /**
1860 * @tc.name: HDRPresentTest001
1861 * @tc.desc: test SetHDRPresent and GetHDRPresent
1862 * @tc.type:FUNC
1863 * @tc.require: issueIB6Y6O
1864 *
1865 */
1866 HWTEST_F(RSSurfaceRenderNodeTest, HDRPresentTest001, TestSize.Level1)
1867 {
1868 auto rsContext = std::make_shared<RSContext>();
1869 ASSERT_NE(rsContext, nullptr);
1870 auto childNode = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
1871 auto parentNode = std::make_shared<RSSurfaceRenderNode>(id + 1, rsContext);
1872 auto leashWindowNode = std::make_shared<RSSurfaceRenderNode>(id + 2, rsContext);
1873 ASSERT_NE(childNode, nullptr);
1874 ASSERT_NE(parentNode, nullptr);
1875 ASSERT_NE(leashWindowNode, nullptr);
1876
1877 NodeId childNodeId = childNode->GetId();
1878 pid_t childNodePid = ExtractPid(childNodeId);
1879 NodeId parentNodeId = parentNode->GetId();
1880 pid_t parentNodePid = ExtractPid(parentNodeId);
1881 NodeId leashWindowNodeId = leashWindowNode->GetId();
1882 pid_t leashWindowNodePid = ExtractPid(leashWindowNodeId);
1883 rsContext->GetMutableNodeMap().renderNodeMap_[childNodePid][childNodeId] = childNode;
1884 rsContext->GetMutableNodeMap().renderNodeMap_[parentNodePid][parentNodeId] = parentNode;
1885 rsContext->GetMutableNodeMap().renderNodeMap_[leashWindowNodePid][leashWindowNodeId] = leashWindowNode;
1886
1887 parentNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1888 childNode->nodeType_ = RSSurfaceNodeType::UI_EXTENSION_COMMON_NODE;
1889 leashWindowNode->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
1890
1891 leashWindowNode->AddChild(parentNode);
1892 parentNode->AddChild(childNode);
1893 leashWindowNode->SetIsOnTheTree(true);
1894 parentNode->SetIsOnTheTree(true);
1895 childNode->SetIsOnTheTree(true);
1896
1897 childNode->SetHDRPresent(true);
1898 ASSERT_FALSE(childNode->GetHDRPresent());
1899 leashWindowNode->SetHDRPresent(false);
1900 ASSERT_FALSE(leashWindowNode->GetHDRPresent());
1901 }
1902
1903 /**
1904 * @tc.name: HDRPresentTest002
1905 * @tc.desc: test IncreaseHDRNum and ReduceHDRNum
1906 * @tc.type:FUNC
1907 * @tc.require: issueIB6Y6O
1908 *
1909 */
1910 HWTEST_F(RSSurfaceRenderNodeTest, HDRPresentTest002, TestSize.Level1)
1911 {
1912 auto rsContext = std::make_shared<RSContext>();
1913 ASSERT_NE(rsContext, nullptr);
1914 auto childNode = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
1915 auto parentNode = std::make_shared<RSSurfaceRenderNode>(id + 1, rsContext);
1916 auto leashWindowNode = std::make_shared<RSSurfaceRenderNode>(id + 2, rsContext);
1917 ASSERT_NE(childNode, nullptr);
1918 ASSERT_NE(parentNode, nullptr);
1919 ASSERT_NE(leashWindowNode, nullptr);
1920
1921 NodeId childNodeId = childNode->GetId();
1922 pid_t childNodePid = ExtractPid(childNodeId);
1923 NodeId parentNodeId = parentNode->GetId();
1924 pid_t parentNodePid = ExtractPid(parentNodeId);
1925 NodeId leashWindowNodeId = leashWindowNode->GetId();
1926 pid_t leashWindowNodePid = ExtractPid(leashWindowNodeId);
1927 rsContext->GetMutableNodeMap().renderNodeMap_[childNodePid][childNodeId] = childNode;
1928 rsContext->GetMutableNodeMap().renderNodeMap_[parentNodePid][parentNodeId] = parentNode;
1929 rsContext->GetMutableNodeMap().renderNodeMap_[leashWindowNodePid][leashWindowNodeId] = leashWindowNode;
1930
1931 parentNode->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
1932 childNode->nodeType_ = RSSurfaceNodeType::UI_EXTENSION_COMMON_NODE;
1933 leashWindowNode->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
1934
1935 leashWindowNode->AddChild(parentNode);
1936 parentNode->AddChild(childNode);
1937 leashWindowNode->SetIsOnTheTree(true);
1938 parentNode->SetIsOnTheTree(true);
1939 childNode->SetIsOnTheTree(true);
1940
1941 childNode->IncreaseHDRNum();
1942 ASSERT_TRUE(childNode->GetHDRPresent());
1943 childNode->ReduceHDRNum();
1944 ASSERT_FALSE(childNode->GetHDRPresent());
1945 }
1946
1947 /**
1948 * @tc.name: CheckIfOcclusionReusable
1949 * @tc.desc: test results of CheckIfOcclusionReusable
1950 * @tc.type: FUNC
1951 * @tc.require: issueI9L0VL
1952 */
1953 HWTEST_F(RSSurfaceRenderNodeTest, CheckIfOcclusionReusable, TestSize.Level1)
1954 {
1955 std::shared_ptr<RSSurfaceRenderNode> surfaceNode = std::make_shared<RSSurfaceRenderNode>(id);
1956 std::queue<NodeId> surfaceNodesIds;
1957 ASSERT_TRUE(surfaceNode->CheckIfOcclusionReusable(surfaceNodesIds));
1958 surfaceNodesIds.push(1);
1959 bool result = surfaceNode->CheckIfOcclusionReusable(surfaceNodesIds);
1960 ASSERT_TRUE(result);
1961 }
1962
1963 /**
1964 * @tc.name: CheckParticipateInOcclusion
1965 * @tc.desc: test results of CheckParticipateInOcclusion
1966 * @tc.type: FUNC
1967 * @tc.require: issueI9L0VL
1968 */
1969 HWTEST_F(RSSurfaceRenderNodeTest, CheckParticipateInOcclusion, TestSize.Level1)
1970 {
1971 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
1972 EXPECT_FALSE(node->CheckParticipateInOcclusion());
1973 }
1974
1975 /**
1976 * @tc.name: CheckAndUpdateOpaqueRegion
1977 * @tc.desc: test results of CheckAndUpdateOpaqueRegion
1978 * @tc.type: FUNC
1979 * @tc.require: issueI9L0VL
1980 */
1981 HWTEST_F(RSSurfaceRenderNodeTest, CheckAndUpdateOpaqueRegion, TestSize.Level1)
1982 {
1983 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
1984 RectI screeninfo { 0, 0, 100, 100 };
1985 ScreenRotation screenRotation = ScreenRotation::ROTATION_0;
1986 node->CheckAndUpdateOpaqueRegion(screeninfo, screenRotation, true);
1987 EXPECT_FALSE(node->IsOpaqueRegionChanged());
1988 }
1989
1990 /**
1991 * @tc.name: UpdateChildrenFilterRects
1992 * @tc.desc: test results of UpdateChildrenFilterRects
1993 * @tc.type: FUNC
1994 * @tc.require: issueI9L0VL
1995 */
1996 HWTEST_F(RSSurfaceRenderNodeTest, UpdateChildrenFilterRects, TestSize.Level1)
1997 {
1998 std::shared_ptr<RSSurfaceRenderNode> testNode = std::make_shared<RSSurfaceRenderNode>(id);
1999 std::shared_ptr<RSRenderNode> filterNode = std::make_shared<RSRenderNode>(id + 1);
2000 RectI rect { 0, 0, 20, 20 };
2001 bool cacheValid = true;
2002 testNode->ResetChildrenFilterRects();
2003 testNode->UpdateChildrenFilterRects(filterNode, rect, cacheValid);
2004 testNode->UpdateChildrenFilterRects(filterNode, RectI(), cacheValid);
2005 const std::vector<RectI>& filterRects = testNode->GetChildrenNeedFilterRects();
2006 ASSERT_EQ(filterRects.size(), 1);
2007 }
2008
2009 /**
2010 * @tc.name: UpdateChildrenFilterRects
2011 * @tc.desc: test results of UpdateChildrenFilterRects
2012 * @tc.type: FUNC
2013 * @tc.require: issueI9L0VL
2014 */
2015 HWTEST_F(RSSurfaceRenderNodeTest, UpdateAbilityNodeIds, TestSize.Level1)
2016 {
2017 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2018 node->UpdateAbilityNodeIds(1, true);
2019 EXPECT_TRUE(node->GetAbilityNodeIds().count(1) == 1);
2020 std::unordered_set<NodeId> nodeIds;
2021 node->AddAbilityComponentNodeIds(nodeIds);
2022 node->ResetAbilityNodeIds();
2023 node->UpdateAbilityNodeIds(1, false);
2024 EXPECT_TRUE(node->GetAbilityNodeIds().empty());
2025 }
2026
2027 /**
2028 * @tc.name: UpdateChildHardwareEnabledNode
2029 * @tc.desc: test results of UpdateChildHardwareEnabledNode
2030 * @tc.type: FUNC
2031 * @tc.require: issueI9L0VL
2032 */
2033 HWTEST_F(RSSurfaceRenderNodeTest, UpdateChildHardwareEnabledNode, TestSize.Level1)
2034 {
2035 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2036 node->UpdateChildHardwareEnabledNode(1, false);
2037 node->UpdateChildHardwareEnabledNode(1, true);
2038 ASSERT_TRUE(node->GetNeedCollectHwcNode());
2039 }
2040
2041 /**
2042 * @tc.name: SetHwcChildrenDisabledStateByUifirst
2043 * @tc.desc: test results of SetHwcChildrenDisabledStateByUifirst
2044 * @tc.type: FUNC
2045 * @tc.require: issueI9L0VL
2046 */
2047 HWTEST_F(RSSurfaceRenderNodeTest, SetHwcChildrenDisabledStateByUifirst, TestSize.Level1)
2048 {
2049 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2050 node->SetHwcChildrenDisabledStateByUifirst();
2051 ASSERT_TRUE(node->childHardwareEnabledNodes_.size() == 0);
2052 }
2053
2054 /**
2055 * @tc.name: OnApplyModifiers
2056 * @tc.desc: test results of OnApplyModifiers
2057 * @tc.type: FUNC
2058 * @tc.require: issueI9L0VL
2059 */
2060 HWTEST_F(RSSurfaceRenderNodeTest, OnApplyModifiers, TestSize.Level1)
2061 {
2062 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2063 node->OnApplyModifiers();
2064 auto& properties = node->GetMutableRenderProperties();
2065 ASSERT_EQ(properties.GetAlpha(), properties.GetAlpha() * node->contextAlpha_);
2066 }
2067
2068 /**
2069 * @tc.name: LeashWindowRelatedAppWindowOccluded
2070 * @tc.desc: test results of LeashWindowRelatedAppWindowOccluded
2071 * @tc.type: FUNC
2072 * @tc.require: issueI9L0VL
2073 */
2074 HWTEST_F(RSSurfaceRenderNodeTest, LeashWindowRelatedAppWindowOccluded, TestSize.Level1)
2075 {
2076 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2077 std::vector<std::shared_ptr<RSSurfaceRenderNode>> appNode;
2078 ASSERT_FALSE(node->LeashWindowRelatedAppWindowOccluded(appNode));
2079 }
2080
2081 /**
2082 * @tc.name: GetLeashWindowNestedSurfaces
2083 * @tc.desc: test results of GetLeashWindowNestedSurfaces
2084 * @tc.type: FUNC
2085 * @tc.require: issueI9L0VL
2086 */
2087 HWTEST_F(RSSurfaceRenderNodeTest, GetLeashWindowNestedSurfaces, TestSize.Level1)
2088 {
2089 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2090 ASSERT_TRUE(node->GetLeashWindowNestedSurfaces().size() == 0);
2091 }
2092
2093 /**
2094 * @tc.name: IsUIFirstSelfDrawCheck
2095 * @tc.desc: test results of IsUIFirstSelfDrawCheck
2096 * @tc.type: FUNC
2097 * @tc.require: issueI9L0VL
2098 */
2099 HWTEST_F(RSSurfaceRenderNodeTest, IsUIFirstSelfDrawCheck, TestSize.Level1)
2100 {
2101 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2102 ASSERT_TRUE(node->IsUIFirstSelfDrawCheck());
2103 }
2104
2105 /**
2106 * @tc.name: IsCurFrameStatic
2107 * @tc.desc: test results of IsCurFrameStatic
2108 * @tc.type: FUNC
2109 * @tc.require: issueI9L0VL
2110 */
2111 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic, TestSize.Level1)
2112 {
2113 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2114 DeviceType deviceType = DeviceType::PHONE;
2115 bool res = node->IsCurFrameStatic(deviceType);
2116 ASSERT_TRUE(res);
2117 }
2118
2119 /**
2120 * @tc.name: IsVisibleDirtyEmpty
2121 * @tc.desc: test results of IsVisibleDirtyEmpty
2122 * @tc.type: FUNC
2123 * @tc.require: issueI9L0VL
2124 */
2125 HWTEST_F(RSSurfaceRenderNodeTest, IsVisibleDirtyEmpty, TestSize.Level1)
2126 {
2127 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2128 DeviceType deviceType = DeviceType::PHONE;
2129 bool res = node->IsVisibleDirtyEmpty(deviceType);
2130 ASSERT_TRUE(res);
2131 }
2132
2133 /**
2134 * @tc.name: UpdateCacheSurfaceDirtyManager
2135 * @tc.desc: test results of UpdateCacheSurfaceDirtyManager
2136 * @tc.type: FUNC
2137 * @tc.require: issueI9L0VL
2138 */
2139 HWTEST_F(RSSurfaceRenderNodeTest, UpdateCacheSurfaceDirtyManager, TestSize.Level1)
2140 {
2141 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2142 int bufferAge = 1;
2143 node->UpdateCacheSurfaceDirtyManager(bufferAge);
2144 ASSERT_NE(node->cacheSurfaceDirtyManager_, nullptr);
2145 }
2146
2147 /**
2148 * @tc.name: SetIsOnTheTree
2149 * @tc.desc: test results of SetIsOnTheTree
2150 * @tc.type: FUNC
2151 * @tc.require: issueI9L0VL
2152 */
2153 HWTEST_F(RSSurfaceRenderNodeTest, SetIsOnTheTree, TestSize.Level1)
2154 {
2155 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2156 bool flag = true;
2157 NodeId instanceRootNodeId = 1;
2158 NodeId firstLevelNodeId = 1;
2159 NodeId cacheNodeId = 1;
2160 node->SetIsOnTheTree(flag, instanceRootNodeId, firstLevelNodeId, cacheNodeId);
2161 ASSERT_EQ(node->GetId(), 0);
2162 }
2163
2164 /**
2165 * @tc.name: HasOnlyOneRootNode
2166 * @tc.desc: test results of HasOnlyOneRootNode
2167 * @tc.type: FUNC
2168 * @tc.require: issueI9L0VL
2169 */
2170 HWTEST_F(RSSurfaceRenderNodeTest, HasOnlyOneRootNode, TestSize.Level1)
2171 {
2172 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2173 bool res = node->HasOnlyOneRootNode();
2174 ASSERT_FALSE(res);
2175 }
2176
2177 /**
2178 * @tc.name: GetNodeIsSingleFrameComposer
2179 * @tc.desc: test results of GetNodeIsSingleFrameComposer
2180 * @tc.type: FUNC
2181 * @tc.require: issueI9L0VL
2182 */
2183 HWTEST_F(RSSurfaceRenderNodeTest, GetNodeIsSingleFrameComposer, TestSize.Level1)
2184 {
2185 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2186 bool res = node->GetNodeIsSingleFrameComposer();
2187 ASSERT_FALSE(res);
2188 }
2189
2190 /**
2191 * @tc.name: QuerySubAssignable
2192 * @tc.desc: test results of QuerySubAssignable
2193 * @tc.type: FUNC
2194 * @tc.require: issueI9L0VL
2195 */
2196 HWTEST_F(RSSurfaceRenderNodeTest, QuerySubAssignable, TestSize.Level1)
2197 {
2198 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2199 bool isRotation = true;
2200 bool res = node->QuerySubAssignable(isRotation);
2201 ASSERT_FALSE(res);
2202 }
2203
2204 /**
2205 * @tc.name: GetGravityTranslate
2206 * @tc.desc: test results of GetGravityTranslate
2207 * @tc.type: FUNC
2208 * @tc.require: issueI9L0VL
2209 */
2210 HWTEST_F(RSSurfaceRenderNodeTest, GetGravityTranslate, TestSize.Level1)
2211 {
2212 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2213 float imgWidth = 1.0f;
2214 float imgHeight = 1.0f;
2215 node->GetGravityTranslate(imgWidth, imgHeight);
2216 ASSERT_FALSE(node->IsLeashWindow());
2217 }
2218
2219 /**
2220 * @tc.name: SetOcclusionVisible
2221 * @tc.desc: test results of SetOcclusionVisible
2222 * @tc.type: FUNC
2223 * @tc.require: issueI9L0VL
2224 */
2225 HWTEST_F(RSSurfaceRenderNodeTest, SetOcclusionVisible, TestSize.Level1)
2226 {
2227 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2228 bool visible = true;
2229 node->SetOcclusionVisible(visible);
2230 node->InitRenderParams();
2231 node->addedToPendingSyncList_ = true;
2232 node->SetOcclusionVisible(visible);
2233 ASSERT_TRUE(node->isOcclusionVisible_);
2234 }
2235
2236 /**
2237 * @tc.name: UpdatePartialRenderParams
2238 * @tc.desc: test results of UpdatePartialRenderParams
2239 * @tc.type: FUNC
2240 * @tc.require: issueI9L0VL
2241 */
2242 HWTEST_F(RSSurfaceRenderNodeTest, UpdatePartialRenderParams, TestSize.Level1)
2243 {
2244 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2245 node->UpdatePartialRenderParams();
2246 node->UpdateRenderParams();
2247 node->UpdateAncestorDisplayNodeInRenderParams();
2248 node->SetUifirstChildrenDirtyRectParam(RectI());
2249 node->SetUifirstNodeEnableParam(MultiThreadCacheType::NONE);
2250 node->SetIsParentUifirstNodeEnableParam(true);
2251 ASSERT_EQ(node->stagingRenderParams_.get(), nullptr);
2252 }
2253
2254 /**
2255 * @tc.name: InitRenderParams
2256 * @tc.desc: test results of InitRenderParams
2257 * @tc.type: FUNC
2258 * @tc.require: issueI9L0VL
2259 */
2260 HWTEST_F(RSSurfaceRenderNodeTest, InitRenderParams, TestSize.Level1)
2261 {
2262 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2263 node->InitRenderParams();
2264 ASSERT_NE(node->stagingRenderParams_.get(), nullptr);
2265 }
2266
2267 /**
2268 * @tc.name: GetHasTransparentSurface
2269 * @tc.desc: test results of GetHasTransparentSurface
2270 * @tc.type: FUNC
2271 * @tc.require: issueI9L0VL
2272 */
2273 HWTEST_F(RSSurfaceRenderNodeTest, GetHasTransparentSurface, TestSize.Level1)
2274 {
2275 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2276 node->SetHasSharedTransitionNode(true);
2277 ASSERT_TRUE(node->GetHasSharedTransitionNode());
2278 ASSERT_FALSE(node->GetHasTransparentSurface());
2279 }
2280
2281 /**
2282 * @tc.name: GetCacheSurfaceProcessedStatus
2283 * @tc.desc: test results of GetCacheSurfaceProcessedStatus
2284 * @tc.type: FUNC
2285 * @tc.require: issueI9L0VL
2286 */
2287 HWTEST_F(RSSurfaceRenderNodeTest, GetCacheSurfaceProcessedStatus, TestSize.Level1)
2288 {
2289 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2290 CacheProcessStatus cacheProcessStatus = CacheProcessStatus::DOING;
2291 node->SetCacheSurfaceProcessedStatus(cacheProcessStatus);
2292 ASSERT_EQ(node->GetCacheSurfaceProcessedStatus(), cacheProcessStatus);
2293 }
2294
2295 /**
2296 * @tc.name: IsUIFirstCacheReusable
2297 * @tc.desc: test results of IsUIFirstCacheReusable
2298 * @tc.type: FUNC
2299 * @tc.require: issueI9L0VL
2300 */
2301 HWTEST_F(RSSurfaceRenderNodeTest, IsUIFirstCacheReusable, TestSize.Level1)
2302 {
2303 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2304 DeviceType deviceType = DeviceType::PHONE;
2305 node->GetContextClipRegion();
2306 ASSERT_FALSE(node->IsHistoryOccludedDirtyRegionNeedSubmit());
2307 node->ClearHistoryUnSubmittedDirtyInfo();
2308 ASSERT_FALSE(node->hasUnSubmittedOccludedDirtyRegion_);
2309 node->UpdateHistoryUnsubmittedDirtyInfo();
2310 ASSERT_TRUE(node->hasUnSubmittedOccludedDirtyRegion_);
2311 ASSERT_FALSE(node->IsUIFirstCacheReusable(deviceType));
2312 }
2313
2314 /**
2315 * @tc.name: GetLocalZOrder
2316 * @tc.desc: test results of GetLocalZOrder
2317 * @tc.type: FUNC
2318 * @tc.require: issueI9L0VL
2319 */
2320 HWTEST_F(RSSurfaceRenderNodeTest, GetLocalZOrder, TestSize.Level1)
2321 {
2322 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2323 float localZOrder = 1.0f;
2324 node->SetLocalZOrder(localZOrder);
2325 ASSERT_EQ(node->GetLocalZOrder(), localZOrder);
2326 }
2327
2328 /**
2329 * @tc.name: GetChildHardwareEnabledNodes
2330 * @tc.desc: test results of GetChildHardwareEnabledNodes
2331 * @tc.type: FUNC
2332 * @tc.require: issueI9L0VL
2333 */
2334 HWTEST_F(RSSurfaceRenderNodeTest, GetChildHardwareEnabledNodes, TestSize.Level1)
2335 {
2336 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2337 std::weak_ptr<RSSurfaceRenderNode> childNode = std::make_shared<RSSurfaceRenderNode>(id + 1);
2338 node->AddChildHardwareEnabledNode(childNode);
2339 node->ResetChildHardwareEnabledNodes();
2340 ASSERT_EQ(node->GetChildHardwareEnabledNodes().size(), 0);
2341 }
2342
2343 /**
2344 * @tc.name: UpdateSurfaceCacheContentStatic
2345 * @tc.desc: test results of UpdateSurfaceCacheContentStatic
2346 * @tc.type: FUNC
2347 * @tc.require: issueI9L0VL
2348 */
2349 HWTEST_F(RSSurfaceRenderNodeTest, UpdateSurfaceCacheContentStatic001, TestSize.Level1)
2350 {
2351 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2352 node->UpdateSurfaceCacheContentStatic();
2353 ASSERT_EQ(node->dirtyContentNodeNum_, 0);
2354 }
2355
2356 /**
2357 * @tc.name: GetChildrenNeedFilterRectsCacheValid
2358 * @tc.desc: test results of GetChildrenNeedFilterRectsCacheValid
2359 * @tc.type: FUNC
2360 * @tc.require: issueI9L0VL
2361 */
2362 HWTEST_F(RSSurfaceRenderNodeTest, GetChildrenNeedFilterRectsCacheValid, TestSize.Level1)
2363 {
2364 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2365 ASSERT_EQ(node->GetChildrenFilterNodes().size(), 0);
2366 ASSERT_EQ(node->GetChildrenNeedFilterRectsCacheValid().size(), 0);
2367 }
2368
2369 /**
2370 * @tc.name: CheckOpaqueRegionBaseInfo
2371 * @tc.desc: test results of CheckOpaqueRegionBaseInfo
2372 * @tc.type: FUNC
2373 * @tc.require: issueI9L0VL
2374 */
2375 HWTEST_F(RSSurfaceRenderNodeTest, CheckOpaqueRegionBaseInfo, TestSize.Level1)
2376 {
2377 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2378 RectI screeninfo;
2379 RectI absRect;
2380 ScreenRotation screenRotation = ScreenRotation::ROTATION_0;
2381 bool isFocusWindow = true;
2382 Vector4<int> cornerRadius;
2383 ASSERT_FALSE(node->CheckOpaqueRegionBaseInfo(screeninfo, absRect, screenRotation, isFocusWindow, cornerRadius));
2384 bool hasContainer = true;
2385 float density = 1.0f;
2386 node->containerConfig_.Update(hasContainer, density);
2387 node->InitRenderParams();
2388 node->addedToPendingSyncList_ = true;
2389 node->isHardwareForcedDisabled_ = true;
2390 node->UpdateHardwareDisabledState(true);
2391 ASSERT_FALSE(node->opaqueRegionBaseInfo_.hasContainerWindow_);
2392 node->UpdateOccludedByFilterCache(false);
2393 ASSERT_FALSE(node->IsOccludedByFilterCache());
2394 ASSERT_TRUE(node->IsSCBNode());
2395 ASSERT_FALSE(node->CheckIfOcclusionChanged());
2396 }
2397
2398 /**
2399 * @tc.name: NeedSetCallbackForRenderThreadRefresh
2400 * @tc.desc: test results of NeedSetCallbackForRenderThreadRefresh
2401 * @tc.type: FUNC
2402 * @tc.require: issueI9L0VL
2403 */
2404 HWTEST_F(RSSurfaceRenderNodeTest, NeedSetCallbackForRenderThreadRefresh, TestSize.Level1)
2405 {
2406 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(id);
2407 node->SetStartAnimationFinished();
2408 ASSERT_TRUE(node->IsStartAnimationFinished());
2409
2410 node->SetCallbackForRenderThreadRefresh(true);
2411 ASSERT_FALSE(node->NeedSetCallbackForRenderThreadRefresh());
2412 }
2413
2414 /**
2415 * @tc.name: ProtectedLayer001
2416 * @tc.desc: Test ProtectedLayer when SetProtectedLayer is true.
2417 * @tc.type: FUNC
2418 * @tc.require: issueI7ZSC2
2419 */
2420 HWTEST_F(RSSurfaceRenderNodeTest, ProtectedLayer001, TestSize.Level2)
2421 {
2422 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2423 ASSERT_NE(node, nullptr);
2424
2425 node->SetProtectedLayer(true);
2426 bool result = node->GetProtectedLayer();
2427 ASSERT_EQ(result, true);
2428 }
2429
2430 /**
2431 * @tc.name: ProtectedLayer002
2432 * @tc.desc: Test ProtectedLayer when SetProtectedLayer is false.
2433 * @tc.type: FUNC
2434 * @tc.require: issueI7ZSC2
2435 */
2436 HWTEST_F(RSSurfaceRenderNodeTest, ProtectedLayer002, TestSize.Level2)
2437 {
2438 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2439 ASSERT_NE(node, nullptr);
2440
2441 node->SetProtectedLayer(false);
2442 bool result = node->GetProtectedLayer();
2443 ASSERT_EQ(result, false);
2444 }
2445
2446 /**
2447 * @tc.name: GetHasProtectedLayer001
2448 * @tc.desc: Test GetHasProtectedLayer when SetProtectedLayer is true.
2449 * @tc.type: FUNC
2450 * @tc.require: issueI7ZSC2
2451 */
2452 HWTEST_F(RSSurfaceRenderNodeTest, GetHasProtectedLayer001, TestSize.Level2)
2453 {
2454 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2455 ASSERT_NE(node, nullptr);
2456
2457 node->SetProtectedLayer(true);
2458 bool result = node->GetHasProtectedLayer();
2459 ASSERT_EQ(result, true);
2460 }
2461
2462 /**
2463 * @tc.name: GetHasProtectedLayer002
2464 * @tc.desc: Test GetHasProtectedLayer when SetProtectedLayer is false.
2465 * @tc.type: FUNC
2466 * @tc.require: issueI7ZSC2
2467 */
2468 HWTEST_F(RSSurfaceRenderNodeTest, GetHasProtectedLayer002, TestSize.Level2)
2469 {
2470 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2471 ASSERT_NE(node, nullptr);
2472
2473 node->SetProtectedLayer(false);
2474 bool result = node->GetHasProtectedLayer();
2475 ASSERT_EQ(result, false);
2476 }
2477
2478 /**
2479 * @tc.name: GetHasPrivacyContentLayer001
2480 * @tc.desc: Test GetHasPrivacyContentLayer when SetProtectedLayer is true.
2481 * @tc.type: FUNC
2482 * @tc.require: issueI7ZSC2
2483 */
2484 HWTEST_F(RSSurfaceRenderNodeTest, GetHasPrivacyContentLayer001, TestSize.Level2)
2485 {
2486 auto rsContext = std::make_shared<RSContext>();
2487 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
2488 ASSERT_NE(node, nullptr);
2489
2490 node->SetHidePrivacyContent(true);
2491 bool result = node->GetHasPrivacyContentLayer();
2492 ASSERT_EQ(result, true);
2493 }
2494
2495 /**
2496 * @tc.name: GetHasPrivacyContentLayer002
2497 * @tc.desc: Test GetHasPrivacyContentLayer when SetProtectedLayer is false.
2498 * @tc.type: FUNC
2499 * @tc.require: issueI7ZSC2
2500 */
2501 HWTEST_F(RSSurfaceRenderNodeTest, GetHasPrivacyContentLayer002, TestSize.Level2)
2502 {
2503 auto rsContext = std::make_shared<RSContext>();
2504 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
2505 ASSERT_NE(node, nullptr);
2506
2507 node->SetHidePrivacyContent(false);
2508 bool result = node->GetHasPrivacyContentLayer();
2509 ASSERT_EQ(result, false);
2510 }
2511
2512 /**
2513 * @tc.name: IsCurFrameStatic001
2514 * @tc.desc: Test IsCurFrameStatic when DeviceType is PC.
2515 * @tc.type: FUNC
2516 * @tc.require: issueI9P0BR
2517 */
2518 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic001, TestSize.Level2)
2519 {
2520 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2521 ASSERT_NE(node, nullptr);
2522
2523 bool result = node->IsCurFrameStatic(DeviceType::PC);
2524 ASSERT_EQ(result, false);
2525 }
2526
2527 /**
2528 * @tc.name: IsCurFrameStatic002
2529 * @tc.desc: Test IsCurFrameStatic when DeviceType is PHONE.
2530 * @tc.type: FUNC
2531 * @tc.require: issueI9P0BR
2532 */
2533 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic002, TestSize.Level2)
2534 {
2535 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2536 ASSERT_NE(node, nullptr);
2537
2538 bool result = node->IsCurFrameStatic(DeviceType::PHONE);
2539 ASSERT_EQ(result, true);
2540 }
2541
2542 /**
2543 * @tc.name: IsCurFrameStatic003
2544 * @tc.desc: Test IsCurFrameStatic when node is leashwiNode
2545 * @tc.type: FUNC
2546 * @tc.require: issueI9P0BR
2547 */
2548 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic003, TestSize.Level2)
2549 {
2550 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2551 ASSERT_NE(node, nullptr);
2552 node->surfaceCacheContentStatic_ = true;
2553 node->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
2554 bool result = node->IsCurFrameStatic(DeviceType::PC);
2555 ASSERT_EQ(result, true);
2556 }
2557
2558 /**
2559 * @tc.name: IsCurFrameStatic004
2560 * @tc.desc: Test IsCurFrameStatic when node is selfDrawingNode
2561 * @tc.type: FUNC
2562 * @tc.require: issueI9P0BR
2563 */
2564 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic004, TestSize.Level2)
2565 {
2566 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2567 ASSERT_NE(node, nullptr);
2568 node->surfaceCacheContentStatic_ = true;
2569 node->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
2570 bool result = node->IsCurFrameStatic(DeviceType::PC);
2571 ASSERT_EQ(result, false);
2572 }
2573
2574 /**
2575 * @tc.name: IsCurFrameStatic005
2576 * @tc.desc: Test IsCurFrameStatic when childNode is contentStatic
2577 * @tc.type: FUNC
2578 * @tc.require: issueI9P0BR
2579 */
2580 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic005, TestSize.Level2)
2581 {
2582 auto leash = std::make_shared<RSSurfaceRenderNode>(id, context);
2583 ASSERT_NE(leash, nullptr);
2584 leash->surfaceCacheContentStatic_ = true;
2585 leash->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
2586 auto app = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
2587 ASSERT_NE(app, nullptr);
2588 app->surfaceCacheContentStatic_ = true;
2589 app->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2590
2591 leash->AddChild(app);
2592 leash->GenerateFullChildrenList();
2593 leash->lastFrameChildrenCnt_ = 1;
2594 bool result = leash->IsCurFrameStatic(DeviceType::PC);
2595 ASSERT_EQ(result, true);
2596 }
2597
2598 /**
2599 * @tc.name: IsCurFrameStatic006
2600 * @tc.desc: Test IsCurFrameStatic when lastFrameChildrenCnt_ is 0
2601 * @tc.type: FUNC
2602 * @tc.require: issueI9P0BR
2603 */
2604 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic006, TestSize.Level2)
2605 {
2606 auto leash = std::make_shared<RSSurfaceRenderNode>(id, context);
2607 ASSERT_NE(leash, nullptr);
2608 leash->surfaceCacheContentStatic_ = true;
2609 leash->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
2610 auto app = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
2611 ASSERT_NE(app, nullptr);
2612 app->surfaceCacheContentStatic_ = true;
2613 app->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2614
2615 leash->AddChild(app);
2616 leash->GenerateFullChildrenList();
2617 bool result = leash->IsCurFrameStatic(DeviceType::PC);
2618 ASSERT_EQ(result, false);
2619 }
2620
2621 /**
2622 * @tc.name: IsCurFrameStatic007
2623 * @tc.desc: Test IsCurFrameStatic when lastFrameChildrenCnt_ is 0
2624 * @tc.type: FUNC
2625 * @tc.require: issueI9P0BR
2626 */
2627 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic007, TestSize.Level2)
2628 {
2629 auto leash = std::make_shared<RSSurfaceRenderNode>(id, context);
2630 ASSERT_NE(leash, nullptr);
2631 leash->surfaceCacheContentStatic_ = true;
2632 leash->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
2633 auto app = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
2634 ASSERT_NE(app, nullptr);
2635 app->surfaceCacheContentStatic_ = false;
2636 app->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2637
2638 leash->AddChild(app);
2639 leash->GenerateFullChildrenList();
2640 bool result = leash->IsCurFrameStatic(DeviceType::PC);
2641 ASSERT_EQ(result, false);
2642 }
2643
2644 /**
2645 * @tc.name: IsCurFrameStatic008
2646 * @tc.desc: Test IsCurFrameStatic when childNode is not contentStatic
2647 * @tc.type: FUNC
2648 * @tc.require: issueI9P0BR
2649 */
2650 HWTEST_F(RSSurfaceRenderNodeTest, IsCurFrameStatic008, TestSize.Level2)
2651 {
2652 auto leash = std::make_shared<RSSurfaceRenderNode>(id, context);
2653 ASSERT_NE(leash, nullptr);
2654 leash->surfaceCacheContentStatic_ = true;
2655 leash->nodeType_ = RSSurfaceNodeType::LEASH_WINDOW_NODE;
2656 auto app = std::make_shared<RSSurfaceRenderNode>(id + 1, context);
2657 ASSERT_NE(app, nullptr);
2658 app->surfaceCacheContentStatic_ = false;
2659 app->nodeType_ = RSSurfaceNodeType::APP_WINDOW_NODE;
2660
2661 leash->AddChild(app);
2662 leash->GenerateFullChildrenList();
2663 leash->lastFrameChildrenCnt_ = 1;
2664 bool result = leash->IsCurFrameStatic(DeviceType::PC);
2665 ASSERT_EQ(result, false);
2666 }
2667
2668 /**
2669 * @tc.name: SetDoDirectComposition001
2670 * @tc.desc: Test SetDoDirectComposition
2671 * @tc.type: FUNC
2672 * @tc.require: issueI9Q8E9
2673 */
2674 HWTEST_F(RSSurfaceRenderNodeTest, SetDoDirectComposition001, TestSize.Level2)
2675 {
2676 auto node = std::make_shared<RSSurfaceRenderNode>(id, context);
2677 ASSERT_NE(node, nullptr);
2678
2679 node->SetDoDirectComposition(false);
2680 ASSERT_EQ(node->GetDoDirectComposition(), false);
2681
2682 node->SetDoDirectComposition(true);
2683 ASSERT_EQ(node->GetDoDirectComposition(), true);
2684 }
2685
2686 /**
2687 * @tc.name: SetSkipDraw001
2688 * @tc.desc: Test function SetSkipDraw
2689 * @tc.type: FUNC
2690 * @tc.require: issueI9U6LX
2691 */
2692 HWTEST_F(RSSurfaceRenderNodeTest, SetSkipDraw001, TestSize.Level2)
2693 {
2694 auto rsContext = std::make_shared<RSContext>();
2695 ASSERT_NE(rsContext, nullptr);
2696 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
2697 ASSERT_NE(node, nullptr);
2698
2699 node->SetSkipDraw(true);
2700 ASSERT_TRUE(node->GetSkipDraw());
2701
2702 node->SetSkipDraw(false);
2703 ASSERT_FALSE(node->GetSkipDraw());
2704 }
2705
2706 /**
2707 * @tc.name: SetSkipDraw001
2708 * @tc.desc: Test function SetSkipDraw
2709 * @tc.type: FUNC
2710 * @tc.require: issueI9U6LX
2711 */
2712 HWTEST_F(RSSurfaceRenderNodeTest, GetSkipDraw001, TestSize.Level2)
2713 {
2714 auto rsContext = std::make_shared<RSContext>();
2715 ASSERT_NE(rsContext, nullptr);
2716 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
2717 ASSERT_NE(node, nullptr);
2718
2719 ASSERT_FALSE(node->GetSkipDraw());
2720 }
2721
2722 /**
2723 * @tc.name: RotateCorner001
2724 * @tc.desc: test results of RotateCorner
2725 * @tc.type:FUNC
2726 * @tc.require:issueIAIAQ0
2727 */
2728 HWTEST_F(RSSurfaceRenderNodeTest, RotateCorner001, TestSize.Level2)
2729 {
2730 auto rsContext = std::make_shared<RSContext>();
2731 auto node = std::make_shared<RSSurfaceRenderNode>(id, rsContext);
2732 constexpr int firstCornerRadius{1};
2733 constexpr int secondCornerRadius{2};
2734 constexpr int thirdCornerRadius{3};
2735 constexpr int fourthCornerRadius{4};
2736
2737 Vector4<int> cornerRadius1{firstCornerRadius, secondCornerRadius, thirdCornerRadius, fourthCornerRadius};
2738 node->RotateCorner(RS_ROTATION_0, cornerRadius1);
2739 EXPECT_TRUE(cornerRadius1 == Vector4<int>(
2740 firstCornerRadius, secondCornerRadius, thirdCornerRadius, fourthCornerRadius));
2741
2742 Vector4<int> cornerRadius2{firstCornerRadius, secondCornerRadius, thirdCornerRadius, fourthCornerRadius};
2743 node->RotateCorner(RS_ROTATION_90, cornerRadius2);
2744 EXPECT_TRUE(cornerRadius2 == Vector4<int>(
2745 fourthCornerRadius, firstCornerRadius, secondCornerRadius, thirdCornerRadius));
2746
2747 Vector4<int> cornerRadius3{firstCornerRadius, secondCornerRadius, thirdCornerRadius, fourthCornerRadius};
2748 node->RotateCorner(RS_ROTATION_180, cornerRadius3);
2749 EXPECT_TRUE(cornerRadius3 == Vector4<int>(
2750 thirdCornerRadius, fourthCornerRadius, firstCornerRadius, secondCornerRadius));
2751
2752 Vector4<int> cornerRadius4{firstCornerRadius, secondCornerRadius, thirdCornerRadius, fourthCornerRadius};
2753 node->RotateCorner(RS_ROTATION_270, cornerRadius4);
2754 EXPECT_TRUE(cornerRadius4 == Vector4<int>(
2755 secondCornerRadius, thirdCornerRadius, fourthCornerRadius, firstCornerRadius));
2756 }
2757
2758 /**
2759 * @tc.name: MarkBlurIntersectDRMTest
2760 * @tc.desc: test if node could be marked BlurIntersectWithDRM correctly
2761 * @tc.type: FUNC
2762 * @tc.require: issuesIAQZ4I
2763 */
2764 HWTEST_F(RSSurfaceRenderNodeTest, MarkBlurIntersectDRMTest, TestSize.Level1)
2765 {
2766 std::shared_ptr<RSRenderNode> nodeTest = std::make_shared<RSRenderNode>(0);
2767 EXPECT_NE(nodeTest, nullptr);
2768 nodeTest->MarkBlurIntersectWithDRM(true, true);
2769 }
2770 } // namespace Rosen
2771 } // namespace OHOS