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