1 /*
2 * Copyright (c) 2023-2024 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 <gtest/gtest.h>
17 #include "accesstoken_kit.h"
18 #include "i18n_service_ability_client.h"
19 #include "locale_config.h"
20 #include "nativetoken_kit.h"
21 #include "preferred_language.h"
22 #include "token_setproc.h"
23 #include "i18n_service_test.h"
24
25 using testing::ext::TestSize;
26 using namespace std;
27 namespace OHOS {
28 namespace Global {
29 namespace I18n {
30 static const uint64_t SELF_TOKEN_ID = GetSelfTokenID();
31 static constexpr int32_t I18N_UID = 3013;
32 static constexpr int32_t ROOT_UID = 0;
33
34 class I18nServiceTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 };
41
SetUpTestCase(void)42 void I18nServiceTest::SetUpTestCase(void)
43 {}
44
TearDownTestCase(void)45 void I18nServiceTest::TearDownTestCase(void)
46 {}
47
SetUp(void)48 void I18nServiceTest::SetUp(void)
49 {}
50
TearDown(void)51 void I18nServiceTest::TearDown(void)
52 {}
53
RemoveNativeTokenTypeAndPermissions()54 void RemoveNativeTokenTypeAndPermissions()
55 {
56 SetSelfTokenID(SELF_TOKEN_ID);
57 seteuid(ROOT_UID);
58 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
59 seteuid(I18N_UID);
60 }
61
AddNativeTokenTypeAndPermissions()62 void AddNativeTokenTypeAndPermissions()
63 {
64 const char* permissions[] = {
65 "ohos.permission.UPDATE_CONFIGURATION"
66 };
67 NativeTokenInfoParams infoInstance = {
68 .dcapsNum = 0,
69 .permsNum = sizeof(permissions) / sizeof(permissions[0]),
70 .aclsNum = 0,
71 .dcaps = nullptr,
72 .perms = permissions,
73 .acls = nullptr,
74 .aplStr = "system_basic",
75 };
76 infoInstance.processName = "I18nServiceTest";
77 SetSelfTokenID(GetAccessTokenId(&infoInstance));
78 seteuid(ROOT_UID);
79 int32_t ret = OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
80 printf("ReloadNativeTokenInfo result is %d. \n", ret);
81 seteuid(I18N_UID);
82 }
83
InitTestEnvironment()84 void InitTestEnvironment()
85 {
86 LocaleConfig::SetSystemLanguage("zh-Hans");
87 LocaleConfig::SetSystemRegion("CN");
88 LocaleConfig::SetSystemLocale("zh-Hans-CN");
89 LocaleConfig::Set24HourClock("true");
90 std::vector<std::string> preferredLanguageList = PreferredLanguage::GetPreferredLanguageList();
91 if (preferredLanguageList.size() > 1) {
92 for (size_t i = preferredLanguageList.size(); i > 1; --i) {
93 PreferredLanguage::RemovePreferredLanguage(i);
94 }
95 }
96 RemoveNativeTokenTypeAndPermissions();
97 }
98
99 /**
100 * @tc.name: I18nServiceFuncTest001
101 * @tc.desc: Test I18nServiceAbilityClient SetSystemLanguage: no permission case
102 * @tc.type: FUNC
103 */
104 HWTEST_F(I18nServiceTest, I18nServiceFuncTest001, TestSize.Level1)
105 {
106 InitTestEnvironment();
107 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("en");
108 EXPECT_EQ(err, I18nErrorCode::NO_PERMISSION);
109 }
110
111 /**
112 * @tc.name: I18nServiceFuncTest002
113 * @tc.desc: Test I18nServiceAbilityClient SetSystemLanguage
114 * @tc.type: FUNC
115 */
116 HWTEST_F(I18nServiceTest, I18nServiceFuncTest002, TestSize.Level1)
117 {
118 InitTestEnvironment();
119 AddNativeTokenTypeAndPermissions();
120 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("en");
121 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
122 }
123
124 /**
125 * @tc.name: I18nServiceFuncTest003
126 * @tc.desc: Test I18nServiceAbilityClient SetSystemLanguage: invalid language tag
127 * @tc.type: FUNC
128 */
129 HWTEST_F(I18nServiceTest, I18nServiceFuncTest003, TestSize.Level1)
130 {
131 InitTestEnvironment();
132 AddNativeTokenTypeAndPermissions();
133 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("fake_language_tag");
134 EXPECT_EQ(err, I18nErrorCode::INVALID_LANGUAGE_TAG);
135 }
136
137 /**
138 * @tc.name: I18nServiceFuncTest004
139 * @tc.desc: Test I18nServiceAbilityClient SetSystemRegion: no permission case.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(I18nServiceTest, I18nServiceFuncTest004, TestSize.Level1)
143 {
144 InitTestEnvironment();
145 I18nErrorCode err = I18nServiceAbilityClient::SetSystemRegion("US");
146 EXPECT_EQ(err, I18nErrorCode::NO_PERMISSION);
147 }
148
149 /**
150 * @tc.name: I18nServiceFuncTest005
151 * @tc.desc: Test I18nServiceAbilityClient SetSystemRegion
152 * @tc.type: FUNC
153 */
154 HWTEST_F(I18nServiceTest, I18nServiceFuncTest005, TestSize.Level1)
155 {
156 InitTestEnvironment();
157 AddNativeTokenTypeAndPermissions();
158 I18nErrorCode err = I18nServiceAbilityClient::SetSystemRegion("US");
159 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
160 }
161
162 /**
163 * @tc.name: I18nServiceFuncTest006
164 * @tc.desc: Test I18nServiceAbilityClient SetSystemRegion: invalid region tag.
165 * @tc.type: FUNC
166 */
167 HWTEST_F(I18nServiceTest, I18nServiceFuncTest006, TestSize.Level1)
168 {
169 InitTestEnvironment();
170 AddNativeTokenTypeAndPermissions();
171 I18nErrorCode err = I18nServiceAbilityClient::SetSystemRegion("fake_region_tag");
172 EXPECT_EQ(err, I18nErrorCode::INVALID_REGION_TAG);
173 }
174
175 /**
176 * @tc.name: I18nServiceFuncTest007
177 * @tc.desc: Test I18nServiceAbilityClient SetSystemLocale: no permission case.
178 * @tc.type: FUNC
179 */
180 HWTEST_F(I18nServiceTest, I18nServiceFuncTest007, TestSize.Level1)
181 {
182 InitTestEnvironment();
183 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLocale("en-US");
184 EXPECT_EQ(err, I18nErrorCode::NO_PERMISSION);
185 }
186
187 /**
188 * @tc.name: I18nServiceFuncTest008
189 * @tc.desc: Test I18nServiceAbilityClient SetSystemLocale
190 * @tc.type: FUNC
191 */
192 HWTEST_F(I18nServiceTest, I18nServiceFuncTest008, TestSize.Level1)
193 {
194 InitTestEnvironment();
195 AddNativeTokenTypeAndPermissions();
196 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLocale("en-US");
197 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
198 err = I18nServiceAbilityClient::SetSystemLocale("en-XA");
199 LocaleConfig::GetDisplayLanguage("zh", "en-US", true);
200 }
201
202 /**
203 * @tc.name: I18nServiceFuncTest009
204 * @tc.desc: Test I18nServiceAbilityClient SetSystemLocale: invalid locale tag.
205 * @tc.type: FUNC
206 */
207 HWTEST_F(I18nServiceTest, I18nServiceFuncTest009, TestSize.Level1)
208 {
209 InitTestEnvironment();
210 AddNativeTokenTypeAndPermissions();
211 I18nErrorCode err = I18nServiceAbilityClient::SetSystemRegion("fake_locale_tag");
212 EXPECT_EQ(err, I18nErrorCode::INVALID_REGION_TAG);
213 }
214
215 /**
216 * @tc.name: I18nServiceFuncTest010
217 * @tc.desc: Test I18nServiceAbilityClient Set24HourClock: no permission.
218 * @tc.type: FUNC
219 */
220 HWTEST_F(I18nServiceTest, I18nServiceFuncTest010, TestSize.Level1)
221 {
222 InitTestEnvironment();
223 I18nErrorCode err = I18nServiceAbilityClient::Set24HourClock("false");
224 EXPECT_EQ(err, I18nErrorCode::NO_PERMISSION);
225 }
226
227 /**
228 * @tc.name: I18nServiceFuncTest011
229 * @tc.desc: Test I18nServiceAbilityClient Set24HourClock: set 24 hour clock to false.
230 * @tc.type: FUNC
231 */
232 HWTEST_F(I18nServiceTest, I18nServiceFuncTest011, TestSize.Level1)
233 {
234 InitTestEnvironment();
235 AddNativeTokenTypeAndPermissions();
236 I18nErrorCode err = I18nServiceAbilityClient::Set24HourClock("false");
237 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
238 }
239
240 /**
241 * @tc.name: I18nServiceFuncTest012
242 * @tc.desc: Test I18nServiceAbilityClient Set24HourClock: set 24 hour clock to true.
243 * @tc.type: FUNC
244 */
245 HWTEST_F(I18nServiceTest, I18nServiceFuncTest012, TestSize.Level1)
246 {
247 InitTestEnvironment();
248 AddNativeTokenTypeAndPermissions();
249 I18nErrorCode err = I18nServiceAbilityClient::Set24HourClock("true");
250 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
251 }
252
253 /**
254 * @tc.name: I18nServiceFuncTest013
255 * @tc.desc: Test I18nServiceAbilityClient SetUsingLocalDigit: test no permission case.
256 * @tc.type: FUNC
257 */
258 HWTEST_F(I18nServiceTest, I18nServiceFuncTest013, TestSize.Level1)
259 {
260 InitTestEnvironment();
261 I18nErrorCode err = I18nServiceAbilityClient::SetUsingLocalDigit(true);
262 EXPECT_EQ(err, I18nErrorCode::NO_PERMISSION);
263 }
264
265 /**
266 * @tc.name: I18nServiceFuncTest014
267 * @tc.desc: Test I18nServiceAbilityClient SetUsingLocalDigit: test no local digit language.
268 * @tc.type: FUNC
269 */
270 HWTEST_F(I18nServiceTest, I18nServiceFuncTest014, TestSize.Level1)
271 {
272 InitTestEnvironment();
273 AddNativeTokenTypeAndPermissions();
274 I18nErrorCode err = I18nServiceAbilityClient::SetUsingLocalDigit(true);
275 EXPECT_EQ(err, I18nErrorCode::UPDATE_LOCAL_DIGIT_FAILED);
276 }
277
278 /**
279 * @tc.name: I18nServiceFuncTest015
280 * @tc.desc: Test I18nServiceAbilityClient SetUsingLocalDigit test set local digit to true
281 * @tc.type: FUNC
282 */
283 HWTEST_F(I18nServiceTest, I18nServiceFuncTest015, TestSize.Level1)
284 {
285 InitTestEnvironment();
286 AddNativeTokenTypeAndPermissions();
287 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("ar");
288 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
289 err = I18nServiceAbilityClient::SetUsingLocalDigit(true);
290 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
291 }
292
293 /**
294 * @tc.name: I18nServiceFuncTest016
295 * @tc.desc: Test I18nServiceAbilityClient SetUsingLocalDigit test set local digit to false
296 * @tc.type: FUNC
297 */
298 HWTEST_F(I18nServiceTest, I18nServiceFuncTest016, TestSize.Level1)
299 {
300 InitTestEnvironment();
301 AddNativeTokenTypeAndPermissions();
302 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("ar");
303 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
304 err = I18nServiceAbilityClient::SetUsingLocalDigit(false);
305 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
306 }
307
308 /**
309 * @tc.name: I18nServiceFuncTest017
310 * @tc.desc: Test I18nServiceAbilityClient AddPreferredLanguage: test no permission case
311 * @tc.type: FUNC
312 */
313 HWTEST_F(I18nServiceTest, I18nServiceFuncTest017, TestSize.Level1)
314 {
315 InitTestEnvironment();
316 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("ar", 0);
317 EXPECT_EQ(err, I18nErrorCode::NO_PERMISSION);
318 }
319
320 /**
321 * @tc.name: I18nServiceFuncTest018
322 * @tc.desc: Test I18nServiceAbilityClient AddPreferredLanguage: test add language to preferred language list header.
323 * @tc.type: FUNC
324 */
325 HWTEST_F(I18nServiceTest, I18nServiceFuncTest018, TestSize.Level1)
326 {
327 InitTestEnvironment();
328 AddNativeTokenTypeAndPermissions();
329 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("ar", 0);
330 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
331 }
332
333 /**
334 * @tc.name: I18nServiceFuncTest019
335 * @tc.desc: Test I18nServiceAbilityClient AddPreferredLanguage: test add language to preferred language list tailor.
336 * @tc.type: FUNC
337 */
338 HWTEST_F(I18nServiceTest, I18nServiceFuncTest019, TestSize.Level1)
339 {
340 InitTestEnvironment();
341 AddNativeTokenTypeAndPermissions();
342 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", 1);
343 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
344 }
345
346 /**
347 * @tc.name: I18nServiceFuncTest020
348 * @tc.desc: Test I18nServiceAbilityClient AddPreferredLanguage: test add language to negative index.
349 * @tc.type: FUNC
350 */
351 HWTEST_F(I18nServiceTest, I18nServiceFuncTest020, TestSize.Level1)
352 {
353 InitTestEnvironment();
354 AddNativeTokenTypeAndPermissions();
355 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", -10);
356 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
357 }
358
359 /**
360 * @tc.name: I18nServiceFuncTest021
361 * @tc.desc: Test I18nServiceAbilityClient AddPreferredLanguage: test add language to large index.
362 * @tc.type: FUNC
363 */
364 HWTEST_F(I18nServiceTest, I18nServiceFuncTest021, TestSize.Level1)
365 {
366 InitTestEnvironment();
367 AddNativeTokenTypeAndPermissions();
368 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", 10);
369 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
370 }
371
372 /**
373 * @tc.name: I18nServiceFuncTest022
374 * @tc.desc: Test I18nServiceAbilityClient AddPreferredLanguage: test add invalid language tag.
375 * @tc.type: FUNC
376 */
377 HWTEST_F(I18nServiceTest, I18nServiceFuncTest022, TestSize.Level1)
378 {
379 InitTestEnvironment();
380 AddNativeTokenTypeAndPermissions();
381 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", 1);
382 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
383 }
384
385 /**
386 * @tc.name: I18nServiceFuncTest023
387 * @tc.desc: Test I18nServiceAbilityClient RemovePreferredLanguage: test no permission case.
388 * @tc.type: FUNC
389 */
390 HWTEST_F(I18nServiceTest, I18nServiceFuncTest023, TestSize.Level1)
391 {
392 InitTestEnvironment();
393 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", -1);
394 EXPECT_EQ(err, I18nErrorCode::NO_PERMISSION);
395 }
396
397 /**
398 * @tc.name: I18nServiceFuncTest024
399 * @tc.desc: Test I18nServiceAbilityClient RemovePreferredLanguage: remove when preferred language list size is 1.
400 * @tc.type: FUNC
401 */
402 HWTEST_F(I18nServiceTest, I18nServiceFuncTest024, TestSize.Level1)
403 {
404 InitTestEnvironment();
405 AddNativeTokenTypeAndPermissions();
406 I18nErrorCode err = I18nServiceAbilityClient::RemovePreferredLanguage(0);
407 EXPECT_EQ(err, I18nErrorCode::REMOVE_PREFERRED_LANGUAGE_FAILED);
408 }
409
410 /**
411 * @tc.name: I18nServiceFuncTest025
412 * @tc.desc: Test I18nServiceAbilityClient RemovePreferredLanguage: remove large index.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(I18nServiceTest, I18nServiceFuncTest025, TestSize.Level1)
416 {
417 InitTestEnvironment();
418 AddNativeTokenTypeAndPermissions();
419 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", 0);
420 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
421 err = I18nServiceAbilityClient::RemovePreferredLanguage(10);
422 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
423 }
424
425 /**
426 * @tc.name: I18nServiceFuncTest026
427 * @tc.desc: Test I18nServiceAbilityClient RemovePreferredLanguage: remove first preferred language.
428 * @tc.type: FUNC
429 */
430 HWTEST_F(I18nServiceTest, I18nServiceFuncTest026, TestSize.Level1)
431 {
432 InitTestEnvironment();
433 AddNativeTokenTypeAndPermissions();
434 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", 0);
435 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
436 err = I18nServiceAbilityClient::RemovePreferredLanguage(0);
437 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
438 }
439
440 /**
441 * @tc.name: I18nServiceFuncTest027
442 * @tc.desc: Test I18nServiceAbilityClient RemovePreferredLanguage: remove last preferred language.
443 * @tc.type: FUNC
444 */
445 HWTEST_F(I18nServiceTest, I18nServiceFuncTest027, TestSize.Level1)
446 {
447 InitTestEnvironment();
448 AddNativeTokenTypeAndPermissions();
449 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", 0);
450 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
451 err = I18nServiceAbilityClient::RemovePreferredLanguage(1);
452 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
453 }
454
455 /**
456 * @tc.name: I18nServiceFuncTest028
457 * @tc.desc: Test I18nServiceAbilityClient RemovePreferredLanguage: remove negative index.
458 * @tc.type: FUNC
459 */
460 HWTEST_F(I18nServiceTest, I18nServiceFuncTest028, TestSize.Level1)
461 {
462 InitTestEnvironment();
463 AddNativeTokenTypeAndPermissions();
464 I18nErrorCode err = I18nServiceAbilityClient::AddPreferredLanguage("fr", 0);
465 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
466 err = I18nServiceAbilityClient::RemovePreferredLanguage(-1);
467 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
468 }
469
470 /**
471 * @tc.name: I18nServiceFuncTest029
472 * @tc.desc: Test I18nServiceAbilityClient SetTemperatureType: set temperature type kelvin.
473 * @tc.type: FUNC
474 */
475 HWTEST_F(I18nServiceTest, I18nServiceFuncTest029, TestSize.Level1)
476 {
477 InitTestEnvironment();
478 AddNativeTokenTypeAndPermissions();
479 I18nErrorCode err = I18nServiceAbilityClient::SetTemperatureType(TemperatureType::KELVIN);
480 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
481 }
482
483 /**
484 * @tc.name: I18nServiceFuncTest030
485 * @tc.desc: Test I18nServiceAbilityClient SetFirstDayOfWeek: set first day of week SUN.
486 * @tc.type: FUNC
487 */
488 HWTEST_F(I18nServiceTest, I18nServiceFuncTest030, TestSize.Level1)
489 {
490 InitTestEnvironment();
491 AddNativeTokenTypeAndPermissions();
492 I18nErrorCode err = I18nServiceAbilityClient::SetFirstDayOfWeek(WeekDay::SUN);
493 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
494 }
495
496 /**
497 * @tc.name: I18nServiceFuncTest031
498 * @tc.desc: Test I18nServiceAbilityClient set and get Collation
499 * @tc.type: FUNC
500 */
501 HWTEST_F(I18nServiceTest, I18nServiceFuncTest031, TestSize.Level1)
502 {
503 InitTestEnvironment();
504 AddNativeTokenTypeAndPermissions();
505 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("en-Latn-US");
506 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
507 err = I18nServiceAbilityClient::SetSystemLocale("en-Latn-US");
508 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
509
510 std::unordered_map<std::string, std::string> systemCollations;
511 err = I18nServiceAbilityClient::GetSystemCollations(systemCollations);
512 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
513 EXPECT_TRUE(systemCollations.find("lower") != systemCollations.end());
514 EXPECT_TRUE(systemCollations.find("upper") != systemCollations.end());
515 err = I18nServiceAbilityClient::SetSystemCollation("upper");
516 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
517 std::string usingCollation;
518 err = I18nServiceAbilityClient::GetUsingCollation(usingCollation);
519 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
520 EXPECT_EQ(usingCollation, "upper");
521 }
522
523 /**
524 * @tc.name: I18nServiceFuncTest032
525 * @tc.desc: Test I18nServiceAbilityClient set and get numbering system
526 * @tc.type: FUNC
527 */
528 HWTEST_F(I18nServiceTest, I18nServiceFuncTest032, TestSize.Level1)
529 {
530 InitTestEnvironment();
531 AddNativeTokenTypeAndPermissions();
532 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("ar");
533 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
534 err = I18nServiceAbilityClient::SetSystemLocale("ar-CN");
535 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
536
537 std::unordered_map<std::string, std::string> systemNumberingSystems;
538 err = I18nServiceAbilityClient::GetSystemNumberingSystems(systemNumberingSystems);
539 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
540 EXPECT_TRUE(systemNumberingSystems.find("arab") != systemNumberingSystems.end());
541 EXPECT_TRUE(systemNumberingSystems.find("latn") != systemNumberingSystems.end());
542 err = I18nServiceAbilityClient::SetSystemNumberingSystem("latn");
543 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
544 std::string usingNumberingSystem;
545 err = I18nServiceAbilityClient::GetUsingNumberingSystem(usingNumberingSystem);
546 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
547 EXPECT_EQ(usingNumberingSystem, "latn");
548 }
549
550 /**
551 * @tc.name: I18nServiceFuncTest033
552 * @tc.desc: Test I18nServiceAbilityClient set and get number pattern
553 * @tc.type: FUNC
554 */
555 HWTEST_F(I18nServiceTest, I18nServiceFuncTest033, TestSize.Level1)
556 {
557 InitTestEnvironment();
558 AddNativeTokenTypeAndPermissions();
559 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("zh-Hans");
560 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
561 err = I18nServiceAbilityClient::SetSystemLocale("zh-Hans-CN");
562 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
563
564 std::unordered_map<std::string, std::string> systemNumberPatterns;
565 err = I18nServiceAbilityClient::GetSystemNumberPatterns(systemNumberPatterns);
566 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
567 EXPECT_TRUE(systemNumberPatterns.find("002c002e") != systemNumberPatterns.end());
568 EXPECT_TRUE(systemNumberPatterns.find("0000002e") != systemNumberPatterns.end());
569 EXPECT_TRUE(systemNumberPatterns.find("002e002c") != systemNumberPatterns.end());
570 EXPECT_TRUE(systemNumberPatterns.find("0000002c") != systemNumberPatterns.end());
571 err = I18nServiceAbilityClient::SetSystemNumberPattern("002e002c");
572 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
573 std::string usingNumberPattern;
574 err = I18nServiceAbilityClient::GetUsingNumberPattern(usingNumberPattern);
575 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
576 EXPECT_EQ(usingNumberPattern, "002e002c");
577 }
578
579 /**
580 * @tc.name: I18nServiceFuncTest034
581 * @tc.desc: Test I18nServiceAbilityClient set and get measurement
582 * @tc.type: FUNC
583 */
584 HWTEST_F(I18nServiceTest, I18nServiceFuncTest034, TestSize.Level1)
585 {
586 InitTestEnvironment();
587 AddNativeTokenTypeAndPermissions();
588 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("zh-Hans");
589 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
590 err = I18nServiceAbilityClient::SetSystemLocale("zh-Hans-CN");
591 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
592
593 std::unordered_map<std::string, std::string> systemMeasurements;
594 err = I18nServiceAbilityClient::GetSystemMeasurements(systemMeasurements);
595 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
596 EXPECT_TRUE(systemMeasurements.find("uksystem") != systemMeasurements.end());
597 EXPECT_TRUE(systemMeasurements.find("metric") != systemMeasurements.end());
598 EXPECT_TRUE(systemMeasurements.find("ussystem") != systemMeasurements.end());
599 err = I18nServiceAbilityClient::SetSystemMeasurement("ussystem");
600 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
601 std::string usingMeasurement;
602 err = I18nServiceAbilityClient::GetUsingMeasurement(usingMeasurement);
603 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
604 EXPECT_EQ(usingMeasurement, "ussystem");
605 }
606
607 /**
608 * @tc.name: I18nServiceFuncTest035
609 * @tc.desc: Test I18nServiceAbilityClient set and get numerical date patterns
610 * @tc.type: FUNC
611 */
612 HWTEST_F(I18nServiceTest, I18nServiceFuncTest035, TestSize.Level1)
613 {
614 InitTestEnvironment();
615 AddNativeTokenTypeAndPermissions();
616 I18nErrorCode err = I18nServiceAbilityClient::SetSystemLanguage("zh-Hans");
617 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
618 err = I18nServiceAbilityClient::SetSystemLocale("zh-Hans-CN");
619 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
620 std::unordered_map<std::string, std::string> numericalDatePatterns;
621 err = I18nServiceAbilityClient::GetSystemNumericalDatePatterns(numericalDatePatterns);
622 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
623 EXPECT_TRUE(numericalDatePatterns.find("d/MM/y") != numericalDatePatterns.end());
624 EXPECT_TRUE(numericalDatePatterns.find("d/M/yy") != numericalDatePatterns.end());
625 EXPECT_TRUE(numericalDatePatterns.find("y-MM-d") != numericalDatePatterns.end());
626 EXPECT_TRUE(numericalDatePatterns.find("d/M/y") != numericalDatePatterns.end());
627 EXPECT_TRUE(numericalDatePatterns.find("d/MM/yy") != numericalDatePatterns.end());
628 EXPECT_TRUE(numericalDatePatterns.find("d.MM.yy") != numericalDatePatterns.end());
629 EXPECT_TRUE(numericalDatePatterns.find("yy/MM/d") != numericalDatePatterns.end());
630 EXPECT_TRUE(numericalDatePatterns.find("d.MM.y") != numericalDatePatterns.end());
631 EXPECT_TRUE(numericalDatePatterns.find("d-MM-y") != numericalDatePatterns.end());
632 EXPECT_TRUE(numericalDatePatterns.find("y/M/d") != numericalDatePatterns.end());
633 EXPECT_TRUE(numericalDatePatterns.find("d-M-y") != numericalDatePatterns.end());
634
635 err = I18nServiceAbilityClient::SetSystemNumericalDatePattern("d-M-y");
636 EXPECT_EQ(err, I18nErrorCode::SUCCESS);
637
638 std::string identifier;
639 err = I18nServiceAbilityClient::GetUsingNumericalDatePattern(identifier);
640 EXPECT_EQ(identifier, "d-M-y");
641 }
642 } // namespace I18n
643 } // namespace Global
644 } // namespace OHOS