1 /*
2 * Copyright (C) 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 #include "ringtone_language_manager_test.h"
16
17 #include "ability_context_impl.h"
18 #include "parameter.h"
19 #include "rdb_helper.h"
20 #include "ringtone_errno.h"
21 #include "ringtone_log.h"
22 #include "ringtone_type.h"
23 #define private public
24 #include "ringtone_rdbstore.h"
25 #include "ringtone_language_manager.h"
26 #undef private
27
28 using namespace std;
29 using namespace OHOS;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Media {
34 const char TEST_LANGUAGE_KEY[] = "persist.global.language";
35 const char TEST_DEFAULT_LANGUAGE_KEY[] = "const.global.language";
36 const char TEST_CHINESE_ABBREVIATION[] = "zh-Hans";
37 const char TEST_ENGLISH_ABBREVIATION[] = "en-Latn-US";
38 const char TEST_ABNORMAL_LANGUAGE[] = "";
39 const int32_t TEST_SYSPARA_SIZE = 64;
40
41 enum {
42 DATA_INDEX = 0,
43 DISPLAY_NAME_INDEX,
44 TITLE_INDEX,
45 SOURCE_TYPE_INDEX,
46 DISPLAY_LANGUAGE_TYPE_INDEX,
47 };
48
49 static std::shared_ptr<RingtoneUnistore> g_ringtoneUniStore = nullptr;
50 const std::vector<std::vector<std::string>> g_ringtoneMetadata = {
51 {"/sys_prod/resource/media/audio/alarms/candy.ogg", "candy.ogg", "糖果", "1", "zh-Hans"},
52 {"/sys_prod/resource/media/audio/alarms/spring_outing.ogg", "spring_outing.ogg", "春游", "1", "zh-Hans"},
53 {"/sys_prod/resource/media/audio/alarms/maze.ogg", "maze.ogg", "maze", "1", "en-Latn-US"},
54 {"/sys_prod/resource/media/audio/alarms/didi.ogg", "didi.ogg", "didi", "1", "en-Latn-US"},
55 {"/sys_prod/resource/media/audio/alarms/brook.ogg", "brook.ogg", "brook", "1", ""},
56 {"/sys_prod/resource/media/audio/alarms/kaleidoscope.ogg", "kaleidoscope.ogg", "kaleidoscope", "2", ""},
57 };
58 const std::vector<std::vector<std::string>> g_vibrationMetadata = {
59 {"/sys_prod/resource/media/haptics/standard/synchronized/ringtones/candy.json", "candy.json", "糖果", "1",
60 "zh-Hans"},
61 {"/sys_prod/resource/media/haptics/gentle/synchronized/ringtones/candy.json", "candy.json", "candy", "2", ""},
62 {"/sys_prod/resource/media/haptics/standard/synchronized/ringtones/maze.json", "maze.json", "maze", "1",
63 "en-Latn-US"},
64 {"/sys_prod/resource/media/haptics/gentle/synchronized/ringtones/maze.json", "maze.json", "maze", "2", ""},
65 {"/sys_prod/resource/media/haptics/standard/non-synchronized/brook.json", "brook.json", "溪流", "1", "zh-Hans"},
66 {"/sys_prod/resource/media/haptics/standard/non-synchronized/didi.json", "didi.json", "didi", "1", "en-Latn-US"},
67 };
68 const std::map<std::string, std::map<std::string, std::string>> g_translationResource = {
69 {
70 "zh-Hans", {
71 {"candy", "糖果"},
72 {"spring_outing", "春游"},
73 {"maze", "迷宫"},
74 {"didi", "滴滴"},
75 {"brook", "溪流"},
76 {"kaleidoscope", "万花筒"},
77 }
78 },
79 {
80 "en-Latn-US", {
81 {"candy", "candy"},
82 {"spring_outing", "spring outing"},
83 {"maze", "maze"},
84 {"didi", "didi"},
85 {"brook", "brook"},
86 {"kaleidoscope", "kaleidoscope"},
87 }
88 }
89 };
90
91 const string CHINESE_ABBREVIATION = "zh-Hans";
92 const string ENGLISH_ABBREVIATION = "en-Latn-US";
93 const int32_t RINGTONE_DIFF_AMOUN = 3;
94 const int32_t VIBRATION_DIFF_AMOUN = 2;
95
96 void InitTestData();
97
SetUpTestCase()98 void RingtoneLanguageManagerTest::SetUpTestCase() {}
99
TearDownTestCase()100 void RingtoneLanguageManagerTest::TearDownTestCase() {}
101
102 // SetUp:Execute before each test case
SetUp()103 void RingtoneLanguageManagerTest::SetUp()
104 {
105 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
106 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
107 abilityContextImpl->SetStageContext(stageContext);
108 g_ringtoneUniStore = RingtoneRdbStore::GetInstance(abilityContextImpl);
109 int32_t ret = g_ringtoneUniStore->Init();
110 EXPECT_EQ(ret, E_OK);
111 InitTestData();
112 }
113
TearDown(void)114 void RingtoneLanguageManagerTest::TearDown(void) {}
115
InitTestData()116 void InitTestData()
117 {
118 Uri uri(RINGTONE_PATH_URI);
119 RingtoneDataCommand ringtoneCmdDel(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
120 int32_t rowId = 0;
121 int32_t ret = g_ringtoneUniStore->Delete(ringtoneCmdDel, rowId);
122 EXPECT_EQ(ret, E_OK);
123
124 for (auto &item : g_ringtoneMetadata) {
125 RingtoneDataCommand cmdInsert(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
126 NativeRdb::ValuesBucket values;
127 values.Put(RINGTONE_COLUMN_DATA, item[DATA_INDEX]);
128 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, item[DISPLAY_NAME_INDEX]);
129 values.Put(RINGTONE_COLUMN_TITLE, item[TITLE_INDEX]);
130 values.Put(RINGTONE_COLUMN_SOURCE_TYPE, stoi(item[SOURCE_TYPE_INDEX]));
131 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
132 if (!item[DISPLAY_LANGUAGE_TYPE_INDEX].empty()) {
133 values.Put(RINGTONE_COLUMN_DISPLAY_LANGUAGE_TYPE, item[DISPLAY_LANGUAGE_TYPE_INDEX]);
134 }
135 cmdInsert.SetValueBucket(values);
136 int64_t rowId = E_HAS_DB_ERROR;
137 int32_t ret = g_ringtoneUniStore->Insert(cmdInsert, rowId);
138 EXPECT_EQ(ret, E_OK);
139 }
140
141 RingtoneDataCommand vibrationCmdDel(uri, VIBRATE_TABLE, RingtoneOperationType::DELETE);
142 rowId = 0;
143 ret = g_ringtoneUniStore->Delete(vibrationCmdDel, rowId);
144 EXPECT_EQ(ret, E_OK);
145
146 for (auto &item : g_vibrationMetadata) {
147 RingtoneDataCommand cmdInsert(uri, VIBRATE_TABLE, RingtoneOperationType::INSERT);
148 NativeRdb::ValuesBucket values;
149 values.Put(VIBRATE_COLUMN_DATA, item[DATA_INDEX]);
150 values.Put(VIBRATE_COLUMN_DISPLAY_NAME, item[DISPLAY_NAME_INDEX]);
151 values.Put(VIBRATE_COLUMN_TITLE, item[TITLE_INDEX]);
152 values.Put(VIBRATE_COLUMN_VIBRATE_TYPE, stoi(item[SOURCE_TYPE_INDEX]));
153 if (!item[DISPLAY_LANGUAGE_TYPE_INDEX].empty()) {
154 values.Put(VIBRATE_COLUMN_DISPLAY_LANGUAGE, item[DISPLAY_LANGUAGE_TYPE_INDEX]);
155 }
156 cmdInsert.SetValueBucket(values);
157 int64_t rowId = E_HAS_DB_ERROR;
158 int32_t ret = g_ringtoneUniStore->Insert(cmdInsert, rowId);
159 EXPECT_EQ(ret, E_OK);
160 }
161 }
162
163 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByRingtone_test_001, TestSize.Level0)
164 {
165 auto langMgr = RingtoneLanguageManager::GetInstance();
166 langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
167
168 int rowCount = 0;
169 std::shared_ptr<NativeRdb::ResultSet> resultSet;
170 int ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
171 EXPECT_EQ(ret, E_OK);
172 EXPECT_EQ(rowCount, RINGTONE_DIFF_AMOUN);
173 }
174
175 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByRingtone_test_002, TestSize.Level0)
176 {
177 auto langMgr = RingtoneLanguageManager::GetInstance();
178 langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
179
180 int rowCount = 0;
181 std::shared_ptr<NativeRdb::ResultSet> resultSet;
182 int ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
183 EXPECT_EQ(ret, E_OK);
184 EXPECT_EQ(rowCount, RINGTONE_DIFF_AMOUN);
185 }
186
187 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByRingtone_test_003, TestSize.Level0)
188 {
189 int32_t rowCount = 1;
190 std::shared_ptr<NativeRdb::ResultSet> resultSet;
191 g_ringtoneUniStore->Stop();
192 auto langMgr = RingtoneLanguageManager::GetInstance();
193 EXPECT_NE(langMgr, nullptr);
194 langMgr->ChangeLanguageDataToRingtone(rowCount, resultSet);
195 int32_t result = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
196 EXPECT_EQ(result, E_RDB);
197 g_ringtoneUniStore->Init();
198 }
199
200 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToRingtone_test_001, TestSize.Level0)
201 {
202 auto langMgr = RingtoneLanguageManager::GetInstance();
203 langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
204
205 int rowCount = 0;
206 std::shared_ptr<NativeRdb::ResultSet> resultSet;
207 int32_t ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
208 EXPECT_EQ(ret, E_OK);
209 EXPECT_EQ(rowCount, RINGTONE_DIFF_AMOUN);
210
211 langMgr->ringtoneTranslate_ = g_translationResource;
212 langMgr->ChangeLanguageDataToRingtone(rowCount, resultSet);
213
214 ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
215 EXPECT_EQ(ret, E_OK);
216 EXPECT_EQ(rowCount, 0);
217 }
218
219 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToRingtone_test_002, TestSize.Level0)
220 {
221 auto langMgr = RingtoneLanguageManager::GetInstance();
222 langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
223
224 int rowCount = 0;
225 std::shared_ptr<NativeRdb::ResultSet> resultSet;
226 int32_t ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
227 EXPECT_EQ(ret, E_OK);
228 EXPECT_EQ(rowCount, RINGTONE_DIFF_AMOUN);
229
230 langMgr->ringtoneTranslate_ = g_translationResource;
231 langMgr->ChangeLanguageDataToRingtone(rowCount, resultSet);
232
233 ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
234 EXPECT_EQ(ret, E_OK);
235 EXPECT_EQ(rowCount, 0);
236 }
237
238 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByVibration_test_001, TestSize.Level0)
239 {
240 auto langMgr = RingtoneLanguageManager::GetInstance();
241 langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
242
243 int rowCount = 0;
244 std::shared_ptr<NativeRdb::ResultSet> resultSet;
245 int ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
246 EXPECT_EQ(ret, E_OK);
247 EXPECT_EQ(rowCount, VIBRATION_DIFF_AMOUN);
248 }
249
250 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByVibration_test_002, TestSize.Level0)
251 {
252 auto langMgr = RingtoneLanguageManager::GetInstance();
253 langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
254
255 int rowCount = 0;
256 std::shared_ptr<NativeRdb::ResultSet> resultSet;
257 int ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
258 EXPECT_EQ(ret, E_OK);
259 EXPECT_EQ(rowCount, VIBRATION_DIFF_AMOUN);
260 }
261
262 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByVibration_test_003, TestSize.Level0)
263 {
264 int32_t rowCount = 1;
265 std::shared_ptr<NativeRdb::ResultSet> resultSet;
266 g_ringtoneUniStore->Stop();
267 auto langMgr = RingtoneLanguageManager::GetInstance();
268 EXPECT_NE(langMgr, nullptr);
269 langMgr->ChangeLanguageDataToVibration(rowCount, resultSet);
270 int32_t result = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
271 EXPECT_EQ(result, E_RDB);
272 g_ringtoneUniStore->Init();
273 }
274
275 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToVibration_test_001, TestSize.Level0)
276 {
277 auto langMgr = RingtoneLanguageManager::GetInstance();
278 langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
279
280 int rowCount = 0;
281 std::shared_ptr<NativeRdb::ResultSet> resultSet;
282 int32_t ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
283 EXPECT_EQ(ret, E_OK);
284 EXPECT_EQ(rowCount, VIBRATION_DIFF_AMOUN);
285
286 langMgr->vibrationTranslate_ = g_translationResource;
287 langMgr->ChangeLanguageDataToVibration(rowCount, resultSet);
288
289 ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
290 EXPECT_EQ(ret, E_OK);
291 EXPECT_EQ(rowCount, 0);
292 }
293
294 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToVibration_test_002, TestSize.Level0)
295 {
296 auto langMgr = RingtoneLanguageManager::GetInstance();
297 langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
298
299 int rowCount = 0;
300 std::shared_ptr<NativeRdb::ResultSet> resultSet;
301 int32_t ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
302 EXPECT_EQ(ret, E_OK);
303 EXPECT_EQ(rowCount, VIBRATION_DIFF_AMOUN);
304
305 langMgr->vibrationTranslate_ = g_translationResource;
306 langMgr->ChangeLanguageDataToVibration(rowCount, resultSet);
307
308 ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
309 EXPECT_EQ(ret, E_OK);
310 EXPECT_EQ(rowCount, 0);
311 }
312
313 /*
314 * Feature: Service
315 * Function: Test RingtoneLanguageManager with SyncAssetLanguage
316 * SubFunction: NA
317 * FunctionPoints: NA
318 * EnvConditions: NA
319 * CaseDescription: Test SyncAssetLanguage for normal branches
320 */
321 HWTEST_F(RingtoneLanguageManagerTest, languageManager_SyncAssetLanguage_test_001, TestSize.Level0)
322 {
323 auto langMgr = RingtoneLanguageManager::GetInstance();
324 ASSERT_NE(langMgr, nullptr);
325 std::string language = "test";
326 langMgr->systemLanguage_ = language;
327 langMgr->SyncAssetLanguage();
328 EXPECT_NE(langMgr->systemLanguage_, language);
329 }
330
331 /*
332 * Feature: Service
333 * Function: Test RingtoneLanguageManager with SyncAssetLanguage
334 * SubFunction: NA
335 * FunctionPoints: NA
336 * EnvConditions: NA
337 * CaseDescription: Test SyncAssetLanguage when persist system language is zh-Hans
338 */
339 HWTEST_F(RingtoneLanguageManagerTest, languageManager_SyncAssetLanguage_test_002, TestSize.Level0)
340 {
341 char paramValue[TEST_SYSPARA_SIZE] = {0};
342 auto langMgr = RingtoneLanguageManager::GetInstance();
343 EXPECT_NE(langMgr, nullptr);
344 SetParameter(TEST_LANGUAGE_KEY, TEST_CHINESE_ABBREVIATION);
345 GetParameter(TEST_LANGUAGE_KEY, "", paramValue, TEST_SYSPARA_SIZE);
346 string language = langMgr->GetSystemLanguage();
347 EXPECT_EQ(language, TEST_CHINESE_ABBREVIATION);
348 cout << "language = " << language << endl;
349 langMgr->SyncAssetLanguage();
350 language = langMgr->GetSystemLanguage();
351 EXPECT_EQ(langMgr->systemLanguage_, language);
352 }
353
354 /*
355 * Feature: Service
356 * Function: Test RingtoneLanguageManager with SyncAssetLanguage
357 * SubFunction: NA
358 * FunctionPoints: NA
359 * EnvConditions: NA
360 * CaseDescription: Test SyncAssetLanguage when persist system language is zh-Hans
361 */
362 HWTEST_F(RingtoneLanguageManagerTest, languageManager_SyncAssetLanguage_test_003, TestSize.Level0)
363 {
364 char paramValue[TEST_SYSPARA_SIZE] = {0};
365 auto langMgr = RingtoneLanguageManager::GetInstance();
366 EXPECT_NE(langMgr, nullptr);
367 SetParameter(TEST_LANGUAGE_KEY, TEST_ENGLISH_ABBREVIATION);
368 GetParameter(TEST_LANGUAGE_KEY, "", paramValue, TEST_SYSPARA_SIZE);
369 string language = langMgr->GetSystemLanguage();
370 EXPECT_EQ(language, TEST_ENGLISH_ABBREVIATION);
371 cout << "language = " << language << endl;
372 langMgr->SyncAssetLanguage();
373 language = langMgr->GetSystemLanguage();
374 EXPECT_EQ(langMgr->systemLanguage_, language);
375 }
376
377 /*
378 * Feature: Service
379 * Function: Test RingtoneLanguageManager with SyncAssetLanguage
380 * SubFunction: NA
381 * FunctionPoints: NA
382 * EnvConditions: NA
383 * CaseDescription: Test SyncAssetLanguage when persist system language is en-Latn-US
384 */
385 HWTEST_F(RingtoneLanguageManagerTest, languageManager_SyncAssetLanguage_test_004, TestSize.Level0)
386 {
387 char paramValue[TEST_SYSPARA_SIZE] = {0};
388 auto langMgr = RingtoneLanguageManager::GetInstance();
389 EXPECT_NE(langMgr, nullptr);
390 SetParameter(TEST_LANGUAGE_KEY, TEST_CHINESE_ABBREVIATION);
391 GetParameter(TEST_LANGUAGE_KEY, "", paramValue, TEST_SYSPARA_SIZE);
392 string language = langMgr->GetSystemLanguage();
393 EXPECT_EQ(language, TEST_CHINESE_ABBREVIATION);
394 cout << "language = " << language << endl;
395 langMgr->SyncAssetLanguage();
396 language = langMgr->GetSystemLanguage();
397 EXPECT_EQ(langMgr->systemLanguage_, language);
398 }
399
400 /*
401 * Feature: Service
402 * Function: Test RingtoneLanguageManager with GetSystemLanguage
403 * SubFunction: NA
404 * FunctionPoints: NA
405 * EnvConditions: NA
406 * CaseDescription: Test GetSystemLanguage when default system language
407 */
408 HWTEST_F(RingtoneLanguageManagerTest, languageManager_GetSystemLanguage_test_001, TestSize.Level0)
409 {
410 char paramValue[TEST_SYSPARA_SIZE] = {0};
411 auto langMgr = RingtoneLanguageManager::GetInstance();
412 EXPECT_NE(langMgr, nullptr);
413 SetParameter(TEST_LANGUAGE_KEY, TEST_ABNORMAL_LANGUAGE);
414 SetParameter(TEST_DEFAULT_LANGUAGE_KEY, TEST_CHINESE_ABBREVIATION);
415 GetParameter(TEST_DEFAULT_LANGUAGE_KEY, "", paramValue, TEST_SYSPARA_SIZE);
416 string language = langMgr->GetSystemLanguage();
417 EXPECT_EQ(language, TEST_CHINESE_ABBREVIATION);
418 cout << "language = " << language << endl;
419 }
420
421 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ReadMultilingualResources_test_001, TestSize.Level0)
422 {
423 auto langMgr = RingtoneLanguageManager::GetInstance();
424 ASSERT_NE(langMgr, nullptr);
425
426 string filePath = "data/createfile_001.";
427 ResourceFileType resourceFileType = VIBRATION_FILE;
428 auto ret = langMgr->ReadMultilingualResources(filePath, resourceFileType);
429 EXPECT_EQ(ret, false);
430 }
431
432 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ParseMultilingualXml_test_001, TestSize.Level0)
433 {
434 auto langMgr = RingtoneLanguageManager::GetInstance();
435 ASSERT_NE(langMgr, nullptr);
436
437 xmlNodePtr rootNode = new xmlNode();
438 ASSERT_NE(rootNode, nullptr);
439 ResourceFileType resourceFileType = VIBRATION_FILE;
440 auto ret = langMgr->ParseMultilingualXml(rootNode, resourceFileType);
441 EXPECT_EQ(ret, true);
442 }
443 } // namespace Media
444 } // namespace OHOS
445