1 /*
2 * Copyright (c) 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, software
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 "drawing_bitmap.h"
17 #include "drawing_font_collection.h"
18 #include "drawing_point.h"
19 #include "drawing_rect.h"
20 #include "drawing_text_line.h"
21 #include "drawing_text_run.h"
22 #include "drawing_types.h"
23 #include "drawing_text_typography.h"
24 #include "gtest/gtest.h"
25 #include "string"
26
27 #ifdef RS_ENABLE_VK
28 #include "platform/ohos/backend/rs_vulkan_context.h"
29 #endif
30
31 using namespace testing;
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace {
36 constexpr static float FLOAT_DATA_EPSILON = 1e-6f;
37 }
38
39 class NdkRunTest : public testing::Test {
40 public:
SetUpTestCase()41 static void SetUpTestCase()
42 {
43 #ifdef RS_ENABLE_VK
44 Rosen::RsVulkanContext::SetRecyclable(false);
45 #endif
46 }
TearDownTestCase()47 static void TearDownTestCase() {}
SetUp()48 void SetUp() override {};
49 void TearDown() override;
50 void PrepareCreateTextLine();
51 void PrepareCreateTextLineForGlyphDrawing();
52
53 OH_Drawing_TypographyStyle* typeStyle_ = nullptr;
54 OH_Drawing_TextStyle* txtStyle_ = nullptr;
55 OH_Drawing_FontCollection* fontCollection_ = nullptr;
56 OH_Drawing_TypographyCreate* handler_ = nullptr;
57 OH_Drawing_Typography* typography_ = nullptr;
58 OH_Drawing_Bitmap* cBitmap_ = nullptr;
59 OH_Drawing_Canvas* canvas_ = nullptr;
60 OH_Drawing_Array* runs_ = nullptr;
61 OH_Drawing_Array* textLines_ = nullptr;
62 std::string text_;
63 };
64
PrepareCreateTextLine()65 void NdkRunTest::PrepareCreateTextLine()
66 {
67 double maxWidth = 500.0;
68 uint32_t height = 40;
69 typeStyle_ = OH_Drawing_CreateTypographyStyle();
70 EXPECT_TRUE(typeStyle_ != nullptr);
71 txtStyle_ = OH_Drawing_CreateTextStyle();
72 EXPECT_TRUE(txtStyle_ != nullptr);
73 fontCollection_ = OH_Drawing_CreateFontCollection();
74 EXPECT_TRUE(fontCollection_ != nullptr);
75 handler_ = OH_Drawing_CreateTypographyHandler(typeStyle_, fontCollection_);
76 EXPECT_TRUE(handler_ != nullptr);
77 OH_Drawing_SetTextStyleColor(txtStyle_, OH_Drawing_ColorSetArgb(0xFF, 0x00, 0x00, 0x00));
78 double fontSize = 30;
79 OH_Drawing_SetTextStyleFontSize(txtStyle_, fontSize);
80 OH_Drawing_SetTextStyleFontWeight(txtStyle_, FONT_WEIGHT_400);
81 bool halfLeading = true;
82 OH_Drawing_SetTextStyleHalfLeading(txtStyle_, halfLeading);
83 const char* fontFamilies[] = { "Roboto" };
84 OH_Drawing_SetTextStyleFontFamilies(txtStyle_, 1, fontFamilies);
85 OH_Drawing_TypographyHandlerPushTextStyle(handler_, txtStyle_);
86 OH_Drawing_TypographyHandlerAddText(handler_, text_.c_str());
87 OH_Drawing_TypographyHandlerPopTextStyle(handler_);
88 typography_ = OH_Drawing_CreateTypography(handler_);
89 EXPECT_TRUE(typography_ != nullptr);
90 OH_Drawing_TypographyLayout(typography_, maxWidth);
91 double position[2] = { 10.0, 15.0 };
92 OH_Drawing_Bitmap* cBitmap_ = OH_Drawing_BitmapCreate();
93 EXPECT_TRUE(cBitmap_ != nullptr);
94 OH_Drawing_BitmapFormat cFormat { COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE };
95 uint32_t width = 20;
96 OH_Drawing_BitmapBuild(cBitmap_, width, height, &cFormat);
97 canvas_ = OH_Drawing_CanvasCreate();
98 EXPECT_TRUE(canvas_ != nullptr);
99 OH_Drawing_CanvasBind(canvas_, cBitmap_);
100 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
101 OH_Drawing_TypographyPaint(typography_, canvas_, position[0], position[1]);
102 }
103
PrepareCreateTextLineForGlyphDrawing()104 void NdkRunTest::PrepareCreateTextLineForGlyphDrawing()
105 {
106 double maxWidth = 1200.0;
107 typeStyle_ = OH_Drawing_CreateTypographyStyle();
108 EXPECT_NE(typeStyle_, nullptr);
109 txtStyle_ = OH_Drawing_CreateTextStyle();
110 EXPECT_NE(txtStyle_, nullptr);
111 fontCollection_ = OH_Drawing_CreateFontCollection();
112 EXPECT_NE(fontCollection_, nullptr);
113 handler_ = OH_Drawing_CreateTypographyHandler(typeStyle_, fontCollection_);
114 EXPECT_NE(handler_, nullptr);
115 double fontSize = 100;
116 OH_Drawing_SetTextStyleFontSize(txtStyle_, fontSize);
117 OH_Drawing_TypographyHandlerPushTextStyle(handler_, txtStyle_);
118 OH_Drawing_TypographyHandlerAddText(handler_, text_.c_str());
119 typography_ = OH_Drawing_CreateTypography(handler_);
120 EXPECT_NE(typography_, nullptr);
121 OH_Drawing_TypographyLayout(typography_, maxWidth);
122 textLines_ = OH_Drawing_TypographyGetTextLines(typography_);
123 EXPECT_NE(textLines_, nullptr);
124 size_t size = OH_Drawing_GetDrawingArraySize(textLines_);
125 EXPECT_TRUE(size != 0);
126 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines_, 0);
127 EXPECT_NE(textLine, nullptr);
128 runs_ = OH_Drawing_TextLineGetGlyphRuns(textLine);
129 EXPECT_NE(runs_, nullptr);
130 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs_);
131 EXPECT_TRUE(runsSize != 0);
132 }
133
TearDown()134 void NdkRunTest::TearDown()
135 {
136 OH_Drawing_CanvasDestroy(canvas_);
137 canvas_ = nullptr;
138 OH_Drawing_BitmapDestroy(cBitmap_);
139 cBitmap_ = nullptr;
140 OH_Drawing_DestroyTypography(typography_);
141 typography_ = nullptr;
142 OH_Drawing_DestroyTypographyHandler(handler_);
143 handler_ = nullptr;
144 OH_Drawing_DestroyFontCollection(fontCollection_);
145 fontCollection_ = nullptr;
146 OH_Drawing_DestroyTextStyle(txtStyle_);
147 txtStyle_ = nullptr;
148 OH_Drawing_DestroyTypographyStyle(typeStyle_);
149 typeStyle_ = nullptr;
150 text_ = "";
151 if (textLines_ != nullptr) {
152 OH_Drawing_DestroyTextLines(textLines_);
153 textLines_ = nullptr;
154 }
155 if (runs_ != nullptr) {
156 OH_Drawing_DestroyRuns(runs_);
157 runs_ = nullptr;
158 }
159 }
160
161 /*
162 * @tc.name: RunTest001
163 * @tc.desc: Test for get run by index.
164 * @tc.type: FUNC
165 */
166 HWTEST_F(NdkRunTest, RunTest001, TestSize.Level0)
167 {
168 text_ = "Hello 你好 World";
169 PrepareCreateTextLine();
170 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
171 EXPECT_TRUE(textLines != nullptr);
172 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
173 ASSERT_GT(size, 0);
174 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, 0);
175
176 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
177 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
178 ASSERT_GT(runsSize, 0);
179
180 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(nullptr, 0);
181 EXPECT_EQ(run, nullptr);
182 run = OH_Drawing_GetRunByIndex(runs, -1);
183 EXPECT_EQ(run, nullptr);
184 run = OH_Drawing_GetRunByIndex(runs, runsSize);
185 EXPECT_EQ(run, nullptr);
186 run = OH_Drawing_GetRunByIndex(runs, 0);
187 uint32_t count = OH_Drawing_GetRunGlyphCount(run);
188 EXPECT_EQ(count, 6);
189
190 // branchCoverage
191 auto nullCount = OH_Drawing_GetDrawingArraySize(nullptr);
192 EXPECT_EQ(nullCount, 0);
193 OH_Drawing_DestroyRuns(nullptr);
194
195 OH_Drawing_DestroyRuns(runs);
196 OH_Drawing_DestroyTextLines(textLines);
197 }
198
199 /*
200 * @tc.name: RunTest002
201 * @tc.desc: Test for get run glyph count.
202 * @tc.type: FUNC
203 */
204 HWTEST_F(NdkRunTest, RunTest002, TestSize.Level0)
205 {
206 text_ = "Hello 你好 World⌚����������������مرحبا中国 测文本\n 123";
207 PrepareCreateTextLine();
208 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
209 EXPECT_TRUE(textLines != nullptr);
210 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
211 ASSERT_GT(size, 0);
212 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, 0);
213
214 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
215 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
216 ASSERT_GT(runsSize, 0);
217 std::vector<int32_t> countArr = {6, 2, 1, 5, 5, 5};
218 for (int i = 0; i < runsSize; i++) {
219 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs, i);
220 uint32_t count = OH_Drawing_GetRunGlyphCount(run);
221 EXPECT_EQ(count, countArr[i]);
222 }
223
224 // branchCoverage
225 OH_Drawing_GetRunGlyphCount(nullptr);
226
227 OH_Drawing_DestroyRuns(runs);
228 OH_Drawing_DestroyTextLines(textLines);
229 }
230
231 /*
232 * @tc.name: RunTest003
233 * @tc.desc: Test for get glyph index in paragraph.
234 * @tc.type: FUNC
235 */
236 HWTEST_F(NdkRunTest, RunTest003, TestSize.Level0)
237 {
238 text_ = "Hello 你好 World⌚����������������مرحبا中国 测文本\n 123";
239 PrepareCreateTextLine();
240 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
241 EXPECT_TRUE(textLines != nullptr);
242 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
243 ASSERT_GT(size, 0);
244 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, 0);
245
246 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
247 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
248 ASSERT_GT(runsSize, 0);
249 OH_Drawing_Run* run1 = OH_Drawing_GetRunByIndex(runs, 1);
250 uint32_t count = OH_Drawing_GetRunGlyphCount(run1);
251 auto glyphIndexArr = OH_Drawing_GetRunStringIndices(run1, 0, count);
252 auto glyphIndexArrSize = OH_Drawing_GetDrawingArraySize(glyphIndexArr);
253 std::vector<int32_t> indexndexArr = {6, 7};
254 for (int j = 0; j < glyphIndexArrSize; j++) {
255 auto glyphIndex = OH_Drawing_GetRunStringIndicesByIndex(glyphIndexArr, j);
256 EXPECT_EQ(glyphIndex, indexndexArr[j]);
257 }
258 // branchCoverage
259 OH_Drawing_GetRunStringIndices(nullptr, -1, -1);
260 OH_Drawing_GetRunStringIndicesByIndex(glyphIndexArr, glyphIndexArrSize);
261 OH_Drawing_DestroyRunStringIndices(glyphIndexArr);
262 OH_Drawing_GetRunGlyphCount(nullptr);
263
264
265 OH_Drawing_DestroyRuns(runs);
266 OH_Drawing_DestroyTextLines(textLines);
267 }
268
269 /*
270 * @tc.name: RunTest004
271 * @tc.desc: Test for get run string range.
272 * @tc.type: FUNC
273 */
274 HWTEST_F(NdkRunTest, RunTest004, TestSize.Level0)
275 {
276 text_ = "Hello 你好 World⌚����������������مرحبا中国 测文本\n 123";
277 PrepareCreateTextLine();
278 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
279 EXPECT_TRUE(textLines != nullptr);
280 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
281 ASSERT_GT(size, 0);
282 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, 0);
283
284 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
285 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
286 ASSERT_GT(runsSize, 0);
287
288 std::vector<int32_t> locationArr = {0, 6, 8, 9, 14, 19};
289 std::vector<int32_t> lengthArr = {6, 2, 1, 5, 5, 5};
290 for (int i = 0; i < runsSize; i++) {
291 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs, i);
292 uint64_t location = 0;
293 uint64_t length = 0;
294 OH_Drawing_GetRunStringRange(run, &location, &length);
295 EXPECT_EQ(location, locationArr[i]);
296 EXPECT_EQ(length, lengthArr[i]);
297 // branchCoverage
298 OH_Drawing_GetRunStringRange(run, nullptr, nullptr);
299 }
300
301 OH_Drawing_DestroyRuns(runs);
302 OH_Drawing_DestroyTextLines(textLines);
303 }
304
305 /*
306 * @tc.name: RunTest005
307 * @tc.desc: Test for get run typographic bounds.
308 * @tc.type: FUNC
309 */
310 HWTEST_F(NdkRunTest, RunTest005, TestSize.Level0)
311 {
312 text_ = "Hello 你好 World⌚����������������مرحبا中国 测文本\n 123";
313 PrepareCreateTextLine();
314 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
315 EXPECT_TRUE(textLines != nullptr);
316 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
317 ASSERT_GT(size, 0);
318 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, 0);
319
320 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
321 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
322 ASSERT_GT(runsSize, 0);
323
324 std::vector<float> widthArr = {78.929932, 59.999939, 8.099991, 81.509903, 187.187500, 64.349945};
325 std::vector<float> ascentArr = {-27.840000, -27.840000, -27.840000, -27.840000, -27.798166, -35.369999};
326 std::vector<float> descentArr = {7.320000, 7.320000, 7.320000, 7.320000, 7.431193, 9.690001};
327 for (int i = 0; i < runsSize; i++) {
328 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs, i);
329 float ascent = 0.0;
330 float descent = 0.0;
331 float leading = 0.0;
332 float width = OH_Drawing_GetRunTypographicBounds(run, &ascent, &descent, &leading);
333 EXPECT_EQ(leading, 0);
334 EXPECT_NEAR(ascent, ascentArr[i], FLOAT_DATA_EPSILON);
335 EXPECT_NEAR(descent, descentArr[i], FLOAT_DATA_EPSILON);
336 EXPECT_NEAR(width, widthArr[i], FLOAT_DATA_EPSILON);
337 // branchCoverage
338 OH_Drawing_GetRunTypographicBounds(run, nullptr, nullptr, nullptr);
339 OH_Drawing_GetRunTypographicBounds(nullptr, &ascent, &descent, &leading);
340 }
341
342 OH_Drawing_DestroyRuns(runs);
343 OH_Drawing_DestroyTextLines(textLines);
344 }
345
346 /*
347 * @tc.name: RunTest006
348 * @tc.desc: Test for get run image bounds.
349 * @tc.type: FUNC
350 */
351 HWTEST_F(NdkRunTest, RunTest006, TestSize.Level0)
352 {
353 text_ = "Hello 你好 World⌚����������������مرحبا中国 测文本\n 123";
354 PrepareCreateTextLine();
355 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
356 EXPECT_TRUE(textLines != nullptr);
357 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
358 ASSERT_GT(size, 0);
359 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, 0);
360
361 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
362 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
363 ASSERT_GT(runsSize, 0);
364
365 std::vector<float> leftArr = {2.0, 78.929932, 147.029861, 147.029861, 228.539764, 417.727264};
366 std::vector<float> topArr = {1.0, 3.0, 0.0, 1.0, 8.0, 3.0};
367 std::vector<float> bottomArr = {25.0, 32.0, 0.0, 25.0, 44.0, 33.0};
368 std::vector<float> rightArr = {70.099960, 137.929901, 147.029861, 226.329788, 416.289764, 484.857208};
369 for (int i = 0; i < runsSize; i++) {
370 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs, i);
371 OH_Drawing_Rect* bounds = OH_Drawing_GetRunImageBounds(run);
372
373 EXPECT_NEAR(OH_Drawing_RectGetLeft(bounds), leftArr[i], FLOAT_DATA_EPSILON);
374 EXPECT_NEAR(OH_Drawing_RectGetTop(bounds), topArr[i], FLOAT_DATA_EPSILON);
375 EXPECT_NEAR(OH_Drawing_RectGetBottom(bounds), bottomArr[i], FLOAT_DATA_EPSILON);
376 EXPECT_NEAR(OH_Drawing_RectGetRight(bounds), rightArr[i], FLOAT_DATA_EPSILON);
377 OH_Drawing_DestroyRunImageBounds(bounds);
378 }
379 // branchCoverage
380 OH_Drawing_GetRunImageBounds(nullptr);
381
382 OH_Drawing_DestroyRuns(runs);
383 OH_Drawing_DestroyTextLines(textLines);
384 }
385
386 /*
387 * @tc.name: RunTest007
388 * @tc.desc: Test for get run glyphs.
389 * @tc.type: FUNC
390 */
391 HWTEST_F(NdkRunTest, RunTest007, TestSize.Level0)
392 {
393 text_ = "Hello 你好 World⌚����������������مرحبا中国 测文本\n 123";
394 PrepareCreateTextLine();
395 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
396 EXPECT_TRUE(textLines != nullptr);
397 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
398 ASSERT_GT(size, 0);
399 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, 0);
400
401 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
402 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
403 ASSERT_GT(runsSize, 0);
404
405 std::vector<int32_t> glyphSizeArr = {6, 2, 1, 5, 5, 5};
406 std::vector<int32_t> glyphArr = {7824, 10413};
407 for (int i = 0; i < runsSize; i++) {
408 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs, i);
409 uint32_t count = OH_Drawing_GetRunGlyphCount(run);
410 OH_Drawing_Array* glyphs = OH_Drawing_GetRunGlyphs(run, 0, count);
411 size_t glyphSize = OH_Drawing_GetDrawingArraySize(glyphs);
412 EXPECT_EQ(glyphSize, glyphSizeArr[i]);
413 if (i == 1) {
414 for (int j = 0; j < glyphSize; j++) {
415 EXPECT_EQ(OH_Drawing_GetRunGlyphsByIndex(glyphs, j), glyphArr[j]);
416 }
417 }
418 // branchCoverage
419 OH_Drawing_GetRunGlyphsByIndex(glyphs, glyphSize);
420
421 OH_Drawing_DestroyRunGlyphs(glyphs);
422 }
423 // branchCoverage
424 OH_Drawing_GetRunGlyphs(nullptr, -1, -1);
425
426 OH_Drawing_DestroyRuns(runs);
427 OH_Drawing_DestroyTextLines(textLines);
428 }
429
430 /*
431 * @tc.name: RunTest008
432 * @tc.desc: Test for get run positions.
433 * @tc.type: FUNC
434 */
435 HWTEST_F(NdkRunTest, RunTest008, TestSize.Level0)
436 {
437 text_ = "Hello 你好 World⌚����������������مرحبا中国 测文本\n 123";
438 PrepareCreateTextLine();
439 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
440 EXPECT_TRUE(textLines != nullptr);
441 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
442 ASSERT_GT(size, 0);
443 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, 0);
444
445 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
446 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
447 ASSERT_GT(runsSize, 0);
448
449 std::vector<int32_t> positionSizeArr = {6, 2, 1, 5, 5, 5};
450 std::vector<float> posXArr = {0, 29.999969};
451 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs, 1);
452 uint32_t count = OH_Drawing_GetRunGlyphCount(run);
453 OH_Drawing_Array* positions = OH_Drawing_GetRunPositions(run, 0, count);
454 EXPECT_TRUE(positions != nullptr);
455 size_t positionSize = OH_Drawing_GetDrawingArraySize(positions);
456 for (size_t posIndex = 0; posIndex < positionSize; posIndex++) {
457 OH_Drawing_Point* pos = OH_Drawing_GetRunPositionsByIndex(positions, posIndex);
458 EXPECT_TRUE(pos != nullptr);
459 float x = 0.0;
460 OH_Drawing_PointGetX(pos, &x);
461 EXPECT_NEAR(x, posXArr[posIndex], FLOAT_DATA_EPSILON);
462 }
463 EXPECT_EQ(positionSize, 2);
464
465 // branchCoverage
466 OH_Drawing_GetRunPositionsByIndex(positions, positionSize);
467 OH_Drawing_DestroyRunPositions(positions);
468 OH_Drawing_GetRunPositions(nullptr, -1, -1);
469
470 OH_Drawing_DestroyRuns(runs);
471 OH_Drawing_DestroyTextLines(textLines);
472 }
473
474 /*
475 * @tc.name: RunTest009
476 * @tc.desc: Test for special value input parameters testing.
477 * @tc.type: FUNC
478 */
479 HWTEST_F(NdkRunTest, RunTest009, TestSize.Level0)
480 {
481 text_ = "Hello\t中国 World \n !@#%^&*){}[] 123456789 -= ,."
482 "< >、/ Draclp11⌚��������������������مرحبا中国 测文本\n 123";
483 PrepareCreateTextLine();
484 OH_Drawing_Array* textLines = OH_Drawing_TypographyGetTextLines(typography_);
485 EXPECT_TRUE(textLines != nullptr);
486 size_t size = OH_Drawing_GetDrawingArraySize(textLines);
487 for (size_t index = 0; index < size; index++) {
488 OH_Drawing_TextLine* textLine = OH_Drawing_GetTextLineByIndex(textLines, index);
489 EXPECT_TRUE(textLine != nullptr);
490 OH_Drawing_Array* runs = OH_Drawing_TextLineGetGlyphRuns(textLine);
491 EXPECT_TRUE(runs != nullptr);
492 size_t runsSize = OH_Drawing_GetDrawingArraySize(runs);
493 for (size_t runIndex = 0; runIndex < runsSize; runIndex++) {
494 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs, runIndex);
495 EXPECT_TRUE(run != nullptr);
496 // Get the actual size of the run
497 uint32_t count = OH_Drawing_GetRunGlyphCount(run);
498 EXPECT_TRUE(count > 0);
499 // If both start and end are 0, all data of the current run
500 OH_Drawing_Array* positions = OH_Drawing_GetRunPositions(run, 0, 0);
501 EXPECT_TRUE(positions != nullptr);
502 size_t positionSize = OH_Drawing_GetDrawingArraySize(positions);
503 EXPECT_EQ(positionSize, count);
504 OH_Drawing_DestroyRunPositions(positions);
505
506 // If both start and end are 0, all data of the current run
507 OH_Drawing_Array* glyphs = OH_Drawing_GetRunGlyphs(run, 0, 0);
508 EXPECT_TRUE(glyphs != nullptr);
509 size_t glyphSize = OH_Drawing_GetDrawingArraySize(glyphs);
510 EXPECT_EQ(glyphSize, count);
511 OH_Drawing_DestroyRunGlyphs(glyphs);
512
513 // If both start and end are 0, all data of the current run
514 OH_Drawing_Array* indices = OH_Drawing_GetRunStringIndices(run, 0, 0);
515 EXPECT_TRUE(indices != nullptr);
516 size_t indiceSize = OH_Drawing_GetDrawingArraySize(indices);
517 EXPECT_EQ(indiceSize, count);
518 OH_Drawing_DestroyRunStringIndices(indices);
519 }
520 OH_Drawing_DestroyRuns(runs);
521 }
522 OH_Drawing_DestroyTextLines(textLines);
523 }
524
525 /*
526 * @tc.name: RunTest010
527 * @tc.desc: Test for the run of nullptr pointer testing.
528 * @tc.type: FUNC
529 */
530 HWTEST_F(NdkRunTest, RunTest010, TestSize.Level0)
531 {
532 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(nullptr, 0);
533 EXPECT_TRUE(run == nullptr);
534 uint32_t count = OH_Drawing_GetRunGlyphCount(nullptr);
535 EXPECT_EQ(count, 0);
536 uint64_t location = 0;
537 uint64_t length = 0;
538 OH_Drawing_GetRunStringRange(nullptr, &location, &length);
539 EXPECT_EQ(location, 0);
540 EXPECT_EQ(length, 0);
541 EXPECT_TRUE(OH_Drawing_GetRunStringIndices(nullptr, 0, 0) == nullptr);
542 EXPECT_TRUE(OH_Drawing_GetRunGlyphs(nullptr, 0, 0) == nullptr);
543 EXPECT_TRUE(OH_Drawing_GetRunPositions(nullptr, 0, 0) == nullptr);
544 EXPECT_TRUE(OH_Drawing_GetRunImageBounds(nullptr) == nullptr);
545 OH_Drawing_RunPaint(nullptr, nullptr, 0, 0);
546 float ascent = 0.0;
547 float descent = 0.0;
548 float leading = 0.0;
549 float width = OH_Drawing_GetRunTypographicBounds(nullptr, &ascent, &descent, &leading);
550 EXPECT_EQ(ascent, 0.0);
551 EXPECT_EQ(descent, 0.0);
552 EXPECT_EQ(leading, 0.0);
553 EXPECT_EQ(width, 0.0);
554 }
555
556
557 /*
558 * @tc.name: GlyDrawingTest001
559 * @tc.desc: Test for the glyph drawing of nullptr testing.
560 * @tc.type: FUNC
561 */
562 HWTEST_F(NdkRunTest, GlyDrawingTest001, TestSize.Level0)
563 {
564 OH_Drawing_Font* font = OH_Drawing_GetRunFont(nullptr);
565 EXPECT_TRUE(font == nullptr);
566
567 OH_Drawing_TextDirection direction = OH_Drawing_GetRunTextDirection(nullptr);
568 EXPECT_EQ(direction, TEXT_DIRECTION_LTR);
569
570 OH_Drawing_Array* advances = OH_Drawing_GetRunGlyphAdvances(nullptr, 0, 0);
571 EXPECT_TRUE(advances == nullptr);
572
573 OH_Drawing_Point* advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 0);
574 EXPECT_TRUE(advance == nullptr);
575
576 OH_Drawing_DestroyRunGlyphAdvances(advances);
577 }
578
579 /*
580 * @tc.name: GlyDrawingTest002
581 * @tc.desc: Test for the glyph drawing of the English text.
582 * @tc.type: FUNC
583 */
584 HWTEST_F(NdkRunTest, GlyDrawingTest002, TestSize.Level0)
585 {
586 text_ = "Hello你好";
587 PrepareCreateTextLineForGlyphDrawing();
588 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs_, 0);
589 EXPECT_NE(run, nullptr);
590
591 OH_Drawing_Font* font = OH_Drawing_GetRunFont(run);
592 EXPECT_NE(font, nullptr);
593 OH_Drawing_Font_Metrics fontMetrics;
594 OH_Drawing_FontGetMetrics(font, &fontMetrics);
595 EXPECT_EQ(fontMetrics.flags, 31);
596 EXPECT_NEAR(fontMetrics.top, -105.599998, FLOAT_DATA_EPSILON);
597 EXPECT_NEAR(fontMetrics.ascent, -92.799995, FLOAT_DATA_EPSILON);
598 EXPECT_NEAR(fontMetrics.descent, 24.399999, FLOAT_DATA_EPSILON);
599 EXPECT_NEAR(fontMetrics.bottom, 27.100000, FLOAT_DATA_EPSILON);
600 EXPECT_NEAR(fontMetrics.leading, 0.0, FLOAT_DATA_EPSILON);
601 EXPECT_NEAR(fontMetrics.avgCharWidth, 50.0, FLOAT_DATA_EPSILON);
602 EXPECT_NEAR(fontMetrics.maxCharWidth, 248.600006, FLOAT_DATA_EPSILON);
603
604 OH_Drawing_TextDirection direction = OH_Drawing_GetRunTextDirection(run);
605 EXPECT_EQ(direction, TEXT_DIRECTION_LTR);
606
607 OH_Drawing_Array* advances = OH_Drawing_GetRunGlyphAdvances(run, 0, 0);
608 EXPECT_NE(advances, nullptr);
609 size_t advancesSize = OH_Drawing_GetDrawingArraySize(advances);
610 EXPECT_TRUE(advancesSize != 0);
611
612 OH_Drawing_Point* advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 0);
613 EXPECT_NE(advance, nullptr);
614 float x = 0.0;
615 OH_Drawing_PointGetX(advance, &x);
616 EXPECT_NEAR(x, 74.499923, FLOAT_DATA_EPSILON);
617 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 1);
618 EXPECT_NE(advance, nullptr);
619 OH_Drawing_PointGetX(advance, &x);
620 EXPECT_NEAR(x, 54.699951, FLOAT_DATA_EPSILON);
621 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 10);
622 EXPECT_TRUE(advance == nullptr);
623
624 OH_Drawing_DestroyRunGlyphAdvances(advances);
625 OH_Drawing_FontDestroy(font);
626 }
627
628 /*
629 * @tc.name: GlyDrawingTest003
630 * @tc.desc: Test for the glyph drawing of the emoji text.
631 * @tc.type: FUNC
632 */
633 HWTEST_F(NdkRunTest, GlyDrawingTest003, TestSize.Level0)
634 {
635 text_ = "⌚��������������������";
636 PrepareCreateTextLineForGlyphDrawing();
637 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs_, 0);
638 EXPECT_NE(run, nullptr);
639
640 OH_Drawing_Font* font = OH_Drawing_GetRunFont(run);
641 EXPECT_NE(font, nullptr);
642 OH_Drawing_Font_Metrics fontMetrics;
643 OH_Drawing_FontGetMetrics(font, &fontMetrics);
644 EXPECT_EQ(fontMetrics.flags, 31);
645 EXPECT_NEAR(fontMetrics.top, -92.660552, FLOAT_DATA_EPSILON);
646 EXPECT_NEAR(fontMetrics.ascent, -92.660552, FLOAT_DATA_EPSILON);
647 EXPECT_NEAR(fontMetrics.descent, 24.770643, FLOAT_DATA_EPSILON);
648 EXPECT_NEAR(fontMetrics.bottom, 24.770643, FLOAT_DATA_EPSILON);
649 EXPECT_NEAR(fontMetrics.leading, 0.0, FLOAT_DATA_EPSILON);
650 EXPECT_NEAR(fontMetrics.avgCharWidth, 124.511718, FLOAT_DATA_EPSILON);
651 EXPECT_NEAR(fontMetrics.maxCharWidth, 124.7706451, FLOAT_DATA_EPSILON);
652
653 OH_Drawing_TextDirection direction = OH_Drawing_GetRunTextDirection(run);
654 EXPECT_EQ(direction, TEXT_DIRECTION_LTR);
655
656 OH_Drawing_Array* advancesNullTest1 = OH_Drawing_GetRunGlyphAdvances(run, -10, -20);
657 EXPECT_TRUE(advancesNullTest1 == nullptr);
658 OH_Drawing_DestroyRunGlyphAdvances(advancesNullTest1);
659
660 OH_Drawing_Array* advancesNullTest2 = OH_Drawing_GetRunGlyphAdvances(run, 100, 20);
661 EXPECT_TRUE(advancesNullTest2 == nullptr);
662 OH_Drawing_DestroyRunGlyphAdvances(advancesNullTest2);
663
664 OH_Drawing_Array* advances = OH_Drawing_GetRunGlyphAdvances(run, 1, 2);
665 EXPECT_NE(advances, nullptr);
666 size_t advancesSize = OH_Drawing_GetDrawingArraySize(advances);
667 EXPECT_EQ(advancesSize, 2);
668
669 OH_Drawing_Point* advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 0);
670 EXPECT_NE(advance, nullptr);
671 float x = 0.0;
672 OH_Drawing_PointGetX(advance, &x);
673 EXPECT_NEAR(x, 124.765625, FLOAT_DATA_EPSILON);
674
675 OH_Drawing_DestroyRunGlyphAdvances(advances);
676 OH_Drawing_FontDestroy(font);
677 }
678
679 /*
680 * @tc.name: GlyDrawingTest004
681 * @tc.desc: Test for the glyph drawing of the RTL text.
682 * @tc.type: FUNC
683 */
684 HWTEST_F(NdkRunTest, GlyDrawingTest004, TestSize.Level0)
685 {
686 text_ = "مرحبا";
687 PrepareCreateTextLineForGlyphDrawing();
688 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs_, 0);
689 EXPECT_NE(run, nullptr);
690
691 OH_Drawing_Font* font = OH_Drawing_GetRunFont(run);
692 EXPECT_NE(font, nullptr);
693 OH_Drawing_Font_Metrics fontMetrics;
694 OH_Drawing_FontGetMetrics(font, &fontMetrics);
695 EXPECT_EQ(fontMetrics.flags, 31);
696 EXPECT_NEAR(fontMetrics.top, -139.800003, FLOAT_DATA_EPSILON);
697 EXPECT_NEAR(fontMetrics.ascent, -117.900001, FLOAT_DATA_EPSILON);
698 EXPECT_NEAR(fontMetrics.descent, 32.300003, FLOAT_DATA_EPSILON);
699 EXPECT_NEAR(fontMetrics.bottom, 39.299999, FLOAT_DATA_EPSILON);
700 EXPECT_NEAR(fontMetrics.leading, 0.0, FLOAT_DATA_EPSILON);
701 EXPECT_NEAR(fontMetrics.avgCharWidth, 70.300003, FLOAT_DATA_EPSILON);
702 EXPECT_NEAR(fontMetrics.maxCharWidth, 160.900009, FLOAT_DATA_EPSILON);
703
704 OH_Drawing_TextDirection direction = OH_Drawing_GetRunTextDirection(run);
705 EXPECT_EQ(direction, TEXT_DIRECTION_RTL);
706
707 OH_Drawing_Array* advances = OH_Drawing_GetRunGlyphAdvances(run, 1, 2);
708 EXPECT_NE(advances, nullptr);
709 size_t advancesSize = OH_Drawing_GetDrawingArraySize(advances);
710 EXPECT_EQ(advancesSize, 2);
711
712 OH_Drawing_Point* advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 0);
713 EXPECT_NE(advance, nullptr);
714 float x = 0.0;
715 OH_Drawing_PointGetX(advance, &x);
716 EXPECT_NEAR(x, 32.999969, FLOAT_DATA_EPSILON);
717 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 1);
718 EXPECT_NE(advance, nullptr);
719 OH_Drawing_PointGetX(advance, &x);
720 EXPECT_NEAR(x, 64.599945, FLOAT_DATA_EPSILON);
721
722 OH_Drawing_DestroyRunGlyphAdvances(advances);
723 OH_Drawing_FontDestroy(font);
724 }
725
726 /*
727 * @tc.name: GlyDrawingTest005
728 * @tc.desc: Test for the glyph drawing of the Arabic and Latin ligature text.
729 * @tc.type: FUNC
730 */
731 HWTEST_F(NdkRunTest, GlyDrawingTest005, TestSize.Level0)
732 {
733 text_ = "\u0644\u0627Hello你好连字测试\u0066\u0069";
734 PrepareCreateTextLineForGlyphDrawing();
735 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs_, 0);
736 EXPECT_NE(run, nullptr);
737
738 OH_Drawing_Font* font = OH_Drawing_GetRunFont(run);
739 EXPECT_NE(font, nullptr);
740 OH_Drawing_Font_Metrics fontMetrics;
741 OH_Drawing_FontGetMetrics(font, &fontMetrics);
742 EXPECT_EQ(fontMetrics.flags, 31);
743 EXPECT_NEAR(fontMetrics.top, -139.800003, FLOAT_DATA_EPSILON);
744 EXPECT_NEAR(fontMetrics.ascent, -117.900001, FLOAT_DATA_EPSILON);
745 EXPECT_NEAR(fontMetrics.descent, 32.300003, FLOAT_DATA_EPSILON);
746 EXPECT_NEAR(fontMetrics.bottom, 39.299999, FLOAT_DATA_EPSILON);
747 EXPECT_NEAR(fontMetrics.leading, 0.0, FLOAT_DATA_EPSILON);
748 EXPECT_NEAR(fontMetrics.avgCharWidth, 70.300003, FLOAT_DATA_EPSILON);
749 EXPECT_NEAR(fontMetrics.maxCharWidth, 160.900009, FLOAT_DATA_EPSILON);
750
751 OH_Drawing_TextDirection direction = OH_Drawing_GetRunTextDirection(run);
752 EXPECT_EQ(direction, TEXT_DIRECTION_RTL);
753
754 OH_Drawing_Array* advancesTest1 = OH_Drawing_GetRunGlyphAdvances(run, 0, 1);
755 EXPECT_NE(advancesTest1, nullptr);
756 size_t advancesSize = OH_Drawing_GetDrawingArraySize(advancesTest1);
757 EXPECT_EQ(advancesSize, 1);
758
759 OH_Drawing_Point* advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advancesTest1, 0);
760 EXPECT_NE(advance, nullptr);
761 float x = 0.0;
762 OH_Drawing_PointGetX(advance, &x);
763 EXPECT_NEAR(x, 48.999954, FLOAT_DATA_EPSILON);
764 OH_Drawing_DestroyRunGlyphAdvances(advancesTest1);
765
766 run = OH_Drawing_GetRunByIndex(runs_, 3);
767 OH_Drawing_Array* advancesTest2 = OH_Drawing_GetRunGlyphAdvances(run, 0, 2);
768 EXPECT_NE(advancesTest2, nullptr);
769 advancesSize = OH_Drawing_GetDrawingArraySize(advancesTest2);
770 EXPECT_EQ(advancesSize, 1);
771
772 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advancesTest2, 0);
773 EXPECT_NE(advance, nullptr);
774 OH_Drawing_PointGetX(advance, &x);
775 EXPECT_NEAR(x, 57.399948, FLOAT_DATA_EPSILON);
776
777 OH_Drawing_DestroyRunGlyphAdvances(advancesTest2);
778 OH_Drawing_FontDestroy(font);
779 }
780
781 /*
782 * @tc.name: GlyDrawingTest006
783 * @tc.desc: Test for the glyph drawing of the Sanskrit combination text.
784 * @tc.type: FUNC
785 */
786 HWTEST_F(NdkRunTest, GlyDrawingTest006, TestSize.Level0)
787 {
788 text_ = "क्Hello你好天成文测试का";
789 PrepareCreateTextLineForGlyphDrawing();
790 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs_, 0);
791 EXPECT_NE(run, nullptr);
792
793 OH_Drawing_Font* font = OH_Drawing_GetRunFont(run);
794 EXPECT_NE(font, nullptr);
795 OH_Drawing_Font_Metrics fontMetrics;
796 OH_Drawing_FontGetMetrics(font, &fontMetrics);
797 EXPECT_EQ(fontMetrics.flags, 31);
798 EXPECT_NEAR(fontMetrics.top, -134.699997, FLOAT_DATA_EPSILON);
799 EXPECT_NEAR(fontMetrics.ascent, -89.600006, FLOAT_DATA_EPSILON);
800 EXPECT_NEAR(fontMetrics.descent, 40.799999, FLOAT_DATA_EPSILON);
801 EXPECT_NEAR(fontMetrics.bottom, 39.399998, FLOAT_DATA_EPSILON);
802 EXPECT_NEAR(fontMetrics.leading, 0.0, FLOAT_DATA_EPSILON);
803 EXPECT_NEAR(fontMetrics.avgCharWidth, 55.500000, FLOAT_DATA_EPSILON);
804 EXPECT_NEAR(fontMetrics.maxCharWidth, 201.300003, FLOAT_DATA_EPSILON);
805
806 OH_Drawing_TextDirection direction = OH_Drawing_GetRunTextDirection(run);
807 EXPECT_EQ(direction, TEXT_DIRECTION_LTR);
808
809 OH_Drawing_Array* advancesTest1 = OH_Drawing_GetRunGlyphAdvances(run, 0, 2);
810 EXPECT_NE(advancesTest1, nullptr);
811 size_t advancesSize = OH_Drawing_GetDrawingArraySize(advancesTest1);
812 EXPECT_EQ(advancesSize, 2);
813
814 OH_Drawing_Point* advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advancesTest1, 0);
815 EXPECT_NE(advance, nullptr);
816 float x = 0.0;
817 OH_Drawing_PointGetX(advance, &x);
818 EXPECT_NEAR(x, 76.199921, FLOAT_DATA_EPSILON);
819
820 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advancesTest1, 1);
821 EXPECT_NE(advance, nullptr);
822 OH_Drawing_PointGetX(advance, &x);
823 EXPECT_NEAR(x, 0.000000, FLOAT_DATA_EPSILON);
824
825 run = OH_Drawing_GetRunByIndex(runs_, 3);
826 OH_Drawing_Array* advancesTest2 = OH_Drawing_GetRunGlyphAdvances(run, 0, 2);
827 EXPECT_NE(advancesTest2, nullptr);
828 advancesSize = OH_Drawing_GetDrawingArraySize(advancesTest2);
829 EXPECT_EQ(advancesSize, 2);
830
831 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advancesTest2, 0);
832 EXPECT_NE(advance, nullptr);
833 OH_Drawing_PointGetX(advance, &x);
834 EXPECT_NEAR(x, 76.199921, FLOAT_DATA_EPSILON);
835
836 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advancesTest2, 1);
837 EXPECT_NE(advance, nullptr);
838 OH_Drawing_PointGetX(advance, &x);
839 EXPECT_NEAR(x, 25.899979, FLOAT_DATA_EPSILON);
840
841 OH_Drawing_DestroyRunGlyphAdvances(advancesTest2);
842 OH_Drawing_FontDestroy(font);
843 }
844
845 /*
846 * @tc.name: GlyDrawingTest007
847 * @tc.desc: Test for the glyph drawing of the Sanskrit combination text.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(NdkRunTest, GlyDrawingTest007, TestSize.Level0)
851 {
852 text_ = "གྷHello你好藏文测试སྒྲ";
853 PrepareCreateTextLineForGlyphDrawing();
854 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs_, 0);
855 EXPECT_NE(run, nullptr);
856 OH_Drawing_Font* font = OH_Drawing_GetRunFont(run);
857 EXPECT_NE(font, nullptr);
858 OH_Drawing_Font_Metrics fontMetrics;
859 OH_Drawing_FontGetMetrics(font, &fontMetrics);
860 EXPECT_EQ(fontMetrics.flags, 31);
861 EXPECT_NEAR(fontMetrics.top, -110.679001, FLOAT_DATA_EPSILON);
862 EXPECT_NEAR(fontMetrics.ascent, -115.813995, FLOAT_DATA_EPSILON);
863 EXPECT_NEAR(fontMetrics.descent, 106.570999, FLOAT_DATA_EPSILON);
864 EXPECT_NEAR(fontMetrics.bottom, 78.605003, FLOAT_DATA_EPSILON);
865 EXPECT_NEAR(fontMetrics.leading, 0.0, FLOAT_DATA_EPSILON);
866 EXPECT_NEAR(fontMetrics.avgCharWidth, 49.848999, FLOAT_DATA_EPSILON);
867 EXPECT_NEAR(fontMetrics.maxCharWidth, 206.347992, FLOAT_DATA_EPSILON);
868
869 OH_Drawing_TextDirection direction = OH_Drawing_GetRunTextDirection(run);
870 EXPECT_EQ(direction, TEXT_DIRECTION_LTR);
871
872 OH_Drawing_Array* advancesTest1 = OH_Drawing_GetRunGlyphAdvances(run, 0, 1);
873 EXPECT_NE(advancesTest1, nullptr);
874 size_t advancesSize = OH_Drawing_GetDrawingArraySize(advancesTest1);
875 EXPECT_EQ(advancesSize, 1);
876
877 OH_Drawing_Point* advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advancesTest1, 0);
878 EXPECT_NE(advance, nullptr);
879 float x = 0.0;
880 OH_Drawing_PointGetX(advance, &x);
881 EXPECT_NEAR(x, 56.405991, FLOAT_DATA_EPSILON);
882 OH_Drawing_DestroyRunGlyphAdvances(advancesTest1);
883
884 run = OH_Drawing_GetRunByIndex(runs_, 3);
885 OH_Drawing_Array* advancesTest2 = OH_Drawing_GetRunGlyphAdvances(run, 0, 1);
886 EXPECT_NE(advancesTest2, nullptr);
887 advancesSize = OH_Drawing_GetDrawingArraySize(advancesTest2);
888 EXPECT_EQ(advancesSize, 1);
889 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advancesTest2, 0);
890 EXPECT_NE(advance, nullptr);
891 OH_Drawing_PointGetX(advance, &x);
892 EXPECT_NEAR(x, 53.324997, FLOAT_DATA_EPSILON);
893
894 OH_Drawing_DestroyRunGlyphAdvances(advancesTest2);
895 OH_Drawing_FontDestroy(font);
896 }
897
898 /*
899 * @tc.name: GlyDrawingTest008
900 * @tc.desc: Test for the glyph drawing of the Thai text.
901 * @tc.type: FUNC
902 */
903 HWTEST_F(NdkRunTest, GlyDrawingTest008, TestSize.Level0)
904 {
905 text_ = "\u0E01\u0E33\u0E41\u0E01Hello你好泰文测试";
906 PrepareCreateTextLineForGlyphDrawing();
907 OH_Drawing_Run* run = OH_Drawing_GetRunByIndex(runs_, 0);
908 EXPECT_NE(run, nullptr);
909
910 OH_Drawing_Font* font = OH_Drawing_GetRunFont(run);
911 EXPECT_NE(font, nullptr);
912 OH_Drawing_Font_Metrics fontMetrics;
913 OH_Drawing_FontGetMetrics(font, &fontMetrics);
914 EXPECT_EQ(fontMetrics.flags, 31);
915 EXPECT_NEAR(fontMetrics.top, -100.899994, FLOAT_DATA_EPSILON);
916 EXPECT_NEAR(fontMetrics.ascent, -106.099998, FLOAT_DATA_EPSILON);
917 EXPECT_NEAR(fontMetrics.descent, 45.000000, FLOAT_DATA_EPSILON);
918 EXPECT_NEAR(fontMetrics.bottom, 43.299999, FLOAT_DATA_EPSILON);
919 EXPECT_NEAR(fontMetrics.leading, 0.0, FLOAT_DATA_EPSILON);
920 EXPECT_NEAR(fontMetrics.avgCharWidth, 55.800003, FLOAT_DATA_EPSILON);
921 EXPECT_NEAR(fontMetrics.maxCharWidth, 165.100006, FLOAT_DATA_EPSILON);
922
923 OH_Drawing_TextDirection direction = OH_Drawing_GetRunTextDirection(run);
924 EXPECT_EQ(direction, TEXT_DIRECTION_LTR);
925
926 OH_Drawing_Array* advances = OH_Drawing_GetRunGlyphAdvances(run, 0, 5);
927 EXPECT_NE(advances, nullptr);
928 size_t advancesSize = OH_Drawing_GetDrawingArraySize(advances);
929 EXPECT_EQ(advancesSize, 5);
930
931 OH_Drawing_Point* advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 0);
932 EXPECT_NE(advance, nullptr);
933 float x = 0.0;
934 OH_Drawing_PointGetX(advance, &x);
935 EXPECT_NEAR(x, 59.999939, FLOAT_DATA_EPSILON);
936
937 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 1);
938 EXPECT_NE(advance, nullptr);
939 OH_Drawing_PointGetX(advance, &x);
940 EXPECT_NEAR(x, 0.000000, FLOAT_DATA_EPSILON);
941
942 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 2);
943 EXPECT_NE(advance, nullptr);
944 OH_Drawing_PointGetX(advance, &x);
945 EXPECT_NEAR(x, 40.599960, FLOAT_DATA_EPSILON);
946 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 3);
947 EXPECT_NE(advance, nullptr);
948 OH_Drawing_PointGetX(advance, &x);
949 EXPECT_NEAR(x, 56.799942, FLOAT_DATA_EPSILON);
950
951 advance = OH_Drawing_GetRunGlyphAdvanceByIndex(advances, 4);
952 EXPECT_NE(advance, nullptr);
953 OH_Drawing_PointGetX(advance, &x);
954 EXPECT_NEAR(x, 59.999939, FLOAT_DATA_EPSILON);
955
956 OH_Drawing_DestroyRunGlyphAdvances(advances);
957 OH_Drawing_FontDestroy(font);
958 }
959 } // namespace OHOS