1 /*
2  * Copyright (c) 2023-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 "common/spannable_string.h"
17 #include "font/ui_font_header.h"
18 #include "gfx_utils/color.h"
19 #include "gfx_utils/list.h"
20 #include "securec.h"
21 
22 #include <climits>
23 #include <gtest/gtest.h>
24 #if defined(ENABLE_SPANNABLE_STRING) && ENABLE_SPANNABLE_STRING
25 
26 using namespace testing::ext;
27 namespace OHOS {
28 class SP_test : public SpannableString {
29 public:
GetSpanListSize()30     uint16_t GetSpanListSize()
31     {
32         return spanList_.Size();
33     }
GetSizeListSize()34     uint16_t GetSizeListSize()
35     {
36         return sizeList_.Size();
37     }
GetFontIdListSize()38     uint16_t GetFontIdListSize()
39     {
40         return fontIdList_.Size();
41     }
GetHeightListSize()42     uint16_t GetHeightListSize()
43     {
44         return heightList_.Size();
45     }
GetIsSpannableLen()46     uint16_t GetIsSpannableLen()
47     {
48         return isSpannableLen_;
49     }
SetSpannable(bool value,uint16_t startIndex,uint16_t endIndex)50     bool SetSpannable(bool value, uint16_t startIndex, uint16_t endIndex)
51     {
52         return SpannableString::SetSpannable(value, startIndex, endIndex);
53     }
SetFontHeight(int16_t inputHeight,uint16_t startIndex,uint16_t endIndex)54     void SetFontHeight(int16_t inputHeight, uint16_t startIndex, uint16_t endIndex)
55     {
56         return SpannableString::SetFontHeight(inputHeight, startIndex, endIndex);
57     }
58 };
59 
60 class SpannableStringTest : public testing::Test {
61 public:
SpannableStringTest()62     SpannableStringTest() : spannableString_(nullptr) {}
~SpannableStringTest()63     virtual ~SpannableStringTest() {}
SetUpTestCase()64     static void SetUpTestCase() {}
TearDownTestCase()65     static void TearDownTestCase() {}
66     void SetUp();
67     void TearDown();
68     SP_test *spannableString_;
69 };
70 
SetUp()71 void SpannableStringTest::SetUp()
72 {
73     if (spannableString_ == nullptr) {
74         spannableString_ = new SP_test();
75     }
76 }
77 
TearDown()78 void SpannableStringTest::TearDown()
79 {
80     if (spannableString_ != nullptr) {
81         delete spannableString_;
82         spannableString_ = nullptr;
83     }
84 }
85 
86 /**
87  * @tc.name: SpannableString_SpannableString_001
88  * @tc.desc: Verify SpannableString function, each attribute shall be  0 or nullptr, equal.
89  * @tc.type: FUNC
90  */
91 HWTEST_F(SpannableStringTest, SpannableString_SpannableString_001, TestSize.Level1)
92 {
93     if (spannableString_ == nullptr) {
94         EXPECT_NE(spannableString_, nullptr);
95         return;
96     }
97     EXPECT_EQ(spannableString_->GetSpanListSize(), 0);
98     EXPECT_EQ(spannableString_->GetIsSpannableLen(), 0);
99     EXPECT_EQ(spannableString_->GetSizeListSize(), 0);
100     EXPECT_EQ(spannableString_->GetFontIdListSize(), 0);
101     EXPECT_EQ(spannableString_->GetHeightListSize(), 0);
102 }
103 
104 /**
105  * @tc.name: SpannableString_SetSpannable_001
106  * @tc.desc: Verify SetSpannable function, capability, equal.
107  * @tc.type: FUNC
108  */
109 HWTEST_F(SpannableStringTest, SpannableString_SetSpannable_001, TestSize.Level1)
110 {
111     if (spannableString_ == nullptr) {
112         EXPECT_NE(spannableString_, nullptr);
113         return;
114     }
115     uint16_t default_is_spannable_len = 10; // default_is_spannable_len is 10
116     uint16_t start_1 = 2;
117     uint16_t end_1 = 5;
118     spannableString_->SetSpannable(true, start_1, end_1);
119     EXPECT_EQ(spannableString_->GetSpannableLen(), default_is_spannable_len);
120     for (uint16_t i = 0; i < start_1; i++) {
121         EXPECT_EQ(spannableString_->GetSpannable(i), false);
122     }
123     for (uint16_t i = start_1; i < end_1; i++) {
124         EXPECT_EQ(spannableString_->GetSpannable(i), true);
125     }
126     for (uint16_t i = end_1; i < default_is_spannable_len; i++) {
127         EXPECT_EQ(spannableString_->GetSpannable(i), false);
128     }
129 }
130 
131 /**
132  * @tc.name: SpannableString_SetSpannable_002
133  * @tc.desc: Verify SetSpannable function, out-of-bound, equal.
134  * @tc.type: FUNC
135  */
136 HWTEST_F(SpannableStringTest, SpannableString_SetSpannable_002, TestSize.Level1)
137 {
138     uint16_t default_is_spannable_len = 10;
139     uint16_t start = 9;
140     uint16_t end = 12;
141     spannableString_->SetSpannable(true, start, end);
142     EXPECT_EQ(default_is_spannable_len * 2 + 1, spannableString_->GetIsSpannableLen());
143     if ((default_is_spannable_len * 2 + 1) == spannableString_->GetIsSpannableLen()) {
144         for (uint16_t i = 0; i < start; i++) {
145             EXPECT_EQ(spannableString_->GetSpannable(i), false);
146         }
147         for (uint16_t i = start; i < end; i++) {
148             EXPECT_EQ(spannableString_->GetSpannable(i), true);
149         }
150         for (uint16_t i = end; i < (default_is_spannable_len * 2 + 1); i++) {
151             EXPECT_EQ(spannableString_->GetSpannable(i), true);
152         }
153     }
154 }
155 
156 /**
157  * @tc.name: SpannableString_SetSpannable_002
158  * @tc.desc: Verify SetSpannable function, out-of-bound, equal.
159  * @tc.type: FUNC
160  */
161 HWTEST_F(SpannableStringTest, SpannableString_SetSpannable_003, TestSize.Level1)
162 {
163     uint16_t default_is_spannable_len = 10;
164     uint16_t start = 0;
165     uint16_t end = 10;
166     spannableString_->SetSpannable(true, start, end);
167     EXPECT_EQ(default_is_spannable_len, spannableString_->GetIsSpannableLen());
168     if (default_is_spannable_len == spannableString_->GetIsSpannableLen()) {
169         for (uint16_t i = 0; i < start; i++) {
170             EXPECT_EQ(spannableString_->GetSpannable(i), false);
171         }
172         for (uint16_t i = start; i < default_is_spannable_len; i++) {
173             EXPECT_EQ(spannableString_->GetSpannable(i), true);
174         }
175     }
176 }
177 
178 /**
179  * @tc.name: SpannableString_SetSpannable_004
180  * @tc.desc: Verify SetSpannable function, out-of-bound, equal.
181  * @tc.type: FUNC
182  */
183 HWTEST_F(SpannableStringTest, SpannableString_SetSpannable_004, TestSize.Level1)
184 {
185     uint16_t default_is_spannable_len = 10;
186     uint16_t start = 0;
187     uint16_t end = 0;
188     spannableString_->SetSpannable(true, start, end);
189 
190     // since (0<0)!=true, isSpannableLen is still 0.
191     EXPECT_EQ(0, spannableString_->GetIsSpannableLen());
192 }
193 
194 /**
195  * @tc.name: SpannableString_SetSpannable_005
196  * @tc.desc: Verify SetSpannable function, out-of-bound, equal.
197  * @tc.type: FUNC
198  */
199 HWTEST_F(SpannableStringTest, SpannableString_SetSpannable_005, TestSize.Level1)
200 {
201     uint16_t default_is_spannable_len = 10;
202     uint16_t start = 10;
203     uint16_t end = 10;
204     spannableString_->SetSpannable(true, start, end);
205     EXPECT_EQ(default_is_spannable_len, spannableString_->GetIsSpannableLen());
206     if (default_is_spannable_len == spannableString_->GetIsSpannableLen()) {
207         for (uint16_t i = 0; i < start; i++) {
208             EXPECT_EQ(spannableString_->GetSpannable(i), false);
209         }
210     }
211 }
212 
213 /**
214  * @tc.name: SpannableString_SetSpannable_006
215  * @tc.desc: Verify SetSpannable function, out-of-bound, equal.
216  * @tc.type: FUNC
217  */
218 HWTEST_F(SpannableStringTest, SpannableString_SetSpannable_006, TestSize.Level1)
219 {
220     uint16_t default_is_spannable_len = 10;
221     uint16_t start = 9;
222     uint16_t end = 10;
223     spannableString_->SetSpannable(true, start, end);
224     EXPECT_EQ(default_is_spannable_len, spannableString_->GetIsSpannableLen());
225     if (default_is_spannable_len == spannableString_->GetIsSpannableLen()) {
226         for (uint16_t i = 0; i < start; i++) {
227             EXPECT_EQ(spannableString_->GetSpannable(i), false);
228         }
229         for (uint16_t i = start; i < end; i++) {
230             EXPECT_EQ(spannableString_->GetSpannable(i), true);
231         }
232     }
233 }
234 
235 /**
236  * @tc.name: SpannableString_SetSpannable_007
237  * @tc.desc: Verify SetSpannable function, de-duplicate, equal.
238  * @tc.type: FUNC
239  */
240 HWTEST_F(SpannableStringTest, SpannableString_SetSpannable_007, TestSize.Level1)
241 {
242     uint16_t default_is_spannable_len = 10;
243     uint16_t start_1 = 2;
244     uint16_t end_1 = 5;
245     spannableString_->SetSpannable(true, start_1, end_1);
246     uint16_t start_2 = 4;
247     uint16_t end_2 = 6;
248     spannableString_->SetSpannable(true, start_2, end_2);
249     EXPECT_EQ(default_is_spannable_len, spannableString_->GetIsSpannableLen());
250     if (default_is_spannable_len == spannableString_->GetIsSpannableLen()) {
251         for (uint16_t i = 0; i < start_1; i++) {
252             EXPECT_EQ(spannableString_->GetSpannable(i), false);
253         }
254         for (uint16_t i = start_1; i < end_2; i++) {
255             EXPECT_EQ(spannableString_->GetSpannable(i), true);
256         }
257         for (uint16_t i = end_2; i < default_is_spannable_len; i++) {
258             EXPECT_EQ(spannableString_->GetSpannable(i), false);
259         }
260     }
261 }
262 
263 /**
264  * @tc.name: SpannableString_GetSpannable_001
265  * @tc.desc: Verify SetSpannable function, must trust isSpannableLen_ is right, then verify capability, equal.
266  * @tc.type: FUNC
267  */
268 HWTEST_F(SpannableStringTest, SpannableString_GetSpannable_001, TestSize.Level1)
269 {
270     uint16_t default_is_spannable_len = 10;
271     EXPECT_EQ(default_is_spannable_len, spannableString_->GetIsSpannableLen());
272     uint16_t start = 2;
273     uint16_t end = 5;
274     spannableString_->SetSpannable(true, start, end);
275     for (uint16_t i = start; i < end; i++) {
276         bool value = spannableString_->GetSpannable(i);
277         EXPECT_EQ(true, value);
278     }
279 }
280 
281 /**
282  * @tc.name: SpannableString_GetSpannable_002
283  * @tc.desc: Verify GetSpannable function, must trust isSpannableLen_ is right, out-of-bound, equal.
284  * @tc.type: FUNC
285  */
286 HWTEST_F(SpannableStringTest, SpannableString_GetSpannable_002, TestSize.Level1)
287 {
288     uint16_t default_is_spannable_len = 10;
289     uint16_t start = 2;
290     uint16_t end = 5;
291     spannableString_->SetSpannable(true, start, end);
292     EXPECT_EQ(default_is_spannable_len, spannableString_->GetIsSpannableLen());
293     bool value_0 = spannableString_->GetSpannable(0);
294     bool value_2 = spannableString_->GetSpannable(2);
295     bool value_4 = spannableString_->GetSpannable(4);
296     bool value_5 = spannableString_->GetSpannable(5);
297     bool value_9 = spannableString_->GetSpannable(9);
298     bool value_10 = spannableString_->GetSpannable(10);
299     EXPECT_EQ(false, value_0);
300     EXPECT_EQ(true, value_2);
301     EXPECT_EQ(true, value_4);
302     EXPECT_EQ(false, value_5);
303     EXPECT_EQ(false, value_9);
304     EXPECT_EQ(false, value_10);
305 }
306 
307 /**
308  * @tc.name: SpannableString_SetFontSize_001
309  * @tc.desc: Verify SetFontSize function, must trust GetFontSize is OK, then verify SetFontSize, capability, equal.
310  * @tc.type: FUNC
311  */
312 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_001, TestSize.Level1)
313 {
314     uint8_t fontSize = 16;
315     uint16_t start = 2;
316     uint16_t end = 5;
317     spannableString_->SetFontSize(fontSize, start, end);
318     EXPECT_EQ(1, spannableString_->GetSizeListSize());
319     for (uint16_t i = start; i < end; i++) {
320         uint8_t tempFontSize = 0;
321         spannableString_->GetFontSize(i, tempFontSize);
322         EXPECT_EQ(fontSize, tempFontSize);
323     }
324 }
325 
326 /**
327  * @tc.name: SpannableString_SetFontSize_002
328  * @tc.desc: Verify SetFontSize function, de-duplicate, case same font 0, not draw on requirements analysis, equal.
329  * @tc.type: FUNC
330  */
331 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_002, TestSize.Level1)
332 {
333     uint8_t fontSize = 16;
334     uint16_t start_1 = 2;
335     uint16_t end_1 = 4;
336     spannableString_->SetFontSize(fontSize, start_1, end_1);
337     uint16_t start_2 = 6;
338     uint16_t end_2 = 8;
339     spannableString_->SetFontSize(fontSize, start_2, end_2);
340     EXPECT_EQ(2, spannableString_->GetSizeListSize());
341     for (uint16_t i = start_1; i < end_1; i++) {
342         uint8_t tempFontSize = 0;
343         spannableString_->GetFontSize(i, tempFontSize);
344         EXPECT_EQ(fontSize, tempFontSize);
345     }
346     for (uint16_t i = start_2; i < end_2; i++) {
347         uint8_t tempFontSize = 0;
348         spannableString_->GetFontSize(i, tempFontSize);
349         EXPECT_EQ(fontSize, tempFontSize);
350     }
351 }
352 
353 /**
354  * @tc.name: SpannableString_SetFontSize_003
355  * @tc.desc: Verify SetFontSize function, de-duplicate, same font case 1, equal.
356  * @tc.type: FUNC
357  */
358 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_003, TestSize.Level1)
359 {
360     uint8_t fontSize = 16;
361     uint16_t start_1 = 4;
362     uint16_t end_1 = 6;
363     spannableString_->SetFontSize(fontSize, start_1, end_1);
364     uint16_t start_2 = 2;
365     uint16_t end_2 = 5;
366     spannableString_->SetFontSize(fontSize, start_2, end_2);
367     EXPECT_EQ(1, spannableString_->GetSizeListSize());
368     for (uint16_t i = start_2; i < end_1; i++) {
369         uint8_t tempFontSize = 0;
370         spannableString_->GetFontSize(i, tempFontSize);
371         EXPECT_EQ(fontSize, tempFontSize);
372     }
373 }
374 
375 /**
376  * @tc.name: SpannableString_SetFontSize_004
377  * @tc.desc: Verify SetFontSize function, de-duplicate, same font case 2, equal.
378  * @tc.type: FUNC
379  */
380 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_004, TestSize.Level1)
381 {
382     uint8_t fontSize = 16;
383     uint16_t start_1 = 2;
384     uint16_t end_1 = 8;
385     spannableString_->SetFontSize(fontSize, start_1, end_1);
386     uint16_t start_2 = 4;
387     uint16_t end_2 = 6;
388     spannableString_->SetFontSize(fontSize, start_2, end_2);
389     EXPECT_EQ(1, spannableString_->GetSizeListSize());
390     for (uint16_t i = start_1; i < end_1; i++) {
391         uint8_t tempFontSize = 0;
392         spannableString_->GetFontSize(i, tempFontSize);
393         EXPECT_EQ(fontSize, tempFontSize);
394     }
395 }
396 
397 /**
398  * @tc.name: SpannableString_SetFontSize_005
399  * @tc.desc: Verify SetFontSize function, de-duplicate, same font case 3, equal.
400  * @tc.type: FUNC
401  */
402 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_005, TestSize.Level1)
403 {
404     uint8_t fontSize = 16;
405     uint16_t start_1 = 2;
406     uint16_t end_1 = 6;
407     spannableString_->SetFontSize(fontSize, start_1, end_1);
408     uint16_t start_2 = 4;
409     uint16_t end_2 = 8;
410     spannableString_->SetFontSize(fontSize, start_2, end_2);
411     EXPECT_EQ(1, spannableString_->GetSizeListSize());
412     for (uint16_t i = start_1; i < end_2; i++) {
413         uint8_t tempFontSize = 0;
414         spannableString_->GetFontSize(i, tempFontSize);
415         EXPECT_EQ(fontSize, tempFontSize);
416     }
417 }
418 
419 /**
420  * @tc.name: SpannableString_SetFontSize_006
421  * @tc.desc: Verify SetFontSize function, de-duplicate, same font case 4, equal.
422  * @tc.type: FUNC
423  */
424 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_006, TestSize.Level1)
425 {
426     uint8_t fontSize = 16;
427     uint16_t start_1 = 4;
428     uint16_t end_1 = 6;
429     spannableString_->SetFontSize(fontSize, start_1, end_1);
430     uint16_t start_2 = 2;
431     uint16_t end_2 = 8;
432     spannableString_->SetFontSize(fontSize, start_2, end_2);
433     EXPECT_EQ(1, spannableString_->GetSizeListSize());
434     for (uint16_t i = start_2; i < end_2; i++) {
435         uint8_t tempFontSize = 0;
436         spannableString_->GetFontSize(i, tempFontSize);
437         EXPECT_EQ(fontSize, tempFontSize);
438     }
439 }
440 
441 /**
442  * @tc.name: SpannableString_SetFontSize_007
443  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 1, equal.
444  * @tc.type: FUNC
445  */
446 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_007, TestSize.Level1)
447 {
448     uint8_t fontSize_red = 16;
449     uint16_t start_red = 2;
450     uint16_t end_red = 4;
451     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
452     uint8_t fontSize_green = 23;
453     uint16_t start_green = 6;
454     uint16_t end_green = 8;
455     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
456     EXPECT_EQ(2, spannableString_->GetSizeListSize());
457     for (uint16_t i = start_red; i < end_red; i++) {
458         uint8_t tempFontSize = 0;
459         spannableString_->GetFontSize(i, tempFontSize);
460         EXPECT_EQ(fontSize_red, tempFontSize);
461     }
462     for (uint16_t i = start_green; i < end_green; i++) {
463         uint8_t tempFontSize = 0;
464         spannableString_->GetFontSize(i, tempFontSize);
465         EXPECT_EQ(fontSize_green, tempFontSize);
466     }
467 }
468 
469 /**
470  * @tc.name: SpannableString_SetFontSize_008
471  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 2, equal.
472  * @tc.type: FUNC
473  */
474 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_008, TestSize.Level1)
475 {
476     uint8_t fontSize_red = 16;
477     uint16_t start_red = 2;
478     uint16_t end_red = 4;
479     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
480     uint8_t fontSize_green = 23;
481     uint16_t start_green = 4;
482     uint16_t end_green = 6;
483     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
484     EXPECT_EQ(2, spannableString_->GetSizeListSize());
485     for (uint16_t i = start_red; i < start_green; i++) {
486         uint8_t tempFontSize = 0;
487         spannableString_->GetFontSize(i, tempFontSize);
488         EXPECT_EQ(fontSize_red, tempFontSize);
489     }
490     for (uint16_t i = start_green; i < end_green; i++) {
491         uint8_t tempFontSize = 0;
492         spannableString_->GetFontSize(i, tempFontSize);
493         EXPECT_EQ(fontSize_green, tempFontSize);
494     }
495 }
496 
497 /**
498  * @tc.name: SpannableString_SetFontSize_009
499  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 3, equal.
500  * @tc.type: FUNC
501  */
502 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_009, TestSize.Level1)
503 {
504     uint8_t fontSize_red = 16;
505     uint16_t start_red = 2;
506     uint16_t end_red = 6;
507     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
508     uint8_t fontSize_green = 23;
509     uint16_t start_green = 4;
510     uint16_t end_green = 8;
511     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
512     EXPECT_EQ(2, spannableString_->GetSizeListSize());
513     for (uint16_t i = start_red; i < start_green; i++) {
514         uint8_t tempFontSize = 0;
515         spannableString_->GetFontSize(i, tempFontSize);
516         EXPECT_EQ(fontSize_red, tempFontSize);
517     }
518     for (uint16_t i = start_green; i < end_green; i++) {
519         uint8_t tempFontSize = 0;
520         spannableString_->GetFontSize(i, tempFontSize);
521         EXPECT_EQ(fontSize_green, tempFontSize);
522     }
523 }
524 
525 /**
526  * @tc.name: SpannableString_SetFontSize_010
527  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 4, equal.
528  * @tc.type: FUNC
529  */
530 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_010, TestSize.Level1)
531 {
532     uint8_t fontSize_red = 16;
533     uint16_t start_red = 2;
534     uint16_t end_red = 6;
535     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
536     uint8_t fontSize_green = 23;
537     uint16_t start_green = 4;
538     uint16_t end_green = 6;
539     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
540     EXPECT_EQ(2, spannableString_->GetSizeListSize());
541     for (uint16_t i = start_red; i < start_green; i++) {
542         uint8_t tempFontSize = 0;
543         spannableString_->GetFontSize(i, tempFontSize);
544         EXPECT_EQ(fontSize_red, tempFontSize);
545     }
546     for (uint16_t i = start_green; i < end_green; i++) {
547         uint8_t tempFontSize = 0;
548         spannableString_->GetFontSize(i, tempFontSize);
549         EXPECT_EQ(fontSize_green, tempFontSize);
550     }
551 }
552 
553 /**
554  * @tc.name: SpannableString_SetFontSize_011
555  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 5, equal.
556  * @tc.type: FUNC
557  */
558 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_011, TestSize.Level1)
559 {
560     uint8_t fontSize_red = 16;
561     uint16_t start_red = 2;
562     uint16_t end_red = 8;
563     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
564     uint8_t fontSize_green = 23;
565     uint16_t start_green = 4;
566     uint16_t end_green = 6;
567     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
568     EXPECT_EQ(3, spannableString_->GetSizeListSize());
569     for (uint16_t i = start_red; i < start_green; i++) {
570         uint8_t tempFontSize = 0;
571         spannableString_->GetFontSize(i, tempFontSize);
572         EXPECT_EQ(fontSize_red, tempFontSize);
573     }
574     for (uint16_t i = start_green; i < end_green; i++) {
575         uint8_t tempFontSize = 0;
576         spannableString_->GetFontSize(i, tempFontSize);
577         EXPECT_EQ(fontSize_green, tempFontSize);
578     }
579     for (uint16_t i = end_green; i < end_red; i++) {
580         uint8_t tempFontSize = 0;
581         spannableString_->GetFontSize(i, tempFontSize);
582         EXPECT_EQ(fontSize_red, tempFontSize);
583     }
584 }
585 
586 /**
587  * @tc.name: SpannableString_SetFontSize_012
588  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 6, equal.
589  * @tc.type: FUNC
590  */
591 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_012, TestSize.Level1)
592 {
593     uint8_t fontSize_red = 16;
594     uint16_t start_red = 2;
595     uint16_t end_red = 4;
596     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
597     uint8_t fontSize_green = 23;
598     uint16_t start_green = 2;
599     uint16_t end_green = 6;
600     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
601     EXPECT_EQ(1, spannableString_->GetSizeListSize());
602     for (uint16_t i = start_green; i < end_green; i++) {
603         uint8_t tempFontSize = 0;
604         spannableString_->GetFontSize(i, tempFontSize);
605         EXPECT_EQ(fontSize_green, tempFontSize);
606     }
607 }
608 
609 /**
610  * @tc.name: SpannableString_SetFontSize_013
611  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 7, equal.
612  * @tc.type: FUNC
613  */
614 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_013, TestSize.Level1)
615 {
616     uint8_t fontSize_red = 16;
617     uint16_t start_red = 2;
618     uint16_t end_red = 6;
619     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
620     uint8_t fontSize_green = 23;
621     uint16_t start_green = 2;
622     uint16_t end_green = 6;
623     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
624     EXPECT_EQ(1, spannableString_->GetSizeListSize());
625     for (uint16_t i = start_green; i < end_green; i++) {
626         uint8_t tempFontSize = 0;
627         spannableString_->GetFontSize(i, tempFontSize);
628         EXPECT_EQ(fontSize_green, tempFontSize);
629     }
630 }
631 
632 /**
633  * @tc.name: SpannableString_SetFontSize_014
634  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 8, equal.
635  * @tc.type: FUNC
636  */
637 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_014, TestSize.Level1)
638 {
639     uint8_t fontSize_red = 16;
640     uint16_t start_red = 2;
641     uint16_t end_red = 8;
642     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
643     uint8_t fontSize_green = 23;
644     uint16_t start_green = 2;
645     uint16_t end_green = 6;
646     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
647     EXPECT_EQ(2, spannableString_->GetSizeListSize());
648     for (uint16_t i = start_green; i < end_green; i++) {
649         uint8_t tempFontSize = 0;
650         spannableString_->GetFontSize(i, tempFontSize);
651         EXPECT_EQ(fontSize_green, tempFontSize);
652     }
653     for (uint16_t i = end_green; i < end_red; i++) {
654         uint8_t tempFontSize = 0;
655         spannableString_->GetFontSize(i, tempFontSize);
656         EXPECT_EQ(fontSize_red, tempFontSize);
657     }
658 }
659 
660 /**
661  * @tc.name: SpannableString_SetFontSize_015
662  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 9, equal.
663  * @tc.type: FUNC
664  */
665 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_015, TestSize.Level1)
666 {
667     uint8_t fontSize_red = 16;
668     uint16_t start_red = 4;
669     uint16_t end_red = 6;
670     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
671     uint8_t fontSize_green = 23;
672     uint16_t start_green = 2;
673     uint16_t end_green = 8;
674     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
675     EXPECT_EQ(1, spannableString_->GetSizeListSize());
676     for (uint16_t i = start_green; i < end_green; i++) {
677         uint8_t tempFontSize = 0;
678         spannableString_->GetFontSize(i, tempFontSize);
679         EXPECT_EQ(fontSize_green, tempFontSize);
680     }
681 }
682 
683 /**
684  * @tc.name: SpannableString_SetFontSize_016
685  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 10, equal.
686  * @tc.type: FUNC
687  */
688 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_016, TestSize.Level1)
689 {
690     uint8_t fontSize_red = 16;
691     uint16_t start_red = 4;
692     uint16_t end_red = 6;
693     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
694     uint8_t fontSize_green = 23;
695     uint16_t start_green = 2;
696     uint16_t end_green = 6;
697     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
698     EXPECT_EQ(1, spannableString_->GetSizeListSize());
699     for (uint16_t i = start_green; i < end_green; i++) {
700         uint8_t tempFontSize = 0;
701         spannableString_->GetFontSize(i, tempFontSize);
702         EXPECT_EQ(fontSize_green, tempFontSize);
703     }
704 }
705 
706 /**
707  * @tc.name: SpannableString_SetFontSize_017
708  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 11, equal.
709  * @tc.type: FUNC
710  */
711 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_017, TestSize.Level1)
712 {
713     uint8_t fontSize_red = 16;
714     uint16_t start_red = 4;
715     uint16_t end_red = 8;
716     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
717     uint8_t fontSize_green = 23;
718     uint16_t start_green = 2;
719     uint16_t end_green = 6;
720     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
721     EXPECT_EQ(2, spannableString_->GetSizeListSize());
722     for (uint16_t i = end_green; i < end_red; i++) {
723         uint8_t tempFontSize = 0;
724         spannableString_->GetFontSize(i, tempFontSize);
725         EXPECT_EQ(fontSize_red, tempFontSize);
726     }
727     for (uint16_t i = start_green; i < end_green; i++) {
728         uint8_t tempFontSize = 0;
729         spannableString_->GetFontSize(i, tempFontSize);
730         EXPECT_EQ(fontSize_green, tempFontSize);
731     }
732 }
733 
734 /**
735  * @tc.name: SpannableString_SetFontSize_018
736  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 12, equal.
737  * @tc.type: FUNC
738  */
739 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_018, TestSize.Level1)
740 {
741     uint8_t fontSize_red = 16;
742     uint16_t start_red = 6;
743     uint16_t end_red = 8;
744     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
745     uint8_t fontSize_green = 23;
746     uint16_t start_green = 2;
747     uint16_t end_green = 6;
748     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
749     EXPECT_EQ(2, spannableString_->GetSizeListSize());
750     for (uint16_t i = start_red; i < end_red; i++) {
751         uint8_t tempFontSize = 0;
752         spannableString_->GetFontSize(i, tempFontSize);
753         EXPECT_EQ(fontSize_red, tempFontSize);
754     }
755     for (uint16_t i = start_green; i < end_green; i++) {
756         uint8_t tempFontSize = 0;
757         spannableString_->GetFontSize(i, tempFontSize);
758         EXPECT_EQ(fontSize_green, tempFontSize);
759     }
760 }
761 
762 /**
763  * @tc.name: SpannableString_SetFontSize_019
764  * @tc.desc: Verify SetFontSize function, de-duplicate, different font case 13, equal.
765  * @tc.type: FUNC
766  */
767 HWTEST_F(SpannableStringTest, SpannableString_SetFontSize_019, TestSize.Level1)
768 {
769     uint8_t fontSize_red = 16;
770     uint16_t start_red = 6;
771     uint16_t end_red = 8;
772     spannableString_->SetFontSize(fontSize_red, start_red, end_red);
773     uint8_t fontSize_green = 23;
774     uint16_t start_green = 2;
775     uint16_t end_green = 6;
776     spannableString_->SetFontSize(fontSize_green, start_green, end_green);
777     EXPECT_EQ(2, spannableString_->GetSizeListSize());
778     for (uint16_t i = start_red; i < end_red; i++) {
779         uint8_t tempFontSize = 0;
780         spannableString_->GetFontSize(i, tempFontSize);
781         EXPECT_EQ(fontSize_red, tempFontSize);
782     }
783     for (uint16_t i = start_green; i < end_green; i++) {
784         uint8_t tempFontSize = 0;
785         spannableString_->GetFontSize(i, tempFontSize);
786         EXPECT_EQ(fontSize_green, tempFontSize);
787     }
788 }
789 /* * here de-duplicate has already been verified, no need verifiy anymore */
790 
791 /**
792  * @tc.name: SpannableString_GetFontSize_001
793  * @tc.desc: Verify SetFontSize function, capability & bound, equal.
794  * @tc.type: FUNC
795  */
796 HWTEST_F(SpannableStringTest, SpannableString_GetFontSize_001, TestSize.Level1)
797 {
798     uint8_t fontSize = 16;
799     uint16_t start = 6;
800     uint16_t end = 8;
801     spannableString_->SetFontSize(fontSize, start, end);
802     uint8_t output_0 = 0;
803     bool hasGet_0 = spannableString_->GetFontSize(0, output_0);
804     EXPECT_EQ(false, hasGet_0);
805     EXPECT_EQ(0, output_0);
806     uint8_t output_6 = 0;
807     bool hasGet_6 = spannableString_->GetFontSize(6, output_6);
808     EXPECT_EQ(true, hasGet_6);
809     EXPECT_EQ(fontSize, output_6);
810     uint8_t output_8 = 0;
811     bool hasGet_8 = spannableString_->GetFontSize(8, output_8);
812     EXPECT_EQ(false, hasGet_8);
813     EXPECT_EQ(0, output_8);
814 }
815 
816 /**
817  * @tc.name: SpannableString_SetFontId_001
818  * @tc.desc: Verify SetFontId function, capability, equal.
819  * @tc.type: FUNC
820  */
821 HWTEST_F(SpannableStringTest, SpannableString_SetFontId_001, TestSize.Level1)
822 {
823     uint16_t fontId = 16;
824     uint16_t start = 6;
825     uint16_t end = 8;
826     spannableString_->SetFontId(fontId, start, end);
827     EXPECT_EQ(1, spannableString_->GetFontIdListSize());
828     for (uint16_t i = start; i < end; i++) {
829         uint16_t tempFontId = 0;
830         spannableString_->GetFontId(i, tempFontId);
831         EXPECT_EQ(fontId, tempFontId);
832     }
833 }
834 
835 /**
836  * @tc.name: SpannableString_GetFontId_001
837  * @tc.desc: Verify GetFontId function, capability & bound, equal.
838  * @tc.type: FUNC
839  */
840 HWTEST_F(SpannableStringTest, SpannableString_GetFontId_001, TestSize.Level1)
841 {
842     uint16_t fontId = 16;
843     uint16_t start = 6;
844     uint16_t end = 8;
845     spannableString_->SetFontId(fontId, start, end);
846     uint16_t output_0 = 0;
847     bool hasFind_0 = false;
848     hasFind_0 = spannableString_->GetFontId(0, output_0);
849     EXPECT_EQ(false, hasFind_0);
850     EXPECT_EQ(0, output_0);
851     uint16_t output_6 = 0;
852     bool hasFind_6 = false;
853     hasFind_6 = spannableString_->GetFontId(6, output_6);
854     EXPECT_EQ(true, hasFind_6);
855     EXPECT_EQ(fontId, output_6);
856     uint16_t output_8 = 0;
857     bool hasFind_8 = false;
858     hasFind_8 = spannableString_->GetFontId(8, output_8);
859     EXPECT_EQ(false, hasFind_8);
860     EXPECT_EQ(0, output_8);
861 }
862 
863 /**
864  * @tc.name: SpannableString_SetFontHeight_001
865  * @tc.desc: Verify SetFontHeight function, capability, equal.
866  * @tc.type: FUNC
867  */
868 HWTEST_F(SpannableStringTest, SpannableString_SetFontHeight_001, TestSize.Level1)
869 {
870     int16_t height = 16;
871     uint16_t start = 6;
872     uint16_t end = 8;
873     spannableString_->SetFontHeight(height, start, end);
874     EXPECT_EQ(1, spannableString_->GetHeightListSize());
875     for (uint16_t i = start; i < end; i++) {
876         int16_t tempHeight = 0;
877         spannableString_->GetFontHeight(i, tempHeight, 0, 20);
878         EXPECT_EQ(height, tempHeight);
879     }
880 }
881 
882 /**
883  * @tc.name: SpannableString_GetHeight_001
884  * @tc.desc: Verify GetHeight function, capability & out-of-bound, equal.
885  * @tc.type: FUNC
886  */
887 HWTEST_F(SpannableStringTest, SpannableString_GetHeight_001, TestSize.Level1)
888 {
889     int16_t height = 16;
890     uint16_t start = 6;
891     uint16_t end = 8;
892     spannableString_->SetFontHeight(height, start, end);
893     int16_t output_0 = 0;
894     bool hasFind_0 = spannableString_->GetFontHeight(0, output_0, 0, 20);
895     EXPECT_EQ(false, hasFind_0);
896     EXPECT_EQ(0, output_0);
897     int16_t output_6 = 0;
898     bool hasFind_6 = spannableString_->GetFontHeight(6, output_6, 0, 20);
899     EXPECT_EQ(true, hasFind_6);
900     EXPECT_EQ(height, output_6);
901     int16_t output_8 = 0;
902     bool hasFind_8 = spannableString_->GetFontHeight(8, output_8, 0, 20);
903     EXPECT_EQ(false, hasFind_8);
904     EXPECT_EQ(0, output_8);
905 }
906 
907 /**
908  * @tc.name: SpannableString_SetSpannableString_001
909  * @tc.desc: Verify SetSpannableString function, capability, cover blank,equal.
910  * @tc.type: FUNC
911  */
912 HWTEST_F(SpannableStringTest, SpannableString_SetSpannableString_001, TestSize.Level1)
913 {
914     SpannableString *input = new SpannableString();
915     const char *text_ = "hello world hello openharmony";
916     input->InitIsSpannable(strlen(text_));
917     TextStyle textStyle = TextStyle::TEXT_STYLE_NORMAL;
918     uint16_t textStyleStart = 2;
919     uint16_t textStyleEnd = 4;
920     input->SetTextStyle(textStyle, textStyleStart, textStyleEnd);
921     uint8_t inputFontSize = 17;
922     uint16_t fontSizeStart = 6;
923     uint16_t fontSizeEnd = 8;
924     input->SetFontSize(inputFontSize, fontSizeStart, fontSizeEnd);
925     uint16_t inputFontId = 21;
926     uint16_t fontIdStart = 10;
927     uint16_t fontIdEnd = 12;
928     input->SetFontId(inputFontId, fontIdStart, fontIdEnd);
929     uint16_t inputHeight = 25;
930     uint16_t heightStart = 14;
931     uint16_t heightEnd = 16;
932     input->SetFontHeight(inputHeight, heightStart, heightEnd);
933 
934     const SpannableString *inputPtr = input;
935 
936     spannableString_->SetSpannableString(inputPtr);
937 
938     EXPECT_EQ(1, spannableString_->GetSpanListSize());
939     // textStyle value has not been check
940 
941     EXPECT_EQ(1, spannableString_->GetSizeListSize());
942     for (uint16_t i = fontSizeStart; i < fontSizeEnd; i++) {
943         EXPECT_EQ(true, spannableString_->GetSpannable(i));
944         uint8_t tempSize = 0;
945         spannableString_->GetFontSize(i, tempSize);
946         EXPECT_EQ(inputFontSize, tempSize);
947     }
948 
949     EXPECT_EQ(1, spannableString_->GetFontIdListSize());
950     for (uint16_t i = fontIdStart; i < fontIdEnd; i++) {
951         EXPECT_EQ(true, spannableString_->GetSpannable(i));
952         uint16_t tempFontId = 0;
953         spannableString_->GetFontId(i, tempFontId);
954         EXPECT_EQ(inputFontId, tempFontId);
955     }
956 
957     EXPECT_EQ(1, spannableString_->GetHeightListSize());
958     for (uint16_t i = heightStart; i < heightEnd; i++) {
959         EXPECT_EQ(true, spannableString_->GetSpannable(i));
960         int16_t tempHeight = 0;
961         spannableString_->GetFontHeight(i, tempHeight, 0, 20);
962         EXPECT_EQ(inputHeight, tempHeight);
963     }
964 }
965 
966 /**
967  * @tc.name: SpannableString_SetSpannableString_002
968  * @tc.desc: Verify SetSpannableString function, capability, componments already exist and now cover them, equal.
969  * @tc.type: FUNC
970  */
971 HWTEST_F(SpannableStringTest, SpannableString_SetSpannableString_002, TestSize.Level1)
972 {
973     SpannableString *input = new SpannableString();
974     const char *text_1 = "hello world hello openharmony";
975     input->InitIsSpannable(strlen(text_1));
976     TextStyle textStyle = TextStyle::TEXT_STYLE_NORMAL;
977     uint16_t textStyleStart = 2;
978     uint16_t textStyleEnd = 4;
979     input->SetTextStyle(textStyle, textStyleStart, textStyleEnd);
980     uint8_t inputFontSize = 17;
981     uint16_t fontSizeStart = 6;
982     uint16_t fontSizeEnd = 8;
983     input->SetFontSize(inputFontSize, fontSizeStart, fontSizeEnd);
984     uint16_t inputFontId = 21;
985     uint16_t fontIdStart = 10;
986     uint16_t fontIdEnd = 12;
987     input->SetFontId(inputFontId, fontIdStart, fontIdEnd);
988     uint16_t inputHeight = 25;
989     uint16_t heightStart = 14;
990     uint16_t heightEnd = 16;
991     input->SetFontHeight(inputHeight, heightStart, heightEnd);
992 
993     const char *text_2 = "hello world hello openharmony";
994     spannableString_->InitIsSpannable(strlen(text_2));
995     TextStyle textStyle_exist = TextStyle::TEXT_STYLE_NORMAL;
996     uint16_t textStyleStart_exist = 3;
997     uint16_t textStyleEnd_exist = 14;
998     spannableString_->SetTextStyle(textStyle_exist, textStyleStart_exist, textStyleEnd_exist);
999     uint8_t inputFontSize_exist = 18;
1000     uint16_t fontSizeStart_exist = 7;
1001     uint16_t fontSizeEnd_exist = 18;
1002     spannableString_->SetFontSize(inputFontSize_exist, fontSizeStart_exist, fontSizeEnd_exist);
1003     uint16_t inputFontId_exist = 22;
1004     uint16_t fontIdStart_exist = 11;
1005     uint16_t fontIdEnd_exist = 22;
1006     spannableString_->SetFontId(inputFontId_exist, fontIdStart_exist, fontIdEnd_exist);
1007     uint16_t inputHeight_exist = 26;
1008     uint16_t heightStart_exist = 15;
1009     uint16_t heightEnd_exist = 26;
1010     spannableString_->SetFontHeight(inputHeight_exist, heightStart_exist, heightEnd_exist);
1011 
1012     const SpannableString *inputPtr = input;
1013     spannableString_->SetSpannableString(inputPtr);
1014 
1015     EXPECT_EQ(1, spannableString_->GetSpanListSize());
1016     // textStyle value has not been check
1017 
1018     EXPECT_EQ(1, spannableString_->GetSizeListSize());
1019     for (uint16_t i = fontSizeStart; i < fontSizeEnd; i++) {
1020         EXPECT_EQ(true, spannableString_->GetSpannable(i));
1021         uint8_t tempSize = 0;
1022         spannableString_->GetFontSize(i, tempSize);
1023         EXPECT_EQ(inputFontSize, tempSize);
1024     }
1025 
1026     EXPECT_EQ(1, spannableString_->GetFontIdListSize());
1027     for (uint16_t i = fontIdStart; i < fontIdEnd; i++) {
1028         EXPECT_EQ(true, spannableString_->GetSpannable(i));
1029         uint16_t tempFontId = 0;
1030         spannableString_->GetFontId(i, tempFontId);
1031         EXPECT_EQ(inputFontId, tempFontId);
1032     }
1033 
1034     EXPECT_EQ(1, spannableString_->GetHeightListSize());
1035     for (uint16_t i = heightStart; i < heightEnd; i++) {
1036         EXPECT_EQ(true, spannableString_->GetSpannable(i));
1037         int16_t tempHeight = 0;
1038         spannableString_->GetFontHeight(i, tempHeight, 0, 20);
1039         EXPECT_EQ(inputHeight, tempHeight);
1040     }
1041 }
1042 } // namespace OHOS
1043 #endif // ENABLE_SPANNABLE_STRING
1044