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 "unicode/locid.h"
20 #include "parameter.h"
21
22 using namespace OHOS::Global::I18n;
23 using testing::ext::TestSize;
24 using namespace std;
25
26 namespace OHOS {
27 namespace Global {
28 namespace I18n {
29 class LocaleConfigTest : public testing::Test {
30 public:
31 static string originalLanguage;
32 static string originalRegion;
33 static string originalLocale;
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38
39 static std::vector<std::pair<std::string, std::string>> languageAndRegion;
40 static std::vector<std::string> simplifiedLanguage;
41 };
42
43 string LocaleConfigTest::originalLanguage;
44 string LocaleConfigTest::originalRegion;
45 string LocaleConfigTest::originalLocale;
46
47 std::vector<std::pair<std::string, std::string>> LocaleConfigTest::languageAndRegion {
48 { "zh-Hans", "CN" }, { "zh-Hant", "HK" }, { "zh-Hant", "TW" }, { "en-Latn-US", "US" }, { "en-Latn-US", "GB" },
49 { "bo", "CN" }, { "ug", "CN" }, { "am", "CN" }, { "ar", "CN" }, { "as", "CN" }, { "az-Latn", "IR" },
50 { "be", "CN" }, { "bg", "CN" }, { "bn", "CN" }, { "bs-Latn", "CN" }, { "ca", "CN" }, { "cs", "CN" },
51 { "da", "CN" }, { "de", "CN" }, { "el", "CN" }, { "es-ES", "US" }, { "es-US", "ES" }, { "et", "CN" },
52 { "eu", "CN" }, { "fa", "IR" }, { "fi", "CN" }, { "tl", "CN" }, { "fr", "CN" }, { "jv-Latn", "CN" },
53 { "mai", "CN" }, { "mn-Cyrl", "CN" }, { "uz-Latn", "CN" }
54 };
55
56 std::vector<std::string> LocaleConfigTest::simplifiedLanguage {
57 "zh-Hans", "zh-Hant-HK", "zh-Hant", "en", "en-GB", "bo", "ug", "am", "ar", "as", "az-Latn", "be", "bg", "bn",
58 "bs-Latn", "ca", "cs", "da", "de", "el", "es", "es-US", "et", "eu", "fa", "fi", "tl", "fr", "jv-Latn", "mai",
59 "mn-Cyrl", "uz-Latn"
60 };
61
SetUpTestCase(void)62 void LocaleConfigTest::SetUpTestCase(void)
63 {
64 originalLanguage = LocaleConfig::GetSystemLanguage();
65 originalRegion = LocaleConfig::GetSystemRegion();
66 originalLocale = LocaleConfig::GetSystemLocale();
67 LocaleConfig::SetSystemLanguage("zh-Hans");
68 LocaleConfig::SetSystemRegion("CN");
69 LocaleConfig::SetSystemLocale("zh-Hans-CN");
70 }
71
TearDownTestCase(void)72 void LocaleConfigTest::TearDownTestCase(void)
73 {
74 LocaleConfig::SetSystemLanguage(originalLanguage);
75 LocaleConfig::SetSystemRegion(originalRegion);
76 LocaleConfig::SetSystemLocale(originalLocale);
77 }
78
SetUp(void)79 void LocaleConfigTest::SetUp(void)
80 {}
81
TearDown(void)82 void LocaleConfigTest::TearDown(void)
83 {}
84
85 /**
86 * @tc.name: LocaleConfigFuncTest001
87 * @tc.desc: Test LocaleConfig GetSystemLanguage default
88 * @tc.type: FUNC
89 */
90 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest001, TestSize.Level1)
91 {
92 int ret = SetParameter("hm.sys.language", "");
93 if (!ret) {
94 EXPECT_EQ(LocaleConfig::GetSystemLanguage(), "zh-Hans");
95 }
96 }
97
98 /**
99 * @tc.name: LocaleConfigFuncTest002
100 * @tc.desc: Test LocaleConfig GetSystemRegion default.
101 * @tc.type: FUNC
102 */
103 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest002, TestSize.Level1)
104 {
105 int ret = SetParameter("hm.sys.locale", "");
106 if (!ret) {
107 EXPECT_EQ(LocaleConfig::GetSystemRegion(), "CN");
108 }
109 }
110
111 /**
112 * @tc.name: LocaleConfigFuncTest003
113 * @tc.desc: Test LocaleConfig GetSystemLocale default
114 * @tc.type: FUNC
115 */
116 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest003, TestSize.Level1)
117 {
118 int ret = SetParameter("hm.sys.locale", "");
119 if (!ret) {
120 EXPECT_EQ(LocaleConfig::GetSystemLocale(), "zh-Hans-CN");
121 }
122 }
123
124 /**
125 * @tc.name: LocaleConfigFuncTest004
126 * @tc.desc: Test LocaleConfig SetSystemLanguage
127 * @tc.type: FUNC
128 */
129 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest004, TestSize.Level1)
130 {
131 string language = "pt-PT";
132 I18nErrorCode status = LocaleConfig::SetSystemLanguage(language);
133 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
134 LocaleConfig::SetSystemLanguage("zh-Hans");
135 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
136 LocaleConfig::SetSystemLanguage("%$=");
137 }
138
139 /**
140 * @tc.name: LocaleConfigFuncTest005
141 * @tc.desc: Test LocaleConfig SetSystemLocale
142 * @tc.type: FUNC
143 */
144 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest005, TestSize.Level1)
145 {
146 string locale = "zh-Hant-TW";
147 I18nErrorCode status = LocaleConfig::SetSystemLocale(locale);
148 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
149 status = LocaleConfig::SetSystemLocale("zh-Hans-CN");
150 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
151 }
152
153 /**
154 * @tc.name: LocaleConfigFuncTest006
155 * @tc.desc: Test LocaleConfig SetSystemRegion
156 * @tc.type: FUNC
157 */
158 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest006, TestSize.Level1)
159 {
160 string locale = "zh-Hant-TW";
161 I18nErrorCode status = LocaleConfig::SetSystemLocale(locale);
162 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
163 status = LocaleConfig::SetSystemRegion("HK");
164 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
165 status = LocaleConfig::SetSystemLocale("zh-Hans-CN");
166 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
167 status = LocaleConfig::SetSystemRegion("@*%");
168 EXPECT_EQ(status, I18nErrorCode::INVALID_REGION_TAG);
169 status = LocaleConfig::SetSystemLocale("zh-Hans-CN", 2);
170 EXPECT_NE(status, I18nErrorCode::SUCCESS);
171 status = LocaleConfig::SetSystemLocale("zh-Hans-CN", 2);
172 EXPECT_NE(status, I18nErrorCode::SUCCESS);
173 status = LocaleConfig::SetSystemLocale("ar-EG");
174 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
175 EXPECT_FALSE(LocaleConfig::GetUsingLocalDigit());
176 status = LocaleConfig::SetSystemLocale("$$@");
177 EXPECT_NE(status, I18nErrorCode::SUCCESS);
178 status = LocaleConfig::SetSystemLocale("zh-Hans-CN");
179 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
180 }
181
182 /**
183 * @tc.name: LocaleConfigFuncTest007
184 * @tc.desc: Test LocaleConfig GetSystemCountries
185 * @tc.type: FUNC
186 */
187 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest007, TestSize.Level1)
188 {
189 std::unordered_set<std::string> countries = LocaleConfig::GetSystemCountries("zh");
190 EXPECT_TRUE(countries.size() > 200);
191 }
192
193 /**
194 * @tc.name: LocaleConfigFuncTest008
195 * @tc.desc: Test LocaleConfig GetDisplayLanguage
196 * @tc.type: FUNC
197 */
198 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest008, TestSize.Level1)
199 {
200 std::string languageTag = "pt";
201 std::string localeTag = "en-US";
202 std::string displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
203 EXPECT_EQ(displayName, "Portuguese");
204
205 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
206 EXPECT_EQ(displayName, "Portuguese");
207
208 std::string fakeLocaleTag = "FakeLocaleTag";
209 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, true);
210 EXPECT_EQ(displayName, "");
211
212 std::string fakeLanguageTag = "FakeLanguageTag";
213 displayName = LocaleConfig::GetDisplayLanguage(fakeLanguageTag, localeTag, true);
214 EXPECT_EQ(displayName, "");
215
216 languageTag = "zh-Hans-CN";
217 localeTag = "en-US";
218 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
219 EXPECT_EQ(displayName, "Simplified Chinese");
220
221 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
222 EXPECT_EQ(displayName, "Simplified Chinese");
223
224 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, false);
225 EXPECT_EQ(displayName, "");
226
227 languageTag = "pt-Latn-BR";
228 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
229 EXPECT_EQ(displayName, "Portuguese (Brazil)");
230
231 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, false);
232 EXPECT_EQ(displayName, "");
233
234 languageTag = "zh";
235 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
236 EXPECT_EQ(displayName, "Chinese");
237
238 localeTag = "en-Hans";
239 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
240 EXPECT_EQ(displayName, "Chinese");
241
242 languageTag = "zh-Hans";
243 localeTag = "en-US";
244 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
245 EXPECT_EQ(displayName, "Simplified Chinese");
246
247 languageTag = "ro-MD";
248 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
249 EXPECT_EQ(displayName, "Moldavian");
250 }
251
252 /**
253 * @tc.name: LocaleConfigFuncTest009
254 * @tc.desc: Test LocaleConfig GetDisplayRegion
255 * @tc.type: FUNC
256 */
257 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest009, TestSize.Level1)
258 {
259 std::string regionTag = "JP";
260 std::string localeTag = "zh-Hans-CN";
261 std::string displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
262 EXPECT_EQ(displayName, "日本");
263
264 std::string fakeRegionTag = "XX";
265 displayName = LocaleConfig::GetDisplayRegion(fakeRegionTag, localeTag, false);
266 EXPECT_EQ(displayName, "XX");
267
268 std::string fakeLocaleTag = "FakeLocaleTag";
269 displayName = LocaleConfig::GetDisplayRegion(regionTag, fakeLocaleTag, false);
270 EXPECT_EQ(displayName, "");
271
272 localeTag = "en-Latn-US";
273 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
274 EXPECT_EQ(displayName, "Japan");
275
276 regionTag = "zh-Hans-CN";
277 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
278 EXPECT_EQ(displayName, "China");
279
280 regionTag = "HK";
281 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
282 EXPECT_EQ(displayName, "Hong Kong (China)");
283 }
284
285 /**
286 * @tc.name: LocaleConfigFuncTest010
287 * @tc.desc: Test LocaleConfig GetDisplayLanguage
288 * @tc.type: FUNC
289 */
290 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest010, TestSize.Level1)
291 {
292 std::string languageTag = "zh-Hant-HK";
293 std::string localeTag = "zh-Hant";
294 std::string displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
295 EXPECT_EQ(displayName, "繁體中文（中國香港）");
296
297 languageTag = "zh-Hant-HK";
298 localeTag = "zh-Hans";
299 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
300 EXPECT_EQ(displayName, "繁体中文（中国香港）");
301
302 languageTag = "zh-Hant-HK";
303 localeTag = "en-US";
304 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
305 EXPECT_EQ(displayName, "Traditional Chinese(Hong Kong, China)");
306 }
307
308 /**
309 * @tc.name: LocaleConfigFuncTest011
310 * @tc.desc: Test LocaleConfig GetDisplayRegion
311 * @tc.type: FUNC
312 */
313 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest011, TestSize.Level1)
314 {
315 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh", "en-US", true), "");
316 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh-Hans-CN", "en-US", true), "China");
317 }
318
319 /**
320 * @tc.name: LocaleConfigFuncTest012
321 * @tc.desc: Test LocaleConfig GetDisplayRegion
322 * @tc.type: FUNC
323 */
324 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest012, TestSize.Level1)
325 {
326 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh-Hans", "en-US", true), "");
327 }
328
329 /**
330 * @tc.name: LocaleConfigFuncTest013
331 * @tc.desc: Test LocaleConfig LocalDigit
332 * @tc.type: FUNC
333 */
334 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest013, TestSize.Level1)
335 {
336 bool current = LocaleConfig::GetUsingLocalDigit();
337 I18nErrorCode status = LocaleConfig::SetUsingLocalDigit(true);
338 EXPECT_EQ(status, I18nErrorCode::UPDATE_LOCAL_DIGIT_FAILED);
339 current = LocaleConfig::GetUsingLocalDigit();
340 EXPECT_FALSE(current);
341 }
342
343 /**
344 * @tc.name: LocaleConfigFuncTest014
345 * @tc.desc: Test LocaleConfig 24 hour clock
346 * @tc.type: FUNC
347 */
348 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest014, TestSize.Level1)
349 {
350 bool current = LocaleConfig::Is24HourClock();
351 I18nErrorCode status = LocaleConfig::Set24HourClock("true");
352 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
353 current = LocaleConfig::Is24HourClock();
354 EXPECT_TRUE(current);
355 status = LocaleConfig::Set24HourClock("abc");
356 EXPECT_EQ(status, I18nErrorCode::INVALID_24_HOUR_CLOCK_TAG);
357 LocaleConfig::Set24HourClock("");
358 LocaleConfig::Set24HourClock("false");
359 }
360
361 /**
362 * @tc.name: LocaleConfigFuncTest015
363 * @tc.desc: Test LocaleConfig valid locales
364 * @tc.type: FUNC
365 */
366 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest015, TestSize.Level1)
367 {
368 string localeTag = "zh";
369 string validLocaleTag = LocaleConfig::GetValidLocale(localeTag);
370 EXPECT_EQ(validLocaleTag, "zh");
371
372 localeTag = "zh-u-hc-h12-nu-latn-ca-chinese-co-pinyin-kf-upper-kn-true";
373 validLocaleTag = LocaleConfig::GetValidLocale(localeTag);
374 EXPECT_EQ(validLocaleTag, "zh-u-ca-chinese-co-pinyin-kn-true-kf-upper-nu-latn-hc-h12");
375 }
376
377 /**
378 * @tc.name: LocaleConfigFuncTest016
379 * @tc.desc: Test LocaleConfig isRTL
380 * @tc.type: FUNC
381 */
382 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest016, TestSize.Level1)
383 {
384 string localeTag = "zh";
385 bool isRTL = LocaleConfig::IsRTL(localeTag);
386 EXPECT_TRUE(!isRTL);
387 localeTag = "ar";
388 isRTL = LocaleConfig::IsRTL(localeTag);
389 EXPECT_TRUE(isRTL);
390 }
391
392 /**
393 * @tc.name: LocaleConfigFuncTest017
394 * @tc.desc: Test LocaleConfig isSuggested
395 * @tc.type: FUNC
396 */
397 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest017, TestSize.Level1)
398 {
399 string language = "zh";
400 bool isSuggested = LocaleConfig::IsSuggested(language);
401 EXPECT_TRUE(isSuggested);
402 string region = "CN";
403 isSuggested = LocaleConfig::IsSuggested(language, region);
404 EXPECT_TRUE(isSuggested);
405 std::string fakeLanguage = "FakeLanguage";
406 isSuggested = LocaleConfig::IsSuggested(fakeLanguage);
407 EXPECT_FALSE(isSuggested);
408 }
409
410 /**
411 * @tc.name: LocaleConfigFuncTest018
412 * @tc.desc: Test LocaleCOnfig systemRegion
413 * @tc.type: FUNC
414 */
415 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest018, TestSize.Level1)
416 {
417 string currentRegion = LocaleConfig::GetSystemRegion();
418 EXPECT_TRUE(currentRegion.length() > 0);
419 string region = "CN";
420 I18nErrorCode status = LocaleConfig::SetSystemRegion(region);
421 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
422 currentRegion = LocaleConfig::GetSystemRegion();
423 EXPECT_EQ(currentRegion, region);
424 }
425
426 /**
427 * @tc.name: LocaleConfigFuncTest019
428 * @tc.desc: Test LocaleCOnfig systemLocale
429 * @tc.type: FUNC
430 */
431 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest019, TestSize.Level1)
432 {
433 string currentLocale = LocaleConfig::GetSystemLocale();
434 EXPECT_TRUE(currentLocale.length() > 0);
435 string locale = "zh-Hans-CN";
436 I18nErrorCode status = LocaleConfig::SetSystemLocale(locale);
437 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
438 currentLocale = LocaleConfig::GetSystemLocale();
439 EXPECT_EQ(currentLocale, locale);
440 }
441
442 /**
443 * @tc.name: LocaleConfigFuncTest020
444 * @tc.desc: Test LocaleConfig systemLanguages
445 * @tc.type: FUNC
446 */
447 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest020, TestSize.Level1)
448 {
449 std::unordered_set<std::string> languages = LocaleConfig::GetSystemLanguages();
450 EXPECT_TRUE(languages.size() > 2);
451 LocaleConfig::SetSystemLocale("ur-Latn-PK");
452 LocaleConfig::SetUsingLocalDigit(true);
453 LocaleConfig::SetUsingLocalDigit(false);
454 }
455
456 /**
457 * @tc.name: LocaleConfigFuncTest021
458 * @tc.desc: Test LocaleConfig IsValidLanguage
459 * @tc.type: FUNC
460 */
461 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest021, TestSize.Level1)
462 {
463 const string language = "zh";
464 const string fakeLanguage = "010";
465 const string tag = "zh-Hans";
466 const string fakeTag = "13-Hans";
467 bool flag = LocaleConfig::IsValidLanguage(language);
468 EXPECT_TRUE(flag);
469 flag = LocaleConfig::IsValidLanguage(fakeLanguage);
470 EXPECT_TRUE(!flag);
471 flag = LocaleConfig::IsValidTag(tag);
472 EXPECT_TRUE(flag);
473 flag = LocaleConfig::IsValidTag(fakeTag);
474 EXPECT_TRUE(!flag);
475 EXPECT_FALSE(LocaleConfig::IsValidTag(""));
476 }
477
478 /**
479 * @tc.name: LocaleConfigFuncTest022
480 * @tc.desc: Test LocaleConfig GetSimplifiedSystemLanguage
481 * @tc.type: FUNC
482 */
483 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest022, TestSize.Level1)
484 {
485 for (auto index = 0; index < LocaleConfigTest::languageAndRegion.size(); ++index) {
486 LocaleConfig::SetSystemLanguage(languageAndRegion[index].first);
487 LocaleConfig::SetSystemRegion(languageAndRegion[index].second);
488 std::string ret = LocaleConfig::GetSimplifiedSystemLanguage();
489 EXPECT_EQ(ret, LocaleConfigTest::simplifiedLanguage[index]);
490 }
491 }
492 } // namespace I18n
493 } // namespace Global
494 } // namespace OHOS