1 /*
2 * Copyright (c) 2023-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_error_code.h"
19 #include "drawing_matrix.h"
20 #include "drawing_rect.h"
21 #include "utils/scalar.h"
22
23 #ifdef RS_ENABLE_VK
24 #include "platform/ohos/backend/rs_vulkan_context.h"
25 #endif
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 namespace Drawing {
33 class NativeDrawingMatrixTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 };
40
41 constexpr uint32_t INTNUM_TEN = 10;
42 constexpr int32_t NEGATIVE_ONE = -1;
43 constexpr uint32_t MAPPOINTS_SIZE = 5;
44 constexpr uint32_t MAPPOINTS_COUNT = 2;
45
SetUpTestCase()46 void NativeDrawingMatrixTest::SetUpTestCase()
47 {
48 #ifdef RS_ENABLE_VK
49 RsVulkanContext::SetRecyclable(false);
50 #endif
51 }
TearDownTestCase()52 void NativeDrawingMatrixTest::TearDownTestCase() {}
SetUp()53 void NativeDrawingMatrixTest::SetUp() {}
TearDown()54 void NativeDrawingMatrixTest::TearDown() {}
55
56 /*
57 * @tc.name: NativeDrawingMatrixTest_SetMatrix001
58 * @tc.desc: test for SetMatrix.
59 * @tc.type: FUNC
60 * @tc.require: AR000GTO5R
61 */
62 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_SetMatrix001, TestSize.Level1)
63 {
64 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
65 OH_Drawing_MatrixSetMatrix(
66 matrix,
67 1, 0, 0,
68 0, -1, 0,
69 0, 0, 1);
70 float value = OH_Drawing_MatrixGetValue(matrix, 0);
71 EXPECT_TRUE(IsScalarAlmostEqual(value, 1.0f));
72 OH_Drawing_MatrixDestroy(matrix);
73 OH_Drawing_MatrixDestroy(nullptr);
74 }
75
76 /*
77 * @tc.name: NativeDrawingMatrixTest_SetRectToRect002
78 * @tc.desc: test for SetRectToRect.
79 * @tc.type: FUNC
80 * @tc.require: AR000GTO5R
81 */
82 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_SetRectToRect002, TestSize.Level1)
83 {
84 OH_Drawing_Rect *rectSrcOne = OH_Drawing_RectCreate(0, 0, 0, 0);
85 OH_Drawing_Rect *rectDstOne = OH_Drawing_RectCreate(0, 0, 0, 0);
86 OH_Drawing_Matrix *matrixOne = OH_Drawing_MatrixCreate();
87 bool isSuccess = OH_Drawing_MatrixSetRectToRect(matrixOne,
88 rectSrcOne, rectDstOne, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
89 EXPECT_EQ(isSuccess, false);
90 isSuccess = OH_Drawing_MatrixSetRectToRect(nullptr,
91 rectSrcOne, rectDstOne, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
92 EXPECT_EQ(isSuccess, false);
93 isSuccess = OH_Drawing_MatrixSetRectToRect(matrixOne,
94 nullptr, rectDstOne, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
95 EXPECT_EQ(isSuccess, false);
96 isSuccess = OH_Drawing_MatrixSetRectToRect(matrixOne,
97 rectSrcOne, nullptr, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
98 EXPECT_EQ(isSuccess, false);
99 isSuccess = OH_Drawing_MatrixSetRectToRect(nullptr, nullptr, nullptr, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
100 EXPECT_EQ(isSuccess, false);
101
102 OH_Drawing_Rect *rectSrcTwo = OH_Drawing_RectCreate(1, 2, 3, 4);
103 OH_Drawing_Rect *rectDstTwo = OH_Drawing_RectCreate(5, 6, 8, 9);
104 OH_Drawing_Matrix *matrixTwo = OH_Drawing_MatrixCreate();
105 bool isSuccessTwo = OH_Drawing_MatrixSetRectToRect(matrixTwo,
106 rectSrcTwo, rectDstTwo, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
107 EXPECT_EQ(isSuccessTwo, true);
108 float value;
109 value = OH_Drawing_MatrixGetValue(matrixTwo, 0);
110 EXPECT_TRUE(IsScalarAlmostEqual(value, 1.5f));
111 value = OH_Drawing_MatrixGetValue(matrixTwo, 1);
112 EXPECT_TRUE(IsScalarAlmostEqual(value, 0.0f));
113 value = OH_Drawing_MatrixGetValue(matrixTwo, 2);
114 EXPECT_TRUE(IsScalarAlmostEqual(value, 3.5f));
115
116 value = OH_Drawing_MatrixGetValue(matrixTwo, 3);
117 EXPECT_TRUE(IsScalarAlmostEqual(value, 0.0f));
118 value = OH_Drawing_MatrixGetValue(matrixTwo, 4);
119 EXPECT_TRUE(IsScalarAlmostEqual(value, 1.5f));
120 value = OH_Drawing_MatrixGetValue(matrixTwo, 5);
121 EXPECT_TRUE(IsScalarAlmostEqual(value, 3.0f));
122
123 value = OH_Drawing_MatrixGetValue(matrixTwo, 6);
124 EXPECT_TRUE(IsScalarAlmostEqual(value, 0.0f));
125 value = OH_Drawing_MatrixGetValue(matrixTwo, 7);
126 EXPECT_TRUE(IsScalarAlmostEqual(value, 0.0f));
127 value = OH_Drawing_MatrixGetValue(matrixTwo, 8);
128 EXPECT_TRUE(IsScalarAlmostEqual(value, 1.0f));
129
130 OH_Drawing_MatrixDestroy(matrixOne);
131 OH_Drawing_MatrixDestroy(matrixTwo);
132 OH_Drawing_RectDestroy(rectSrcOne);
133 OH_Drawing_RectDestroy(rectDstOne);
134 OH_Drawing_RectDestroy(rectSrcTwo);
135 OH_Drawing_RectDestroy(rectDstTwo);
136 }
137
138 /*
139 * @tc.name: NativeDrawingMatrixTest_Reset003
140 * @tc.desc: test for Reset.
141 * @tc.type: FUNC
142 * @tc.require: AR000GTO5R
143 */
144 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_Reset003, TestSize.Level1)
145 {
146 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate();
147 OH_Drawing_MatrixSetMatrix(nullptr, 2, 0, 0, 0, 1, 2, 0, 0, 1);
148 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
149 OH_Drawing_MatrixSetMatrix(matrix, 2, 0, 0, 0, 1, 2, 0, 0, 1);
150 OH_Drawing_MatrixReset(nullptr);
151 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
152 OH_Drawing_MatrixReset(matrix);
153 bool isIdentity = OH_Drawing_MatrixIsIdentity(matrix);
154 EXPECT_EQ(isIdentity, true);
155 OH_Drawing_MatrixDestroy(matrix);
156 }
157
158 /*
159 * @tc.name: NativeDrawingMatrixTest_CreateRotation004
160 * @tc.desc: test for CreateRotation.
161 * @tc.type: FUNC
162 * @tc.require: SR000S9F0C
163 */
164 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_CreateRotation004, TestSize.Level1)
165 {
166 // rotate deg: 180 pivot, point (1, 1)
167 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreateRotation(180, 1, 1);
168 OH_Drawing_MatrixGetValue(nullptr, 0);
169 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
170 OH_Drawing_MatrixGetValue(matrix, NEGATIVE_ONE);
171 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
172 OH_Drawing_MatrixGetValue(matrix, INTNUM_TEN);
173 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
174 float value;
175 value = OH_Drawing_MatrixGetValue(matrix, 0);
176 EXPECT_TRUE(IsScalarAlmostEqual(value, -1));
177 value = OH_Drawing_MatrixGetValue(matrix, 1);
178 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
179 value = OH_Drawing_MatrixGetValue(matrix, 2);
180 EXPECT_TRUE(IsScalarAlmostEqual(value, 2));
181
182 value = OH_Drawing_MatrixGetValue(matrix, 3);
183 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
184 value = OH_Drawing_MatrixGetValue(matrix, 4);
185 EXPECT_TRUE(IsScalarAlmostEqual(value, -1));
186 value = OH_Drawing_MatrixGetValue(matrix, 5);
187 EXPECT_TRUE(IsScalarAlmostEqual(value, 2));
188
189 value = OH_Drawing_MatrixGetValue(matrix, 6);
190 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
191 value = OH_Drawing_MatrixGetValue(matrix, 7);
192 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
193 value = OH_Drawing_MatrixGetValue(matrix, 8);
194 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
195
196 OH_Drawing_MatrixDestroy(matrix);
197 }
198
199 /*
200 * @tc.name: NativeDrawingMatrixTest_CreateScale005
201 * @tc.desc: test for CreateScale.
202 * @tc.type: FUNC
203 * @tc.require: SR000S9F0C
204 */
205 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_CreateScale005, TestSize.Level1)
206 {
207 /* The first 10 is horizontal scale factor.
208 The second 10 is vertical scale factor.
209 The third 10 is pivot on x-axis.
210 The fourth 10 is the pivot on y-axis.
211 */
212 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreateScale(10, 10, 10, 10);
213 float value;
214 value = OH_Drawing_MatrixGetValue(matrix, 0);
215 EXPECT_TRUE(IsScalarAlmostEqual(value, 10));
216 value = OH_Drawing_MatrixGetValue(matrix, 1);
217 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
218 value = OH_Drawing_MatrixGetValue(matrix, 2);
219 EXPECT_TRUE(IsScalarAlmostEqual(value, -90));
220
221 value = OH_Drawing_MatrixGetValue(matrix, 3);
222 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
223 value = OH_Drawing_MatrixGetValue(matrix, 4);
224 EXPECT_TRUE(IsScalarAlmostEqual(value, 10));
225 value = OH_Drawing_MatrixGetValue(matrix, 5);
226 EXPECT_TRUE(IsScalarAlmostEqual(value, -90));
227
228 value = OH_Drawing_MatrixGetValue(matrix, 6);
229 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
230 value = OH_Drawing_MatrixGetValue(matrix, 7);
231 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
232 value = OH_Drawing_MatrixGetValue(matrix, 8);
233 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
234
235 OH_Drawing_MatrixDestroy(matrix);
236 }
237
238 /*
239 * @tc.name: NativeDrawingMatrixTest_CreateTranslation006
240 * @tc.desc: test for CreateTranslation.
241 * @tc.type: FUNC
242 * @tc.require: SR000S9F0C
243 */
244 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_CreateTranslation006, TestSize.Level1)
245 {
246 // translate x= 100, y = 200
247 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreateTranslation(100, 200);
248 float value;
249 value = OH_Drawing_MatrixGetValue(matrix, 0);
250 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
251 value = OH_Drawing_MatrixGetValue(matrix, 1);
252 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
253 value = OH_Drawing_MatrixGetValue(matrix, 2);
254 EXPECT_TRUE(IsScalarAlmostEqual(value, 100));
255
256 value = OH_Drawing_MatrixGetValue(matrix, 3);
257 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
258 value = OH_Drawing_MatrixGetValue(matrix, 4);
259 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
260 value = OH_Drawing_MatrixGetValue(matrix, 5);
261 EXPECT_TRUE(IsScalarAlmostEqual(value, 200));
262
263 value = OH_Drawing_MatrixGetValue(matrix, 6);
264 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
265 value = OH_Drawing_MatrixGetValue(matrix, 7);
266 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
267 value = OH_Drawing_MatrixGetValue(matrix, 8);
268 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
269
270 OH_Drawing_MatrixDestroy(matrix);
271 }
272
273 /*
274 * @tc.name: NativeDrawingMatrixTest_Concat007
275 * @tc.desc: test for Concat.
276 * @tc.type: FUNC
277 * @tc.require: SR000S9F0C
278 */
279 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_Concat007, TestSize.Level1)
280 {
281 OH_Drawing_Matrix* matrixA = OH_Drawing_MatrixCreate();
282 OH_Drawing_Matrix* matrixB = OH_Drawing_MatrixCreate();
283 bool ret;
284 ret = OH_Drawing_MatrixIsEqual(nullptr, matrixB);
285 EXPECT_TRUE(!ret);
286 ret = OH_Drawing_MatrixIsEqual(matrixA, nullptr);
287 EXPECT_TRUE(!ret);
288 ret = OH_Drawing_MatrixIsEqual(matrixA, matrixB);
289 EXPECT_TRUE(ret);
290 OH_Drawing_MatrixSetMatrix(
291 matrixA,
292 1, 0, 0,
293 0, -1, 0,
294 0, 0, 1);
295 OH_Drawing_MatrixSetMatrix(
296 matrixB,
297 1, 0, 100,
298 0, -1, 200,
299 0, 0, 1);
300 ret = OH_Drawing_MatrixIsEqual(matrixA, matrixB);
301 EXPECT_TRUE(!ret);
302 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
303 OH_Drawing_MatrixConcat(nullptr, matrixA, matrixB);
304 OH_Drawing_MatrixConcat(matrix, nullptr, matrixB);
305 OH_Drawing_MatrixConcat(matrix, matrixA, nullptr);
306 OH_Drawing_MatrixConcat(matrix, matrixA, matrixB);
307 float value;
308 value = OH_Drawing_MatrixGetValue(matrix, 0);
309 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
310 value = OH_Drawing_MatrixGetValue(matrix, 1);
311 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
312 value = OH_Drawing_MatrixGetValue(matrix, 2);
313 EXPECT_TRUE(IsScalarAlmostEqual(value, 100));
314
315 value = OH_Drawing_MatrixGetValue(matrix, 3);
316 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
317 value = OH_Drawing_MatrixGetValue(matrix, 4);
318 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
319 value = OH_Drawing_MatrixGetValue(matrix, 5);
320 EXPECT_TRUE(IsScalarAlmostEqual(value, -200));
321
322 value = OH_Drawing_MatrixGetValue(matrix, 6);
323 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
324 value = OH_Drawing_MatrixGetValue(matrix, 7);
325 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
326 value = OH_Drawing_MatrixGetValue(matrix, 8);
327 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
328
329 OH_Drawing_MatrixDestroy(matrix);
330 OH_Drawing_MatrixDestroy(matrixA);
331 OH_Drawing_MatrixDestroy(matrixB);
332 }
333
334 /*
335 * @tc.name: NativeDrawingMatrixTest_Rotate008
336 * @tc.desc: test for Rotate.
337 * @tc.type: FUNC
338 * @tc.require: SR000S9F0C
339 */
340 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_Rotate008, TestSize.Level1)
341 {
342 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
343 // rotate deg: 180 pivot, point (1, 1)
344 OH_Drawing_MatrixRotate(nullptr, 180, 1, 1);
345 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
346 OH_Drawing_MatrixRotate(matrix, 180, 1, 1);
347 float value;
348 value = OH_Drawing_MatrixGetValue(matrix, 0);
349 EXPECT_TRUE(IsScalarAlmostEqual(value, -1));
350 value = OH_Drawing_MatrixGetValue(matrix, 1);
351 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
352 value = OH_Drawing_MatrixGetValue(matrix, 2);
353 EXPECT_TRUE(IsScalarAlmostEqual(value, 2));
354
355 value = OH_Drawing_MatrixGetValue(matrix, 3);
356 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
357 value = OH_Drawing_MatrixGetValue(matrix, 4);
358 EXPECT_TRUE(IsScalarAlmostEqual(value, -1));
359 value = OH_Drawing_MatrixGetValue(matrix, 5);
360 EXPECT_TRUE(IsScalarAlmostEqual(value, 2));
361
362 value = OH_Drawing_MatrixGetValue(matrix, 6);
363 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
364 value = OH_Drawing_MatrixGetValue(matrix, 7);
365 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
366 value = OH_Drawing_MatrixGetValue(matrix, 8);
367 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
368
369 //GetValue exception
370 value = OH_Drawing_MatrixGetValue(nullptr, 8);
371 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
372 value = OH_Drawing_MatrixGetValue(matrix, -1);
373 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
374 value = OH_Drawing_MatrixGetValue(matrix, 9);
375 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
376
377 OH_Drawing_MatrixDestroy(matrix);
378 }
379
380 /*
381 * @tc.name: NativeDrawingMatrixTest_PreRotate009
382 * @tc.desc: test for PreRotate.
383 * @tc.type: FUNC
384 * @tc.require: AR000GTO5R
385 */
386 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_PreRotate009, TestSize.Level1)
387 {
388 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate();
389 OH_Drawing_MatrixSetMatrix(matrix, 2, 0, 0, 0, 1, 2, 0, 0, 1);
390 OH_Drawing_MatrixPreRotate(matrix, 5, 10, 20);
391 OH_Drawing_MatrixPreRotate(nullptr, 5, 10, 20);
392 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
393
394 OH_Drawing_MatrixSetMatrix(matrix, 1, 2, 3, 4, 5, 6, 7, 8, 9);
395 OH_Drawing_MatrixPreRotate(matrix, 90, 1, 0);
396 OH_Drawing_Matrix* matrix2 = OH_Drawing_MatrixCreate();
397 OH_Drawing_MatrixSetMatrix(matrix2, 2, -1, 2, 5, -4, 5, 8, -7, 8);
398 bool ret = false;
399 ret = OH_Drawing_MatrixIsEqual(matrix, matrix2);
400 EXPECT_EQ(ret, true);
401 OH_Drawing_MatrixDestroy(matrix);
402 OH_Drawing_MatrixDestroy(matrix2);
403 }
404
405 /*
406 * @tc.name: NativeDrawingMatrixTest_PostRotate010
407 * @tc.desc: test for PostRotate.
408 * @tc.type: FUNC
409 * @tc.require: AR000GTO5R
410 */
411 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_PostRotate010, TestSize.Level1)
412 {
413 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate();
414 OH_Drawing_MatrixSetMatrix(matrix, 2, 0, 0, 0, 1, 2, 0, 0, 1);
415 OH_Drawing_MatrixPostRotate(matrix, 5, 10, 20);
416 OH_Drawing_MatrixPostRotate(nullptr, 5, 10, 20);
417 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
418
419 OH_Drawing_MatrixSetMatrix(matrix, 1, 2, 3, 4, 5, 6, 7, 8, 9);
420 OH_Drawing_MatrixPostRotate(matrix, 90, 1, 0);
421 OH_Drawing_Matrix* matrix2 = OH_Drawing_MatrixCreate();
422 OH_Drawing_MatrixSetMatrix(matrix2, 3, 3, 3, -6, -6, -6, 7, 8, 9);
423 bool ret = false;
424 ret = OH_Drawing_MatrixIsEqual(matrix, matrix2);
425 EXPECT_EQ(ret, true);
426 OH_Drawing_MatrixDestroy(matrix);
427 OH_Drawing_MatrixDestroy(matrix2);
428 }
429
430 /*
431 * @tc.name: NativeDrawingMatrixTest_Scale011
432 * @tc.desc: test for Scale.
433 * @tc.type: FUNC
434 * @tc.require: SR000S9F0C
435 */
436 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_Scale011, TestSize.Level1)
437 {
438 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
439 /* The first 10 is horizontal scale factor.
440 The second 10 is vertical scale factor.
441 The third 10 is pivot on x-axis.
442 The fourth 10 is the pivot on y-axis.
443 */
444 OH_Drawing_MatrixScale(nullptr, 10, 10, 10, 10);
445 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
446 OH_Drawing_MatrixScale(matrix, 10, 10, 10, 10);
447 float value;
448 value = OH_Drawing_MatrixGetValue(matrix, 0);
449 EXPECT_TRUE(IsScalarAlmostEqual(value, 10));
450 value = OH_Drawing_MatrixGetValue(matrix, 1);
451 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
452 value = OH_Drawing_MatrixGetValue(matrix, 2);
453 EXPECT_TRUE(IsScalarAlmostEqual(value, -90));
454
455 value = OH_Drawing_MatrixGetValue(matrix, 3);
456 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
457 value = OH_Drawing_MatrixGetValue(matrix, 4);
458 EXPECT_TRUE(IsScalarAlmostEqual(value, 10));
459 value = OH_Drawing_MatrixGetValue(matrix, 5);
460 EXPECT_TRUE(IsScalarAlmostEqual(value, -90));
461
462 value = OH_Drawing_MatrixGetValue(matrix, 6);
463 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
464 value = OH_Drawing_MatrixGetValue(matrix, 7);
465 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
466 value = OH_Drawing_MatrixGetValue(matrix, 8);
467 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
468
469 OH_Drawing_MatrixDestroy(matrix);
470 }
471
472 /*
473 * @tc.name: NativeDrawingMatrixTest_PreScale012
474 * @tc.desc: test for PreScale.
475 * @tc.type: FUNC
476 * @tc.require: SR000S9F0C
477 */
478 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_PreScale012, TestSize.Level1)
479 {
480 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
481 OH_Drawing_MatrixPreScale(nullptr, 10, 10, 10, 10);
482 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
483 OH_Drawing_MatrixPreScale(matrix, 10, 10, 10, 10);
484 float value;
485 value = OH_Drawing_MatrixGetValue(matrix, 0);
486 EXPECT_TRUE(IsScalarAlmostEqual(value, 10));
487
488 OH_Drawing_MatrixSetMatrix(matrix, 2, 1, 3, 1, 2, 2, 3, 1, 1);
489 OH_Drawing_MatrixPreScale(matrix, 4, 6, 5, 7);
490 OH_Drawing_Matrix* matrix2 = OH_Drawing_MatrixCreate();
491 OH_Drawing_MatrixSetMatrix(matrix2, 8, 6, -62, 4, 12, -83, 12, 6, -79);
492 bool ret = false;
493 ret = OH_Drawing_MatrixIsEqual(matrix, matrix2);
494 EXPECT_EQ(ret, true);
495
496 OH_Drawing_MatrixDestroy(matrix);
497 OH_Drawing_MatrixDestroy(matrix2);
498 }
499
500 /*
501 * @tc.name: NativeDrawingMatrixTest_PostScale013
502 * @tc.desc: test for PostScale.
503 * @tc.type: FUNC
504 * @tc.require: SR000S9F0C
505 */
506 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_PostScale013, TestSize.Level1)
507 {
508 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
509 OH_Drawing_MatrixPostScale(nullptr, 10, 10, 10, 10);
510 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
511 OH_Drawing_MatrixPostScale(matrix, 10, 10, 10, 10);
512 float value;
513 value = OH_Drawing_MatrixGetValue(matrix, 0);
514 EXPECT_TRUE(IsScalarAlmostEqual(value, 10));
515
516 OH_Drawing_MatrixSetMatrix(matrix, 2, 1, 3, 1, 2, 2, 3, 1, 1);
517 OH_Drawing_MatrixPostScale(matrix, 4, 6, 5, 7);
518 OH_Drawing_Matrix* matrix2 = OH_Drawing_MatrixCreate();
519 OH_Drawing_MatrixSetMatrix(matrix2, -37, -11, -3, -99, -23, -23, 3, 1, 1);
520 bool ret = false;
521 ret = OH_Drawing_MatrixIsEqual(matrix, matrix2);
522 EXPECT_EQ(ret, true);
523 OH_Drawing_MatrixDestroy(matrix);
524 OH_Drawing_MatrixDestroy(matrix2);
525 }
526
527 /*
528 * @tc.name: NativeDrawingMatrixTest_Translate014
529 * @tc.desc: test for Translate.
530 * @tc.type: FUNC
531 * @tc.require: SR000S9F0C
532 */
533 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_Translate014, TestSize.Level1)
534 {
535 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
536 bool ret;
537 ret = OH_Drawing_MatrixIsIdentity(matrix);
538 EXPECT_TRUE(ret);
539 ret = OH_Drawing_MatrixIsIdentity(nullptr);
540 EXPECT_TRUE(!ret);
541 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
542 // translate x = 100, y = 200
543 OH_Drawing_MatrixTranslate(nullptr, 100, 200);
544 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
545 OH_Drawing_MatrixTranslate(matrix, 100, 200);
546 ret = OH_Drawing_MatrixIsIdentity(matrix);
547 EXPECT_TRUE(!ret);
548 float value;
549 value = OH_Drawing_MatrixGetValue(matrix, 0);
550 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
551 value = OH_Drawing_MatrixGetValue(matrix, 1);
552 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
553 value = OH_Drawing_MatrixGetValue(matrix, 2);
554 EXPECT_TRUE(IsScalarAlmostEqual(value, 100));
555
556 value = OH_Drawing_MatrixGetValue(matrix, 3);
557 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
558 value = OH_Drawing_MatrixGetValue(matrix, 4);
559 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
560 value = OH_Drawing_MatrixGetValue(matrix, 5);
561 EXPECT_TRUE(IsScalarAlmostEqual(value, 200));
562
563 value = OH_Drawing_MatrixGetValue(matrix, 6);
564 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
565 value = OH_Drawing_MatrixGetValue(matrix, 7);
566 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
567 value = OH_Drawing_MatrixGetValue(matrix, 8);
568 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
569
570 OH_Drawing_MatrixDestroy(matrix);
571 }
572
573 /*
574 * @tc.name: NativeDrawingMatrixTest_PreTranslate015
575 * @tc.desc: test for PreTranslate.
576 * @tc.type: FUNC
577 * @tc.require: SR000S9F0C
578 */
579 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_PreTranslate015, TestSize.Level1)
580 {
581 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
582 OH_Drawing_MatrixPreTranslate(nullptr, 10, 10);
583 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
584 OH_Drawing_MatrixPreTranslate(matrix, 10, 10);
585 float value;
586 value = OH_Drawing_MatrixGetValue(matrix, 0);
587 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
588
589 OH_Drawing_MatrixSetMatrix(matrix, 2, 1, 3, 1, 2, 2, 3, 1, 1);
590 OH_Drawing_MatrixPreTranslate(matrix, 2, 4);
591 OH_Drawing_Matrix* matrix2 = OH_Drawing_MatrixCreate();
592 OH_Drawing_MatrixSetMatrix(matrix2, 2, 1, 11, 1, 2, 12, 3, 1, 11);
593 bool ret = false;
594 ret = OH_Drawing_MatrixIsEqual(matrix, matrix2);
595 EXPECT_EQ(ret, true);
596 OH_Drawing_MatrixDestroy(matrix);
597 OH_Drawing_MatrixDestroy(matrix2);
598 }
599
600 /*
601 * @tc.name: NativeDrawingMatrixTest_PostTranslate016
602 * @tc.desc: test for PostTranslate.
603 * @tc.type: FUNC
604 * @tc.require: SR000S9F0C
605 */
606 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_PostTranslate016, TestSize.Level1)
607 {
608 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
609 OH_Drawing_MatrixPostTranslate(nullptr, 10, 10);
610 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
611 OH_Drawing_MatrixPostTranslate(matrix, 10, 10);
612 float value;
613 value = OH_Drawing_MatrixGetValue(matrix, 0);
614 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
615
616 OH_Drawing_MatrixSetMatrix(matrix, 2, 1, 3, 1, 2, 2, 3, 1, 1);
617 OH_Drawing_MatrixPostTranslate(matrix, 2, 4);
618 OH_Drawing_Matrix* matrix2 = OH_Drawing_MatrixCreate();
619 OH_Drawing_MatrixSetMatrix(matrix2, 8, 3, 5, 13, 6, 6, 3, 1, 1);
620 bool ret = false;
621 ret = OH_Drawing_MatrixIsEqual(matrix, matrix2);
622 EXPECT_EQ(ret, true);
623
624 OH_Drawing_MatrixDestroy(matrix);
625 OH_Drawing_MatrixDestroy(matrix2);
626 }
627
628 /*
629 * @tc.name: NativeDrawingMatrixTest_Invert017
630 * @tc.desc: test for Invert.
631 * @tc.type: FUNC
632 * @tc.require: SR000S9F0C
633 */
634 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_Invert017, TestSize.Level1)
635 {
636 bool ret;
637 ret = OH_Drawing_MatrixInvert(nullptr, nullptr);
638 EXPECT_TRUE(!ret);
639 OH_Drawing_Matrix* matrixA = OH_Drawing_MatrixCreate();
640 OH_Drawing_Matrix* matrixB = OH_Drawing_MatrixCreate();
641 ret = OH_Drawing_MatrixInvert(nullptr, matrixB);
642 EXPECT_TRUE(!ret);
643 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
644 ret = OH_Drawing_MatrixInvert(matrixA, nullptr);
645 EXPECT_TRUE(!ret);
646 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
647 ret = OH_Drawing_MatrixInvert(matrixA, matrixB);
648 EXPECT_TRUE(ret);
649 OH_Drawing_MatrixSetMatrix(
650 matrixA,
651 1, 0, 0,
652 0, -0.5, 0,
653 0, 0, 1);
654 ret = OH_Drawing_MatrixInvert(matrixA, matrixB);
655 EXPECT_TRUE(ret);
656
657 float value;
658 value = OH_Drawing_MatrixGetValue(matrixB, 0);
659 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
660 value = OH_Drawing_MatrixGetValue(matrixB, 1);
661 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
662 value = OH_Drawing_MatrixGetValue(matrixB, 2);
663 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
664
665 value = OH_Drawing_MatrixGetValue(matrixB, 3);
666 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
667 value = OH_Drawing_MatrixGetValue(matrixB, 4);
668 EXPECT_TRUE(IsScalarAlmostEqual(value, -2));
669 value = OH_Drawing_MatrixGetValue(matrixB, 5);
670 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
671
672 value = OH_Drawing_MatrixGetValue(matrixB, 6);
673 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
674 value = OH_Drawing_MatrixGetValue(matrixB, 7);
675 EXPECT_TRUE(IsScalarAlmostEqual(value, 0));
676 value = OH_Drawing_MatrixGetValue(matrixB, 8);
677 EXPECT_TRUE(IsScalarAlmostEqual(value, 1));
678
679 OH_Drawing_MatrixDestroy(matrixA);
680 OH_Drawing_MatrixDestroy(matrixB);
681 }
682
683 /**
684 * @tc.name: NativeDrawingMatrixTest_SetPolyToPoly018
685 * @tc.desc: test for set poly to poly of Matrix.
686 * @tc.type: FUNC
687 * @tc.require: AR20240104201189
688 */
689 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_SetPolyToPoly018, TestSize.Level1)
690 {
691 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
692 ASSERT_TRUE(matrix != nullptr);
693 OH_Drawing_MatrixSetMatrix(
694 matrix,
695 1, 0, 0,
696 0, -1, 0,
697 0, 0, 1);
698 OH_Drawing_Point2D src[] = {{0, 0}, {100, 0}, {100, 100}, {0, 100}, {0, 100}};
699 OH_Drawing_Point2D dst[] = {{0, 0}, {100, 30}, {100, 70}, {0, 100}, {0, 100}};
700 EXPECT_TRUE(OH_Drawing_MatrixSetPolyToPoly(matrix, src, dst, 0));
701 OH_Drawing_MatrixSetPolyToPoly(nullptr, src, dst, 0);
702 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
703 OH_Drawing_MatrixSetPolyToPoly(matrix, src, dst, NEGATIVE_ONE);
704 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
705 OH_Drawing_MatrixSetPolyToPoly(matrix, src, dst, INTNUM_TEN);
706 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
707 OH_Drawing_MatrixDestroy(matrix);
708 }
709
710 /**
711 * @tc.name: NativeDrawingMatrixTest_SetPolyToPoly019
712 * @tc.desc: test for set poly to poly of Matrix.
713 * @tc.type: FUNC
714 * @tc.require: AR20240104201189
715 */
716 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_SetPolyToPoly019, TestSize.Level1)
717 {
718 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
719 ASSERT_TRUE(matrix != nullptr);
720 OH_Drawing_MatrixSetMatrix(
721 matrix,
722 1, 0, 0,
723 0, -1, 0,
724 0, 0, 1);
725 OH_Drawing_Point2D src[] = {{0, 0}, {100, 0}, {100, 100}, {0, 100}};
726 OH_Drawing_Point2D dst[] = {{0, 0}, {100, 30}, {100, 70}, {0, 100}};
727 EXPECT_TRUE(OH_Drawing_MatrixSetPolyToPoly(matrix, src, dst, 1));
728 OH_Drawing_MatrixDestroy(matrix);
729 }
730
731 /**
732 * @tc.name: NativeDrawingMatrixTest_SetPolyToPoly020
733 * @tc.desc: test for set poly to poly of Matrix.
734 * @tc.type: FUNC
735 * @tc.require: AR20240104201189
736 */
737 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_SetPolyToPoly020, TestSize.Level1)
738 {
739 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
740 ASSERT_TRUE(matrix != nullptr);
741 OH_Drawing_MatrixSetMatrix(
742 matrix,
743 1, 0, 0,
744 0, -1, 0,
745 0, 0, 1);
746 OH_Drawing_Point2D src[] = {{0, 0}, {100, 0}, {100, 100}, {0, 100}, {0, 100}};
747 OH_Drawing_Point2D dst[] = {{0, 0}, {100, 30}, {100, 70}, {0, 100}, {0, 100}};
748 EXPECT_TRUE(OH_Drawing_MatrixSetPolyToPoly(matrix, src, dst, 4));
749 OH_Drawing_MatrixDestroy(matrix);
750 }
751
752 /**
753 * @tc.name: NativeDrawingMatrixTest_SetPolyToPoly021
754 * @tc.desc: test for set poly to poly of Matrix.
755 * @tc.type: FUNC
756 * @tc.require: AR20240104201189
757 */
758 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_SetPolyToPoly021, TestSize.Level1)
759 {
760 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
761 ASSERT_TRUE(matrix != nullptr);
762 OH_Drawing_MatrixSetMatrix(
763 matrix,
764 1, 0, 0,
765 0, -1, 0,
766 0, 0, 1);
767 OH_Drawing_Point2D src[] = {{0, 0}, {100, 0}, {100, 100}, {0, 100}, {0, 100}};
768 OH_Drawing_Point2D dst[] = {{0, 0}, {100, 30}, {100, 70}, {0, 100}, {0, 100}};
769 EXPECT_FALSE(OH_Drawing_MatrixSetPolyToPoly(matrix, src, dst, 5));
770 OH_Drawing_MatrixDestroy(matrix);
771 }
772
773 /**
774 * @tc.name: NativeDrawingMatrixTest_GetAll022
775 * @tc.desc: test for Copies nine scalar values contained by Matrix into buffer.
776 * @tc.type: FUNC
777 * @tc.require: AR20240104201189
778 */
779 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_GetAll022, TestSize.Level1)
780 {
781 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
782 ASSERT_TRUE(matrix != nullptr);
783 float buffer[9];
784 float emptyBuffer[9] = {1, 2, 3, 3, 2, 1, 4, 5, 6};
785 OH_Drawing_MatrixSetMatrix(matrix, 1, 2, 3, 3, 2, 1, 4, 5, 6);
786 EXPECT_EQ(OH_Drawing_MatrixGetAll(matrix, buffer), OH_DRAWING_SUCCESS);
787 for (int i = 0; i < 9; ++i) {
788 EXPECT_TRUE(IsScalarAlmostEqual(buffer[i], emptyBuffer[i]));
789 }
790 OH_Drawing_MatrixDestroy(matrix);
791 }
792
793 /*
794 * @tc.name: NativeDrawingMatrixTest_IsEqualAndConcat023
795 * @tc.desc: test for IsEqual and Concat.
796 * @tc.type: FUNC
797 * @tc.require: SR000S9F0C
798 */
799 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_IsEqualAndConcat023, TestSize.Level1)
800 {
801 OH_Drawing_Matrix* matrixA = OH_Drawing_MatrixCreate();
802 OH_Drawing_Matrix* matrixB = OH_Drawing_MatrixCreate();
803 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
804 OH_Drawing_MatrixIsEqual(nullptr, matrixB);
805 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
806 OH_Drawing_MatrixIsEqual(matrixA, nullptr);
807 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
808
809 OH_Drawing_MatrixConcat(nullptr, matrixA, matrixB);
810 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
811 OH_Drawing_MatrixConcat(matrix, nullptr, matrixB);
812 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
813 OH_Drawing_MatrixConcat(matrix, matrixA, nullptr);
814 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
815
816 OH_Drawing_MatrixDestroy(matrix);
817 OH_Drawing_MatrixDestroy(matrixA);
818 OH_Drawing_MatrixDestroy(matrixB);
819 }
820
821 /*
822 * @tc.name: NativeDrawingMatrixTest_SetRectToRect024
823 * @tc.desc: test for SetRectToRect.
824 * @tc.type: FUNC
825 * @tc.require: SR000S9F0C
826 */
827 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_SetRectToRect024, TestSize.Level1)
828 {
829 OH_Drawing_Rect *rectSrcOne = OH_Drawing_RectCreate(0, 0, 0, 0);
830 OH_Drawing_Rect *rectDstOne = OH_Drawing_RectCreate(0, 0, 0, 0);
831 OH_Drawing_Matrix *matrixOne = OH_Drawing_MatrixCreate();
832 OH_Drawing_MatrixSetRectToRect(nullptr, rectSrcOne, rectDstOne, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
833 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
834 OH_Drawing_MatrixSetRectToRect(matrixOne, nullptr, rectDstOne, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
835 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
836 OH_Drawing_MatrixSetRectToRect(matrixOne, rectSrcOne, nullptr, OH_Drawing_ScaleToFit::SCALE_TO_FIT_FILL);
837 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
838
839 OH_Drawing_MatrixDestroy(matrixOne);
840 OH_Drawing_RectDestroy(rectSrcOne);
841 OH_Drawing_RectDestroy(rectDstOne);
842 }
843
844 /**
845 * @tc.name: NativeDrawingMatrixTest_MapPoints025
846 * @tc.desc: test for maps the src point array to the dst point array by matrix transformation.
847 * @tc.type: FUNC
848 * @tc.require: AR20240104201189
849 */
850 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_MapPoints025, TestSize.Level1)
851 {
852 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
853 ASSERT_TRUE(matrix != nullptr);
854 OH_Drawing_Point2D src[] = {{0, 0}, {100, 0}, {100, 100}, {0, 100}, {0, 100}};
855 OH_Drawing_Point2D dst[MAPPOINTS_SIZE];
856
857 OH_Drawing_MatrixMapPoints(nullptr, src, dst, MAPPOINTS_COUNT);
858 OH_Drawing_MatrixTranslate(matrix, 100, 200);
859 OH_Drawing_MatrixMapPoints(matrix, src, dst, MAPPOINTS_COUNT);
860
861 EXPECT_EQ(dst[0].x, 100);
862 EXPECT_EQ(dst[0].y, 200);
863 OH_Drawing_MatrixDestroy(matrix);
864 }
865
866 /**
867 * @tc.name: NativeDrawingMatrixTest_MapRect026
868 * @tc.desc: test for sets dst to bounds of src corners mapped by matrix transformation.
869 * @tc.type: FUNC
870 * @tc.require: AR20240104201189
871 */
872 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_MapRect026, TestSize.Level1)
873 {
874 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
875 ASSERT_TRUE(matrix != nullptr);
876 OH_Drawing_Rect* src = OH_Drawing_RectCreate(0, 100, 200, 200);
877 OH_Drawing_Rect* dst = OH_Drawing_RectCreate(0, 0, 0, 0);
878
879 EXPECT_FALSE(OH_Drawing_MatrixMapRect(nullptr, src, dst));
880 OH_Drawing_MatrixTranslate(matrix, 100, 200);
881 EXPECT_TRUE(OH_Drawing_MatrixMapRect(matrix, src, dst));
882
883 EXPECT_TRUE(IsScalarAlmostEqual(OH_Drawing_RectGetHeight(dst), 100.f));
884 EXPECT_TRUE(IsScalarAlmostEqual(OH_Drawing_RectGetLeft(dst), 100.f));
885 OH_Drawing_RectDestroy(src);
886 OH_Drawing_RectDestroy(dst);
887 OH_Drawing_MatrixDestroy(matrix);
888 }
889
890 /**
891 * @tc.name: NativeDrawingMatrixTest_OH_Drawing_MatrixCopy027
892 * @tc.desc: test for sets create matrix by copy.
893 * @tc.type: FUNC
894 * @tc.require: AR20240104201189
895 */
896 HWTEST_F(NativeDrawingMatrixTest, NativeDrawingMatrixTest_OH_Drawing_MatrixCopy001, TestSize.Level1)
897 {
898 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
899 ASSERT_TRUE(matrix != nullptr);
900 OH_Drawing_Matrix* matrix2 = OH_Drawing_MatrixCopy(matrix);
901 ASSERT_TRUE(matrix2 != nullptr);
902 OH_Drawing_Matrix* matrix3 = OH_Drawing_MatrixCopy(nullptr);
903 ASSERT_TRUE(matrix3 == nullptr);
904
905 OH_Drawing_MatrixDestroy(matrix);
906 OH_Drawing_MatrixDestroy(matrix2);
907 OH_Drawing_MatrixDestroy(matrix3);
908 }
909
910 } // namespace Drawing
911 } // namespace Rosen
912 } // namespace OHOS
913