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
1377 /**
1378 * @tc.name: I18NFuncTest063
1379 * @tc.desc: Test LocaleInfo copy constructor
1380 * @tc.type: FUNC
1381 */
1382 HWTEST_F(I18NTest, I18NFuncTest063, TestSize.Level1)
1383 {
1384 LocaleInfo locale("km", "KH");
1385 LocaleInfo locale2(locale);
1386 const char *language = locale2.GetLanguage();
1387 const char *region = locale2.GetRegion();
1388 EXPECT_TRUE(language != nullptr);
1389 EXPECT_TRUE(region != nullptr);
1390 if (language != nullptr) {
1391 EXPECT_TRUE(strcmp(language, "km") == 0);
1392 }
1393 if (region != nullptr) {
1394 EXPECT_TRUE(strcmp(region, "KH") == 0);
1395 }
1396 }
1397
1398 /**
1399 * @tc.name: I18NFuncTest064
1400 * @tc.desc: Test DateTimeFormat km
1401 * @tc.type: FUNC
1402 */
1403 HWTEST_F(I18NTest, I18NFuncTest064, TestSize.Level1)
1404 {
1405 I18nStatus status = I18nStatus::ISUCCESS;
1406 LocaleInfo locale("km", "", "");
1407 AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::ABBR_MONTH_WEEKDAY_DAY;
1408 DateTimeFormat formatter(pattern, locale);
1409 string out;
1410 formatter.Format(0, "", out, status);
1411 EXPECT_EQ(out, "ព្រហ 1 មករា");
1412 }
1413
1414 /**
1415 * @tc.name: I18NFuncTest065
1416 * @tc.desc: Test DateTimeFormat kk
1417 * @tc.type: FUNC
1418 */
1419 HWTEST_F(I18NTest, I18NFuncTest065, TestSize.Level1)
1420 {
1421 I18nStatus status = I18nStatus::ISUCCESS;
1422 LocaleInfo locale("kk", "", "");
1423 AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::ABBR_MONTH_WEEKDAY_DAY;
1424 DateTimeFormat formatter(pattern, locale);
1425 string out;
1426 formatter.Format(0, "", out, status);
1427 EXPECT_EQ(out, "1 Қаң., Бс");
1428 }
1429
1430 /**
1431 * @tc.name: I18NFuncTest066
1432 * @tc.desc: Test DateTimeFormat uz
1433 * @tc.type: FUNC
1434 */
1435 HWTEST_F(I18NTest, I18NFuncTest066, TestSize.Level1)
1436 {
1437 I18nStatus status = I18nStatus::ISUCCESS;
1438 LocaleInfo locale("uz", "", "");
1439 AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::ABBR_MONTH_WEEKDAY_DAY;
1440 DateTimeFormat formatter(pattern, locale);
1441 string out;
1442 formatter.Format(0, "", out, status);
1443 EXPECT_EQ(out, "Pay, 1-yan");
1444 }
1445
1446 /**
1447 * @tc.name: I18NFuncTest067
1448 * @tc.desc: Test WeekInfo GetFirstDayOfWeek
1449 * @tc.type: FUNC
1450 * @tc.require: issueI4WKP8
1451 */
1452 HWTEST_F(I18NTest, I18NFuncTest067, TestSize.Level1)
1453 {
1454 I18nStatus status = I18nStatus::ISUCCESS;
1455 LocaleInfo locale("kk", "KZ");
1456 WeekInfo weekInfo(locale, status);
1457 uint8_t ret = weekInfo.GetFirstDayOfWeek();
1458 EXPECT_EQ(ret, 2);
1459 LocaleInfo locale2("km", "KH");
1460 WeekInfo weekInfo2(locale2, status);
1461 ret = weekInfo2.GetFirstDayOfWeek();
1462 EXPECT_EQ(ret, 1);
1463 LocaleInfo locale3("uz", "UZ");
1464 WeekInfo weekInfo3(locale3, status);
1465 ret = weekInfo3.GetFirstDayOfWeek();
1466 EXPECT_EQ(ret, 2);
1467 }
1468
1469 /**
1470 * @tc.name: I18NFuncTest068
1471 * @tc.desc: Test PluralFormat Format function
1472 * @tc.type: FUNC
1473 * @tc.require: issueI4WKP8
1474 */
1475 HWTEST_F(I18NTest, I18NFuncTest068, TestSize.Level1)
1476 {
1477 LocaleInfo locale("km", "", "");
1478 I18nStatus status = I18nStatus::ISUCCESS;
1479 PluralFormat formatter(locale, status);
1480 double number = 2.3;
1481 int out = formatter.GetPluralRuleIndex(number, status);
1482 int expect = PluralRuleType::OTHER;
1483 EXPECT_EQ(expect, out);
1484 number = 10.1;
1485 out = formatter.GetPluralRuleIndex(number, status);
1486 expect = PluralRuleType::OTHER;
1487 EXPECT_EQ(expect, out);
1488 number = 1.5;
1489 out = formatter.GetPluralRuleIndex(number, status);
1490 expect = PluralRuleType::OTHER;
1491 EXPECT_EQ(expect, out);
1492 }
1493
1494 /**
1495 * @tc.name: I18NFuncTest069
1496 * @tc.desc: Test DateTimeFormat Format function
1497 * @tc.type: FUNC
1498 * @tc.require: issueI4WKP8
1499 */
1500 HWTEST_F(I18NTest, I18NFuncTest069, TestSize.Level1)
1501 {
1502 LocaleInfo locale("be", "", "");
1503 std::string out = "";
1504 time_t now = 3600 * 3 + 3600 * 24 * 6;
1505 I18nStatus status = I18nStatus::ISUCCESS;
1506 AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::FULL;
1507 DateTimeFormat formatter(pattern, locale);
1508 formatter.Format(now, "-1:45", out, status);
1509 std::string expect = "серада, 7 студзеня 1970 г.";
1510 EXPECT_EQ(expect, out);
1511 }
1512
1513 /**
1514 * @tc.name: I18NFuncTest070
1515 * @tc.desc: Test DateTimeFormat Format function
1516 * @tc.type: FUNC
1517 * @tc.require: issueI4WKP8
1518 */
1519 HWTEST_F(I18NTest, I18NFuncTest070, TestSize.Level1)
1520 {
1521 LocaleInfo locale("kk", "", "");
1522 std::string out = "";
1523 time_t now = 3600 * 3 + 3600 * 24 * 6;
1524 I18nStatus status = I18nStatus::ISUCCESS;
1525 AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::MEDIUM;
1526 DateTimeFormat formatter(pattern, locale);
1527 formatter.Format(now, "-1:45", out, status);
1528 std::string expect = "1970 ж. 7 Қаң.";
1529 EXPECT_EQ(expect, out);
1530 }
1531
1532 /**
1533 * @tc.name: I18NFuncTest071
1534 * @tc.desc: Test DateTimeFormat Format function
1535 * @tc.type: FUNC
1536 * @tc.require: issueI4WKP8
1537 */
1538 HWTEST_F(I18NTest, I18NFuncTest071, TestSize.Level1)
1539 {
1540 LocaleInfo locale("km", "", "");
1541 std::string out = "";
1542 time_t now = 3600 * 3 + 3600 * 24 * 6;
1543 I18nStatus status = I18nStatus::ISUCCESS;
1544 AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::MEDIUM;
1545 DateTimeFormat formatter(pattern, locale);
1546 formatter.Format(now, "-1:45", out, status);
1547 std::string expect = "7 មករា 1970";
1548 EXPECT_EQ(expect, out);
1549 }
1550
1551 /**
1552 * @tc.name: I18NFuncTest072
1553 * @tc.desc: Test DateTimeFormat Format function
1554 * @tc.type: FUNC
1555 * @tc.require: issueI4WKP8
1556 */
1557 HWTEST_F(I18NTest, I18NFuncTest072, TestSize.Level1)
1558 {
1559 LocaleInfo locale("uz", "", "");
1560 std::string out = "";
1561 time_t now = 3600 * 3 + 3600 * 24 * 6;
1562 I18nStatus status = I18nStatus::ISUCCESS;
1563 AvailableDateTimeFormatPattern pattern = AvailableDateTimeFormatPattern::FULL;
1564 DateTimeFormat formatter(pattern, locale);
1565 formatter.Format(now, "-1:45", out, status);
1566 std::string expect = "chorshanba, 7-yanvar, 1970";
1567 EXPECT_EQ(expect, out);
1568 }
1569
1570 /**
1571 * @tc.name: I18NFuncTest073
1572 * @tc.desc: Test numberFormat format integer
1573 * @tc.type: FUNC
1574 */
1575 HWTEST_F(I18NTest, I18NFuncTest073, TestSize.Level1)
1576 {
1577 LocaleInfo locale("be", "", "");
1578 int status = 0;
1579 NumberFormat formatter(locale, status);
1580 EXPECT_TRUE(status == 0);
1581 int intNum1 = 1234567;
1582 int intNum2 = 123456789;
1583 int intNum3 = 1234;
1584 std::string out = formatter.Format(intNum1, status);
1585 std::string out2 = formatter.Format(intNum2, status);
1586 std::string out3 = formatter.Format(intNum3, status);
1587 EXPECT_EQ(out, "1 234 567");
1588 EXPECT_EQ(out2, "123 456 789");
1589 EXPECT_EQ(out3, "1 234");
1590 }
1591
1592 /**
1593 * @tc.name: I18NFuncTest074
1594 * @tc.desc: Test numberFormat format integer
1595 * @tc.type: FUNC
1596 */
1597 HWTEST_F(I18NTest, I18NFuncTest074, TestSize.Level1)
1598 {
1599 LocaleInfo locale("km", "", "");
1600 int status = 0;
1601 NumberFormat formatter(locale, status);
1602 EXPECT_TRUE(status == 0);
1603 int intNum1 = 1234567;
1604 int intNum2 = 123456789;
1605 int intNum3 = 1234;
1606 std::string out = formatter.Format(intNum1, status);
1607 std::string out2 = formatter.Format(intNum2, status);
1608 std::string out3 = formatter.Format(intNum3, status);
1609 EXPECT_EQ(out, "1.234.567");
1610 EXPECT_EQ(out2, "123.456.789");
1611 EXPECT_EQ(out3, "1.234");
1612 }
1613
1614 /**
1615 * @tc.name: I18NFuncTest075
1616 * @tc.desc: Test numberFormat format integer
1617 * @tc.type: FUNC
1618 */
1619 HWTEST_F(I18NTest, I18NFuncTest075, TestSize.Level1)
1620 {
1621 LocaleInfo locale("kk", "", "");
1622 int status = 0;
1623 NumberFormat formatter(locale, status);
1624 EXPECT_TRUE(status == 0);
1625 int intNum1 = 1234567;
1626 int intNum2 = 123456789;
1627 int intNum3 = 1234;
1628 std::string out = formatter.Format(intNum1, status);
1629 std::string out2 = formatter.Format(intNum2, status);
1630 std::string out3 = formatter.Format(intNum3, status);
1631 EXPECT_EQ(out, "1 234 567");
1632 EXPECT_EQ(out2, "123 456 789");
1633 EXPECT_EQ(out3, "1 234");
1634 }
1635
1636 /**
1637 * @tc.name: I18NFuncTest076
1638 * @tc.desc: Test numberFormat format integer
1639 * @tc.type: FUNC
1640 */
1641 HWTEST_F(I18NTest, I18NFuncTest076, TestSize.Level1)
1642 {
1643 LocaleInfo locale("uz", "", "");
1644 int status = 0;
1645 NumberFormat formatter(locale, status);
1646 EXPECT_TRUE(status == 0);
1647 int intNum1 = 1234567;
1648 int intNum2 = 123456789;
1649 int intNum3 = 1234;
1650 std::string out = formatter.Format(intNum1, status);
1651 std::string out2 = formatter.Format(intNum2, status);
1652 std::string out3 = formatter.Format(intNum3, status);
1653 EXPECT_EQ(out, "1 234 567");
1654 EXPECT_EQ(out2, "123 456 789");
1655 EXPECT_EQ(out3, "1 234");
1656 }
1657 } // namespace I18N
1658 } // namespace OHOS