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