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 "rdb_helper.h"
19 #include "ringtone_errno.h"
20 #include "ringtone_type.h"
21 #include "ringtone_rdbstore.h"
22 #define private public
23 #include "ringtone_language_manager.h"
24 #undef private
25
26 using namespace std;
27 using namespace OHOS;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Media {
32
33 enum {
34 DATA_INDEX = 0,
35 DISPLAY_NAME_INDEX,
36 TITLE_INDEX,
37 SOURCE_TYPE_INDEX,
38 DISPLAY_LANGUAGE_TYPE_INDEX,
39 };
40
41 static std::shared_ptr<RingtoneUnistore> g_ringtoneUniStore = nullptr;
42 const std::vector<std::vector<std::string>> g_ringtoneMetadata = {
43 {"/sys_prod/resource/media/audio/alarms/candy.ogg", "candy.ogg", "糖果", "1", "zh-Hans"},
44 {"/sys_prod/resource/media/audio/alarms/spring_outing.ogg", "spring_outing.ogg", "春游", "1", "zh-Hans"},
45 {"/sys_prod/resource/media/audio/alarms/maze.ogg", "maze.ogg", "maze", "1", "en-Latn-US"},
46 {"/sys_prod/resource/media/audio/alarms/didi.ogg", "didi.ogg", "didi", "1", "en-Latn-US"},
47 {"/sys_prod/resource/media/audio/alarms/brook.ogg", "brook.ogg", "brook", "1", ""},
48 {"/sys_prod/resource/media/audio/alarms/kaleidoscope.ogg", "kaleidoscope.ogg", "kaleidoscope", "2", ""},
49 };
50 const std::vector<std::vector<std::string>> g_vibrationMetadata = {
51 {"/sys_prod/resource/media/haptics/standard/synchronized/ringtones/candy.json", "candy.json", "糖果", "1",
52 "zh-Hans"},
53 {"/sys_prod/resource/media/haptics/gentle/synchronized/ringtones/candy.json", "candy.json", "candy", "2", ""},
54 {"/sys_prod/resource/media/haptics/standard/synchronized/ringtones/maze.json", "maze.json", "maze", "1",
55 "en-Latn-US"},
56 {"/sys_prod/resource/media/haptics/gentle/synchronized/ringtones/maze.json", "maze.json", "maze", "2", ""},
57 {"/sys_prod/resource/media/haptics/standard/non-synchronized/brook.json", "brook.json", "溪流", "1", "zh-Hans"},
58 {"/sys_prod/resource/media/haptics/standard/non-synchronized/didi.json", "didi.json", "didi", "1", "en-Latn-US"},
59 };
60 const std::map<std::string, std::map<std::string, std::string>> g_translationResource = {
61 {
62 "zh-Hans", {
63 {"candy", "糖果"},
64 {"spring_outing", "春游"},
65 {"maze", "迷宫"},
66 {"didi", "滴滴"},
67 {"brook", "溪流"},
68 {"kaleidoscope", "万花筒"},
69 }
70 },
71 {
72 "en-Latn-US", {
73 {"candy", "candy"},
74 {"spring_outing", "spring outing"},
75 {"maze", "maze"},
76 {"didi", "didi"},
77 {"brook", "brook"},
78 {"kaleidoscope", "kaleidoscope"},
79 }
80 }
81 };
82
83 const string CHINESE_ABBREVIATION = "zh-Hans";
84 const string ENGLISH_ABBREVIATION = "en-Latn-US";
85 const int32_t RINGTONE_DIFF_AMOUN = 3;
86 const int32_t VIBRATION_DIFF_AMOUN = 2;
87
88 void InitTestData();
89
SetUpTestCase()90 void RingtoneLanguageManagerTest::SetUpTestCase() {}
91
TearDownTestCase()92 void RingtoneLanguageManagerTest::TearDownTestCase() {}
93
94 // SetUp:Execute before each test case
SetUp()95 void RingtoneLanguageManagerTest::SetUp()
96 {
97 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
98 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
99 abilityContextImpl->SetStageContext(stageContext);
100 g_ringtoneUniStore = RingtoneRdbStore::GetInstance(abilityContextImpl);
101 int32_t ret = g_ringtoneUniStore->Init();
102 EXPECT_EQ(ret, E_OK);
103 InitTestData();
104 }
105
TearDown(void)106 void RingtoneLanguageManagerTest::TearDown(void) {}
107
InitTestData()108 void InitTestData()
109 {
110 Uri uri(RINGTONE_PATH_URI);
111 RingtoneDataCommand ringtoneCmdDel(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
112 int32_t rowId = 0;
113 int32_t ret = g_ringtoneUniStore->Delete(ringtoneCmdDel, rowId);
114 EXPECT_EQ(ret, E_OK);
115
116 for (auto &item : g_ringtoneMetadata) {
117 RingtoneDataCommand cmdInsert(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
118 NativeRdb::ValuesBucket values;
119 values.Put(RINGTONE_COLUMN_DATA, item[DATA_INDEX]);
120 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, item[DISPLAY_NAME_INDEX]);
121 values.Put(RINGTONE_COLUMN_TITLE, item[TITLE_INDEX]);
122 values.Put(RINGTONE_COLUMN_SOURCE_TYPE, stoi(item[SOURCE_TYPE_INDEX]));
123 if (!item[DISPLAY_LANGUAGE_TYPE_INDEX].empty()) {
124 values.Put(RINGTONE_COLUMN_DISPLAY_LANGUAGE_TYPE, item[DISPLAY_LANGUAGE_TYPE_INDEX]);
125 }
126 cmdInsert.SetValueBucket(values);
127 int64_t rowId = E_HAS_DB_ERROR;
128 int32_t ret = g_ringtoneUniStore->Insert(cmdInsert, rowId);
129 EXPECT_EQ(ret, E_OK);
130 }
131
132 RingtoneDataCommand vibrationCmdDel(uri, VIBRATE_TABLE, RingtoneOperationType::DELETE);
133 rowId = 0;
134 ret = g_ringtoneUniStore->Delete(vibrationCmdDel, rowId);
135 EXPECT_EQ(ret, E_OK);
136
137 for (auto &item : g_vibrationMetadata) {
138 RingtoneDataCommand cmdInsert(uri, VIBRATE_TABLE, RingtoneOperationType::INSERT);
139 NativeRdb::ValuesBucket values;
140 values.Put(VIBRATE_COLUMN_DATA, item[DATA_INDEX]);
141 values.Put(VIBRATE_COLUMN_DISPLAY_NAME, item[DISPLAY_NAME_INDEX]);
142 values.Put(VIBRATE_COLUMN_TITLE, item[TITLE_INDEX]);
143 values.Put(VIBRATE_COLUMN_VIBRATE_TYPE, stoi(item[SOURCE_TYPE_INDEX]));
144 if (!item[DISPLAY_LANGUAGE_TYPE_INDEX].empty()) {
145 values.Put(VIBRATE_COLUMN_DISPLAY_LANGUAGE, item[DISPLAY_LANGUAGE_TYPE_INDEX]);
146 }
147 cmdInsert.SetValueBucket(values);
148 int64_t rowId = E_HAS_DB_ERROR;
149 int32_t ret = g_ringtoneUniStore->Insert(cmdInsert, rowId);
150 EXPECT_EQ(ret, E_OK);
151 }
152 }
153
154 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByRingtone_test_001, TestSize.Level0)
155 {
156 auto langMgr = RingtoneLanguageManager::GetInstance();
157 langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
158
159 int rowCount = 0;
160 std::shared_ptr<NativeRdb::ResultSet> resultSet;
161 int ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
162 EXPECT_EQ(ret, E_OK);
163 EXPECT_EQ(rowCount, RINGTONE_DIFF_AMOUN);
164 }
165
166 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByRingtone_test_002, TestSize.Level0)
167 {
168 auto langMgr = RingtoneLanguageManager::GetInstance();
169 langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
170
171 int rowCount = 0;
172 std::shared_ptr<NativeRdb::ResultSet> resultSet;
173 int ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
174 EXPECT_EQ(ret, E_OK);
175 EXPECT_EQ(rowCount, RINGTONE_DIFF_AMOUN);
176 }
177
178 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToRingtone_test_001, TestSize.Level0)
179 {
180 auto langMgr = RingtoneLanguageManager::GetInstance();
181 langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
182
183 int rowCount = 0;
184 std::shared_ptr<NativeRdb::ResultSet> resultSet;
185 int32_t ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
186 EXPECT_EQ(ret, E_OK);
187 EXPECT_EQ(rowCount, RINGTONE_DIFF_AMOUN);
188
189 langMgr->ringtoneTranslate_ = g_translationResource;
190 langMgr->ChangeLanguageDataToRingtone(rowCount, resultSet);
191
192 ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
193 EXPECT_EQ(ret, E_OK);
194 EXPECT_EQ(rowCount, 0);
195 }
196
197 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToRingtone_test_002, TestSize.Level0)
198 {
199 auto langMgr = RingtoneLanguageManager::GetInstance();
200 langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
201
202 int rowCount = 0;
203 std::shared_ptr<NativeRdb::ResultSet> resultSet;
204 int32_t ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
205 EXPECT_EQ(ret, E_OK);
206 EXPECT_EQ(rowCount, RINGTONE_DIFF_AMOUN);
207
208 langMgr->ringtoneTranslate_ = g_translationResource;
209 langMgr->ChangeLanguageDataToRingtone(rowCount, resultSet);
210
211 ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
212 EXPECT_EQ(ret, E_OK);
213 EXPECT_EQ(rowCount, 0);
214 }
215
216 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByVibration_test_001, TestSize.Level0)
217 {
218 auto langMgr = RingtoneLanguageManager::GetInstance();
219 langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
220
221 int rowCount = 0;
222 std::shared_ptr<NativeRdb::ResultSet> resultSet;
223 int ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
224 EXPECT_EQ(ret, E_OK);
225 EXPECT_EQ(rowCount, VIBRATION_DIFF_AMOUN);
226 }
227
228 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByVibration_test_002, TestSize.Level0)
229 {
230 auto langMgr = RingtoneLanguageManager::GetInstance();
231 langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
232
233 int rowCount = 0;
234 std::shared_ptr<NativeRdb::ResultSet> resultSet;
235 int ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
236 EXPECT_EQ(ret, E_OK);
237 EXPECT_EQ(rowCount, VIBRATION_DIFF_AMOUN);
238 }
239
240 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToVibration_test_001, TestSize.Level0)
241 {
242 auto langMgr = RingtoneLanguageManager::GetInstance();
243 langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
244
245 int rowCount = 0;
246 std::shared_ptr<NativeRdb::ResultSet> resultSet;
247 int32_t ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
248 EXPECT_EQ(ret, E_OK);
249 EXPECT_EQ(rowCount, VIBRATION_DIFF_AMOUN);
250
251 langMgr->vibrationTranslate_ = g_translationResource;
252 langMgr->ChangeLanguageDataToVibration(rowCount, resultSet);
253
254 ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
255 EXPECT_EQ(ret, E_OK);
256 EXPECT_EQ(rowCount, 0);
257 }
258
259 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToVibration_test_002, TestSize.Level0)
260 {
261 auto langMgr = RingtoneLanguageManager::GetInstance();
262 langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
263
264 int rowCount = 0;
265 std::shared_ptr<NativeRdb::ResultSet> resultSet;
266 int32_t ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
267 EXPECT_EQ(ret, E_OK);
268 EXPECT_EQ(rowCount, VIBRATION_DIFF_AMOUN);
269
270 langMgr->vibrationTranslate_ = g_translationResource;
271 langMgr->ChangeLanguageDataToVibration(rowCount, resultSet);
272
273 ret = langMgr->CheckLanguageTypeByVibration(rowCount, resultSet);
274 EXPECT_EQ(ret, E_OK);
275 EXPECT_EQ(rowCount, 0);
276 }
277 } // namespace Media
278 } // namespace OHOS
279