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 }
170
171 /**
172 * @tc.name: LocaleConfigFuncTest007
173 * @tc.desc: Test LocaleConfig GetSystemCountries
174 * @tc.type: FUNC
175 */
176 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest007, TestSize.Level1)
177 {
178 vector<string> countries;
179 LocaleConfig::GetSystemCountries(countries);
180 EXPECT_TRUE(countries.size() > 200);
181 }
182
183 /**
184 * @tc.name: LocaleConfigFuncTest008
185 * @tc.desc: Test LocaleConfig GetDisplayLanguage
186 * @tc.type: FUNC
187 */
188 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest008, TestSize.Level1)
189 {
190 std::string languageTag = "pt";
191 std::string localeTag = "en-US";
192 std::string displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
193 EXPECT_EQ(displayName, "Portuguese");
194
195 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
196 EXPECT_EQ(displayName, "Portuguese");
197
198 std::string fakeLocaleTag = "FakeLocaleTag";
199 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, true);
200 EXPECT_EQ(displayName, "");
201
202 std::string fakeLanguageTag = "FakeLanguageTag";
203 displayName = LocaleConfig::GetDisplayLanguage(fakeLanguageTag, localeTag, true);
204 EXPECT_EQ(displayName, "");
205
206 languageTag = "zh-Hans-CN";
207 localeTag = "en-US";
208 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
209 EXPECT_EQ(displayName, "Simplified Chinese");
210
211 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
212 EXPECT_EQ(displayName, "Simplified Chinese");
213
214 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, false);
215 EXPECT_EQ(displayName, "");
216
217 languageTag = "pt-Latn-BR";
218 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, false);
219 EXPECT_EQ(displayName, "Portuguese (Brazil)");
220
221 displayName = LocaleConfig::GetDisplayLanguage(languageTag, fakeLocaleTag, false);
222 EXPECT_EQ(displayName, "");
223
224 languageTag = "zh";
225 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
226 EXPECT_EQ(displayName, "Chinese");
227
228 localeTag = "en-Hans";
229 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
230 EXPECT_EQ(displayName, "Chinese");
231
232 languageTag = "zh-Hans";
233 localeTag = "en-US";
234 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
235 EXPECT_EQ(displayName, "Simplified Chinese");
236
237 languageTag = "ro-MD";
238 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
239 EXPECT_EQ(displayName, "Moldavian");
240 }
241
242 /**
243 * @tc.name: LocaleConfigFuncTest009
244 * @tc.desc: Test LocaleConfig GetDisplayRegion
245 * @tc.type: FUNC
246 */
247 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest009, TestSize.Level1)
248 {
249 std::string regionTag = "JP";
250 std::string localeTag = "zh-Hans-CN";
251 std::string displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
252 EXPECT_EQ(displayName, "日本");
253
254 std::string fakeRegionTag = "XX";
255 displayName = LocaleConfig::GetDisplayRegion(fakeRegionTag, localeTag, false);
256 EXPECT_EQ(displayName, "XX");
257
258 std::string fakeLocaleTag = "FakeLocaleTag";
259 displayName = LocaleConfig::GetDisplayRegion(regionTag, fakeLocaleTag, false);
260 EXPECT_EQ(displayName, "");
261
262 localeTag = "en-Latn-US";
263 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
264 EXPECT_EQ(displayName, "Japan");
265
266 regionTag = "zh-Hans-CN";
267 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
268 EXPECT_EQ(displayName, "China");
269
270 regionTag = "HK";
271 displayName = LocaleConfig::GetDisplayRegion(regionTag, localeTag, false);
272 EXPECT_EQ(displayName, "Hong Kong (China)");
273 }
274
275 /**
276 * @tc.name: LocaleConfigFuncTest010
277 * @tc.desc: Test LocaleConfig GetDisplayLanguage
278 * @tc.type: FUNC
279 */
280 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest010, TestSize.Level1)
281 {
282 std::string languageTag = "zh-Hant-HK";
283 std::string localeTag = "zh-Hant";
284 std::string displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
285 EXPECT_EQ(displayName, "繁體中文（中國香港）");
286
287 languageTag = "zh-Hant-HK";
288 localeTag = "zh-Hans";
289 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
290 EXPECT_EQ(displayName, "繁体中文（中国香港）");
291
292 languageTag = "zh-Hant-HK";
293 localeTag = "en-US";
294 displayName = LocaleConfig::GetDisplayLanguage(languageTag, localeTag, true);
295 EXPECT_EQ(displayName, "Traditional Chinese(Hong Kong, China)");
296 }
297
298 /**
299 * @tc.name: LocaleConfigFuncTest011
300 * @tc.desc: Test LocaleConfig GetDisplayRegion
301 * @tc.type: FUNC
302 */
303 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest011, TestSize.Level1)
304 {
305 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh", "en-US", true), "");
306 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh-Hans-CN", "en-US", true), "China");
307 }
308
309 /**
310 * @tc.name: LocaleConfigFuncTest012
311 * @tc.desc: Test LocaleConfig GetDisplayRegion
312 * @tc.type: FUNC
313 */
314 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest012, TestSize.Level1)
315 {
316 EXPECT_EQ(LocaleConfig::GetDisplayRegion("zh-Hans", "en-US", true), "");
317 }
318
319 /**
320 * @tc.name: LocaleConfigFuncTest013
321 * @tc.desc: Test LocaleConfig LocalDigit
322 * @tc.type: FUNC
323 */
324 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest013, TestSize.Level1)
325 {
326 bool current = LocaleConfig::GetUsingLocalDigit();
327 I18nErrorCode status = LocaleConfig::SetUsingLocalDigit(true);
328 EXPECT_EQ(status, I18nErrorCode::UPDATE_LOCAL_DIGIT_FAILED);
329 current = LocaleConfig::GetUsingLocalDigit();
330 EXPECT_FALSE(current);
331 }
332
333 /**
334 * @tc.name: LocaleConfigFuncTest014
335 * @tc.desc: Test LocaleConfig 24 hour clock
336 * @tc.type: FUNC
337 */
338 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest014, TestSize.Level1)
339 {
340 bool current = LocaleConfig::Is24HourClock();
341 I18nErrorCode status = LocaleConfig::Set24HourClock("true");
342 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
343 current = LocaleConfig::Is24HourClock();
344 EXPECT_TRUE(current);
345 status = LocaleConfig::Set24HourClock("abc");
346 EXPECT_EQ(status, I18nErrorCode::INVALID_24_HOUR_CLOCK_TAG);
347 LocaleConfig::Set24HourClock("");
348 }
349
350 /**
351 * @tc.name: LocaleConfigFuncTest015
352 * @tc.desc: Test LocaleConfig valid locales
353 * @tc.type: FUNC
354 */
355 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest015, TestSize.Level1)
356 {
357 string localeTag = "zh";
358 string validLocaleTag = LocaleConfig::GetValidLocale(localeTag);
359 EXPECT_EQ(validLocaleTag, "zh");
360
361 localeTag = "zh-u-hc-h12-nu-latn-ca-chinese-co-pinyin-kf-upper-kn-true";
362 validLocaleTag = LocaleConfig::GetValidLocale(localeTag);
363 EXPECT_EQ(validLocaleTag, "zh-u-ca-chinese-co-pinyin-kn-true-kf-upper-nu-latn-hc-h12");
364 }
365
366 /**
367 * @tc.name: LocaleConfigFuncTest016
368 * @tc.desc: Test LocaleConfig isRTL
369 * @tc.type: FUNC
370 */
371 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest016, TestSize.Level1)
372 {
373 string localeTag = "zh";
374 bool isRTL = LocaleConfig::IsRTL(localeTag);
375 EXPECT_TRUE(!isRTL);
376 localeTag = "ar";
377 isRTL = LocaleConfig::IsRTL(localeTag);
378 EXPECT_TRUE(isRTL);
379 }
380
381 /**
382 * @tc.name: LocaleConfigFuncTest017
383 * @tc.desc: Test LocaleConfig isSuggested
384 * @tc.type: FUNC
385 */
386 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest017, TestSize.Level1)
387 {
388 string language = "zh";
389 bool isSuggested = LocaleConfig::IsSuggested(language);
390 EXPECT_TRUE(isSuggested);
391 string region = "CN";
392 isSuggested = LocaleConfig::IsSuggested(language, region);
393 EXPECT_TRUE(isSuggested);
394 std::string fakeLanguage = "FakeLanguage";
395 isSuggested = LocaleConfig::IsSuggested(fakeLanguage);
396 EXPECT_FALSE(isSuggested);
397 }
398
399 /**
400 * @tc.name: LocaleConfigFuncTest018
401 * @tc.desc: Test LocaleCOnfig systemRegion
402 * @tc.type: FUNC
403 */
404 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest018, TestSize.Level1)
405 {
406 string currentRegion = LocaleConfig::GetSystemRegion();
407 EXPECT_TRUE(currentRegion.length() > 0);
408 string region = "CN";
409 I18nErrorCode status = LocaleConfig::SetSystemRegion(region);
410 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
411 currentRegion = LocaleConfig::GetSystemRegion();
412 EXPECT_EQ(currentRegion, region);
413 }
414
415 /**
416 * @tc.name: LocaleConfigFuncTest019
417 * @tc.desc: Test LocaleCOnfig systemLocale
418 * @tc.type: FUNC
419 */
420 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest019, TestSize.Level1)
421 {
422 string currentLocale = LocaleConfig::GetSystemLocale();
423 EXPECT_TRUE(currentLocale.length() > 0);
424 string locale = "zh-Hans-CN";
425 I18nErrorCode status = LocaleConfig::SetSystemLocale(locale);
426 EXPECT_EQ(status, I18nErrorCode::SUCCESS);
427 currentLocale = LocaleConfig::GetSystemLocale();
428 EXPECT_EQ(currentLocale, locale);
429 }
430
431 /**
432 * @tc.name: LocaleConfigFuncTest020
433 * @tc.desc: Test LocaleConfig systemLanguages
434 * @tc.type: FUNC
435 */
436 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest020, TestSize.Level1)
437 {
438 vector<string> languages;
439 LocaleConfig::GetSystemLanguages(languages);
440 EXPECT_TRUE(languages.size() > 2);
441 LocaleConfig::SetSystemLocale("ur-Latn-PK");
442 LocaleConfig::SetUsingLocalDigit(true);
443 LocaleConfig::SetUsingLocalDigit(false);
444 }
445
446 /**
447 * @tc.name: LocaleConfigFuncTest021
448 * @tc.desc: Test LocaleConfig IsValidLanguage
449 * @tc.type: FUNC
450 */
451 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest021, TestSize.Level1)
452 {
453 const string language = "zh";
454 const string fakeLanguage = "010";
455 const string tag = "zh-Hans";
456 const string fakeTag = "13-Hans";
457 bool flag = LocaleConfig::IsValidLanguage(language);
458 EXPECT_TRUE(flag);
459 flag = LocaleConfig::IsValidLanguage(fakeLanguage);
460 EXPECT_TRUE(!flag);
461 flag = LocaleConfig::IsValidTag(tag);
462 EXPECT_TRUE(flag);
463 flag = LocaleConfig::IsValidTag(fakeTag);
464 EXPECT_TRUE(!flag);
465 EXPECT_FALSE(LocaleConfig::IsValidTag(""));
466 }
467
468 /**
469 * @tc.name: LocaleConfigFuncTest022
470 * @tc.desc: Test LocaleConfig GetSimplifiedSystemLanguage
471 * @tc.type: FUNC
472 */
473 HWTEST_F(LocaleConfigTest, LocaleConfigFuncTest022, TestSize.Level1)
474 {
475 for (auto index = 0; index < LocaleConfigTest::languageAndRegion.size(); ++index) {
476 LocaleConfig::SetSystemLanguage(languageAndRegion[index].first);
477 LocaleConfig::SetSystemRegion(languageAndRegion[index].second);
478 std::string ret = LocaleConfig::GetSimplifiedSystemLanguage();
479 EXPECT_EQ(ret, LocaleConfigTest::simplifiedLanguage[index]);
480 }
481 }
482 } // namespace I18n
483 } // namespace Global
484 } // namespace OHOS