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 <fstream>
17 #include <gtest/gtest.h>
18 
19 #include "font_descriptor_cache.h"
20 
21 using namespace testing;
22 using namespace testing::ext;
23 
24 namespace OHOS {
25 namespace Rosen {
26 static const std::string FILE_NAME = "/data/service/el1/public/for-all-app/fonts/install_fontconfig.json";
27 static const std::string FILE_NAME_PATH = "/system/fonts/hm_symbol_config.json";
28 static const std::string EFFECTIVE_FILE_NAME = "/system/fonts/HarmonyOS_Sans.ttf";
29 constexpr uint32_t WEIGHT_500 = 500;
30 
31 class FontDescriptorTest : public testing::Test {};
32 
33 /**
34  * @tc.name: ClearFontFileCacheTest
35  * @tc.desc: test the ClearFontFileCache function
36  * @tc.type: FUNC
37  */
38 HWTEST_F(FontDescriptorTest, ClearFontFileCacheTest, TestSize.Level1)
39 {
40     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
41     fontDescriptorCache->ClearFontFileCache();
42     EXPECT_NE(fontDescriptorCache, nullptr);
43 }
44 
45 /**
46  * @tc.name: ParserStylishFontsTest
47  * @tc.desc: test the ParserStylishFonts function
48  * @tc.type: FUNC
49  */
50 HWTEST_F(FontDescriptorTest, ParserStylishFontsTest, TestSize.Level1)
51 {
52     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
53     TextEngine::FontParser::FontDescriptor descriptor;
54     descriptor.fullName = "test";
55     fontDescriptorCache->parser_.visibilityFonts_.push_back(descriptor);
56     EXPECT_NE(fontDescriptorCache->parser_.visibilityFonts_.size(), 0);
57     fontDescriptorCache->ParserStylishFonts();
58 }
59 
60 /**
61  * @tc.name: FontDescriptorScatterTest
62  * @tc.desc: test the FontDescriptorScatter function
63  * @tc.type: FUNC
64  */
65 HWTEST_F(FontDescriptorTest, FontDescriptorScatterTest, TestSize.Level1)
66 {
67     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
68     FontDescSharedPtr desc = std::make_shared<TextEngine::FontParser::FontDescriptor>();
69     desc->symbolic = false;
70     fontDescriptorCache->FontDescriptorScatter(desc);
71     EXPECT_EQ(desc->symbolic, false);
72     desc->symbolic = true;
73     fontDescriptorCache->FontDescriptorScatter(desc);
74     EXPECT_NE(fontDescriptorCache, nullptr);
75 }
76 
77 /**
78  * @tc.name: MatchFromFontDescriptorAndIsDefaultTest
79  * @tc.desc: test the MatchFromFontDescriptor and IsDefault function
80  * @tc.type: FUNC
81  */
82 HWTEST_F(FontDescriptorTest, MatchFromFontDescriptorTest, TestSize.Level1)
83 {
84     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
85     EXPECT_NE(fontDescriptorCache, nullptr);
86 
87     FontDescSharedPtr desc = nullptr;
88     std::set<FontDescSharedPtr> result;
89     fontDescriptorCache->MatchFromFontDescriptor(desc, result);
90 
91     desc = std::make_shared<TextEngine::FontParser::FontDescriptor>();
92     EXPECT_NE(desc, nullptr);
93 
94     EXPECT_TRUE(fontDescriptorCache->IsDefault(desc));
95 
96     desc->fontFamily = "IsDefaultFamily";
97     desc->fullName = "IsDefaultName";
98     desc->postScriptName = "IsDefaultName";
99     desc->fontSubfamily = "IsDefaultFamily";
100     desc->weight = 1;
101     desc->width = 1;
102     desc->italic = 1;
103     desc->monoSpace = true;
104     desc->symbolic = true;
105     EXPECT_FALSE(fontDescriptorCache->IsDefault(desc));
106 }
107 
108 /**
109  * @tc.name: FontDescriptorCacheFilterTest
110  * @tc.desc: test the FontDescriptorCacheFilter function
111  * @tc.type: FUNC
112  */
113 HWTEST_F(FontDescriptorTest, FontDescriptorCacheFilterTest, TestSize.Level1)
114 {
115     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
116     EXPECT_NE(fontDescriptorCache, nullptr);
117 
118     std::set<FontDescSharedPtr> finishRet;
119     EXPECT_TRUE(fontDescriptorCache->FilterSymbolicCache(false, finishRet));
120     EXPECT_TRUE(fontDescriptorCache->FilterMonoSpaceCache(false, finishRet));
121     EXPECT_TRUE(fontDescriptorCache->FilterItalicCache(0, finishRet));
122     EXPECT_FALSE(fontDescriptorCache->FilterWidthCache(-1, finishRet));
123     EXPECT_TRUE(fontDescriptorCache->FilterWidthCache(0, finishRet));
124     EXPECT_FALSE(fontDescriptorCache->FilterBoldCache(-1, finishRet));
125     EXPECT_TRUE(fontDescriptorCache->FilterBoldCache(0, finishRet));
126 
127     FontDescSharedPtr finish = std::make_shared<TextEngine::FontParser::FontDescriptor>();
128     EXPECT_NE(finish, nullptr);
129     finish->weight = 1;
130     finishRet.emplace(finish);
131     EXPECT_TRUE(fontDescriptorCache->FilterBoldCache(1, finishRet));
132 }
133 
134 /**
135  * @tc.name: GetSystemFontFullNamesByTypeTest
136  * @tc.desc: test the GetSystemFontFullNamesByType function
137  * @tc.type: FUNC
138  */
139 HWTEST_F(FontDescriptorTest, GetSystemFontFullNamesByTypeTest, TestSize.Level1)
140 {
141     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
142     EXPECT_NE(fontDescriptorCache, nullptr);
143 
144     std::string fullName = "GetSystemFontFullNamesByTypeTests";
145     std::unordered_set<std::string> fontLis;
146     fontLis.emplace(fullName);
147     fontDescriptorCache->GetSystemFontFullNamesByType(16, fontLis);
148     EXPECT_EQ(fontLis.size(), 0);
149 }
150 
151 /**
152  * @tc.name: HandleMapIntersectionTest
153  * @tc.desc: test the HandleMapIntersection function
154  * @tc.type: FUNC
155  */
156 HWTEST_F(FontDescriptorTest, HandleMapIntersectionTest, TestSize.Level1)
157 {
158     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
159     EXPECT_NE(fontDescriptorCache, nullptr);
160 
161     std::set<FontDescSharedPtr> finishRet;
162     std::string name = "";
163     std::unordered_map<std::string, std::set<FontDescSharedPtr>> map;
164     EXPECT_TRUE(fontDescriptorCache->HandleMapIntersection(finishRet, name, map));
165 
166     FontDescSharedPtr finish = std::make_shared<TextEngine::FontParser::FontDescriptor>();
167     EXPECT_NE(finish, nullptr);
168     finish->weight = 1;
169     finishRet.emplace(finish);
170     name = "test";
171     std::string nameMap = "HandleMapIntersectionTest";
172     map[nameMap] = finishRet;
173     EXPECT_FALSE(fontDescriptorCache->HandleMapIntersection(finishRet, name, map));
174 
175     FontDescSharedPtr finishTest = std::make_shared<TextEngine::FontParser::FontDescriptor>();
176     EXPECT_NE(finishTest, nullptr);
177     finishTest->fullName = "test";
178     finishRet.emplace(finishTest);
179     name = "HandleMapIntersectionTest";
180     EXPECT_TRUE(fontDescriptorCache->HandleMapIntersection(finishRet, name, map));
181 
182     finishRet.clear();
183     finishRet.emplace(finish);
184     EXPECT_TRUE(fontDescriptorCache->HandleMapIntersection(finishRet, name, map));
185 }
186 
187 /**
188  * @tc.name: GetFontDescSharedPtrByFullNameTest
189  * @tc.desc: test the GetFontDescSharedPtrByFullName function
190  * @tc.type: FUNC
191  */
192 HWTEST_F(FontDescriptorTest, GetFontDescSharedPtrByFullNameTest, TestSize.Level1)
193 {
194     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
195     EXPECT_NE(fontDescriptorCache, nullptr);
196 
197     FontDescSharedPtr result = nullptr;
198     std::string fullName = "";
199     int32_t systemFontType = 16;
200     fontDescriptorCache->GetFontDescSharedPtrByFullName(fullName, systemFontType, result);
201 
202     fullName = "HandleMapIntersectionTest";
203     fontDescriptorCache->GetFontDescSharedPtrByFullName(fullName, systemFontType, result);
204 
205     FontDescSharedPtr fontDescSharedPtr = std::make_shared<TextEngine::FontParser::FontDescriptor>();
206     EXPECT_NE(fontDescSharedPtr, nullptr);
207     std::set<FontDescSharedPtr> fontDescSet;
208     fontDescSet.emplace(fontDescSharedPtr);
209     fontDescriptorCache->fullNameMap_.emplace(fullName, fontDescSet);
210     systemFontType = 14;
211     fontDescriptorCache->GetFontDescSharedPtrByFullName(fullName, systemFontType, result);
212     EXPECT_TRUE(result != nullptr);
213 
214     fontDescriptorCache->fullNameMap_.clear();
215     fontDescriptorCache->GetFontDescSharedPtrByFullName(fullName, systemFontType, result);
216     EXPECT_TRUE(result == nullptr);
217 
218     fontDescriptorCache->stylishFullNameMap_.emplace("HandleMapIntersectionTest", fontDescSet);
219     fontDescriptorCache->GetFontDescSharedPtrByFullName(fullName, systemFontType, result);
220     EXPECT_TRUE(result != nullptr);
221 
222     fontDescriptorCache->stylishFullNameMap_.clear();
223     fontDescriptorCache->GetFontDescSharedPtrByFullName(fullName, systemFontType, result);
224     EXPECT_TRUE(result == nullptr);
225 }
226 
227 /**
228  * @tc.name: FilterSymbolicCacheTest
229  * @tc.desc: test the FilterSymbolicCache function
230  * @tc.type: FUNC
231  */
232 HWTEST_F(FontDescriptorTest, FilterSymbolicCacheTest, TestSize.Level1)
233 {
234     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
235     EXPECT_NE(fontDescriptorCache, nullptr);
236     bool symbolic = false;
237     std::set<FontDescSharedPtr> finishRet;
238     bool res = fontDescriptorCache->FilterSymbolicCache(symbolic, finishRet);
239     EXPECT_EQ(res, true);
240     symbolic = true;
241     fontDescriptorCache->symbolicCache_.clear();
242     res = fontDescriptorCache->FilterSymbolicCache(symbolic, finishRet);
243     EXPECT_EQ(res, false);
244     FontDescSharedPtr desc = std::make_shared<TextEngine::FontParser::FontDescriptor>();
245     desc->symbolic = false;
246     finishRet.insert(desc);
247     res = fontDescriptorCache->FilterSymbolicCache(symbolic, finishRet);
248     EXPECT_EQ(res, false);
249     FontDescSharedPtr descPtr = std::make_shared<TextEngine::FontParser::FontDescriptor>();
250     descPtr->symbolic = true;
251     finishRet.insert(descPtr);
252     res = fontDescriptorCache->FilterSymbolicCache(symbolic, finishRet);
253     EXPECT_EQ(res, true);
254     fontDescriptorCache->MatchFromFontDescriptor(desc, finishRet);
255 }
256 
257 /**
258  * @tc.name: FilterMonoSpaceCacheTest
259  * @tc.desc: test the FilterMonoSpaceCache function
260  * @tc.type: FUNC
261  */
262 HWTEST_F(FontDescriptorTest, FilterMonoSpaceCacheTest, TestSize.Level1)
263 {
264     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
265     EXPECT_NE(fontDescriptorCache, nullptr);
266     bool monoSpace = false;
267     std::set<FontDescSharedPtr> finishRet;
268     bool res = fontDescriptorCache->FilterMonoSpaceCache(monoSpace, finishRet);
269     EXPECT_EQ(res, true);
270     monoSpace = true;
271     fontDescriptorCache->monoSpaceCache_.clear();
272     res = fontDescriptorCache->FilterMonoSpaceCache(monoSpace, finishRet);
273     EXPECT_EQ(res, false);
274     FontDescSharedPtr desc = std::make_shared<TextEngine::FontParser::FontDescriptor>();
275     desc->monoSpace = false;
276     finishRet.insert(desc);
277     res = fontDescriptorCache->FilterMonoSpaceCache(monoSpace, finishRet);
278     EXPECT_EQ(res, false);
279     FontDescSharedPtr descPtr = std::make_shared<TextEngine::FontParser::FontDescriptor>();
280     descPtr->monoSpace = true;
281     finishRet.insert(descPtr);
282     res = fontDescriptorCache->FilterMonoSpaceCache(monoSpace, finishRet);
283     EXPECT_EQ(res, true);
284 }
285 
286 /**
287  * @tc.name: FilterItalicCacheTest
288  * @tc.desc: test the FilterItalicCache function
289  * @tc.type: FUNC
290  */
291 HWTEST_F(FontDescriptorTest, FilterItalicCacheTest, TestSize.Level1)
292 {
293     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
294     EXPECT_NE(fontDescriptorCache, nullptr);
295     int italic = 0;
296     std::set<FontDescSharedPtr> finishRet;
297     bool res = fontDescriptorCache->FilterItalicCache(italic, finishRet);
298     EXPECT_EQ(res, true);
299     italic = 1;
300     fontDescriptorCache->italicCache_.clear();
301     res = fontDescriptorCache->FilterItalicCache(italic, finishRet);
302     EXPECT_EQ(res, false);
303     FontDescSharedPtr desc = std::make_shared<TextEngine::FontParser::FontDescriptor>();
304     desc->italic = 0;
305     finishRet.insert(desc);
306     res = fontDescriptorCache->FilterItalicCache(italic, finishRet);
307     EXPECT_EQ(res, false);
308     FontDescSharedPtr descPtr = std::make_shared<TextEngine::FontParser::FontDescriptor>();
309     descPtr->italic = 1;
310     finishRet.insert(descPtr);
311     res = fontDescriptorCache->FilterItalicCache(italic, finishRet);
312     EXPECT_EQ(res, true);
313 }
314 
315 /**
316  * @tc.name: FilterWidthCacheTest
317  * @tc.desc: test the FilterWidthCache function
318  * @tc.type: FUNC
319  */
320 HWTEST_F(FontDescriptorTest, FilterWidthCacheTest, TestSize.Level1)
321 {
322     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
323     EXPECT_NE(fontDescriptorCache, nullptr);
324     int width = 0;
325     std::set<FontDescSharedPtr> finishRet;
326     bool res = fontDescriptorCache->FilterWidthCache(width, finishRet);
327     EXPECT_EQ(res, true);
328     width = -1;
329     res = fontDescriptorCache->FilterWidthCache(width, finishRet);
330     EXPECT_EQ(res, false);
331     width = 1;
332     FontDescSharedPtr desc = std::make_shared<TextEngine::FontParser::FontDescriptor>();
333     desc->width = 0;
334     fontDescriptorCache->allFontDescriptor_.insert(desc);
335     res = fontDescriptorCache->FilterWidthCache(width, finishRet);
336     EXPECT_EQ(res, false);
337     desc->width = 1;
338     FontDescSharedPtr descPtr = std::make_shared<TextEngine::FontParser::FontDescriptor>();
339     descPtr->width = 1;
340     fontDescriptorCache->allFontDescriptor_.insert(descPtr);
341     res = fontDescriptorCache->FilterWidthCache(width, finishRet);
342     EXPECT_EQ(res, true);
343     finishRet.insert(descPtr);
344     res = fontDescriptorCache->FilterWidthCache(width, finishRet);
345     EXPECT_EQ(res, true);
346 }
347 
348 /**
349  * @tc.name: FilterBoldCacheTest
350  * @tc.desc: test the FilterBoldCache function
351  * @tc.type: FUNC
352  */
353 HWTEST_F(FontDescriptorTest, FilterBoldCacheTest, TestSize.Level1)
354 {
355     auto fontDescriptorCache = std::make_shared<FontDescriptorCache>();
356     EXPECT_NE(fontDescriptorCache, nullptr);
357     int weight = 0;
358     std::set<FontDescSharedPtr> finishRet;
359     bool res = fontDescriptorCache->FilterBoldCache(weight, finishRet);
360     EXPECT_EQ(res, true);
361     weight = -1;
362     res = fontDescriptorCache->FilterBoldCache(weight, finishRet);
363     EXPECT_EQ(res, false);
364     weight = 1;
365     FontDescSharedPtr desc = std::make_shared<TextEngine::FontParser::FontDescriptor>();
366     desc->weight = 0;
367     fontDescriptorCache->allFontDescriptor_.insert(desc);
368     res = fontDescriptorCache->FilterBoldCache(weight, finishRet);
369     EXPECT_EQ(res, false);
370     FontDescSharedPtr descPtr = std::make_shared<TextEngine::FontParser::FontDescriptor>();
371     descPtr->weight = 1;
372     fontDescriptorCache->allFontDescriptor_.insert(descPtr);
373     res = fontDescriptorCache->FilterBoldCache(weight, finishRet);
374     EXPECT_EQ(res, false);
375     weight = WEIGHT_500;
376     res = fontDescriptorCache->FilterBoldCache(weight, finishRet);
377     EXPECT_EQ(res, false);
378     finishRet.insert(desc);
379     res = fontDescriptorCache->FilterBoldCache(weight, finishRet);
380     EXPECT_EQ(res, false);
381 }
382 } // namespace Rosen
383 } // namespace OHOS
384