1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, Hardware
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "c/drawing_bitmap.h"
19 #include "c/drawing_brush.h"
20 #include "c/drawing_canvas.h"
21 #include "c/drawing_color.h"
22 #include "c/drawing_color_filter.h"
23 #include "c/drawing_filter.h"
24 #include "c/drawing_font.h"
25 #include "c/drawing_mask_filter.h"
26 #include "c/drawing_path.h"
27 #include "c/drawing_pen.h"
28 #include "c/drawing_point.h"
29 #include "c/drawing_rect.h"
30 #include "c/drawing_round_rect.h"
31 #include "c/drawing_shader_effect.h"
32 #include "c/drawing_text_blob.h"
33 #include "c/drawing_typeface.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace Rosen {
40 namespace Drawing {
41 class NativeDrawingCanvasTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47 protected:
48 OH_Drawing_Canvas *canvas_ = nullptr;
49 OH_Drawing_Brush *brush_ = nullptr;
50 };
51
SetUpTestCase()52 void NativeDrawingCanvasTest::SetUpTestCase() {}
TearDownTestCase()53 void NativeDrawingCanvasTest::TearDownTestCase() {}
SetUp()54 void NativeDrawingCanvasTest::SetUp()
55 {
56 canvas_ = OH_Drawing_CanvasCreate();
57 ASSERT_NE(nullptr, canvas_);
58 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
59 brush_ = OH_Drawing_BrushCreate();
60 EXPECT_NE(brush_, nullptr);
61 OH_Drawing_BrushSetColor(brush_, 0xffff0000);
62 OH_Drawing_CanvasAttachBrush(canvas_, brush_);
63 }
64
TearDown()65 void NativeDrawingCanvasTest::TearDown()
66 {
67 if (canvas_ != nullptr) {
68 OH_Drawing_CanvasDetachBrush(canvas_);
69 OH_Drawing_BrushDestroy(brush_);
70 brush_ = nullptr;
71 OH_Drawing_CanvasDestroy(canvas_);
72 canvas_ = nullptr;
73 }
74 }
75
76 /*
77 * @tc.name: NativeDrawingCanvasTest_CanvasNULLPTR
78 * @tc.desc: test for OH_Drawing_CanvasBind.
79 * @tc.type: FUNC
80 * @tc.require: AR000GTO5R
81 */
82 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasNULLPTR, TestSize.Level1)
83 {
84 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
85 EXPECT_NE(bitmap, nullptr);
86 OH_Drawing_CanvasBind(nullptr, bitmap);
87 OH_Drawing_BitmapDestroy(bitmap);
88 OH_Drawing_CanvasAttachPen(canvas_, nullptr);
89 OH_Drawing_CanvasTranslate(canvas_, INT32_MIN, INT32_MIN);
90 OH_Drawing_CanvasTranslate(canvas_, INT32_MAX, INT32_MAX);
91 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20);
92 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, INT32_MAX, INT32_MAX);
93 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, INT32_MIN, INT32_MIN);
94 OH_Drawing_Path* path = OH_Drawing_PathCreate();
95 OH_Drawing_PathMoveTo(path, INT32_MAX, INT32_MIN);
96 OH_Drawing_PathMoveTo(nullptr, 9999, -1000);
97 OH_Drawing_PathClose(nullptr);
98 OH_Drawing_PathClose(path);
99 OH_Drawing_CanvasDrawPath(nullptr, path);
100 OH_Drawing_CanvasDrawPath(canvas_, nullptr);
101 OH_Drawing_PathDestroy(path);
102 }
103
104 /*
105 * @tc.name: NativeDrawingCanvasTest_CanvasBind
106 * @tc.desc: test for OH_Drawing_CanvasBind.
107 * @tc.type: FUNC
108 * @tc.require: AR000GTO5R
109 */
110 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasBind, TestSize.Level1)
111 {
112 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
113 EXPECT_NE(bitmap, nullptr);
114 OH_Drawing_CanvasBind(canvas_, bitmap);
115 OH_Drawing_BitmapDestroy(bitmap);
116 }
117
118 /*
119 * @tc.name: NativeDrawingCanvasTest_canvas002
120 * @tc.desc: test for OH_Drawing_CanvasAttachPen & OH_Drawing_CanvasDetachPen.
121 * @tc.type: FUNC
122 * @tc.require: AR000GTO5R
123 */
124 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_canvas002, TestSize.Level1)
125 {
126 OH_Drawing_Pen* pen = OH_Drawing_PenCreate();
127 EXPECT_NE(pen, nullptr);
128 OH_Drawing_CanvasAttachPen(canvas_, pen);
129 OH_Drawing_CanvasDetachPen(canvas_);
130 OH_Drawing_PenDestroy(pen);
131 }
132
133 /*
134 * @tc.name: NativeDrawingCanvasTest_DrawLine
135 * @tc.desc: test for OH_Drawing_CanvasDrawLine.
136 * @tc.type: FUNC
137 * @tc.require: AR000GTO5R
138 */
139 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawLine, TestSize.Level1)
140 {
141 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, 20, 20);
142 OH_Drawing_CanvasDrawLine(canvas_, -15.2f, -1, 0, 20);
143 }
144
145 /*
146 * @tc.name: NativeDrawingCanvasTest_DrawPath
147 * @tc.desc: test for OH_Drawing_CanvasDrawPath.
148 * @tc.type: FUNC
149 * @tc.require: AR000GTO5R
150 */
151 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPath, TestSize.Level1)
152 {
153 OH_Drawing_Path* path = OH_Drawing_PathCreate();
154 EXPECT_NE(path, nullptr);
155 constexpr int height = 300;
156 constexpr int width = 300;
157 constexpr float arc = 18.0f;
158 int len = height / 4;
159 float aX = width / 2;
160 float aY = height / 4;
161 float dX = aX - len * std::sin(arc);
162 float dY = aY + len * std::cos(arc);
163 float cX = aX + len * std::sin(arc);
164 float cY = dY;
165 float bX = aX + (len / 2.0);
166 float bY = aY + std::sqrt((cX - dX) * (cX - dX) + (len / 2.0) * (len / 2.0));
167 float eX = aX - (len / 2.0);
168 float eY = bY;
169 OH_Drawing_PathMoveTo(path, aX, aY);
170 OH_Drawing_PathLineTo(path, bX, bY);
171 OH_Drawing_PathLineTo(path, cX, cY);
172 OH_Drawing_PathLineTo(path, dX, dY);
173 OH_Drawing_PathLineTo(path, eX, eY);
174 OH_Drawing_PathClose(path);
175 OH_Drawing_CanvasDrawPath(canvas_, path);
176 OH_Drawing_PathDestroy(path);
177 }
178
179 /*
180 * @tc.name: NativeDrawingCanvasTest_SaveAndRestore
181 * @tc.desc: test for OH_Drawing_CanvasSave & OH_Drawing_CanvasRestore.
182 * @tc.type: FUNC
183 * @tc.require: AR000GTO5R
184 */
185 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveAndRestore, TestSize.Level1)
186 {
187 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300);
188 EXPECT_NE(nullptr, rect);
189 OH_Drawing_CanvasSave(nullptr);
190 OH_Drawing_CanvasSave(canvas_);
191 OH_Drawing_CanvasTranslate(nullptr, 100, 100);
192 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
193 OH_Drawing_CanvasDrawArc(nullptr, rect, 10, 200);
194 OH_Drawing_CanvasDrawArc(canvas_, nullptr, 10, 200);
195 OH_Drawing_CanvasDrawArc(canvas_, rect, 10, 200);
196 OH_Drawing_CanvasRestore(nullptr);
197 OH_Drawing_CanvasRestore(canvas_);
198 OH_Drawing_CanvasTranslate(canvas_, 200, 200);
199 OH_Drawing_CanvasDrawOval(nullptr, rect);
200 OH_Drawing_CanvasDrawOval(canvas_, nullptr);
201 OH_Drawing_CanvasDrawOval(canvas_, rect);
202 OH_Drawing_RectDestroy(nullptr);
203 OH_Drawing_RectDestroy(rect);
204 }
205
206 /*
207 * @tc.name: NativeDrawingCanvasTest_Clear
208 * @tc.desc: test for OH_Drawing_CanvasClear.
209 * @tc.type: FUNC
210 * @tc.require: AR000GTO5R
211 */
212 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Clear, TestSize.Level1)
213 {
214 OH_Drawing_CanvasClear(nullptr, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
215 OH_Drawing_CanvasClear(canvas_, -100);
216 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN));
217 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
218 }
219
220 /*
221 * @tc.name: NativeDrawingCanvasTest_RestoreToCount
222 * @tc.desc: test for OH_Drawing_CanvasRestoreToCount.
223 * @tc.type: FUNC
224 * @tc.require: AR000GTO5R
225 */
226 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RestoreToCount, TestSize.Level1)
227 {
228 OH_Drawing_CanvasSave(canvas_);
229 OH_Drawing_CanvasTranslate(canvas_, 300, 300);
230 OH_Drawing_CanvasSave(canvas_);
231 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
232 OH_Drawing_CanvasSave(canvas_);
233 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
234 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
235 OH_Drawing_CanvasDrawRect(canvas_, rect);
236 int count = OH_Drawing_CanvasGetSaveCount(canvas_);
237 EXPECT_EQ(count, 4);
238 OH_Drawing_CanvasRestoreToCount(nullptr, count - 2);
239 OH_Drawing_CanvasRestoreToCount(canvas_, count - 2);
240 EXPECT_EQ(2, OH_Drawing_CanvasGetSaveCount(canvas_));
241 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(nullptr, 20, 20);
242 EXPECT_EQ(roundRect, nullptr);
243 roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20);
244 EXPECT_NE(roundRect, nullptr);
245 OH_Drawing_CanvasDrawRoundRect(nullptr, roundRect);
246 OH_Drawing_CanvasDrawRoundRect(canvas_, nullptr);
247 OH_Drawing_CanvasDrawRoundRect(canvas_, roundRect);
248 OH_Drawing_CanvasRestoreToCount(canvas_, 1);
249 OH_Drawing_CanvasDrawRect(canvas_, rect);
250 OH_Drawing_RoundRectDestroy(roundRect);
251 OH_Drawing_RectDestroy(rect);
252 OH_Drawing_RoundRectDestroy(nullptr);
253 OH_Drawing_RectDestroy(nullptr);
254 }
255
256 /*
257 * @tc.name: NativeDrawingCanvasTest_Scale
258 * @tc.desc: test for OH_Drawing_CanvasScale.
259 * @tc.type: FUNC
260 * @tc.require: AR000GTO5R
261 */
262 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Scale, TestSize.Level1)
263 {
264 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 20, 60, 120);
265 OH_Drawing_CanvasTranslate(canvas_, 20, 20);
266 OH_Drawing_CanvasDrawRect(canvas_, rect);
267 OH_Drawing_CanvasScale(nullptr, 2, .5f);
268 OH_Drawing_CanvasScale(canvas_, 2, .5f);
269 OH_Drawing_BrushSetColor(nullptr, 0xFF67C23A);
270 OH_Drawing_BrushSetColor(brush_, 0xFF67C23A);
271 OH_Drawing_CanvasDrawRect(canvas_, rect);
272 }
273
274 /*
275 * @tc.name: NativeDrawingCanvasTest_ClipRect
276 * @tc.desc: test for OH_Drawing_CanvasClipRect.
277 * @tc.type: FUNC
278 * @tc.require: AR000GTO5R
279 */
280 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRect, TestSize.Level1)
281 {
282 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 90, 90);
283 OH_Drawing_CanvasRotate(nullptr, 10, 0, 0);
284 OH_Drawing_CanvasRotate(canvas_, 10, 0, 0);
285 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 60);
286 OH_Drawing_BrushSetAntiAlias(nullptr, true);
287 OH_Drawing_BrushSetAntiAlias(brush_, true);
288 for (auto alias : {false, true}) {
289 OH_Drawing_CanvasSave(canvas_);
290 OH_Drawing_CanvasClipRect(nullptr, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
291 OH_Drawing_CanvasClipRect(canvas_, nullptr, OH_Drawing_CanvasClipOp::INTERSECT, alias);
292 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
293 OH_Drawing_CanvasDrawCircle(canvas_, nullptr, 60);
294 OH_Drawing_CanvasDrawCircle(nullptr, point, 60);
295 OH_Drawing_CanvasDrawCircle(canvas_, point, 60);
296 OH_Drawing_CanvasRestore(canvas_);
297 OH_Drawing_CanvasTranslate(canvas_, 80, 0);
298 }
299 OH_Drawing_RectDestroy(rect);
300 OH_Drawing_PointDestroy(point);
301 }
302
303 /*
304 * @tc.name: NativeDrawingCanvasTest_ClipPath
305 * @tc.desc: test for OH_Drawing_CanvasClipPath.
306 * @tc.type: FUNC
307 * @tc.require: AR000GTO5R
308 */
309 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipPath, TestSize.Level1)
310 {
311 OH_Drawing_Path *path = OH_Drawing_PathCreate();
312 OH_Drawing_PathMoveTo(path, 100, 300);
313 OH_Drawing_PathLineTo(path, 200, 300);
314 OH_Drawing_PathLineTo(path, 200, 400);
315 OH_Drawing_PathLineTo(path, 100, 350);
316 OH_Drawing_PathClose(nullptr);
317 OH_Drawing_PathClose(path);
318 OH_Drawing_CanvasClipPath(nullptr, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
319 OH_Drawing_CanvasClipPath(canvas_, nullptr, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
320 OH_Drawing_CanvasClipPath(canvas_, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
321 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 300, 200, 400);
322 OH_Drawing_CanvasDrawRect(canvas_, rect);
323 OH_Drawing_RectDestroy(rect);
324 OH_Drawing_PathDestroy(path);
325 }
326
327 /*
328 * @tc.name: NativeDrawingCanvasTest_LinearGradient
329 * @tc.desc: test for LinearGradient
330 * @tc.type: FUNC
331 * @tc.require: AR000GTO5R
332 */
333 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_LinearGradient, TestSize.Level1)
334 {
335 OH_Drawing_Point* startPt = OH_Drawing_PointCreate(100, 400);
336 OH_Drawing_Point* endPt = OH_Drawing_PointCreate(200, 500);
337 uint32_t color[] = {0xffff0000, 0xff00ff00};
338 float pos[] = {0., 1.0};
339 OH_Drawing_ShaderEffect* linearGradient = OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt,
340 color, pos, 2, OH_Drawing_TileMode::CLAMP);
341 OH_Drawing_BrushSetShaderEffect(nullptr, linearGradient);
342 OH_Drawing_BrushSetShaderEffect(brush_, nullptr);
343 OH_Drawing_BrushSetShaderEffect(brush_, linearGradient);
344 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
345 OH_Drawing_CanvasDrawRect(canvas_, rect);
346 OH_Drawing_RectDestroy(rect);
347 OH_Drawing_ShaderEffectDestroy(nullptr);
348 OH_Drawing_ShaderEffectDestroy(linearGradient);
349 OH_Drawing_PointDestroy(startPt);
350 OH_Drawing_PointDestroy(endPt);
351 }
352
353 /*
354 * @tc.name: NativeDrawingCanvasTest_SweepGradient
355 * @tc.desc: test for sweep gradient shader effect
356 * @tc.type: FUNC
357 * @tc.require: AR000GTO5R
358 */
359 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SweepGradient, TestSize.Level1)
360 {
361 OH_Drawing_Point* centerPt = OH_Drawing_PointCreate(350, 450);
362 uint32_t colors[] = {0xffff00ff, 0xff00ff00};
363 float pos[] = {0., 1.0};
364 OH_Drawing_ShaderEffect* sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(nullptr, nullptr,
365 nullptr, -2, OH_Drawing_TileMode::MIRROR);
366 EXPECT_EQ(sweepGradient, nullptr);
367 sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors,
368 pos, 2, OH_Drawing_TileMode::MIRROR);
369 EXPECT_NE(sweepGradient, nullptr);
370 OH_Drawing_BrushSetShaderEffect(brush_, sweepGradient);
371 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500);
372 OH_Drawing_CanvasDrawRect(canvas_, rect);
373 OH_Drawing_RectDestroy(rect);
374 OH_Drawing_ShaderEffectDestroy(sweepGradient);
375 OH_Drawing_PointDestroy(centerPt);
376 }
377
378 /*
379 * @tc.name: NativeDrawingCanvasTest_MaskFilter
380 * @tc.desc: test for maskfilter
381 * @tc.type: FUNC
382 * @tc.require: AR000GTO5R
383 */
384 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_MaskFilter, TestSize.Level1)
385 {
386 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
387 OH_Drawing_MaskFilter* maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true);
388 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
389 OH_Drawing_FilterSetMaskFilter(nullptr, maskFilter);
390 OH_Drawing_FilterSetMaskFilter(filter, nullptr);
391 OH_Drawing_FilterSetMaskFilter(filter, maskFilter);
392 OH_Drawing_BrushSetFilter(brush_, filter);
393 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
394 OH_Drawing_CanvasDrawRect(canvas_, rect);
395 OH_Drawing_RectDestroy(rect);
396 OH_Drawing_MaskFilterDestroy(maskFilter);
397 OH_Drawing_FilterDestroy(filter);
398 }
399
400 /*
401 * @tc.name: NativeDrawingCanvasTest_ColorFilter
402 * @tc.desc: test for colorfilter create blend mode, linear to srgb gamma, luma, matrix
403 * @tc.type: FUNC
404 * @tc.require: AR000GTO5R
405 */
406 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateBlendMode, TestSize.Level1)
407 {
408 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
409 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xff0000ff,
410 OH_Drawing_BlendMode::BLEND_MODE_SRC);
411 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
412 OH_Drawing_FilterSetColorFilter(nullptr, colorFilter);
413 OH_Drawing_FilterSetColorFilter(filter, nullptr);
414 OH_Drawing_FilterSetColorFilter(filter, colorFilter);
415 OH_Drawing_BrushSetFilter(brush_, nullptr);
416 OH_Drawing_BrushSetFilter(brush_, filter);
417 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
418 OH_Drawing_CanvasDrawRect(canvas_, rect);
419 OH_Drawing_ColorFilter* linear = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
420 OH_Drawing_FilterSetColorFilter(filter, linear);
421 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
422 OH_Drawing_CanvasDrawRect(canvas_, rect);
423 OH_Drawing_ColorFilter* luma = OH_Drawing_ColorFilterCreateLuma();
424 OH_Drawing_FilterSetColorFilter(filter, luma);
425 OH_Drawing_CanvasTranslate(canvas_, 200, 200);
426 OH_Drawing_CanvasDrawRect(canvas_, rect);
427 const float matrix[20] = {
428 1, 0, 0, 0, 0,
429 0, 1, 0, 0, 0,
430 0, 0, 1, 0, 0,
431 0, 0, 0, 0.5f, 0
432 };
433 OH_Drawing_ColorFilter* matrixFilter = OH_Drawing_ColorFilterCreateMatrix(nullptr);
434 EXPECT_EQ(matrixFilter, nullptr);
435 matrixFilter = OH_Drawing_ColorFilterCreateMatrix(matrix);
436 EXPECT_NE(matrixFilter, nullptr);
437 OH_Drawing_FilterSetColorFilter(filter, matrixFilter);
438 OH_Drawing_CanvasTranslate(canvas_, 300, 300);
439 OH_Drawing_CanvasDrawRect(canvas_, rect);
440 OH_Drawing_RectDestroy(rect);
441 OH_Drawing_ColorFilterDestroy(colorFilter);
442 OH_Drawing_ColorFilterDestroy(luma);
443 OH_Drawing_ColorFilterDestroy(matrixFilter);
444 OH_Drawing_ColorFilterDestroy(linear);
445 OH_Drawing_FilterDestroy(filter);
446 OH_Drawing_FilterDestroy(nullptr);
447 }
448
449 /*
450 * @tc.name: NativeDrawingCanvasTest_ColorFilterCreateCompose
451 * @tc.desc: test for create compose color filter
452 * @tc.type: FUNC
453 * @tc.require: AR000GTO5R
454 */
455 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateCompose, TestSize.Level1)
456 {
457 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
458 OH_Drawing_ColorFilter* outerFilter = OH_Drawing_ColorFilterCreateLuma();
459 OH_Drawing_ColorFilter* innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear();
460 OH_Drawing_ColorFilter* compose = OH_Drawing_ColorFilterCreateCompose(nullptr, nullptr);
461 EXPECT_EQ(compose, nullptr);
462 compose = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter);
463 EXPECT_NE(compose, nullptr);
464 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
465 OH_Drawing_FilterSetColorFilter(filter, compose);
466 OH_Drawing_BrushSetFilter(brush_, filter);
467 OH_Drawing_Canvas* canvas_ = OH_Drawing_CanvasCreate();
468 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
469 OH_Drawing_CanvasDrawRect(canvas_, rect);
470 OH_Drawing_RectDestroy(rect);
471 OH_Drawing_ColorFilterDestroy(outerFilter);
472 OH_Drawing_ColorFilterDestroy(innerFilter);
473 OH_Drawing_ColorFilterDestroy(compose);
474 OH_Drawing_FilterDestroy(filter);
475 }
476
477 /*
478 * @tc.name: NativeDrawingCanvasTest_DrawBitmap
479 * @tc.desc: test for DrawBitmap
480 * @tc.type: FUNC
481 * @tc.require: AR000GTO5R
482 */
483 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmap, TestSize.Level1)
484 {
485 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
486 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
487 constexpr uint32_t width = 200;
488 constexpr uint32_t height = 200;
489 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
490 OH_Drawing_CanvasBind(canvas_, bitmap);
491 OH_Drawing_CanvasDrawBitmap(canvas_, bitmap, 0, 0);
492 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
493 OH_Drawing_BitmapDestroy(bitmap);
494 }
495
496 /*
497 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob
498 * @tc.desc: test for DrawTextBlob
499 * @tc.type: FUNC
500 * @tc.require: AR000GTO5R
501 */
502 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob, TestSize.Level1)
503 {
504 OH_Drawing_Font *font = OH_Drawing_FontCreate();
505 OH_Drawing_FontSetFakeBoldText(font, true);
506 OH_Drawing_FontSetTextSize(font, 20);
507 OH_Drawing_FontSetTextSkewX(font, 0.25);
508 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
509 OH_Drawing_FontSetTypeface(font, typeSurface);
510 auto *builder = OH_Drawing_TextBlobBuilderCreate();
511 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(nullptr, nullptr, INT32_MAX, nullptr));
512 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, INT32_MIN, nullptr));
513 const OH_Drawing_RunBuffer* runBuffer = OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, nullptr);
514 ASSERT_NE(runBuffer, nullptr);
515 runBuffer->glyphs[0] = 65;
516 runBuffer->pos[0] = 0;
517 runBuffer->pos[1] = 0;
518 runBuffer->glyphs[1] = 227;
519 runBuffer->pos[2] = 14.9;
520 runBuffer->pos[3] = 0;
521 runBuffer->glyphs[2] = 283;
522 runBuffer->pos[4] = 25.84;
523 runBuffer->pos[5] = 0;
524 runBuffer->glyphs[3] = 283;
525 runBuffer->pos[6] = 30.62;
526 runBuffer->pos[7] = 0;
527 runBuffer->glyphs[4] = 299;
528 runBuffer->pos[8] = 35.4;
529 runBuffer->pos[9] = 0;
530 runBuffer->glyphs[5] = 2;
531 runBuffer->pos[10] = 47.22;
532 runBuffer->pos[11] = 0;
533 runBuffer->glyphs[6]= 94;
534 runBuffer->pos[12] = 52.62;
535 runBuffer->pos[13] = 0;
536 runBuffer->glyphs[7] = 37;
537 runBuffer->pos[14] = 67.42;
538 runBuffer->pos[15] = 0;
539 runBuffer->glyphs[8] = 84;
540 runBuffer->pos[16] = 81.7;
541 runBuffer->pos[17] = 0;
542 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobBuilderMake(builder);
543 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 100, 700);
544 OH_Drawing_TextBlobDestroy(textBlob);
545 OH_Drawing_TextBlobBuilderDestroy(builder);
546 OH_Drawing_FontDestroy(font);
547 OH_Drawing_TypefaceDestroy(typeSurface);
548 OH_Drawing_TextBlobDestroy(nullptr);
549 OH_Drawing_TextBlobBuilderDestroy(nullptr);
550 OH_Drawing_FontDestroy(nullptr);
551 OH_Drawing_TypefaceDestroy(nullptr);
552 }
553 } // namespace Drawing
554 } // namespace Rosen
555 } // namespace OHOS
556