1 /*
2 * Copyright (c) 2021-2022 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 "locale_config_test.h"
17 #include <gtest/gtest.h>
18 #include "locale_config.h"
19 #include "locale_config_ext.h"
20 #include "unicode/locid.h"
21 #include "parameter.h"
22
23 using namespace OHOS::Global::I18n;
24 using testing::ext::TestSize;
25 using namespace std;
26
27 namespace OHOS {
28 namespace Global {
29 namespace I18n {
30 class LocaleConfigTest : public testing::Test {
31 public:
32 static string originalLanguage;
33 static string originalRegion;
34 static string originalLocale;
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39
40 static std::vector<std::pair<std::string, std::string>> languageAndRegion;
41 static std::vector<std::string> simplifiedLanguage;
42 };
43
44 string LocaleConfigTest::originalLanguage;
45 string LocaleConfigTest::originalRegion;
46 string LocaleConfigTest::originalLocale;
47
48 std::vector<std::pair<std::string, std::string>> LocaleConfigTest::languageAndRegion {
49 { "zh-Hans", "CN" }, { "zh-Hant", "HK" }, { "zh-Hant", "TW" }, { "en-Latn-US", "US" }, { "en-Latn-US", "GB" },
50 { "bo", "CN" }, { "ug", "CN" }, { "am", "CN" }, { "ar", "CN" }, { "as", "CN" }, { "az-Latn", "IR" },
51 { "be", "CN" }, { "bg", "CN" }, { "bn", "CN" }, { "bs-Latn", "CN" }, { "ca", "CN" }, { "cs", "CN" },
52 { "da", "CN" }, { "de", "CN" }, { "el", "CN" }, { "es-ES", "US" }, { "es-US", "ES" }, { "et", "CN" },
53 { "eu", "CN" }, { "fa", "IR" }, { "fi", "CN" }, { "tl", "CN" }, { "fr", "CN" }, { "jv-Latn", "CN" },
54 { "mai", "CN" }, { "mn-Cyrl", "CN" }, { "uz-Latn", "CN" }
55 };
56
57 std::vector<std::string> LocaleConfigTest::simplifiedLanguage {
58 "zh-Hans", "zh-Hant-HK", "zh-Hant", "en", "en-GB", "bo", "ug", "am", "ar", "as", "az-Latn", "be", "bg", "bn",
59 "bs-Latn", "ca", "cs", "da", "de", "el", "es", "es-US", "et", "eu", "fa", "fi", "tl", "fr", "jv-Latn", "mai",
60 "mn-Cyrl", "uz-Latn"
61 };
62
SetUpTestCase(void)63 void LocaleConfigTest::SetUpTestCase(void)
64 {
65 originalLanguage = LocaleConfig::GetSystemLanguage();
66 originalRegion = LocaleConfig::GetSystemRegion();
67 originalLocale = LocaleConfig::GetSystemLocale();
68 LocaleConfig::SetSystemLanguage("zh-Hans");
69 LocaleConfig::SetSystemRegion("CN");
70 LocaleConfig::SetSystemLocale("zh-Hans-CN");
71 }
72
TearDownTestCase(void)73 void LocaleConfigTest::TearDownTestCase(void)
74 {
75 LocaleConfig::SetSystemLanguage(originalLanguage);
76 LocaleConfig::SetSystemRegion(originalRegion);
77 LocaleConfig::SetSystemLocale(originalLocale);
78 }
79
SetUp(void)80 void LocaleConfigTest::SetUp(void)
81 {}
82
TearDown(void)83 void LocaleConfigTest::TearDown(void)
84 {}
85
86 /**
87 * @tc.name: LocaleConfigFuncTest001
88 * @tc.desc: Test LocaleConfig GetSystemLanguage default
89 * @tc.type: FUNC
90 */
91 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest001, TestSize.Level1)
92 {
93 int ret = SetParameter("hm.sys.language", "");
94 if (!ret) {
95 EXPECT_EQ(LocaleConfig::GetSystemLanguage(), "zh-Hans");
96 }
97 }
98
99 /**
100 * @tc.name: LocaleConfigFuncTest002
101 * @tc.desc: Test LocaleConfig GetSystemRegion default.
102 * @tc.type: FUNC
103 */
104 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest002, TestSize.Level1)
105 {
106 int ret = SetParameter("hm.sys.locale", "");
107 if (!ret) {
108 EXPECT_EQ(LocaleConfig::GetSystemRegion(), "CN");
109 }
110 }
111
112 /**
113 * @tc.name: LocaleConfigFuncTest003
114 * @tc.desc: Test LocaleConfig GetSystemLocale default
115 * @tc.type: FUNC
116 */
117 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest003, TestSize.Level1)
118 {
119 int ret = SetParameter("hm.sys.locale", "");
120 if (!ret) {
121 EXPECT_EQ(LocaleConfig::GetSystemLocale(), "zh-Hans-CN");
122 }
123 }
124
125 /**
126 * @tc.name: LocaleConfigFuncTest004
127 * @tc.desc: Test LocaleConfig SetSystemLanguage
128 * @tc.type: FUNC
129 */
130 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest004, TestSize.Level1)
131 {
132 string language = "pt-PT";
133 I18nErrorCode status = LocaleConfig::SetSystemLanguage(language);
134 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
135 LocaleConfig::SetSystemLanguage("zh-Hans");
136 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
137 LocaleConfig::SetSystemLanguage("%$=");
138 }
139
140 /**
141 * @tc.name: LocaleConfigFuncTest005
142 * @tc.desc: Test LocaleConfig SetSystemLocale
143 * @tc.type: FUNC
144 */
145 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest005, TestSize.Level1)
146 {
147 string locale = "zh-Hant-TW";
148 I18nErrorCode status = LocaleConfig::SetSystemLocale(locale);
149 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
150 status = LocaleConfig::SetSystemLocale("zh-Hans-CN");
151 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
152 }
153
154 /**
155 * @tc.name: LocaleConfigFuncTest006
156 * @tc.desc: Test LocaleConfig SetSystemRegion
157 * @tc.type: FUNC
158 */
159 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest006, TestSize.Level1)
160 {
161 string locale = "zh-Hant-TW";
162 I18nErrorCode status = LocaleConfig::SetSystemLocale(locale);
163 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
164 status = LocaleConfig::SetSystemRegion("HK");
165 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
166 status = LocaleConfig::SetSystemLocale("zh-Hans-CN");
167 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
168 status = LocaleConfig::SetSystemRegion("@*%");
169 EXPECT_EQ(status, I18nErrorCode::INVALID_REGION_TAG);
170 status = LocaleConfig::SetSystemLocale("zh-Hans-CN", 2);
171 EXPECT_NE(status, I18nErrorCode::SUCCESS);
172 status = LocaleConfig::SetSystemLocale("zh-Hans-CN", 2);
173 EXPECT_NE(status, I18nErrorCode::SUCCESS);
174 status = LocaleConfig::SetSystemLocale("ar-EG");
175 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
176 EXPECT_FALSE(LocaleConfig::GetUsingLocalDigit());
177 status = LocaleConfig::SetSystemLocale("$$@");
178 EXPECT_NE(status, I18nErrorCode::SUCCESS);
179 status = LocaleConfig::SetSystemLocale("zh-Hans-CN");
180 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
181 }
182
183 /**
184 * @tc.name: LocaleConfigFuncTest007
185 * @tc.desc: Test LocaleConfig GetSystemCountries
186 * @tc.type: FUNC
187 */
188 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest007, TestSize.Level1)
189 {
190 std::unordered_set<std::string> countries = LocaleConfig::GetSystemCountries("zh");
191 EXPECT_TRUE(countries.size() > 200);
192 }
193
194 /**
195 * @tc.name: LocaleConfigFuncTest008
196 * @tc.desc: Test LocaleConfig GetDisplayLanguage
197 * @tc.type: FUNC
198 */
199 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest008, TestSize.Level1)
200 {
201 std::string languageTag = "pt";
202 std::string localeTag = "en-US";
203 std::string displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
204 EXPECT_EQ(displayName, "Portuguese");
205
206 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
207 EXPECT_EQ(displayName, "Portuguese");
208
209 std::string fakeLocaleTag = "FakeLocaleTag";
210 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, true);
211 EXPECT_EQ(displayName, "");
212
213 std::string fakeLanguageTag = "FakeLanguageTag";
214 displayName = LocaleConfig::GetDisplayLanguage(fakeLanguageTag, localeTag, true);
215 EXPECT_EQ(displayName, "");
216
217 languageTag = "zh-Hans-CN";
218 localeTag = "en-US";
219 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
220 EXPECT_EQ(displayName, "Simplified Chinese");
221
222 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
223 EXPECT_EQ(displayName, "Simplified Chinese");
224
225 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, false);
226 EXPECT_EQ(displayName, "");
227
228 languageTag = "pt-Latn-BR";
229 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
230 EXPECT_EQ(displayName, "Portuguese (Brazil)");
231
232 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, false);
233 EXPECT_EQ(displayName, "");
234
235 languageTag = "zh";
236 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
237 EXPECT_EQ(displayName, "Chinese");
238
239 localeTag = "en-Hans";
240 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
241 EXPECT_EQ(displayName, "Chinese");
242
243 languageTag = "zh-Hans";
244 localeTag = "en-US";
245 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
246 EXPECT_EQ(displayName, "Simplified Chinese");
247
248 languageTag = "ro-MD";
249 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
250 EXPECT_EQ(displayName, "Moldavian");
251 }
252
253 /**
254 * @tc.name: LocaleConfigFuncTest009
255 * @tc.desc: Test LocaleConfig GetDisplayRegion
256 * @tc.type: FUNC
257 */
258 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest009, TestSize.Level1)
259 {
260 std::string regionTag = "JP";
261 std::string localeTag = "zh-Hans-CN";
262 std::string displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
263 EXPECT_EQ(displayName, "日本");
264
265 std::string fakeRegionTag = "XX";
266 displayName = LocaleConfig::GetDisplayRegion(fakeRegionTag, localeTag, false);
267 EXPECT_EQ(displayName, "XX");
268
269 std::string fakeLocaleTag = "FakeLocaleTag";
270 displayName = LocaleConfig::GetDisplayRegion(regionTag, fakeLocaleTag, false);
271 EXPECT_EQ(displayName, "");
272
273 localeTag = "en-Latn-US";
274 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
275 EXPECT_EQ(displayName, "Japan");
276
277 regionTag = "zh-Hans-CN";
278 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
279 EXPECT_EQ(displayName, "China");
280
281 regionTag = "HK";
282 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
283 EXPECT_EQ(displayName, "Hong Kong (China)");
284 }
285
286 /**
287 * @tc.name: LocaleConfigFuncTest010
288 * @tc.desc: Test LocaleConfig GetDisplayLanguage
289 * @tc.type: FUNC
290 */
291 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest010, TestSize.Level1)
292 {
293 std::string languageTag = "zh-Hant-HK";
294 std::string localeTag = "zh-Hant";
295 std::string displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
296 EXPECT_EQ(displayName, "繁體中文（中國香港）");
297
298 languageTag = "zh-Hant-HK";
299 localeTag = "zh-Hans";
300 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
301 EXPECT_EQ(displayName, "繁体中文（中国香港）");
302
303 languageTag = "zh-Hant-HK";
304 localeTag = "en-US";
305 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
306 EXPECT_EQ(displayName, "Traditional Chinese(Hong Kong, China)");
307 }
308
309 /**
310 * @tc.name: LocaleConfigFuncTest011
311 * @tc.desc: Test LocaleConfig GetDisplayRegion
312 * @tc.type: FUNC
313 */
314 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest011, TestSize.Level1)
315 {
316 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh", "en-US", true), "");
317 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh-Hans-CN", "en-US", true), "China");
318 }
319
320 /**
321 * @tc.name: LocaleConfigFuncTest012
322 * @tc.desc: Test LocaleConfig GetDisplayRegion
323 * @tc.type: FUNC
324 */
325 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest012, TestSize.Level1)
326 {
327 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh-Hans", "en-US", true), "");
328 }
329
330 /**
331 * @tc.name: LocaleConfigFuncTest013
332 * @tc.desc: Test LocaleConfig LocalDigit
333 * @tc.type: FUNC
334 */
335 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest013, TestSize.Level1)
336 {
337 bool current = LocaleConfig::GetUsingLocalDigit();
338 I18nErrorCode status = LocaleConfig::SetUsingLocalDigit(true);
339 EXPECT_EQ(status, I18nErrorCode::UPDATE_LOCAL_DIGIT_FAILED);
340 current = LocaleConfig::GetUsingLocalDigit();
341 EXPECT_FALSE(current);
342 }
343
344 /**
345 * @tc.name: LocaleConfigFuncTest014
346 * @tc.desc: Test LocaleConfig 24 hour clock
347 * @tc.type: FUNC
348 */
349 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest014, TestSize.Level1)
350 {
351 bool current = LocaleConfig::Is24HourClock();
352 I18nErrorCode status = LocaleConfig::Set24HourClock("true");
353 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
354 current = LocaleConfig::Is24HourClock();
355 EXPECT_TRUE(current);
356 status = LocaleConfig::Set24HourClock("abc");
357 EXPECT_EQ(status, I18nErrorCode::INVALID_24_HOUR_CLOCK_TAG);
358 LocaleConfig::Set24HourClock("");
359 LocaleConfig::Set24HourClock("false");
360 }
361
362 /**
363 * @tc.name: LocaleConfigFuncTest015
364 * @tc.desc: Test LocaleConfig valid locales
365 * @tc.type: FUNC
366 */
367 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest015, TestSize.Level1)
368 {
369 string localeTag = "zh";
370 string validLocaleTag = LocaleConfig::GetValidLocale(localeTag);
371 EXPECT_EQ(validLocaleTag, "zh");
372
373 localeTag = "zh-u-hc-h12-nu-latn-ca-chinese-co-pinyin-kf-upper-kn-true";
374 validLocaleTag = LocaleConfig::GetValidLocale(localeTag);
375 EXPECT_EQ(validLocaleTag, "zh-u-ca-chinese-co-pinyin-kn-true-kf-upper-nu-latn-hc-h12");
376 }
377
378 /**
379 * @tc.name: LocaleConfigFuncTest016
380 * @tc.desc: Test LocaleConfig isRTL
381 * @tc.type: FUNC
382 */
383 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest016, TestSize.Level1)
384 {
385 string localeTag = "zh";
386 bool isRTL = LocaleConfig::IsRTL(localeTag);
387 EXPECT_TRUE(!isRTL);
388 localeTag = "ar";
389 isRTL = LocaleConfig::IsRTL(localeTag);
390 EXPECT_TRUE(isRTL);
391 }
392
393 /**
394 * @tc.name: LocaleConfigFuncTest017
395 * @tc.desc: Test LocaleConfig isSuggested
396 * @tc.type: FUNC
397 */
398 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest017, TestSize.Level1)
399 {
400 string language = "zh";
401 bool isSuggested = LocaleConfig::IsSuggested(language);
402 EXPECT_TRUE(isSuggested);
403 string region = "CN";
404 isSuggested = LocaleConfig::IsSuggested(language, region);
405 EXPECT_TRUE(isSuggested);
406 std::string fakeLanguage = "FakeLanguage";
407 isSuggested = LocaleConfig::IsSuggested(fakeLanguage);
408 EXPECT_FALSE(isSuggested);
409 }
410
411 /**
412 * @tc.name: LocaleConfigFuncTest018
413 * @tc.desc: Test LocaleCOnfig systemRegion
414 * @tc.type: FUNC
415 */
416 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest018, TestSize.Level1)
417 {
418 string currentRegion = LocaleConfig::GetSystemRegion();
419 EXPECT_TRUE(currentRegion.length() > 0);
420 string region = "CN";
421 I18nErrorCode status = LocaleConfig::SetSystemRegion(region);
422 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
423 currentRegion = LocaleConfig::GetSystemRegion();
424 EXPECT_EQ(currentRegion, region);
425 }
426
427 /**
428 * @tc.name: LocaleConfigFuncTest019
429 * @tc.desc: Test LocaleCOnfig systemLocale
430 * @tc.type: FUNC
431 */
432 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest019, TestSize.Level1)
433 {
434 string currentLocale = LocaleConfig::GetSystemLocale();
435 EXPECT_TRUE(currentLocale.length() > 0);
436 string locale = "zh-Hans-CN";
437 I18nErrorCode status = LocaleConfig::SetSystemLocale(locale);
438 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
439 currentLocale = LocaleConfig::GetSystemLocale();
440 EXPECT_EQ(currentLocale, locale);
441 }
442
443 /**
444 * @tc.name: LocaleConfigFuncTest020
445 * @tc.desc: Test LocaleConfig systemLanguages
446 * @tc.type: FUNC
447 */
448 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest020, TestSize.Level1)
449 {
450 std::unordered_set<std::string> languages = LocaleConfig::GetSystemLanguages();
451 EXPECT_TRUE(languages.size() > 2);
452 LocaleConfig::SetSystemLocale("ur-Latn-PK");
453 LocaleConfig::SetUsingLocalDigit(true);
454 LocaleConfig::SetUsingLocalDigit(false);
455 }
456
457 /**
458 * @tc.name: LocaleConfigFuncTest021
459 * @tc.desc: Test LocaleConfig IsValidLanguage
460 * @tc.type: FUNC
461 */
462 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest021, TestSize.Level1)
463 {
464 const string language = "zh";
465 const string fakeLanguage = "010";
466 const string tag = "zh-Hans";
467 const string fakeTag = "13-Hans";
468 bool flag = LocaleConfig::IsValidLanguage(language);
469 EXPECT_TRUE(flag);
470 flag = LocaleConfig::IsValidLanguage(fakeLanguage);
471 EXPECT_TRUE(!flag);
472 flag = LocaleConfig::IsValidTag(tag);
473 EXPECT_TRUE(flag);
474 flag = LocaleConfig::IsValidTag(fakeTag);
475 EXPECT_TRUE(!flag);
476 EXPECT_FALSE(LocaleConfig::IsValidTag(""));
477 icu::Locale locale = LocaleConfigExt::GetIcuLocale(tag);
478 EXPECT_EQ(locale.getLanguage(), language);
479 }
480
481 /**
482 * @tc.name: LocaleConfigFuncTest022
483 * @tc.desc: Test LocaleConfig GetSimplifiedSystemLanguage
484 * @tc.type: FUNC
485 */
486 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest022, TestSize.Level1)
487 {
488 for (auto index = 0; index < LocaleConfigTest::languageAndRegion.size(); ++index) {
489 LocaleConfig::SetSystemLanguage(languageAndRegion[index].first);
490 LocaleConfig::SetSystemRegion(languageAndRegion[index].second);
491 std::string ret = LocaleConfig::GetSimplifiedSystemLanguage();
492 EXPECT_EQ(ret, LocaleConfigTest::simplifiedLanguage[index]);
493 }
494 }
495
496 /**
497 * @tc.name: LocaleConfigFuncTest023
498 * @tc.desc: Test LocaleConfig GetEffectiveLanguage and GetEffectiveLocale
499 * @tc.type: FUNC
500 */
501 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest023, TestSize.Level1)
502 {
503 std::string systemLanguage = LocaleConfig::GetSystemLanguage();
504 std::string systemLocale = LocaleConfig::GetSystemLocale();
505 std::string language = "zh-Hans";
506 std::string locale = "zh-Hans-CN-u-mu-celsius";
507 LocaleConfig::SetSystemLanguage(language);
508 LocaleConfig::SetSystemLocale(locale);
509 std::string effectiveLanguage = LocaleConfig::GetEffectiveLanguage();
510 std::string effectiveLocale = LocaleConfig::GetEffectiveLocale();
511 std::string systemHour = LocaleConfig::GetSystemHour();
512 EXPECT_EQ(systemHour, "false");
513 EXPECT_EQ(effectiveLanguage, "zh-Hans-CN");
514 EXPECT_EQ(effectiveLocale, "zh-Hans-CN-u-mu-celsius");
515 LocaleConfig::SetSystemLanguage(systemLanguage);
516 LocaleConfig::SetSystemLocale(systemLocale);
517 }
518
519 /**
520 * @tc.name: LocaleConfigFuncTest024
521 * @tc.desc: Test LocaleConfig Collations
522 * @tc.type: FUNC
523 */
524 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest024, TestSize.Level1)
525 {
526 std::string systemLanguage = LocaleConfig::GetSystemLanguage();
527 std::string systemLocale = LocaleConfig::GetSystemLocale();
528 LocaleConfig::SetSystemLanguage("zh-Hant");
529 LocaleConfig::SetSystemRegion("HK");
530 std::unordered_map<std::string, std::string> systemCollations;
531 I18nErrorCode errCode = LocaleConfig::GetSystemCollations(systemCollations);
532 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
533 EXPECT_TRUE(systemCollations.find("pinyin") != systemCollations.end());
534 EXPECT_TRUE(systemCollations.find("stroke") != systemCollations.end());
535 EXPECT_TRUE(systemCollations.find("zhuyin") != systemCollations.end());
536
537 std::string usingCollation;
538 errCode = LocaleConfig::GetUsingCollation(usingCollation);
539 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
540 EXPECT_EQ(usingCollation, "stroke");
541 std::string systemLocaleInstanceTag = LocaleConfig::GetSystemLocaleInstanceTag();
542 EXPECT_EQ(systemLocaleInstanceTag, "zh-Hant-HK");
543
544 LocaleConfig::SetSystemLanguage("en-Latn-US");
545 errCode = LocaleConfig::GetSystemCollations(systemCollations);
546 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
547 EXPECT_TRUE(systemCollations.find("lower") != systemCollations.end());
548 EXPECT_TRUE(systemCollations.find("upper") != systemCollations.end());
549 errCode = LocaleConfig::GetUsingCollation(usingCollation);
550 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
551 EXPECT_EQ(usingCollation, "lower");
552 systemLocaleInstanceTag = LocaleConfig::GetSystemLocaleInstanceTag();
553 EXPECT_EQ(systemLocaleInstanceTag, "en-Latn-HK");
554
555 LocaleConfig::SetSystemLanguage("zh-Hans");
556 errCode = LocaleConfig::GetSystemCollations(systemCollations);
557 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
558 EXPECT_EQ(systemCollations.size(), 0);
559 errCode = LocaleConfig::GetUsingCollation(usingCollation);
560 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
561 EXPECT_EQ(usingCollation, "");
562 systemLocaleInstanceTag = LocaleConfig::GetSystemLocaleInstanceTag();
563 EXPECT_EQ(systemLocaleInstanceTag, "zh-Hans-HK");
564 LocaleConfig::SetSystemLanguage(systemLanguage);
565 LocaleConfig::SetSystemLocale(systemLocale);
566 }
567
568 /**
569 * @tc.name: LocaleConfigFuncTest025
570 * @tc.desc: Test LocaleConfig Collations
571 * @tc.type: FUNC
572 */
573 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest025, TestSize.Level1)
574 {
575 std::string systemLanguage = LocaleConfig::GetSystemLanguage();
576 std::string systemLocale = LocaleConfig::GetSystemLocale();
577 LocaleConfig::SetSystemLanguage("zh-Hans");
578 LocaleConfig::SetSystemRegion("HK");
579 I18nErrorCode errCode = LocaleConfig::SetSystemCollation("upper");
580 EXPECT_EQ(errCode, I18nErrorCode::INVALID_PARAM);
581 std::string systemLocaleInstanceTag = LocaleConfig::GetSystemLocaleInstanceTag();
582 EXPECT_EQ(systemLocaleInstanceTag, "zh-Hans-HK");
583
584 LocaleConfig::SetSystemLanguage("zh-Hant");
585 errCode = LocaleConfig::SetSystemCollation("upper");
586 EXPECT_EQ(errCode, I18nErrorCode::INVALID_PARAM);
587 systemLocaleInstanceTag = LocaleConfig::GetSystemLocaleInstanceTag();
588 EXPECT_EQ(systemLocaleInstanceTag, "zh-Hant-HK");
589
590 errCode = LocaleConfig::SetSystemCollation("pinyin");
591 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
592 systemLocaleInstanceTag = LocaleConfig::GetSystemLocaleInstanceTag();
593 EXPECT_EQ(systemLocaleInstanceTag, "zh-Hant-HK-u-co-pinyin");
594 LocaleConfig::SetSystemLanguage(systemLanguage);
595 LocaleConfig::SetSystemLocale(systemLocale);
596 }
597
598 /**
599 * @tc.name: LocaleConfigFuncTest026
600 * @tc.desc: Test LocaleConfig numbering system
601 * @tc.type: FUNC
602 */
603 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest026, TestSize.Level1)
604 {
605 std::string systemLanguage = LocaleConfig::GetSystemLanguage();
606 std::string systemLocale = LocaleConfig::GetSystemLocale();
607 LocaleConfig::SetSystemLanguage("ur");
608 LocaleConfig::SetSystemLocale("ur-CN");
609 std::unordered_map<std::string, std::string> systemNumberingSystems;
610 I18nErrorCode errCode = LocaleConfig::GetSystemNumberingSystems(systemNumberingSystems);
611 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
612 EXPECT_TRUE(systemNumberingSystems.find("arabext") != systemNumberingSystems.end());
613 EXPECT_TRUE(systemNumberingSystems.find("latn") != systemNumberingSystems.end());
614
615 std::string usingNumberingSystem;
616 errCode = LocaleConfig::GetUsingNumberingSystem(usingNumberingSystem);
617 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
618 EXPECT_EQ(usingNumberingSystem, "latn");
619 std::string systemLocaleInstanceTag = LocaleConfig::GetSystemLocaleInstanceTag();
620 EXPECT_EQ(systemLocaleInstanceTag, "ur-CN");
621
622 errCode = LocaleConfig::SetSystemNumberingSystem("latn");
623 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
624 errCode = LocaleConfig::GetUsingNumberingSystem(usingNumberingSystem);
625 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
626 EXPECT_EQ(usingNumberingSystem, "latn");
627 systemLocaleInstanceTag = LocaleConfig::GetSystemLocaleInstanceTag();
628 EXPECT_EQ(systemLocaleInstanceTag, "ur-CN-u-nu-latn");
629
630 errCode = LocaleConfig::SetSystemNumberingSystem("arab");
631 EXPECT_EQ(errCode, I18nErrorCode::INVALID_PARAM);
632
633 LocaleConfig::SetSystemLanguage(systemLanguage);
634 LocaleConfig::SetSystemLocale(systemLocale);
635 }
636
637 /**
638 * @tc.name: LocaleConfigFuncTest027
639 * @tc.desc: Test LocaleConfig number pattern
640 * @tc.type: FUNC
641 */
642 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest027, TestSize.Level1)
643 {
644 std::string systemLanguage = LocaleConfig::GetSystemLanguage();
645 std::string systemLocale = LocaleConfig::GetSystemLocale();
646 LocaleConfig::SetSystemLanguage("zh-Hans");
647 LocaleConfig::SetSystemRegion("CN");
648 std::unordered_map<std::string, std::string> systemNumberPatterns;
649 I18nErrorCode errCode = LocaleConfig::GetSystemNumberPatterns(systemNumberPatterns);
650 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
651 EXPECT_TRUE(systemNumberPatterns.find("002c002e") != systemNumberPatterns.end());
652 EXPECT_TRUE(systemNumberPatterns.find("0000002e") != systemNumberPatterns.end());
653 EXPECT_TRUE(systemNumberPatterns.find("002e002c") != systemNumberPatterns.end());
654 EXPECT_TRUE(systemNumberPatterns.find("0000002c") != systemNumberPatterns.end());
655
656 std::string usingNumberPattern;
657 errCode = LocaleConfig::GetUsingNumberPattern(usingNumberPattern);
658 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
659 EXPECT_EQ(usingNumberPattern, "002c002e");
660
661 errCode = LocaleConfig::SetSystemNumberPattern("0000002c");
662 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
663 errCode = LocaleConfig::GetUsingNumberPattern(usingNumberPattern);
664 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
665 EXPECT_EQ(usingNumberPattern, "0000002c");
666
667 errCode = LocaleConfig::SetSystemNumberingSystem("002d002f");
668 EXPECT_EQ(errCode, I18nErrorCode::INVALID_PARAM);
669
670 LocaleConfig::SetSystemLanguage(systemLanguage);
671 LocaleConfig::SetSystemLocale(systemLocale);
672 }
673
674 /**
675 * @tc.name: LocaleConfigFuncTest028
676 * @tc.desc: Test LocaleConfig
677 * @tc.type: FUNC
678 */
679 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest028, TestSize.Level1)
680 {
681 std::string localeTag = "zh-Hans-CN-u-nu-arab-x-np-002c002e";
682 std::pair<std::string, std::string> numberPattern = LocaleConfig::GetNumberPatternFromLocale(localeTag);
683 EXPECT_EQ(numberPattern.first, ",");
684 EXPECT_EQ(numberPattern.second, ".");
685 std::string removedLocale = LocaleConfig::RemoveCustExtParam(localeTag);
686 EXPECT_EQ(removedLocale, "zh-Hans-CN-u-nu-arab");
687 removedLocale = LocaleConfig::RemoveAllExtParam(localeTag);
688 EXPECT_EQ(removedLocale, "zh-Hans-CN");
689 std::string modifiedLocale = LocaleConfig::ModifyExtParam(localeTag, "np", "0000002c", "-x-");
690 EXPECT_EQ(modifiedLocale, "zh-Hans-CN-u-nu-arab-x-np-0000002c");
691 std::string extParam = LocaleConfig::QueryExtParam(localeTag, "np", "-x-");
692 EXPECT_EQ(extParam, "002c002e");
693 std::string numberingSystemDigit = LocaleConfig::GetNumberingSystemDigit("latn");
694 EXPECT_EQ(numberingSystemDigit, "0123456789");
695 }
696
697 /**
698 * @tc.name: LocaleConfigFuncTest029
699 * @tc.desc: Test LocaleConfig
700 * @tc.type: FUNC
701 */
702 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest029, TestSize.Level1)
703 {
704 std::string systemLanguage = LocaleConfig::GetSystemLanguage();
705 std::string systemLocale = LocaleConfig::GetSystemLocale();
706
707 LocaleConfig::SetSystemLanguage("zh-Hans");
708 LocaleConfig::SetSystemLocale("zh-Hans-CN");
709 std::unordered_map<std::string, std::string> systemMeasurements;
710 I18nErrorCode errCode = LocaleConfig::GetSystemMeasurements(systemMeasurements);
711 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
712 EXPECT_TRUE(systemMeasurements.find("uksystem") != systemMeasurements.end());
713 EXPECT_TRUE(systemMeasurements.find("ussystem") != systemMeasurements.end());
714 EXPECT_TRUE(systemMeasurements.find("metric") != systemMeasurements.end());
715
716 std::string usingMeasurement;
717 errCode = LocaleConfig::GetUsingMeasurement(usingMeasurement);
718 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
719 EXPECT_EQ(usingMeasurement, "metric");
720
721 errCode = LocaleConfig::SetSystemMeasurement("uksystem");
722 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
723 errCode = LocaleConfig::GetUsingMeasurement(usingMeasurement);
724 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
725 EXPECT_EQ(usingMeasurement, "uksystem");
726
727 errCode = LocaleConfig::SetSystemMeasurement("Invalid");
728 EXPECT_EQ(errCode, I18nErrorCode::INVALID_PARAM);
729
730 std::string measurement = LocaleConfig::GetMeasurementFromLocale("zh-Hans-CN-u-ms-uksystem");
731 EXPECT_EQ(measurement, "uksystem");
732
733 LocaleConfig::SetSystemLanguage(systemLanguage);
734 LocaleConfig::SetSystemLocale(systemLocale);
735 }
736
737 /**
738 * @tc.name: LocaleConfigFuncTest030
739 * @tc.desc: Test LocaleConfig
740 * @tc.type: FUNC
741 */
742 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest030, TestSize.Level1)
743 {
744 std::string systemLanguage = LocaleConfig::GetSystemLanguage();
745 std::string systemLocale = LocaleConfig::GetSystemLocale();
746
747 LocaleConfig::SetSystemLanguage("zh-Hans");
748 LocaleConfig::SetSystemLocale("zh-Hans-CN");
749 std::unordered_map<std::string, std::string> numericalDatePatterns;
750 I18nErrorCode errCode = LocaleConfig::GetSystemNumericalDatePatterns(numericalDatePatterns);
751 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
752 EXPECT_TRUE(numericalDatePatterns.find("d/MM/y") != numericalDatePatterns.end());
753 EXPECT_TRUE(numericalDatePatterns.find("d/M/yy") != numericalDatePatterns.end());
754 EXPECT_TRUE(numericalDatePatterns.find("y-MM-d") != numericalDatePatterns.end());
755 EXPECT_TRUE(numericalDatePatterns.find("d/M/y") != numericalDatePatterns.end());
756 EXPECT_TRUE(numericalDatePatterns.find("d/MM/yy") != numericalDatePatterns.end());
757 EXPECT_TRUE(numericalDatePatterns.find("d.MM.yy") != numericalDatePatterns.end());
758 EXPECT_TRUE(numericalDatePatterns.find("yy/MM/d") != numericalDatePatterns.end());
759 EXPECT_TRUE(numericalDatePatterns.find("d.MM.y") != numericalDatePatterns.end());
760 EXPECT_TRUE(numericalDatePatterns.find("d-MM-y") != numericalDatePatterns.end());
761 EXPECT_TRUE(numericalDatePatterns.find("y/M/d") != numericalDatePatterns.end());
762 EXPECT_TRUE(numericalDatePatterns.find("d-M-y") != numericalDatePatterns.end());
763
764 std::string identifier;
765 errCode = LocaleConfig::GetUsingNumericalDatePattern(identifier);
766 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
767 EXPECT_EQ(identifier, "y/M/d");
768
769 errCode = LocaleConfig::SetSystemNumericalDatePattern("d/MM/yy");
770 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
771 errCode = LocaleConfig::GetUsingNumericalDatePattern(identifier);
772 EXPECT_EQ(errCode, I18nErrorCode::SUCCESS);
773 EXPECT_EQ(identifier, "d/MM/yy");
774
775 errCode = LocaleConfig::SetSystemNumericalDatePattern("Invalid");
776 EXPECT_EQ(errCode, I18nErrorCode::INVALID_PARAM);
777
778 std::string patternNumber = LocaleConfig::GetPatternNumberFromLocale("zh-Hans-CN");
779 EXPECT_EQ(patternNumber, "");
780
781 LocaleConfig::SetSystemLanguage(systemLanguage);
782 LocaleConfig::SetSystemLocale(systemLocale);
783 }
784 } // namespace I18n
785 } // namespace Global
786 } // namespace OHOS