1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "gtest/gtest.h"
17 
18 #include "recording/recording_canvas.h"
19 #include "draw/path.h"
20 
21 using namespace testing;
22 using namespace testing::ext;
23 
24 namespace OHOS {
25 namespace Rosen {
26 namespace Drawing {
27 const int CANAS_WIDTH = 10;
28 const int CANAS_HEIGHT = 20;
29 const float RADIUS = 1.0f;
30 const float ANGLE = 90.f;
31 class RecordingCanvasTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp() override;
36     void TearDown() override;
37 };
38 
SetUpTestCase()39 void RecordingCanvasTest::SetUpTestCase() {}
TearDownTestCase()40 void RecordingCanvasTest::TearDownTestCase() {}
SetUp()41 void RecordingCanvasTest::SetUp() {}
TearDown()42 void RecordingCanvasTest::TearDown() {}
43 
44 /**
45  * @tc.name: DrawPoint001
46  * @tc.desc: Test the playback of the DrawPoint function.
47  * @tc.type: FUNC
48  * @tc.require: I7K0BS
49  */
50 HWTEST_F(RecordingCanvasTest, DrawPoint001, TestSize.Level1)
51 {
52     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
53     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
54     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
55 
56     Point point(CANAS_WIDTH, CANAS_HEIGHT);
57     recordingCanvas1->DrawPoint(point);
58     recordingCanvas2->DrawPoint(point);
59 
60     Brush brush(Color::COLOR_GREEN);
61     recordingCanvas1->AttachBrush(brush);
62     recordingCanvas2->AttachBrush(brush);
63     recordingCanvas1->DrawPoint(point);
64     recordingCanvas2->DrawPoint(point);
65 
66     Pen pen(Color::COLOR_GREEN);
67     recordingCanvas1->AttachPen(pen);
68     recordingCanvas2->AttachPen(pen);
69     recordingCanvas1->DrawPoint(point);
70     recordingCanvas2->DrawPoint(point);
71 
72     recordingCanvas1->DetachBrush();
73     recordingCanvas2->DetachBrush();
74     recordingCanvas1->DrawPoint(point);
75     recordingCanvas2->DrawPoint(point);
76 
77     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
78     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
79     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
80     Canvas canvas;
81     drawCmdList1->Playback(canvas);
82     drawCmdList2->Playback(canvas);
83 }
84 
85 /**
86  * @tc.name: DrawPoints001
87  * @tc.desc: Test the playback of the DrawPoints function.
88  * @tc.type: FUNC
89  * @tc.require: I7K0BS
90  */
91 HWTEST_F(RecordingCanvasTest, DrawPoints001, TestSize.Level1)
92 {
93     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
94     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
95     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
96 
97     std::vector<Point> points = {{CANAS_WIDTH, CANAS_WIDTH}, {CANAS_HEIGHT, CANAS_HEIGHT}};
98     recordingCanvas1->DrawPoints(PointMode::LINES_POINTMODE, points.size(), points.data());
99     recordingCanvas2->DrawPoints(PointMode::LINES_POINTMODE, points.size(), points.data());
100 
101     Brush brush(Color::COLOR_GREEN);
102     recordingCanvas1->AttachBrush(brush);
103     recordingCanvas2->AttachBrush(brush);
104     recordingCanvas1->DrawPoints(PointMode::LINES_POINTMODE, points.size(), points.data());
105     recordingCanvas2->DrawPoints(PointMode::LINES_POINTMODE, points.size(), points.data());
106 
107     Pen pen(Color::COLOR_GREEN);
108     recordingCanvas1->AttachPen(pen);
109     recordingCanvas2->AttachPen(pen);
110     recordingCanvas1->DrawPoints(PointMode::LINES_POINTMODE, points.size(), points.data());
111     recordingCanvas2->DrawPoints(PointMode::LINES_POINTMODE, points.size(), points.data());
112 
113     recordingCanvas1->DetachBrush();
114     recordingCanvas2->DetachBrush();
115     recordingCanvas1->DrawPoints(PointMode::LINES_POINTMODE, points.size(), points.data());
116     recordingCanvas2->DrawPoints(PointMode::LINES_POINTMODE, points.size(), points.data());
117 
118     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
119     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
120     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
121     Canvas canvas;
122     drawCmdList1->Playback(canvas);
123     drawCmdList2->Playback(canvas);
124 }
125 
126 /**
127  * @tc.name: DrawLine001
128  * @tc.desc: Test the playback of the DrawLine function.
129  * @tc.type: FUNC
130  * @tc.require: I7K0BS
131  */
132 HWTEST_F(RecordingCanvasTest, DrawLine001, TestSize.Level1)
133 {
134     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
135     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
136     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
137 
138     Point startPoint(CANAS_WIDTH, CANAS_WIDTH);
139     Point endPoint(CANAS_HEIGHT, CANAS_HEIGHT);
140     recordingCanvas1->DrawLine(startPoint, endPoint);
141     recordingCanvas2->DrawLine(startPoint, endPoint);
142 
143     Brush brush(Color::COLOR_GREEN);
144     recordingCanvas1->AttachBrush(brush);
145     recordingCanvas2->AttachBrush(brush);
146     recordingCanvas1->DrawLine(startPoint, endPoint);
147     recordingCanvas2->DrawLine(startPoint, endPoint);
148 
149     Pen pen(Color::COLOR_GREEN);
150     recordingCanvas1->AttachPen(pen);
151     recordingCanvas2->AttachPen(pen);
152     recordingCanvas1->DrawLine(startPoint, endPoint);
153     recordingCanvas2->DrawLine(startPoint, endPoint);
154 
155     recordingCanvas1->DetachBrush();
156     recordingCanvas2->DetachBrush();
157     recordingCanvas1->DrawLine(startPoint, endPoint);
158     recordingCanvas2->DrawLine(startPoint, endPoint);
159 
160     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
161     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
162     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
163     Canvas canvas;
164     drawCmdList1->Playback(canvas);
165     drawCmdList2->Playback(canvas);
166 }
167 
168 /**
169  * @tc.name: DrawRect001
170  * @tc.desc: Test the playback of the DrawRect function.
171  * @tc.type: FUNC
172  * @tc.require: I7K0BS
173  */
174 HWTEST_F(RecordingCanvasTest, DrawRect001, TestSize.Level1)
175 {
176     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
177     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
178     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
179 
180     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
181     recordingCanvas1->DrawRect(rect);
182     recordingCanvas2->DrawRect(rect);
183 
184     Brush brush(Color::COLOR_GREEN);
185     recordingCanvas1->AttachBrush(brush);
186     recordingCanvas2->AttachBrush(brush);
187     recordingCanvas1->DrawRect(rect);
188     recordingCanvas2->DrawRect(rect);
189 
190     Pen pen(Color::COLOR_GREEN);
191     recordingCanvas1->AttachPen(pen);
192     recordingCanvas2->AttachPen(pen);
193     recordingCanvas1->DrawRect(rect);
194     recordingCanvas2->DrawRect(rect);
195 
196     recordingCanvas1->DetachBrush();
197     recordingCanvas2->DetachBrush();
198     recordingCanvas1->DrawRect(rect);
199     recordingCanvas2->DrawRect(rect);
200 
201     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
202     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
203     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
204     Canvas canvas;
205     drawCmdList1->Playback(canvas);
206     drawCmdList2->Playback(canvas);
207 }
208 
209 /**
210  * @tc.name: DrawRoundRect001
211  * @tc.desc: Test the playback of the DrawRoundRect function.
212  * @tc.type: FUNC
213  * @tc.require: I7K0BS
214  */
215 HWTEST_F(RecordingCanvasTest, DrawRoundRect001, TestSize.Level1)
216 {
217     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
218     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
219     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
220     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
221     RoundRect roundRect(rect, RADIUS, RADIUS);
222     recordingCanvas1->DrawRoundRect(roundRect);
223     recordingCanvas2->DrawRoundRect(roundRect);
224 
225     Brush brush(Color::COLOR_GREEN);
226     recordingCanvas1->AttachBrush(brush);
227     recordingCanvas2->AttachBrush(brush);
228     recordingCanvas1->DrawRoundRect(roundRect);
229     recordingCanvas2->DrawRoundRect(roundRect);
230 
231     Pen pen(Color::COLOR_GREEN);
232     recordingCanvas1->AttachPen(pen);
233     recordingCanvas2->AttachPen(pen);
234     recordingCanvas1->DrawRoundRect(roundRect);
235     recordingCanvas2->DrawRoundRect(roundRect);
236 
237     recordingCanvas1->DetachBrush();
238     recordingCanvas2->DetachBrush();
239     recordingCanvas1->DrawRoundRect(roundRect);
240     recordingCanvas2->DrawRoundRect(roundRect);
241 
242     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
243     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
244     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
245     Canvas canvas;
246     drawCmdList1->Playback(canvas);
247     drawCmdList2->Playback(canvas);
248 }
249 
250 /**
251  * @tc.name: DrawNestedRoundRect001
252  * @tc.desc: Test the playback of the DrawNestedRoundRect function.
253  * @tc.type: FUNC
254  * @tc.require: I7K0BS
255  */
256 HWTEST_F(RecordingCanvasTest, DrawNestedRoundRect001, TestSize.Level1)
257 {
258     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
259     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
260     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
261     Rect rect1(0.0f, 0.0f, CANAS_HEIGHT, CANAS_HEIGHT);
262     RoundRect roundRect1(rect1, RADIUS, RADIUS);
263     Rect rect2(0.0f, 0.0f, CANAS_WIDTH, CANAS_WIDTH);
264     RoundRect roundRect2(rect2, RADIUS, RADIUS);
265     recordingCanvas1->DrawNestedRoundRect(roundRect1, roundRect2);
266     recordingCanvas2->DrawNestedRoundRect(roundRect1, roundRect2);
267 
268     Brush brush(Color::COLOR_GREEN);
269     recordingCanvas1->AttachBrush(brush);
270     recordingCanvas2->AttachBrush(brush);
271     recordingCanvas1->DrawNestedRoundRect(roundRect1, roundRect2);
272     recordingCanvas2->DrawNestedRoundRect(roundRect1, roundRect2);
273 
274     Pen pen(Color::COLOR_GREEN);
275     recordingCanvas1->AttachPen(pen);
276     recordingCanvas2->AttachPen(pen);
277     recordingCanvas1->DrawNestedRoundRect(roundRect1, roundRect2);
278     recordingCanvas2->DrawNestedRoundRect(roundRect1, roundRect2);
279 
280     recordingCanvas1->DetachBrush();
281     recordingCanvas2->DetachBrush();
282     recordingCanvas1->DrawNestedRoundRect(roundRect1, roundRect2);
283     recordingCanvas2->DrawNestedRoundRect(roundRect1, roundRect2);
284 
285     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
286     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
287     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
288     Canvas canvas;
289     drawCmdList1->Playback(canvas);
290     drawCmdList2->Playback(canvas);
291 }
292 
293 /**
294  * @tc.name: DrawArc001
295  * @tc.desc: Test the playback of the DrawArc function.
296  * @tc.type: FUNC
297  * @tc.require: I7K0BS
298  */
299 HWTEST_F(RecordingCanvasTest, DrawArc001, TestSize.Level1)
300 {
301     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
302     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
303     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
304     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
305     recordingCanvas1->DrawArc(rect, 0.0f, ANGLE);
306     recordingCanvas2->DrawArc(rect, 0.0f, ANGLE);
307 
308     Brush brush(Color::COLOR_GREEN);
309     recordingCanvas1->AttachBrush(brush);
310     recordingCanvas2->AttachBrush(brush);
311     recordingCanvas1->DrawArc(rect, 0.0f, ANGLE);
312     recordingCanvas2->DrawArc(rect, 0.0f, ANGLE);
313 
314     Pen pen(Color::COLOR_GREEN);
315     recordingCanvas1->AttachPen(pen);
316     recordingCanvas2->AttachPen(pen);
317     recordingCanvas1->DrawArc(rect, 0.0f, ANGLE);
318     recordingCanvas2->DrawArc(rect, 0.0f, ANGLE);
319 
320     recordingCanvas1->DetachBrush();
321     recordingCanvas2->DetachBrush();
322     recordingCanvas1->DrawArc(rect, 0.0f, ANGLE);
323     recordingCanvas2->DrawArc(rect, 0.0f, ANGLE);
324 
325     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
326     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
327     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
328     Canvas canvas;
329     drawCmdList1->Playback(canvas);
330     drawCmdList2->Playback(canvas);
331 }
332 
333 /**
334  * @tc.name: DrawPie001
335  * @tc.desc: Test the playback of the DrawPie function.
336  * @tc.type: FUNC
337  * @tc.require: I7K0BS
338  */
339 HWTEST_F(RecordingCanvasTest, DrawPie001, TestSize.Level1)
340 {
341     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
342     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
343     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
344     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
345     recordingCanvas1->DrawPie(rect, 0.0f, ANGLE);
346     recordingCanvas2->DrawPie(rect, 0.0f, ANGLE);
347 
348     Brush brush(Color::COLOR_GREEN);
349     recordingCanvas1->AttachBrush(brush);
350     recordingCanvas2->AttachBrush(brush);
351     recordingCanvas1->DrawPie(rect, 0.0f, ANGLE);
352     recordingCanvas2->DrawPie(rect, 0.0f, ANGLE);
353 
354     Pen pen(Color::COLOR_GREEN);
355     recordingCanvas1->AttachPen(pen);
356     recordingCanvas2->AttachPen(pen);
357     recordingCanvas1->DrawPie(rect, 0.0f, ANGLE);
358     recordingCanvas2->DrawPie(rect, 0.0f, ANGLE);
359 
360     recordingCanvas1->DetachBrush();
361     recordingCanvas2->DetachBrush();
362     recordingCanvas1->DrawPie(rect, 0.0f, ANGLE);
363     recordingCanvas2->DrawPie(rect, 0.0f, ANGLE);
364 
365     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
366     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
367     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
368     Canvas canvas;
369     drawCmdList1->Playback(canvas);
370     drawCmdList2->Playback(canvas);
371 }
372 
373 /**
374  * @tc.name: DrawOval001
375  * @tc.desc: Test the playback of the DrawOval function.
376  * @tc.type: FUNC
377  * @tc.require: I7K0BS
378  */
379 HWTEST_F(RecordingCanvasTest, DrawOval001, TestSize.Level1)
380 {
381     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
382     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
383     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
384     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
385     recordingCanvas1->DrawOval(rect);
386     recordingCanvas2->DrawOval(rect);
387 
388     Brush brush(Color::COLOR_GREEN);
389     recordingCanvas1->AttachBrush(brush);
390     recordingCanvas2->AttachBrush(brush);
391     recordingCanvas1->DrawOval(rect);
392     recordingCanvas2->DrawOval(rect);
393 
394     Pen pen(Color::COLOR_GREEN);
395     recordingCanvas1->AttachPen(pen);
396     recordingCanvas2->AttachPen(pen);
397     recordingCanvas1->DrawOval(rect);
398     recordingCanvas2->DrawOval(rect);
399 
400     recordingCanvas1->DetachBrush();
401     recordingCanvas2->DetachBrush();
402     recordingCanvas1->DrawOval(rect);
403     recordingCanvas2->DrawOval(rect);
404 
405     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
406     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
407     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
408     Canvas canvas;
409     drawCmdList1->Playback(canvas);
410     drawCmdList2->Playback(canvas);
411 }
412 
413 /**
414  * @tc.name: DrawCircle001
415  * @tc.desc: Test the playback of the DrawCircle function.
416  * @tc.type: FUNC
417  * @tc.require: I7K0BS
418  */
419 HWTEST_F(RecordingCanvasTest, DrawCircle001, TestSize.Level1)
420 {
421     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
422     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
423     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
424     Point centerpoint(CANAS_WIDTH, CANAS_HEIGHT);
425     recordingCanvas1->DrawCircle(centerpoint, CANAS_WIDTH);
426     recordingCanvas2->DrawCircle(centerpoint, CANAS_WIDTH);
427 
428     Brush brush(Color::COLOR_GREEN);
429     recordingCanvas1->AttachBrush(brush);
430     recordingCanvas2->AttachBrush(brush);
431     recordingCanvas1->DrawCircle(centerpoint, CANAS_WIDTH);
432     recordingCanvas2->DrawCircle(centerpoint, CANAS_WIDTH);
433 
434     Pen pen(Color::COLOR_GREEN);
435     recordingCanvas1->AttachPen(pen);
436     recordingCanvas2->AttachPen(pen);
437     recordingCanvas1->DrawCircle(centerpoint, CANAS_WIDTH);
438     recordingCanvas2->DrawCircle(centerpoint, CANAS_WIDTH);
439 
440     recordingCanvas1->DetachBrush();
441     recordingCanvas2->DetachBrush();
442     recordingCanvas1->DrawCircle(centerpoint, CANAS_WIDTH);
443     recordingCanvas2->DrawCircle(centerpoint, CANAS_WIDTH);
444 
445     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
446     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
447     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
448     Canvas canvas;
449     drawCmdList1->Playback(canvas);
450     drawCmdList2->Playback(canvas);
451 }
452 
453 /**
454  * @tc.name: DrawPath001
455  * @tc.desc: Test the playback of the DrawPath function.
456  * @tc.type: FUNC
457  * @tc.require: I7K0BS
458  */
459 HWTEST_F(RecordingCanvasTest, DrawPath001, TestSize.Level1)
460 {
461     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
462     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
463     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
464     Path path;
465     path.AddRect(Rect(0, 0, CANAS_WIDTH, CANAS_HEIGHT));
466     recordingCanvas1->DrawPath(path);
467     recordingCanvas2->DrawPath(path);
468 
469     Brush brush(Color::COLOR_GREEN);
470     recordingCanvas1->AttachBrush(brush);
471     recordingCanvas2->AttachBrush(brush);
472     recordingCanvas1->DrawPath(path);
473     recordingCanvas2->DrawPath(path);
474 
475     Pen pen(Color::COLOR_GREEN);
476     recordingCanvas1->AttachPen(pen);
477     recordingCanvas2->AttachPen(pen);
478     recordingCanvas1->DrawPath(path);
479     recordingCanvas2->DrawPath(path);
480 
481     recordingCanvas1->DetachBrush();
482     recordingCanvas2->DetachBrush();
483     recordingCanvas1->DrawPath(path);
484     recordingCanvas2->DrawPath(path);
485 
486     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
487     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
488     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
489     Canvas canvas;
490     drawCmdList1->Playback(canvas);
491     drawCmdList2->Playback(canvas);
492 }
493 
494 /**
495  * @tc.name: DrawBackground001
496  * @tc.desc: Test the playback of the DrawBackground function.
497  * @tc.type: FUNC
498  * @tc.require: I7K0BS
499  */
500 HWTEST_F(RecordingCanvasTest, DrawBackground001, TestSize.Level1)
501 {
502     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
503     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
504     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
505     Brush brush(Color::COLOR_RED);
506     recordingCanvas1->DrawBackground(brush);
507     recordingCanvas2->DrawBackground(brush);
508     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
509     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
510     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
511     Canvas canvas;
512     drawCmdList1->Playback(canvas);
513     drawCmdList2->Playback(canvas);
514 }
515 
516 /**
517  * @tc.name: DrawShadow001
518  * @tc.desc: Test the playback of the DrawShadow function.
519  * @tc.type: FUNC
520  * @tc.require: I7K0BS
521  */
522 HWTEST_F(RecordingCanvasTest, DrawShadow001, TestSize.Level1)
523 {
524     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
525     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
526     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
527     Path path;
528     Point3 planeParams(1.0f, 0.0f, 0.0f);
529     Point3 devLightPos(1.0f, 1.0f, 1.0f);
530     recordingCanvas1->DrawShadow(
531         path, planeParams, devLightPos, 1.0f, Color::COLOR_BLACK, Color::COLOR_BLUE, ShadowFlags::NONE);
532     recordingCanvas2->DrawShadow(
533         path, planeParams, devLightPos, 1.0f, Color::COLOR_BLACK, Color::COLOR_BLUE, ShadowFlags::NONE);
534     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
535     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
536     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
537     Canvas canvas;
538     drawCmdList1->Playback(canvas);
539     drawCmdList2->Playback(canvas);
540 }
541 
542 /**
543  * @tc.name: DrawShadowStyle001
544  * @tc.desc: Test the playback of the DrawShadowStyle function.
545  * @tc.type: FUNC
546  * @tc.require: I7K0BS
547  */
548 HWTEST_F(RecordingCanvasTest, DrawShadowStyle001, TestSize.Level1)
549 {
550     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
551     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
552     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
553     Path path;
554     Point3 planeParams(1.0f, 0.0f, 0.0f);
555     Point3 devLightPos(1.0f, 1.0f, 1.0f);
556     recordingCanvas1->DrawShadowStyle(
557         path, planeParams, devLightPos, 1.0f, Color::COLOR_BLACK, Color::COLOR_BLUE, ShadowFlags::NONE, true);
558     recordingCanvas2->DrawShadowStyle(
559         path, planeParams, devLightPos, 1.0f, Color::COLOR_BLACK, Color::COLOR_BLUE, ShadowFlags::NONE, true);
560     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
561     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
562     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
563     Canvas canvas;
564     drawCmdList1->Playback(canvas);
565     drawCmdList2->Playback(canvas);
566 }
567 
568 /**
569  * @tc.name: DrawRegion001
570  * @tc.desc: Test the playback of the DrawRegion function.
571  * @tc.type: FUNC
572  * @tc.require: I7K0BS
573  */
574 HWTEST_F(RecordingCanvasTest, DrawRegion001, TestSize.Level1)
575 {
576     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
577     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
578     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
579     Region region;
580     region.SetRect(RectI(0, 0, CANAS_WIDTH, CANAS_HEIGHT));
581     recordingCanvas1->DrawRegion(region);
582     recordingCanvas2->DrawRegion(region);
583 
584     Brush brush(Color::COLOR_GREEN);
585     recordingCanvas1->AttachBrush(brush);
586     recordingCanvas2->AttachBrush(brush);
587     recordingCanvas1->DrawRegion(region);
588     recordingCanvas2->DrawRegion(region);
589 
590     Pen pen(Color::COLOR_GREEN);
591     recordingCanvas1->AttachPen(pen);
592     recordingCanvas2->AttachPen(pen);
593     recordingCanvas1->DrawRegion(region);
594     recordingCanvas2->DrawRegion(region);
595 
596     recordingCanvas1->DetachBrush();
597     recordingCanvas2->DetachBrush();
598     recordingCanvas1->DrawRegion(region);
599     recordingCanvas2->DrawRegion(region);
600 
601     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
602     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
603     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
604     Canvas canvas;
605     drawCmdList1->Playback(canvas);
606     drawCmdList2->Playback(canvas);
607 }
608 
609 /**
610  * @tc.name: DrawColor001
611  * @tc.desc: Test the playback of the DrawColor function.
612  * @tc.type: FUNC
613  * @tc.require: I7K0BS
614  */
615 HWTEST_F(RecordingCanvasTest, DrawColor001, TestSize.Level1)
616 {
617     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
618     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
619     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
620     recordingCanvas1->DrawColor(Color::COLOR_RED);
621     recordingCanvas2->DrawColor(Color::COLOR_RED);
622     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
623     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
624     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
625     Canvas canvas;
626     drawCmdList1->Playback(canvas);
627     drawCmdList2->Playback(canvas);
628 }
629 
630 /**
631  * @tc.name: DrawBitmap001
632  * @tc.desc: Test the playback of the DrawBitmap function.
633  * @tc.type: FUNC
634  * @tc.require: I7K0BS
635  */
636 HWTEST_F(RecordingCanvasTest, DrawBitmap001, TestSize.Level1)
637 {
638     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
639     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
640     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
641     Bitmap bitmap;
642     BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
643     bitmap.Build(CANAS_WIDTH, CANAS_WIDTH, bitmapFormat);
644     recordingCanvas1->DrawBitmap(bitmap, CANAS_WIDTH, CANAS_WIDTH);
645     recordingCanvas2->DrawBitmap(bitmap, CANAS_WIDTH, CANAS_WIDTH);
646 
647     Brush brush(Color::COLOR_GREEN);
648     recordingCanvas1->AttachBrush(brush);
649     recordingCanvas2->AttachBrush(brush);
650     recordingCanvas1->DrawBitmap(bitmap, CANAS_WIDTH, CANAS_WIDTH);
651     recordingCanvas2->DrawBitmap(bitmap, CANAS_WIDTH, CANAS_WIDTH);
652 
653     Pen pen(Color::COLOR_GREEN);
654     recordingCanvas1->AttachPen(pen);
655     recordingCanvas2->AttachPen(pen);
656     recordingCanvas1->DrawBitmap(bitmap, CANAS_WIDTH, CANAS_WIDTH);
657     recordingCanvas2->DrawBitmap(bitmap, CANAS_WIDTH, CANAS_WIDTH);
658 
659     recordingCanvas1->DetachBrush();
660     recordingCanvas2->DetachBrush();
661     recordingCanvas1->DrawBitmap(bitmap, CANAS_WIDTH, CANAS_WIDTH);
662     recordingCanvas2->DrawBitmap(bitmap, CANAS_WIDTH, CANAS_WIDTH);
663 
664     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
665     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
666     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
667     Canvas canvas;
668     drawCmdList1->Playback(canvas);
669     drawCmdList2->Playback(canvas);
670 }
671 
672 /**
673  * @tc.name: DrawImage001
674  * @tc.desc: Test the playback of the DrawImage function.
675  * @tc.type: FUNC
676  * @tc.require: I7K0BS
677  */
678 HWTEST_F(RecordingCanvasTest, DrawImage001, TestSize.Level1)
679 {
680     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
681     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
682     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
683     Bitmap bitmap;
684     BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
685     bitmap.Build(CANAS_HEIGHT, CANAS_HEIGHT, bitmapFormat);
686     Image image;
687     image.BuildFromBitmap(bitmap);
688     SamplingOptions samplingOptions;
689     recordingCanvas1->DrawImage(image, CANAS_WIDTH, CANAS_WIDTH, samplingOptions);
690     recordingCanvas2->DrawImage(image, CANAS_WIDTH, CANAS_WIDTH, samplingOptions);
691 
692     Brush brush(Color::COLOR_GREEN);
693     recordingCanvas1->AttachBrush(brush);
694     recordingCanvas2->AttachBrush(brush);
695     recordingCanvas1->DrawImage(image, CANAS_WIDTH, CANAS_WIDTH, samplingOptions);
696     recordingCanvas2->DrawImage(image, CANAS_WIDTH, CANAS_WIDTH, samplingOptions);
697 
698     Pen pen(Color::COLOR_GREEN);
699     recordingCanvas1->AttachPen(pen);
700     recordingCanvas2->AttachPen(pen);
701     recordingCanvas1->DrawImage(image, CANAS_WIDTH, CANAS_WIDTH, samplingOptions);
702     recordingCanvas2->DrawImage(image, CANAS_WIDTH, CANAS_WIDTH, samplingOptions);
703 
704     recordingCanvas1->DetachBrush();
705     recordingCanvas2->DetachBrush();
706     recordingCanvas1->DrawImage(image, CANAS_WIDTH, CANAS_WIDTH, samplingOptions);
707     recordingCanvas2->DrawImage(image, CANAS_WIDTH, CANAS_WIDTH, samplingOptions);
708 
709     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
710     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
711     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
712     Canvas canvas;
713     drawCmdList1->Playback(canvas);
714     drawCmdList2->Playback(canvas);
715 }
716 
717 /**
718  * @tc.name: DrawImageRect001
719  * @tc.desc: Test the playback of the DrawImageRect function.
720  * @tc.type: FUNC
721  * @tc.require: I7K0BS
722  */
723 HWTEST_F(RecordingCanvasTest, DrawImageRect001, TestSize.Level1)
724 {
725     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
726     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
727     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
728     Bitmap bitmap;
729     BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
730     bitmap.Build(CANAS_HEIGHT, CANAS_HEIGHT, bitmapFormat);
731     Image image;
732     image.BuildFromBitmap(bitmap);
733     Rect dstRect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
734     SamplingOptions samplingOptions;
735     recordingCanvas1->DrawImageRect(image, dstRect, samplingOptions);
736     recordingCanvas2->DrawImageRect(image, dstRect, samplingOptions);
737 
738     Brush brush(Color::COLOR_GREEN);
739     recordingCanvas1->AttachBrush(brush);
740     recordingCanvas2->AttachBrush(brush);
741     recordingCanvas1->DrawImageRect(image, dstRect, samplingOptions);
742     recordingCanvas2->DrawImageRect(image, dstRect, samplingOptions);
743 
744     Pen pen(Color::COLOR_GREEN);
745     recordingCanvas1->AttachPen(pen);
746     recordingCanvas2->AttachPen(pen);
747     recordingCanvas1->DrawImageRect(image, dstRect, samplingOptions);
748     recordingCanvas2->DrawImageRect(image, dstRect, samplingOptions);
749 
750     recordingCanvas1->DetachBrush();
751     recordingCanvas2->DetachBrush();
752     recordingCanvas1->DrawImageRect(image, dstRect, samplingOptions);
753     recordingCanvas2->DrawImageRect(image, dstRect, samplingOptions);
754 
755     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
756     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
757     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
758     Canvas canvas;
759     drawCmdList1->Playback(canvas);
760     drawCmdList2->Playback(canvas);
761 }
762 
763 /**
764  * @tc.name: DrawImageRect002
765  * @tc.desc: Test the playback of the DrawImageRect function.
766  * @tc.type: FUNC
767  * @tc.require: I7K0BS
768  */
769 HWTEST_F(RecordingCanvasTest, DrawImageRect002, TestSize.Level1)
770 {
771     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
772     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
773     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
774     Bitmap bitmap;
775     BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
776     bitmap.Build(CANAS_WIDTH, CANAS_WIDTH, bitmapFormat);
777     Image image;
778     image.BuildFromBitmap(bitmap);
779     Rect srcRect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
780     Rect dstRect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
781     SamplingOptions samplingOptions;
782     recordingCanvas1->DrawImageRect(image, srcRect, dstRect, samplingOptions);
783     recordingCanvas2->DrawImageRect(image, srcRect, dstRect, samplingOptions);
784 
785     Brush brush(Color::COLOR_GREEN);
786     recordingCanvas1->AttachBrush(brush);
787     recordingCanvas2->AttachBrush(brush);
788     recordingCanvas1->DrawImageRect(image, srcRect, dstRect, samplingOptions);
789     recordingCanvas2->DrawImageRect(image, srcRect, dstRect, samplingOptions);
790 
791     Pen pen(Color::COLOR_GREEN);
792     recordingCanvas1->AttachPen(pen);
793     recordingCanvas2->AttachPen(pen);
794     recordingCanvas1->DrawImageRect(image, srcRect, dstRect, samplingOptions);
795     recordingCanvas2->DrawImageRect(image, srcRect, dstRect, samplingOptions);
796 
797     recordingCanvas1->DetachBrush();
798     recordingCanvas2->DetachBrush();
799     recordingCanvas1->DrawImageRect(image, srcRect, dstRect, samplingOptions);
800     recordingCanvas2->DrawImageRect(image, srcRect, dstRect, samplingOptions);
801 
802     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
803     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
804     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
805     Canvas canvas;
806     drawCmdList1->Playback(canvas);
807     drawCmdList2->Playback(canvas);
808 }
809 
810 /**
811  * @tc.name: DrawPicture001
812  * @tc.desc: Test the playback of the DrawPicture function.
813  * @tc.type: FUNC
814  * @tc.require: I7K0BS
815  */
816 HWTEST_F(RecordingCanvasTest, DrawPicture001, TestSize.Level1)
817 {
818     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
819     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
820     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
821     Picture pic;
822     recordingCanvas1->DrawPicture(pic);
823     recordingCanvas2->DrawPicture(pic);
824     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
825     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
826     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
827     Canvas canvas;
828     drawCmdList1->Playback(canvas);
829     drawCmdList2->Playback(canvas);
830 }
831 
832 /**
833  * @tc.name: ClipRect001
834  * @tc.desc: Test the playback of the ClipRect function.
835  * @tc.type: FUNC
836  * @tc.require: I7K0BS
837  */
838 HWTEST_F(RecordingCanvasTest, ClipRect001, TestSize.Level1)
839 {
840     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
841     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
842     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
843     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
844     recordingCanvas1->ClipRect(rect, ClipOp::DIFFERENCE, true);
845     recordingCanvas2->ClipRect(rect, ClipOp::DIFFERENCE, true);
846     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
847     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
848     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
849     Canvas canvas;
850     drawCmdList1->Playback(canvas);
851     drawCmdList2->Playback(canvas);
852 }
853 
854 /**
855  * @tc.name: ClipIRect001
856  * @tc.desc: Test the playback of the ClipRect function.
857  * @tc.type: FUNC
858  * @tc.require: I7K0BS
859  */
860 HWTEST_F(RecordingCanvasTest, ClipIRect001, TestSize.Level1)
861 {
862     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
863     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
864     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
865     RectI rect(0, 0, 10, 20);
866     recordingCanvas1->ClipIRect(rect);
867     recordingCanvas2->ClipIRect(rect);
868     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
869     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
870     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
871     Canvas canvas;
872     drawCmdList1->Playback(canvas);
873     drawCmdList2->Playback(canvas);
874 }
875 
876 /**
877  * @tc.name: ClipRoundRect001
878  * @tc.desc: Test the playback of the ClipRoundRect function.
879  * @tc.type: FUNC
880  * @tc.require: I7K0BS
881  */
882 HWTEST_F(RecordingCanvasTest, ClipRoundRect001, TestSize.Level1)
883 {
884     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
885     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
886     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
887     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
888     RoundRect roundRect(rect, RADIUS, RADIUS);
889     recordingCanvas1->ClipRoundRect(roundRect, ClipOp::DIFFERENCE, true);
890     recordingCanvas2->ClipRoundRect(roundRect, ClipOp::DIFFERENCE, true);
891     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
892     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
893     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
894     Canvas canvas;
895     drawCmdList1->Playback(canvas);
896     drawCmdList2->Playback(canvas);
897 }
898 
899 /**
900  * @tc.name: ClipRoundRect002
901  * @tc.desc: Test the playback of the ClipRoundRect function.
902  * @tc.type: FUNC
903  * @tc.require: I7K0BS
904  */
905 HWTEST_F(RecordingCanvasTest, ClipRoundRect002, TestSize.Level1)
906 {
907     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
908     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
909     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
910     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
911     std::vector<Point> radii = { {RADIUS, RADIUS}, {RADIUS, RADIUS}, {RADIUS, RADIUS}, {RADIUS, RADIUS} };
912     recordingCanvas1->ClipRoundRect(rect, radii, true);
913     recordingCanvas2->ClipRoundRect(rect, radii, true);
914     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
915     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
916     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
917     Canvas canvas;
918     drawCmdList1->Playback(canvas);
919     drawCmdList2->Playback(canvas);
920 }
921 
922 /**
923  * @tc.name: ClipPath001
924  * @tc.desc: Test the playback of the ClipPath function.
925  * @tc.type: FUNC
926  * @tc.require: I7K0BS
927  */
928 HWTEST_F(RecordingCanvasTest, ClipPath001, TestSize.Level1)
929 {
930     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
931     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
932     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
933     Path path;
934     path.AddRect(Rect(0, 0, CANAS_WIDTH, CANAS_HEIGHT));
935     recordingCanvas1->ClipPath(path, ClipOp::DIFFERENCE, true);
936     recordingCanvas2->ClipPath(path, ClipOp::DIFFERENCE, true);
937     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
938     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
939     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
940     Canvas canvas;
941     drawCmdList1->Playback(canvas);
942     drawCmdList2->Playback(canvas);
943 }
944 
945 /**
946  * @tc.name: ClipRegion001
947  * @tc.desc: Test the playback of the ClipRegion function.
948  * @tc.type: FUNC
949  * @tc.require: I7K0BS
950  */
951 HWTEST_F(RecordingCanvasTest, ClipRegion001, TestSize.Level1)
952 {
953     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
954     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
955     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
956     Region region;
957     region.SetRect(RectI(0, 0, CANAS_WIDTH, CANAS_HEIGHT));
958     recordingCanvas1->ClipRegion(region);
959     recordingCanvas2->ClipRegion(region);
960     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
961     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
962     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
963     Canvas canvas;
964     drawCmdList1->Playback(canvas);
965     drawCmdList2->Playback(canvas);
966 }
967 
968 /**
969  * @tc.name: SetMatrix001
970  * @tc.desc: Test the playback of the SetMatrix function.
971  * @tc.type: FUNC
972  * @tc.require: I7K0BS
973  */
974 HWTEST_F(RecordingCanvasTest, SetMatrix001, TestSize.Level1)
975 {
976     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
977     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
978     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
979     Matrix matrix;
980     recordingCanvas1->SetMatrix(matrix);
981     recordingCanvas2->SetMatrix(matrix);
982     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
983     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
984     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
985     Canvas canvas;
986     drawCmdList1->Playback(canvas);
987     drawCmdList2->Playback(canvas);
988 }
989 
990 /**
991  * @tc.name: ResetMatrix001
992  * @tc.desc: Test the playback of the ResetMatrix function.
993  * @tc.type: FUNC
994  * @tc.require: I7K0BS
995  */
996 HWTEST_F(RecordingCanvasTest, ResetMatrix001, TestSize.Level1)
997 {
998     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
999     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1000     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1001     recordingCanvas1->ResetMatrix();
1002     recordingCanvas2->ResetMatrix();
1003     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1004     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1005     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1006     Canvas canvas;
1007     drawCmdList1->Playback(canvas);
1008     drawCmdList2->Playback(canvas);
1009 }
1010 
1011 /**
1012  * @tc.name: ConcatMatrix001
1013  * @tc.desc: Test the playback of the ConcatMatrix function.
1014  * @tc.type: FUNC
1015  * @tc.require: I7K0BS
1016  */
1017 HWTEST_F(RecordingCanvasTest, ConcatMatrix001, TestSize.Level1)
1018 {
1019     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1020     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1021     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1022     Matrix matrix;
1023     matrix.Translate(CANAS_WIDTH, CANAS_WIDTH);
1024     recordingCanvas1->ConcatMatrix(matrix);
1025     recordingCanvas2->ConcatMatrix(matrix);
1026     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1027     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1028     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1029     Canvas canvas;
1030     drawCmdList1->Playback(canvas);
1031     drawCmdList2->Playback(canvas);
1032 }
1033 
1034 /**
1035  * @tc.name: Translate001
1036  * @tc.desc: Test the playback of the Translate function.
1037  * @tc.type: FUNC
1038  * @tc.require: I7K0BS
1039  */
1040 HWTEST_F(RecordingCanvasTest, Translate001, TestSize.Level1)
1041 {
1042     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1043     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1044     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1045     recordingCanvas1->Translate(CANAS_WIDTH, CANAS_WIDTH);
1046     recordingCanvas2->Translate(CANAS_WIDTH, CANAS_WIDTH);
1047     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1048     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1049     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1050     Canvas canvas;
1051     drawCmdList1->Playback(canvas);
1052     drawCmdList2->Playback(canvas);
1053 }
1054 
1055 /**
1056  * @tc.name: Scale001
1057  * @tc.desc: Test the playback of the Scale function.
1058  * @tc.type: FUNC
1059  * @tc.require: I7K0BS
1060  */
1061 HWTEST_F(RecordingCanvasTest, Scale001, TestSize.Level1)
1062 {
1063     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1064     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1065     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1066     recordingCanvas1->Scale(2.0f, 1.0f);
1067     recordingCanvas2->Scale(2.0f, 1.0f);
1068     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1069     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1070     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1071     Canvas canvas;
1072     drawCmdList1->Playback(canvas);
1073     drawCmdList2->Playback(canvas);
1074 }
1075 
1076 /**
1077  * @tc.name: Rotate001
1078  * @tc.desc: Test the playback of the Rotate function.
1079  * @tc.type: FUNC
1080  * @tc.require: I7K0BS
1081  */
1082 HWTEST_F(RecordingCanvasTest, Rotate001, TestSize.Level1)
1083 {
1084     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1085     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1086     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1087     recordingCanvas1->Rotate(ANGLE, CANAS_WIDTH, CANAS_WIDTH);
1088     recordingCanvas2->Rotate(ANGLE, CANAS_WIDTH, CANAS_WIDTH);
1089     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1090     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1091     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1092     Canvas canvas;
1093     drawCmdList1->Playback(canvas);
1094     drawCmdList2->Playback(canvas);
1095 }
1096 
1097 /**
1098  * @tc.name: Shear001
1099  * @tc.desc: Test the playback of the Shear function.
1100  * @tc.type: FUNC
1101  * @tc.require: I7K0BS
1102  */
1103 HWTEST_F(RecordingCanvasTest, Shear001, TestSize.Level1)
1104 {
1105     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1106     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1107     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1108     recordingCanvas1->Shear(CANAS_WIDTH, CANAS_WIDTH);
1109     recordingCanvas2->Shear(CANAS_WIDTH, CANAS_WIDTH);
1110     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1111     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1112     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1113     Canvas canvas;
1114     drawCmdList1->Playback(canvas);
1115     drawCmdList2->Playback(canvas);
1116 }
1117 
1118 /**
1119  * @tc.name: Flush001
1120  * @tc.desc: Test the playback of the Flush function.
1121  * @tc.type: FUNC
1122  * @tc.require: I7K0BS
1123  */
1124 HWTEST_F(RecordingCanvasTest, Flush001, TestSize.Level1)
1125 {
1126     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1127     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1128     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1129     recordingCanvas1->Flush();
1130     recordingCanvas2->Flush();
1131     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1132     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1133     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1134     Canvas canvas;
1135     drawCmdList1->Playback(canvas);
1136     drawCmdList2->Playback(canvas);
1137 }
1138 
1139 /**
1140  * @tc.name: Clear001
1141  * @tc.desc: Test the playback of the Clear function.
1142  * @tc.type: FUNC
1143  * @tc.require: I7K0BS
1144  */
1145 HWTEST_F(RecordingCanvasTest, Clear001, TestSize.Level1)
1146 {
1147     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1148     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1149     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1150     recordingCanvas1->Clear(Color::COLOR_BLUE);
1151     recordingCanvas2->Clear(Color::COLOR_BLUE);
1152     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1153     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1154     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1155     Canvas canvas;
1156     drawCmdList1->Playback(canvas);
1157     drawCmdList2->Playback(canvas);
1158 }
1159 
1160 /**
1161  * @tc.name: SaveRestore001
1162  * @tc.desc: Test the playback of the Save function.
1163  * @tc.type: FUNC
1164  * @tc.require: I7K0BS
1165  */
1166 HWTEST_F(RecordingCanvasTest, SaveRestore001, TestSize.Level1)
1167 {
1168     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1169     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1170     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1171     recordingCanvas1->Save();
1172     recordingCanvas2->Save();
1173     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
1174     recordingCanvas1->ClipRect(rect, ClipOp::DIFFERENCE, true);
1175     recordingCanvas2->ClipRect(rect, ClipOp::DIFFERENCE, true);
1176     recordingCanvas1->Restore();
1177     recordingCanvas2->Restore();
1178     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1179     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1180     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1181     Canvas canvas;
1182     drawCmdList1->Playback(canvas);
1183     drawCmdList2->Playback(canvas);
1184 }
1185 
1186 /**
1187  * @tc.name: SaveRestore002
1188  * @tc.desc: Test the playback of the Save function.
1189  * @tc.type: FUNC
1190  * @tc.require: I7K0BS
1191  */
1192 HWTEST_F(RecordingCanvasTest, SaveRestore002, TestSize.Level1)
1193 {
1194     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1195     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1196     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1197     recordingCanvas1->Save();
1198     recordingCanvas2->Save();
1199     EXPECT_TRUE(recordingCanvas1->GetSaveCount() == 2 && recordingCanvas2->GetSaveCount() == 2);
1200     recordingCanvas1->Restore();
1201     recordingCanvas2->Restore();
1202     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1203     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1204     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1205     Canvas canvas;
1206     drawCmdList1->Playback(canvas);
1207     drawCmdList2->Playback(canvas);
1208 }
1209 
1210 /**
1211  * @tc.name: SaveLayer001
1212  * @tc.desc: Test the playback of the SaveLayer function.
1213  * @tc.type: FUNC
1214  * @tc.require: I7K0BS
1215  */
1216 HWTEST_F(RecordingCanvasTest, SaveLayer001, TestSize.Level1)
1217 {
1218     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1219     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1220     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1221     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
1222     Brush brush;
1223     uint32_t saveLayerFlags = 0;
1224     SaveLayerOps saveLayerRec(&rect, &brush, saveLayerFlags);
1225     recordingCanvas1->SaveLayer(saveLayerRec);
1226     recordingCanvas2->SaveLayer(saveLayerRec);
1227     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1228     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1229     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1230     Canvas canvas;
1231     drawCmdList1->Playback(canvas);
1232     drawCmdList2->Playback(canvas);
1233 }
1234 
1235 /**
1236  * @tc.name: Restore001
1237  * @tc.desc: Test the playback of the Restore function.
1238  * @tc.type: FUNC
1239  * @tc.require: I7K0BS
1240  */
1241 HWTEST_F(RecordingCanvasTest, Restore001, TestSize.Level1)
1242 {
1243     auto recordingCanvas = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1244     EXPECT_TRUE(recordingCanvas != nullptr);
1245     recordingCanvas->Restore();
1246     auto drawCmdList = recordingCanvas->GetDrawCmdList();
1247     EXPECT_TRUE(drawCmdList != nullptr);
1248     Canvas canvas;
1249     drawCmdList->Playback(canvas);
1250 }
1251 
1252 /**
1253  * @tc.name: Discard001
1254  * @tc.desc: Test the playback of the Discard function.
1255  * @tc.type: FUNC
1256  * @tc.require: I7K0BS
1257  */
1258 HWTEST_F(RecordingCanvasTest, Discard001, TestSize.Level1)
1259 {
1260     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1261     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1262     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1263     recordingCanvas1->Discard();
1264     recordingCanvas2->Discard();
1265     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1266     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1267     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1268     Canvas canvas;
1269     drawCmdList1->Playback(canvas);
1270     drawCmdList2->Playback(canvas);
1271 }
1272 
1273 /**
1274  * @tc.name: ClipAdaptiveRoundRect001
1275  * @tc.desc: Test the playback of the ClipAdaptiveRoundRect function.
1276  * @tc.type: FUNC
1277  * @tc.require: I7OAIR
1278  */
1279 HWTEST_F(RecordingCanvasTest, ClipAdaptiveRoundRect001, TestSize.Level1)
1280 {
1281     auto recordingCanvas1 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT);
1282     auto recordingCanvas2 = std::make_shared<RecordingCanvas>(CANAS_WIDTH, CANAS_HEIGHT, false);
1283     EXPECT_TRUE(recordingCanvas1 != nullptr && recordingCanvas2 != nullptr);
1284     std::vector<Point> radiusXY = { { 1, 3 } };
1285     recordingCanvas1->ClipAdaptiveRoundRect(radiusXY);
1286     recordingCanvas2->ClipAdaptiveRoundRect(radiusXY);
1287     auto drawCmdList1 = recordingCanvas1->GetDrawCmdList();
1288     auto drawCmdList2 = recordingCanvas2->GetDrawCmdList();
1289     EXPECT_TRUE(drawCmdList1 != nullptr && drawCmdList2 != nullptr);
1290     Canvas canvas;
1291     Rect rect(0.0f, 0.0f, CANAS_WIDTH, CANAS_HEIGHT);
1292     drawCmdList1->Playback(canvas, &rect);
1293     drawCmdList2->Playback(canvas, &rect);
1294 }
1295 } // namespace Drawing
1296 } // namespace Rosen
1297 } // namespace OHOS