1/* 2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, Hardware 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include "gtest/gtest.h" 17 18#include "drawing_bitmap.h" 19#include "drawing_brush.h" 20#include "drawing_canvas.h" 21#include "drawing_color.h" 22#include "drawing_color_filter.h" 23#include "drawing_filter.h" 24#include "drawing_font.h" 25#include "drawing_image.h" 26#include "drawing_mask_filter.h" 27#include "drawing_matrix.h" 28#include "drawing_path.h" 29#include "drawing_pen.h" 30#include "drawing_point.h" 31#include "drawing_rect.h" 32#include "drawing_region.h" 33#include "drawing_round_rect.h" 34#include "drawing_sampling_options.h" 35#include "drawing_shader_effect.h" 36#include "drawing_text_blob.h" 37#include "drawing_typeface.h" 38#include "drawing_memory_stream.h" 39#include "effect/color_filter.h" 40#include "effect/filter.h" 41 42using namespace testing; 43using namespace testing::ext; 44 45namespace OHOS { 46namespace Rosen { 47namespace Drawing { 48class NativeDrawingCanvasTest : public testing::Test { 49public: 50 static void SetUpTestCase(); 51 static void TearDownTestCase(); 52 void SetUp() override; 53 void TearDown() override; 54 protected: 55 OH_Drawing_Canvas *canvas_ = nullptr; 56 OH_Drawing_Brush *brush_ = nullptr; 57}; 58 59constexpr uint32_t POINT_PARAMETER = 3; 60constexpr uint32_t COLOR_PARAMETER = 3; 61 62void NativeDrawingCanvasTest::SetUpTestCase() {} 63void NativeDrawingCanvasTest::TearDownTestCase() {} 64void NativeDrawingCanvasTest::SetUp() 65{ 66 canvas_ = OH_Drawing_CanvasCreate(); 67 ASSERT_NE(nullptr, canvas_); 68 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF)); 69 brush_ = OH_Drawing_BrushCreate(); 70 EXPECT_NE(brush_, nullptr); 71 OH_Drawing_BrushSetColor(brush_, 0xffff0000); 72 OH_Drawing_CanvasAttachBrush(canvas_, brush_); 73} 74 75void NativeDrawingCanvasTest::TearDown() 76{ 77 if (canvas_ != nullptr) { 78 OH_Drawing_CanvasDetachBrush(canvas_); 79 OH_Drawing_BrushDestroy(brush_); 80 brush_ = nullptr; 81 OH_Drawing_CanvasDestroy(canvas_); 82 canvas_ = nullptr; 83 } 84} 85 86/* 87 * @tc.name: NativeDrawingCanvasTest_CanvasNULLPTR001 88 * @tc.desc: test for OH_Drawing_CanvasBind. 89 * @tc.size : MediumTest 90 * @tc.type : Function 91 * @tc.level : Level 1 92 */ 93HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasNULLPTR001, TestSize.Level1) 94{ 95 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 96 EXPECT_NE(bitmap, nullptr); 97 OH_Drawing_CanvasBind(nullptr, bitmap); 98 OH_Drawing_BitmapDestroy(bitmap); 99 OH_Drawing_CanvasAttachPen(canvas_, nullptr); 100 OH_Drawing_CanvasTranslate(canvas_, INT32_MIN, INT32_MIN); 101 OH_Drawing_CanvasTranslate(canvas_, INT32_MAX, INT32_MAX); 102 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20); 103 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, INT32_MAX, INT32_MAX); 104 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, INT32_MIN, INT32_MIN); 105 OH_Drawing_Path* path = OH_Drawing_PathCreate(); 106 OH_Drawing_PathMoveTo(path, INT32_MAX, INT32_MIN); 107 OH_Drawing_PathMoveTo(nullptr, 9999, -1000); 108 OH_Drawing_PathClose(nullptr); 109 OH_Drawing_PathClose(path); 110 OH_Drawing_CanvasDrawPath(nullptr, path); 111 OH_Drawing_CanvasDrawPath(canvas_, nullptr); 112 OH_Drawing_PathDestroy(path); 113} 114 115/* 116 * @tc.name: NativeDrawingCanvasTest_CanvasBind002 117 * @tc.desc: test for OH_Drawing_CanvasBind. 118 * @tc.size : MediumTest 119 * @tc.type : Function 120 * @tc.level : Level 1 121 */ 122HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasBind002, TestSize.Level1) 123{ 124 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 125 EXPECT_NE(bitmap, nullptr); 126 OH_Drawing_CanvasBind(canvas_, bitmap); 127 OH_Drawing_BitmapDestroy(bitmap); 128} 129 130/* 131 * @tc.name: NativeDrawingCanvasTest_canvas003 132 * @tc.desc: test for OH_Drawing_CanvasAttachPen & OH_Drawing_CanvasDetachPen. 133 * @tc.size : MediumTest 134 * @tc.type : Function 135 * @tc.level : Level 1 136 */ 137HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_canvas003, TestSize.Level1) 138{ 139 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 140 EXPECT_NE(pen, nullptr); 141 OH_Drawing_CanvasAttachPen(canvas_, pen); 142 OH_Drawing_CanvasDetachPen(canvas_); 143 OH_Drawing_PenDestroy(pen); 144} 145 146/* 147 * @tc.name: NativeDrawingCanvasTest_DrawLine004 148 * @tc.desc: test for OH_Drawing_CanvasDrawLine. 149 * @tc.size : MediumTest 150 * @tc.type : Function 151 * @tc.level : Level 1 152 */ 153HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawLine004, TestSize.Level1) 154{ 155 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, 20, 20); 156 OH_Drawing_CanvasDrawLine(canvas_, -15.2f, -1, 0, 20); 157} 158 159/* 160 * @tc.name: NativeDrawingCanvasTest_DrawPath005 161 * @tc.desc: test for OH_Drawing_CanvasDrawPath. 162 * @tc.size : MediumTest 163 * @tc.type : Function 164 * @tc.level : Level 1 165 */ 166HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPath005, TestSize.Level1) 167{ 168 OH_Drawing_Path* path = OH_Drawing_PathCreate(); 169 EXPECT_NE(path, nullptr); 170 constexpr int height = 300; 171 constexpr int width = 300; 172 constexpr float arc = 18.0f; 173 int len = height / 4; 174 float aX = width / 2; 175 float aY = height / 4; 176 float dX = aX - len * std::sin(arc); 177 float dY = aY + len * std::cos(arc); 178 float cX = aX + len * std::sin(arc); 179 float cY = dY; 180 float bX = aX + (len / 2.0); 181 float bY = aY + std::sqrt((cX - dX) * (cX - dX) + (len / 2.0) * (len / 2.0)); 182 float eX = aX - (len / 2.0); 183 float eY = bY; 184 OH_Drawing_PathMoveTo(path, aX, aY); 185 OH_Drawing_PathLineTo(path, bX, bY); 186 OH_Drawing_PathLineTo(path, cX, cY); 187 OH_Drawing_PathLineTo(path, dX, dY); 188 OH_Drawing_PathLineTo(path, eX, eY); 189 OH_Drawing_PathClose(path); 190 OH_Drawing_CanvasDrawPath(canvas_, path); 191 OH_Drawing_PathDestroy(path); 192} 193 194/* 195 * @tc.name: NativeDrawingCanvasTest_DrawPoints006 196 * @tc.desc: test for OH_Drawing_CanvasDrawPoints. 197 * @tc.size : MediumTest 198 * @tc.type : Function 199 * @tc.level : Level 1 200 */ 201HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPoints006, TestSize.Level1) 202{ 203 OH_Drawing_Point2D pointOne={250, 500}; 204 OH_Drawing_Point2D pointTwo={200, 500}; 205 OH_Drawing_Point2D pointThree={500, 700}; 206 OH_Drawing_Point2D points[POINT_PARAMETER] = {pointOne, pointTwo, pointThree}; 207 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, POINT_PARAMETER, nullptr); 208 OH_Drawing_CanvasDrawPoints(nullptr, POINT_MODE_POINTS, POINT_PARAMETER, nullptr); 209 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, POINT_PARAMETER, points); 210} 211 212/* 213 * @tc.name: NativeDrawingCanvasTest_DrawVertices007 214 * @tc.desc: test for OH_Drawing_CanvasDrawVertices. 215 * @tc.size : MediumTest 216 * @tc.type : Function 217 * @tc.level : Level 1 218 */ 219HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawVertices007, TestSize.Level1) 220{ 221 OH_Drawing_Point2D point_one = {0, 0}; 222 OH_Drawing_Point2D point_two = {100, 100}; 223 OH_Drawing_Point2D point_three = {300, 100}; 224 OH_Drawing_Point2D points_vertices[POINT_PARAMETER] = {point_one, point_two, point_three}; 225 226 OH_Drawing_Point2D texs_one = {0, 0}; 227 OH_Drawing_Point2D texs_two = {1, 1}; 228 OH_Drawing_Point2D texs_three = {2, 0}; 229 OH_Drawing_Point2D texs_vertices[POINT_PARAMETER] = {texs_one, texs_two, texs_three}; 230 uint32_t colors[COLOR_PARAMETER] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 231 232 uint16_t indices[COLOR_PARAMETER] = {0, 1, 2}; 233 OH_Drawing_CanvasDrawVertices(nullptr, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices, 234 colors, POINT_PARAMETER, indices, BLEND_MODE_COLOR); 235 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, nullptr, texs_vertices, colors, 236 POINT_PARAMETER, indices, BLEND_MODE_COLOR); 237 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, nullptr, colors, 238 POINT_PARAMETER, indices, BLEND_MODE_COLOR); 239 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices, 240 nullptr, POINT_PARAMETER, indices, BLEND_MODE_COLOR); 241 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices, 242 colors, POINT_PARAMETER, nullptr, BLEND_MODE_COLOR); 243 OH_Drawing_CanvasDrawVertices(nullptr, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, nullptr, nullptr, nullptr, 244 POINT_PARAMETER, nullptr, BLEND_MODE_COLOR); 245 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices, 246 colors, POINT_PARAMETER, indices, BLEND_MODE_COLOR); 247} 248 249/* 250 * @tc.name: NativeDrawingCanvasTest_SaveAndRestore008 251 * @tc.desc: test for OH_Drawing_CanvasSave & OH_Drawing_CanvasRestore. 252 * @tc.size : MediumTest 253 * @tc.type : Function 254 * @tc.level : Level 1 255 */ 256HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveAndRestore008, TestSize.Level1) 257{ 258 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300); 259 EXPECT_NE(nullptr, rect); 260 OH_Drawing_CanvasSave(nullptr); 261 OH_Drawing_CanvasSave(canvas_); 262 OH_Drawing_CanvasTranslate(nullptr, 100, 100); 263 OH_Drawing_CanvasTranslate(canvas_, 100, 100); 264 OH_Drawing_CanvasDrawArc(nullptr, rect, 10, 200); 265 OH_Drawing_CanvasDrawArc(canvas_, nullptr, 10, 200); 266 OH_Drawing_CanvasDrawArc(canvas_, rect, 10, 200); 267 OH_Drawing_CanvasRestore(nullptr); 268 OH_Drawing_CanvasRestore(canvas_); 269 OH_Drawing_CanvasTranslate(canvas_, 200, 200); 270 OH_Drawing_CanvasDrawOval(nullptr, rect); 271 OH_Drawing_CanvasDrawOval(canvas_, nullptr); 272 OH_Drawing_CanvasDrawOval(canvas_, rect); 273 OH_Drawing_RectDestroy(nullptr); 274 OH_Drawing_RectDestroy(rect); 275} 276 277/* 278 * @tc.name: NativeDrawingCanvasTest_Clear009 279 * @tc.desc: test for OH_Drawing_CanvasClear. 280 * @tc.size : MediumTest 281 * @tc.type : Function 282 * @tc.level : Level 1 283 */ 284HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Clear009, TestSize.Level1) 285{ 286 OH_Drawing_CanvasClear(nullptr, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 287 OH_Drawing_CanvasClear(canvas_, -100); 288 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN)); 289 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 290} 291 292/* 293 * @tc.name: NativeDrawingCanvasTest_RestoreToCount010 294 * @tc.desc: test for OH_Drawing_CanvasRestoreToCount. 295 * @tc.size : MediumTest 296 * @tc.type : Function 297 * @tc.level : Level 1 298 */ 299HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RestoreToCount010, TestSize.Level1) 300{ 301 OH_Drawing_CanvasSave(canvas_); 302 OH_Drawing_CanvasTranslate(canvas_, 300, 300); 303 OH_Drawing_CanvasSave(canvas_); 304 OH_Drawing_CanvasTranslate(canvas_, 100, 100); 305 OH_Drawing_CanvasSave(canvas_); 306 OH_Drawing_CanvasTranslate(canvas_, 100, 100); 307 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 308 OH_Drawing_CanvasDrawRect(canvas_, rect); 309 int count = OH_Drawing_CanvasGetSaveCount(canvas_); 310 EXPECT_EQ(count, 4); 311 OH_Drawing_CanvasRestoreToCount(nullptr, count - 2); 312 OH_Drawing_CanvasRestoreToCount(canvas_, count - 2); 313 EXPECT_EQ(2, OH_Drawing_CanvasGetSaveCount(canvas_)); 314 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(nullptr, 20, 20); 315 EXPECT_EQ(roundRect, nullptr); 316 roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 317 EXPECT_NE(roundRect, nullptr); 318 OH_Drawing_CanvasDrawRoundRect(nullptr, roundRect); 319 OH_Drawing_CanvasDrawRoundRect(canvas_, nullptr); 320 OH_Drawing_CanvasDrawRoundRect(canvas_, roundRect); 321 OH_Drawing_CanvasRestoreToCount(canvas_, 1); 322 OH_Drawing_CanvasDrawRect(canvas_, rect); 323 OH_Drawing_RoundRectDestroy(roundRect); 324 OH_Drawing_RectDestroy(rect); 325 OH_Drawing_RoundRectDestroy(nullptr); 326 OH_Drawing_RectDestroy(nullptr); 327} 328 329/* 330 * @tc.name: NativeDrawingCanvasTest_Scale011 331 * @tc.desc: test for OH_Drawing_CanvasScale. 332 * @tc.size : MediumTest 333 * @tc.type : Function 334 * @tc.level : Level 1 335 */ 336HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Scale011, TestSize.Level1) 337{ 338 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 20, 60, 120); 339 OH_Drawing_CanvasTranslate(canvas_, 20, 20); 340 OH_Drawing_CanvasDrawRect(canvas_, rect); 341 OH_Drawing_CanvasScale(nullptr, 2, .5f); 342 OH_Drawing_CanvasScale(canvas_, 2, .5f); 343 OH_Drawing_BrushSetColor(nullptr, 0xFF67C23A); 344 OH_Drawing_BrushSetColor(brush_, 0xFF67C23A); 345 OH_Drawing_CanvasDrawRect(canvas_, rect); 346} 347/* 348 * @tc.name : NativeDrawingCanvasTest_Skew012 349 * @tc.desc : test for OH_Drawing_CanvasSkew. 350 * @tc.size : MediumTest 351 * @tc.type : Function 352 * @tc.level : Level 1 353 */ 354HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Skew012, TestSize.Level1) 355{ 356 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 100, 300, 300); 357 ASSERT_NE(rect, nullptr); 358 OH_Drawing_CanvasSkew(nullptr, 0, 0.3f); 359 OH_Drawing_BrushSetColor(brush_, 0xFF67C23A); 360 OH_Drawing_CanvasSkew(canvas_, 0, 0.3f); 361 OH_Drawing_CanvasDrawRect(canvas_, rect); 362 363 OH_Drawing_Matrix* matrixSkew= OH_Drawing_MatrixCreate(); 364 OH_Drawing_MatrixReset(matrixSkew); 365 Matrix* cMatrix = reinterpret_cast<Matrix*>(matrixSkew); 366 EXPECT_NE(cMatrix, nullptr); 367 cMatrix->SetSkew(0, 0.3f); 368 369 OH_Drawing_Matrix* matrixTotal = OH_Drawing_MatrixCreate(); 370 OH_Drawing_CanvasGetTotalMatrix(canvas_, nullptr); 371 OH_Drawing_CanvasGetTotalMatrix(nullptr, matrixTotal); 372 float valueMatrixSkew; 373 float valueCanvasSkew; 374 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 0); 375 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 0); 376 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 377 378 OH_Drawing_CanvasGetTotalMatrix(canvas_, matrixTotal); 379 EXPECT_NE(matrixTotal, nullptr); 380 381 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 0); 382 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 0); 383 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 384 385 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 1); 386 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 1); 387 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 388 389 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 2); 390 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 2); 391 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 392 393 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 3); 394 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 3); 395 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 396 397 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 4); 398 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 4); 399 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 400 401 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 5); 402 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 5); 403 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 404 405 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 6); 406 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 6); 407 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 408 409 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 7); 410 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 7); 411 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 412 413 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 8); 414 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 8); 415 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew)); 416 417 OH_Drawing_RectDestroy(rect); 418 OH_Drawing_MatrixDestroy(matrixSkew); 419 OH_Drawing_MatrixDestroy(matrixTotal); 420} 421/* 422 * @tc.name: NativeDrawingCanvasTest_ClipRect013 423 * @tc.desc: test for OH_Drawing_CanvasClipRect. 424 * @tc.size : MediumTest 425 * @tc.type : Function 426 * @tc.level : Level 1 427 */ 428HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRect013, TestSize.Level1) 429{ 430 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 90, 90); 431 OH_Drawing_CanvasRotate(nullptr, 10, 0, 0); 432 OH_Drawing_CanvasRotate(canvas_, 10, 0, 0); 433 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 60); 434 OH_Drawing_BrushSetAntiAlias(nullptr, true); 435 OH_Drawing_BrushSetAntiAlias(brush_, true); 436 for (auto alias : {false, true}) { 437 OH_Drawing_CanvasSave(canvas_); 438 OH_Drawing_CanvasClipRect(nullptr, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias); 439 OH_Drawing_CanvasClipRect(canvas_, nullptr, OH_Drawing_CanvasClipOp::INTERSECT, alias); 440 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias); 441 OH_Drawing_CanvasDrawCircle(canvas_, nullptr, 60); 442 OH_Drawing_CanvasDrawCircle(nullptr, point, 60); 443 OH_Drawing_CanvasDrawCircle(canvas_, point, 60); 444 OH_Drawing_CanvasRestore(canvas_); 445 OH_Drawing_CanvasTranslate(canvas_, 80, 0); 446 } 447 OH_Drawing_RectDestroy(rect); 448 OH_Drawing_PointDestroy(point); 449} 450 451/* 452 * @tc.name: NativeDrawingCanvasTest_ClipPath014 453 * @tc.desc: test for OH_Drawing_CanvasClipPath. 454 * @tc.size : MediumTest 455 * @tc.type : Function 456 * @tc.level : Level 1 457 */ 458HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipPath014, TestSize.Level1) 459{ 460 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 461 OH_Drawing_PathMoveTo(path, 100, 300); 462 OH_Drawing_PathLineTo(path, 200, 300); 463 OH_Drawing_PathLineTo(path, 200, 400); 464 OH_Drawing_PathLineTo(path, 100, 350); 465 OH_Drawing_PathClose(nullptr); 466 OH_Drawing_PathClose(path); 467 OH_Drawing_CanvasClipPath(nullptr, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 468 OH_Drawing_CanvasClipPath(canvas_, nullptr, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 469 OH_Drawing_CanvasClipPath(canvas_, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 470 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 300, 200, 400); 471 OH_Drawing_CanvasDrawRect(canvas_, rect); 472 OH_Drawing_RectDestroy(rect); 473 OH_Drawing_PathDestroy(path); 474} 475 476/* 477 * @tc.name: NativeDrawingCanvasTest_LinearGradient015 478 * @tc.desc: test for LinearGradient 479 * @tc.size : MediumTest 480 * @tc.type : Function 481 * @tc.level : Level 1 482 */ 483HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_LinearGradient015, TestSize.Level1) 484{ 485 OH_Drawing_Point* startPt = OH_Drawing_PointCreate(100, 400); 486 OH_Drawing_Point* endPt = OH_Drawing_PointCreate(200, 500); 487 uint32_t color[] = {0xffff0000, 0xff00ff00}; 488 float pos[] = {0., 1.0}; 489 OH_Drawing_ShaderEffect* linearGradient = OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, 490 color, pos, 2, OH_Drawing_TileMode::CLAMP); 491 OH_Drawing_BrushSetShaderEffect(nullptr, linearGradient); 492 OH_Drawing_BrushSetShaderEffect(brush_, nullptr); 493 OH_Drawing_BrushSetShaderEffect(brush_, linearGradient); 494 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600); 495 OH_Drawing_CanvasDrawRect(canvas_, rect); 496 OH_Drawing_RectDestroy(rect); 497 OH_Drawing_ShaderEffectDestroy(nullptr); 498 OH_Drawing_ShaderEffectDestroy(linearGradient); 499 OH_Drawing_PointDestroy(startPt); 500 OH_Drawing_PointDestroy(endPt); 501} 502 503/* 504 * @tc.name: NativeDrawingCanvasTest_SweepGradient016 505 * @tc.desc: test for sweep gradient shader effect 506 * @tc.size : MediumTest 507 * @tc.type : Function 508 * @tc.level : Level 1 509 */ 510HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SweepGradient016, TestSize.Level1) 511{ 512 OH_Drawing_Point* centerPt = OH_Drawing_PointCreate(350, 450); 513 uint32_t colors[] = {0xffff00ff, 0xff00ff00}; 514 float pos[] = {0., 1.0}; 515 OH_Drawing_ShaderEffect* sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(nullptr, nullptr, 516 nullptr, -2, OH_Drawing_TileMode::MIRROR); 517 EXPECT_EQ(sweepGradient, nullptr); 518 sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, 519 pos, 2, OH_Drawing_TileMode::MIRROR); 520 EXPECT_NE(sweepGradient, nullptr); 521 OH_Drawing_BrushSetShaderEffect(brush_, sweepGradient); 522 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500); 523 OH_Drawing_CanvasDrawRect(canvas_, rect); 524 OH_Drawing_RectDestroy(rect); 525 OH_Drawing_ShaderEffectDestroy(sweepGradient); 526 OH_Drawing_PointDestroy(centerPt); 527} 528/* 529 * @tc.name: NativeDrawingCanvasTest_ImageShader017 530 * @tc.desc: test for image shader effect 531 * @tc.size : MediumTest 532 * @tc.type : Function 533 * @tc.level : Level 1 534 */ 535HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageShader017, TestSize.Level1) 536{ 537 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 538 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 539 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0x00)); 540 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR); 541 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 542 OH_Drawing_ShaderEffect *effect = nullptr; 543 effect = OH_Drawing_ShaderEffectCreateImageShader(nullptr, CLAMP, CLAMP, nullptr, nullptr); 544 EXPECT_EQ(effect, nullptr); 545 effect = OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, options, matrix); 546 OH_Drawing_BrushSetShaderEffect(brush, effect); 547 OH_Drawing_CanvasAttachBrush(canvas_, brush); 548 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500); 549 OH_Drawing_CanvasDrawRect(canvas_, rect); 550 OH_Drawing_RectDestroy(rect); 551 OH_Drawing_ShaderEffectDestroy(effect); 552 OH_Drawing_MatrixDestroy(matrix); 553 OH_Drawing_SamplingOptionsDestroy(options); 554 OH_Drawing_BrushDestroy(brush); 555 OH_Drawing_ImageDestroy(image); 556} 557 558/* 559 * @tc.name: NativeDrawingCanvasTest_RadialGradient 560 * @tc.desc: test for Radial gradient shader effect 561 * @tc.size : MediumTest 562 * @tc.type : Function 563 * @tc.level : Level 1 564 */ 565HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RadialGradient, TestSize.Level1) 566{ 567 OH_Drawing_Point* centerPt = OH_Drawing_PointCreate(350, 450); 568 uint32_t colors[] = {0xffff00ff, 0xff00ff00}; 569 float pos[] = {0., 1.0}; 570 OH_Drawing_ShaderEffect* radialGradient = OH_Drawing_ShaderEffectCreateRadialGradient(nullptr, 20, 571 nullptr, nullptr, -2, OH_Drawing_TileMode::MIRROR); 572 EXPECT_EQ(radialGradient, nullptr); 573 radialGradient = OH_Drawing_ShaderEffectCreateRadialGradient(centerPt, 30, colors, 574 pos, 2, OH_Drawing_TileMode::MIRROR); 575 EXPECT_NE(radialGradient, nullptr); 576 OH_Drawing_BrushSetShaderEffect(brush_, radialGradient); 577 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500); 578 OH_Drawing_CanvasDrawRect(canvas_, rect); 579 OH_Drawing_RectDestroy(rect); 580 OH_Drawing_ShaderEffectDestroy(radialGradient); 581 OH_Drawing_PointDestroy(centerPt); 582} 583 584/* 585 * @tc.name: NativeDrawingCanvasTest_MaskFilter018 586 * @tc.desc: test for maskfilter 587 * @tc.size : MediumTest 588 * @tc.type : Function 589 * @tc.level : Level 1 590 */ 591HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_MaskFilter018, TestSize.Level1) 592{ 593 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000); 594 OH_Drawing_MaskFilter* maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true); 595 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate(); 596 OH_Drawing_FilterSetMaskFilter(nullptr, maskFilter); 597 OH_Drawing_FilterSetMaskFilter(filter, nullptr); 598 OH_Drawing_FilterSetMaskFilter(filter, maskFilter); 599 OH_Drawing_BrushSetFilter(brush_, filter); 600 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600); 601 OH_Drawing_CanvasDrawRect(canvas_, rect); 602 OH_Drawing_RectDestroy(rect); 603 OH_Drawing_MaskFilterDestroy(maskFilter); 604 OH_Drawing_FilterDestroy(filter); 605} 606 607/* 608 * @tc.name: NativeDrawingCanvasTest_ColorFilter019 609 * @tc.desc: test for colorfilter create blend mode, linear to srgb gamma, luma, matrix 610 * @tc.size : MediumTest 611 * @tc.type : Function 612 * @tc.level : Level 1 613 */ 614HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateBlendMode019, TestSize.Level1) 615{ 616 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000); 617 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xff0000ff, 618 OH_Drawing_BlendMode::BLEND_MODE_SRC); 619 EXPECT_NE(colorFilter, nullptr); 620 OH_Drawing_ColorFilter* colorFilterTmp = OH_Drawing_ColorFilterCreateLinearToSrgbGamma(); 621 EXPECT_NE(colorFilterTmp, nullptr); 622 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate(); 623 EXPECT_NE(filter, nullptr); 624 625 OH_Drawing_FilterSetColorFilter(nullptr, colorFilter); 626 OH_Drawing_FilterSetColorFilter(filter, nullptr); 627 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp); 628 EXPECT_EQ(reinterpret_cast<ColorFilter*>(colorFilterTmp)->GetType(), ColorFilter::FilterType::NO_TYPE); 629 630 OH_Drawing_FilterSetColorFilter(filter, colorFilter); 631 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp); 632 EXPECT_EQ(reinterpret_cast<ColorFilter*>(colorFilterTmp)->GetType(), ColorFilter::FilterType::BLEND_MODE); 633 634 OH_Drawing_BrushSetFilter(brush_, nullptr); 635 OH_Drawing_BrushSetFilter(brush_, filter); 636 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 637 OH_Drawing_CanvasDrawRect(canvas_, rect); 638 OH_Drawing_ColorFilter* linear = OH_Drawing_ColorFilterCreateLinearToSrgbGamma(); 639 OH_Drawing_FilterSetColorFilter(filter, linear); 640 OH_Drawing_CanvasTranslate(canvas_, 100, 100); 641 OH_Drawing_CanvasDrawRect(canvas_, rect); 642 OH_Drawing_ColorFilter* luma = OH_Drawing_ColorFilterCreateLuma(); 643 OH_Drawing_FilterSetColorFilter(filter, luma); 644 OH_Drawing_CanvasTranslate(canvas_, 200, 200); 645 OH_Drawing_CanvasDrawRect(canvas_, rect); 646 const float matrix[20] = { 647 1, 0, 0, 0, 0, 648 0, 1, 0, 0, 0, 649 0, 0, 1, 0, 0, 650 0, 0, 0, 0.5f, 0 651 }; 652 OH_Drawing_ColorFilter* matrixFilter = OH_Drawing_ColorFilterCreateMatrix(nullptr); 653 EXPECT_EQ(matrixFilter, nullptr); 654 matrixFilter = OH_Drawing_ColorFilterCreateMatrix(matrix); 655 EXPECT_NE(matrixFilter, nullptr); 656 OH_Drawing_FilterSetColorFilter(filter, matrixFilter); 657 OH_Drawing_CanvasTranslate(canvas_, 300, 300); 658 OH_Drawing_CanvasDrawRect(canvas_, rect); 659 OH_Drawing_RectDestroy(rect); 660 OH_Drawing_ColorFilterDestroy(colorFilter); 661 OH_Drawing_ColorFilterDestroy(luma); 662 OH_Drawing_ColorFilterDestroy(matrixFilter); 663 OH_Drawing_ColorFilterDestroy(linear); 664 OH_Drawing_ColorFilterDestroy(colorFilterTmp); 665 OH_Drawing_FilterDestroy(filter); 666 OH_Drawing_FilterDestroy(nullptr); 667} 668 669/* 670 * @tc.name: NativeDrawingCanvasTest_ColorFilterCreateCompose020 671 * @tc.desc: test for create compose color filter 672 * @tc.size : MediumTest 673 * @tc.type : Function 674 * @tc.level : Level 1 675 */ 676HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateCompose020, TestSize.Level1) 677{ 678 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000); 679 OH_Drawing_ColorFilter* outerFilter = OH_Drawing_ColorFilterCreateLuma(); 680 OH_Drawing_ColorFilter* innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear(); 681 OH_Drawing_ColorFilter* compose = OH_Drawing_ColorFilterCreateCompose(nullptr, nullptr); 682 EXPECT_EQ(compose, nullptr); 683 compose = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter); 684 EXPECT_NE(compose, nullptr); 685 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate(); 686 OH_Drawing_FilterSetColorFilter(filter, compose); 687 OH_Drawing_BrushSetFilter(brush_, filter); 688 OH_Drawing_Canvas* canvas_ = OH_Drawing_CanvasCreate(); 689 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600); 690 OH_Drawing_CanvasDrawRect(canvas_, rect); 691 OH_Drawing_RectDestroy(rect); 692 OH_Drawing_ColorFilterDestroy(outerFilter); 693 OH_Drawing_ColorFilterDestroy(innerFilter); 694 OH_Drawing_ColorFilterDestroy(compose); 695 OH_Drawing_FilterDestroy(filter); 696} 697 698/* 699 * @tc.name: NativeDrawingCanvasTest_DrawBitmap021 700 * @tc.desc: test for DrawBitmap 701 * @tc.size : MediumTest 702 * @tc.type : Function 703 * @tc.level : Level 1 704 */ 705HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmap021, TestSize.Level1) 706{ 707 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 708 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 709 constexpr uint32_t width = 200; 710 constexpr uint32_t height = 200; 711 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 712 OH_Drawing_CanvasBind(canvas_, bitmap); 713 OH_Drawing_CanvasDrawBitmap(canvas_, bitmap, 0, 0); 714 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF)); 715 OH_Drawing_BitmapDestroy(bitmap); 716} 717/* 718 * @tc.name: NativeDrawingCanvasTest_DrawBitmapRect022 719 * @tc.desc: test for DrawBitmapRect 720 * @tc.size : MediumTest 721 * @tc.type : Function 722 * @tc.level : Level 1 723 */ 724HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmapRect022, TestSize.Level1) 725{ 726 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 727 EXPECT_NE(bitmap, nullptr); 728 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 729 constexpr uint32_t width = 200; 730 constexpr uint32_t height = 200; 731 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 732 OH_Drawing_Rect* src = OH_Drawing_RectCreate(0, 0, 200, 200); 733 EXPECT_NE(src, nullptr); 734 OH_Drawing_Rect* dst = OH_Drawing_RectCreate(0, 0, 200, 200); 735 EXPECT_NE(dst, nullptr); 736 OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate( 737 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 738 EXPECT_NE(options, nullptr); 739 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, options); 740 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, nullptr); 741 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, nullptr, nullptr); 742 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, nullptr, nullptr, nullptr); 743 OH_Drawing_CanvasDrawBitmapRect(canvas_, nullptr, nullptr, nullptr, nullptr); 744 OH_Drawing_CanvasDrawBitmapRect(nullptr, nullptr, nullptr, nullptr, nullptr); 745 OH_Drawing_BitmapDestroy(bitmap); 746} 747 748/* 749 * @tc.name: NativeDrawingCanvasTest_SetMatrix023 750 * @tc.desc: test for SetMatrix 751 * @tc.size : MediumTest 752 * @tc.type : Function 753 * @tc.level : Level 1 754 */ 755HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SetMatrix023, TestSize.Level1) 756{ 757 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate(); 758 EXPECT_NE(matrix, nullptr); 759 OH_Drawing_MatrixSetMatrix( 760 matrix, 761 1, 0, 0, 762 0, -1, 0, 763 0, 0, 1); 764 OH_Drawing_CanvasSetMatrix(canvas_, matrix); 765 OH_Drawing_CanvasSetMatrix(canvas_, nullptr); 766 OH_Drawing_CanvasSetMatrix(nullptr, nullptr); 767 OH_Drawing_MatrixDestroy(matrix); 768} 769 770/* 771 * @tc.name: NativeDrawingCanvasTest_ResetMatrix024 772 * @tc.desc: test for ResetMatrix 773 * @tc.size : MediumTest 774 * @tc.type : Function 775 * @tc.level : Level 1 776 */ 777HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ResetMatrix024, TestSize.Level1) 778{ 779 OH_Drawing_CanvasResetMatrix(nullptr); 780 OH_Drawing_CanvasResetMatrix(canvas_); 781} 782 783/* 784 * @tc.name: NativeDrawingCanvasTest_DrawImageRect025 785 * @tc.desc: test for DrawImageRect 786 * @tc.size : MediumTest 787 * @tc.type : Function 788 * @tc.level : Level 1 789 */ 790HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawImageRect025, TestSize.Level1) 791{ 792 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 200, 200); 793 EXPECT_NE(rect, nullptr); 794 OH_Drawing_Image* image = OH_Drawing_ImageCreate(); 795 EXPECT_NE(image, nullptr); 796 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 797 EXPECT_NE(bitmap, nullptr); 798 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 799 constexpr uint32_t width = 200; 800 constexpr uint32_t height = 200; 801 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 802 OH_Drawing_ImageBuildFromBitmap(image, bitmap); 803 OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate( 804 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 805 EXPECT_NE(options, nullptr); 806 OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, options); 807 OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, nullptr); 808 OH_Drawing_CanvasDrawImageRect(canvas_, image, nullptr, nullptr); 809 OH_Drawing_CanvasDrawImageRect(canvas_, nullptr, nullptr, nullptr); 810 OH_Drawing_CanvasDrawImageRect(nullptr, nullptr, nullptr, nullptr); 811 OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, image, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT); 812 OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, nullptr, nullptr, nullptr, nullptr, STRICT_SRC_RECT_CONSTRAINT); 813 OH_Drawing_SamplingOptionsDestroy(options); 814 OH_Drawing_BitmapDestroy(bitmap); 815 OH_Drawing_ImageDestroy(image); 816} 817 818/* 819 * @tc.name: NativeDrawingCanvasTest_ReadPixelsToBitmap026 820 * @tc.desc: test for ReadPixelsToBitmap 821 * @tc.size : MediumTest 822 * @tc.type : Function 823 * @tc.level : Level 1 824 */ 825HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixelsToBitmap026, TestSize.Level1) 826{ 827 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 828 EXPECT_NE(bitmap, nullptr); 829 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(canvas_, bitmap, 100, 100)); 830 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(canvas_, nullptr, 100, 100)); 831 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(nullptr, nullptr, 100, 100)); 832 OH_Drawing_BitmapDestroy(bitmap); 833} 834 835/* 836 * @tc.name: NativeDrawingCanvasTest_ReadPixels027 837 * @tc.desc: test for ReadPixels 838 * @tc.size : MediumTest 839 * @tc.type : Function 840 * @tc.level : Level 1 841 */ 842HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixels027, TestSize.Level1) 843{ 844 OH_Drawing_Image_Info imageInfo; 845 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 846 EXPECT_NE(bitmap, nullptr); 847 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 848 constexpr uint32_t width = 200; 849 constexpr uint32_t height = 200; 850 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 851 void* pixels = OH_Drawing_BitmapGetPixels(bitmap); 852 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, pixels, 0, 0, 0)); 853 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, nullptr, 0, 0, 0)); 854 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, nullptr, nullptr, 0, 0, 0)); 855 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(nullptr, nullptr, nullptr, 0, 0, 0)); 856 OH_Drawing_BitmapDestroy(bitmap); 857} 858 859/* 860 * @tc.name: NativeDrawingCanvasTest_GetWidth028 861 * @tc.desc: test for GetWidth 862 * @tc.size : MediumTest 863 * @tc.type : Function 864 * @tc.level : Level 1 865 */ 866HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetWidth028, TestSize.Level1) 867{ 868 EXPECT_TRUE(OH_Drawing_CanvasGetWidth(nullptr) == 0); 869 EXPECT_TRUE(OH_Drawing_CanvasGetWidth(canvas_) >= 0); 870} 871 872/* 873 * @tc.name: NativeDrawingCanvasTest_GetHeight029 874 * @tc.desc: test for GetHeight 875 * @tc.size : MediumTest 876 * @tc.type : Function 877 * @tc.level : Level 1 878 */ 879HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetHeight029, TestSize.Level1) 880{ 881 EXPECT_TRUE(OH_Drawing_CanvasGetHeight(nullptr) == 0); 882 EXPECT_TRUE(OH_Drawing_CanvasGetHeight(canvas_) >= 0); 883} 884 885/* 886 * @tc.name: NativeDrawingCanvasTest_GetLocalClipBounds030 887 * @tc.desc: test for GetLocalClipBounds 888 * @tc.size : MediumTest 889 * @tc.type : Function 890 * @tc.level : Level 1 891 */ 892HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetLocalClipBounds030, TestSize.Level1) 893{ 894 OH_Drawing_CanvasGetLocalClipBounds(nullptr, nullptr); 895 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 1, 1); 896 EXPECT_NE(rect, nullptr); 897 OH_Drawing_CanvasGetLocalClipBounds(nullptr, rect); 898 OH_Drawing_CanvasGetLocalClipBounds(canvas_, rect); 899 OH_Drawing_RectDestroy(rect); 900} 901 902/* 903 * @tc.name: NativeDrawingCanvasTest_ConcatMatrix031 904 * @tc.desc: test for ConcatMatrix 905 * @tc.size : MediumTest 906 * @tc.type : Function 907 * @tc.level : Level 1 908 */ 909HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ConcatMatrix031, TestSize.Level1) 910{ 911 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate(); 912 EXPECT_NE(matrix, nullptr); 913 OH_Drawing_MatrixSetMatrix( 914 matrix, 915 1, 0, 0, 916 0, -1, 0, 917 0, 0, 1); 918 OH_Drawing_CanvasConcatMatrix(canvas_, matrix); 919 OH_Drawing_CanvasConcatMatrix(canvas_, nullptr); 920 OH_Drawing_CanvasConcatMatrix(nullptr, nullptr); 921 OH_Drawing_MatrixDestroy(matrix); 922} 923 924/* 925 * @tc.name: NativeDrawingCanvasTest_DrawShadow032 926 * @tc.desc: test for DrawShadow 927 * @tc.size : MediumTest 928 * @tc.type : Function 929 * @tc.level : Level 1 930 */ 931HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawShadow032, TestSize.Level1) 932{ 933 OH_Drawing_Point3D p1{0.0, 0.0, 0.0}; 934 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 935 OH_Drawing_CanvasDrawShadow(nullptr, nullptr, p1, p2, 0, 0xFF000000, 936 0xFF000000, OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL); 937 938 OH_Drawing_Path* path = OH_Drawing_PathCreate(); 939 EXPECT_NE(path, nullptr); 940 OH_Drawing_CanvasDrawShadow(canvas_, path, p1, p2, 10, 0xFF000000, 0xFF000000, 941 OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL); 942} 943/* 944 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob033 945 * @tc.desc: test for DrawTextBlob 946 * @tc.size : MediumTest 947 * @tc.type : Function 948 * @tc.level : Level 1 949 */ 950HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob033, TestSize.Level1) 951{ 952 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 953 OH_Drawing_FontSetFakeBoldText(font, true); 954 OH_Drawing_FontSetTextSize(font, 20); 955 OH_Drawing_FontSetTextSkewX(font, 0.25); 956 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 957 OH_Drawing_FontSetTypeface(font, typeSurface); 958 auto *builder = OH_Drawing_TextBlobBuilderCreate(); 959 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(nullptr, nullptr, INT32_MAX, nullptr)); 960 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, INT32_MIN, nullptr)); 961 const OH_Drawing_RunBuffer* runBuffer = OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, nullptr); 962 ASSERT_NE(runBuffer, nullptr); 963 runBuffer->glyphs[0] = 65; 964 runBuffer->pos[0] = 0; 965 runBuffer->pos[1] = 0; 966 runBuffer->glyphs[1] = 227; 967 runBuffer->pos[2] = 14.9; 968 runBuffer->pos[3] = 0; 969 runBuffer->glyphs[2] = 283; 970 runBuffer->pos[4] = 25.84; 971 runBuffer->pos[5] = 0; 972 runBuffer->glyphs[3] = 283; 973 runBuffer->pos[6] = 30.62; 974 runBuffer->pos[7] = 0; 975 runBuffer->glyphs[4] = 299; 976 runBuffer->pos[8] = 35.4; 977 runBuffer->pos[9] = 0; 978 runBuffer->glyphs[5] = 2; 979 runBuffer->pos[10] = 47.22; 980 runBuffer->pos[11] = 0; 981 runBuffer->glyphs[6]= 94; 982 runBuffer->pos[12] = 52.62; 983 runBuffer->pos[13] = 0; 984 runBuffer->glyphs[7] = 37; 985 runBuffer->pos[14] = 67.42; 986 runBuffer->pos[15] = 0; 987 runBuffer->glyphs[8] = 84; 988 runBuffer->pos[16] = 81.7; 989 runBuffer->pos[17] = 0; 990 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobBuilderMake(builder); 991 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 100, 700); 992 OH_Drawing_TextBlobDestroy(textBlob); 993 OH_Drawing_TextBlobBuilderDestroy(builder); 994 OH_Drawing_FontDestroy(font); 995 OH_Drawing_TypefaceDestroy(typeSurface); 996 OH_Drawing_TextBlobDestroy(nullptr); 997 OH_Drawing_TextBlobBuilderDestroy(nullptr); 998 OH_Drawing_FontDestroy(nullptr); 999 OH_Drawing_TypefaceDestroy(nullptr); 1000} 1001 1002/* 1003 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob034 1004 * @tc.desc: test for DrawTextBlob2 1005 * @tc.size : MediumTest 1006 * @tc.type : Function 1007 * @tc.level : Level 1 1008 */ 1009HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob034, TestSize.Level1) 1010{ 1011 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0); 1012 EXPECT_NE(rect, nullptr); 1013 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1014 EXPECT_NE(font, nullptr); 1015 const char* str = "123456"; 1016 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromString(nullptr, 1017 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8)); 1018 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromString(str, 1019 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8)); 1020 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromString(str, 1021 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 1022 EXPECT_NE(textBlob, nullptr); 1023 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0); 1024 OH_Drawing_TextBlobGetBounds(textBlob, nullptr); 1025 OH_Drawing_TextBlobGetBounds(textBlob, rect); 1026 OH_Drawing_CanvasDrawRect(canvas_, rect); 1027 OH_Drawing_TextBlobDestroy(textBlob); 1028 OH_Drawing_FontDestroy(font); 1029 OH_Drawing_RectDestroy(rect); 1030} 1031 1032/* 1033 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob035 1034 * @tc.desc: test for DrawTextBlob3 1035 * @tc.size : MediumTest 1036 * @tc.type : Function 1037 * @tc.level : Level 1 1038 */ 1039HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob035, TestSize.Level1) 1040{ 1041 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0); 1042 EXPECT_NE(rect, nullptr); 1043 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1044 EXPECT_NE(font, nullptr); 1045 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromFile(nullptr, 0); 1046 EXPECT_EQ(nullptr, typeface); 1047 // sub test 1, OH_Drawing_FontGetTypeface 1048 OH_Drawing_FontGetTypeface(nullptr); 1049 EXPECT_EQ(nullptr, typeface); 1050 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 1051 OH_Drawing_FontSetTypeface(font, typeSurface); 1052 EXPECT_NE(nullptr, OH_Drawing_FontGetTypeface(font)); 1053 // sub test 2, OH_Drawing_FontCountText 1054 const char* str = "123456"; 1055 int count = 0; 1056 count = OH_Drawing_FontCountText(nullptr, str, strlen(str), 1057 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 1058 EXPECT_EQ(0, count); 1059 count = OH_Drawing_FontCountText(font, nullptr, strlen(str), 1060 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 1061 EXPECT_EQ(0, count); 1062 count = OH_Drawing_FontCountText(font, str, strlen(str), 1063 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 1064 EXPECT_EQ(strlen(str), count); 1065 // sub test 3, OH_Drawing_TextBlobCreateFromText 1066 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromText(nullptr, strlen(str), 1067 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8)); 1068 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromText(str, strlen(str), 1069 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8)); 1070 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromText(str, strlen(str), 1071 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 1072 EXPECT_NE(textBlob, nullptr); 1073 EXPECT_TRUE(OH_Drawing_TextBlobUniqueID(nullptr) == 0); 1074 EXPECT_TRUE(OH_Drawing_TextBlobUniqueID(textBlob) > 0); 1075 // draw textblob 1076 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0); 1077 1078 OH_Drawing_TextBlobDestroy(textBlob); 1079 OH_Drawing_FontDestroy(font); 1080 OH_Drawing_TypefaceDestroy(typeSurface); 1081} 1082 1083/* 1084 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob036 1085 * @tc.desc: test for DrawTextBlob4 1086 * @tc.size : MediumTest 1087 * @tc.type : Function 1088 * @tc.level : Level 1 1089 */ 1090HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob036, TestSize.Level1) 1091{ 1092 size_t length = 1; 1093 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1094 EXPECT_NE(font, nullptr); 1095 OH_Drawing_MemoryStream* memoryStream = OH_Drawing_MemoryStreamCreate(nullptr, 1096 length, false); 1097 OH_Drawing_MemoryStreamDestroy(memoryStream); 1098 EXPECT_EQ(nullptr, memoryStream); 1099 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromStream( 1100 memoryStream, 0); 1101 EXPECT_EQ(nullptr, typeface); 1102 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 1103 OH_Drawing_FontSetTypeface(font, typeSurface); 1104 EXPECT_NE(nullptr, OH_Drawing_FontGetTypeface(font)); 1105 const char* str = "123456"; 1106 int count = strlen(str); 1107 OH_Drawing_Point2D pts[count]; 1108 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(nullptr, count, &pts[0], 1109 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8)); 1110 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(str, count, nullptr, 1111 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8)); 1112 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0], 1113 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8)); 1114 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0], 1115 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 1116 EXPECT_NE(textBlob, nullptr); 1117 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0); 1118 1119 OH_Drawing_TextBlobDestroy(textBlob); 1120 OH_Drawing_FontDestroy(font); 1121 OH_Drawing_TypefaceDestroy(typeSurface); 1122} 1123 1124/* 1125 * @tc.name: NativeDrawingCanvasTest_SaveLayer037 1126 * @tc.desc: test for SaveLayer 1127 * @tc.size : MediumTest 1128 * @tc.type : Function 1129 * @tc.level : Level 1 1130 */ 1131HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveLayer037, TestSize.Level1) 1132{ 1133 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600); 1134 EXPECT_NE(rect, nullptr); 1135 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 1136 EXPECT_NE(brush, nullptr); 1137 // test exception 1138 OH_Drawing_CanvasSaveLayer(nullptr, rect, brush); 1139 OH_Drawing_CanvasSaveLayer(canvas_, rect, brush); 1140 OH_Drawing_CanvasRestore(canvas_); 1141 OH_Drawing_RectDestroy(rect); 1142} 1143/* 1144 * @tc.name: NativeDrawingTest001 1145 * @tc.desc: test for fontSetLinearText 1146 * @tc.size : MediumTest 1147 * @tc.type : Function 1148 * @tc.level : Level 1 1149 */ 1150HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_FontSetLinearText_001, TestSize.Level1) 1151{ 1152 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1153 OH_Drawing_FontSetTextSize(font, 20); 1154 OH_Drawing_FontSetTextSkewX(font, 0.25); 1155 OH_Drawing_FontSetLinearText(font, true); 1156 OH_Drawing_FontDestroy(font); 1157} 1158 1159/* 1160 * @tc.name: NativeDrawingTest002 1161 * @tc.desc: test for penSetFilter 1162 * @tc.size : MediumTest 1163 * @tc.type : Function 1164 * @tc.level : Level 1 1165 */ 1166HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_PenSetFilter_001, TestSize.Level1) 1167{ 1168 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 1169 EXPECT_EQ(canvas == nullptr, false); 1170 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xff0000ff, 1171 OH_Drawing_BlendMode::BLEND_MODE_SRC); 1172 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate(); 1173 OH_Drawing_FilterSetColorFilter(filter, colorFilter); 1174 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 1175 OH_Drawing_PenSetColor(pen, 0xff00ff00); 1176 OH_Drawing_PenSetFilter(pen, filter); 1177 OH_Drawing_CanvasAttachPen(canvas, pen); 1178 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(100, 400, 200, 500); 1179 OH_Drawing_CanvasDrawRect(canvas, rect); 1180 OH_Drawing_RectDestroy(rect); 1181 OH_Drawing_PenDestroy(pen); 1182 OH_Drawing_ColorFilterDestroy(colorFilter); 1183 OH_Drawing_FilterDestroy(filter); 1184 OH_Drawing_CanvasDestroy(canvas); 1185} 1186 1187/* 1188 * @tc.name: NativeDrawingTest003 1189 * @tc.desc: test for penSetFilter 1190 * @tc.size : MediumTest 1191 * @tc.type : Function 1192 * @tc.level : Level 1 1193 */ 1194HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_PenSetshaderEffect, TestSize.Level1) 1195{ 1196 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 1197 EXPECT_EQ(canvas == nullptr, false); 1198 OH_Drawing_Point* startPt = OH_Drawing_PointCreate(100, 400); 1199 OH_Drawing_Point* endPt = OH_Drawing_PointCreate(200, 500); 1200 uint32_t color[] = {0xffff0000, 0xff00ff00}; 1201 float pos[] = {0., 1.0}; 1202 OH_Drawing_ShaderEffect* linearGradient = OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, 1203 color, pos, 2, OH_Drawing_TileMode::CLAMP); 1204 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 1205 OH_Drawing_PenSetShaderEffect(pen, linearGradient); 1206 OH_Drawing_CanvasAttachPen(canvas, pen); 1207 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(100, 400, 200, 500); 1208 OH_Drawing_CanvasDrawRect(canvas, rect); 1209 OH_Drawing_RectDestroy(rect); 1210 OH_Drawing_PenDestroy(pen); 1211 OH_Drawing_ShaderEffectDestroy(linearGradient); 1212 OH_Drawing_PointDestroy(startPt); 1213 OH_Drawing_PointDestroy(endPt); 1214 OH_Drawing_CanvasDestroy(canvas); 1215} 1216/* 1217 * @tc.name: NativeDrawingCanvasTest_DrawRegion038 1218 * @tc.desc: test for DrawRegion 1219 * @tc.size : MediumTest 1220 * @tc.type : Function 1221 * @tc.level : Level 1 1222 */ 1223HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawRegion038, TestSize.Level1) 1224{ 1225 OH_Drawing_Region* region=OH_Drawing_RegionCreate(); 1226 OH_Drawing_Rect* rect=OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 1227 OH_Drawing_RegionSetRect(region, rect); 1228 OH_Drawing_CanvasDrawRegion(canvas_, region); 1229} 1230 1231/* 1232 * @tc.name: NativeDrawingCanvasTest_DrawBackground039 1233 * @tc.desc: test for DrawBackground 1234 * @tc.size : MediumTest 1235 * @tc.type : Function 1236 * @tc.level : Level 1 1237 */ 1238HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBackground039, TestSize.Level1) 1239{ 1240 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 1241 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 1242 OH_Drawing_CanvasDrawBackground(canvas_, brush); 1243} 1244 1245/* 1246 * @tc.name: NativeDrawingCanvasTest_DrawColor046 1247 * @tc.desc: test for DrawColor 1248 * @tc.type: FUNC 1249 * @tc.require: SR000S9F0C 1250 */ 1251HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawColor046, TestSize.Level1) 1252{ 1253 EXPECT_EQ(OH_Drawing_CanvasDrawColor(nullptr, 0xFFFF0000, OH_Drawing_BlendMode::BLEND_MODE_SRC), 1254 OH_DRAWING_ERROR_INVALID_PARAMETER); 1255 EXPECT_EQ(OH_Drawing_CanvasDrawColor(canvas_, 0xFFFF0000, OH_Drawing_BlendMode::BLEND_MODE_COLOR), 1256 OH_DRAWING_SUCCESS); 1257} 1258 1259/* 1260 * @tc.name: NativeDrawingCanvasTest_IsClipEmpty042 1261 * @tc.desc: test for if clip is empty 1262 * @tc.type: FUNC 1263 * @tc.require: AR000GTO5R 1264 */ 1265HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_IsClipEmpty042, TestSize.Level1) 1266{ 1267 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 1268 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1269 // 720: bitmap's width, 720: bitmap's height 1270 constexpr uint32_t width = 720; 1271 constexpr uint32_t height = 720; 1272 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1273 OH_Drawing_CanvasBind(canvas_, bitmap); 1274 1275 // 150.0f: rect's left, 100.0f: rect's top, 500.0f: rect's right, 500.0f: rect's bottom 1276 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(150.0f, 100.0f, 500.f, 500.f); 1277 1278 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, false); 1279 1280 bool isClipEmpty = false; 1281 EXPECT_EQ(OH_Drawing_CanvasIsClipEmpty(canvas_, &isClipEmpty), OH_DRAWING_SUCCESS); 1282 EXPECT_EQ(isClipEmpty, false); 1283 1284 OH_Drawing_RectDestroy(rect); 1285 OH_Drawing_BitmapDestroy(bitmap); 1286} 1287 1288/* 1289 * @tc.name: NativeDrawingCanvasTest_GetImageInfo043 1290 * @tc.desc: test for Gets ImageInfo of Canvas. 1291 * @tc.type: FUNC 1292 * @tc.require: AR000GTO5R 1293 */ 1294HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetImageInfo043, TestSize.Level1) 1295{ 1296 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 1297 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1298 // 720: bitmap's width, 720: bitmap's height 1299 constexpr uint32_t width = 720; 1300 constexpr uint32_t height = 720; 1301 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1302 OH_Drawing_CanvasBind(canvas_, bitmap); 1303 OH_Drawing_Image_Info* imageInfo = new OH_Drawing_Image_Info(); 1304 EXPECT_EQ(OH_Drawing_CanvasGetImageInfo(canvas_, imageInfo), OH_DRAWING_SUCCESS); 1305 EXPECT_EQ(720, imageInfo->width); 1306 EXPECT_EQ(720, imageInfo->height); 1307 EXPECT_EQ(1, imageInfo->alphaType); 1308 EXPECT_EQ(4, imageInfo->colorType); 1309 delete imageInfo; 1310} 1311 1312 1313/* 1314 * @tc.name: NativeDrawingCanvasTest_ClipRegion044 1315 * @tc.desc: test for Drawing Canvas Clip Region. 1316 * @tc.type: FUNC 1317 * @tc.require: AR000GTO5R 1318 */ 1319HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRegion044, TestSize.Level1) 1320{ 1321 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate(); 1322 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1323 constexpr uint32_t width = 720; // 720: width of canvas 1324 constexpr uint32_t height = 720; // 720: height of canvas 1325 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1326 OH_Drawing_CanvasBind(canvas_, bitmap); 1327 1328 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 1329 // 0.0f: rect's left, 0.0f: rect's top, 720.0f: rect's right, 720.0f: rect's bottom 1330 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 720.f, 720.f); 1331 OH_Drawing_RegionSetRect(region, rect); 1332 EXPECT_EQ(OH_Drawing_CanvasClipRegion(canvas_, region, OH_Drawing_CanvasClipOp::INTERSECT), OH_DRAWING_SUCCESS); 1333 EXPECT_EQ(OH_Drawing_CanvasClipRegion(nullptr, region, OH_Drawing_CanvasClipOp::INTERSECT), 1334 OH_DRAWING_ERROR_INVALID_PARAMETER); 1335 1336 EXPECT_EQ(720, OH_Drawing_CanvasGetWidth(canvas_)); 1337 EXPECT_EQ(720, OH_Drawing_CanvasGetHeight(canvas_)); 1338 1339 OH_Drawing_RegionDestroy(region); 1340 OH_Drawing_RectDestroy(rect); 1341 OH_Drawing_BitmapDestroy(bitmap); 1342} 1343} // namespace Drawing 1344} // namespace Rosen 1345} // namespace OHOS