1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, 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 #include "drawable/rs_display_render_node_drawable.h"
18 #include "drawable/rs_surface_render_node_drawable.h"
19 #include "params/rs_render_thread_params.h"
20 #include "pipeline/rs_display_render_node.h"
21 #include "pipeline/rs_render_engine.h"
22 #include "pipeline/rs_surface_render_node.h"
23 #include "pipeline/rs_uni_render_thread.h"
24 #include "params/rs_render_thread_params.h"
25 #include "pipeline/rs_uni_render_engine.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace OHOS::Rosen::DrawableV2;
30 
31 namespace OHOS::Rosen {
32 constexpr int32_t DEFAULT_CANVAS_SIZE = 100;
33 constexpr NodeId DEFAULT_ID = 0xFFFF;
34 
35 class RSSurfaceRenderNodeDrawableTest : public testing::Test {
36 public:
37     static void SetUpTestCase();
38     static void TearDownTestCase();
39     void SetUp() override;
40     void TearDown() override;
41 
42     std::shared_ptr<RSSurfaceRenderNode> renderNode_;
43     RSRenderNodeDrawableAdapter* drawable_ = nullptr;
44     RSSurfaceRenderNodeDrawable* surfaceDrawable_ = nullptr;
45     std::shared_ptr<Drawing::Canvas> drawingCanvas_;
46     std::shared_ptr<RSPaintFilterCanvas> canvas_;
47     static inline Occlusion::Rect DEFAULT_RECT{0, 80, 500, 500};
48 };
49 
SetUpTestCase()50 void RSSurfaceRenderNodeDrawableTest::SetUpTestCase() {}
TearDownTestCase()51 void RSSurfaceRenderNodeDrawableTest::TearDownTestCase() {}
SetUp()52 void RSSurfaceRenderNodeDrawableTest::SetUp()
53 {
54     renderNode_ = std::make_shared<RSSurfaceRenderNode>(DEFAULT_ID);
55     if (!renderNode_) {
56         RS_LOGE("RSSurfaceRenderNodeDrawableTest: failed to create surface node.");
57     }
58     drawable_ = RSSurfaceRenderNodeDrawable::OnGenerate(renderNode_);
59     if (drawable_) {
60         drawable_->renderParams_ = std::make_unique<RSSurfaceRenderParams>(DEFAULT_ID);
61         surfaceDrawable_ = static_cast<RSSurfaceRenderNodeDrawable*>(drawable_);
62         if (!drawable_->renderParams_) {
63             RS_LOGE("RSSurfaceRenderNodeDrawableTest: failed to init render params.");
64         }
65     }
66     drawingCanvas_ = std::make_unique<Drawing::Canvas>(DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE);
67     if (drawingCanvas_) {
68         canvas_ = std::make_shared<RSPaintFilterCanvas>(drawingCanvas_.get());
69     }
70 }
TearDown()71 void RSSurfaceRenderNodeDrawableTest::TearDown() {}
72 
73 /**
74  * @tc.name: CreateSurfaceRenderNodeDrawableTest
75  * @tc.desc: Test If SurfaceRenderNodeDrawable Can Be Created
76  * @tc.type: FUNC
77  * @tc.require: #I9NVOG
78  */
79 HWTEST_F(RSSurfaceRenderNodeDrawableTest, CreateSurfaceRenderNodeDrawable, TestSize.Level1)
80 {
81     NodeId id = 1;
82     auto renderNode = std::make_shared<RSSurfaceRenderNode>(id);
83     auto drawable = RSSurfaceRenderNodeDrawable::OnGenerate(renderNode);
84     ASSERT_NE(drawable, nullptr);
85 }
86 
87 /**
88  * @tc.name: OnDraw
89  * @tc.desc: Test OnDraw
90  * @tc.type: FUNC
91  * @tc.require: #I9NVOG
92  */
93 HWTEST_F(RSSurfaceRenderNodeDrawableTest, OnDraw, TestSize.Level1)
94 {
95     ASSERT_NE(surfaceDrawable_, nullptr);
96     // default case, shouldpaint == false
97     ASSERT_NE(drawable_->renderParams_, nullptr);
98     surfaceDrawable_->OnDraw(*drawingCanvas_);
99     // if should paint
100     drawable_->renderParams_->shouldPaint_ = true;
101     drawable_->renderParams_->contentEmpty_ = false;
102     surfaceDrawable_->OnDraw(*drawingCanvas_);
103 }
104 
105 /**
106  * @tc.name: MergeDirtyRegionBelowCurSurface
107  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, default case, empty dirty region
108  * @tc.type: FUNC
109  * @tc.require: #I9NVOG
110  */
111 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface001, TestSize.Level1)
112 {
113     ASSERT_NE(surfaceDrawable_, nullptr);
114     auto uniParams = std::make_shared<RSRenderThreadParams>();
115     ASSERT_NE(uniParams, nullptr);
116     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
117     ASSERT_NE(surfaceParams, nullptr);
118     Drawing::Region region;
119     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
120     ASSERT_TRUE(region.IsEmpty());
121 
122     surfaceDrawable_->renderParams_ = nullptr;
123     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
124     surfaceDrawable_->renderParams_ = std::make_unique<RSSurfaceRenderParams>(surfaceDrawable_->nodeId_);
125 }
126 
127 /**
128  * @tc.name: MergeDirtyRegionBelowCurSurface
129  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, dirty region expected not empty.
130  * @tc.type: FUNC
131  * @tc.require: #I9NVOG
132  */
133 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface002, TestSize.Level1)
134 {
135     ASSERT_NE(surfaceDrawable_, nullptr);
136     auto uniParams = std::make_shared<RSRenderThreadParams>();
137     ASSERT_NE(uniParams, nullptr);
138     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
139     ASSERT_NE(surfaceParams, nullptr);
140     Drawing::Region region;
141     surfaceParams->windowInfo_.isMainWindowType_ = true;
142     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
143     ASSERT_TRUE(surfaceParams->IsMainWindowType());
144 }
145 
146 /**
147  * @tc.name: MergeDirtyRegionBelowCurSurface
148  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, dirty region expected not empty.
149  * @tc.type: FUNC
150  * @tc.require: issueIAEDYI
151  */
152 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface003, TestSize.Level1)
153 {
154     ASSERT_NE(surfaceDrawable_, nullptr);
155     auto uniParams = std::make_shared<RSRenderThreadParams>();
156     ASSERT_NE(uniParams, nullptr);
157     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
158     ASSERT_NE(surfaceParams, nullptr);
159     Drawing::Region region;
160     surfaceParams->windowInfo_.isMainWindowType_ = true;
161     Occlusion::Rect rect(1, 2, 3, 4);
162     Occlusion::Rect bound(1, 2, 3, 4);
163     surfaceParams->visibleRegion_.rects_.push_back(rect);
164     surfaceParams->visibleRegion_.bound_ = bound;
165     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
166     ASSERT_FALSE(surfaceParams->GetVisibleRegion().IsEmpty());
167 }
168 
169 /**
170  * @tc.name: MergeDirtyRegionBelowCurSurface
171  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, dirty region expected not empty.
172  * @tc.type: FUNC
173  * @tc.require: issueIAEDYI
174  */
175 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface004, TestSize.Level1)
176 {
177     ASSERT_NE(surfaceDrawable_, nullptr);
178     auto uniParams = std::make_shared<RSRenderThreadParams>();
179     ASSERT_NE(uniParams, nullptr);
180     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
181     ASSERT_NE(surfaceParams, nullptr);
182     Drawing::Region region;
183     surfaceParams->windowInfo_.isMainWindowType_ = false;
184     surfaceParams->windowInfo_.isLeashWindow_ = true;
185     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
186     ASSERT_TRUE(surfaceParams->GetVisibleRegion().IsEmpty());
187 }
188 
189 /**
190  * @tc.name: MergeDirtyRegionBelowCurSurface
191  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, dirty region expected not empty.
192  * @tc.type: FUNC
193  * @tc.require: issueIAEDYI
194  */
195 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface005, TestSize.Level1)
196 {
197     ASSERT_NE(surfaceDrawable_, nullptr);
198     auto uniParams = std::make_shared<RSRenderThreadParams>();
199     ASSERT_NE(uniParams, nullptr);
200     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
201     ASSERT_NE(surfaceParams, nullptr);
202     Drawing::Region region;
203     surfaceParams->windowInfo_.isMainWindowType_ = true;
204     surfaceParams->windowInfo_.isLeashWindow_ = true;
205     surfaceParams->isParentScaling_ = true;
206     surfaceParams->isSubSurfaceNode_ = true;
207     Occlusion::Rect rect(1, 2, 3, 4);
208     Occlusion::Rect bound(1, 2, 3, 4);
209     surfaceParams->visibleRegion_.rects_.push_back(rect);
210     surfaceParams->visibleRegion_.bound_ = bound;
211     ASSERT_FALSE(surfaceParams->GetVisibleRegion().IsEmpty());
212     uniParams->accumulatedDirtyRegion_ = Occlusion::Rect { 0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE };
213     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
214     ASSERT_FALSE(surfaceParams->GetVisibleRegion().IsEmpty());
215 }
216 
217 /**
218  * @tc.name: MergeDirtyRegionBelowCurSurface
219  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, dirty region expected not empty.
220  * @tc.type: FUNC
221  * @tc.require: issueIAEDYI
222  */
223 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface006, TestSize.Level1)
224 {
225     ASSERT_NE(surfaceDrawable_, nullptr);
226     auto uniParams = std::make_shared<RSRenderThreadParams>();
227     ASSERT_NE(uniParams, nullptr);
228     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
229     ASSERT_NE(surfaceParams, nullptr);
230     Drawing::Region region;
231     surfaceParams->windowInfo_.isMainWindowType_ = true;
232     surfaceParams->windowInfo_.isLeashWindow_ = true;
233     surfaceParams->isParentScaling_ = false;
234     surfaceParams->isSubSurfaceNode_ = true;
235     uniParams->accumulatedDirtyRegion_ = Occlusion::Rect { 0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE };
236     surfaceParams->visibleRegion_ = Occlusion::Rect { 0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE };
237     Occlusion::Rect rect(1, 2, 3, 4);
238     Occlusion::Rect bound(1, 2, 3, 4);
239     surfaceParams->visibleRegion_.rects_.push_back(rect);
240     surfaceParams->visibleRegion_.bound_ = bound;
241     surfaceParams->uiFirstFlag_ = MultiThreadCacheType::ARKTS_CARD;
242     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
243     ASSERT_FALSE(surfaceParams->GetVisibleRegion().IsEmpty());
244 }
245 
246 /**
247  * @tc.name: MergeDirtyRegionBelowCurSurface
248  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, dirty region expected not empty.
249  * @tc.type: FUNC
250  * @tc.require: issueIAEDYI
251  */
252 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface007, TestSize.Level1)
253 {
254     ASSERT_NE(surfaceDrawable_, nullptr);
255     auto uniParams = std::make_shared<RSRenderThreadParams>();
256     ASSERT_NE(uniParams, nullptr);
257     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
258     ASSERT_NE(surfaceParams, nullptr);
259     Drawing::Region region;
260     surfaceParams->windowInfo_.isMainWindowType_ = false;
261     surfaceParams->windowInfo_.isLeashWindow_ = true;
262     surfaceParams->isParentScaling_ = true;
263     surfaceParams->isSubSurfaceNode_ = false;
264     uniParams->accumulatedDirtyRegion_ = Occlusion::Rect { 0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE };
265     surfaceParams->visibleRegion_ = Occlusion::Rect { 0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE };
266     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
267     ASSERT_FALSE(surfaceParams->GetVisibleRegion().IsEmpty());
268 }
269 
270 /**
271  * @tc.name: MergeDirtyRegionBelowCurSurface
272  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, dirty region expected not empty.
273  * @tc.type: FUNC
274  * @tc.require: issueIAEDYI
275  */
276 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface008, TestSize.Level1)
277 {
278     ASSERT_NE(surfaceDrawable_, nullptr);
279     auto uniParams = std::make_shared<RSRenderThreadParams>();
280     ASSERT_NE(uniParams, nullptr);
281     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
282     ASSERT_NE(surfaceParams, nullptr);
283     Drawing::Region region;
284     surfaceParams->windowInfo_.isMainWindowType_ = false;
285     surfaceParams->windowInfo_.isLeashWindow_ = true;
286     surfaceParams->isParentScaling_ = false;
287     surfaceParams->isSubSurfaceNode_ = true;
288     uniParams->accumulatedDirtyRegion_ = Occlusion::Rect { 0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE };
289     surfaceParams->visibleRegion_ = Occlusion::Rect { 0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE };
290     Occlusion::Rect rect(1, 2, 3, 4);
291     Occlusion::Rect bound(1, 2, 3, 4);
292     surfaceParams->visibleRegion_.rects_.push_back(rect);
293     surfaceParams->visibleRegion_.bound_ = bound;
294     uniParams->accumulatedDirtyRegion_.rects_.push_back(rect);
295     uniParams->accumulatedDirtyRegion_.bound_ = bound;
296     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
297     ASSERT_FALSE(surfaceParams->GetVisibleRegion().IsEmpty());
298 }
299 
300 /**
301  * @tc.name: MergeDirtyRegionBelowCurSurface
302  * @tc.desc: Test MergeDirtyRegionBelowCurSurface, dirty region expected not empty.
303  * @tc.type: FUNC
304  * @tc.require: issueIAEDYI
305  */
306 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeDirtyRegionBelowCurSurface009, TestSize.Level1)
307 {
308     ASSERT_NE(surfaceDrawable_, nullptr);
309     auto uniParams = std::make_shared<RSRenderThreadParams>();
310     ASSERT_NE(uniParams, nullptr);
311     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
312     ASSERT_NE(surfaceParams, nullptr);
313     Drawing::Region region;
314     surfaceParams->windowInfo_.isMainWindowType_ = false;
315     surfaceParams->windowInfo_.isLeashWindow_ = true;
316     surfaceParams->isParentScaling_ = false;
317     surfaceParams->isSubSurfaceNode_ = false;
318     uniParams->accumulatedDirtyRegion_ = Occlusion::Rect{0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE};
319     surfaceParams->transparentRegion_ = Occlusion::Rect{0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE};
320     surfaceParams->SetVisibleRegion(Occlusion::Rect{0, 0, DEFAULT_CANVAS_SIZE, DEFAULT_CANVAS_SIZE});
321     Occlusion::Rect rect(1, 2, 3, 4);
322     Occlusion::Rect bound(1, 2, 3, 4);
323     surfaceParams->transparentRegion_.rects_.push_back(rect);
324     surfaceParams->transparentRegion_.bound_ = bound;
325     uniParams->accumulatedDirtyRegion_.rects_.push_back(rect);
326     uniParams->accumulatedDirtyRegion_.bound_ = bound;
327     surfaceDrawable_->MergeDirtyRegionBelowCurSurface(*uniParams, region);
328     ASSERT_FALSE(surfaceParams->GetTransparentRegion().IsEmpty());
329     ASSERT_FALSE(region.IsEmpty());
330 }
331 
332 /**
333  * @tc.name: OnCapture
334  * @tc.desc: Test OnCapture
335  * @tc.type: FUNC
336  * @tc.require: #I9NVOG
337  */
338 HWTEST_F(RSSurfaceRenderNodeDrawableTest, OnCapture, TestSize.Level1)
339 {
340     ASSERT_NE(surfaceDrawable_, nullptr);
341     ASSERT_NE(drawable_->renderParams_, nullptr);
342     // default, should not paint
343     surfaceDrawable_->OnCapture(*canvas_);
344     // should paint
345     drawable_->renderParams_->shouldPaint_ = true;
346     drawable_->renderParams_->contentEmpty_ = false;
347     surfaceDrawable_->OnCapture(*canvas_);
348 }
349 
350 /**
351  * @tc.name: CaptureSurface
352  * @tc.desc: Test CaptureSurface, default case
353  * @tc.type: FUNC
354  * @tc.require: #I9NVOG
355  */
356 HWTEST_F(RSSurfaceRenderNodeDrawableTest, CaptureSurface001, TestSize.Level1)
357 {
358     ASSERT_NE(surfaceDrawable_, nullptr);
359     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
360     ASSERT_NE(surfaceParams, nullptr);
361     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
362     surfaceParams->rsSurfaceNodeType_ = RSSurfaceNodeType::SELF_DRAWING_NODE;
363     surfaceParams->isSpherizeValid_ = false;
364     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
365     surfaceDrawable_->hasHdrPresent_ = true;
366     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
367 
368     surfaceParams->protectedLayerIds_.insert(1);
369     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
370     surfaceParams->skipLayerIds_.insert(1);
371     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
372     surfaceParams->securityLayerIds_.insert(1);
373     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
374     ASSERT_TRUE(surfaceParams->HasSkipLayer());
375     RSUniRenderThread::Instance().Sync(std::make_unique<RSRenderThreadParams>());
376     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
377 
378     surfaceParams->isProtectedLayer_ = true;
379     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
380     surfaceParams->isSkipLayer_ = true;
381     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
382     surfaceParams->isSecurityLayer_ = true;
383     CaptureParam param;
384     param.isSingleSurface_ = true;
385     RSUniRenderThread::SetCaptureParam(param);
386     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
387     ASSERT_TRUE(surfaceParams->GetIsSecurityLayer());
388 }
389 
390 #ifdef USE_VIDEO_PROCESSING_ENGINE
391 /**
392  * @tc.name: DealWithHdr
393  * @tc.desc: Test DealWithHdr
394  * @tc.type: FUNC
395  * @tc.require: issueIAEDYI
396  */
397 HWTEST_F(RSSurfaceRenderNodeDrawableTest, DealWithHdr, TestSize.Level1)
398 {
399     ASSERT_NE(surfaceDrawable_, nullptr);
400     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
401     ASSERT_NE(surfaceParams, nullptr);
402     surfaceDrawable_->DealWithHdr(*renderNode_, *surfaceParams);
403 }
404 #endif
405 
406 /**
407  * @tc.name: CaptureSurface
408  * @tc.desc: Test CaptureSurface, special case: security/protected layer.
409  * @tc.type: FUNC
410  * @tc.require: #I9NVOG
411  */
412 HWTEST_F(RSSurfaceRenderNodeDrawableTest, CaptureSurface002, TestSize.Level1)
413 {
414     ASSERT_NE(surfaceDrawable_, nullptr);
415     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
416     ASSERT_NE(surfaceParams, nullptr);
417     surfaceParams->isSecurityLayer_ = true;
418     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
419     surfaceParams->isSecurityLayer_ = false;
420     surfaceParams->isProtectedLayer_ = true;
421     surfaceDrawable_->CaptureSurface(*canvas_, *surfaceParams);
422 }
423 
424 /**
425  * @tc.name: MergeSubSurfaceNodesDirtyRegionForMainWindow_001
426  * @tc.desc: Test MergeSubSurfaceNodesDirtyRegionForMainWindow, if a surface has no sub-surface, early return.
427  * @tc.type: FUNC
428  * @tc.require: issueIB2HV9
429  */
430 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeSubSurfaceNodesDirtyRegionForMainWindow_001, TestSize.Level1)
431 {
432     // main surface
433     ASSERT_NE(drawable_, nullptr);
434     ASSERT_NE(surfaceDrawable_, nullptr);
435     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
436     ASSERT_NE(surfaceParams, nullptr);
437 
438     Occlusion::Region resultRegion;
439     surfaceDrawable_->MergeSubSurfaceNodesDirtyRegionForMainWindow(*surfaceParams, resultRegion);
440     ASSERT_TRUE(resultRegion.IsEmpty());
441 }
442 
443 /**
444  * @tc.name: MergeSubSurfaceNodesDirtyRegionForMainWindow_002
445  * @tc.desc: Test MergeSubSurfaceNodesDirtyRegionForMainWindow, if a surface has subsurface dirty, it should be counted.
446  * @tc.type: FUNC
447  * @tc.require: issueIB2HV9
448  */
449 HWTEST_F(RSSurfaceRenderNodeDrawableTest, MergeSubSurfaceNodesDirtyRegionForMainWindow_002, TestSize.Level1)
450 {
451     // main surface
452     ASSERT_NE(drawable_, nullptr);
453     ASSERT_NE(surfaceDrawable_, nullptr);
454     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
455     ASSERT_NE(surfaceParams, nullptr);
456     // child surface
457     NodeId subSurfaceId = 1;
458     auto subSurfaceNode = std::make_shared<RSSurfaceRenderNode>(subSurfaceId);
459     ASSERT_NE(subSurfaceNode, nullptr);
460     RSRenderNodeDrawableAdapter::SharedPtr subNodeDrawable(RSSurfaceRenderNodeDrawable::OnGenerate(subSurfaceNode));
461     ASSERT_NE(subNodeDrawable, nullptr);
462     auto subSurfaceDrawable = static_cast<RSSurfaceRenderNodeDrawable*>(subNodeDrawable.get());
463     ASSERT_NE(subSurfaceDrawable, nullptr);
464     subSurfaceDrawable->syncDirtyManager_->dirtyRegion_ = {
465         DEFAULT_RECT.left_, DEFAULT_RECT.top_,
466         DEFAULT_RECT.right_ - DEFAULT_RECT.left_, DEFAULT_RECT.bottom_ - DEFAULT_RECT.top_ };
467     RSRenderNodeDrawableAdapter::RenderNodeDrawableCache_.emplace(subSurfaceId, subNodeDrawable);
468     surfaceParams->allSubSurfaceNodeIds_.insert(subSurfaceId);
469 
470     Occlusion::Region resultRegion;
471     surfaceDrawable_->MergeSubSurfaceNodesDirtyRegionForMainWindow(*surfaceParams, resultRegion);
472     ASSERT_FALSE(resultRegion.IsEmpty());
473 }
474 
475 /**
476  * @tc.name: CalculateVisibleDirtyRegion
477  * @tc.desc: Test CalculateVisibleDirtyRegion
478  * @tc.type: FUNC
479  * @tc.require: #IA940V
480  */
481 HWTEST_F(RSSurfaceRenderNodeDrawableTest, CalculateVisibleDirtyRegion, TestSize.Level1)
482 {
483     ASSERT_NE(surfaceDrawable_, nullptr);
484     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
485     ASSERT_NE(surfaceParams, nullptr);
486     auto uniParams = std::make_shared<RSRenderThreadParams>();
487 
488     surfaceParams->SetWindowInfo(false, true, false);
489     Drawing::Region result = surfaceDrawable_->CalculateVisibleDirtyRegion(*uniParams,
490         *surfaceParams, *surfaceDrawable_, true);
491     ASSERT_TRUE(result.IsEmpty());
492 
493     surfaceParams->SetWindowInfo(true, false, false);
494     result = surfaceDrawable_->CalculateVisibleDirtyRegion(*uniParams, *surfaceParams, *surfaceDrawable_, true);
495     ASSERT_FALSE(result.IsEmpty());
496 
497     uniParams->SetOcclusionEnabled(true);
498     Occlusion::Region region;
499     surfaceParams->SetVisibleRegion(region);
500     result = surfaceDrawable_->CalculateVisibleDirtyRegion(*uniParams, *surfaceParams, *surfaceDrawable_, false);
501     ASSERT_TRUE(result.IsEmpty());
502 
503     Occlusion::Region region1(DEFAULT_RECT);
504     surfaceParams->SetVisibleRegion(region1);
505     uniParams->SetOcclusionEnabled(false);
506     surfaceDrawable_->globalDirtyRegion_ = region1;
507     surfaceDrawable_->CalculateVisibleDirtyRegion(*uniParams, *surfaceParams, *surfaceDrawable_, false);
508 }
509 
510 /**
511  * @tc.name: PrepareOffscreenRender
512  * @tc.desc: Test PrepareOffscreenRender
513  * @tc.type: FUNC
514  * @tc.require: #IA940V
515  */
516 HWTEST_F(RSSurfaceRenderNodeDrawableTest, PrepareOffscreenRender, TestSize.Level1)
517 {
518     ASSERT_NE(surfaceDrawable_, nullptr);
519     std::shared_ptr<Drawing::Surface> surface = Drawing::Surface::MakeRasterN32Premul(100, 100);
520     ASSERT_NE(surface, nullptr);
521     RSPaintFilterCanvas paintFilterCanvas(surface.get());
522     surfaceDrawable_->curCanvas_ = &paintFilterCanvas;
523     surfaceDrawable_->offscreenSurface_ = std::make_shared<Drawing::Surface>();
524     ASSERT_TRUE(surfaceDrawable_->PrepareOffscreenRender());
525 
526     surfaceDrawable_->curCanvas_->surface_ = nullptr;
527     ASSERT_FALSE(surfaceDrawable_->PrepareOffscreenRender());
528 }
529 
530 /**
531  * @tc.name: PrepareOffscreenRender
532  * @tc.desc: Test PrepareOffscreenRender
533  * @tc.type: FUNC
534  * @tc.require: issueIAEDYI
535  */
536 HWTEST_F(RSSurfaceRenderNodeDrawableTest, PrepareOffscreenRenderTest001, TestSize.Level1)
537 {
538     ASSERT_NE(surfaceDrawable_, nullptr);
539     std::shared_ptr<Drawing::Surface> surface = Drawing::Surface::MakeRasterN32Premul(100, 100);
540     ASSERT_NE(surface, nullptr);
541     RSPaintFilterCanvas paintFilterCanvas(surface.get());
542     surfaceDrawable_->curCanvas_ = &paintFilterCanvas;
543     surfaceDrawable_->offscreenSurface_ = std::make_shared<Drawing::Surface>();
544     ASSERT_TRUE(surfaceDrawable_->PrepareOffscreenRender());
545     ASSERT_TRUE(surfaceDrawable_->curCanvas_->GetSurface());
546 }
547 
548 /**
549  * @tc.name: PrepareOffscreenRender
550  * @tc.desc: Test PrepareOffscreenRender
551  * @tc.type: FUNC
552  * @tc.require: issueIAEDYI
553  */
554 HWTEST_F(RSSurfaceRenderNodeDrawableTest, PrepareOffscreenRenderTest002, TestSize.Level1)
555 {
556     ASSERT_NE(surfaceDrawable_, nullptr);
557     std::shared_ptr<Drawing::Surface> surface = Drawing::Surface::MakeRasterN32Premul(100, 100);
558     ASSERT_NE(surface, nullptr);
559     RSPaintFilterCanvas paintFilterCanvas(surface.get());
560     surfaceDrawable_->curCanvas_ = &paintFilterCanvas;
561     surfaceDrawable_->maxRenderSize_ = 200; // for test
562     surfaceDrawable_->offscreenSurface_ = std::make_shared<Drawing::Surface>();
563     ASSERT_TRUE(surfaceDrawable_->PrepareOffscreenRender());
564     ASSERT_TRUE(surfaceDrawable_->curCanvas_->GetSurface());
565 }
566 
567 /**
568  * @tc.name: IsHardwareEnabled
569  * @tc.desc: Test IsHardwareEnabled
570  * @tc.type: FUNC
571  * @tc.require: issueIAEDYI
572  */
573 HWTEST_F(RSSurfaceRenderNodeDrawableTest, IsHardwareEnabled, TestSize.Level1)
574 {
575     ASSERT_NE(surfaceDrawable_, nullptr);
576     RSUniRenderThread::Instance().Sync(std::make_unique<RSRenderThreadParams>());
577     ASSERT_FALSE(surfaceDrawable_->IsHardwareEnabled());
578 
579     auto nodePtr = std::make_shared<RSRenderNode>(0);
580     ASSERT_NE(nodePtr, nullptr);
581     auto rsSurfaceRenderNode = DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(nodePtr);
582     RSRenderThreadParamsManager::Instance().renderThreadParams_ = std::make_unique<RSRenderThreadParams>();
583     RSUniRenderThread::Instance().GetRSRenderThreadParams()->hardwareEnabledTypeDrawables_.push_back(
584         std::make_pair(0, rsSurfaceRenderNode));
585     ASSERT_FALSE(surfaceDrawable_->IsHardwareEnabled());
586 
587     auto rsRenderNode = std::make_shared<RSRenderNode>(0);
588     ASSERT_NE(rsRenderNode, nullptr);
589     auto surfaceRenderNode = DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(rsRenderNode);
590     surfaceRenderNode->renderParams_ = std::make_unique<RSRenderParams>(0);
591     RSUniRenderThread::Instance().GetRSRenderThreadParams()->hardwareEnabledTypeDrawables_.push_back(
592         std::make_pair(0, surfaceRenderNode));
593     ASSERT_FALSE(surfaceDrawable_->IsHardwareEnabled());
594 }
595 
596 /**
597  * @tc.name: FinishOffscreenRender
598  * @tc.desc: Test FinishOffscreenRender
599  * @tc.type: FUNC
600  * @tc.require: #IA940V
601  */
602 HWTEST_F(RSSurfaceRenderNodeDrawableTest, FinishOffscreenRender, TestSize.Level1)
603 {
604     ASSERT_NE(surfaceDrawable_, nullptr);
605     Drawing::SamplingOptions samping;
606     surfaceDrawable_->FinishOffscreenRender(samping);
607     Drawing::Canvas canvas;
608     RSPaintFilterCanvas backupCanvas(&canvas);
609     surfaceDrawable_->canvasBackup_ = &backupCanvas;
610 
611     Drawing::Canvas canvas2;
612     RSPaintFilterCanvas curCanvas(&canvas2);
613     surfaceDrawable_->curCanvas_ = &curCanvas;
614     surfaceDrawable_->curCanvas_->Save();
615     surfaceDrawable_->offscreenSurface_ = Drawing::Surface::MakeRasterN32Premul(100, 100);
616     surfaceDrawable_->FinishOffscreenRender(samping);
617     ASSERT_NE(surfaceDrawable_->curCanvas_, nullptr);
618 }
619 
620 /**
621  * @tc.name: DrawUIFirstDfx
622  * @tc.desc: Test DrawUIFirstDfx
623  * @tc.type: FUNC
624  * @tc.require: #IA940V
625  */
626 HWTEST_F(RSSurfaceRenderNodeDrawableTest, DrawUIFirstDfx, TestSize.Level1)
627 {
628     ASSERT_NE(surfaceDrawable_, nullptr);
629     Drawing::Canvas canvas;
630     RSPaintFilterCanvas paintFilterCanvas(&canvas);
631 
632     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
633     ASSERT_NE(surfaceParams, nullptr);
634 
635     surfaceDrawable_->DrawUIFirstDfx(paintFilterCanvas, MultiThreadCacheType::ARKTS_CARD, *surfaceParams, true);
636     surfaceDrawable_->DrawUIFirstDfx(paintFilterCanvas, MultiThreadCacheType::LEASH_WINDOW, *surfaceParams, true);
637     surfaceDrawable_->DrawUIFirstDfx(paintFilterCanvas, MultiThreadCacheType::LEASH_WINDOW, *surfaceParams, false);
638 }
639 
640 /**
641  * @tc.name: GetVisibleDirtyRegion
642  * @tc.desc: Test GetVisibleDirtyRegion
643  * @tc.type: FUNC
644  * @tc.require: #IA940V
645  */
646 HWTEST_F(RSSurfaceRenderNodeDrawableTest, GetVisibleDirtyRegion, TestSize.Level1)
647 {
648     ASSERT_NE(surfaceDrawable_, nullptr);
649 
650     Occlusion::Region region(Occlusion::Rect{0, 0, 100, 100});
651     surfaceDrawable_->SetVisibleDirtyRegion(region);
652     ASSERT_FALSE(surfaceDrawable_->GetVisibleDirtyRegion().IsEmpty());
653 }
654 
655 /**
656  * @tc.name: SetVisibleDirtyRegion
657  * @tc.desc: Test SetVisibleDirtyRegion
658  * @tc.type: FUNC
659  * @tc.require: #IA940V
660  */
661 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetVisibleDirtyRegion, TestSize.Level1)
662 {
663     ASSERT_NE(surfaceDrawable_, nullptr);
664 
665     Occlusion::Region region(Occlusion::Rect{0, 0, 100, 100});
666     surfaceDrawable_->SetVisibleDirtyRegion(region);
667     ASSERT_FALSE(surfaceDrawable_->GetVisibleDirtyRegion().IsEmpty());
668 
669     surfaceDrawable_->renderNode_ = std::weak_ptr<const RSRenderNode>();
670     surfaceDrawable_->SetVisibleDirtyRegion(region);
671 }
672 
673 /**
674  * @tc.name: SetAlignedVisibleDirtyRegion
675  * @tc.desc: Test SetAlignedVisibleDirtyRegion
676  * @tc.type: FUNC
677  * @tc.require: #IA940V
678  */
679 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetAlignedVisibleDirtyRegion, TestSize.Level1)
680 {
681     ASSERT_NE(surfaceDrawable_, nullptr);
682 
683     Occlusion::Region region(Occlusion::Rect{0, 0, 100, 100});
684     surfaceDrawable_->SetAlignedVisibleDirtyRegion(region);
685 
686     surfaceDrawable_->renderNode_ = std::weak_ptr<const RSRenderNode>();
687     surfaceDrawable_->SetAlignedVisibleDirtyRegion(region);
688 }
689 
690 /**
691  * @tc.name: SetGlobalDirtyRegion
692  * @tc.desc: Test SetGlobalDirtyRegion
693  * @tc.type: FUNC
694  * @tc.require: #IA940V
695  */
696 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetGlobalDirtyRegion, TestSize.Level1)
697 {
698     ASSERT_NE(surfaceDrawable_, nullptr);
699 
700     Occlusion::Region rect;
701     surfaceDrawable_->SetGlobalDirtyRegion(rect);
702 
703     surfaceDrawable_->renderNode_ = std::weak_ptr<const RSRenderNode>();
704     surfaceDrawable_->SetGlobalDirtyRegion(rect);
705 }
706 /**
707  * @tc.name: SetDirtyRegionBelowCurrentLayer
708  * @tc.desc: Test SetDirtyRegionBelowCurrentLayer
709  * @tc.type: FUNC
710  * @tc.require: #IA940V
711  */
712 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetDirtyRegionBelowCurrentLayer, TestSize.Level1)
713 {
714     ASSERT_NE(surfaceDrawable_, nullptr);
715     ASSERT_NE(renderNode_, nullptr);
716 
717     Occlusion::Region region;
718     surfaceDrawable_->SetDirtyRegionBelowCurrentLayer(region);
719 
720     surfaceDrawable_->renderNode_ = std::weak_ptr<const RSRenderNode>();
721     surfaceDrawable_->SetDirtyRegionBelowCurrentLayer(region);
722 }
723 
724 /**
725  * @tc.name: GetSyncDirtyManager
726  * @tc.desc: Test GetSyncDirtyManager
727  * @tc.type: FUNC
728  * @tc.require: #IA940V
729  */
730 HWTEST_F(RSSurfaceRenderNodeDrawableTest, GetSyncDirtyManager, TestSize.Level1)
731 {
732     ASSERT_NE(surfaceDrawable_, nullptr);
733     ASSERT_NE(renderNode_, nullptr);
734 
735     std::shared_ptr<RSDirtyRegionManager> manager = surfaceDrawable_->GetSyncDirtyManager();
736     ASSERT_NE(manager, nullptr);
737 }
738 
739 /**
740  * @tc.name: GetSyncDirtyManager
741  * @tc.desc: Test GetSyncDirtyManager
742  * @tc.type: FUNC
743  * @tc.require: #I9NVOG
744  */
745 HWTEST_F(RSSurfaceRenderNodeDrawableTest, GetSyncDirtyManagerTest, TestSize.Level1)
746 {
747     auto renderNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_ID-1);
748     ASSERT_NE(renderNode, nullptr);
749     auto drawable = std::static_pointer_cast<RSSurfaceRenderNodeDrawable>(
750         DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(renderNode));
751     ASSERT_NE(drawable, nullptr);
752     drawable->GetSyncDirtyManager();
753     renderNode = nullptr;
754     drawable->GetSyncDirtyManager();
755 }
756 
757 /**
758  * @tc.name: SetDirtyRegionBelowCurrentLayer
759  * @tc.desc: Test SetDirtyRegionBelowCurrentLayer
760  * @tc.type: FUNC
761  * @tc.require: #I9NVOG
762  */
763 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetDirtyRegionBelowCurrentLayerTest, TestSize.Level1)
764 {
765     auto renderNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_ID-1);
766     ASSERT_NE(renderNode, nullptr);
767     auto drawable = std::static_pointer_cast<RSSurfaceRenderNodeDrawable>(
768         DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(renderNode));
769     ASSERT_NE(drawable, nullptr);
770     Occlusion::Region VisibleDirtyRegion;
771     drawable->SetDirtyRegionBelowCurrentLayer(VisibleDirtyRegion);
772     renderNode = nullptr;
773     drawable->SetDirtyRegionBelowCurrentLayer(VisibleDirtyRegion);
774 }
775 
776 /**
777  * @tc.name: SetDirtyRegionAlignedEnable
778  * @tc.desc: Test SetDirtyRegionAlignedEnable
779  * @tc.type: FUNC
780  * @tc.require: #I9NVOG
781  */
782 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetDirtyRegionAlignedEnableTest, TestSize.Level1)
783 {
784     auto renderNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_ID-1);
785     ASSERT_NE(renderNode, nullptr);
786     auto drawable = std::static_pointer_cast<RSSurfaceRenderNodeDrawable>(
787         DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(renderNode));
788     ASSERT_NE(drawable, nullptr);
789     drawable->SetDirtyRegionAlignedEnable(true);
790     renderNode = nullptr;
791     drawable->SetDirtyRegionAlignedEnable(true);
792 }
793 
794 /**
795  * @tc.name: SetGlobalDirtyRegion
796  * @tc.desc: Test SetGlobalDirtyRegion
797  * @tc.type: FUNC
798  * @tc.require: #I9NVOG
799  */
800 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetGlobalDirtyRegionTest, TestSize.Level1)
801 {
802     auto renderNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_ID-1);
803     ASSERT_NE(renderNode, nullptr);
804     auto drawable = std::static_pointer_cast<RSSurfaceRenderNodeDrawable>(
805         DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(renderNode));
806     ASSERT_NE(drawable, nullptr);
807     const Occlusion::Region rect{Occlusion::Rect(0, 0, 100, 100)};
808     drawable->SetGlobalDirtyRegion(rect);
809     renderNode = nullptr;
810     drawable->SetGlobalDirtyRegion(rect);
811 }
812 
813 /**
814  * @tc.name: GetVisibleDirtyRegion
815  * @tc.desc: Test GetVisibleDirtyRegion
816  * @tc.type: FUNC
817  * @tc.require: #I9NVOG
818  */
819 HWTEST_F(RSSurfaceRenderNodeDrawableTest, GetVisibleDirtyRegionTest, TestSize.Level1)
820 {
821     auto renderNode = std::make_shared<RSSurfaceRenderNode>(DEFAULT_ID-1);
822     ASSERT_NE(renderNode, nullptr);
823     auto drawable = std::static_pointer_cast<RSSurfaceRenderNodeDrawable>(
824         DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(renderNode));
825     ASSERT_NE(drawable, nullptr);
826     drawable->GetVisibleDirtyRegion();
827     renderNode = nullptr;
828     drawable->GetVisibleDirtyRegion();
829 }
830 
831 /**
832  * @tc.name: EnableGpuOverDrawDrawBufferOptimization
833  * @tc.desc: Test EnableGpuOverDrawDrawBufferOptimization
834  * @tc.type: FUNC
835  * @tc.require: #I9NVOG
836  */
837 HWTEST_F(RSSurfaceRenderNodeDrawableTest, EnableGpuOverDrawDrawBufferOptimizationTest, TestSize.Level1)
838 {
839     ASSERT_NE(surfaceDrawable_, nullptr);
840     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
841     ASSERT_NE(surfaceParams, nullptr);
842     Drawing::Canvas drawingCanvas;
843     surfaceDrawable_->EnableGpuOverDrawDrawBufferOptimization(drawingCanvas, surfaceParams);
844 
845     Vector4f vct(1.f, 1.f, 1.f, 1.f); // for test
846     surfaceParams->overDrawBufferNodeCornerRadius_ = vct;
847     surfaceDrawable_->EnableGpuOverDrawDrawBufferOptimization(drawingCanvas, surfaceParams);
848 }
849 
850 /**
851  * @tc.name: DrawUIFirstDfx
852  * @tc.desc: Test DrawUIFirstDfx
853  * @tc.type: FUNC
854  * @tc.require: #I9NVOG
855  */
856 HWTEST_F(RSSurfaceRenderNodeDrawableTest, DrawUIFirstDfxTest, TestSize.Level1)
857 {
858     ASSERT_NE(surfaceDrawable_, nullptr);
859     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
860     ASSERT_NE(surfaceParams, nullptr);
861     Drawing::Canvas drawingCanvas;
862     RSPaintFilterCanvas canvas(&drawingCanvas);
863 
864     MultiThreadCacheType enableType = MultiThreadCacheType::ARKTS_CARD;
865     surfaceDrawable_->DrawUIFirstDfx(canvas, enableType, *surfaceParams, true);
866 
867     enableType = MultiThreadCacheType::LEASH_WINDOW;
868     surfaceDrawable_->DrawUIFirstDfx(canvas, enableType, *surfaceParams, true);
869     surfaceDrawable_->DrawUIFirstDfx(canvas, enableType, *surfaceParams, false);
870 }
871 
872 /**
873  * @tc.name: DealWithSelfDrawingNodeBuffer
874  * @tc.desc: Test DealWithSelfDrawingNodeBuffer
875  * @tc.type: FUNC
876  * @tc.require: #I9NVOG
877  */
878 HWTEST_F(RSSurfaceRenderNodeDrawableTest, DealWithSelfDrawingNodeBufferTest, TestSize.Level1)
879 {
880     ASSERT_NE(renderNode_, nullptr);
881     ASSERT_NE(surfaceDrawable_, nullptr);
882     RSUniRenderThread::GetCaptureParam().isSnapshot_ = true;
883     std::shared_ptr<Drawing::Surface> drawingSurface = std::make_shared<Drawing::Surface>();
884     canvas_->surface_ = drawingSurface.get();
885     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
886     ASSERT_NE(surfaceParams, nullptr);
887     const auto params01 = surfaceParams;
888     RSUniRenderThread::Instance().uniRenderEngine_ = std::make_shared<RSUniRenderEngine>();
889     surfaceParams->isHardwareEnabled_ = true;
890     CaptureParam param;
891     param.isSnapshot_ = false;
892     param.isMirror_ = false;
893     RSUniRenderThread::SetCaptureParam(param);
894     surfaceDrawable_->DealWithSelfDrawingNodeBuffer(*canvas_, *params01);
895     ASSERT_FALSE(surfaceDrawable_->IsHardwareEnabledTopSurface());
896     ASSERT_TRUE(surfaceParams->GetHardwareEnabled());
897 
898     renderNode_->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
899     renderNode_->name_ = "pointer window"; // for test
900     const auto params03 = surfaceParams;
901     surfaceDrawable_->DealWithSelfDrawingNodeBuffer(*canvas_, *params03);
902     ASSERT_TRUE(renderNode_->IsHardwareEnabledTopSurface());
903 }
904 
905 /**
906  * @tc.name: DrawSelfDrawingNodeBuffer
907  * @tc.desc: Test DrawSelfDrawingNodeBuffer
908  * @tc.type: FUNC
909  * @tc.require: issueIAEDYI
910  */
911 HWTEST_F(RSSurfaceRenderNodeDrawableTest, DrawSelfDrawingNodeBufferTest, TestSize.Level1)
912 {
913     ASSERT_NE(surfaceDrawable_, nullptr);
914     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
915     ASSERT_NE(surfaceParams, nullptr);
916     const auto params01 = surfaceParams;
917     BufferDrawParam params;
918     RSUniRenderThread::Instance().uniRenderEngine_ = std::make_shared<RSUniRenderEngine>();
919     surfaceDrawable_->DrawSelfDrawingNodeBuffer(*canvas_, *params01, params);
920     ASSERT_TRUE(surfaceParams->GetSelfDrawingNodeType() != SelfDrawingNodeType::VIDEO);
921 
922     Color color(255, 255, 255, 255); // for test
923     surfaceParams->backgroundColor_ = color;
924     const auto params02 = surfaceParams;
925     surfaceDrawable_->DrawSelfDrawingNodeBuffer(*canvas_, *params02, params);
926     ASSERT_TRUE(surfaceParams->GetSelfDrawingNodeType() != SelfDrawingNodeType::VIDEO);
927     ASSERT_FALSE(surfaceDrawable_->HasCornerRadius(*params02));
928 
929     surfaceParams->rrect_.radius_[0].x_ = 0.f;
930     surfaceParams->rrect_.radius_[0].y_ = 4.f;
931     const auto params03 = surfaceParams;
932     surfaceDrawable_->DrawSelfDrawingNodeBuffer(*canvas_, *params03, params);
933     ASSERT_TRUE(surfaceDrawable_->HasCornerRadius(*params03));
934 }
935 
936 /**
937  * @tc.name: HasCornerRadius
938  * @tc.desc: Test HasCornerRadius
939  * @tc.type: FUNC
940  * @tc.require: issueIAEDYI
941  */
942 HWTEST_F(RSSurfaceRenderNodeDrawableTest, HasCornerRadiusTest, TestSize.Level1)
943 {
944     ASSERT_NE(surfaceDrawable_, nullptr);
945     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
946     ASSERT_NE(surfaceParams, nullptr);
947     const auto params01 = surfaceParams;
948     ASSERT_FALSE(surfaceDrawable_->HasCornerRadius(*params01));
949 
950     surfaceParams->rrect_.radius_[0].y_ = 4.f;
951     const auto params02 = surfaceParams;
952     ASSERT_TRUE(surfaceDrawable_->HasCornerRadius(*params02));
953 
954     surfaceParams->rrect_.radius_[0].x_ = 0.f;
955     const auto params03 = surfaceParams;
956     ASSERT_TRUE(surfaceDrawable_->HasCornerRadius(*params03));
957 }
958 
959 /**
960  * @tc.name: DealWithUIFirstCache
961  * @tc.desc: Test DealWithUIFirstCache
962  * @tc.type: FUNC
963  * @tc.require: issueIAEDYI
964  */
965 HWTEST_F(RSSurfaceRenderNodeDrawableTest, DealWithUIFirstCacheTest, TestSize.Level1)
966 {
967     ASSERT_NE(surfaceDrawable_, nullptr);
968     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
969     ASSERT_NE(surfaceParams, nullptr);
970     auto uniParams = std::make_shared<RSRenderThreadParams>();
971     ASSERT_FALSE(surfaceDrawable_->DealWithUIFirstCache(*canvas_, *surfaceParams, *uniParams));
972 
973     surfaceParams->uiFirstFlag_ = MultiThreadCacheType::ARKTS_CARD;
974     ASSERT_TRUE(surfaceDrawable_->DealWithUIFirstCache(*canvas_, *surfaceParams, *uniParams));
975 
976     RSUniRenderThread::GetCaptureParam().isSnapshot_ = false;
977     uniParams->isUIFirstDebugEnable_ = true;
978     ASSERT_TRUE(surfaceDrawable_->DealWithUIFirstCache(*canvas_, *surfaceParams, *uniParams));
979 
980     surfaceParams->uifirstUseStarting_ = 1;
981     ASSERT_TRUE(surfaceDrawable_->DealWithUIFirstCache(*canvas_, *surfaceParams, *uniParams));
982 }
983 
984 /**
985  * @tc.name: OnGeneralProcess
986  * @tc.desc: Test OnGeneralProcess
987  * @tc.type: FUNC
988  * @tc.require: issueIAEDYI
989  */
990 HWTEST_F(RSSurfaceRenderNodeDrawableTest, OnGeneralProcessTest, TestSize.Level1)
991 {
992     auto& rtThread = RSUniRenderThread::Instance();
993     if (!rtThread.GetRSRenderThreadParams()) {
994         rtThread.Sync(std::make_unique<RSRenderThreadParams>());
995     }
996     if (!rtThread.uniRenderEngine_) {
997         rtThread.uniRenderEngine_ = std::make_shared<RSRenderEngine>();
998     }
999 
1000     ASSERT_NE(surfaceDrawable_, nullptr);
1001     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
1002     ASSERT_NE(surfaceParams, nullptr);
1003     Drawing::Canvas drawingCanvas;
1004     RSPaintFilterCanvas canvas(&drawingCanvas);
1005     surfaceDrawable_->OnGeneralProcess(canvas, *surfaceParams, false);
1006     EXPECT_FALSE(surfaceParams->GetBuffer());
1007     surfaceDrawable_->OnGeneralProcess(canvas, *surfaceParams, true);
1008 }
1009 
1010 /**
1011  * @tc.name: DealWithUIFirstCache001
1012  * @tc.desc: Test DealWithUIFirstCache while capture but don't has cache texture
1013  * @tc.type: FUNC
1014  * @tc.require: issueIAOTZ3
1015  */
1016 HWTEST_F(RSSurfaceRenderNodeDrawableTest, DealWithUIFirstCache002, TestSize.Level2)
1017 {
1018     ASSERT_NE(surfaceDrawable_, nullptr);
1019     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(surfaceDrawable_->renderParams_.get());
1020     ASSERT_NE(surfaceParams, nullptr);
1021     auto uniParams = std::make_shared<RSRenderThreadParams>();
1022 
1023     RSUniRenderThread::GetCaptureParam().isSnapshot_ = true;
1024     ASSERT_FALSE(surfaceDrawable_->DealWithUIFirstCache(*canvas_, *surfaceParams, *uniParams));
1025 }
1026 
1027 /**
1028  * @tc.name: CheckIfSurfaceSkipInMirror001
1029  * @tc.desc: Test CheckIfSurfaceSkipInMirror for main screen
1030  * @tc.type: FUNC
1031  * @tc.require: issueIAOTZ3
1032  */
1033 HWTEST_F(RSSurfaceRenderNodeDrawableTest, CheckIfSurfaceSkipInMirror001, TestSize.Level2)
1034 {
1035     ASSERT_NE(surfaceDrawable_, nullptr);
1036     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(surfaceDrawable_->renderParams_.get());
1037     ASSERT_NE(surfaceParams, nullptr);
1038     RSUniRenderThread::GetCaptureParam().isMirror_ = false;
1039     ASSERT_FALSE(surfaceDrawable_->CheckIfSurfaceSkipInMirror(*surfaceParams));
1040 }
1041 
1042 /**
1043  * @tc.name: CheckIfSurfaceSkipInMirror002
1044  * @tc.desc: Test CheckIfSurfaceSkipInMirror while don't has white list and black list
1045  * @tc.type: FUNC
1046  * @tc.require: issueIAOTZ3
1047  */
1048 HWTEST_F(RSSurfaceRenderNodeDrawableTest, CheckIfSurfaceSkipInMirror002, TestSize.Level2)
1049 {
1050     ASSERT_NE(surfaceDrawable_, nullptr);
1051     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(surfaceDrawable_->renderParams_.get());
1052     ASSERT_NE(surfaceParams, nullptr);
1053     RSUniRenderThread::GetCaptureParam().isMirror_ = true;
1054     ASSERT_FALSE(surfaceDrawable_->CheckIfSurfaceSkipInMirror(*surfaceParams));
1055 }
1056 
1057 /**
1058  * @tc.name: CheckIfSurfaceSkipInMirror003
1059  * @tc.desc: Test CheckIfSurfaceSkipInMirror for node in black list
1060  * @tc.type: FUNC
1061  * @tc.require: issueIAOTZ3
1062  */
1063 HWTEST_F(RSSurfaceRenderNodeDrawableTest, CheckIfSurfaceSkipInMirror003, TestSize.Level2)
1064 {
1065     ASSERT_NE(surfaceDrawable_, nullptr);
1066     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(surfaceDrawable_->renderParams_.get());
1067     ASSERT_NE(surfaceParams, nullptr);
1068     std::unordered_set<NodeId> blackList = {surfaceParams->GetId()};
1069     RSUniRenderThread::Instance().SetBlackList(blackList);
1070 
1071     RSUniRenderThread::GetCaptureParam().isMirror_ = true;
1072     ASSERT_TRUE(surfaceDrawable_->CheckIfSurfaceSkipInMirror(*surfaceParams));
1073 }
1074 
1075 /**
1076  * @tc.name: CheckIfSurfaceSkipInMirror004
1077  * @tc.desc: Test CheckIfSurfaceSkipInMirror while white list isn't empty and node not in white list
1078  * @tc.type: FUNC
1079  * @tc.require: issueIAOTZ3
1080  */
1081 HWTEST_F(RSSurfaceRenderNodeDrawableTest, CheckIfSurfaceSkipInMirror004, TestSize.Level2)
1082 {
1083     ASSERT_NE(surfaceDrawable_, nullptr);
1084     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(surfaceDrawable_->renderParams_.get());
1085     ASSERT_NE(surfaceParams, nullptr);
1086     auto uniParams = std::make_shared<RSRenderThreadParams>();
1087     std::unordered_set<NodeId> whiteList = {surfaceParams->GetId() + 1};
1088     RSUniRenderThread::Instance().SetWhiteList(whiteList);
1089 
1090     RSUniRenderThread::GetCaptureParam().isMirror_ = true;
1091     ASSERT_TRUE(surfaceDrawable_->CheckIfSurfaceSkipInMirror(*surfaceParams));
1092 }
1093 
1094 /**
1095  * @tc.name: SetVirtualScreenWhiteListRootId001
1096  * @tc.desc: Test SetVirtualScreenWhiteListRootId while node's id not in white list
1097  * @tc.type: FUNC
1098  * @tc.require: issueIAOTZ3
1099  */
1100 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetVirtualScreenWhiteListRootId001, TestSize.Level2)
1101 {
1102     ASSERT_NE(renderNode_, nullptr);
1103     std::unordered_set<NodeId> whiteList = {renderNode_->GetId() + 1};
1104 
1105     ASSERT_NE(surfaceDrawable_, nullptr);
1106     surfaceDrawable_->SetVirtualScreenWhiteListRootId(whiteList, renderNode_->GetId());
1107     ASSERT_EQ(RSUniRenderThread::GetCaptureParam().rootIdInWhiteList_, INVALID_NODEID);
1108 }
1109 
1110 /**
1111  * @tc.name: SetVirtualScreenWhiteListRootId002
1112  * @tc.desc: Test SetVirtualScreenWhiteListRootId while node's id in white list
1113  * @tc.type: FUNC
1114  * @tc.require: issueIAOTZ3
1115  */
1116 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetVirtualScreenWhiteListRootId002, TestSize.Level2)
1117 {
1118     ASSERT_NE(renderNode_, nullptr);
1119     std::unordered_set<NodeId> whiteList = {renderNode_->GetId()};
1120 
1121     ASSERT_NE(surfaceDrawable_, nullptr);
1122     surfaceDrawable_->SetVirtualScreenWhiteListRootId(whiteList, renderNode_->GetId());
1123     ASSERT_EQ(RSUniRenderThread::GetCaptureParam().rootIdInWhiteList_, renderNode_->GetId());
1124 }
1125 
1126 /**
1127  * @tc.name: SetVirtualScreenWhiteListRootId003
1128  * @tc.desc: Test SetVirtualScreenWhiteListRootId while rootIdInWhiteList has been set
1129  * @tc.type: FUNC
1130  * @tc.require: issueIAOTZ3
1131  */
1132 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetVirtualScreenWhiteListRootId003, TestSize.Level2)
1133 {
1134     ASSERT_NE(renderNode_, nullptr);
1135     std::unordered_set<NodeId> whiteList = {renderNode_->GetId(), renderNode_->GetId() +1};
1136 
1137     ASSERT_NE(surfaceDrawable_, nullptr);
1138     surfaceDrawable_->SetVirtualScreenWhiteListRootId(whiteList, renderNode_->GetId());
1139     surfaceDrawable_->SetVirtualScreenWhiteListRootId(whiteList, renderNode_->GetId() + 1);
1140     ASSERT_EQ(RSUniRenderThread::GetCaptureParam().rootIdInWhiteList_, renderNode_->GetId());
1141 }
1142 
1143 /**
1144  * @tc.name: ResetVirtualScreenWhiteListRootId001
1145  * @tc.desc: Test ResetVirtualScreenWhiteListRootId while id equals rootIdInWhiteList_
1146  * @tc.type: FUNC
1147  * @tc.require: issueIAOTZ3
1148  */
1149 HWTEST_F(RSSurfaceRenderNodeDrawableTest, ResetVirtualScreenWhiteListRootId001, TestSize.Level2)
1150 {
1151     ASSERT_NE(renderNode_, nullptr);
1152     std::unordered_set<NodeId> whiteList = {renderNode_->GetId()};
1153 
1154     ASSERT_NE(surfaceDrawable_, nullptr);
1155     surfaceDrawable_->SetVirtualScreenWhiteListRootId(whiteList, renderNode_->GetId());
1156     surfaceDrawable_->ResetVirtualScreenWhiteListRootId(renderNode_->GetId());
1157     ASSERT_EQ(RSUniRenderThread::GetCaptureParam().rootIdInWhiteList_, INVALID_NODEID);
1158 }
1159 
1160 /**
1161  * @tc.name: SetSubThreadSkip001
1162  * @tc.desc: Test SetSubThreadSkip
1163  * @tc.type: FUNC
1164  * @tc.require: issueIAOTZ3
1165  */
1166 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetSubThreadSkip001, TestSize.Level2)
1167 {
1168     ASSERT_NE(surfaceDrawable_, nullptr);
1169 
1170     surfaceDrawable_->SetSubThreadSkip(true);
1171     ASSERT_TRUE(surfaceDrawable_->IsSubThreadSkip());
1172 }
1173 
1174 /**
1175  * @tc.name: SetAndGet
1176  * @tc.desc: Test SetAndGet
1177  * @tc.type: FUNC
1178  * @tc.require: issueIAEDYI
1179  */
1180 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetAndGetTest001, TestSize.Level1)
1181 {
1182     ASSERT_NE(surfaceDrawable_, nullptr);
1183     Occlusion::Region region = surfaceDrawable_->GetVisibleDirtyRegion();
1184     EXPECT_TRUE(region.IsEmpty());
1185     Occlusion::Region OccRegion;
1186     surfaceDrawable_->SetVisibleDirtyRegion(OccRegion);
1187     surfaceDrawable_->SetAlignedVisibleDirtyRegion(OccRegion);
1188     Occlusion::Region rect;
1189     surfaceDrawable_->SetGlobalDirtyRegion(rect);
1190     surfaceDrawable_->SetDirtyRegionAlignedEnable(true);
1191     surfaceDrawable_->SetDirtyRegionBelowCurrentLayer(OccRegion);
1192     surfaceDrawable_->GetSyncDirtyManager();
1193 }
1194 
1195 /**
1196  * @tc.name: SetAndGet
1197  * @tc.desc: Test SetAndGet
1198  * @tc.type: FUNC
1199  * @tc.require: issueIAEDYI
1200  */
1201 HWTEST_F(RSSurfaceRenderNodeDrawableTest, SetAndGetTest002, TestSize.Level1)
1202 {
1203     ASSERT_NE(surfaceDrawable_, nullptr);
1204     surfaceDrawable_->renderParams_ = std::make_unique<RSRenderParams>(0);
1205     Occlusion::Region OccRegion;
1206     surfaceDrawable_->SetVisibleDirtyRegion(OccRegion);
1207     Occlusion::Region region = surfaceDrawable_->GetVisibleDirtyRegion();
1208     EXPECT_TRUE(region.IsEmpty());
1209 
1210     surfaceDrawable_->SetAlignedVisibleDirtyRegion(OccRegion);
1211     Occlusion::Region rect;
1212     surfaceDrawable_->SetGlobalDirtyRegion(rect);
1213     surfaceDrawable_->SetDirtyRegionAlignedEnable(true);
1214     surfaceDrawable_->SetDirtyRegionBelowCurrentLayer(OccRegion);
1215     ASSERT_NE(surfaceDrawable_->GetSyncDirtyManager(), nullptr);
1216 }
1217 
1218 /**
1219  * @tc.name: DealWithSelfDrawingNodeBuffer
1220  * @tc.desc: Test DealWithSelfDrawingNodeBuffer
1221  * @tc.type: FUNC
1222  * @tc.require: issueIAOTZ3
1223  */
1224 HWTEST_F(RSSurfaceRenderNodeDrawableTest, DealWithSelfDrawingNodeBufferTest001, TestSize.Level1)
1225 {
1226     ASSERT_NE(surfaceDrawable_, nullptr);
1227     auto surfaceParams = static_cast<RSSurfaceRenderParams*>(drawable_->renderParams_.get());
1228     ASSERT_NE(surfaceParams, nullptr);
1229     Drawing::Canvas drawingCanvas;
1230     RSPaintFilterCanvas canvas(&drawingCanvas);
1231     surfaceParams->isInFixedRotation_ = false;
1232     surfaceDrawable_->DealWithSelfDrawingNodeBuffer(canvas, *surfaceParams);
1233     ASSERT_FALSE(surfaceParams->GetHardwareEnabled());
1234     ASSERT_FALSE(surfaceParams->IsInFixedRotation());
1235 
1236     surfaceParams->isInFixedRotation_ = true;
1237     surfaceDrawable_->DealWithSelfDrawingNodeBuffer(canvas, *surfaceParams);
1238     surfaceParams->isHardwareEnabled_ = true;
1239     surfaceDrawable_->name_ = "test";
1240     surfaceDrawable_->surfaceNodeType_ = RSSurfaceNodeType::DEFAULT;
1241     surfaceDrawable_->DealWithSelfDrawingNodeBuffer(canvas, *surfaceParams);
1242     ASSERT_TRUE(surfaceParams->GetHardwareEnabled());
1243 
1244     surfaceParams->isHardCursor_ = true;
1245     surfaceDrawable_->DealWithSelfDrawingNodeBuffer(canvas, *surfaceParams);
1246     ASSERT_TRUE(surfaceParams->GetHardCursorStatus());
1247     ASSERT_FALSE(surfaceDrawable_->IsHardwareEnabledTopSurface());
1248 
1249     surfaceDrawable_->DealWithSelfDrawingNodeBuffer(canvas, *surfaceParams);
1250     surfaceDrawable_->surfaceNodeType_ = RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
1251     surfaceDrawable_->name_ = "pointer window";
1252     surfaceDrawable_->DealWithSelfDrawingNodeBuffer(canvas, *surfaceParams);
1253 }
1254 }
1255