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