1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, Hardware
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17 #include "drawing_brush.h"
18 #include "drawing_error_code.h"
19 #include "drawing_font.h"
20 #include "drawing_path.h"
21 #include "drawing_rect.h"
22 #include "drawing_typeface.h"
23 #include "drawing_pen.h"
24 #include "drawing_point.h"
25
26 #ifdef RS_ENABLE_VK
27 #include "platform/ohos/backend/rs_vulkan_context.h"
28 #endif
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 namespace Drawing {
36 constexpr float FLOAT_DATA_EPSILON = 1e-6f;
37 constexpr char TTF_FILE_PATH[] = {0x2F, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x2F, 0x66, 0x6F, 0x6E, 0x74, 0x73,
38 0x2F, 0x48, 0x61, 0x72, 0x6D, 0x6F, 0x6E, 0x79, 0x4F, 0x53, 0x5F, 0x53, 0x61, 0x6E, 0x73, 0x5F,
39 0x53, 0x43, 0x2E, 0x74, 0x74, 0x66, 0x00};
40 class NdkFontTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46 };
47
SetUpTestCase()48 void NdkFontTest::SetUpTestCase()
49 {
50 #ifdef RS_ENABLE_VK
51 RsVulkanContext::SetRecyclable(false);
52 #endif
53 }
TearDownTestCase()54 void NdkFontTest::TearDownTestCase() {}
SetUp()55 void NdkFontTest::SetUp() {}
TearDown()56 void NdkFontTest::TearDown() {}
57
58 /*
59 * @tc.name: GetMetrics001
60 * @tc.desc: test for GetMetrics.
61 * @tc.type: FUNC
62 * @tc.require: AR000GTO5R
63 */
64 HWTEST_F(NdkFontTest, GetMetrics001, TestSize.Level0)
65 {
66 OH_Drawing_Font* font = OH_Drawing_FontCreate();
67 EXPECT_NE(font, nullptr);
68 OH_Drawing_Font_Metrics cFontMetrics;
69 EXPECT_TRUE(OH_Drawing_FontGetMetrics(font, &cFontMetrics) >= 0);
70 EXPECT_TRUE(OH_Drawing_FontGetMetrics(font, nullptr) < 0);
71 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
72 EXPECT_TRUE(OH_Drawing_FontGetMetrics(nullptr, nullptr) < 0);
73 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
74 OH_Drawing_FontDestroy(font);
75 }
76
77 /*
78 * @tc.name: GetMetrics002
79 * @tc.desc: test for sans sc metrics data.
80 * @tc.type: FUNC
81 */
82 HWTEST_F(NdkFontTest, GetMetrics002, TestSize.Level0)
83 {
84 OH_Drawing_Font* font = OH_Drawing_FontCreate();
85 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromFile(TTF_FILE_PATH, 0);
86 OH_Drawing_FontSetTypeface(font, typeface);
87 OH_Drawing_Font_Metrics fontMetrics;
88 OH_Drawing_FontGetMetrics(font, &fontMetrics);
89 EXPECT_EQ(fontMetrics.flags, 31);
90 EXPECT_NEAR(fontMetrics.top, -12.672000, FLOAT_DATA_EPSILON);
91 EXPECT_NEAR(fontMetrics.ascent, -11.136000, FLOAT_DATA_EPSILON);
92 EXPECT_NEAR(fontMetrics.descent, 2.928000, FLOAT_DATA_EPSILON);
93 EXPECT_NEAR(fontMetrics.bottom, 3.252000, FLOAT_DATA_EPSILON);
94 EXPECT_NEAR(fontMetrics.leading, 0, FLOAT_DATA_EPSILON);
95 EXPECT_NEAR(fontMetrics.avgCharWidth, 6.000000, FLOAT_DATA_EPSILON);
96 EXPECT_NEAR(fontMetrics.maxCharWidth, 29.832001, FLOAT_DATA_EPSILON);
97 EXPECT_NEAR(fontMetrics.xMin, -6.576000, FLOAT_DATA_EPSILON);
98 EXPECT_NEAR(fontMetrics.xMax, 23.256001, FLOAT_DATA_EPSILON);
99 EXPECT_NEAR(fontMetrics.xHeight, 6.000000, FLOAT_DATA_EPSILON);
100 EXPECT_NEAR(fontMetrics.capHeight, 8.400000, FLOAT_DATA_EPSILON);
101 EXPECT_NEAR(fontMetrics.underlineThickness, 0.600000, FLOAT_DATA_EPSILON);
102 EXPECT_NEAR(fontMetrics.underlinePosition, 2.484000, FLOAT_DATA_EPSILON);
103 EXPECT_NEAR(fontMetrics.strikeoutThickness, 0.600000, FLOAT_DATA_EPSILON);
104 EXPECT_NEAR(fontMetrics.strikeoutPosition, -3.600000, FLOAT_DATA_EPSILON);
105 OH_Drawing_TypefaceDestroy(typeface);
106 OH_Drawing_FontDestroy(font);
107 }
108
109 /*
110 * @tc.name: GetMetrics003
111 * @tc.desc: test for symbol metrics data.
112 * @tc.type: FUNC
113 */
114 HWTEST_F(NdkFontTest, GetMetrics003, TestSize.Level0)
115 {
116 OH_Drawing_Font* font = OH_Drawing_FontCreate();
117 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromFile("/system/fonts/HMSymbolVF.ttf", 0);
118 OH_Drawing_FontSetTypeface(font, typeface);
119 OH_Drawing_Font_Metrics fontMetrics;
120 OH_Drawing_FontGetMetrics(font, &fontMetrics);
121 EXPECT_EQ(fontMetrics.flags, 31);
122 EXPECT_NEAR(fontMetrics.top, -10.559999, FLOAT_DATA_EPSILON);
123 EXPECT_NEAR(fontMetrics.ascent, -10.559999, FLOAT_DATA_EPSILON);
124 EXPECT_NEAR(fontMetrics.descent, 1.440000, FLOAT_DATA_EPSILON);
125 EXPECT_NEAR(fontMetrics.bottom, 1.440000, FLOAT_DATA_EPSILON);
126 EXPECT_NEAR(fontMetrics.leading, 0, FLOAT_DATA_EPSILON);
127 EXPECT_NEAR(fontMetrics.avgCharWidth, 12.000000, FLOAT_DATA_EPSILON);
128 EXPECT_NEAR(fontMetrics.maxCharWidth, 19.092001, FLOAT_DATA_EPSILON);
129 EXPECT_NEAR(fontMetrics.xMin, -0.684000, FLOAT_DATA_EPSILON);
130 EXPECT_NEAR(fontMetrics.xMax, 18.408001, FLOAT_DATA_EPSILON);
131 EXPECT_NEAR(fontMetrics.xHeight, 6.000000, FLOAT_DATA_EPSILON);
132 EXPECT_NEAR(fontMetrics.capHeight, 8.400000, FLOAT_DATA_EPSILON);
133 EXPECT_NEAR(fontMetrics.underlineThickness, 0.600000, FLOAT_DATA_EPSILON);
134 EXPECT_NEAR(fontMetrics.underlinePosition, 1.200000, FLOAT_DATA_EPSILON);
135 EXPECT_NEAR(fontMetrics.strikeoutThickness, 0.600000, FLOAT_DATA_EPSILON);
136 EXPECT_NEAR(fontMetrics.strikeoutPosition, -3.000000, FLOAT_DATA_EPSILON);
137 OH_Drawing_TypefaceDestroy(typeface);
138 OH_Drawing_FontDestroy(font);
139 }
140
141 /*
142 * @tc.name: GetMetrics004
143 * @tc.desc: test for emoji metrics data.
144 * @tc.type: FUNC
145 */
146 HWTEST_F(NdkFontTest, GetMetrics004, TestSize.Level0)
147 {
148 OH_Drawing_Font* font = OH_Drawing_FontCreate();
149 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromFile("/system/fonts/HMOSColorEmojiFlags.ttf", 0);
150 OH_Drawing_FontSetTypeface(font, typeface);
151 OH_Drawing_Font_Metrics fontMetrics;
152 OH_Drawing_FontGetMetrics(font, &fontMetrics);
153 EXPECT_EQ(fontMetrics.flags, 31);
154 EXPECT_NEAR(fontMetrics.top, -11.119267, FLOAT_DATA_EPSILON);
155 EXPECT_NEAR(fontMetrics.ascent, -11.119267, FLOAT_DATA_EPSILON);
156 EXPECT_NEAR(fontMetrics.descent, 2.972477, FLOAT_DATA_EPSILON);
157 EXPECT_NEAR(fontMetrics.bottom, 2.972477, FLOAT_DATA_EPSILON);
158 EXPECT_NEAR(fontMetrics.leading, 0, FLOAT_DATA_EPSILON);
159 EXPECT_NEAR(fontMetrics.avgCharWidth, 14.941406, FLOAT_DATA_EPSILON);
160 EXPECT_NEAR(fontMetrics.maxCharWidth, 14.972477, FLOAT_DATA_EPSILON);
161 EXPECT_NEAR(fontMetrics.xMin, 0, FLOAT_DATA_EPSILON);
162 EXPECT_NEAR(fontMetrics.xMax, 14.972477, FLOAT_DATA_EPSILON);
163 EXPECT_NEAR(fontMetrics.xHeight, 11.119267, FLOAT_DATA_EPSILON);
164 EXPECT_NEAR(fontMetrics.capHeight, 11.132812, FLOAT_DATA_EPSILON);
165 EXPECT_NEAR(fontMetrics.underlineThickness, 0.767578, FLOAT_DATA_EPSILON);
166 EXPECT_NEAR(fontMetrics.underlinePosition, 7.289062, FLOAT_DATA_EPSILON);
167 EXPECT_NEAR(fontMetrics.strikeoutThickness, 0.597656, FLOAT_DATA_EPSILON);
168 EXPECT_NEAR(fontMetrics.strikeoutPosition, -3.105469, FLOAT_DATA_EPSILON);
169 OH_Drawing_TypefaceDestroy(typeface);
170 OH_Drawing_FontDestroy(font);
171 }
172
173 /*
174 * @tc.name: IsAndSetBaselineSnap002
175 * @tc.desc: test for SetBaselineSnap and IsBaselineSnap.
176 * @tc.type: FUNC
177 * @tc.require: AR000GTO5R
178 */
179 HWTEST_F(NdkFontTest, IsAndSetBaselineSnap002, TestSize.Level0)
180 {
181 OH_Drawing_Font* font = OH_Drawing_FontCreate();
182 EXPECT_NE(font, nullptr);
183 OH_Drawing_FontSetBaselineSnap(nullptr, true);
184 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
185 EXPECT_EQ(OH_Drawing_FontIsBaselineSnap(nullptr), false);
186 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
187 OH_Drawing_FontSetBaselineSnap(nullptr, false);
188 EXPECT_EQ(OH_Drawing_FontIsBaselineSnap(nullptr), false);
189 OH_Drawing_FontSetBaselineSnap(font, true);
190 EXPECT_EQ(OH_Drawing_FontIsBaselineSnap(font), true);
191 OH_Drawing_FontSetBaselineSnap(font, false);
192 EXPECT_EQ(OH_Drawing_FontIsBaselineSnap(font), false);
193 OH_Drawing_FontDestroy(font);
194 }
195
196 /*
197 * @tc.name: IsAndSetSubpixel003
198 * @tc.desc: test for SetSubpixel and IsSubpixel.
199 * @tc.type: FUNC
200 * @tc.require: AR000GTO5R
201 */
202 HWTEST_F(NdkFontTest, IsAndSetSubpixel003, TestSize.Level0)
203 {
204 OH_Drawing_Font* font = OH_Drawing_FontCreate();
205 EXPECT_NE(font, nullptr);
206 OH_Drawing_FontSetSubpixel(nullptr, false);
207 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
208 EXPECT_EQ(OH_Drawing_FontIsSubpixel(nullptr), false);
209 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
210 OH_Drawing_FontSetSubpixel(nullptr, true);
211 EXPECT_EQ(OH_Drawing_FontIsSubpixel(nullptr), false);
212 OH_Drawing_FontSetSubpixel(font, true);
213 EXPECT_EQ(OH_Drawing_FontIsSubpixel(font), true);
214 OH_Drawing_FontSetSubpixel(font, false);
215 EXPECT_EQ(OH_Drawing_FontIsSubpixel(font), false);
216 OH_Drawing_FontDestroy(font);
217 }
218
219 /*
220 * @tc.name: TextToGlyphs004
221 * @tc.desc: test for TextToGlyphs.
222 * @tc.type: FUNC
223 * @tc.require: AR000GTO5R
224 */
225 HWTEST_F(NdkFontTest, TextToGlyphs004, TestSize.Level0)
226 {
227 OH_Drawing_Font* font = OH_Drawing_FontCreate();
228 OH_Drawing_FontSetTextSize(font, 100); // 100 means font text size
229 EXPECT_NE(font, nullptr);
230 const char *str = "hello world";
231 OH_Drawing_FontCountText(nullptr, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
232 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
233 OH_Drawing_FontCountText(font, nullptr, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
234 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
235 uint32_t count = 0;
236 count = OH_Drawing_FontCountText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
237 EXPECT_EQ(11, count); // 11 means str length
238
239 uint16_t glyphs[50] = {0}; // 50 means glyphs array number
240 OH_Drawing_FontTextToGlyphs(nullptr, str, 0, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, 0);
241 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
242 OH_Drawing_FontTextToGlyphs(font, nullptr, 0, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, 0);
243 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
244 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, nullptr, 0);
245 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
246 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, 0);
247 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
248 int glyphsCount = 1;
249 glyphsCount = OH_Drawing_FontTextToGlyphs(font, str, 0,
250 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, 0);
251 EXPECT_EQ(0, glyphsCount);
252 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
253
254 glyphsCount = OH_Drawing_FontTextToGlyphs(font, str, strlen(str),
255 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count);
256 EXPECT_EQ(11, glyphsCount); // 11 means glyphsCount
257
258 float widths[50] = {0.f}; // 50 means widths array number
259 OH_Drawing_FontGetWidths(nullptr, glyphs, glyphsCount, widths);
260 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
261 OH_Drawing_FontGetWidths(font, nullptr, glyphsCount, widths);
262 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
263 OH_Drawing_FontGetWidths(font, glyphs, 0, widths);
264 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
265 OH_Drawing_FontGetWidths(font, glyphs, glyphsCount, nullptr);
266 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
267 OH_Drawing_FontGetWidths(font, glyphs, glyphsCount, widths);
268 EXPECT_EQ(58.0, widths[0]); // 58.0 means glyphs[0] width
269 OH_Drawing_FontDestroy(font);
270 }
271
272 /*
273 * @tc.name: SetAndGetScaleX005
274 * @tc.desc: test for SetAndGetScaleX.
275 * @tc.type: FUNC
276 * @tc.require: AR000GTO5R
277 */
278 HWTEST_F(NdkFontTest, SetAndGetScaleX005, TestSize.Level0)
279 {
280 OH_Drawing_Font* font = OH_Drawing_FontCreate();
281 EXPECT_NE(font, nullptr);
282 OH_Drawing_FontSetScaleX(nullptr, 2);
283 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
284 EXPECT_TRUE(OH_Drawing_FontGetScaleX(nullptr) == -1);
285 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
286 EXPECT_TRUE(OH_Drawing_FontGetScaleX(font) == 1);
287 OH_Drawing_FontSetScaleX(font, 2);
288 EXPECT_TRUE(OH_Drawing_FontGetScaleX(font) == 2);
289 OH_Drawing_FontDestroy(font);
290 }
291
292 /*
293 * @tc.name: GetAndSetEdging006
294 * @tc.desc: test for GetAndSetEdging.
295 * @tc.type: FUNC
296 * @tc.require: AR000GTO5R
297 */
298 HWTEST_F(NdkFontTest, GetAndSetEdging006, TestSize.Level0)
299 {
300 OH_Drawing_Font* font = OH_Drawing_FontCreate();
301 EXPECT_NE(font, nullptr);
302 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_ANTI_ALIAS);
303 EXPECT_EQ(OH_Drawing_FontGetEdging(nullptr), OH_Drawing_FontEdging::FONT_EDGING_ALIAS);
304 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
305 OH_Drawing_FontSetEdging(nullptr, OH_Drawing_FontEdging::FONT_EDGING_ALIAS);
306 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
307 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_ANTI_ALIAS);
308 OH_Drawing_FontSetEdging(font, OH_Drawing_FontEdging::FONT_EDGING_ALIAS);
309 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_ALIAS);
310 OH_Drawing_FontSetEdging(font, OH_Drawing_FontEdging::FONT_EDGING_ANTI_ALIAS);
311 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_ANTI_ALIAS);
312 OH_Drawing_FontSetEdging(font, OH_Drawing_FontEdging::FONT_EDGING_SUBPIXEL_ANTI_ALIAS);
313 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_SUBPIXEL_ANTI_ALIAS);
314 OH_Drawing_FontDestroy(font);
315 }
316
317 /*
318 * @tc.name: GetAndSetForceAutoHinting007
319 * @tc.desc: test for GetAndSetForceAutoHinting.
320 * @tc.type: FUNC
321 * @tc.require: AR000GTO5R
322 */
323 HWTEST_F(NdkFontTest, GetAndSetForceAutoHinting007, TestSize.Level0)
324 {
325 OH_Drawing_Font* font = OH_Drawing_FontCreate();
326 EXPECT_NE(font, nullptr);
327 EXPECT_EQ(OH_Drawing_FontIsForceAutoHinting(nullptr), false);
328 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
329 OH_Drawing_FontSetForceAutoHinting(nullptr, true);
330 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
331 EXPECT_EQ(OH_Drawing_FontIsForceAutoHinting(font), false);
332 OH_Drawing_FontSetForceAutoHinting(font, true);
333 EXPECT_EQ(OH_Drawing_FontIsForceAutoHinting(font), true);
334 OH_Drawing_FontSetForceAutoHinting(font, false);
335 EXPECT_EQ(OH_Drawing_FontIsForceAutoHinting(font), false);
336 OH_Drawing_FontDestroy(font);
337 }
338
339 /*
340 * @tc.name: GetAndSetHinting008
341 * @tc.desc: test for GetHinting and SetHinting.
342 * @tc.type: FUNC
343 * @tc.require: AR000GTO5R
344 */
345 HWTEST_F(NdkFontTest, GetAndSetHinting008, TestSize.Level0)
346 {
347 OH_Drawing_Font* font = OH_Drawing_FontCreate();
348 EXPECT_NE(font, nullptr);
349 EXPECT_TRUE(OH_Drawing_FontGetHinting(nullptr) == OH_Drawing_FontHinting::FONT_HINTING_NONE);
350 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
351 OH_Drawing_FontSetHinting(nullptr, OH_Drawing_FontHinting::FONT_HINTING_NONE);
352 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
353 OH_Drawing_FontSetHinting(font, OH_Drawing_FontHinting::FONT_HINTING_NONE);
354 EXPECT_TRUE(OH_Drawing_FontGetHinting(font) == OH_Drawing_FontHinting::FONT_HINTING_NONE);
355 OH_Drawing_FontSetHinting(font, OH_Drawing_FontHinting::FONT_HINTING_SLIGHT);
356 EXPECT_TRUE(OH_Drawing_FontGetHinting(font) == OH_Drawing_FontHinting::FONT_HINTING_SLIGHT);
357 OH_Drawing_FontSetHinting(font, OH_Drawing_FontHinting::FONT_HINTING_SLIGHT);
358 EXPECT_TRUE(OH_Drawing_FontGetHinting(font) == OH_Drawing_FontHinting::FONT_HINTING_SLIGHT);
359 OH_Drawing_FontDestroy(font);
360 }
361
362 /*
363 * @tc.name: GetAndSetEmbeddedBitmaps009
364 * @tc.desc: test for GetEmbeddedBitmaps and SetEmbeddedBitmaps.
365 * @tc.type: FUNC
366 * @tc.require: AR000GTO5R
367 */
368 HWTEST_F(NdkFontTest, GetAndSetEmbeddedBitmaps009, TestSize.Level0)
369 {
370 OH_Drawing_Font* font = OH_Drawing_FontCreate();
371 EXPECT_NE(font, nullptr);
372 EXPECT_TRUE(OH_Drawing_FontIsEmbeddedBitmaps(nullptr) == false);
373 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
374 OH_Drawing_FontSetEmbeddedBitmaps(nullptr, true);
375 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
376 OH_Drawing_FontSetEmbeddedBitmaps(font, true);
377 EXPECT_TRUE(OH_Drawing_FontIsEmbeddedBitmaps(font) == true);
378 OH_Drawing_FontSetEmbeddedBitmaps(font, false);
379 EXPECT_TRUE(OH_Drawing_FontIsEmbeddedBitmaps(font) == false);
380 OH_Drawing_FontDestroy(font);
381 }
382
383 /*
384 * @tc.name: GetTextSize010
385 * @tc.desc: test for GetTextSize.
386 * @tc.type: FUNC
387 * @tc.require: AR000GTO5R
388 */
389 HWTEST_F(NdkFontTest, GetTextSize010, TestSize.Level0)
390 {
391 OH_Drawing_Font* font = OH_Drawing_FontCreate();
392 EXPECT_NE(font, nullptr);
393 OH_Drawing_FontSetTextSize(nullptr, 100);
394 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
395 OH_Drawing_FontGetTextSize(nullptr);
396 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
397 OH_Drawing_FontSetTextSize(font, 100);
398 float size = OH_Drawing_FontGetTextSize(font);
399 EXPECT_EQ(size, 100);
400 OH_Drawing_FontDestroy(font);
401 }
402
403 /*
404 * @tc.name: GetTextSkewX011
405 * @tc.desc: test for GetTextSkewX.
406 * @tc.type: FUNC
407 * @tc.require: AR000GTO5R
408 */
409 HWTEST_F(NdkFontTest, GetTextSkewX011, TestSize.Level0)
410 {
411 OH_Drawing_Font* font = OH_Drawing_FontCreate();
412 EXPECT_NE(font, nullptr);
413 OH_Drawing_FontSetTextSkewX(nullptr, 10);
414 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
415 OH_Drawing_FontGetTextSkewX(nullptr);
416 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
417 OH_Drawing_FontSetTextSkewX(font, 10);
418 float size = OH_Drawing_FontGetTextSkewX(font);
419 EXPECT_EQ(size, 10);
420 OH_Drawing_FontDestroy(font);
421 }
422
423 /*
424 * @tc.name: IsLinearText012
425 * @tc.desc: test for IsLinearText.
426 * @tc.type: FUNC
427 * @tc.require: AR000GTO5R
428 */
429 HWTEST_F(NdkFontTest, IsLinearText012, TestSize.Level0)
430 {
431 OH_Drawing_Font* font = OH_Drawing_FontCreate();
432 EXPECT_NE(font, nullptr);
433 OH_Drawing_FontSetLinearText(nullptr, true);
434 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
435 OH_Drawing_FontIsLinearText(nullptr);
436 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
437 bool ret = OH_Drawing_FontIsLinearText(font);
438 EXPECT_EQ(ret, false);
439 OH_Drawing_FontSetLinearText(font, true);
440 ret = OH_Drawing_FontIsLinearText(font);
441 EXPECT_EQ(ret, true);
442 OH_Drawing_FontDestroy(font);
443 }
444
445 /*
446 * @tc.name: SetFakeBoldText013
447 * @tc.desc: test for SetFakeBoldText.
448 * @tc.type: FUNC
449 * @tc.require: AR000GTO5R
450 */
451 HWTEST_F(NdkFontTest, SetFakeBoldText013, TestSize.Level0)
452 {
453 OH_Drawing_Font* font = OH_Drawing_FontCreate();
454 EXPECT_NE(font, nullptr);
455 OH_Drawing_FontSetFakeBoldText(nullptr, true);
456 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
457 OH_Drawing_FontIsFakeBoldText(nullptr);
458 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
459 bool ret = OH_Drawing_FontIsFakeBoldText(font);
460 EXPECT_EQ(ret, false);
461 OH_Drawing_FontSetFakeBoldText(font, true);
462 ret = OH_Drawing_FontIsFakeBoldText(font);
463 EXPECT_EQ(ret, true);
464 OH_Drawing_FontDestroy(font);
465 }
466
467 /*
468 * @tc.name: FontMeasureText014
469 * @tc.desc: test for FontMeasureText.
470 * @tc.type: FUNC
471 * @tc.require: AR000GTO5R
472 */
473 HWTEST_F(NdkFontTest, FontMeasureText014, TestSize.Level0)
474 {
475 OH_Drawing_Font* font = OH_Drawing_FontCreate();
476 EXPECT_NE(font, nullptr);
477 OH_Drawing_FontSetTextSize(font, 50);
478 const char* str = "hello world";
479 float textWidth = 0.f;
480 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_SUCCESS;
481 drawingErrorCode = OH_Drawing_FontMeasureText(nullptr, str, strlen(str),
482 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, nullptr, &textWidth);
483 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
484 EXPECT_EQ(textWidth, 0.f);
485 drawingErrorCode = OH_Drawing_FontMeasureText(font, str, 0, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
486 nullptr, &textWidth);
487 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
488 EXPECT_EQ(textWidth, 0.f);
489 drawingErrorCode = OH_Drawing_FontMeasureText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
490 nullptr, &textWidth);
491 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS);
492 EXPECT_EQ(textWidth, 254.0); // 254.0 is textWidth
493
494 OH_Drawing_FontDestroy(font);
495 }
496
497 /*
498 * @tc.name: FontMeasureSingleCharacter015
499 * @tc.desc: test for OH_Drawing_FontMeasureSingleCharacter.
500 * @tc.type: FUNC
501 * @tc.require: AR000GTO5R
502 */
503 HWTEST_F(NdkFontTest, FontMeasureSingleCharacter015, TestSize.Level0)
504 {
505 OH_Drawing_Font* font = OH_Drawing_FontCreate();
506 EXPECT_NE(font, nullptr);
507 OH_Drawing_FontSetTextSize(font, 50); // 50 means font text size
508 const char* strOne = "a";
509 const char* strTwo = "你好";
510 float textWidth = 0.f;
511 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_SUCCESS;
512 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(nullptr, strOne, &textWidth);
513 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
514 EXPECT_EQ(textWidth, 0.f);
515 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, nullptr, &textWidth);
516 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
517 EXPECT_EQ(textWidth, 0.f);
518 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, strOne, nullptr);
519 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
520 EXPECT_EQ(textWidth, 0.f);
521 const char* strThree = "";
522 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, strThree, &textWidth);
523 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
524 EXPECT_EQ(textWidth, 0.f);
525 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, strOne, &textWidth);
526 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS);
527 EXPECT_TRUE(textWidth > 0);
528 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, strTwo, &textWidth);
529 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS);
530 EXPECT_TRUE(textWidth > 0);
531 OH_Drawing_FontDestroy(font);
532 }
533
534 /*
535 * @tc.name: FontCreatePathForGlyph001
536 * @tc.desc: test for common character of glyph ID.
537 * @tc.type: FUNC
538 * @tc.require:
539 */
540 HWTEST_F(NdkFontTest, FontGetPathForGlyph001, TestSize.Level0)
541 {
542 OH_Drawing_Font* font = OH_Drawing_FontCreate();
543 EXPECT_NE(font, nullptr);
544 OH_Drawing_FontSetTextSize(font, 50);
545 const char* str = "helloworld";
546 uint32_t count = OH_Drawing_FontCountText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
547 EXPECT_EQ(strlen(str), count);
548 uint16_t glyphs[count];
549 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count);
550 std::vector result = { 160.50444, 116.570892, 84.6191406, 84.6191406, 80.983223, 195.274139, 80.983223, 83.3096237,
551 84.6191406, 126.002419 };
552 for (int i = 0; i < count; i++) {
553 OH_Drawing_Path* path = OH_Drawing_PathCreate();
554 ASSERT_NE(path, nullptr);
555 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(font, glyphs[i], path), OH_DRAWING_SUCCESS);
556 EXPECT_LE(std::abs(OH_Drawing_PathGetLength(path, false) - result[i]), 0.01);
557 EXPECT_TRUE(OH_Drawing_PathIsClosed(path, false));
558 OH_Drawing_PathDestroy(path);
559 }
560 OH_Drawing_FontDestroy(font);
561 }
562
563 /*
564 * @tc.name: FontCreatePathForGlyph002
565 * @tc.desc: test for space character of glyph ID.
566 * @tc.type: FUNC
567 * @tc.require:
568 */
569 HWTEST_F(NdkFontTest, FontGetPathForGlyph002, TestSize.Level0)
570 {
571 OH_Drawing_Font* font = OH_Drawing_FontCreate();
572 EXPECT_NE(font, nullptr);
573 OH_Drawing_FontSetTextSize(font, 50);
574 const char* space = " ";
575 uint32_t count = OH_Drawing_FontCountText(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
576 EXPECT_EQ(strlen(space), count);
577 uint16_t glyphs[count];
578 OH_Drawing_FontTextToGlyphs(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
579 glyphs, count);
580 OH_Drawing_Path* path = OH_Drawing_PathCreate();
581 ASSERT_NE(path, nullptr);
582 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(font, glyphs[0], path), OH_DRAWING_SUCCESS);
583 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) == 0);
584 EXPECT_FALSE(OH_Drawing_PathIsClosed(path, false));
585 if (path != nullptr) {
586 OH_Drawing_PathDestroy(path);
587 }
588 OH_Drawing_FontDestroy(font);
589 }
590
591 /*
592 * @tc.name: FontCreatePathForGlyph003
593 * @tc.desc: test for abnormal parameter
594 * @tc.type: FUNC
595 * @tc.require:
596 */
597 HWTEST_F(NdkFontTest, FontGetPathForGlyph003, TestSize.Level0)
598 {
599 OH_Drawing_Font* font = OH_Drawing_FontCreate();
600 EXPECT_NE(font, nullptr);
601 OH_Drawing_FontSetTextSize(font, 50);
602 const char* str = "hello world";
603 uint32_t count = OH_Drawing_FontCountText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
604 EXPECT_EQ(strlen(str), count);
605 uint16_t glyphs[count];
606 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
607 glyphs, count);
608
609 OH_Drawing_Path* path = OH_Drawing_PathCreate();
610 ASSERT_NE(path, nullptr);
611 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(nullptr, glyphs[0], path), OH_DRAWING_ERROR_INVALID_PARAMETER);
612 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(font, glyphs[0], nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER);
613 if (path != nullptr) {
614 OH_Drawing_PathDestroy(path);
615 }
616 OH_Drawing_FontDestroy(font);
617 }
618
619 /*
620 * @tc.name: FontCreatePathForGlyph004
621 * @tc.desc: test for non exist glyph ID.
622 * @tc.type: FUNC
623 * @tc.require:
624 */
625 HWTEST_F(NdkFontTest, FontGetPathForGlyph004, TestSize.Level0)
626 {
627 OH_Drawing_Font* font = OH_Drawing_FontCreate();
628 EXPECT_NE(font, nullptr);
629 OH_Drawing_FontSetTextSize(font, 50);
630 uint16_t glyphsNotExist = 65535;
631 OH_Drawing_Path* path = OH_Drawing_PathCreate();
632 ASSERT_NE(path, nullptr);
633 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(font, glyphsNotExist, path), OH_DRAWING_ERROR_INVALID_PARAMETER);
634 if (path != nullptr) {
635 OH_Drawing_PathDestroy(path);
636 }
637 OH_Drawing_FontDestroy(font);
638 }
639
640 /*
641 * @tc.name: FontGetBounds001
642 * @tc.desc: test for common character of glyph ID.
643 * @tc.type: FUNC
644 * @tc.require:
645 */
646 HWTEST_F(NdkFontTest, FontGetBounds001, TestSize.Level0)
647 {
648 OH_Drawing_Font* font = OH_Drawing_FontCreate();
649 EXPECT_NE(font, nullptr);
650 OH_Drawing_FontSetTextSize(font, 50);
651 const char* str = "helloworld";
652 uint32_t count = OH_Drawing_FontCountText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
653 EXPECT_EQ(strlen(str), count);
654 uint16_t glyphs[count];
655 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
656 glyphs, count);
657 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count);
658 ASSERT_NE(outRectarr, nullptr);
659 size_t size = 0;
660 EXPECT_EQ(OH_Drawing_RectGetArraySize(outRectarr, &size), OH_DRAWING_SUCCESS);
661 EXPECT_EQ(size, count);
662 EXPECT_EQ(OH_Drawing_FontGetBounds(font, glyphs, count, outRectarr), OH_DRAWING_SUCCESS);
663 std::vector<std::array<int, 4>> arr = { { 23, 39, -39, 3 }, { 25, 28, -27, 2 }, { 6, 39, -39, 3 },
664 { 6, 39, -39, 3 }, { 26, 28, -27, 2 }, { 39, 26, -26, 0 }, { 26, 28, -27, 2 }, { 16, 27, -27, 3 },
665 { 6, 39, -39, 3 }, { 25, 40, -39, 2 } };
666 for (int i = 0; i < count; i++) {
667 OH_Drawing_Rect* iter = nullptr;
668 EXPECT_EQ(OH_Drawing_RectGetArrayElement(outRectarr, i, &iter), OH_DRAWING_SUCCESS);
669 ASSERT_NE(iter, nullptr);
670 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetWidth(iter)), arr[i][0]);
671 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetHeight(iter)), arr[i][1]);
672 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetTop(iter)), arr[i][2]);
673 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetLeft(iter)), arr[i][3]);
674 EXPECT_EQ(OH_Drawing_RectGetBottom(iter) - OH_Drawing_RectGetTop(iter), OH_Drawing_RectGetHeight(iter));
675 EXPECT_EQ(OH_Drawing_RectGetRight(iter) - OH_Drawing_RectGetLeft(iter), OH_Drawing_RectGetWidth(iter));
676 }
677 EXPECT_EQ(OH_Drawing_RectDestroyArray(outRectarr), OH_DRAWING_SUCCESS);
678
679 OH_Drawing_FontDestroy(font);
680 }
681
682 /*
683 * @tc.name: FontGetBounds002
684 * @tc.desc: test for space character of glyph ID.
685 * @tc.type: FUNC
686 * @tc.require:
687 */
688 HWTEST_F(NdkFontTest, FontGetBounds002, TestSize.Level0)
689 {
690 OH_Drawing_Font* font = OH_Drawing_FontCreate();
691 EXPECT_NE(font, nullptr);
692 OH_Drawing_FontSetTextSize(font, 50);
693 const char* space = " ";
694 uint32_t count = OH_Drawing_FontCountText(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
695 EXPECT_EQ(strlen(space), count);
696 uint16_t glyphs[count];
697 OH_Drawing_FontTextToGlyphs(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
698 glyphs, count);
699 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count);
700 ASSERT_NE(outRectarr, nullptr);
701 size_t size = 0;
702 EXPECT_EQ(OH_Drawing_RectGetArraySize(outRectarr, &size), OH_DRAWING_SUCCESS);
703 EXPECT_EQ(size, count);
704 EXPECT_EQ(OH_Drawing_FontGetBounds(font, glyphs, count, outRectarr), OH_DRAWING_SUCCESS);
705 for (int i = 0; i < count; i++) {
706 OH_Drawing_Rect *iter = nullptr;
707 EXPECT_EQ(OH_Drawing_RectGetArrayElement(outRectarr, i, &iter), OH_DRAWING_SUCCESS);
708 ASSERT_NE(iter, nullptr);
709 EXPECT_EQ(OH_Drawing_RectGetWidth(iter), 0);
710 EXPECT_EQ(OH_Drawing_RectGetHeight(iter), 0);
711 }
712 EXPECT_EQ(OH_Drawing_RectDestroyArray(outRectarr), OH_DRAWING_SUCCESS);
713 OH_Drawing_FontDestroy(font);
714 }
715
716 /*
717 * @tc.name: FontGetBounds003
718 * @tc.desc: test for abnormal parameter
719 * @tc.type: FUNC
720 * @tc.require:
721 */
722 HWTEST_F(NdkFontTest, FontGetBounds003, TestSize.Level0)
723 {
724 OH_Drawing_Font* font = OH_Drawing_FontCreate();
725 EXPECT_NE(font, nullptr);
726 OH_Drawing_FontSetTextSize(font, 50);
727 const char* space = " ";
728 uint32_t count = OH_Drawing_FontCountText(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
729 EXPECT_EQ(strlen(space), count);
730 uint16_t glyphs[count];
731 OH_Drawing_FontTextToGlyphs(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
732 glyphs, count);
733 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count - 1);
734 ASSERT_NE(outRectarr, nullptr);
735 // not enough size
736 EXPECT_EQ(OH_Drawing_FontGetBounds(font, glyphs, count, outRectarr), OH_DRAWING_ERROR_INVALID_PARAMETER);
737 EXPECT_EQ(OH_Drawing_FontGetBounds(nullptr, glyphs, count, outRectarr), OH_DRAWING_ERROR_INVALID_PARAMETER);
738 EXPECT_EQ(OH_Drawing_FontGetBounds(font, nullptr, count, outRectarr), OH_DRAWING_ERROR_INVALID_PARAMETER);
739 EXPECT_EQ(OH_Drawing_FontGetBounds(font, glyphs, count, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER);
740 EXPECT_EQ(OH_Drawing_RectDestroyArray(outRectarr), OH_DRAWING_SUCCESS);
741 OH_Drawing_FontDestroy(font);
742 }
743
744 /*
745 * @tc.name: FontGetTextPath001
746 * @tc.desc: test for common character of textpath.
747 * @tc.type: FUNC
748 * @tc.require: IAKP0I
749 */
750 HWTEST_F(NdkFontTest, FontGetTextPath001, TestSize.Level0)
751 {
752 OH_Drawing_Font* font = OH_Drawing_FontCreate();
753 EXPECT_NE(font, nullptr);
754 const char* str = "Hello 中文";
755 size_t length = std::char_traits<char>::length(str);
756 float x = 12.0f;
757 float y = 150.0f;
758 OH_Drawing_Path* path = OH_Drawing_PathCreate();
759 ASSERT_NE(path, nullptr);
760 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, str, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
761 OH_DRAWING_SUCCESS);
762 ASSERT_NE(path, nullptr);
763 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) > 0);
764 if (path != nullptr) {
765 OH_Drawing_PathDestroy(path);
766 }
767 OH_Drawing_FontDestroy(font);
768 }
769
770 /*
771 * @tc.name: FontGetTextPath002
772 * @tc.desc: test for UTF16 and UTF32 character of textpath.
773 * @tc.type: FUNC
774 * @tc.require: IAKP0I
775 */
776 HWTEST_F(NdkFontTest, FontGetTextPath002, TestSize.Level0)
777 {
778 OH_Drawing_Font* font = OH_Drawing_FontCreate();
779 EXPECT_NE(font, nullptr);
780
781 float x = 12.0f;
782 float y = 150.0f;
783 const char16_t* u16str = u"Hello 中文";
784 size_t u16strLen = std::char_traits<char16_t>::length(u16str);
785 OH_Drawing_Path* path = OH_Drawing_PathCreate();
786 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, u16str, sizeof(char16_t) * u16strLen, TEXT_ENCODING_UTF16, x, y, path),
787 OH_DRAWING_SUCCESS);
788 ASSERT_NE(path, nullptr);
789 float u16PathLen = OH_Drawing_PathGetLength(path, false);
790
791 const char32_t* u32str = U"Hello 中文";
792 size_t u32strLen = std::char_traits<char32_t>::length(u32str);
793 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, u32str, sizeof(char32_t) * u32strLen, TEXT_ENCODING_UTF32, x, y, path),
794 OH_DRAWING_SUCCESS);
795 ASSERT_NE(path, nullptr);
796 float u32PathLen = OH_Drawing_PathGetLength(path, false);
797 ASSERT_TRUE(u16PathLen > 0 && u32PathLen > 0);
798 ASSERT_EQ(u16PathLen, u32PathLen);
799 if (path != nullptr) {
800 OH_Drawing_PathDestroy(path);
801 }
802 OH_Drawing_FontDestroy(font);
803 }
804
805 /*
806 * @tc.name: FontGetTextPath003
807 * @tc.desc: test for space character of textpath.
808 * @tc.type: FUNC
809 * @tc.require: IAKP0I
810 */
811 HWTEST_F(NdkFontTest, FontGetTextPath003, TestSize.Level0)
812 {
813 OH_Drawing_Font* font = OH_Drawing_FontCreate();
814 EXPECT_NE(font, nullptr);
815 const char* space = " ";
816 size_t length = std::char_traits<char>::length(space);
817 float x = 12.0f;
818 float y = 150.0f;
819 OH_Drawing_Path* path = OH_Drawing_PathCreate();
820 ASSERT_NE(path, nullptr);
821 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, space, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
822 OH_DRAWING_SUCCESS);
823 ASSERT_NE(path, nullptr);
824 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) == 0);
825 EXPECT_FALSE(OH_Drawing_PathIsClosed(path, false));
826 if (path != nullptr) {
827 OH_Drawing_PathDestroy(path);
828 }
829 OH_Drawing_FontDestroy(font);
830 }
831
832 /*
833 * @tc.name: FontGetTextPath004
834 * @tc.desc: test for abnormal paramete of textpath.
835 * @tc.type: FUNC
836 * @tc.require: IAKP0I
837 */
838 HWTEST_F(NdkFontTest, FontGetTextPath004, TestSize.Level0)
839 {
840 OH_Drawing_Font* font = OH_Drawing_FontCreate();
841 EXPECT_NE(font, nullptr);
842 const char* str = "Hello 中文";
843 size_t length = std::char_traits<char>::length(str);
844 float x = 12.0f;
845 float y = 150.0f;
846 OH_Drawing_Path* path = OH_Drawing_PathCreate();
847 ASSERT_NE(path, nullptr);
848 EXPECT_EQ(OH_Drawing_FontGetTextPath(nullptr, str, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
849 OH_DRAWING_ERROR_INVALID_PARAMETER);
850 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, nullptr, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
851 OH_DRAWING_ERROR_INVALID_PARAMETER);
852 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, str, 0, TEXT_ENCODING_UTF8, x, y, path),
853 OH_DRAWING_ERROR_INVALID_PARAMETER);
854 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, str, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, nullptr),
855 OH_DRAWING_ERROR_INVALID_PARAMETER);
856 OH_Drawing_FontDestroy(font);
857 }
858
859 /*
860 * @tc.name: FontGetTextPath005
861 * @tc.desc: test for negative coordinates of textpath.
862 * @tc.type: FUNC
863 * @tc.require: IAKP0I
864 */
865 HWTEST_F(NdkFontTest, FontGetTextPath005, TestSize.Level0)
866 {
867 OH_Drawing_Font* font = OH_Drawing_FontCreate();
868 EXPECT_NE(font, nullptr);
869 const char* str = "Hello 中文";
870 size_t length = std::char_traits<char>::length(str);
871 float x = -1.0f;
872 float y = -1.0f;
873 OH_Drawing_Path* path = OH_Drawing_PathCreate();
874 ASSERT_NE(path, nullptr);
875 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, str, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
876 OH_DRAWING_SUCCESS);
877 ASSERT_NE(path, nullptr);
878 if (path != nullptr) {
879 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) > 0);
880 OH_Drawing_PathDestroy(path);
881 }
882 OH_Drawing_FontDestroy(font);
883 }
884
885 /*
886 * @tc.name: FontGetTextPath006
887 * @tc.desc: test for conversion of glyphsID to path.
888 * @tc.type: FUNC
889 * @tc.require: IAKP0I
890 */
891 HWTEST_F(NdkFontTest, FontGetTextPath006, TestSize.Level0)
892 {
893 OH_Drawing_Font* font = OH_Drawing_FontCreate();
894 EXPECT_NE(font, nullptr);
895 const char* str = "Hello 中文";
896 uint32_t count = 0;
897 count = OH_Drawing_FontCountText(font, str, strlen(str), TEXT_ENCODING_UTF8);
898 EXPECT_NE(count, 0);
899 uint16_t glyphs[count];
900 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), TEXT_ENCODING_UTF8, glyphs, count);
901
902 float x = 12.0f;
903 float y = 150.0f;
904 OH_Drawing_Path* path = OH_Drawing_PathCreate();
905 ASSERT_NE(path, nullptr);
906 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, glyphs, sizeof(glyphs), TEXT_ENCODING_GLYPH_ID, x, y, path),
907 OH_DRAWING_SUCCESS);
908 ASSERT_NE(path, nullptr);
909 if (path != nullptr) {
910 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) > 0);
911 OH_Drawing_PathDestroy(path);
912 }
913 OH_Drawing_FontDestroy(font);
914 }
915
916 /*
917 * @tc.name: FontThemeFont001
918 * @tc.desc: test for theme font.
919 * @tc.type: FUNC
920 * @tc.require: IAKP0I
921 */
922 HWTEST_F(NdkFontTest, FontThemeFont001, TestSize.Level0)
923 {
924 OH_Drawing_Font* font = OH_Drawing_FontCreate();
925 EXPECT_NE(font, nullptr);
926 bool followed = true;
927 OH_Drawing_FontIsThemeFontFollowed(font, &followed);
928 EXPECT_EQ(followed, false);
929 OH_Drawing_FontSetThemeFontFollowed(font, true);
930 OH_Drawing_FontIsThemeFontFollowed(font, &followed);
931 EXPECT_EQ(followed, true);
932 OH_Drawing_FontDestroy(font);
933 }
934
935 /*
936 * @tc.name: FontMeasureTextWithBrushOrPen001
937 * @tc.desc: test for FontMeasureTextWithBrushOrPen.
938 * @tc.type: FUNC
939 * @tc.require: AR20250515745872
940 */
941 HWTEST_F(NdkFontTest, FontMeasureTextWithBrushOrPen001, TestSize.Level0)
942 {
943 OH_Drawing_Font *font = OH_Drawing_FontCreate();
944 OH_Drawing_FontSetTextSize(font, 50);
945 const char* text = "你好世界";
946 float textWidth;
947 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate();
948 OH_Drawing_Pen* pen = OH_Drawing_PenCreate();
949 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(nullptr, text, strlen(text),
950 TEXT_ENCODING_UTF8, brush, nullptr, nullptr, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER);
951 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, nullptr, strlen(text),
952 TEXT_ENCODING_UTF8, brush, nullptr, nullptr, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER);
953 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, 0,
954 TEXT_ENCODING_UTF8, brush, nullptr, nullptr, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER);
955 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(nullptr, text, strlen(text),
956 TEXT_ENCODING_UTF8, brush, pen, nullptr, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER);
957 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text),
958 static_cast<OH_Drawing_TextEncoding>(10), nullptr, nullptr, nullptr, &textWidth);
959 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
960 EXPECT_EQ(static_cast<int>(textWidth), 0);
961
962 errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text),
963 TEXT_ENCODING_UTF8, nullptr, nullptr, nullptr, &textWidth);
964 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
965 EXPECT_EQ(static_cast<int>(textWidth), 200);
966
967 const char* text1 = "hello world";
968 errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text1, strlen(text),
969 TEXT_ENCODING_UTF8, brush, nullptr, nullptr, &textWidth);
970 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
971 EXPECT_EQ(static_cast<int>(textWidth), 304);
972
973 OH_Drawing_Rect* bounds = OH_Drawing_RectCreate(0, 0, 200, 200);
974 errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text1, strlen(text),
975 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth);
976 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
977 EXPECT_EQ(static_cast<int>(textWidth), 304);
978 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetLeft(bounds)), 3);
979 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetRight(bounds)), 251);
980 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetRight(bounds)), 251);
981 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetBottom(bounds)), 1);
982
983 const char* text2 = "1234567890 !@#$%^&*(";
984 errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text2, strlen(text2),
985 TEXT_ENCODING_UTF8, nullptr, pen, nullptr, &textWidth);
986 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
987 EXPECT_EQ(static_cast<int>(textWidth), 555);
988 OH_Drawing_BrushDestroy(brush);
989 OH_Drawing_PenDestroy(pen);
990 OH_Drawing_FontDestroy(font);
991 }
992
993 /*
994 * @tc.name: FontGetWidthsBounds001
995 * @tc.desc: test for FontMeasureTextWithBrushOrPen.
996 * @tc.type: FUNC
997 * @tc.require: AR20250515745872
998 */
999 HWTEST_F(NdkFontTest, OH_Drawing_FontGetWidthsBounds001, TestSize.Level0)
1000 {
1001 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1002 OH_Drawing_FontSetTextSize(font, 50);
1003 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate();
1004 OH_Drawing_Pen* pen = OH_Drawing_PenCreate();
1005 const char* text = "你好世界";
1006 uint32_t count = 0;
1007 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8);
1008 uint16_t glyphs[count];
1009 OH_Drawing_FontTextToGlyphs(font, text, strlen(text), TEXT_ENCODING_UTF8, glyphs, count);
1010 int glyphsCount = 0;
1011 glyphsCount = OH_Drawing_FontTextToGlyphs(
1012 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count);
1013 // paramter font is nullptr
1014 float widths[50] = {0.f}; // 50 means widths array number
1015 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count);
1016 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(nullptr, glyphs, glyphsCount, brush, pen, widths, outRectarr),
1017 OH_DRAWING_ERROR_INVALID_PARAMETER);
1018 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, nullptr, glyphsCount, brush, pen, widths, outRectarr),
1019 OH_DRAWING_ERROR_INVALID_PARAMETER);
1020 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, 0, brush, pen, widths, outRectarr),
1021 OH_DRAWING_ERROR_INVALID_PARAMETER);
1022 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, 0, brush, pen, widths, outRectarr),
1023 OH_DRAWING_ERROR_INVALID_PARAMETER);
1024
1025 std::vector<int> widthArr = {50, 50, 50, 50};
1026 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontGetWidthsBounds(
1027 font, glyphs, glyphsCount, brush, nullptr, widths, nullptr);
1028 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
1029 for (int i = 0; i < count; i++) {
1030 EXPECT_EQ(static_cast<int>(widths[i]), widthArr[i]);
1031 }
1032
1033 errorCode = OH_Drawing_FontGetWidthsBounds(
1034 font, glyphs, glyphsCount, nullptr, pen, nullptr, outRectarr);
1035 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
1036
1037 std::vector<std::array<int, 4>> arr = { { 0, -42, 48, 3 }, { 1, -42, 48, 3 }, { 2, -42, 47, 2 }, { 1, -40, 48, 3 }};
1038 for (int i = 0; i < count; i++) {
1039 OH_Drawing_Rect* iter = nullptr;
1040 EXPECT_EQ(OH_Drawing_RectGetArrayElement(outRectarr, i, &iter), OH_DRAWING_SUCCESS);
1041 ASSERT_NE(iter, nullptr);
1042 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetLeft(iter)), arr[i][0]);
1043 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetTop(iter)), arr[i][1]);
1044 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetRight(iter)), arr[i][2]);
1045 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetBottom(iter)), arr[i][3]);
1046 EXPECT_EQ(OH_Drawing_RectGetBottom(iter) - OH_Drawing_RectGetTop(iter), OH_Drawing_RectGetHeight(iter));
1047 EXPECT_EQ(OH_Drawing_RectGetRight(iter) - OH_Drawing_RectGetLeft(iter), OH_Drawing_RectGetWidth(iter));
1048 }
1049 OH_Drawing_BrushDestroy(brush);
1050 OH_Drawing_PenDestroy(pen);
1051 OH_Drawing_FontDestroy(font);
1052 }
1053
1054 /*
1055 * @tc.name: FontGetPos001
1056 * @tc.desc: test for FontGetPos.
1057 * @tc.type: FUNC
1058 * @tc.require: AR20250515745872
1059 */
1060 HWTEST_F(NdkFontTest, OH_Drawing_FontGetPos001, TestSize.Level0)
1061 {
1062 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1063 OH_Drawing_FontSetTextSize(font, 50);
1064 const char* text = "你好世界";
1065 uint32_t count = 0;
1066 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8);
1067 OH_Drawing_Point *point = OH_Drawing_PointCreate(10.0, 10.0);
1068 uint16_t glyphs[count];
1069 OH_Drawing_FontTextToGlyphs(font, text, strlen(text), TEXT_ENCODING_UTF8, glyphs, count);
1070 int glyphsCount = 0;
1071 glyphsCount = OH_Drawing_FontTextToGlyphs(
1072 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count);
1073 // paramter font is nullptr
1074 OH_Drawing_Point2D* points = new OH_Drawing_Point2D[count];
1075 EXPECT_EQ(OH_Drawing_FontGetPos(nullptr, glyphs, glyphsCount, point, points), OH_DRAWING_ERROR_INVALID_PARAMETER);
1076 EXPECT_EQ(OH_Drawing_FontGetPos(font, nullptr, glyphsCount, point, points), OH_DRAWING_ERROR_INVALID_PARAMETER);
1077 EXPECT_EQ(OH_Drawing_FontGetPos(font, glyphs, 0, point, points), OH_DRAWING_ERROR_INVALID_PARAMETER);
1078 EXPECT_EQ(OH_Drawing_FontGetPos(font, glyphs, glyphsCount, nullptr, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER);
1079
1080 std::vector<std::array<int, 2>> testPoints = {{10, 10}, {60, 10}, {110, 10}, {160, 10}};
1081 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontGetPos(font, glyphs, glyphsCount, point, points);
1082 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
1083 for (int i = 0; i < count; i++) {
1084 EXPECT_EQ(static_cast<int>(points[i].x), testPoints[i][0]);
1085 EXPECT_EQ(static_cast<int>(points[i].y), testPoints[i][1]);
1086 }
1087 OH_Drawing_PointDestroy(point);
1088 if (points != nullptr) {
1089 delete[] points;
1090 }
1091 OH_Drawing_FontDestroy(font);
1092 }
1093
1094 /*
1095 * @tc.name: FontGetSpacing001
1096 * @tc.desc: test for FontGetSpacing.
1097 * @tc.type: FUNC
1098 * @tc.require: AR20250515745872
1099 */
1100 HWTEST_F(NdkFontTest, OH_Drawing_FontGetSpacing001, TestSize.Level0)
1101 {
1102 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1103 OH_Drawing_FontSetTextSize(font, 30);
1104 float spacing = 0.0f;
1105 EXPECT_EQ(OH_Drawing_FontGetSpacing(nullptr, &spacing), OH_DRAWING_ERROR_INVALID_PARAMETER);
1106 EXPECT_EQ(OH_Drawing_FontGetSpacing(font, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER);
1107 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontGetSpacing(font, &spacing);
1108 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS);
1109 EXPECT_EQ(std::fabs(spacing - 35.16) < 1e-6, true);
1110 OH_Drawing_FontDestroy(font);
1111 }
1112 } // namespace Drawing
1113 } // namespace Rosen
1114 } // namespace OHOS