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 std::string s = "asd";
55 auto typeface1 = SkiaTypeface::MakeDefault();
56 typeface1->GetFamilyName();
57 }
58
59 /**
60 * @tc.name: GetFontStyle001
61 * @tc.desc: Test GetFontStyle
62 * @tc.type: FUNC
63 * @tc.require:I91EDT
64 */
65 HWTEST_F(SkiaTypefaceTest, GetFontStyle001, TestSize.Level1)
66 {
67 auto typeface1 = SkiaTypeface::MakeDefault();
68 typeface1->GetFontStyle();
69 }
70
71 /**
72 * @tc.name: GetTableData001
73 * @tc.desc: Test GetTableData
74 * @tc.type: FUNC
75 * @tc.require:I91EDT
76 */
77 HWTEST_F(SkiaTypefaceTest, GetTableData001, TestSize.Level1)
78 {
79 auto typeface1 = SkiaTypeface::MakeDefault();
80 auto tag = HB_TAG('n', 'a', 'm', 'e');
81 auto size = typeface1->GetTableSize(tag);
82 std::unique_ptr<char[]> tableData = nullptr;
83 tableData = std::make_unique<char[]>(size);
84 auto retTableData = typeface1->GetTableData(tag, 0, size, tableData.get());
85 ASSERT_TRUE(retTableData == size);
86 }
87
88 /**
89 * @tc.name: GetItalic001
90 * @tc.desc: Test GetItalic
91 * @tc.type: FUNC
92 * @tc.require:I91EDT
93 */
94 HWTEST_F(SkiaTypefaceTest, GetItalic001, TestSize.Level1)
95 {
96 auto typeface1 = SkiaTypeface::MakeDefault();
97 ASSERT_TRUE(!typeface1->GetItalic());
98 }
99
100 /**
101 * @tc.name: GetUniqueID001
102 * @tc.desc: Test GetUniqueID
103 * @tc.type: FUNC
104 * @tc.require:I91EDT
105 */
106 HWTEST_F(SkiaTypefaceTest, GetUniqueID001, TestSize.Level1)
107 {
108 auto typeface = SkiaTypeface::MakeDefault();
109 ASSERT_TRUE(typeface->GetUniqueID() >= 0);
110 }
111
112 /**
113 * @tc.name: GetUnitsPerEm001
114 * @tc.desc: Test GetUnitsPerEm
115 * @tc.type: FUNC
116 * @tc.require:I91EDT
117 */
118 HWTEST_F(SkiaTypefaceTest, GetUnitsPerEm001, TestSize.Level1)
119 {
120 auto typeface = SkiaTypeface::MakeDefault();
121 ASSERT_TRUE(typeface->GetUnitsPerEm() >= 0);
122 }
123
124 /**
125 * @tc.name: SerializeTypeface001
126 * @tc.desc: Test SerializeTypeface
127 * @tc.type: FUNC
128 * @tc.require:I91EDT
129 */
130 HWTEST_F(SkiaTypefaceTest, SerializeTypeface001, TestSize.Level1)
131 {
132 auto skTypeface = SkTypeface::MakeDefault();
133 ASSERT_TRUE(SkiaTypeface::SerializeTypeface(skTypeface.get(), nullptr) != nullptr);
134 ASSERT_TRUE(SkiaTypeface::SerializeTypeface(nullptr, nullptr) == nullptr);
135 }
136
137 /**
138 * @tc.name: MakeFromName001
139 * @tc.desc: Test MakeFromName
140 * @tc.type: FUNC
141 * @tc.require:I91EDT
142 */
143 HWTEST_F(SkiaTypefaceTest, MakeFromName001, TestSize.Level1)
144 {
145 FontStyle fontStyle;
146 ASSERT_TRUE(SkiaTypeface::MakeFromName("familyName", fontStyle) != nullptr);
147 }
148
149 /**
150 * @tc.name: MakeFromName002
151 * @tc.desc: Test MakeFromName
152 * @tc.type: FUNC
153 * @tc.require:I91EDT
154 */
155 HWTEST_F(SkiaTypefaceTest, MakeFromName002, TestSize.Level1)
156 {
157 FontStyle fontStyle;
158 auto typeface = SkiaTypeface::MakeDefault();
159 ASSERT_TRUE(typeface != nullptr);
160 ASSERT_TRUE(SkiaTypeface::MakeFromName("familyName", fontStyle) != nullptr);
161 }
162
163 /**
164 * @tc.name: MakeFromFile001
165 * @tc.desc: Test MakeFromFile
166 * @tc.type: FUNC
167 * @tc.require:I91EDT
168 */
169 HWTEST_F(SkiaTypefaceTest, MakeFromFile001, TestSize.Level1)
170 {
171 ASSERT_TRUE(SkiaTypeface::MakeFromFile("path", 0) == nullptr);
172 }
173
174 /**
175 * @tc.name: MakeFromFile002
176 * @tc.desc: Test MakeFromFile
177 * @tc.type: FUNC
178 * @tc.require:I91EDT
179 */
180 HWTEST_F(SkiaTypefaceTest, MakeFromFile002, TestSize.Level1)
181 {
182 auto defaultTypeface = SkiaTypeface::MakeDefault();
183 ASSERT_NE(defaultTypeface, nullptr) ;
184 const char validPath[] = "resources/fonts/Em.ttf";
185 auto typefaceInvalidPath = SkiaTypeface::MakeFromFile("invalid/path/to/font.ttf", 0);
186 ASSERT_EQ(typefaceInvalidPath, nullptr);
187 auto typefaceInvalidIndex = SkiaTypeface::MakeFromFile(validPath, 99); // 索引99是一个无效的索引
188 ASSERT_EQ(typefaceInvalidIndex, nullptr);
189 }
190
191 /**
192 * @tc.name: IsCustomTypeface001
193 * @tc.desc: Test IsCustomTypeface
194 * @tc.type: FUNC
195 * @tc.require:I91EDT
196 */
197 HWTEST_F(SkiaTypefaceTest, IsCustomTypeface001, TestSize.Level1)
198 {
199 auto typeface1 = SkiaTypeface::MakeDefault();
200 ASSERT_TRUE(!typeface1->IsCustomTypeface());
201 auto typeface2 = SkiaTypeface(nullptr);
202 ASSERT_TRUE(!typeface2.IsCustomTypeface());
203 }
204
205 /**
206 * @tc.name: GetFamilyName002
207 * @tc.desc: Test GetFamilyName
208 * @tc.type: FUNC
209 * @tc.require:I91EDT
210 */
211 HWTEST_F(SkiaTypefaceTest, GetFamilyName002, TestSize.Level1)
212 {
213 auto typeface = SkiaTypeface::MakeDefault();
214 ASSERT_TRUE(typeface != nullptr);
215 std::string familyNameFromMethod = typeface->GetFamilyName();
216 ASSERT_FALSE(familyNameFromMethod.empty());
217 }
218
219 /**
220 * @tc.name: GetFontStyle002
221 * @tc.desc: Test GetFontStyle
222 * @tc.type: FUNC
223 * @tc.require:I91EDT
224 */
225 HWTEST_F(SkiaTypefaceTest, GetFontStyle002, TestSize.Level1)
226 {
227 FontStyle expectedStyle;
228 auto typeface = SkiaTypeface::MakeDefault();
229 ASSERT_NE(typeface, nullptr);
230 FontStyle fontStyle = typeface->GetFontStyle();
231 EXPECT_EQ(expectedStyle, fontStyle);
232 }
233
234 /**
235 * @tc.name: GetTableSize001
236 * @tc.desc: Test GetTableSize
237 * @tc.type: FUNC
238 * @tc.require:I91EDT
239 */
240 HWTEST_F(SkiaTypefaceTest, GetTableSize001, TestSize.Level1)
241 {
242 auto typeface = std::make_shared<Typeface>(nullptr);
243 auto tag = HB_TAG('n', 'a', 'm', 'e');
244 auto size = typeface->GetTableSize(tag);
245 EXPECT_EQ(size, 0u);
246 }
247
248 /**
249 * @tc.name: GetTableData002
250 * @tc.desc: Test GetTableData
251 * @tc.type: FUNC
252 * @tc.require:I91EDT
253 */
254 HWTEST_F(SkiaTypefaceTest, GetTableData002, TestSize.Level1)
255 {
256 auto typeface = std::make_shared<Typeface>(nullptr);
257 auto tag = HB_TAG('n', 'a', 'm', 'e');
258 auto size = typeface->GetTableSize(tag);
259 std::unique_ptr<char[]> tableData = nullptr;
260 tableData = std::make_unique<char[]>(size);
261 auto retTableData = typeface->GetTableData(tag, 0, size, tableData.get());
262 ASSERT_TRUE(retTableData == size);
263 }
264
265 /**
266 * @tc.name: GetItalic002
267 * @tc.desc: Test GetItalic
268 * @tc.type: FUNC
269 * @tc.require:I91EDT
270 */
271 HWTEST_F(SkiaTypefaceTest, GetItalic002, TestSize.Level1)
272 {
273 auto typeface = SkiaTypeface::MakeDefault();
274 ASSERT_TRUE(typeface != nullptr);
275 ASSERT_TRUE(!typeface->GetItalic());
276 }
277
278 /**
279 * @tc.name: GetUniqueID002
280 * @tc.desc: Test GetUniqueID
281 * @tc.type: FUNC
282 * @tc.require:I91EDT
283 */
284 HWTEST_F(SkiaTypefaceTest, GetUniqueID002, TestSize.Level1)
285 {
286 auto typeface = std::make_shared<SkiaTypeface>(nullptr);
287 ASSERT_TRUE(typeface->GetUniqueID() == 0);
288 }
289
290 /**
291 * @tc.name: GetUnitsPerEm002
292 * @tc.desc: Test GetUnitsPerEm
293 * @tc.type: FUNC
294 * @tc.require:I91EDT
295 */
296 HWTEST_F(SkiaTypefaceTest, GetUnitsPerEm002, TestSize.Level1)
297 {
298 auto typeface = std::make_shared<SkiaTypeface>(nullptr);
299 ASSERT_TRUE(typeface->GetUnitsPerEm() == 0);
300 }
301
302 /**
303 * @tc.name: MakeClone001
304 * @tc.desc: Test MakeClone
305 * @tc.type: FUNC
306 * @tc.require:I91EDT
307 */
308 HWTEST_F(SkiaTypefaceTest, MakeClone001, TestSize.Level1)
309 {
310 auto typeface = SkiaTypeface::MakeDefault();
311 ASSERT_TRUE(typeface != nullptr);
312 FontArguments skArgs;
313 ASSERT_TRUE(typeface->MakeClone(skArgs) != nullptr);
314 }
315
316 /**
317 * @tc.name: GetSkTypeface002
318 * @tc.desc: Test GetSkTypeface
319 * @tc.type: FUNC
320 * @tc.require:I91EDT
321 */
322 HWTEST_F(SkiaTypefaceTest, GetSkTypeface002, TestSize.Level1)
323 {
324 auto typeface = SkTypeface::MakeDefault();
325 auto skiatypeface = SkiaTypeface(typeface);
326 ASSERT_TRUE(typeface != nullptr);
327 ASSERT_TRUE(skiatypeface.GetSkTypeface() != nullptr);
328 }
329
330 /**
331 * @tc.name: MakeDefault001
332 * @tc.desc: Test MakeDefault
333 * @tc.type: FUNC
334 * @tc.require:I91EDT
335 */
336 HWTEST_F(SkiaTypefaceTest, MakeDefault001, TestSize.Level1)
337 {
338 auto typeface = SkiaTypeface::MakeDefault();
339 ASSERT_TRUE(typeface != nullptr);
340 ASSERT_TRUE(SkiaTypeface::MakeDefault() != nullptr);
341 }
342
343 /**
344 * @tc.name: MakeFromStream001
345 * @tc.desc: Test MakeFromStream
346 * @tc.type: FUNC
347 * @tc.require: I91EDT
348 */
349 HWTEST_F(SkiaTypefaceTest, MakeFromStream001, TestSize.Level1)
350 {
351 std::unique_ptr<MemoryStream> memoryStream = std::make_unique<MemoryStream>();
352 uint8_t fontData[] = "Mock font data";
353 size_t fontDataSize = sizeof(fontData);
354 memoryStream = std::make_unique<MemoryStream>(reinterpret_cast<const void*>(fontData), fontDataSize, true);
355 std::shared_ptr<Typeface> typefaceWithData = SkiaTypeface::MakeFromStream(std::move(memoryStream), 0);
356 ASSERT_EQ(typefaceWithData, nullptr);
357 std::shared_ptr<Typeface> typefaceEmptyStream = SkiaTypeface::MakeFromStream(std::make_unique<MemoryStream>(), 0);
358 ASSERT_EQ(typefaceEmptyStream, nullptr);
359 }
360
361 /**
362 * @tc.name: DeserializeTypeface001
363 * @tc.desc: Test DeserializeTypeface
364 * @tc.type: FUNC
365 * @tc.require: I91EDT
366 */
367 HWTEST_F(SkiaTypefaceTest, DeserializeTypeface001, TestSize.Level1)
368 {
369 constexpr size_t SOME_SIZE = 5; // 5 SOME_SIZE
370 const uint8_t validData[SOME_SIZE] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
371 const uint8_t* dataPtr = validData;
372 auto typeface = SkiaTypeface::MakeDefault();
373 ASSERT_NE(typeface, nullptr);
374 ASSERT_TRUE(dataPtr != nullptr);
375 ASSERT_TRUE(
376 SkiaTypeface::DeserializeTypeface(reinterpret_cast<const void*>(validData), SOME_SIZE, nullptr) == nullptr);
377 }
378
379 /**
380 * @tc.name: SerializeTypeface002
381 * @tc.desc: Test SerializeTypeface use case normal situation
382 * @tc.type: FUNC
383 * @tc.require:I91EDT
384 */
385 HWTEST_F(SkiaTypefaceTest, SerializeTypeface002, TestSize.Level1)
386 {
387 auto skTypeface = SkTypeface::MakeDefault();
388 bool isCustomTypeface = true;
389 std::shared_ptr<Drawing::Typeface> typeface = nullptr;
390 TextBlob::Context customContext { typeface, isCustomTypeface };
391 auto serializedData = SkiaTypeface::SerializeTypeface(skTypeface.get(), &customContext);
392 ASSERT_TRUE(serializedData != nullptr);
393 ASSERT_TRUE(customContext.GetTypeface() == nullptr);
394 }
395
396 /**
397 * @tc.name: SerializeTypeface003
398 * @tc.desc: Test SerializeTypeface Case Exception
399 * @tc.type: FUNC
400 * @tc.require:I91EDT
401 */
402 HWTEST_F(SkiaTypefaceTest, SerializeTypeface003, TestSize.Level1)
403 {
404 auto skTypeface = SkTypeface::MakeDefault();
405 bool isCustomTypeface = true;
406 TextBlob::Context customContext { nullptr, isCustomTypeface };
407 auto serializedDataNull = SkiaTypeface::SerializeTypeface(nullptr, &customContext);
408 ASSERT_TRUE(serializedDataNull == nullptr);
409 ASSERT_TRUE(customContext.GetTypeface() == nullptr);
410 }
411
412 /**
413 * @tc.name: Deserialize001
414 * @tc.desc: Test Deserialize
415 * @tc.type: FUNC
416 * @tc.require:I91EDT
417 */
418 HWTEST_F(SkiaTypefaceTest, Deserialize001, TestSize.Level1)
419 {
420 const void* data = reinterpret_cast<const void*>("test_data");
421 size_t dataSize = sizeof(data);
422 auto typeface = SkiaTypeface::MakeDefault();
423 ASSERT_NE(typeface, nullptr);
424 ASSERT_TRUE(SkiaTypeface::Deserialize(data, dataSize) == nullptr);
425 }
426
427 /**
428 * @tc.name: Serialize001
429 * @tc.desc: Test Serialize
430 * @tc.type: FUNC
431 * @tc.require:I91EDT
432 */
433 HWTEST_F(SkiaTypefaceTest, Serialize001, TestSize.Level1)
434 {
435 auto typeface = SkiaTypeface::MakeDefault();
436 ASSERT_NE(typeface, nullptr);
437 ASSERT_TRUE(typeface->Serialize() != nullptr);
438 }
439 } // namespace Drawing
440 } // namespace Rosen
441 } // namespace OHOS