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