1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <cstddef>
17 
18 #include "gtest/gtest.h"
19 #include "recording/draw_cmd.h"
20 #include "skia_adapter/skia_typeface.h"
21 
22 #include "text/text_blob.h"
23 
24 
25 using namespace testing;
26 using namespace testing::ext;
27 
28 #define HB_TAG(c1,c2,c3,c4) ((uint32_t)((((uint32_t)(c1)&0xFF)<<24)|(((uint32_t)(c2)&0xFF)<<16)|(((uint32_t)(c3)&0xFF)<<8)|((uint32_t)(c4)&0xFF)))
29 
30 namespace OHOS {
31 namespace Rosen {
32 namespace Drawing {
33 class SkiaTypefaceTest : public testing::Test {
34 public:
35     static void SetUpTestCase();
36     static void TearDownTestCase();
37     void SetUp() override;
38     void TearDown() override;
39 };
40 
SetUpTestCase()41 void SkiaTypefaceTest::SetUpTestCase() {}
TearDownTestCase()42 void SkiaTypefaceTest::TearDownTestCase() {}
SetUp()43 void SkiaTypefaceTest::SetUp() {}
TearDown()44 void SkiaTypefaceTest::TearDown() {}
45 
46 /**
47  * @tc.name: GetFamilyName001
48  * @tc.desc: Test GetFamilyName
49  * @tc.type: FUNC
50  * @tc.require:I91EDT
51  */
52 HWTEST_F(SkiaTypefaceTest, GetFamilyName001, TestSize.Level1)
53 {
54     auto typeface1 = SkiaTypeface::MakeDefault();
55     ASSERT_TRUE(typeface1->GetFamilyName() != std::string());
56 }
57 
58 /**
59  * @tc.name: GetFontStyle001
60  * @tc.desc: Test GetFontStyle
61  * @tc.type: FUNC
62  * @tc.require:I91EDT
63  */
64 HWTEST_F(SkiaTypefaceTest, GetFontStyle001, TestSize.Level1)
65 {
66     auto typeface1 = SkiaTypeface::MakeDefault();
67     ASSERT_TRUE(typeface1->GetFontStyle().GetWidth() >= 0);
68 }
69 
70 /**
71  * @tc.name: GetTableData001
72  * @tc.desc: Test GetTableData
73  * @tc.type: FUNC
74  * @tc.require:I91EDT
75  */
76 HWTEST_F(SkiaTypefaceTest, GetTableData001, TestSize.Level1)
77 {
78     auto typeface1 = SkiaTypeface::MakeDefault();
79     auto tag = HB_TAG('n', 'a', 'm', 'e');
80     auto size = typeface1->GetTableSize(tag);
81     std::unique_ptr<char[]> tableData = nullptr;
82     tableData = std::make_unique<char[]>(size);
83     auto retTableData = typeface1->GetTableData(tag, 0, size, tableData.get());
84     ASSERT_TRUE(retTableData == size);
85 }
86 
87 /**
88  * @tc.name: GetItalic001
89  * @tc.desc: Test GetItalic
90  * @tc.type: FUNC
91  * @tc.require:I91EDT
92  */
93 HWTEST_F(SkiaTypefaceTest, GetItalic001, TestSize.Level1)
94 {
95     auto typeface1 = SkiaTypeface::MakeDefault();
96     ASSERT_TRUE(!typeface1->GetItalic());
97 }
98 
99 /**
100  * @tc.name: GetUniqueID001
101  * @tc.desc: Test GetUniqueID
102  * @tc.type: FUNC
103  * @tc.require:I91EDT
104  */
105 HWTEST_F(SkiaTypefaceTest, GetUniqueID001, TestSize.Level1)
106 {
107     auto typeface = SkiaTypeface::MakeDefault();
108     ASSERT_TRUE(typeface->GetUniqueID() >= 0);
109 }
110 
111 /**
112  * @tc.name: GetUnitsPerEm001
113  * @tc.desc: Test GetUnitsPerEm
114  * @tc.type: FUNC
115  * @tc.require:I91EDT
116  */
117 HWTEST_F(SkiaTypefaceTest, GetUnitsPerEm001, TestSize.Level1)
118 {
119     auto typeface = SkiaTypeface::MakeDefault();
120     ASSERT_TRUE(typeface->GetUnitsPerEm() >= 0);
121 }
122 
123 /**
124  * @tc.name: SerializeTypeface001
125  * @tc.desc: Test SerializeTypeface
126  * @tc.type: FUNC
127  * @tc.require:I91EDT
128  */
129 HWTEST_F(SkiaTypefaceTest, SerializeTypeface001, TestSize.Level1)
130 {
131     auto skTypeface = SkTypeface::MakeDefault();
132     ASSERT_TRUE(SkiaTypeface::SerializeTypeface(skTypeface.get(), nullptr) != nullptr);
133     ASSERT_TRUE(SkiaTypeface::SerializeTypeface(nullptr, nullptr) == nullptr);
134 }
135 
136 /**
137  * @tc.name: MakeFromName001
138  * @tc.desc: Test MakeFromName
139  * @tc.type: FUNC
140  * @tc.require:I91EDT
141  */
142 HWTEST_F(SkiaTypefaceTest, MakeFromName001, TestSize.Level1)
143 {
144     FontStyle fontStyle;
145     ASSERT_TRUE(SkiaTypeface::MakeFromName("familyName", fontStyle) != nullptr);
146 }
147 
148 /**
149  * @tc.name: MakeFromName002
150  * @tc.desc: Test MakeFromName
151  * @tc.type: FUNC
152  * @tc.require:I91EDT
153  */
154 HWTEST_F(SkiaTypefaceTest, MakeFromName002, TestSize.Level1)
155 {
156     FontStyle fontStyle;
157     auto typeface = SkiaTypeface::MakeDefault();
158     ASSERT_TRUE(typeface != nullptr);
159     ASSERT_TRUE(SkiaTypeface::MakeFromName("familyName", fontStyle) != nullptr);
160 }
161 
162 /**
163  * @tc.name: MakeFromFile001
164  * @tc.desc: Test MakeFromFile
165  * @tc.type: FUNC
166  * @tc.require:I91EDT
167  */
168 HWTEST_F(SkiaTypefaceTest, MakeFromFile001, TestSize.Level1)
169 {
170     ASSERT_TRUE(SkiaTypeface::MakeFromFile("path", 0) == nullptr);
171 }
172 
173 /**
174  * @tc.name: MakeFromFile002
175  * @tc.desc: Test MakeFromFile
176  * @tc.type: FUNC
177  * @tc.require:I91EDT
178  */
179 HWTEST_F(SkiaTypefaceTest, MakeFromFile002, TestSize.Level1)
180 {
181     auto defaultTypeface = SkiaTypeface::MakeDefault();
182     ASSERT_NE(defaultTypeface, nullptr) ;
183     const char validPath[] = "resources/fonts/Em.ttf";
184     auto typefaceInvalidPath = SkiaTypeface::MakeFromFile("invalid/path/to/font.ttf", 0);
185     ASSERT_EQ(typefaceInvalidPath, nullptr);
186     auto typefaceInvalidIndex = SkiaTypeface::MakeFromFile(validPath, 99); // 索引99是一个无效的索引
187     ASSERT_EQ(typefaceInvalidIndex, nullptr);
188 }
189 
190 /**
191  * @tc.name: IsCustomTypeface001
192  * @tc.desc: Test IsCustomTypeface
193  * @tc.type: FUNC
194  * @tc.require:I91EDT
195  */
196 HWTEST_F(SkiaTypefaceTest, IsCustomTypeface001, TestSize.Level1)
197 {
198     auto typeface1 = SkiaTypeface::MakeDefault();
199     ASSERT_TRUE(!typeface1->IsCustomTypeface());
200     ASSERT_TRUE(!typeface1->IsThemeTypeface());
201     auto typeface2 = SkiaTypeface(nullptr);
202     ASSERT_TRUE(!typeface2.IsCustomTypeface());
203     ASSERT_TRUE(!typeface2.IsThemeTypeface());
204 }
205 
206 /**
207  * @tc.name: GetFamilyName002
208  * @tc.desc: Test GetFamilyName
209  * @tc.type: FUNC
210  * @tc.require:I91EDT
211  */
212 HWTEST_F(SkiaTypefaceTest, GetFamilyName002, TestSize.Level1)
213 {
214     auto typeface = SkiaTypeface::MakeDefault();
215     ASSERT_TRUE(typeface != nullptr);
216     std::string familyNameFromMethod = typeface->GetFamilyName();
217     ASSERT_FALSE(familyNameFromMethod.empty());
218 }
219 
220 /**
221  * @tc.name: GetFontStyle002
222  * @tc.desc: Test GetFontStyle
223  * @tc.type: FUNC
224  * @tc.require:I91EDT
225  */
226 HWTEST_F(SkiaTypefaceTest, GetFontStyle002, TestSize.Level1)
227 {
228     FontStyle expectedStyle;
229     auto typeface = SkiaTypeface::MakeDefault();
230     ASSERT_NE(typeface, nullptr);
231     FontStyle fontStyle = typeface->GetFontStyle();
232     EXPECT_EQ(expectedStyle, fontStyle);
233 }
234 
235 /**
236  * @tc.name: GetTableSize001
237  * @tc.desc: Test GetTableSize
238  * @tc.type: FUNC
239  * @tc.require:I91EDT
240  */
241 HWTEST_F(SkiaTypefaceTest, GetTableSize001, TestSize.Level1)
242 {
243     auto typeface = std::make_shared<Typeface>(nullptr);
244     auto tag = HB_TAG('n', 'a', 'm', 'e');
245     auto size = typeface->GetTableSize(tag);
246     EXPECT_EQ(size, 0u);
247 }
248 
249 /**
250  * @tc.name: GetTableData002
251  * @tc.desc: Test GetTableData
252  * @tc.type: FUNC
253  * @tc.require:I91EDT
254  */
255 HWTEST_F(SkiaTypefaceTest, GetTableData002, TestSize.Level1)
256 {
257     auto typeface = std::make_shared<Typeface>(nullptr);
258     auto tag = HB_TAG('n', 'a', 'm', 'e');
259     auto size = typeface->GetTableSize(tag);
260     std::unique_ptr<char[]> tableData = nullptr;
261     tableData = std::make_unique<char[]>(size);
262     auto retTableData = typeface->GetTableData(tag, 0, size, tableData.get());
263     ASSERT_TRUE(retTableData == size);
264 }
265 
266 /**
267  * @tc.name: GetItalic002
268  * @tc.desc: Test GetItalic
269  * @tc.type: FUNC
270  * @tc.require:I91EDT
271  */
272 HWTEST_F(SkiaTypefaceTest, GetItalic002, TestSize.Level1)
273 {
274     auto typeface = SkiaTypeface::MakeDefault();
275     ASSERT_TRUE(typeface != nullptr);
276     ASSERT_TRUE(!typeface->GetItalic());
277 }
278 
279 /**
280  * @tc.name: GetUniqueID002
281  * @tc.desc: Test GetUniqueID
282  * @tc.type: FUNC
283  * @tc.require:I91EDT
284  */
285 HWTEST_F(SkiaTypefaceTest, GetUniqueID002, TestSize.Level1)
286 {
287     auto typeface = std::make_shared<SkiaTypeface>(nullptr);
288     ASSERT_TRUE(typeface->GetUniqueID() == 0);
289 }
290 
291 /**
292  * @tc.name: GetUnitsPerEm002
293  * @tc.desc: Test GetUnitsPerEm
294  * @tc.type: FUNC
295  * @tc.require:I91EDT
296  */
297 HWTEST_F(SkiaTypefaceTest, GetUnitsPerEm002, TestSize.Level1)
298 {
299     auto typeface = std::make_shared<SkiaTypeface>(nullptr);
300     ASSERT_TRUE(typeface->GetUnitsPerEm() == 0);
301 }
302 
303 /**
304  * @tc.name: MakeClone001
305  * @tc.desc: Test MakeClone
306  * @tc.type: FUNC
307  * @tc.require:I91EDT
308  */
309 HWTEST_F(SkiaTypefaceTest, MakeClone001, TestSize.Level1)
310 {
311     auto typeface = SkiaTypeface::MakeDefault();
312     ASSERT_TRUE(typeface != nullptr);
313     FontArguments skArgs;
314     ASSERT_TRUE(typeface->MakeClone(skArgs) != nullptr);
315 }
316 
317 /**
318  * @tc.name: GetSkTypeface002
319  * @tc.desc: Test GetSkTypeface
320  * @tc.type: FUNC
321  * @tc.require:I91EDT
322  */
323 HWTEST_F(SkiaTypefaceTest, GetSkTypeface002, TestSize.Level1)
324 {
325     auto typeface = SkTypeface::MakeDefault();
326     auto skiatypeface = SkiaTypeface(typeface);
327     ASSERT_TRUE(typeface != nullptr);
328     ASSERT_TRUE(skiatypeface.GetSkTypeface() != nullptr);
329 }
330 
331 /**
332  * @tc.name: MakeDefault001
333  * @tc.desc: Test MakeDefault
334  * @tc.type: FUNC
335  * @tc.require:I91EDT
336  */
337 HWTEST_F(SkiaTypefaceTest, MakeDefault001, TestSize.Level1)
338 {
339     auto typeface = SkiaTypeface::MakeDefault();
340     ASSERT_TRUE(typeface != nullptr);
341     ASSERT_TRUE(SkiaTypeface::MakeDefault() != nullptr);
342 }
343 
344 /**
345  * @tc.name: MakeFromStream001
346  * @tc.desc: Test MakeFromStream
347  * @tc.type: FUNC
348  * @tc.require: I91EDT
349  */
350 HWTEST_F(SkiaTypefaceTest, MakeFromStream001, TestSize.Level1)
351 {
352     std::unique_ptr<MemoryStream> memoryStream = std::make_unique<MemoryStream>();
353     uint8_t fontData[] = "Mock font data";
354     size_t fontDataSize = sizeof(fontData);
355     memoryStream = std::make_unique<MemoryStream>(reinterpret_cast<const void*>(fontData), fontDataSize, true);
356     std::shared_ptr<Typeface> typefaceWithData = SkiaTypeface::MakeFromStream(std::move(memoryStream), 0);
357     ASSERT_EQ(typefaceWithData, nullptr);
358     std::shared_ptr<Typeface> typefaceEmptyStream = SkiaTypeface::MakeFromStream(std::make_unique<MemoryStream>(), 0);
359     ASSERT_EQ(typefaceEmptyStream, nullptr);
360 }
361 
362 /**
363  * @tc.name: DeserializeTypeface001
364  * @tc.desc: Test DeserializeTypeface
365  * @tc.type: FUNC
366  * @tc.require: I91EDT
367  */
368 HWTEST_F(SkiaTypefaceTest, DeserializeTypeface001, TestSize.Level1)
369 {
370     constexpr size_t SOME_SIZE = 5; // 5 SOME_SIZE
371     const uint8_t validData[SOME_SIZE] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
372     const uint8_t* dataPtr = validData;
373     auto typeface = SkiaTypeface::MakeDefault();
374     ASSERT_NE(typeface, nullptr);
375     ASSERT_TRUE(dataPtr != nullptr);
376     ASSERT_TRUE(
377         SkiaTypeface::DeserializeTypeface(reinterpret_cast<const void*>(validData), SOME_SIZE, nullptr) == nullptr);
378 }
379 
380 /**
381  * @tc.name: SerializeTypeface002
382  * @tc.desc: Test SerializeTypeface use case normal situation
383  * @tc.type: FUNC
384  * @tc.require:I91EDT
385  */
386 HWTEST_F(SkiaTypefaceTest, SerializeTypeface002, TestSize.Level1)
387 {
388     auto skTypeface = SkTypeface::MakeDefault();
389     bool isCustomTypeface = true;
390     std::shared_ptr<Drawing::Typeface> typeface = nullptr;
391     TextBlob::Context customContext { typeface, isCustomTypeface };
392     auto serializedData = SkiaTypeface::SerializeTypeface(skTypeface.get(), &customContext);
393     ASSERT_TRUE(serializedData != nullptr);
394     ASSERT_TRUE(customContext.GetTypeface() == nullptr);
395 }
396 
397 /**
398  * @tc.name: SerializeTypeface003
399  * @tc.desc: Test SerializeTypeface Case Exception
400  * @tc.type: FUNC
401  * @tc.require:I91EDT
402  */
403 HWTEST_F(SkiaTypefaceTest, SerializeTypeface003, TestSize.Level1)
404 {
405     auto skTypeface = SkTypeface::MakeDefault();
406     bool isCustomTypeface = true;
407     TextBlob::Context customContext { nullptr, isCustomTypeface };
408     auto serializedDataNull = SkiaTypeface::SerializeTypeface(nullptr, &customContext);
409     ASSERT_TRUE(serializedDataNull == nullptr);
410     ASSERT_TRUE(customContext.GetTypeface() == nullptr);
411 }
412 
413 /**
414  * @tc.name: Deserialize001
415  * @tc.desc: Test Deserialize
416  * @tc.type: FUNC
417  * @tc.require:I91EDT
418  */
419 HWTEST_F(SkiaTypefaceTest, Deserialize001, TestSize.Level1)
420 {
421     const void* data = reinterpret_cast<const void*>("test_data");
422     size_t dataSize = sizeof(data);
423     auto typeface = SkiaTypeface::MakeDefault();
424     ASSERT_NE(typeface, nullptr);
425     ASSERT_TRUE(SkiaTypeface::Deserialize(data, dataSize) == nullptr);
426 }
427 
428 /**
429  * @tc.name: Serialize001
430  * @tc.desc: Test Serialize
431  * @tc.type: FUNC
432  * @tc.require:I91EDT
433  */
434 HWTEST_F(SkiaTypefaceTest, Serialize001, TestSize.Level1)
435 {
436     auto typeface = SkiaTypeface::MakeDefault();
437     ASSERT_NE(typeface, nullptr);
438     ASSERT_TRUE(typeface->Serialize() != nullptr);
439 }
440 } // namespace Drawing
441 } // namespace Rosen
442 } // namespace OHOS