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 <fstream>
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
19
20 #include "font_config.h"
21 #include "font_parser.h"
22 #include "texgine/utils/exlog.h"
23 #include "cmap_table_parser.h"
24 #include "name_table_parser.h"
25 #include "post_table_parser.h"
26 #include "ranges.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Rosen {
33 namespace TextEngine {
34 static const std::string FILE_NAME = "/system/fonts/visibility_list.json";
35
36 class FontParserTest : public testing::Test {
37 };
38
39 class MockCmapTableParser : public CmapTableParser {
40 public:
MockCmapTableParser()41 MockCmapTableParser() {}
42 MOCK_METHOD0(Dump, void());
43 };
44
GetFontSet(const char* fname)45 std::vector<std::string> GetFontSet(const char* fname)
46 {
47 FontConfig fontConfig(fname);
48 return fontConfig.GetFontSet();
49 }
50
ShowVisibilityFonts(std::vector<FontParser::FontDescriptor>& visibilityFonts)51 void ShowVisibilityFonts(std::vector<FontParser::FontDescriptor>& visibilityFonts)
52 {
53 for (auto &it : visibilityFonts) {
54 LOGSO_FUNC_LINE(INFO) << "\n fontFamily: " << it.fontFamily
55 << "\n fontSubfamily: " << it.fontSubfamily
56 << "\n fullName: " << it.fullName
57 << "\n italic: " << it.italic
58 << "\n monoSpace: " << it.monoSpace
59 << "\n path: " << it.path
60 << "\n postScriptName: " << it.postScriptName
61 << "\n symbolic: " << it.symbolic
62 << "\n weight: " << it.weight
63 << "\n width: " << it.width;
64 }
65 }
66
67 /**
68 * @tc.name: FontParserTest1
69 * @tc.desc: test get fontSet file parser
70 * @tc.type:FUNC
71 */
HWTEST_F(FontParserTest, FontParserTest1, TestSize.Level1)72 HWTEST_F(FontParserTest, FontParserTest1, TestSize.Level1)
73 {
74 auto fontSet1 = GetFontSet(nullptr);
75 EXPECT_EQ(fontSet1.size(), 0);
76
77 std::ifstream fileStream(FILE_NAME.c_str());
78 if (fileStream.is_open()) {
79 auto fontSet2 = GetFontSet(FILE_NAME.c_str());
80 EXPECT_NE(fontSet2.size(), 0);
81 fileStream.close();
82 } else {
83 auto fontSet2 = GetFontSet(FILE_NAME.c_str());
84 EXPECT_EQ(fontSet2.size(), 0);
85 }
86 }
87
88 /**
89 * @tc.name: FontParserTest2
90 * @tc.desc: test font file parser
91 * @tc.type:FUNC
92 */
HWTEST_F(FontParserTest, FontParserTest2, TestSize.Level1)93 HWTEST_F(FontParserTest, FontParserTest2, TestSize.Level1)
94 {
95 FontParser fontParser;
96 auto visibilityFonts = fontParser.GetVisibilityFonts();
97 fontParser.GetVisibilityFontByName("Noto Sans Regular");
98 std::ifstream fileStream(FILE_NAME.c_str());
99 if (fileStream.is_open()) {
100 EXPECT_NE(visibilityFonts.size(), 0);
101 ShowVisibilityFonts(visibilityFonts);
102 fileStream.close();
103 } else {
104 EXPECT_EQ(visibilityFonts.size(), 0);
105 }
106 }
107
108 /**
109 * @tc.name: FontParserTest3
110 * @tc.desc: test font file parser
111 * @tc.type:FUNC
112 */
HWTEST_F(FontParserTest, FontParserTest3, TestSize.Level1)113 HWTEST_F(FontParserTest, FontParserTest3, TestSize.Level1)
114 {
115 FontParser fontParser;
116 std::unique_ptr<FontParser::FontDescriptor> font =
117 fontParser.GetVisibilityFontByName("Noto Sans Regular");
118 EXPECT_EQ(font->fontFamily, "Noto Sans");
119 }
120
121 /**
122 * @tc.name: FontConfigTest1
123 * @tc.desc: test font file parser
124 * @tc.type:FUNC
125 */
HWTEST_F(FontParserTest, FontConfigTest1, TestSize.Level1)126 HWTEST_F(FontParserTest, FontConfigTest1, TestSize.Level1)
127 {
128 FontConfigJson fontConfigJson;
129 EXPECT_EQ(fontConfigJson.ParseFile(), 0);
130 auto info = fontConfigJson.GetFontConfigJsonInfo();
131 EXPECT_EQ(info->fontDirSet.size(), 1);
132 fontConfigJson.Dump();
133 }
134
135 /**
136 * @tc.name: FontConfigTest2
137 * @tc.desc: test font file parser
138 * @tc.type:FUNC
139 */
HWTEST_F(FontParserTest, FontConfigTest2, TestSize.Level1)140 HWTEST_F(FontParserTest, FontConfigTest2, TestSize.Level1)
141 {
142 FontConfigJson fontConfigJson;
143 EXPECT_EQ(fontConfigJson.ParseFontFileMap(), 0);
144 auto map = fontConfigJson.GetFontFileMap();
145 EXPECT_EQ(map->size(), 261);
146 for (auto& it: *map) {
147 ASSERT_GT(it.second.size(), 3);
148 std::string end = it.second.substr(it.second.size() - 3, 3);
149 EXPECT_TRUE(end == "ttf" || end == "oft" || end == "ttc");
150 }
151 fontConfigJson.Dump();
152 }
153
154 /**
155 * @tc.name: CmapTableParserTest1
156 * @tc.desc: opentype parser test
157 * @tc.type:FUNC
158 */
HWTEST_F(FontParserTest, CmapTableParserTest1, TestSize.Level1)159 HWTEST_F(FontParserTest, CmapTableParserTest1, TestSize.Level1)
160 {
161 MockCmapTableParser mockCmapTableParser;
162 CmapTableParser cmapTableParser_default;
163 CmapTableParser cmapTableParser("test data", 9);
164 struct NameRecord nameRecord;
165 struct NameTable nameTable;
166 nameRecord.encodingId = nameTable.count;
167 EXPECT_EQ(CmapTableParser::Parse(nullptr, 0), nullptr);
168 EXPECT_CALL(mockCmapTableParser, Dump()).Times(1);
169 mockCmapTableParser.Dump();
170 }
171
172 /**
173 * @tc.name: NameTableParserTest1
174 * @tc.desc: opentype parser test
175 * @tc.type:FUNC
176 */
HWTEST_F(FontParserTest, NameTableParserTest1, TestSize.Level1)177 HWTEST_F(FontParserTest, NameTableParserTest1, TestSize.Level1)
178 {
179 NameTableParser nameTableParser(nullptr, 0);
180 struct NameRecord nameRecord;
181 struct NameTable nameTable;
182 nameRecord.encodingId = nameTable.count;
183 EXPECT_EQ(NameTableParser::Parse(nullptr, 0), nullptr);
184 nameTableParser.Dump();
185 }
186
187 /**
188 * @tc.name: NameTableParserTest2
189 * @tc.desc: opentype parser test
190 * @tc.type:FUNC
191 */
HWTEST_F(FontParserTest, NameTableParserTest2, TestSize.Level1)192 HWTEST_F(FontParserTest, NameTableParserTest2, TestSize.Level1)
193 {
194 auto typeface = Drawing::Typeface::MakeDefault();
195 ASSERT_NE(typeface, nullptr);
196 auto tag = HB_TAG('n', 'a', 'm', 'e');
197 auto size = typeface->GetTableSize(tag);
198 ASSERT_GT(size, 0);
199 std::unique_ptr<char[]> tableData = nullptr;
200 tableData = std::make_unique<char[]>(size);
201 auto retTableData = typeface->GetTableData(tag, 0, size, tableData.get());
202 ASSERT_EQ(size, retTableData);
203 hb_blob_t* hblob = nullptr;
204 hblob = hb_blob_create(
205 reinterpret_cast<const char *>(tableData.get()), size, HB_MEMORY_MODE_WRITABLE, tableData.get(), nullptr);
206 ASSERT_NE(hblob, nullptr);
207 const char* data_ = nullptr;
208 unsigned int length_ = 0;
209 data_ = hb_blob_get_data(hblob, nullptr);
210 length_ = hb_blob_get_length(hblob);
211 auto parseName = std::make_shared<NameTableParser>(data_, length_);
212 auto nameTable = parseName->Parse(data_, length_);
213 parseName->Dump();
214 hb_blob_destroy(hblob);
215 EXPECT_NE(nameTable, nullptr);
216 }
217
218 /**
219 * @tc.name: PostTableParserTest1
220 * @tc.desc: opentype parser test
221 * @tc.type:FUNC
222 */
HWTEST_F(FontParserTest, PostTableParserTest1, TestSize.Level1)223 HWTEST_F(FontParserTest, PostTableParserTest1, TestSize.Level1)
224 {
225 PostTable postTable;
226 PostTableParser postTableParser(reinterpret_cast<char*>(&postTable), sizeof(postTable));
227 const PostTable* res = postTableParser.Parse(reinterpret_cast<char*>(&postTable), sizeof(postTable));
228 EXPECT_EQ(res->version.Get(), postTable.version.Get());
229 EXPECT_EQ(res->italicAngle.Get(), postTable.italicAngle.Get());
230 EXPECT_EQ(res->underlinePosition.Get(), postTable.underlinePosition.Get());
231 EXPECT_EQ(res->underlineThickness.Get(), postTable.underlineThickness.Get());
232 EXPECT_EQ(res->isFixedPitch.Get(), postTable.isFixedPitch.Get());
233 EXPECT_EQ(res->minMemType42.Get(), postTable.minMemType42.Get());
234 EXPECT_EQ(res->maxMemType42.Get(), postTable.maxMemType42.Get());
235 EXPECT_EQ(res->minMemType1.Get(), postTable.minMemType1.Get());
236 postTableParser.Dump();
237 }
238
239 /**
240 * @tc.name: OpenTypeBasicTypeTest1
241 * @tc.desc: opentype parser test
242 * @tc.type:FUNC
243 */
HWTEST_F(FontParserTest, OpenTypeBasicTypeTest1, TestSize.Level1)244 HWTEST_F(FontParserTest, OpenTypeBasicTypeTest1, TestSize.Level1)
245 {
246 char test[] = {'a', 'b', 'c', 'd', 0};
247 struct OpenTypeBasicType::Tag tag;
248 EXPECT_EQ(tag.Get(), "\0\0\0\0");
249 struct OpenTypeBasicType::Int16 int16;
250 EXPECT_EQ(int16.Get(), 0);
251 struct OpenTypeBasicType::Uint16 uint16;
252 EXPECT_EQ(uint16.Get(), 0);
253 struct OpenTypeBasicType::Int32 int32;
254 EXPECT_EQ(int32.Get(), 0);
255 struct OpenTypeBasicType::Uint32 uint32;
256 EXPECT_EQ(uint32.Get(), 0);
257 struct OpenTypeBasicType::Fixed fixed;
258 EXPECT_EQ(fixed.Get(), 0);
259 std::copy(std::begin(test), std::end(test), std::begin(tag.tags));
260 EXPECT_EQ(tag.Get(), test);
261 }
262
263 /**
264 * @tc.name: RangesTest1
265 * @tc.desc: opentype parser test
266 * @tc.type:FUNC
267 */
HWTEST_F(FontParserTest, RangesTest1, TestSize.Level1)268 HWTEST_F(FontParserTest, RangesTest1, TestSize.Level1)
269 {
270 Ranges ranges;
271 struct Ranges::Range range = { 0, 2, 1 };
272 ranges.AddRange(range);
273 struct Ranges::Range range2 = { 4, 5, 2 };
274 ranges.AddRange(range2);
275 EXPECT_EQ(ranges.GetGlyphId(3), Ranges::INVALID_GLYPH_ID);
276 EXPECT_EQ(ranges.GetGlyphId(0), 1);
277 EXPECT_EQ(ranges.GetGlyphId(4), 6);
278 ranges.Dump();
279 }
280 } // namespace TextEngine
281 } // namespace Rosen
282 } // namespace OHOS
283