1 /*
2  * Copyright (c) 2021 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 "i18n_test.h"
17 #include <gtest/gtest.h>
18 #include "date_time_format.h"
19 #include "locale_info.h"
20 #include "measure_format.h"
21 #include "number_format.h"
22 #include "plural_format.h"
23 #include "types.h"
24 #include "week_info.h"
25 
26 using namespace std;
27 using namespace testing::ext;
28 
29 namespace OHOS {
30 namespace I18N {
31 class I18NTest : public testing::Test {
32 public:
33     void SetUp();
34     void TearDown();
35 };
36 
SetUp()37 void I18NTest::SetUp()
38 {
39 }
40 
TearDown()41 void I18NTest::TearDown()
42 {
43 }
44 
45 /**
46  * @tc.name: I18nFuncTest001
47  * @tc.desc: Test LocaleInfo constructor1
48  * @tc.type: FUNC
49  */
50 HWTEST_F(I18NTest, I18NFuncTest001, TestSize.Level1)
51 {
52     LocaleInfo *locale = new LocaleInfo("zh", "Hans", "CN");
53     EXPECT_TRUE(locale != nullptr);
54     delete locale;
55 }
56 
57 /**
58  * @tc.name: I18nFuncTest002
59  * @tc.desc: Test LocaleInfo constructor2
60  * @tc.type: FUNC
61  */
62 HWTEST_F(I18NTest, I18NFuncTest002, TestSize.Level1)
63 {
64     LocaleInfo *locale = new LocaleInfo("zh", "CN");
65     EXPECT_TRUE(locale != nullptr);
66     delete locale;
67 }
68 
69 /**
70  * @tc.name: I18nFuncTest003
71  * @tc.desc: Test LocaleInfo default Constructor
72  * @tc.type: FUNC
73  */
74 HWTEST_F(I18NTest, I18NFuncTest003, TestSize.Level1)
75 {
76     LocaleInfo *locale = new LocaleInfo();
77     EXPECT_TRUE(locale != nullptr);
78     delete locale;
79 }
80 
81 /**
82  * @tc.name: I18nFuncTest004
83  * @tc.desc: Test LocaleInfo copy constructor
84  * @tc.type: FUNC
85  */
86 HWTEST_F(I18NTest, I18NFuncTest004, TestSize.Level1)
87 {
88     LocaleInfo locale("zh", "CN");
89     LocaleInfo locale2(locale);
90     const char *language = locale2.GetLanguage();
91     const char *region = locale2.GetRegion();
92     EXPECT_TRUE(language != nullptr);
93     EXPECT_TRUE(region != nullptr);
94     if (language != nullptr) {
95         EXPECT_TRUE(strcmp(language, "zh") == 0);
96     }
97     if (region != nullptr) {
98         EXPECT_TRUE(strcmp(region, "CN") == 0);
99     }
100 }
101 
102 /**
103  * @tc.name: I18nFuncTest005
104  * @tc.desc: Test LocaleInfo equals function
105  * @tc.type: FUNC
106  */
107 HWTEST_F(I18NTest, I18NFuncTest005, TestSize.Level1)
108 {
109     LocaleInfo locale("zh", "CN");
110     LocaleInfo locale2("zh", "CN");
111     EXPECT_TRUE(locale == locale2);
112 }
113 
114 /**
115  * @tc.name: I18nFuncTest006
116  * @tc.desc: Test LocaleInfo GetLanguage function
117  * @tc.type: FUNC
118  */
119 HWTEST_F(I18NTest, I18NFuncTest006, TestSize.Level1)
120 {
121     LocaleInfo locale("ar", "AE");
122     const char *language = locale.GetLanguage();
123     EXPECT_TRUE(language != nullptr);
124     if (language != nullptr) {
125         EXPECT_TRUE(strcmp(language, "ar") == 0);
126     }
127 }
128 
129 /**
130  * @tc.name: I18nFuncTest007
131  * @tc.desc: Test LocaleInfo GetRegion function
132  * @tc.type: FUNC
133  */
134 HWTEST_F(I18NTest, I18NFuncTest007, TestSize.Level1)
135 {
136     LocaleInfo locale("ar", "AE");
137     const char *region = locale.GetRegion();
138     EXPECT_TRUE(region != nullptr);
139     if (region != nullptr) {
140         EXPECT_TRUE(strcmp(region, "AE") == 0);
141     }
142 }
143 
144 /**
145  * @tc.name: I18nFuncTest008
146  * @tc.desc: Test LocaleInfo GetScript function
147  * @tc.type: FUNC
148  */
149 HWTEST_F(I18NTest, I18NFuncTest008, TestSize.Level1)
150 {
151     LocaleInfo locale("zh", "Hans", "CN");
152     const char *script = locale.GetScript();
153     EXPECT_TRUE(script != nullptr);
154     if (script != nullptr) {
155         EXPECT_TRUE(strcmp(script, "Hans") == 0);
156     }
157 }
158 
159 /**
160  * @tc.name: I18nFuncTest009
161  * @tc.desc: Test LocaleInfo GetId function
162  * @tc.type: FUNC
163  */
164 HWTEST_F(I18NTest, I18NFuncTest009, TestSize.Level1)
165 {
166     LocaleInfo locale("zh", "Hans", "CN");
167     const char *id = locale.GetId();
168     EXPECT_TRUE(id != nullptr);
169     if (id != nullptr) {
170         EXPECT_TRUE(strcmp(id, "zh-Hans-CN") == 0);
171     }
172 }
173 
174 /**
175  * @tc.name: I18nFuncTest010
176  * @tc.desc: Test LocaleInfo IsDefaultLocale function
177  * @tc.type: FUNC
178  */
179 HWTEST_F(I18NTest, I18NFuncTest010, TestSize.Level1)
180 {
181     LocaleInfo locale("zh", "Hans", "CN");
182     EXPECT_TRUE(!locale.IsDefaultLocale());
183     LocaleInfo locale2("en", "US");
184     EXPECT_TRUE(locale2.IsDefaultLocale());
185 }
186 
187 /**
188  * @tc.name: I18nFuncTest011
189  * @tc.desc: Test DateTimeFormat Constructor
190  * @tc.type: FUNC
191  */
192 HWTEST_F(I18NTest, I18NFuncTest011, TestSize.Level1)
193 {
194     LocaleInfo locale("zh", "Hans", "CN");
195     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::HOUR_MINUTE;
196     DateTimeFormat *formatter = new DateTimeFormat(pattern, locale);
197     EXPECT_TRUE(formatter != nullptr);
198     delete formatter;
199 }
200 
201 /**
202  * @tc.name: I18nFuncTest012
203  * @tc.desc: Test DateTimeFormat Init function
204  * @tc.type: FUNC
205  */
206 HWTEST_F(I18NTest, I18NFuncTest012, TestSize.Level1)
207 {
208     LocaleInfo locale("zh", "Hans", "CN");
209     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::HOUR_MINUTE;
210     DateTimeFormat formatter(pattern, locale);
211     EXPECT_TRUE(formatter.Init());
212 }
213 
214 /**
215  * @tc.name: I18nFuncTest013
216  * @tc.desc: Test DateTimeFormat Format function
217  * @tc.type: FUNC
218  */
219 HWTEST_F(I18NTest, I18NFuncTest013, TestSize.Level1)
220 {
221     LocaleInfo locale("zh", "", "");
222     std::string out = "";
223     time_t now = 3600 * 3 + 3600 * 24 * 6;
224     I18nStatus status =  I18nStatus::ISUCCESS;
225     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::FULL;
226     DateTimeFormat formatter(pattern, locale);
227     formatter.Format(now, "-1:45", out, status);
228     std::string expect = "1970年1月7日星期三";
229     EXPECT_TRUE(expect == out);
230 }
231 
232 /**
233  * @tc.name: I18nFuncTest014
234  * @tc.desc: Test DateTimeFormat Format function
235  * @tc.type: FUNC
236  */
237 HWTEST_F(I18NTest, I18NFuncTest014, TestSize.Level1)
238 {
239     LocaleInfo locale("ar", "", "");
240     std::string out = "";
241     time_t now = 3600 * 3 + 3600 * 24 * 6;
242     I18nStatus status =  I18nStatus::ISUCCESS;
243     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::FULL;
244     DateTimeFormat formatter(pattern, locale);
245     formatter.Format(now, "-1:45", out, status);
246     std::string expect = "الأربعاء، ٧ يناير، ١٩٧٠";
247     EXPECT_TRUE(expect == out);
248 }
249 
250 /**
251  * @tc.name: I18nFuncTest015
252  * @tc.desc: Test DateTimeFormat Format function
253  * @tc.type: FUNC
254  */
255 HWTEST_F(I18NTest, I18NFuncTest015, TestSize.Level1)
256 {
257     LocaleInfo locale("en", "", "US");
258     std::string out = "";
259     time_t now = 3600 * 3 + 3600 * 24 * 6;
260     I18nStatus status =  I18nStatus::ISUCCESS;
261     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::FULL;
262     DateTimeFormat formatter(pattern, locale);
263     formatter.Format(now, "-1:45", out, status);
264     std::string expect = "Wednesday, January 7, 1970";
265     EXPECT_TRUE(expect == out);
266 }
267 
268 /**
269  * @tc.name: I18nFuncTest016
270  * @tc.desc: Test DateTimeFormat ApplyPattern function
271  * @tc.type: FUNC
272  */
273 HWTEST_F(I18NTest, I18NFuncTest016, TestSize.Level1)
274 {
275     LocaleInfo locale("zh", "", "");
276     std::string out = "";
277     time_t now = 3600 * 3 + 3600 * 24 * 6;
278     I18nStatus status =  I18nStatus::ISUCCESS;
279     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::SHORT;
280     DateTimeFormat formatter(pattern, locale);
281     formatter.ApplyPattern(AvailableDateTimeFormatPattern::FULL);
282     formatter.Format(now, "-1:45", out, status);
283     std::string expect = "1970年1月7日星期三";
284     EXPECT_TRUE(expect == out);
285 }
286 
287 /**
288  * @tc.name: I18nFuncTest017
289  * @tc.desc: Test DateTimeFormat ApplyPattern function
290  * @tc.type: FUNC
291  */
292 HWTEST_F(I18NTest, I18NFuncTest017, TestSize.Level1)
293 {
294     LocaleInfo locale("ar", "", "");
295     std::string out = "";
296     time_t now = 3600 * 3 + 3600 * 24 * 6;
297     I18nStatus status =  I18nStatus::ISUCCESS;
298     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::SHORT;
299     DateTimeFormat formatter(pattern, locale);
300     formatter.ApplyPattern(AvailableDateTimeFormatPattern::FULL);
301     formatter.Format(now, "-1:45", out, status);
302     std::string expect = "الأربعاء، ٧ يناير، ١٩٧٠";
303     EXPECT_TRUE(expect == out);
304 }
305 
306 /**
307  * @tc.name: I18nFuncTest018
308  * @tc.desc: Test DateTimeFormat ApplyPattern function
309  * @tc.type: FUNC
310  */
311 HWTEST_F(I18NTest, I18NFuncTest018, TestSize.Level1)
312 {
313     LocaleInfo locale("en", "", "US");
314     std::string out = "";
315     time_t now = 3600 * 3 + 3600 * 24 * 6;
316     I18nStatus status =  I18nStatus::ISUCCESS;
317     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::SHORT;
318     DateTimeFormat formatter(pattern, locale);
319     formatter.ApplyPattern(AvailableDateTimeFormatPattern::FULL);
320     formatter.Format(now, "-1:45", out, status);
321     std::string expect = "Wednesday, January 7, 1970";
322     EXPECT_TRUE(expect == out);
323 }
324 
325 /**
326  * @tc.name: I18nFuncTest019
327  * @tc.desc: Test DateTimeFormat GetWeekName
328  * @tc.type: FUNC
329  */
330 HWTEST_F(I18NTest, I18NFuncTest019, TestSize.Level1)
331 {
332     LocaleInfo locale("zh", "", "CN");
333     std::string weekDays[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
334     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::SHORT;
335     DateTimeFormat formatter(pattern, locale);
336     for (int i = 0; i < 7; ++i) {
337         std::string out = formatter.GetWeekName(i, DateTimeDataType::FORMAT_WIDE);
338         EXPECT_TRUE(weekDays[i] == out);
339     }
340 }
341 
342 /**
343  * @tc.name: I18nFuncTest020
344  * @tc.desc: Test DateTimeFormat GetMonthName
345  * @tc.type: FUNC
346  */
347 HWTEST_F(I18NTest, I18NFuncTest020, TestSize.Level1)
348 {
349     LocaleInfo locale("en", "", "US");
350     std::string months[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September",
351         "October", "November", "December" };
352     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::SHORT;
353     DateTimeFormat formatter(pattern, locale);
354     for (int i = 0; i < 12; ++i) {
355         std::string out = formatter.GetMonthName(i, DateTimeDataType::FORMAT_WIDE);
356         EXPECT_TRUE(months[i] == out);
357     }
358 }
359 
360 /**
361  * @tc.name: I18nFuncTest021
362  * @tc.desc: Test numberFormat format integer
363  * @tc.type: FUNC
364  */
365 HWTEST_F(I18NTest, I18NFuncTest021, TestSize.Level1)
366 {
367     LocaleInfo locale("am", "", "");
368     int status =  0;
369     NumberFormat formatter(locale, status);
370     EXPECT_TRUE(status == 0);
371     int intNum1 = 1234567;
372     int intNum2 = 123456789;
373     int intNum3 = 1234;
374     std::string out = formatter.Format(intNum1, status);
375     std::string out2 = formatter.Format(intNum2, status);
376     std::string out3 = formatter.Format(intNum3, status);
377     EXPECT_TRUE(out == "1,234,567");
378     EXPECT_TRUE(out2 == "123,456,789");
379     EXPECT_TRUE(out3 == "1,234");
380 }
381 
382 /**
383  * @tc.name: I18nFuncTest022
384  * @tc.desc: Test numberFormat format no group integer
385  * @tc.type: FUNC
386  */
387 HWTEST_F(I18NTest, I18NFuncTest022, TestSize.Level1)
388 {
389     LocaleInfo locale("am", "", "");
390     int  status =  0;
391     NumberFormat formatter(locale, status);
392     EXPECT_TRUE(status == 0);
393     int intNum1 = 1234567;
394     int intNum2 = 123456789;
395     int intNum3 = 1234;
396     std::string out = formatter.FormatNoGroup(intNum1, status);
397     std::string out2 = formatter.FormatNoGroup(intNum2, status);
398     std::string out3 = formatter.FormatNoGroup(intNum3, status);
399     EXPECT_TRUE(out == "1234567");
400     EXPECT_TRUE(out2 == "123456789");
401     EXPECT_TRUE(out3 == "1234");
402 }
403 
404 /**
405  * @tc.name: I18nFuncTest023
406  * @tc.desc: Test numberFormat format double
407  * @tc.type: FUNC
408  */
409 HWTEST_F(I18NTest, I18NFuncTest023, TestSize.Level1)
410 {
411     LocaleInfo locale("am", "", "");
412     int status =  0;
413     NumberFormat formatter(locale, status);
414     EXPECT_TRUE(status == 0);
415     double doubleNum1 = 1234567.567;
416     double doubleNum2 = 1.23456789567E8;
417     double doubleNum3 = 1234.0;
418     std::string out = formatter.Format(doubleNum1, NumberFormatType::DECIMAL, status);
419     std::string out2 = formatter.Format(doubleNum2, NumberFormatType::DECIMAL, status);
420     std::string out3 = formatter.Format(doubleNum3, NumberFormatType::DECIMAL, status);
421     EXPECT_TRUE(out == "1,234,567.567");
422     EXPECT_TRUE(out2 == "123,456,789.567");
423     EXPECT_TRUE(out3 == "1,234");
424 }
425 
426 /**
427  * @tc.name: I18nFuncTest024
428  * @tc.desc: Test numberFormat format no group double
429  * @tc.type: FUNC
430  */
431 HWTEST_F(I18NTest, I18NFuncTest024, TestSize.Level1)
432 {
433     LocaleInfo locale("am", "", "");
434     int status =  0;
435     NumberFormat formatter(locale, status);
436     EXPECT_TRUE(status == 0);
437     double doubleNum1 = 1234567.567;
438     double doubleNum2 = 1.23456789567E8;
439     double doubleNum3 = 1234.0;
440     std::string out = formatter.FormatNoGroup(doubleNum1, NumberFormatType::DECIMAL, status);
441     std::string out2 = formatter.FormatNoGroup(doubleNum2, NumberFormatType::DECIMAL, status);
442     std::string out3 = formatter.FormatNoGroup(doubleNum3, NumberFormatType::DECIMAL, status);
443     EXPECT_TRUE(out == "1234567.567");
444     EXPECT_TRUE(out2 == "123456789.567");
445     EXPECT_TRUE(out3 == "1234");
446 }
447 
448 /**
449  * @tc.name: I18nFuncTest025
450  * @tc.desc: Test numberFormat format SetMaxDecimalLength;
451  * @tc.type: FUNC
452  */
453 HWTEST_F(I18NTest, I18NFuncTest025, TestSize.Level1)
454 {
455     LocaleInfo locale("am", "", "");
456     int status = 0;
457     NumberFormat formatter(locale, status);
458     EXPECT_TRUE(status == 0);
459     double doubleNum1 = 1234567.567;
460     double doubleNum2 = 1.23456789567E8;
461     double doubleNum3 = 1234.0;
462     formatter.SetMaxDecimalLength(1);
463     std::string out = formatter.FormatNoGroup(doubleNum1, NumberFormatType::DECIMAL, status);
464     std::string out2 = formatter.FormatNoGroup(doubleNum2, NumberFormatType::DECIMAL, status);
465     std::string out3 = formatter.FormatNoGroup(doubleNum3, NumberFormatType::DECIMAL, status);
466     EXPECT_TRUE(out == "1234567.6");
467     EXPECT_TRUE(out2 == "123456789.6");
468     EXPECT_TRUE(out3 == "1234");
469 }
470 
471 /**
472  * @tc.name: I18nFuncTest026
473  * @tc.desc: Test numberFormat format SetMinDecimalLength;
474  * @tc.type: FUNC
475  */
476 HWTEST_F(I18NTest, I18NFuncTest026, TestSize.Level1)
477 {
478     LocaleInfo locale("am", "", "");
479     int status =  0;
480     NumberFormat formatter(locale, status);
481     EXPECT_TRUE(status == 0);
482     double doubleNum1 = 1234567.56;
483     double doubleNum2 = 1.2;
484     double doubleNum3 = 1234.0;
485     formatter.SetMinDecimalLength(3);
486     std::string out = formatter.FormatNoGroup(doubleNum1, NumberFormatType::DECIMAL, status);
487     std::string out2 = formatter.FormatNoGroup(doubleNum2, NumberFormatType::DECIMAL, status);
488     std::string out3 = formatter.FormatNoGroup(doubleNum3, NumberFormatType::DECIMAL, status);
489     EXPECT_TRUE(out == "1234567.560");
490     EXPECT_TRUE(out2 == "1.200");
491     EXPECT_TRUE(out3 == "1234.000");
492 }
493 
494 /**
495  * @tc.name: I18nFuncTest027
496  * @tc.desc: Test numberFormat format percent;
497  * @tc.type: FUNC
498  */
499 HWTEST_F(I18NTest, I18NFuncTest027, TestSize.Level1)
500 {
501     LocaleInfo locale("am", "", "");
502     int status = 0;
503     NumberFormat formatter(locale, status);
504     EXPECT_TRUE(status == 0);
505     double percentNum1 = 0.1234;
506     double percentNum2 = 0.123456;
507     std::string out = formatter.Format(percentNum1, NumberFormatType::PERCENT, status);
508     std::string out2 = formatter.Format(percentNum2, NumberFormatType::PERCENT, status);
509     EXPECT_TRUE(out == "12%");
510     EXPECT_TRUE(out2 == "12%");
511 }
512 /**
513  * @tc.name: I18nFuncTest028
514  * @tc.desc: Test NumberFormat Format function
515  * @tc.type: FUNC
516  */
517 HWTEST_F(I18NTest, I18NFuncTest0028, TestSize.Level1)
518 {
519     LocaleInfo locale("zh", "", "");
520     int status = 0;
521     NumberFormat formatter(locale, status);
522     std::string out = formatter.Format(1234567, status);
523     std::string expect = "1,234,567";
524     EXPECT_TRUE(expect == out);
525 }
526 
527 /**
528  * @tc.name: I18nFuncTest029
529  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
530  * @tc.type: FUNC
531  */
532 HWTEST_F(I18NTest, I18nFuncTest029, TestSize.Level1)
533 {
534     LocaleInfo locale("am", "", "");
535     I18nStatus status = I18nStatus::ISUCCESS;
536     PluralFormat formatter(locale, status);
537     int out = formatter.GetPluralRuleIndex(0, status);
538     int expect = PluralRuleType::ONE;
539     EXPECT_TRUE(expect == out);
540     out = formatter.GetPluralRuleIndex(1, status);
541     expect = PluralRuleType::ONE;
542     EXPECT_TRUE(expect == out);
543     out = formatter.GetPluralRuleIndex(2, status);
544     expect = PluralRuleType::OTHER;
545     EXPECT_TRUE(expect == out);
546     out = formatter.GetPluralRuleIndex(17, status);
547     expect = PluralRuleType::OTHER;
548     EXPECT_TRUE(expect == out);
549     out = formatter.GetPluralRuleIndex(100, status);
550     expect = PluralRuleType::OTHER;
551     EXPECT_TRUE(expect == out);
552     out = formatter.GetPluralRuleIndex(1000, status);
553     expect = PluralRuleType::OTHER;
554     EXPECT_TRUE(expect == out);
555     out = formatter.GetPluralRuleIndex(10000, status);
556     expect = PluralRuleType::OTHER;
557     EXPECT_TRUE(expect == out);
558     out = formatter.GetPluralRuleIndex(100000, status);
559     expect = PluralRuleType::OTHER;
560     EXPECT_TRUE(expect == out);
561     out = formatter.GetPluralRuleIndex(1000000, status);
562     expect = PluralRuleType::OTHER;
563     EXPECT_TRUE(expect == out);
564 }
565 
566 /**
567  * @tc.name: I18nFuncTest030
568  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
569  * @tc.type: FUNC
570  */
571 HWTEST_F(I18NTest, I18nFuncTest030, TestSize.Level1)
572 {
573     LocaleInfo locale("ar", "", "");
574     I18nStatus status = I18nStatus::ISUCCESS;
575     PluralFormat formatter(locale, status);
576     int out = formatter.GetPluralRuleIndex(3, status);
577     int expect = PluralRuleType::FEW;
578     EXPECT_TRUE(expect == out);
579     out = formatter.GetPluralRuleIndex(10, status);
580     expect = PluralRuleType::FEW;
581     EXPECT_TRUE(expect == out);
582     out = formatter.GetPluralRuleIndex(11, status);
583     expect = PluralRuleType::MANY;
584     EXPECT_TRUE(expect == out);
585     out = formatter.GetPluralRuleIndex(26, status);
586     expect = PluralRuleType::MANY;
587     EXPECT_TRUE(expect == out);
588     out = formatter.GetPluralRuleIndex(1, status);
589     expect = PluralRuleType::ONE;
590     EXPECT_TRUE(expect == out);
591     out = formatter.GetPluralRuleIndex(100, status);
592     expect = PluralRuleType::OTHER;
593     EXPECT_TRUE(expect == out);
594     out = formatter.GetPluralRuleIndex(2, status);
595     expect = PluralRuleType::TWO;
596     EXPECT_TRUE(expect == out);
597     out = formatter.GetPluralRuleIndex(0, status);
598     expect = PluralRuleType::ZERO;
599     EXPECT_TRUE(expect == out);
600 }
601 
602 /**
603  * @tc.name: I18nFuncTest031
604  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
605  * @tc.type: FUNC
606  */
607 HWTEST_F(I18NTest, I18nFuncTest031, TestSize.Level1)
608 {
609     LocaleInfo locale("as", "", "");
610     I18nStatus status = I18nStatus::ISUCCESS;
611     PluralFormat formatter(locale, status);
612     int out = formatter.GetPluralRuleIndex(0, status);
613     int expect = PluralRuleType::ONE;
614     EXPECT_TRUE(expect == out);
615     out = formatter.GetPluralRuleIndex(1, status);
616     expect = PluralRuleType::ONE;
617     EXPECT_TRUE(expect == out);
618     out = formatter.GetPluralRuleIndex(2, status);
619     expect = PluralRuleType::OTHER;
620     EXPECT_TRUE(expect == out);
621 }
622 
623 /**
624  * @tc.name: I18nFuncTest032
625  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
626  * @tc.type: FUNC
627  */
628 HWTEST_F(I18NTest, I18nFuncTest032, TestSize.Level1)
629 {
630     LocaleInfo locale("az", "", "");
631     I18nStatus status = I18nStatus::ISUCCESS;
632     PluralFormat formatter(locale, status);
633     int out = formatter.GetPluralRuleIndex(1, status);
634     int expect = PluralRuleType::ONE;
635     EXPECT_TRUE(expect == out);
636     out = formatter.GetPluralRuleIndex(0, status);
637     expect = PluralRuleType::OTHER;
638     EXPECT_TRUE(expect == out);
639     out = formatter.GetPluralRuleIndex(2, status);
640     expect = PluralRuleType::OTHER;
641     EXPECT_TRUE(expect == out);
642     out = formatter.GetPluralRuleIndex(16, status);
643     expect = PluralRuleType::OTHER;
644     EXPECT_TRUE(expect == out);
645     out = formatter.GetPluralRuleIndex(100, status);
646     expect = PluralRuleType::OTHER;
647     EXPECT_TRUE(expect == out);
648 }
649 
650 /**
651  * @tc.name: I18nFuncTest033
652  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
653  * @tc.type: FUNC
654  */
655 HWTEST_F(I18NTest, I18nFuncTest033, TestSize.Level1)
656 {
657     LocaleInfo locale("be", "", "");
658     I18nStatus status = I18nStatus::ISUCCESS;
659     PluralFormat formatter(locale, status);
660     int out = formatter.GetPluralRuleIndex(2, status);
661     int expect = PluralRuleType::FEW;
662     EXPECT_TRUE(expect == out);
663     out = formatter.GetPluralRuleIndex(4, status);
664     expect = PluralRuleType::FEW;
665     EXPECT_TRUE(expect == out);
666     out = formatter.GetPluralRuleIndex(0, status);
667     expect = PluralRuleType::MANY;
668     EXPECT_TRUE(expect == out);
669     out = formatter.GetPluralRuleIndex(5, status);
670     expect = PluralRuleType::MANY;
671     EXPECT_TRUE(expect == out);
672     out = formatter.GetPluralRuleIndex(19, status);
673     expect = PluralRuleType::MANY;
674     EXPECT_TRUE(expect == out);
675     out = formatter.GetPluralRuleIndex(1, status);
676     expect = PluralRuleType::ONE;
677     EXPECT_TRUE(expect == out);
678     out = formatter.GetPluralRuleIndex(21, status);
679     expect = PluralRuleType::ONE;
680     EXPECT_TRUE(expect == out);
681 }
682 
683 /**
684  * @tc.name: I18nFuncTest034
685  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
686  * @tc.type: FUNC
687  */
688 HWTEST_F(I18NTest, I18nFuncTest034, TestSize.Level1)
689 {
690     LocaleInfo locale("bg", "", "");
691     I18nStatus status = I18nStatus::ISUCCESS;
692     PluralFormat formatter(locale, status);
693     int out = formatter.GetPluralRuleIndex(1, status);
694     int expect = PluralRuleType::ONE;
695     EXPECT_TRUE(expect == out);
696     out = formatter.GetPluralRuleIndex(0, status);
697     expect = PluralRuleType::OTHER;
698     EXPECT_TRUE(expect == out);
699     out = formatter.GetPluralRuleIndex(2, status);
700     expect = PluralRuleType::OTHER;
701     EXPECT_TRUE(expect == out);
702     out = formatter.GetPluralRuleIndex(16, status);
703     expect = PluralRuleType::OTHER;
704     EXPECT_TRUE(expect == out);
705     out = formatter.GetPluralRuleIndex(100, status);
706     expect = PluralRuleType::OTHER;
707     EXPECT_TRUE(expect == out);
708     out = formatter.GetPluralRuleIndex(1000, status);
709     expect = PluralRuleType::OTHER;
710     EXPECT_TRUE(expect == out);
711     out = formatter.GetPluralRuleIndex(10000, status);
712     expect = PluralRuleType::OTHER;
713     EXPECT_TRUE(expect == out);
714     out = formatter.GetPluralRuleIndex(100000, status);
715     expect = PluralRuleType::OTHER;
716     EXPECT_TRUE(expect == out);
717     out = formatter.GetPluralRuleIndex(1000000, status);
718     expect = PluralRuleType::OTHER;
719     EXPECT_TRUE(expect == out);
720 }
721 
722 /**
723  * @tc.name: I18nFuncTest035
724  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
725  * @tc.type: FUNC
726  */
727 HWTEST_F(I18NTest, I18nFuncTest035, TestSize.Level1)
728 {
729     LocaleInfo locale("bn", "", "");
730     I18nStatus status = I18nStatus::ISUCCESS;
731     PluralFormat formatter(locale, status);
732     int out = formatter.GetPluralRuleIndex(0, status);
733     int expect = PluralRuleType::ONE;
734     EXPECT_TRUE(expect == out);
735     out = formatter.GetPluralRuleIndex(1, status);
736     expect = PluralRuleType::ONE;
737     EXPECT_TRUE(expect == out);
738     out = formatter.GetPluralRuleIndex(2, status);
739     expect = PluralRuleType::OTHER;
740     EXPECT_TRUE(expect == out);
741     out = formatter.GetPluralRuleIndex(17, status);
742     expect = PluralRuleType::OTHER;
743     EXPECT_TRUE(expect == out);
744     out = formatter.GetPluralRuleIndex(100, status);
745     expect = PluralRuleType::OTHER;
746     EXPECT_TRUE(expect == out);
747     out = formatter.GetPluralRuleIndex(1000, status);
748     expect = PluralRuleType::OTHER;
749     EXPECT_TRUE(expect == out);
750     out = formatter.GetPluralRuleIndex(10000, status);
751     expect = PluralRuleType::OTHER;
752     EXPECT_TRUE(expect == out);
753     out = formatter.GetPluralRuleIndex(100000, status);
754     expect = PluralRuleType::OTHER;
755     EXPECT_TRUE(expect == out);
756     out = formatter.GetPluralRuleIndex(1000000, status);
757     expect = PluralRuleType::OTHER;
758     EXPECT_TRUE(expect == out);
759 }
760 
761 /**
762  * @tc.name: I18nFuncTest036
763  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
764  * @tc.type: FUNC
765  */
766 HWTEST_F(I18NTest, I18nFuncTest036, TestSize.Level1)
767 {
768     LocaleInfo locale("bo", "", "");
769     I18nStatus status = I18nStatus::ISUCCESS;
770     PluralFormat formatter(locale, status);
771     int out = formatter.GetPluralRuleIndex(0, status);
772     int expect = PluralRuleType::OTHER;
773     EXPECT_TRUE(expect == out);
774     out = formatter.GetPluralRuleIndex(15, status);
775     expect = PluralRuleType::OTHER;
776     EXPECT_TRUE(expect == out);
777     out = formatter.GetPluralRuleIndex(100, status);
778     expect = PluralRuleType::OTHER;
779     EXPECT_TRUE(expect == out);
780     out = formatter.GetPluralRuleIndex(1000, status);
781     expect = PluralRuleType::OTHER;
782     EXPECT_TRUE(expect == out);
783     out = formatter.GetPluralRuleIndex(10000, status);
784     expect = PluralRuleType::OTHER;
785     EXPECT_TRUE(expect == out);
786     out = formatter.GetPluralRuleIndex(100000, status);
787     expect = PluralRuleType::OTHER;
788     EXPECT_TRUE(expect == out);
789     out = formatter.GetPluralRuleIndex(1000000, status);
790     expect = PluralRuleType::OTHER;
791     EXPECT_TRUE(expect == out);
792 }
793 
794 /**
795  * @tc.name: I18nFuncTest037
796  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
797  * @tc.type: FUNC
798  */
799 HWTEST_F(I18NTest, I18nFuncTest037, TestSize.Level1)
800 {
801     LocaleInfo locale("bs", "", "");
802     I18nStatus status = I18nStatus::ISUCCESS;
803     PluralFormat formatter(locale, status);
804     int out = formatter.GetPluralRuleIndex(2, status);
805     int expect = PluralRuleType::FEW;
806     EXPECT_TRUE(expect == out);
807     out = formatter.GetPluralRuleIndex(4, status);
808     expect = PluralRuleType::FEW;
809     EXPECT_TRUE(expect == out);
810     out = formatter.GetPluralRuleIndex(22, status);
811     expect = PluralRuleType::FEW;
812     EXPECT_TRUE(expect == out);
813     out = formatter.GetPluralRuleIndex(1, status);
814     expect = PluralRuleType::ONE;
815     EXPECT_TRUE(expect == out);
816     out = formatter.GetPluralRuleIndex(21, status);
817     expect = PluralRuleType::ONE;
818     EXPECT_TRUE(expect == out);
819     out = formatter.GetPluralRuleIndex(0, status);
820     expect = PluralRuleType::OTHER;
821     EXPECT_TRUE(expect == out);
822 }
823 
824 /**
825  * @tc.name: I18nFuncTest038
826  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
827  * @tc.type: FUNC
828  */
829 HWTEST_F(I18NTest, I18nFuncTest038, TestSize.Level1)
830 {
831     LocaleInfo locale("ca", "", "");
832     I18nStatus status = I18nStatus::ISUCCESS;
833     PluralFormat formatter(locale, status);
834     int out = formatter.GetPluralRuleIndex(1, status);
835     int expect = PluralRuleType::ONE;
836     EXPECT_TRUE(expect == out);
837     out = formatter.GetPluralRuleIndex(0, status);
838     expect = PluralRuleType::OTHER;
839     EXPECT_TRUE(expect == out);
840 }
841 
842 /**
843  * @tc.name: I18nFuncTest039
844  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
845  * @tc.type: FUNC
846  */
847 HWTEST_F(I18NTest, I18nFuncTest039, TestSize.Level1)
848 {
849     LocaleInfo locale("cs", "", "");
850     I18nStatus status = I18nStatus::ISUCCESS;
851     PluralFormat formatter(locale, status);
852     int out = formatter.GetPluralRuleIndex(2, status);
853     int expect = PluralRuleType::FEW;
854     EXPECT_TRUE(expect == out);
855     out = formatter.GetPluralRuleIndex(4, status);
856     expect = PluralRuleType::FEW;
857     EXPECT_TRUE(expect == out);
858     out = formatter.GetPluralRuleIndex(1, status);
859     expect = PluralRuleType::ONE;
860     EXPECT_TRUE(expect == out);
861     out = formatter.GetPluralRuleIndex(0, status);
862     expect = PluralRuleType::OTHER;
863     EXPECT_TRUE(expect == out);
864 }
865 
866 /**
867  * @tc.name: I18nFuncTest040
868  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
869  * @tc.type: FUNC
870  */
871 HWTEST_F(I18NTest, I18nFuncTest040, TestSize.Level1)
872 {
873     LocaleInfo locale("da", "", "");
874     I18nStatus status = I18nStatus::ISUCCESS;
875     PluralFormat formatter(locale, status);
876     int out = formatter.GetPluralRuleIndex(1, status);
877     int expect = PluralRuleType::ONE;
878     EXPECT_TRUE(expect == out);
879     out = formatter.GetPluralRuleIndex(0, status);
880     expect = PluralRuleType::OTHER;
881     EXPECT_TRUE(expect == out);
882 }
883 
884 /**
885  * @tc.name: I18nFuncTest041
886  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
887  * @tc.type: FUNC
888  */
889 HWTEST_F(I18NTest, I18nFuncTest041, TestSize.Level1)
890 {
891     LocaleInfo locale("de", "", "");
892     I18nStatus status = I18nStatus::ISUCCESS;
893     PluralFormat formatter(locale, status);
894     int out = formatter.GetPluralRuleIndex(1, status);
895     int expect = PluralRuleType::ONE;
896     EXPECT_TRUE(expect == out);
897     out = formatter.GetPluralRuleIndex(0, status);
898     expect = PluralRuleType::OTHER;
899     EXPECT_TRUE(expect == out);
900     out = formatter.GetPluralRuleIndex(1000000, status);
901     expect = PluralRuleType::OTHER;
902     EXPECT_TRUE(expect == out);
903 }
904 
905 /**
906  * @tc.name: I18nFuncTest042
907  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
908  * @tc.type: FUNC
909  */
910 HWTEST_F(I18NTest, I18nFuncTest042, TestSize.Level1)
911 {
912     LocaleInfo locale("el", "", "");
913     I18nStatus status = I18nStatus::ISUCCESS;
914     PluralFormat formatter(locale, status);
915     int out = formatter.GetPluralRuleIndex(1, status);
916     int expect = PluralRuleType::ONE;
917     EXPECT_TRUE(expect == out);
918     out = formatter.GetPluralRuleIndex(100, status);
919     expect = PluralRuleType::OTHER;
920     EXPECT_TRUE(expect == out);
921 }
922 
923 /**
924  * @tc.name: I18nFuncTest043
925  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
926  * @tc.type: FUNC
927  */
928 HWTEST_F(I18NTest, I18nFuncTest043, TestSize.Level1)
929 {
930     LocaleInfo locale("en", "", "");
931     I18nStatus status = I18nStatus::ISUCCESS;
932     PluralFormat formatter(locale, status);
933     int out = formatter.GetPluralRuleIndex(1, status);
934     int expect = PluralRuleType::ONE;
935     EXPECT_TRUE(expect == out);
936     out = formatter.GetPluralRuleIndex(16, status);
937     expect = PluralRuleType::OTHER;
938     EXPECT_TRUE(expect == out);
939 }
940 
941 /**
942  * @tc.name: I18nFuncTest044
943  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
944  * @tc.type: FUNC
945  */
946 HWTEST_F(I18NTest, I18nFuncTest044, TestSize.Level1)
947 {
948     LocaleInfo locale("es", "", "");
949     I18nStatus status = I18nStatus::ISUCCESS;
950     PluralFormat formatter(locale, status);
951     int out = formatter.GetPluralRuleIndex(1, status);
952     int expect = PluralRuleType::ONE;
953     EXPECT_TRUE(expect == out);
954     out = formatter.GetPluralRuleIndex(0, status);
955     expect = PluralRuleType::OTHER;
956     EXPECT_TRUE(expect == out);
957     out = formatter.GetPluralRuleIndex(2, status);
958     expect = PluralRuleType::OTHER;
959     EXPECT_TRUE(expect == out);
960 }
961 
962 /**
963  * @tc.name: I18nFuncTest045
964  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
965  * @tc.type: FUNC
966  */
967 HWTEST_F(I18NTest, I18nFuncTest045, TestSize.Level1)
968 {
969     LocaleInfo locale("et", "", "");
970     I18nStatus status = I18nStatus::ISUCCESS;
971     PluralFormat formatter(locale, status);
972     int out = formatter.GetPluralRuleIndex(1, status);
973     int expect = PluralRuleType::ONE;
974     EXPECT_TRUE(expect == out);
975     out = formatter.GetPluralRuleIndex(2, status);
976     expect = PluralRuleType::OTHER;
977     EXPECT_TRUE(expect == out);
978     out = formatter.GetPluralRuleIndex(100000, status);
979     expect = PluralRuleType::OTHER;
980     EXPECT_TRUE(expect == out);
981 }
982 
983 /**
984  * @tc.name: I18nFuncTest046
985  * @tc.desc: Test NumberFormat Format percent
986  * @tc.type: FUNC
987  */
988 HWTEST_F(I18NTest, I18nFuncTest046, TestSize.Level1)
989 {
990     LocaleInfo locale("de", "DE");
991     int status = I18nStatus::ISUCCESS;
992     NumberFormat format(locale, status);
993     std::string out = format.Format(0.12, NumberFormatType::PERCENT, status);
994     std::string expect = "12 %";
995     EXPECT_TRUE(expect == out);
996 }
997 
998 /**
999  * @tc.name: I18nFuncTest047
1000  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
1001  * @tc.type: FUNC
1002  */
1003 HWTEST_F(I18NTest, I18nFuncTest047, TestSize.Level1)
1004 {
1005     LocaleInfo locale("lv", "", "");
1006     I18nStatus status = I18nStatus::ISUCCESS;
1007     PluralFormat formatter(locale, status);
1008     double number = 2.1;
1009     int out = formatter.GetPluralRuleIndex(number, status);
1010     int expect = PluralRuleType::ONE;
1011     EXPECT_TRUE(expect == out);
1012     number = 10.0;
1013     out = formatter.GetPluralRuleIndex(number, status);
1014     expect = PluralRuleType::ZERO;
1015     EXPECT_TRUE(expect == out);
1016     number = 100.2;
1017     out = formatter.GetPluralRuleIndex(number, status);
1018     expect = PluralRuleType::OTHER;
1019     EXPECT_TRUE(expect == out);
1020 }
1021 
1022 /**
1023  * @tc.name: I18nFuncTest048
1024  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
1025  * @tc.type: FUNC
1026  */
1027 HWTEST_F(I18NTest, I18nFuncTest048, TestSize.Level1)
1028 {
1029     LocaleInfo locale("hr", "", "");
1030     I18nStatus status = I18nStatus::ISUCCESS;
1031     PluralFormat formatter(locale, status);
1032     double number = 2.3;
1033     int out = formatter.GetPluralRuleIndex(number, status);
1034     int expect = PluralRuleType::FEW;
1035     EXPECT_TRUE(expect == out);
1036     number = 10.1;
1037     out = formatter.GetPluralRuleIndex(number, status);
1038     expect = PluralRuleType::ONE;
1039     EXPECT_TRUE(expect == out);
1040     number = 1.5;
1041     out = formatter.GetPluralRuleIndex(number, status);
1042     expect = PluralRuleType::OTHER;
1043     EXPECT_TRUE(expect == out);
1044 }
1045 
1046 /**
1047  * @tc.name: I18nFuncTest049
1048  * @tc.desc: Test LocaleInfo ForLanguageTag
1049  * @tc.type: FUNC
1050  */
1051 HWTEST_F(I18NTest, I18nFuncTest049, TestSize.Level1)
1052 {
1053     I18nStatus status = I18nStatus::ISUCCESS;
1054     LocaleInfo locale = LocaleInfo::ForLanguageTag("zh-Hant-CN-u-nu-arab", status);
1055     EXPECT_TRUE(status == I18nStatus::ISUCCESS);
1056 }
1057 
1058 /**
1059  * @tc.name: I18nFuncTest050
1060  * @tc.desc: Test LocaleInfo GetExtension
1061  * @tc.type: FUNC
1062  */
1063 HWTEST_F(I18NTest, I18nFuncTest050, TestSize.Level1)
1064 {
1065     I18nStatus status = I18nStatus::ISUCCESS;
1066     LocaleInfo locale = LocaleInfo::ForLanguageTag("zh-Hant-CN-u-nu-arab", status);
1067     EXPECT_TRUE(status == I18nStatus::ISUCCESS);
1068     const char *numberDigits = locale.GetExtension("nu");
1069     EXPECT_TRUE(numberDigits != nullptr);
1070     if (numberDigits != nullptr) {
1071         EXPECT_TRUE(strcmp("arab", numberDigits) == 0);
1072     }
1073 }
1074 
1075 /**
1076  * @tc.name: I18nFuncTest051
1077  * @tc.desc: Test WeekInfo constructor;
1078  * @tc.type: FUNC
1079  */
1080 HWTEST_F(I18NTest, I18nFuncTest051, TestSize.Level1)
1081 {
1082     I18nStatus status = I18nStatus::ISUCCESS;
1083     LocaleInfo locale("zh", "CN");
1084     WeekInfo weekInfo(locale, status);
1085     EXPECT_TRUE(status == I18nStatus::ISUCCESS);
1086 }
1087 
1088 /**
1089  * @tc.name: I18nFuncTest052
1090  * @tc.desc: Test WeekInfo GetFirstDayOfWeek()
1091  * @tc.type: FUNC
1092  */
1093 HWTEST_F(I18NTest, I18nFuncTest052, TestSize.Level1)
1094 {
1095     I18nStatus status = I18nStatus::ISUCCESS;
1096     LocaleInfo locale("zh", "CN");
1097     WeekInfo weekInfo(locale, status);
1098     uint8_t ret = weekInfo.GetFirstDayOfWeek();
1099     EXPECT_TRUE(ret == 1);
1100 }
1101 
1102 /**
1103  * @tc.name: I18nFuncTest053
1104  * @tc.desc: Test WeekInfo GetMinimalDaysInFirstWeek()
1105  * @tc.type: FUNC
1106  */
1107 HWTEST_F(I18NTest, I18nFuncTest053, TestSize.Level1)
1108 {
1109     I18nStatus status = I18nStatus::ISUCCESS;
1110     LocaleInfo locale("zh", "CN");
1111     WeekInfo weekInfo(locale, status);
1112     uint8_t ret = weekInfo.GetMinimalDaysInFirstWeek();
1113     EXPECT_TRUE(ret == 1);
1114 }
1115 
1116 /**
1117  * @tc.name: I18nFuncTest054
1118  * @tc.desc: Test WeekInfo GetFirstDayOfWeekend()
1119  * @tc.type: FUNC
1120  */
1121 HWTEST_F(I18NTest, I18nFuncTest054, TestSize.Level1)
1122 {
1123     I18nStatus status = I18nStatus::ISUCCESS;
1124     LocaleInfo locale("zh", "CN");
1125     WeekInfo weekInfo(locale, status);
1126     uint8_t ret = weekInfo.GetFirstDayOfWeekend();
1127     EXPECT_TRUE(ret == 7);
1128 }
1129 
1130 /**
1131  * @tc.name: I18nFuncTest055
1132  * @tc.desc: Test WeekInfo GetLastDayOfWeekend()
1133  * @tc.type: FUNC
1134  */
1135 HWTEST_F(I18NTest, I18nFuncTest055, TestSize.Level1)
1136 {
1137     I18nStatus status = I18nStatus::ISUCCESS;
1138     LocaleInfo locale("zh", "CN");
1139     WeekInfo weekInfo(locale, status);
1140     uint8_t ret = weekInfo.GetLastDayOfWeekend();
1141     EXPECT_TRUE(ret == 1);
1142 }
1143 
1144 /**
1145  * @tc.name: I18nFuncTest056
1146  * @tc.desc: Test DateTimeFormat be
1147  * @tc.type: FUNC
1148  */
1149 HWTEST_F(I18NTest, I18nFuncTest056, TestSize.Level1)
1150 {
1151     I18nStatus status = I18nStatus::ISUCCESS;
1152     LocaleInfo locale("be", "", "");
1153     AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::ABBR_MONTH_WEEKDAY_DAY;
1154     DateTimeFormat formatter(pattern, locale);
1155     string out;
1156     formatter.Format(0, "", out, status);
1157     EXPECT_TRUE(out == "чц, 1 сту");
1158 }
1159 
1160 /**
1161  * @tc.name: I18nFuncTest057
1162  * @tc.desc: Test numberFormat be
1163  * @tc.type: FUNC
1164  */
1165 HWTEST_F(I18NTest, I18nFuncTest057, TestSize.Level1)
1166 {
1167     LocaleInfo locale("be", "", "");
1168     int status =  0;
1169     NumberFormat formatter(locale, status);
1170     EXPECT_TRUE(status == 0);
1171     int intNum1 = 1234567;
1172     int intNum2 = 123456789;
1173     int intNum3 = 1234;
1174     std::string out = formatter.Format(intNum1, status);
1175     signed char array1[] = { 49, -62, -96, 50, 51, 52, -62, -96, 53, 54, 55, 0 };
1176     string expect1(reinterpret_cast<char *>(array1));
1177     std::string out2 = formatter.Format(intNum2, status);
1178     signed char array2[] = { 49, 50, 51, -62, -96, 52, 53, 54, -62, -96, 55, 56, 57, 0 };
1179     string expect2(reinterpret_cast<char *>(array2));
1180     std::string out3 = formatter.Format(intNum3, status);
1181     signed char array3[] = { 49, -62, -96, 50, 51, 52, 0 };
1182     string expect3(reinterpret_cast<char *>(array3));
1183     EXPECT_TRUE(out == expect1);
1184     EXPECT_TRUE(out2 == expect2);
1185     EXPECT_TRUE(out3 == expect3);
1186 }
1187 
1188 /**
1189  * @tc.name: I18nFuncTest058
1190  * @tc.desc: Test PluralFormat GetPluralRuleIndex function
1191  * @tc.type: FUNC
1192  */
1193 HWTEST_F(I18NTest, I18nFuncTest058, TestSize.Level1)
1194 {
1195     LocaleInfo locale("be", "", "");
1196     I18nStatus status = I18nStatus::ISUCCESS;
1197     PluralFormat formatter(locale, status);
1198     int out = formatter.GetPluralRuleIndex(3, status);
1199     int expect = PluralRuleType::FEW;
1200     EXPECT_TRUE(expect == out);
1201     out = formatter.GetPluralRuleIndex(10, status);
1202     expect = PluralRuleType::MANY;
1203     EXPECT_TRUE(expect == out);
1204     out = formatter.GetPluralRuleIndex(11, status);
1205     expect = PluralRuleType::MANY;
1206     EXPECT_TRUE(expect == out);
1207     out = formatter.GetPluralRuleIndex(26, status);
1208     expect = PluralRuleType::MANY;
1209     EXPECT_TRUE(expect == out);
1210     out = formatter.GetPluralRuleIndex(1, status);
1211     expect = PluralRuleType::ONE;
1212     EXPECT_TRUE(expect == out);
1213     out = formatter.GetPluralRuleIndex(2, status);
1214     expect = PluralRuleType::FEW;
1215     EXPECT_TRUE(expect == out);
1216     out = formatter.GetPluralRuleIndex(0, status);
1217     expect = PluralRuleType::MANY;
1218     EXPECT_TRUE(expect == out);
1219 }
1220 
1221 /**
1222  * @tc.name: I18nFuncTest059
1223  * @tc.desc: Test MeasureFormat Format function
1224  * @tc.type: FUNC
1225  * @tc.require: issueI4WKP8
1226  */
1227 HWTEST_F(I18NTest, I18nFuncTest059, TestSize.Level1)
1228 {
1229     LocaleInfo locale("en", "US");
1230     I18nStatus status = I18nStatus::ISUCCESS;
1231     MeasureFormat formatter(locale, status);
1232     std::string unit = "min";
1233 
1234     std::string expect = "12 min";
1235     std::string out = formatter.Format(12, unit, status);
1236     EXPECT_TRUE(expect.compare(out) == 0);
1237     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_SHORT);
1238     EXPECT_TRUE(expect.compare(out) == 0);
1239     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_MEDIUM);
1240     EXPECT_TRUE(expect.compare(out) == 0);
1241 
1242     expect = "12 minutes";
1243     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_LONG);
1244     EXPECT_TRUE(expect.compare(out) == 0);
1245     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_FULL);
1246     EXPECT_TRUE(expect.compare(out) == 0);
1247 
1248     expect = "1 min";
1249     out = formatter.Format(1, unit, status);
1250     EXPECT_TRUE(expect.compare(out) == 0);
1251     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_SHORT);
1252     EXPECT_TRUE(expect.compare(out) == 0);
1253     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_MEDIUM);
1254     EXPECT_TRUE(expect.compare(out) == 0);
1255 
1256     expect = "1 minute";
1257     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_LONG);
1258     EXPECT_TRUE(expect.compare(out) == 0);
1259     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_FULL);
1260     EXPECT_TRUE(expect.compare(out) == 0);
1261 }
1262 
1263 /**
1264  * @tc.name: I18nFuncTest060
1265  * @tc.desc: Test MeasureFormat Format function
1266  * @tc.type: FUNC
1267  * @tc.require: issueI4WKP8
1268  */
1269 HWTEST_F(I18NTest, I18nFuncTest060, TestSize.Level1)
1270 {
1271     LocaleInfo locale("en", "US");
1272     I18nStatus status = I18nStatus::ISUCCESS;
1273     MeasureFormat formatter(locale, status);
1274     std::string unit = "stroke";
1275 
1276     std::string expect = "12 strokes";
1277     std::string out = formatter.Format(12, unit, status);
1278     EXPECT_TRUE(expect.compare(out) == 0);
1279     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_SHORT);
1280     EXPECT_TRUE(expect.compare(out) == 0);
1281     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_MEDIUM);
1282     EXPECT_TRUE(expect.compare(out) == 0);
1283     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_LONG);
1284     EXPECT_TRUE(expect.compare(out) == 0);
1285     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_FULL);
1286     EXPECT_TRUE(expect.compare(out) == 0);
1287 
1288     expect = "1 stroke";
1289     out = formatter.Format(1, unit, status);
1290     EXPECT_TRUE(expect.compare(out) == 0);
1291     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_SHORT);
1292     EXPECT_TRUE(expect.compare(out) == 0);
1293     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_MEDIUM);
1294     EXPECT_TRUE(expect.compare(out) == 0);
1295     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_LONG);
1296     EXPECT_TRUE(expect.compare(out) == 0);
1297     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_FULL);
1298     EXPECT_TRUE(expect.compare(out) == 0);
1299 }
1300 
1301 /**
1302  * @tc.name: I18nFuncTest061
1303  * @tc.desc: Test MeasureFormat Format function
1304  * @tc.type: FUNC
1305  * @tc.require: issueI4WKP8
1306  */
1307 HWTEST_F(I18NTest, I18nFuncTest061, TestSize.Level1)
1308 {
1309     LocaleInfo locale("en", "US");
1310     I18nStatus status = I18nStatus::ISUCCESS;
1311     MeasureFormat formatter(locale, status);
1312     std::string unit = "ft";
1313 
1314     std::string expect = "12 ft";
1315     std::string out = formatter.Format(12, unit, status);
1316     EXPECT_TRUE(expect.compare(out) == 0);
1317     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_SHORT);
1318     EXPECT_TRUE(expect.compare(out) == 0);
1319     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_MEDIUM);
1320     EXPECT_TRUE(expect.compare(out) == 0);
1321     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_LONG);
1322     EXPECT_TRUE(expect.compare(out) == 0);
1323     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_FULL);
1324     EXPECT_TRUE(expect.compare(out) == 0);
1325 
1326     expect = "1 ft";
1327     out = formatter.Format(1, unit, status);
1328     EXPECT_TRUE(expect.compare(out) == 0);
1329     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_SHORT);
1330     EXPECT_TRUE(expect.compare(out) == 0);
1331     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_MEDIUM);
1332     EXPECT_TRUE(expect.compare(out) == 0);
1333     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_LONG);
1334     EXPECT_TRUE(expect.compare(out) == 0);
1335     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_FULL);
1336     EXPECT_TRUE(expect.compare(out) == 0);
1337 }
1338 
1339 /**
1340  * @tc.name: I18nFuncTest062
1341  * @tc.desc: Test MeasureFormat Format function
1342  * @tc.type: FUNC
1343  * @tc.require: issueI4WKP8
1344  */
1345 HWTEST_F(I18NTest, I18nFuncTest062, TestSize.Level1)
1346 {
1347     LocaleInfo locale("zh", "Hans", "");
1348     I18nStatus status = I18nStatus::ISUCCESS;
1349     MeasureFormat formatter(locale, status);
1350     std::string unit = "min";
1351 
1352     std::string expect = "12 分钟";
1353     std::string out = formatter.Format(12, unit, status);
1354     EXPECT_TRUE(expect.compare(out) == 0);
1355     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_SHORT);
1356     EXPECT_TRUE(expect.compare(out) == 0);
1357     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_MEDIUM);
1358     EXPECT_TRUE(expect.compare(out) == 0);
1359     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_LONG);
1360     EXPECT_TRUE(expect.compare(out) == 0);
1361     out = formatter.Format(12, unit, status, MeasureFormatType::MEASURE_FULL);
1362     EXPECT_TRUE(expect.compare(out) == 0);
1363 
1364     expect = "1 分钟";
1365     out = formatter.Format(1, unit, status);
1366     EXPECT_TRUE(expect.compare(out) == 0);
1367     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_SHORT);
1368     EXPECT_TRUE(expect.compare(out) == 0);
1369     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_MEDIUM);
1370     EXPECT_TRUE(expect.compare(out) == 0);
1371     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_LONG);
1372     EXPECT_TRUE(expect.compare(out) == 0);
1373     out = formatter.Format(1, unit, status, MeasureFormatType::MEASURE_FULL);
1374     EXPECT_TRUE(expect.compare(out) == 0);
1375 }
1376 } // namespace I18N
1377 } // namespace OHOS