1 /*
2 * Copyright (c) 2023 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 <gtest/gtest.h>
17 #include <hb.h>
18
19 #include "measurer_impl.h"
20 #include "param_test_macros.h"
21 #include "texgine_exception.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace OHOS::Rosen;
26
27 struct hb_buffer_t {};
28 struct hb_unicode_funcs_t {};
29 struct hb_font_t {};
30 struct hb_face_t {};
31
32 struct MockVars {
33 size_t calledHBFontCreate = 0;
34 std::unique_ptr<hb_buffer_t> retvalBufferCreate = std::make_unique<hb_buffer_t>();
35 std::unique_ptr<hb_unicode_funcs_t> retvalUnicodeFuncsCreate = std::make_unique<hb_unicode_funcs_t>();
36 size_t calledUnicodeScript = 0;
37 std::vector<hb_script_t> retvalUnicodeScript = {HB_SCRIPT_INVALID};
38 std::unique_ptr<hb_font_t> retvalFontCreate = std::make_unique<hb_font_t>();
39 std::unique_ptr<hb_face_t> retvalFaceCreate = std::make_unique<hb_face_t>();
40 std::vector<hb_glyph_info_t> retvalGetGlyphInfo = {{}};
41 std::vector<hb_glyph_position_t> retvalGetGlyphPosition = {{}};
42 int retvalGetUnitsPerEm = 1;
43 bool retvalHBFeatureFromString = true;
44 bool retvalIsWhitespace = false;
45 bool retvalTypefaceHas = true;
46 size_t retvalGetTableSize = 1;
47 size_t retvalGetTableData = 1;
48
49 std::shared_ptr<TextEngine::Typeface> typeface =
50 std::make_shared<TextEngine::Typeface>(std::make_shared<TextEngine::TexgineTypeface>());
51 } g_measurerMockvars;
52
53 std::list<TextEngine::MeasuringRun> mRuns = {};
54
hb_blob_create(const char *,unsigned int,hb_memory_mode_t,void *,hb_destroy_func_t)55 hb_blob_t *hb_blob_create(const char *, unsigned int, hb_memory_mode_t, void *, hb_destroy_func_t)
56 {
57 return hb_blob_get_empty();
58 }
59
hb_unicode_funcs_create(hb_unicode_funcs_t *)60 hb_unicode_funcs_t *hb_unicode_funcs_create(hb_unicode_funcs_t *)
61 {
62 return g_measurerMockvars.retvalUnicodeFuncsCreate.get();
63 }
64
hb_unicode_script(hb_unicode_funcs_t *,hb_codepoint_t)65 hb_script_t hb_unicode_script(hb_unicode_funcs_t *, hb_codepoint_t)
66 {
67 assert(g_measurerMockvars.retvalUnicodeScript.size() > g_measurerMockvars.calledUnicodeScript);
68 return g_measurerMockvars.retvalUnicodeScript[g_measurerMockvars.calledUnicodeScript++];
69 }
70
hb_feature_from_string(const char *,int,hb_feature_t *)71 hb_bool_t hb_feature_from_string(const char *, int, hb_feature_t *)
72 {
73 return g_measurerMockvars.retvalHBFeatureFromString;
74 }
75
hb_buffer_create()76 hb_buffer_t *hb_buffer_create()
77 {
78 return g_measurerMockvars.retvalBufferCreate.get();
79 }
80
hb_buffer_destroy(hb_buffer_t *)81 void hb_buffer_destroy(hb_buffer_t *)
82 {
83 }
84
hb_font_destroy(hb_font_t *)85 void hb_font_destroy(hb_font_t *)
86 {
87 }
88
hb_face_destroy(hb_face_t *)89 void hb_face_destroy (hb_face_t *)
90 {
91 }
92
hb_buffer_add_utf16(hb_buffer_t *,const uint16_t *,int32_t,uint32_t,int32_t)93 void hb_buffer_add_utf16(hb_buffer_t *, const uint16_t *, int32_t, uint32_t, int32_t)
94 {
95 }
96
hb_buffer_set_direction(hb_buffer_t *,hb_direction_t)97 void hb_buffer_set_direction(hb_buffer_t *, hb_direction_t)
98 {
99 }
100
hb_buffer_set_unicode_funcs(hb_buffer_t *,hb_unicode_funcs_t *)101 void hb_buffer_set_unicode_funcs(hb_buffer_t *, hb_unicode_funcs_t*)
102 {
103 }
104
hb_icu_get_unicode_funcs()105 hb_unicode_funcs_t *hb_icu_get_unicode_funcs()
106 {
107 return nullptr;
108 }
109
hb_buffer_set_script(hb_buffer_t *,hb_script_t)110 void hb_buffer_set_script(hb_buffer_t *, hb_script_t)
111 {
112 }
113
hb_buffer_set_language(hb_buffer_t *,hb_language_t)114 void hb_buffer_set_language(hb_buffer_t *, hb_language_t)
115 {
116 }
117
hb_face_create_for_tables(hb_reference_table_func_t,void *,hb_destroy_func_t)118 hb_face_t *hb_face_create_for_tables(hb_reference_table_func_t, void *, hb_destroy_func_t)
119 {
120 return g_measurerMockvars.retvalFaceCreate.get();
121 }
122
hb_font_create(hb_face_t * face)123 hb_font_t *hb_font_create(hb_face_t *face)
124 {
125 g_measurerMockvars.calledHBFontCreate++;
126 return g_measurerMockvars.retvalFontCreate.get();
127 }
128
hb_shape(hb_font_t *,hb_buffer_t *,const hb_feature_t *,unsigned int)129 void hb_shape(hb_font_t *, hb_buffer_t *, const hb_feature_t *, unsigned int)
130 {
131 }
132
hb_buffer_get_glyph_infos(hb_buffer_t * buffer,unsigned int * length)133 hb_glyph_info_t *hb_buffer_get_glyph_infos(hb_buffer_t *buffer, unsigned int *length)
134 {
135 *length = g_measurerMockvars.retvalGetGlyphInfo.size();
136 return g_measurerMockvars.retvalGetGlyphInfo.data();
137 }
138
hb_buffer_get_glyph_positions(hb_buffer_t * buffer,unsigned int * length)139 hb_glyph_position_t *hb_buffer_get_glyph_positions(hb_buffer_t *buffer, unsigned int *length)
140 {
141 return g_measurerMockvars.retvalGetGlyphPosition.data();
142 }
143
u_isWhitespace(UChar32 c)144 U_CAPI UBool U_EXPORT2 u_isWhitespace(UChar32 c)
145 {
146 return g_measurerMockvars.retvalIsWhitespace;
147 }
148
149 namespace OHOS {
150 namespace Rosen {
151 namespace TextEngine {
GetTableSize(uint32_t tag) const152 size_t TexgineTypeface::GetTableSize(uint32_t tag) const
153 {
154 return g_measurerMockvars.retvalGetTableSize;
155 }
156
GetTableData(uint32_t tag,size_t offset,size_t length,void * data) const157 size_t TexgineTypeface::GetTableData(uint32_t tag, size_t offset, size_t length, void *data) const
158 {
159 return g_measurerMockvars.retvalGetTableData;
160 }
161
GetUnitsPerEm() const162 int TexgineTypeface::GetUnitsPerEm() const
163 {
164 return g_measurerMockvars.retvalGetUnitsPerEm;
165 }
166
GetBoundary(const std::vector<uint16_t> & u16str,bool)167 std::vector<Boundary> WordBreaker::GetBoundary(const std::vector<uint16_t> &u16str, bool)
168 {
169 return {};
170 }
171
Has(uint32_t ch)172 bool Typeface::Has(uint32_t ch)
173 {
174 return g_measurerMockvars.retvalTypefaceHas;
175 }
176
GetTypefaceForChar(const uint32_t & ch,const FontStyles & style,const std::string & script,const std::string & locale) const177 std::shared_ptr<Typeface> FontCollection::GetTypefaceForChar(const uint32_t &ch,
178 const FontStyles &style, const std::string &script, const std::string &locale) const
179 {
180 return g_measurerMockvars.typeface;
181 }
182
InitMiMockVars(MockVars vars,std::list<struct MeasuringRun> runs)183 void InitMiMockVars(MockVars vars, std::list<struct MeasuringRun> runs)
184 {
185 g_measurerMockvars = std::move(vars);
186 mRuns.clear();
187 mRuns.insert(mRuns.begin(), runs.begin(), runs.end());
188 }
189
190 class MeasurerImplTest : public testing::Test {
191 public:
MeasurerImplTest()192 MeasurerImplTest()
193 {
194 normalff_.SetFeature("ftag", 1);
195 }
196
197 std::vector<uint16_t> text_ = {};
198 FontCollection fontCollection_ = std::vector<std::shared_ptr<VariantFontStyleSet>>{};
199 FontFeatures emptyff_;
200 FontFeatures normalff_;
201 CharGroups charGroups_;
202 };
203
204 /**
205 * @tc.name: HbFaceReferenceTableTypeface
206 * @tc.desc: Verify the HbFaceReferenceTableTypeface
207 * @tc.type:FUNC
208 */
209 HWTEST_F(MeasurerImplTest, HbFaceReferenceTableTypeface, TestSize.Level1)
210 {
211 EXPECT_EQ(HbFaceReferenceTableTypeface({}, {}, nullptr), nullptr);
212
213 InitMiMockVars({.retvalGetTableSize = 0}, {});
214 EXPECT_EQ(HbFaceReferenceTableTypeface({}, {}, this), nullptr);
215
216 InitMiMockVars({.retvalGetTableSize = static_cast<size_t>(1000)}, {});
217 EXPECT_EQ(HbFaceReferenceTableTypeface({}, {}, this), nullptr);
218
219 InitMiMockVars({.retvalGetTableSize = 2, .retvalGetTableData = 1}, {});
220 EXPECT_EQ(HbFaceReferenceTableTypeface({}, {}, this), nullptr);
221
222 InitMiMockVars({}, {});
223 EXPECT_NE(HbFaceReferenceTableTypeface({}, {}, this), nullptr);
224 }
225
226 /**
227 * @tc.name: Create
228 * @tc.desc: Verify the Create
229 * @tc.type:FUNC
230 */
231 HWTEST_F(MeasurerImplTest, Create, TestSize.Level1)
232 {
233 EXPECT_NE(MeasurerImpl::Create({}, fontCollection_), nullptr);
234 }
235
236 /**
237 * @tc.name: Measure1
238 * @tc.desc: Verify the Measure
239 * @tc.type:FUNC
240 */
241 HWTEST_F(MeasurerImplTest, Measure1, TestSize.Level1)
242 {
243 size_t ret = 0;
244 InitMiMockVars({.retvalBufferCreate = nullptr}, {});
245 uint16_t testText = 2;
246 text_ = {testText};
247 MeasurerImpl mi(text_, fontCollection_);
248 int begin = 0;
249 int end = 1;
250 mi.SetRange(begin, end);
251 mi.SetFontFeatures(emptyff_);
252
253 EXPECT_EQ(mi.Measure(charGroups_), 1);
254 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
255 }
256
257 /**
258 * @tc.name: Measure2
259 * @tc.desc: Verify the Measure
260 * @tc.type:FUNC
261 */
262 HWTEST_F(MeasurerImplTest, Measure2, TestSize.Level1)
263 {
264 size_t ret = 1;
265 InitMiMockVars({}, {});
266 uint16_t testText = 2;
267 text_ = {testText};
268 MeasurerImpl mi(text_, fontCollection_);
269 int begin = 0;
270 int end = 1;
271 mi.SetRange(begin, end);
272 mi.SetFontFeatures(emptyff_);
273
274 EXPECT_EQ(mi.Measure(charGroups_), 0);
275 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
276 ret++;
277 EXPECT_EQ(mi.Measure(charGroups_), 0);
278 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
279 }
280
281 /**
282 * @tc.name: Measure3
283 * @tc.desc: Verify the Measure
284 * @tc.type:FUNC
285 */
286 HWTEST_F(MeasurerImplTest, Measure3, TestSize.Level1)
287 {
288 size_t ret = 1;
289 InitMiMockVars({}, {});
290 text_ = {3};
291 MeasurerImpl mi(text_, fontCollection_);
292 mi.SetRange(0, 1);
293 mi.SetFontFeatures(normalff_);
294
295 EXPECT_EQ(mi.Measure(charGroups_), 0);
296 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
297 }
298
299 /**
300 * @tc.name: SeekTypeface1
301 * @tc.desc: Verify the SeekTypeface
302 * @tc.type:FUNC
303 */
304 HWTEST_F(MeasurerImplTest, SeekTypeface1, TestSize.Level1)
305 {
306 InitMiMockVars({.typeface = nullptr}, {{.start = 0, .end = 1}});
307 text_ = {'a'};
308 MeasurerImpl mi(text_, fontCollection_);
309 mi.SetRange(0, 1);
310
311 std::list<struct MeasuringRun> runs;
312 mi.SeekTypeface(mRuns);
313 EXPECT_EQ(mRuns.size(), 1);
314 EXPECT_EQ(mRuns.front().typeface, nullptr);
315 }
316
317 /**
318 * @tc.name: SeekTypeface2
319 * @tc.desc: Verify the SeekTypeface
320 * @tc.type:FUNC
321 */
322 HWTEST_F(MeasurerImplTest, SeekTypeface2, TestSize.Level1)
323 {
324 InitMiMockVars({}, {{.start = 0, .end = 2},});
325 text_ = {'a', 'b'};
326 MeasurerImpl mi(text_, fontCollection_);
327 mi.SetRange(0, 2);
328
329 mi.SeekTypeface(mRuns);
330 EXPECT_EQ(mRuns.size(), 1);
331 EXPECT_EQ(mRuns.front().typeface, g_measurerMockvars.typeface);
332 }
333
334 /**
335 * @tc.name: SeekTypeface3
336 * @tc.desc: Verify the SeekTypeface
337 * @tc.type:FUNC
338 */
339 HWTEST_F(MeasurerImplTest, SeekTypeface3, TestSize.Level1)
340 {
341 InitMiMockVars({.retvalTypefaceHas = false}, {{.start = 0, .end = 2},});
342 text_ = {'a', 'b'};
343 MeasurerImpl mi(text_, fontCollection_);
344 mi.SetRange(0, 2);
345 mi.SeekTypeface(mRuns);
346 EXPECT_EQ(mRuns.size(), 2);
347 EXPECT_EQ(mRuns.front().typeface, g_measurerMockvars.typeface);
348 }
349
350 /**
351 * @tc.name: SeekTypeface4
352 * @tc.desc: Verify the SeekTypeface
353 * @tc.type:FUNC
354 */
355 HWTEST_F(MeasurerImplTest, SeekTypeface4, TestSize.Level1)
356 {
357 InitMiMockVars({.retvalTypefaceHas = false}, {{.start = 0, .end = 2},});
358 text_ = {'a'};
359 MeasurerImpl mi(text_, fontCollection_);
360 mi.SetRange(0, 2);
361 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, mi.SeekTypeface(mRuns));
362 }
363
364 /**
365 * @tc.name: SeekScript1
366 * @tc.desc: Verify the SeekScript
367 * @tc.type:FUNC
368 */
369 HWTEST_F(MeasurerImplTest, SeekScript1, TestSize.Level1)
370 {
371 InitMiMockVars({.retvalUnicodeFuncsCreate = nullptr}, {});
372 MeasurerImpl mi(text_, fontCollection_);
373 ASSERT_EXCEPTION(ExceptionType::API_FAILED, mi.SeekScript(mRuns));
374 }
375
376 /**
377 * @tc.name: SeekScript2
378 * @tc.desc: Verify the SeekScript
379 * @tc.type:FUNC
380 */
381 HWTEST_F(MeasurerImplTest, SeekScript2, TestSize.Level1)
382 {
383 InitMiMockVars({.retvalUnicodeScript = {HB_SCRIPT_HAN}}, {{.start = 0, .end = 1},});
384 MeasurerImpl mi(text_, fontCollection_);
385
386 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, mi.SeekScript(mRuns));
387 }
388
389 /**
390 * @tc.name: SeekScript3
391 * @tc.desc: Verify the SeekScript
392 * @tc.type:FUNC
393 */
394 HWTEST_F(MeasurerImplTest, SeekScript3, TestSize.Level1)
395 {
396 InitMiMockVars({.retvalUnicodeScript = {HB_SCRIPT_HAN}}, {});
397 text_ = {'a'};
398 MeasurerImpl mi(text_, fontCollection_);
399 mi.SetRange(0, 1);
400
401 EXPECT_NE(mRuns.front().script, HB_SCRIPT_HAN);
402 mi.SeekScript(mRuns);
403 EXPECT_EQ(mRuns.size(), 1);
404 EXPECT_EQ(mRuns.front().script, HB_SCRIPT_HAN);
405 }
406
407 /**
408 * @tc.name: SeekScript4
409 * @tc.desc: Verify the SeekScript
410 * @tc.type:FUNC
411 */
412 HWTEST_F(MeasurerImplTest, SeekScript4, TestSize.Level1)
413 {
414 InitMiMockVars({.retvalUnicodeScript = {HB_SCRIPT_HAN, HB_SCRIPT_INHERITED}}, {});
415 text_ = {'a', 'b'};
416 MeasurerImpl mi(text_, fontCollection_);
417 mi.SetRange(0, 2);
418
419 mi.SeekScript(mRuns);
420 EXPECT_EQ(mRuns.size(), 1);
421 EXPECT_EQ(mRuns.front().script, HB_SCRIPT_HAN);
422
423 InitMiMockVars({.retvalUnicodeScript = {HB_SCRIPT_HAN, HB_SCRIPT_COMMON}}, {});
424 mi.SeekScript(mRuns);
425 EXPECT_EQ(mRuns.size(), 1);
426 EXPECT_EQ(mRuns.front().script, HB_SCRIPT_HAN);
427 }
428
429 /**
430 * @tc.name: SeekScript5
431 * @tc.desc: Verify the SeekScript
432 * @tc.type:FUNC
433 */
434 HWTEST_F(MeasurerImplTest, SeekScript5, TestSize.Level1)
435 {
436 InitMiMockVars({.retvalUnicodeScript = {HB_SCRIPT_LATIN}}, {});
437 text_ = {'a'};
438 MeasurerImpl mi(text_, fontCollection_);
439
440 std::list<struct MeasuringRun> runs;
441 runs.push_back({.start = 0, .end = 1, .script = HB_SCRIPT_HAN});
442 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, mi.SeekScript(runs));
443 }
444
445 /**
446 * @tc.name: Shape1
447 * @tc.desc: Verify the Shape
448 * @tc.type:FUNC
449 */
450 HWTEST_F(MeasurerImplTest, Shape1, TestSize.Level1)
451 {
452 size_t ret = 0;
453 InitMiMockVars({}, {});
454 MeasurerImpl mi(text_, fontCollection_);
455
456 std::list<struct MeasuringRun> runs;
457 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 0);
458 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
459 }
460
461 /**
462 * @tc.name: Shape2
463 * @tc.desc: Verify the Shape
464 * @tc.type:FUNC
465 */
466 HWTEST_F(MeasurerImplTest, Shape2, TestSize.Level1)
467 {
468 InitMiMockVars({}, {});
469 MeasurerImpl mi(text_, fontCollection_);
470
471 std::list<struct MeasuringRun> runs;
472 runs.push_back({.start = 0, .end = 0});
473 ASSERT_EXCEPTION(ExceptionType::ERROR_STATUS, mi.Shape(charGroups_, runs, {}));
474 }
475
476 /**
477 * @tc.name: Shape3
478 * @tc.desc: Verify the Shape
479 * @tc.type:FUNC
480 */
481 HWTEST_F(MeasurerImplTest, Shape3, TestSize.Level1)
482 {
483 size_t ret = 0;
484 InitMiMockVars({}, {});
485 MeasurerImpl mi(text_, fontCollection_);
486
487 std::list<struct MeasuringRun> runs;
488 runs.push_back({.start = 0, .end = 1, .typeface = nullptr});
489 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 1);
490 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
491 }
492
493 /**
494 * @tc.name: Shape4
495 * @tc.desc: Verify the Shape
496 * @tc.type:FUNC
497 */
498 HWTEST_F(MeasurerImplTest, Shape4, TestSize.Level1)
499 {
500 size_t ret = 0;
501 InitMiMockVars({.retvalBufferCreate = nullptr}, {});
502 MeasurerImpl mi(text_, fontCollection_);
503
504 std::list<struct MeasuringRun> runs;
505 runs.push_back({.start = 0, .end = 1, .typeface = g_measurerMockvars.typeface});
506 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 1);
507 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
508 }
509
510 /**
511 * @tc.name: Shape5
512 * @tc.desc: Verify the Shape
513 * @tc.type:FUNC
514 */
515 HWTEST_F(MeasurerImplTest, Shape5, TestSize.Level1)
516 {
517 size_t ret = 0;
518 InitMiMockVars({.retvalFaceCreate = nullptr}, {});
519 MeasurerImpl mi(text_, fontCollection_);
520
521 std::list<struct MeasuringRun> runs;
522 runs.push_back({.start = 0, .end = 1, .typeface = g_measurerMockvars.typeface});
523 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 1);
524 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
525 }
526
527 /**
528 * @tc.name: Shape6
529 * @tc.desc: Verify the Shape
530 * @tc.type:FUNC
531 */
532 HWTEST_F(MeasurerImplTest, Shape6, TestSize.Level1)
533 {
534 size_t ret = 1;
535 InitMiMockVars({.retvalFontCreate = nullptr}, {});
536 MeasurerImpl mi(text_, fontCollection_);
537
538 std::list<struct MeasuringRun> runs;
539 runs.push_back({.start = 0, .end = 1, .typeface = g_measurerMockvars.typeface});
540 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 1);
541 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
542 }
543
544 /**
545 * @tc.name: Shape7
546 * @tc.desc: Verify the Shape
547 * @tc.type:FUNC
548 */
549 HWTEST_F(MeasurerImplTest, Shape7, TestSize.Level1)
550 {
551 size_t ret = 1;
552 InitMiMockVars({.retvalGetGlyphInfo = {}}, {});
553 MeasurerImpl mi(text_, fontCollection_);
554 mi.SetFontFeatures(normalff_);
555
556 std::list<struct MeasuringRun> runs;
557 runs.push_back({.start = 0, .end = 1, .typeface = g_measurerMockvars.typeface});
558 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 1);
559 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
560 }
561
562 /**
563 * @tc.name: Shape8
564 * @tc.desc: Verify the Shape
565 * @tc.type:FUNC
566 */
567 HWTEST_F(MeasurerImplTest, Shape8, TestSize.Level1)
568 {
569 size_t ret = 1;
570 InitMiMockVars({.retvalGetGlyphPosition = {}}, {});
571 MeasurerImpl mi(text_, fontCollection_);
572 mi.SetFontFeatures(normalff_);
573
574 std::list<struct MeasuringRun> runs;
575 runs.push_back({.start = 0, .end = 1, .typeface = g_measurerMockvars.typeface});
576 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 1);
577 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
578 }
579
580 /**
581 * @tc.name: Shape9
582 * @tc.desc: Verify the Shape
583 * @tc.type:FUNC
584 */
585 HWTEST_F(MeasurerImplTest, Shape9, TestSize.Level1)
586 {
587 size_t ret = 1;
588 InitMiMockVars({.retvalGetUnitsPerEm = 0}, {});
589 MeasurerImpl mi(text_, fontCollection_);
590 mi.SetFontFeatures(normalff_);
591
592 std::list<struct MeasuringRun> runs;
593 runs.push_back({.start = 0, .end = 1, .typeface = g_measurerMockvars.typeface});
594 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 1);
595 EXPECT_EQ(g_measurerMockvars.calledHBFontCreate, ret);
596 }
597
598 /**
599 * @tc.name: Shape10
600 * @tc.desc: Verify the Shape
601 * @tc.type:FUNC
602 */
603 HWTEST_F(MeasurerImplTest, Shape10, TestSize.Level1)
604 {
605 InitMiMockVars({.retvalIsWhitespace = true}, {});
606 g_measurerMockvars.retvalGetGlyphPosition[0].x_advance = 10;
607 text_ = {'a'};
608 MeasurerImpl mi(text_, fontCollection_);
609 mi.SetFontFeatures(normalff_);
610
611 std::list<struct MeasuringRun> runs;
612 runs.push_back({.start = 0, .end = 1, .typeface = g_measurerMockvars.typeface});
613 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 0);
614 EXPECT_EQ(charGroups_.GetSize(), 1);
615 EXPECT_GT(charGroups_.Get(0).invisibleWidth, charGroups_.Get(0).visibleWidth);
616 }
617
618 /**
619 * @tc.name: Shape11
620 * @tc.desc: Verify the Shape
621 * @tc.type:FUNC
622 */
623 HWTEST_F(MeasurerImplTest, Shape11, TestSize.Level1)
624 {
625 InitMiMockVars({}, {});
626 text_ = {'a', 'b'};
627 MeasurerImpl mi(text_, fontCollection_);
628 mi.SetFontFeatures(normalff_);
629 mi.SetRTL(true);
630
631 std::list<struct MeasuringRun> runs;
632 runs.push_back({.start = 0, .end = 1, .typeface = g_measurerMockvars.typeface});
633 runs.push_back({.start = 1, .end = 2, .typeface = g_measurerMockvars.typeface});
634 EXPECT_EQ(mi.Shape(charGroups_, runs, {}), 0);
635 EXPECT_EQ(charGroups_.GetSize(), 2);
636 }
637
638 /**
639 * @tc.name: Shape12
640 * @tc.desc: Verify the Shape
641 * @tc.type:FUNC
642 */
643 HWTEST_F(MeasurerImplTest, Shape12, TestSize.Level1)
644 {
645 InitMiMockVars({.retvalGetGlyphInfo = {{.cluster = 0}, {.cluster = 1}},
646 .retvalGetGlyphPosition = {{}, {}}}, {});
647 text_ = {'a', 'b'};
648 MeasurerImpl mi(text_, fontCollection_);
649 mi.SetFontFeatures(normalff_);
650 mi.SetSpacing(5, 10);
651
652 std::list<struct MeasuringRun> runs;
653 runs.push_back({.start = 0, .end = 2, .typeface = g_measurerMockvars.typeface});
654 std::vector<Boundary> boundaries;
655 boundaries.emplace_back(0, 2);
656 EXPECT_EQ(mi.Shape(charGroups_, runs, boundaries), 0);
657 EXPECT_EQ(charGroups_.GetSize(), 2);
658 EXPECT_EQ(charGroups_.Get(0).invisibleWidth, 5);
659 EXPECT_EQ(charGroups_.Get(1).invisibleWidth, 15);
660 }
661
662 /**
663 * @tc.name: GenerateHBFeatures1
664 * @tc.desc: Verify the GenerateHBFeatures
665 * @tc.type:FUNC
666 */
667 HWTEST_F(MeasurerImplTest, GenerateHBFeatures1, TestSize.Level1)
668 {
669 InitMiMockVars({}, {});
670 MeasurerImpl mi(text_, fontCollection_);
671 std::vector<hb_feature_t> features;
672 mi.GenerateHBFeatures(features, nullptr);
673 EXPECT_EQ(features.size(), 0);
674 }
675
676 /**
677 * @tc.name: GenerateHBFeatures2
678 * @tc.desc: Verify the GenerateHBFeatures
679 * @tc.type:FUNC
680 */
681 HWTEST_F(MeasurerImplTest, GenerateHBFeatures2, TestSize.Level1)
682 {
683 InitMiMockVars({}, {});
684 MeasurerImpl mi(text_, fontCollection_);
685 std::vector<hb_feature_t> features;
686 mi.GenerateHBFeatures(features, &emptyff_);
687 EXPECT_EQ(features.size(), 0);
688 }
689
690 /**
691 * @tc.name: GenerateHBFeatures3
692 * @tc.desc: Verify the GenerateHBFeatures
693 * @tc.type:FUNC
694 */
695 HWTEST_F(MeasurerImplTest, GenerateHBFeatures3, TestSize.Level1)
696 {
697 InitMiMockVars({.retvalHBFeatureFromString = false}, {});
698 MeasurerImpl mi(text_, fontCollection_);
699 std::vector<hb_feature_t> features;
700 mi.GenerateHBFeatures(features, &normalff_);
701 EXPECT_EQ(features.size(), 0);
702 EXPECT_EQ(normalff_.GetFeatures().size(), 1);
703 }
704
705 /**
706 * @tc.name: GenerateHBFeatures4
707 * @tc.desc: Verify the GenerateHBFeatures
708 * @tc.type:FUNC
709 */
710 HWTEST_F(MeasurerImplTest, GenerateHBFeatures4, TestSize.Level1)
711 {
712 InitMiMockVars({}, {});
713 MeasurerImpl mi(text_, fontCollection_);
714 std::vector<hb_feature_t> features;
715 mi.GenerateHBFeatures(features, &normalff_);
716 EXPECT_EQ(features.size(), 1);
717 EXPECT_EQ(normalff_.GetFeatures().size(), 1);
718 }
719 } // namespace TextEngine
720 } // namespace Rosen
721 } // namespace OHOS
722