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
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 namespace Drawing {
29 class NativeFontTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35 };
36
SetUpTestCase()37 void NativeFontTest::SetUpTestCase() {}
TearDownTestCase()38 void NativeFontTest::TearDownTestCase() {}
SetUp()39 void NativeFontTest::SetUp() {}
TearDown()40 void NativeFontTest::TearDown() {}
41
42 /*
43 * @tc.name: NativeFontTest_GetMetrics001
44 * @tc.desc: test for GetMetrics.
45 * @tc.type: FUNC
46 * @tc.require: AR000GTO5R
47 */
48 HWTEST_F(NativeFontTest, NativeFontTest_GetMetrics001, TestSize.Level1)
49 {
50 OH_Drawing_Font* font = OH_Drawing_FontCreate();
51 EXPECT_NE(font, nullptr);
52 OH_Drawing_Font_Metrics cFontMetrics;
53 EXPECT_TRUE(OH_Drawing_FontGetMetrics(font, &cFontMetrics) >= 0);
54 EXPECT_TRUE(OH_Drawing_FontGetMetrics(font, nullptr) < 0);
55 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
56 EXPECT_TRUE(OH_Drawing_FontGetMetrics(nullptr, nullptr) < 0);
57 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
58 OH_Drawing_FontDestroy(font);
59 }
60
61 /*
62 * @tc.name: NativeFontTest_IsAndSetBaselineSnap002
63 * @tc.desc: test for SetBaselineSnap and IsBaselineSnap.
64 * @tc.type: FUNC
65 * @tc.require: AR000GTO5R
66 */
67 HWTEST_F(NativeFontTest, NativeFontTest_IsAndSetBaselineSnap002, TestSize.Level1)
68 {
69 OH_Drawing_Font* font = OH_Drawing_FontCreate();
70 EXPECT_NE(font, nullptr);
71 OH_Drawing_FontSetBaselineSnap(nullptr, true);
72 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
73 EXPECT_EQ(OH_Drawing_FontIsBaselineSnap(nullptr), false);
74 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
75 OH_Drawing_FontSetBaselineSnap(nullptr, false);
76 EXPECT_EQ(OH_Drawing_FontIsBaselineSnap(nullptr), false);
77 OH_Drawing_FontSetBaselineSnap(font, true);
78 EXPECT_EQ(OH_Drawing_FontIsBaselineSnap(font), true);
79 OH_Drawing_FontSetBaselineSnap(font, false);
80 EXPECT_EQ(OH_Drawing_FontIsBaselineSnap(font), false);
81 OH_Drawing_FontDestroy(font);
82 }
83
84 /*
85 * @tc.name: NativeFontTest_IsAndSetSubpixel003
86 * @tc.desc: test for SetSubpixel and IsSubpixel.
87 * @tc.type: FUNC
88 * @tc.require: AR000GTO5R
89 */
90 HWTEST_F(NativeFontTest, NativeFontTest_IsAndSetSubpixel003, TestSize.Level1)
91 {
92 OH_Drawing_Font* font = OH_Drawing_FontCreate();
93 EXPECT_NE(font, nullptr);
94 OH_Drawing_FontSetSubpixel(nullptr, false);
95 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
96 EXPECT_EQ(OH_Drawing_FontIsSubpixel(nullptr), false);
97 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
98 OH_Drawing_FontSetSubpixel(nullptr, true);
99 EXPECT_EQ(OH_Drawing_FontIsSubpixel(nullptr), false);
100 OH_Drawing_FontSetSubpixel(font, true);
101 EXPECT_EQ(OH_Drawing_FontIsSubpixel(font), true);
102 OH_Drawing_FontSetSubpixel(font, false);
103 EXPECT_EQ(OH_Drawing_FontIsSubpixel(font), false);
104 OH_Drawing_FontDestroy(font);
105 }
106
107 /*
108 * @tc.name: NativeFontTest_TextToGlyphs004
109 * @tc.desc: test for TextToGlyphs.
110 * @tc.type: FUNC
111 * @tc.require: AR000GTO5R
112 */
113 HWTEST_F(NativeFontTest, NativeFontTest_TextToGlyphs004, TestSize.Level1)
114 {
115 OH_Drawing_Font* font = OH_Drawing_FontCreate();
116 OH_Drawing_FontSetTextSize(font, 100); // 100 means font text size
117 EXPECT_NE(font, nullptr);
118 const char *str = "hello world";
119 OH_Drawing_FontCountText(nullptr, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
120 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
121 OH_Drawing_FontCountText(font, nullptr, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
122 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
123 uint32_t count = 0;
124 count = OH_Drawing_FontCountText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
125 EXPECT_EQ(11, count); // 11 means str length
126
127 uint16_t glyphs[50] = {0}; // 50 means glyphs array number
128 OH_Drawing_FontTextToGlyphs(nullptr, str, 0, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, 0);
129 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
130 OH_Drawing_FontTextToGlyphs(font, nullptr, 0, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, 0);
131 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
132 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, nullptr, 0);
133 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
134 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, 0);
135 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
136 int glyphsCount = 0;
137 glyphsCount = OH_Drawing_FontTextToGlyphs(font, str, 0,
138 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, 0);
139 EXPECT_EQ(0, glyphsCount);
140 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
141
142 glyphsCount = OH_Drawing_FontTextToGlyphs(font, str, strlen(str),
143 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count);
144 EXPECT_EQ(11, glyphsCount); // 11 means glyphsCount
145
146 float widths[50] = {0.f}; // 50 means widths array number
147 OH_Drawing_FontGetWidths(nullptr, glyphs, glyphsCount, widths);
148 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
149 OH_Drawing_FontGetWidths(font, nullptr, glyphsCount, widths);
150 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
151 OH_Drawing_FontGetWidths(font, glyphs, 0, widths);
152 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
153 OH_Drawing_FontGetWidths(font, glyphs, glyphsCount, nullptr);
154 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
155 OH_Drawing_FontGetWidths(font, glyphs, glyphsCount, widths);
156 EXPECT_EQ(58.0, widths[0]); // 58.0 means glyphs[0] width
157 OH_Drawing_FontDestroy(font);
158 }
159
160 /*
161 * @tc.name: NativeFontTest_SetAndGetScaleX005
162 * @tc.desc: test for SetAndGetScaleX.
163 * @tc.type: FUNC
164 * @tc.require: AR000GTO5R
165 */
166 HWTEST_F(NativeFontTest, NativeFontTest_SetAndGetScaleX005, TestSize.Level1)
167 {
168 OH_Drawing_Font* font = OH_Drawing_FontCreate();
169 EXPECT_NE(font, nullptr);
170 OH_Drawing_FontSetScaleX(nullptr, 2);
171 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
172 EXPECT_TRUE(OH_Drawing_FontGetScaleX(nullptr) == -1);
173 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
174 EXPECT_TRUE(OH_Drawing_FontGetScaleX(font) == 1);
175 OH_Drawing_FontSetScaleX(font, 2);
176 EXPECT_TRUE(OH_Drawing_FontGetScaleX(font) == 2);
177 OH_Drawing_FontDestroy(font);
178 }
179
180 /*
181 * @tc.name: NativeFontTest_GetAndSetEdging006
182 * @tc.desc: test for GetAndSetEdging.
183 * @tc.type: FUNC
184 * @tc.require: AR000GTO5R
185 */
186 HWTEST_F(NativeFontTest, NativeFontTest_GetAndSetEdging006, TestSize.Level1)
187 {
188 OH_Drawing_Font* font = OH_Drawing_FontCreate();
189 EXPECT_NE(font, nullptr);
190 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_ANTI_ALIAS);
191 EXPECT_EQ(OH_Drawing_FontGetEdging(nullptr), OH_Drawing_FontEdging::FONT_EDGING_ALIAS);
192 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
193 OH_Drawing_FontSetEdging(nullptr, OH_Drawing_FontEdging::FONT_EDGING_ALIAS);
194 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
195 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_ANTI_ALIAS);
196 OH_Drawing_FontSetEdging(font, OH_Drawing_FontEdging::FONT_EDGING_ALIAS);
197 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_ALIAS);
198 OH_Drawing_FontSetEdging(font, OH_Drawing_FontEdging::FONT_EDGING_ANTI_ALIAS);
199 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_ANTI_ALIAS);
200 OH_Drawing_FontSetEdging(font, OH_Drawing_FontEdging::FONT_EDGING_SUBPIXEL_ANTI_ALIAS);
201 EXPECT_EQ(OH_Drawing_FontGetEdging(font), OH_Drawing_FontEdging::FONT_EDGING_SUBPIXEL_ANTI_ALIAS);
202 OH_Drawing_FontDestroy(font);
203 }
204
205 /*
206 * @tc.name: NativeFontTest_GetAndSetForceAutoHinting007
207 * @tc.desc: test for GetAndSetForceAutoHinting.
208 * @tc.type: FUNC
209 * @tc.require: AR000GTO5R
210 */
211 HWTEST_F(NativeFontTest, NativeFontTest_GetAndSetForceAutoHinting007, TestSize.Level1)
212 {
213 OH_Drawing_Font* font = OH_Drawing_FontCreate();
214 EXPECT_NE(font, nullptr);
215 EXPECT_EQ(OH_Drawing_FontIsForceAutoHinting(nullptr), false);
216 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
217 OH_Drawing_FontSetForceAutoHinting(nullptr, true);
218 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
219 EXPECT_EQ(OH_Drawing_FontIsForceAutoHinting(font), false);
220 OH_Drawing_FontSetForceAutoHinting(font, true);
221 EXPECT_EQ(OH_Drawing_FontIsForceAutoHinting(font), true);
222 OH_Drawing_FontSetForceAutoHinting(font, false);
223 EXPECT_EQ(OH_Drawing_FontIsForceAutoHinting(font), false);
224 OH_Drawing_FontDestroy(font);
225 }
226
227 /*
228 * @tc.name: NativeFontTest_GetAndSetHinting008
229 * @tc.desc: test for GetHinting and SetHinting.
230 * @tc.type: FUNC
231 * @tc.require: AR000GTO5R
232 */
233 HWTEST_F(NativeFontTest, NativeFontTest_GetAndSetHinting008, TestSize.Level1)
234 {
235 OH_Drawing_Font* font = OH_Drawing_FontCreate();
236 EXPECT_NE(font, nullptr);
237 EXPECT_TRUE(OH_Drawing_FontGetHinting(nullptr) == OH_Drawing_FontHinting::FONT_HINTING_NONE);
238 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
239 OH_Drawing_FontSetHinting(nullptr, OH_Drawing_FontHinting::FONT_HINTING_NONE);
240 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
241 OH_Drawing_FontSetHinting(font, OH_Drawing_FontHinting::FONT_HINTING_NONE);
242 EXPECT_TRUE(OH_Drawing_FontGetHinting(font) == OH_Drawing_FontHinting::FONT_HINTING_NONE);
243 OH_Drawing_FontSetHinting(font, OH_Drawing_FontHinting::FONT_HINTING_SLIGHT);
244 EXPECT_TRUE(OH_Drawing_FontGetHinting(font) == OH_Drawing_FontHinting::FONT_HINTING_SLIGHT);
245 OH_Drawing_FontSetHinting(font, OH_Drawing_FontHinting::FONT_HINTING_SLIGHT);
246 EXPECT_TRUE(OH_Drawing_FontGetHinting(font) == OH_Drawing_FontHinting::FONT_HINTING_SLIGHT);
247 OH_Drawing_FontDestroy(font);
248 }
249
250 /*
251 * @tc.name: NativeFontTest_GetAndSetEmbeddedBitmaps009
252 * @tc.desc: test for GetEmbeddedBitmaps and SetEmbeddedBitmaps.
253 * @tc.type: FUNC
254 * @tc.require: AR000GTO5R
255 */
256 HWTEST_F(NativeFontTest, NativeFontTest_GetAndSetEmbeddedBitmaps009, TestSize.Level1)
257 {
258 OH_Drawing_Font* font = OH_Drawing_FontCreate();
259 EXPECT_NE(font, nullptr);
260 EXPECT_TRUE(OH_Drawing_FontIsEmbeddedBitmaps(nullptr) == false);
261 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
262 OH_Drawing_FontSetEmbeddedBitmaps(nullptr, true);
263 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
264 OH_Drawing_FontSetEmbeddedBitmaps(font, true);
265 EXPECT_TRUE(OH_Drawing_FontIsEmbeddedBitmaps(font) == true);
266 OH_Drawing_FontSetEmbeddedBitmaps(font, false);
267 EXPECT_TRUE(OH_Drawing_FontIsEmbeddedBitmaps(font) == false);
268 OH_Drawing_FontDestroy(font);
269 }
270
271 /*
272 * @tc.name: NativeFontTest_GetTextSize010
273 * @tc.desc: test for GetTextSize.
274 * @tc.type: FUNC
275 * @tc.require: AR000GTO5R
276 */
277 HWTEST_F(NativeFontTest, NativeFontTest_GetTextSize010, TestSize.Level1)
278 {
279 OH_Drawing_Font* font = OH_Drawing_FontCreate();
280 EXPECT_NE(font, nullptr);
281 OH_Drawing_FontSetTextSize(nullptr, 100);
282 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
283 OH_Drawing_FontGetTextSize(nullptr);
284 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
285 OH_Drawing_FontSetTextSize(font, 100);
286 float size = OH_Drawing_FontGetTextSize(font);
287 EXPECT_EQ(size, 100);
288 OH_Drawing_FontDestroy(font);
289 }
290
291 /*
292 * @tc.name: NativeFontTest_GetTextSkewX011
293 * @tc.desc: test for GetTextSkewX.
294 * @tc.type: FUNC
295 * @tc.require: AR000GTO5R
296 */
297 HWTEST_F(NativeFontTest, NativeFontTest_GetTextSkewX011, TestSize.Level1)
298 {
299 OH_Drawing_Font* font = OH_Drawing_FontCreate();
300 EXPECT_NE(font, nullptr);
301 OH_Drawing_FontSetTextSkewX(nullptr, 10);
302 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
303 OH_Drawing_FontGetTextSkewX(nullptr);
304 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
305 OH_Drawing_FontSetTextSkewX(font, 10);
306 float size = OH_Drawing_FontGetTextSkewX(font);
307 EXPECT_EQ(size, 10);
308 OH_Drawing_FontDestroy(font);
309 }
310
311 /*
312 * @tc.name: NativeFontTest_IsLinearText012
313 * @tc.desc: test for IsLinearText.
314 * @tc.type: FUNC
315 * @tc.require: AR000GTO5R
316 */
317 HWTEST_F(NativeFontTest, NativeFontTest_IsLinearText012, TestSize.Level1)
318 {
319 OH_Drawing_Font* font = OH_Drawing_FontCreate();
320 EXPECT_NE(font, nullptr);
321 OH_Drawing_FontSetLinearText(nullptr, true);
322 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
323 OH_Drawing_FontIsLinearText(nullptr);
324 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
325 bool ret = OH_Drawing_FontIsLinearText(font);
326 EXPECT_EQ(ret, false);
327 OH_Drawing_FontSetLinearText(font, true);
328 ret = OH_Drawing_FontIsLinearText(font);
329 EXPECT_EQ(ret, true);
330 OH_Drawing_FontDestroy(font);
331 }
332
333 /*
334 * @tc.name: NativeFontTest_SetFakeBoldText013
335 * @tc.desc: test for SetFakeBoldText.
336 * @tc.type: FUNC
337 * @tc.require: AR000GTO5R
338 */
339 HWTEST_F(NativeFontTest, NativeFontTest_SetFakeBoldText013, TestSize.Level1)
340 {
341 OH_Drawing_Font* font = OH_Drawing_FontCreate();
342 EXPECT_NE(font, nullptr);
343 OH_Drawing_FontSetFakeBoldText(nullptr, true);
344 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
345 OH_Drawing_FontIsFakeBoldText(nullptr);
346 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
347 bool ret = OH_Drawing_FontIsFakeBoldText(font);
348 EXPECT_EQ(ret, false);
349 OH_Drawing_FontSetFakeBoldText(font, true);
350 ret = OH_Drawing_FontIsFakeBoldText(font);
351 EXPECT_EQ(ret, true);
352 OH_Drawing_FontDestroy(font);
353 }
354
355 /*
356 * @tc.name: NativeFontTest_FontMeasureText014
357 * @tc.desc: test for FontMeasureText.
358 * @tc.type: FUNC
359 * @tc.require: AR000GTO5R
360 */
361 HWTEST_F(NativeFontTest, NativeFontTest_FontMeasureText014, TestSize.Level1)
362 {
363 OH_Drawing_Font* font = OH_Drawing_FontCreate();
364 EXPECT_NE(font, nullptr);
365 OH_Drawing_FontSetTextSize(font, 50);
366 const char* str = "hello world";
367 float textWidth = 0.f;
368 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_SUCCESS;
369 drawingErrorCode = OH_Drawing_FontMeasureText(nullptr, str, strlen(str),
370 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, nullptr, &textWidth);
371 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
372 EXPECT_EQ(textWidth, 0.f);
373 drawingErrorCode = OH_Drawing_FontMeasureText(font, str, 0, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
374 nullptr, &textWidth);
375 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
376 EXPECT_EQ(textWidth, 0.f);
377 drawingErrorCode = OH_Drawing_FontMeasureText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
378 nullptr, &textWidth);
379 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS);
380 EXPECT_EQ(textWidth, 254.0); // 254.0 is textWidth
381
382 OH_Drawing_FontDestroy(font);
383 }
384
385 /*
386 * @tc.name: NativeFontTest_FontMeasureSingleCharacter015
387 * @tc.desc: test for OH_Drawing_FontMeasureSingleCharacter.
388 * @tc.type: FUNC
389 * @tc.require: AR000GTO5R
390 */
391 HWTEST_F(NativeFontTest, NativeFontTest_FontMeasureSingleCharacter015, TestSize.Level1)
392 {
393 OH_Drawing_Font* font = OH_Drawing_FontCreate();
394 EXPECT_NE(font, nullptr);
395 OH_Drawing_FontSetTextSize(font, 50); // 50 means font text size
396 const char* strOne = "a";
397 const char* strTwo = "你好";
398 float textWidth = 0.f;
399 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_SUCCESS;
400 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(nullptr, strOne, &textWidth);
401 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
402 EXPECT_EQ(textWidth, 0.f);
403 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, nullptr, &textWidth);
404 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
405 EXPECT_EQ(textWidth, 0.f);
406 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, strOne, nullptr);
407 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
408 EXPECT_EQ(textWidth, 0.f);
409 const char* strThree = "";
410 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, strThree, &textWidth);
411 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER);
412 EXPECT_EQ(textWidth, 0.f);
413 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, strOne, &textWidth);
414 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS);
415 EXPECT_TRUE(textWidth > 0);
416 drawingErrorCode = OH_Drawing_FontMeasureSingleCharacter(font, strTwo, &textWidth);
417 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS);
418 EXPECT_TRUE(textWidth > 0);
419 OH_Drawing_FontDestroy(font);
420 }
421
422 /*
423 * @tc.name: NativeFontTest_FontCreatePathForGlyph001
424 * @tc.desc: test for common character of glyph ID.
425 * @tc.type: FUNC
426 * @tc.require:
427 */
428 HWTEST_F(NativeFontTest, NativeFontTest_FontGetPathForGlyph001, TestSize.Level1)
429 {
430 OH_Drawing_Font* font = OH_Drawing_FontCreate();
431 EXPECT_NE(font, nullptr);
432 OH_Drawing_FontSetTextSize(font, 50);
433 const char* str = "helloworld";
434 uint32_t count = OH_Drawing_FontCountText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
435 EXPECT_EQ(strlen(str), count);
436 uint16_t glyphs[count];
437 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
438 glyphs, count);
439 for (int i = 0; i < count; i++) {
440 OH_Drawing_Path* path = OH_Drawing_PathCreate();
441 ASSERT_NE(path, nullptr);
442 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(font, glyphs[i], path), OH_DRAWING_SUCCESS);
443 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) > 0);
444 EXPECT_TRUE(OH_Drawing_PathIsClosed(path, false));
445 if (path != nullptr) {
446 OH_Drawing_PathDestroy(path);
447 }
448 }
449 OH_Drawing_FontDestroy(font);
450 }
451
452 /*
453 * @tc.name: NativeFontTest_FontCreatePathForGlyph002
454 * @tc.desc: test for space character of glyph ID.
455 * @tc.type: FUNC
456 * @tc.require:
457 */
458 HWTEST_F(NativeFontTest, NativeFontTest_FontGetPathForGlyph002, TestSize.Level1)
459 {
460 OH_Drawing_Font* font = OH_Drawing_FontCreate();
461 EXPECT_NE(font, nullptr);
462 OH_Drawing_FontSetTextSize(font, 50);
463 const char* space = " ";
464 uint32_t count = OH_Drawing_FontCountText(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
465 EXPECT_EQ(strlen(space), count);
466 uint16_t glyphs[count];
467 OH_Drawing_FontTextToGlyphs(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
468 glyphs, count);
469 OH_Drawing_Path* path = OH_Drawing_PathCreate();
470 ASSERT_NE(path, nullptr);
471 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(font, glyphs[0], path), OH_DRAWING_SUCCESS);
472 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) == 0);
473 EXPECT_FALSE(OH_Drawing_PathIsClosed(path, false));
474 if (path != nullptr) {
475 OH_Drawing_PathDestroy(path);
476 }
477 OH_Drawing_FontDestroy(font);
478 }
479
480 /*
481 * @tc.name: NativeFontTest_FontCreatePathForGlyph003
482 * @tc.desc: test for abnormal parameter
483 * @tc.type: FUNC
484 * @tc.require:
485 */
486 HWTEST_F(NativeFontTest, NativeFontTest_FontGetPathForGlyph003, TestSize.Level1)
487 {
488 OH_Drawing_Font* font = OH_Drawing_FontCreate();
489 EXPECT_NE(font, nullptr);
490 OH_Drawing_FontSetTextSize(font, 50);
491 const char* str = "hello world";
492 uint32_t count = OH_Drawing_FontCountText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
493 EXPECT_EQ(strlen(str), count);
494 uint16_t glyphs[count];
495 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
496 glyphs, count);
497
498 OH_Drawing_Path* path = OH_Drawing_PathCreate();
499 ASSERT_NE(path, nullptr);
500 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(nullptr, glyphs[0], path), OH_DRAWING_ERROR_INVALID_PARAMETER);
501 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(font, glyphs[0], nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER);
502 if (path != nullptr) {
503 OH_Drawing_PathDestroy(path);
504 }
505 OH_Drawing_FontDestroy(font);
506 }
507
508 /*
509 * @tc.name: NativeFontTest_FontCreatePathForGlyph004
510 * @tc.desc: test for non exist glyph ID.
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(NativeFontTest, NativeFontTest_FontGetPathForGlyph004, TestSize.Level1)
515 {
516 OH_Drawing_Font* font = OH_Drawing_FontCreate();
517 EXPECT_NE(font, nullptr);
518 OH_Drawing_FontSetTextSize(font, 50);
519 uint16_t glyphsNotExist = 65535;
520 OH_Drawing_Path* path = OH_Drawing_PathCreate();
521 ASSERT_NE(path, nullptr);
522 EXPECT_EQ(OH_Drawing_FontGetPathForGlyph(font, glyphsNotExist, path), OH_DRAWING_ERROR_INVALID_PARAMETER);
523 if (path != nullptr) {
524 OH_Drawing_PathDestroy(path);
525 }
526 OH_Drawing_FontDestroy(font);
527 }
528
529 /*
530 * @tc.name: NativeFontTest_FontGetBounds001
531 * @tc.desc: test for common character of glyph ID.
532 * @tc.type: FUNC
533 * @tc.require:
534 */
535 HWTEST_F(NativeFontTest, NativeFontTest_FontGetBounds001, TestSize.Level1)
536 {
537 OH_Drawing_Font* font = OH_Drawing_FontCreate();
538 EXPECT_NE(font, nullptr);
539 OH_Drawing_FontSetTextSize(font, 50);
540 const char* str = "helloworld";
541 uint32_t count = OH_Drawing_FontCountText(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
542 EXPECT_EQ(strlen(str), count);
543 uint16_t glyphs[count];
544 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
545 glyphs, count);
546 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count);
547 ASSERT_NE(outRectarr, nullptr);
548 size_t size = 0;
549 EXPECT_EQ(OH_Drawing_RectGetArraySize(outRectarr, &size), OH_DRAWING_SUCCESS);
550 EXPECT_EQ(size, count);
551 EXPECT_EQ(OH_Drawing_FontGetBounds(font, glyphs, count, outRectarr), OH_DRAWING_SUCCESS);
552 for (int i = 0; i < count; i++) {
553 OH_Drawing_Rect *iter = nullptr;
554 EXPECT_EQ(OH_Drawing_RectGetArrayElement(outRectarr, i, &iter), OH_DRAWING_SUCCESS);
555 ASSERT_NE(iter, nullptr);
556 EXPECT_TRUE(OH_Drawing_RectGetWidth(iter) > 0);
557 EXPECT_TRUE(OH_Drawing_RectGetHeight(iter) > 0);
558 }
559 EXPECT_EQ(OH_Drawing_RectDestroyArray(outRectarr), OH_DRAWING_SUCCESS);
560
561 OH_Drawing_FontDestroy(font);
562 }
563
564 /*
565 * @tc.name: NativeFontTest_FontGetBounds002
566 * @tc.desc: test for space character of glyph ID.
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570 HWTEST_F(NativeFontTest, NativeFontTest_FontGetBounds002, TestSize.Level1)
571 {
572 OH_Drawing_Font* font = OH_Drawing_FontCreate();
573 EXPECT_NE(font, nullptr);
574 OH_Drawing_FontSetTextSize(font, 50);
575 const char* space = " ";
576 uint32_t count = OH_Drawing_FontCountText(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
577 EXPECT_EQ(strlen(space), count);
578 uint16_t glyphs[count];
579 OH_Drawing_FontTextToGlyphs(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
580 glyphs, count);
581 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count);
582 ASSERT_NE(outRectarr, nullptr);
583 size_t size = 0;
584 EXPECT_EQ(OH_Drawing_RectGetArraySize(outRectarr, &size), OH_DRAWING_SUCCESS);
585 EXPECT_EQ(size, count);
586 EXPECT_EQ(OH_Drawing_FontGetBounds(font, glyphs, count, outRectarr), OH_DRAWING_SUCCESS);
587 for (int i = 0; i < count; i++) {
588 OH_Drawing_Rect *iter = nullptr;
589 EXPECT_EQ(OH_Drawing_RectGetArrayElement(outRectarr, i, &iter), OH_DRAWING_SUCCESS);
590 ASSERT_NE(iter, nullptr);
591 EXPECT_TRUE(OH_Drawing_RectGetWidth(iter) == 0);
592 EXPECT_TRUE(OH_Drawing_RectGetHeight(iter) == 0);
593 }
594 EXPECT_EQ(OH_Drawing_RectDestroyArray(outRectarr), OH_DRAWING_SUCCESS);
595 OH_Drawing_FontDestroy(font);
596 }
597
598 /*
599 * @tc.name: NativeFontTest_FontGetBounds003
600 * @tc.desc: test for abnormal parameter
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(NativeFontTest, NativeFontTest_FontGetBounds003, TestSize.Level1)
605 {
606 OH_Drawing_Font* font = OH_Drawing_FontCreate();
607 EXPECT_NE(font, nullptr);
608 OH_Drawing_FontSetTextSize(font, 50);
609 const char* space = " ";
610 uint32_t count = OH_Drawing_FontCountText(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
611 EXPECT_EQ(strlen(space), count);
612 uint16_t glyphs[count];
613 OH_Drawing_FontTextToGlyphs(font, space, strlen(space), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8,
614 glyphs, count);
615 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count - 1);
616 ASSERT_NE(outRectarr, nullptr);
617 // not enough size
618 EXPECT_EQ(OH_Drawing_FontGetBounds(font, glyphs, count, outRectarr), OH_DRAWING_ERROR_INVALID_PARAMETER);
619 EXPECT_EQ(OH_Drawing_FontGetBounds(nullptr, glyphs, count, outRectarr), OH_DRAWING_ERROR_INVALID_PARAMETER);
620 EXPECT_EQ(OH_Drawing_FontGetBounds(font, nullptr, count, outRectarr), OH_DRAWING_ERROR_INVALID_PARAMETER);
621 EXPECT_EQ(OH_Drawing_FontGetBounds(font, glyphs, count, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER);
622 EXPECT_EQ(OH_Drawing_RectDestroyArray(outRectarr), OH_DRAWING_SUCCESS);
623 OH_Drawing_FontDestroy(font);
624 }
625
626 /*
627 * @tc.name: NativeFontTest_FontGetTextPath001
628 * @tc.desc: test for common character of textpath.
629 * @tc.type: FUNC
630 * @tc.require: IAKP0I
631 */
632 HWTEST_F(NativeFontTest, NativeFontTest_FontGetTextPath001, TestSize.Level1)
633 {
634 OH_Drawing_Font* font = OH_Drawing_FontCreate();
635 EXPECT_NE(font, nullptr);
636 const char* str = "Hello 中文";
637 size_t length = std::char_traits<char>::length(str);
638 float x = 12.0f;
639 float y = 150.0f;
640 OH_Drawing_Path* path = OH_Drawing_PathCreate();
641 ASSERT_NE(path, nullptr);
642 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, str, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
643 OH_DRAWING_SUCCESS);
644 ASSERT_NE(path, nullptr);
645 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) > 0);
646 if (path != nullptr) {
647 OH_Drawing_PathDestroy(path);
648 }
649 OH_Drawing_FontDestroy(font);
650 }
651
652 /*
653 * @tc.name: NativeFontTest_FontGetTextPath002
654 * @tc.desc: test for UTF16 and UTF32 character of textpath.
655 * @tc.type: FUNC
656 * @tc.require: IAKP0I
657 */
658 HWTEST_F(NativeFontTest, NativeFontTest_FontGetTextPath002, TestSize.Level1)
659 {
660 OH_Drawing_Font* font = OH_Drawing_FontCreate();
661 EXPECT_NE(font, nullptr);
662
663 float x = 12.0f;
664 float y = 150.0f;
665 const char16_t* u16str = u"Hello 中文";
666 size_t u16strLen = std::char_traits<char16_t>::length(u16str);
667 OH_Drawing_Path* path = OH_Drawing_PathCreate();
668 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, u16str, sizeof(char16_t) * u16strLen, TEXT_ENCODING_UTF16, x, y, path),
669 OH_DRAWING_SUCCESS);
670 ASSERT_NE(path, nullptr);
671 float u16PathLen = OH_Drawing_PathGetLength(path, false);
672
673 const char32_t* u32str = U"Hello 中文";
674 size_t u32strLen = std::char_traits<char32_t>::length(u32str);
675 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, u32str, sizeof(char32_t) * u32strLen, TEXT_ENCODING_UTF32, x, y, path),
676 OH_DRAWING_SUCCESS);
677 ASSERT_NE(path, nullptr);
678 float u32PathLen = OH_Drawing_PathGetLength(path, false);
679 ASSERT_TRUE(u16PathLen > 0 && u32PathLen > 0);
680 ASSERT_EQ(u16PathLen, u32PathLen);
681 if (path != nullptr) {
682 OH_Drawing_PathDestroy(path);
683 }
684 OH_Drawing_FontDestroy(font);
685 }
686
687 /*
688 * @tc.name: NativeFontTest_FontGetTextPath003
689 * @tc.desc: test for space character of textpath.
690 * @tc.type: FUNC
691 * @tc.require: IAKP0I
692 */
693 HWTEST_F(NativeFontTest, NativeFontTest_FontGetTextPath003, TestSize.Level1)
694 {
695 OH_Drawing_Font* font = OH_Drawing_FontCreate();
696 EXPECT_NE(font, nullptr);
697 const char* space = " ";
698 size_t length = std::char_traits<char>::length(space);
699 float x = 12.0f;
700 float y = 150.0f;
701 OH_Drawing_Path* path = OH_Drawing_PathCreate();
702 ASSERT_NE(path, nullptr);
703 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, space, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
704 OH_DRAWING_SUCCESS);
705 ASSERT_NE(path, nullptr);
706 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) == 0);
707 EXPECT_FALSE(OH_Drawing_PathIsClosed(path, false));
708 if (path != nullptr) {
709 OH_Drawing_PathDestroy(path);
710 }
711 OH_Drawing_FontDestroy(font);
712 }
713
714 /*
715 * @tc.name: NativeFontTest_FontGetTextPath004
716 * @tc.desc: test for abnormal paramete of textpath.
717 * @tc.type: FUNC
718 * @tc.require: IAKP0I
719 */
720 HWTEST_F(NativeFontTest, NativeFontTest_FontGetTextPath004, TestSize.Level1)
721 {
722 OH_Drawing_Font* font = OH_Drawing_FontCreate();
723 EXPECT_NE(font, nullptr);
724 const char* str = "Hello 中文";
725 size_t length = std::char_traits<char>::length(str);
726 float x = 12.0f;
727 float y = 150.0f;
728 OH_Drawing_Path* path = OH_Drawing_PathCreate();
729 ASSERT_NE(path, nullptr);
730 EXPECT_EQ(OH_Drawing_FontGetTextPath(nullptr, str, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
731 OH_DRAWING_ERROR_INVALID_PARAMETER);
732 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, nullptr, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
733 OH_DRAWING_ERROR_INVALID_PARAMETER);
734 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, str, 0, TEXT_ENCODING_UTF8, x, y, path),
735 OH_DRAWING_ERROR_INVALID_PARAMETER);
736 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, str, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, nullptr),
737 OH_DRAWING_ERROR_INVALID_PARAMETER);
738 OH_Drawing_FontDestroy(font);
739 }
740
741 /*
742 * @tc.name: NativeFontTest_FontGetTextPath005
743 * @tc.desc: test for negative coordinates of textpath.
744 * @tc.type: FUNC
745 * @tc.require: IAKP0I
746 */
747 HWTEST_F(NativeFontTest, NativeFontTest_FontGetTextPath005, TestSize.Level1)
748 {
749 OH_Drawing_Font* font = OH_Drawing_FontCreate();
750 EXPECT_NE(font, nullptr);
751 const char* str = "Hello 中文";
752 size_t length = std::char_traits<char>::length(str);
753 float x = -1.0f;
754 float y = -1.0f;
755 OH_Drawing_Path* path = OH_Drawing_PathCreate();
756 ASSERT_NE(path, nullptr);
757 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, str, sizeof(char) * length, TEXT_ENCODING_UTF8, x, y, path),
758 OH_DRAWING_SUCCESS);
759 ASSERT_NE(path, nullptr);
760 if (path != nullptr) {
761 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) > 0);
762 OH_Drawing_PathDestroy(path);
763 }
764 OH_Drawing_FontDestroy(font);
765 }
766
767 /*
768 * @tc.name: NativeFontTest_FontGetTextPath006
769 * @tc.desc: test for conversion of glyphsID to path.
770 * @tc.type: FUNC
771 * @tc.require: IAKP0I
772 */
773 HWTEST_F(NativeFontTest, NativeFontTest_FontGetTextPath006, TestSize.Level1)
774 {
775 OH_Drawing_Font* font = OH_Drawing_FontCreate();
776 EXPECT_NE(font, nullptr);
777 const char* str = "Hello 中文";
778 uint32_t count = 0;
779 count = OH_Drawing_FontCountText(font, str, strlen(str), TEXT_ENCODING_UTF8);
780 EXPECT_NE(count, 0);
781 uint16_t glyphs[count];
782 OH_Drawing_FontTextToGlyphs(font, str, strlen(str), TEXT_ENCODING_UTF8, glyphs, count);
783
784 float x = 12.0f;
785 float y = 150.0f;
786 OH_Drawing_Path* path = OH_Drawing_PathCreate();
787 ASSERT_NE(path, nullptr);
788 EXPECT_EQ(OH_Drawing_FontGetTextPath(font, glyphs, sizeof(glyphs), TEXT_ENCODING_GLYPH_ID, x, y, path),
789 OH_DRAWING_SUCCESS);
790 ASSERT_NE(path, nullptr);
791 if (path != nullptr) {
792 EXPECT_TRUE(OH_Drawing_PathGetLength(path, false) > 0);
793 OH_Drawing_PathDestroy(path);
794 }
795 OH_Drawing_FontDestroy(font);
796 }
797
798 /*
799 * @tc.name: NativeFontTest_FontThemeFont001
800 * @tc.desc: test for theme font.
801 * @tc.type: FUNC
802 * @tc.require: IAKP0I
803 */
804 HWTEST_F(NativeFontTest, NativeFontTest_FontThemeFont001, TestSize.Level1)
805 {
806 OH_Drawing_Font* font = OH_Drawing_FontCreate();
807 EXPECT_NE(font, nullptr);
808 bool followed = true;
809 OH_Drawing_FontIsThemeFontFollowed(font, &followed);
810 EXPECT_EQ(followed, false);
811 OH_Drawing_FontSetThemeFontFollowed(font, true);
812 OH_Drawing_FontIsThemeFontFollowed(font, &followed);
813 EXPECT_EQ(followed, true);
814 OH_Drawing_FontDestroy(font);
815 }
816 } // namespace Drawing
817 } // namespace Rosen
818 } // namespace OHOS