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 #define MLOG_TAG "FileExtUnitTest"
16
17 #include "ringtone_data_manager_test.h"
18
19 #include <iostream>
20
21 #include "ability_context_impl.h"
22 #include "datashare_helper.h"
23 #include "get_self_permissions.h"
24 #include "iservice_registry.h"
25 #define private public
26 #include "ringtone_data_manager.h"
27 #undef private
28 #include "ringtone_errno.h"
29 #include "ringtone_fetch_result.h"
30 #include "ringtone_file_utils.h"
31 #include "ringtone_log.h"
32 #include "ringtone_rdbstore.h"
33
34 using namespace std;
35 using namespace testing::ext;
36
37 namespace OHOS {
38 namespace Media {
39 const string RINGTONE_LIBRARY_PATH = "/storage/cloud/files/Ringtone";
40 const string VIBRATE_LIBRARY_PATH = "/storage/cloud/files/Vibrate";
41 const string MTP_FORMAT_OGG = ".ogg"; // OGG audio files
42 const string MTP_FORMAT_MP3 = ".mp3"; // MP3 audio files
43 const string VIBRATE_FORMAT_JSON = ".json";
44 const string TEST_INSERT_RINGTONE_LIBRARY = "test_insert_ringtone_library";
45 const string TEST_INSERT_VIBRATE_LIBRARY = "test_insert_ringtone_library";
46 const int TEST_RINGTONE_COLUMN_SIZE = 1022;
47 const string RAINNING = "rainning";
48 const int TEST_RINGTONE_COLUMN_TONE_TYPE = 2;
49 const int TEST_VIBRATE_COLUMN_VIBRATE_TYPE = 1;
50 const int TEST_VIBRATE_COLUMN_SOURCE_TYPE = 1;
51 const int TEST_SIMCARD_SETTING_MODE = 1;
52 const string MP3 = "mp3";
53 const string JSON = "json";
54 const string ERROR_RINGTONE_TABLE = "ThotoFiles";
55 const string SELECT_STR = " < ? ";
56
SetUpTestCase()57 void RingtoneDataManagerUnitTest::SetUpTestCase()
58 {
59 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
60 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
61 abilityContextImpl->SetStageContext(stageContext);
62 auto ret = RingtoneDataManager::GetInstance()->Init(abilityContextImpl);
63 CHECK_AND_RETURN_LOG(ret == E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
64
65 vector<string> perms;
66 perms.push_back("ohos.permission.WRITE_RINGTONE");
67
68 uint64_t tokenId = 0;
69 RingtonePermissionUtilsUnitTest::SetAccessTokenPermission("RingtoneDataManagerUnitTest", perms, tokenId);
70 ASSERT_TRUE(tokenId != 0);
71 }
72
TearDownTestCase()73 void RingtoneDataManagerUnitTest::TearDownTestCase()
74 {
75 system("rm -rf /storage/cloud/files/");
76 auto dataManager = RingtoneDataManager::GetInstance();
77 EXPECT_NE(dataManager, nullptr);
78 dataManager->ClearRingtoneDataMgr();
79 }
80
SetUp(void)81 void RingtoneDataManagerUnitTest::SetUp(void)
82 {
83 system("rm -rf /storage/cloud/files/");
84 system("mkdir /storage/cloud/files");
85 system("mkdir /storage/cloud/files/Ringtone");
86 }
87
TearDown(void)88 void RingtoneDataManagerUnitTest::TearDown(void) {}
89
90 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_001, TestSize.Level0)
91 {
92 RINGTONE_INFO_LOG("dataManager_Insert_Test_001::Start");
93 Uri uri(RINGTONE_PATH_URI);
94 DataShare::DataShareValuesBucket valuesBucket;
95 valuesBucket.Put(RINGTONE_COLUMN_DATA,
96 static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
97 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
98 valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
99 valuesBucket.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
100 valuesBucket.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
101 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
102 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
103 auto dataManager = RingtoneDataManager::GetInstance();
104 EXPECT_NE(dataManager, nullptr);
105 auto retVal = dataManager->Insert(cmd, valuesBucket);
106 EXPECT_EQ((retVal > 0), true);
107 RINGTONE_INFO_LOG("dataManager_Insert_Test_001::retVal = %{public}d. End", retVal);
108 }
109
110 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_002, TestSize.Level0)
111 {
112 RINGTONE_INFO_LOG("dataManager_Insert_Test_002::Start");
113 Uri uri(RINGTONE_PATH_URI);
114 DataShare::DataShareValuesBucket valuesBucket;
115 valuesBucket.Put(RINGTONE_COLUMN_DATA,
116 static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
117 TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
118 valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
119 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
120 valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3);
121 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
122 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
123 auto dataManager = RingtoneDataManager::GetInstance();
124 EXPECT_NE(dataManager, nullptr);
125 auto retVal = dataManager->Insert(cmd, valuesBucket);
126 EXPECT_EQ((retVal > 0), true);
127 RINGTONE_INFO_LOG("dataManager_Insert_Test_002::retVal = %{public}d. End", retVal);
128 }
129
130 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_003, TestSize.Level0)
131 {
132 RINGTONE_INFO_LOG("dataManager_Insert_Test_003::Start");
133 Uri uri(RINGTONE_PATH_URI);
134 DataShare::DataShareValuesBucket valuesBucket;
135 valuesBucket.Put(RINGTONE_COLUMN_DATA, RINGTONE_DEFAULT_STR);
136 valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
137 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
138 valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3);
139 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
140 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
141 auto dataManager = RingtoneDataManager::GetInstance();
142 EXPECT_NE(dataManager, nullptr);
143 auto retVal = dataManager->Insert(cmd, valuesBucket);
144 EXPECT_EQ(retVal, E_VIOLATION_PARAMETERS);
145 RINGTONE_INFO_LOG("dataManager_Insert_Test_003::retVal = %{public}d. End", retVal);
146 }
147
148 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_004, TestSize.Level0)
149 {
150 RINGTONE_INFO_LOG("dataManager_Insert_Test_004::Start");
151 Uri uri(RINGTONE_PATH_URI);
152 const string errorRingtoneLibraryPath = "/storage/cloud/files/Photo";
153 DataShare::DataShareValuesBucket valuesBucket;
154 valuesBucket.Put(RINGTONE_COLUMN_DATA,
155 static_cast<string>(errorRingtoneLibraryPath + RINGTONE_SLASH_CHAR +
156 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
157 valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
158 valuesBucket.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
159 valuesBucket.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
160 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
161 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
162 auto dataManager = RingtoneDataManager::GetInstance();
163 EXPECT_NE(dataManager, nullptr);
164 auto retVal = dataManager->Insert(cmd, valuesBucket);
165 EXPECT_EQ(retVal, E_ERR);
166 RINGTONE_INFO_LOG("dataManager_Insert_Test_004::retVal = %{public}d. End", retVal);
167 }
168
169 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_005, TestSize.Level0)
170 {
171 RINGTONE_INFO_LOG("dataManager_Insert_Test_005::Start");
172 Uri uri(RINGTONE_PATH_URI);
173 DataShare::DataShareValuesBucket valuesBucket;
174 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
175 auto dataManager = RingtoneDataManager::GetInstance();
176 EXPECT_NE(dataManager, nullptr);
177 auto retVal = dataManager->Insert(cmd, valuesBucket);
178 EXPECT_EQ(retVal, E_INVALID_VALUES);
179 RINGTONE_INFO_LOG("dataManager_Insert_Test_005::retVal = %{public}d. End", retVal);
180 }
181
182 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_006, TestSize.Level0)
183 {
184 RINGTONE_INFO_LOG("dataManager_Insert_Test_006::Start");
185 Uri uri(RINGTONE_PATH_URI);
186 DataShare::DataShareValuesBucket valuesBucket;
187 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
188 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
189 auto dataManager = RingtoneDataManager::GetInstance();
190 ASSERT_NE(dataManager, nullptr);
191 dataManager->refCnt_ = 0;
192 auto retVal = dataManager->Insert(cmd, valuesBucket);
193 EXPECT_EQ(retVal, E_FAIL);
194 RINGTONE_INFO_LOG("dataManager_Insert_Test_006::retVal = %{public}d. End", retVal);
195 }
196
197 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_007, TestSize.Level0)
198 {
199 RINGTONE_INFO_LOG("dataManager_Insert_Test_007::Start");
200 Uri uri(RINGTONE_PATH_URI);
201 DataShare::DataShareValuesBucket valuesBucket;
202 auto dataManager = RingtoneDataManager::GetInstance();
203 ASSERT_NE(dataManager, nullptr);
204 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
205 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
206 ASSERT_NE(abilityContextImpl, nullptr);
207 abilityContextImpl->SetStageContext(stageContext);
208 auto result = dataManager->Init(abilityContextImpl);
209 EXPECT_EQ(result, E_OK);
210 valuesBucket.Put(RINGTONE_COLUMN_DATA,
211 static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
212 TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
213 valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
214 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
215 valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3);
216 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
217 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
218 shared_ptr<RingtoneUnistore> uniStore = RingtoneRdbStore::GetInstance(abilityContextImpl);
219 ASSERT_NE(uniStore, nullptr);
220 uniStore->Stop();
221 auto retVal = dataManager->Insert(cmd, valuesBucket);
222 EXPECT_EQ(retVal, E_HAS_DB_ERROR);
223 uniStore->Init();
224 RINGTONE_INFO_LOG("dataManager_Insert_Test_007::End");
225 }
226
227 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_008, TestSize.Level0)
228 {
229 RINGTONE_INFO_LOG("dataManager_Insert_Test_008::Start");
230 Uri uri(SIMCARD_SETTING_PATH_URI);
231 DataShare::DataShareValuesBucket valuesBucket;
232 valuesBucket.Put(SIMCARD_SETTING_COLUMN_MODE, static_cast<int>(TEST_SIMCARD_SETTING_MODE));
233 RingtoneDataCommand cmd(uri, SIMCARD_SETTING_TABLE, RingtoneOperationType::INSERT);
234 auto dataManager = RingtoneDataManager::GetInstance();
235 ASSERT_NE(dataManager, nullptr);
236 auto retVal = dataManager->Insert(cmd, valuesBucket);
237 EXPECT_TRUE(retVal > 0);
238 RINGTONE_INFO_LOG("dataManager_Insert_Test_008::retVal = %{public}d. End", retVal);
239 }
240
241 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_001, TestSize.Level0)
242 {
243 RINGTONE_INFO_LOG("dataManager_Query_Test_001::Start");
244 vector<string> columns;
245 DataShare::DataSharePredicates predicates;
246 const string specialStr = " <> ";
247 const int index = 3;
248 string prefix = RINGTONE_COLUMN_MEDIA_TYPE + specialStr + to_string(index);
249 predicates.SetWhereClause(prefix);
250 Uri uri(RINGTONE_PATH_URI);
251 int errCode = 0;
252 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
253 auto dataManager = RingtoneDataManager::GetInstance();
254 EXPECT_NE(dataManager, nullptr);
255 auto queryResultSet = dataManager->Query(cmd, columns, predicates, errCode);
256 EXPECT_NE((queryResultSet == nullptr), true);
257 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
258 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
259 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
260 EXPECT_EQ(results->GetCount() > 0, true);
261 cout << "query count = " << to_string(results->GetCount()) << endl;
262 RINGTONE_INFO_LOG("dataManager_Query_Test_001::End");
263 }
264
265 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_002, TestSize.Level0)
266 {
267 RINGTONE_INFO_LOG("dataManager_Query_Test_002::Start");
268 Uri uri(RINGTONE_PATH_URI);
269 int errCode = 0;
270 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
271 DataShare::DataSharePredicates queryPredicates;
272 queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, to_string(TEST_RINGTONE_COLUMN_TONE_TYPE));
273 vector<string> columns;
274 auto dataManager = RingtoneDataManager::GetInstance();
275 EXPECT_NE(dataManager, nullptr);
276 auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
277 EXPECT_NE((queryResultSet == nullptr), true);
278 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
279 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
280 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
281 cout << "query count = " << to_string(results->GetCount()) << endl;
282 RINGTONE_INFO_LOG("dataManager_Query_Test_002::End");
283 }
284
285 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_003, TestSize.Level0)
286 {
287 RINGTONE_INFO_LOG("dataManager_Query_Test_003::Start");
288 Uri uri(RINGTONE_PATH_URI);
289 int errCode = 0;
290 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
291 DataShare::DataSharePredicates queryPredicates;
292 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
293 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DISPLAY_NAME },
294 { RINGTONE_COLUMN_DATA }, { RINGTONE_COLUMN_SHOT_TONE_TYPE } };
295 auto dataManager = RingtoneDataManager::GetInstance();
296 EXPECT_NE(dataManager, nullptr);
297 auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
298 EXPECT_NE((queryResultSet == nullptr), true);
299 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
300 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
301 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
302 cout << "query count = " << to_string(results->GetCount()) << endl;
303 RINGTONE_INFO_LOG("dataManager_Query_Test_003::End");
304 }
305
306 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_004, TestSize.Level0)
307 {
308 RINGTONE_INFO_LOG("dataManager_Query_Test_004::Start");
309 Uri uri(RINGTONE_PATH_URI);
310 int errCode = 0;
311 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
312 DataShare::DataSharePredicates queryPredicates;
313 queryPredicates.EqualTo(RINGTONE_COLUMN_ALARM_TONE_TYPE, to_string(1));
314 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DISPLAY_NAME },
315 { RINGTONE_COLUMN_DATE_ADDED }, { RINGTONE_COLUMN_SHOT_TONE_TYPE } };
316 auto dataManager = RingtoneDataManager::GetInstance();
317 EXPECT_NE(dataManager, nullptr);
318 auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
319 EXPECT_NE((queryResultSet == nullptr), true);
320 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
321 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
322 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
323 EXPECT_EQ(results->GetCount() == 0, true);
324 cout << "query count = " << to_string(results->GetCount()) << endl;
325 RINGTONE_INFO_LOG("dataManager_Query_Test_004::End");
326 }
327
328 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_005, TestSize.Level0)
329 {
330 RINGTONE_INFO_LOG("dataManager_Query_Test_005::Start");
331 Uri uri(RINGTONE_PATH_URI);
332 int errCode = 0;
333 RingtoneDataCommand cmd(uri, ERROR_RINGTONE_TABLE, RingtoneOperationType::QUERY);
334 DataShare::DataSharePredicates queryPredicates;
335 vector<string> columns;
336 auto dataManager = RingtoneDataManager::GetInstance();
337 EXPECT_NE(dataManager, nullptr);
338 auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
339 EXPECT_NE((queryResultSet == nullptr), true);
340 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
341 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
342 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
343 EXPECT_EQ(results->GetCount() == 0, true);
344 cout << "query count = " << to_string(results->GetCount()) << endl;
345 RINGTONE_INFO_LOG("dataManager_Query_Test_005::End");
346 }
347
348 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Vibrate_Test_001, TestSize.Level0)
349 {
350 RINGTONE_INFO_LOG("dataManager_Query_Vibrate_Test_001::Start");
351 vector<string> columns;
352 DataShare::DataSharePredicates predicates;
353 const string specialStr = " <> ";
354 const int index = 1;
355 string prefix = VIBRATE_COLUMN_VIBRATE_TYPE + specialStr + to_string(index);
356 predicates.SetWhereClause(prefix);
357 Uri uri(VIBRATE_PATH_URI);
358 int errCode = 0;
359 RingtoneDataCommand cmd(uri, VIBRATE_TABLE, RingtoneOperationType::QUERY);
360 auto dataManager = RingtoneDataManager::GetInstance();
361 EXPECT_NE(dataManager, nullptr);
362 auto queryResultSet = dataManager->Query(cmd, columns, predicates, errCode);
363 EXPECT_NE((queryResultSet == nullptr), true);
364 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
365 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
366 auto results = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSet));
367 EXPECT_EQ(results->GetCount() >= 0, true);
368 cout << "query count = " << to_string(results->GetCount()) << endl;
369 RINGTONE_INFO_LOG("dataManager_Query_Vibrate_Test_001::End");
370 }
371
372 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Vibrate_Test_002, TestSize.Level0)
373 {
374 RINGTONE_INFO_LOG("dataManager_Query_Vibrate_Test_002::Start");
375 Uri uri(VIBRATE_PATH_URI);
376 int errCode = 0;
377 RingtoneDataCommand cmd(uri, VIBRATE_TABLE, RingtoneOperationType::QUERY);
378 DataShare::DataSharePredicates queryPredicates;
379 queryPredicates.EqualTo(VIBRATE_COLUMN_SOURCE_TYPE, to_string(TEST_VIBRATE_COLUMN_SOURCE_TYPE));
380 vector<string> columns;
381 auto dataManager = RingtoneDataManager::GetInstance();
382 EXPECT_NE(dataManager, nullptr);
383 auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
384 EXPECT_NE((queryResultSet == nullptr), true);
385 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
386 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
387 auto results = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSet));
388 cout << "query count = " << to_string(results->GetCount()) << endl;
389 RINGTONE_INFO_LOG("dataManager_Query_Vibrate_Test_002::End");
390 }
391
392 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Vibrate_Test_003, TestSize.Level0)
393 {
394 RINGTONE_INFO_LOG("dataManager_Query_Vibrate_Test_003::Start");
395 Uri uri(VIBRATE_PATH_URI);
396 int errCode = 0;
397 RingtoneDataCommand cmd(uri, VIBRATE_TABLE, RingtoneOperationType::QUERY);
398 DataShare::DataSharePredicates queryPredicates;
399 queryPredicates.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE, to_string(TEST_VIBRATE_COLUMN_VIBRATE_TYPE));
400 vector<string> columns = { { VIBRATE_COLUMN_VIBRATE_ID }, { VIBRATE_COLUMN_DISPLAY_NAME },
401 { VIBRATE_COLUMN_DATA }, { VIBRATE_COLUMN_VIBRATE_TYPE } };
402 auto dataManager = RingtoneDataManager::GetInstance();
403 EXPECT_NE(dataManager, nullptr);
404 auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
405 EXPECT_NE((queryResultSet == nullptr), true);
406 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
407 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
408 auto results = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSet));
409 cout << "query count = " << to_string(results->GetCount()) << endl;
410 RINGTONE_INFO_LOG("dataManager_Query_Vibrate_Test_003::End");
411 }
412
413 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_001, TestSize.Level0)
414 {
415 RINGTONE_INFO_LOG("dataManager_Update_Test_001::Start");
416 DataShare::DataSharePredicates predicates;
417
418 DataShare::DataShareValuesBucket valuesBucketUpdate;
419 valuesBucketUpdate.Put(RINGTONE_COLUMN_TONE_TYPE, 0);
420
421 Uri uri(RINGTONE_PATH_URI);
422 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
423 auto dataManager = RingtoneDataManager::GetInstance();
424 EXPECT_NE(dataManager, nullptr);
425 auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
426 EXPECT_EQ((retVal > 0), true);
427 RINGTONE_INFO_LOG("dataManager_Update_Test_001::retVal = %{public}d. End", retVal);
428 }
429
430 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_002, TestSize.Level0)
431 {
432 RINGTONE_INFO_LOG("dataManager_Update_Test_002::Start");
433 vector<string> updateIds;
434 updateIds.push_back(to_string(1));
435 DataShare::DataSharePredicates predicates;
436
437 DataShare::DataShareValuesBucket valuesBucketUpdate;
438
439 Uri uri(RINGTONE_PATH_URI);
440 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
441 auto dataManager = RingtoneDataManager::GetInstance();
442 EXPECT_NE(dataManager, nullptr);
443 auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
444 EXPECT_EQ(retVal, E_INVALID_VALUES);
445 RINGTONE_INFO_LOG("dataManager_Update_Test_002::retVal = %{public}d. End", retVal);
446 }
447
448 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_003, TestSize.Level0)
449 {
450 RINGTONE_INFO_LOG("dataManager_Update_Test_003::Start");
451 DataShare::DataSharePredicates predicates;
452 predicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + SELECT_STR);
453
454 DataShare::DataShareValuesBucket valuesBucketUpdate;
455 valuesBucketUpdate.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, 0);
456 valuesBucketUpdate.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, 0);
457
458 Uri uri(RINGTONE_PATH_URI);
459 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
460 auto dataManager = RingtoneDataManager::GetInstance();
461 EXPECT_NE(dataManager, nullptr);
462 auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
463 EXPECT_EQ(retVal, E_HAS_DB_ERROR);
464 RINGTONE_INFO_LOG("dataManager_Update_Test_003::retVal = %{public}d. End", retVal);
465 }
466
467 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_004, TestSize.Level0)
468 {
469 RINGTONE_INFO_LOG("dataManager_Update_Test_004::Start");
470 vector<string> updateIds;
471 updateIds.push_back(to_string(1));
472 DataShare::DataSharePredicates predicates;
473 predicates.In(RINGTONE_COLUMN_TONE_ID, updateIds);
474
475 DataShare::DataShareValuesBucket valuesBucketUpdate;
476
477 Uri uri(RINGTONE_PATH_URI);
478 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
479 auto dataManager = RingtoneDataManager::GetInstance();
480 EXPECT_NE(dataManager, nullptr);
481 auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
482 EXPECT_EQ(retVal, E_INVALID_VALUES);
483 RINGTONE_INFO_LOG("dataManager_Update_Test_004::retVal = %{public}d. End", retVal);
484 }
485
486 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_005, TestSize.Level0)
487 {
488 RINGTONE_INFO_LOG("dataManager_Update_Test_005::Start");
489 vector<string> updateIds;
490 updateIds.push_back(to_string(1));
491 DataShare::DataSharePredicates predicates;
492 predicates.In(RINGTONE_COLUMN_TONE_ID, updateIds);
493
494 DataShare::DataShareValuesBucket valuesBucketUpdate;
495 valuesBucketUpdate.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, 0);
496 valuesBucketUpdate.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, 0);
497
498 Uri uri(RINGTONE_PATH_URI);
499 RingtoneDataCommand cmd(uri, ERROR_RINGTONE_TABLE, RingtoneOperationType::UPDATE);
500 auto dataManager = RingtoneDataManager::GetInstance();
501 EXPECT_NE(dataManager, nullptr);
502 auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
503 EXPECT_EQ(retVal, E_HAS_DB_ERROR);
504 RINGTONE_INFO_LOG("dataManager_Update_Test_005::retVal = %{public}d. End", retVal);
505 }
506
507 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_001, TestSize.Level0)
508 {
509 Uri uri(RINGTONE_PATH_URI);
510 DataShare::DataShareValuesBucket valuesBucket;
511 valuesBucket.Put(RINGTONE_COLUMN_DATA,
512 static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
513 TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
514 valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
515 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
516 valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3);
517 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
518 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
519 auto dataManager = RingtoneDataManager::GetInstance();
520 EXPECT_NE(dataManager, nullptr);
521 auto retVal = dataManager->Insert(cmd, valuesBucket);
522 EXPECT_EQ((retVal > 0), true);
523
524 int errCode = 0;
525 RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
526 DataShare::DataSharePredicates queryPredicates;
527 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
528 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA } };
529 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
530 EXPECT_NE((queryResultSet == nullptr), true);
531 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
532 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
533 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
534 cout << "query count = " << to_string(results->GetCount()) << endl;
535
536 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
537 if (ringtoneAsset != nullptr && ringtoneAsset->GetPath() != RINGTONE_DEFAULT_STR) {
538 string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(ringtoneAsset->GetId());
539 Uri ofUri(uriStr);
540 RingtoneDataCommand cmdOpen(ofUri, RINGTONE_TABLE, RingtoneOperationType::OPEN);
541 auto fd = dataManager->OpenFile(cmdOpen, RINGTONE_FILEMODE_READWRITE);
542 EXPECT_GE(fd, 0);
543 cout << "OpenFile fd = " << fd << endl;
544 if (fd >= 0) {
545 close(fd);
546 }
547 }
548 }
549
550 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_002, TestSize.Level0)
551 {
552 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_002::Start");
553 Uri uri(RINGTONE_PATH_URI);
554 int errCode = 0;
555 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
556 DataShare::DataSharePredicates queryPredicates;
557 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
558 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA } };
559 auto dataManager = RingtoneDataManager::GetInstance();
560 EXPECT_NE(dataManager, nullptr);
561 auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
562 EXPECT_NE((queryResultSet == nullptr), true);
563 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
564 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
565 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
566 cout << "query count = " << to_string(results->GetCount()) << endl;
567
568 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
569 if (ringtoneAsset != nullptr && ringtoneAsset->GetPath() != RINGTONE_DEFAULT_STR) {
570 string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(ringtoneAsset->GetId());
571 Uri ofUri(uriStr);
572 auto dataManager = RingtoneDataManager::GetInstance();
573 EXPECT_NE(dataManager, nullptr);
574 RingtoneDataCommand cmd(ofUri, ERROR_RINGTONE_TABLE, RingtoneOperationType::OPEN);
575 auto fd = dataManager->OpenFile(cmd, RINGTONE_FILEMODE_READWRITE);
576 EXPECT_LT(fd, 0);
577 cout << "OpenFile fd = " << fd << endl;
578 if (fd >= 0) {
579 close(fd);
580 }
581 }
582 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_002::End");
583 }
584
585 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_003, TestSize.Level0)
586 {
587 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_003::Start");
588 string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR;
589 Uri ofUri(uriStr);
590 auto dataManager = RingtoneDataManager::GetInstance();
591 EXPECT_NE(dataManager, nullptr);
592 RingtoneDataCommand cmd(ofUri, RINGTONE_TABLE, RingtoneOperationType::OPEN);
593 auto fd = dataManager->OpenFile(cmd, RINGTONE_FILEMODE_READWRITE);
594 EXPECT_LT(fd, 0);
595 if (fd >= 0) {
596 close(fd);
597 }
598 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_003::End");
599 }
600
601 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_004, TestSize.Level0)
602 {
603 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_004::Start");
604 string uriStr;
605 Uri ofUri(uriStr);
606 auto dataManager = RingtoneDataManager::GetInstance();
607 EXPECT_NE(dataManager, nullptr);
608 RingtoneDataCommand cmd(ofUri, RINGTONE_TABLE, RingtoneOperationType::OPEN);
609 auto fd = dataManager->OpenFile(cmd, RINGTONE_FILEMODE_READWRITE);
610 EXPECT_LT(fd, 0);
611 if (fd >= 0) {
612 close(fd);
613 }
614 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_004::End");
615 }
616
617 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_005, TestSize.Level0)
618 {
619 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_005::Start");
620 Uri ofUri(RINGTONE_DEFAULT_STR);
621 auto dataManager = RingtoneDataManager::GetInstance();
622 EXPECT_NE(dataManager, nullptr);
623 RingtoneDataCommand cmd(ofUri, RINGTONE_TABLE, RingtoneOperationType::OPEN);
624 auto fd = dataManager->OpenFile(cmd, RINGTONE_FILEMODE_READWRITE);
625 EXPECT_LT(fd, 0);
626 if (fd >= 0) {
627 close(fd);
628 }
629 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_005::End");
630 }
631
632 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_006, TestSize.Level0)
633 {
634 RINGTONE_INFO_LOG("dataManager_OpenFile_Test_006::Start");
635 Uri uri(VIBRATE_PATH_URI);
636 int errCode = 0;
637 RingtoneDataCommand cmd(uri, VIBRATE_TABLE, RingtoneOperationType::QUERY);
638 DataShare::DataSharePredicates queryPredicates;
639 queryPredicates.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE, to_string(TEST_VIBRATE_COLUMN_VIBRATE_TYPE));
640 vector<string> columns = { { VIBRATE_COLUMN_VIBRATE_ID }, { VIBRATE_COLUMN_DISPLAY_NAME },
641 { VIBRATE_COLUMN_DATA }, { VIBRATE_COLUMN_VIBRATE_TYPE } };
642 auto dataManager = RingtoneDataManager::GetInstance();
643 ASSERT_NE(dataManager, nullptr);
644 auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
645 ASSERT_NE((queryResultSet == nullptr), true);
646 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
647 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
648 auto results = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSet));
649 ASSERT_NE(results, nullptr);
650 cout << "query count = " << to_string(results->GetCount()) << endl;
651
652 unique_ptr<VibrateAsset> vibrateAsset = results->GetFirstObject();
653 if (vibrateAsset != nullptr && vibrateAsset->GetPath() != RINGTONE_DEFAULT_STR) {
654 string uriStr = VIBRATE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(vibrateAsset->GetId());
655 Uri ofUri(uriStr);
656 RingtoneDataCommand cmdOpen(ofUri, VIBRATE_TABLE, RingtoneOperationType::OPEN);
657 dataManager->OpenFile(cmdOpen, RINGTONE_FILEMODE_READWRITE);
658 }
659 }
660
661 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_001, TestSize.Level0)
662 {
663 RINGTONE_INFO_LOG("dataManager_Delete_Test_001::Start");
664 Uri uri(RINGTONE_PATH_URI);
665 DataShare::DataSharePredicates predicates;
666 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
667 auto dataManager = RingtoneDataManager::GetInstance();
668 EXPECT_NE(dataManager, nullptr);
669 auto retVal = dataManager->Delete(cmd, predicates);
670 EXPECT_EQ((retVal > 0), true);
671 RINGTONE_INFO_LOG("dataManager_Delete_Test_001::End");
672 }
673
674 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_002, TestSize.Level0)
675 {
676 RINGTONE_INFO_LOG("dataManager_Delete_Test_002::Start");
677 Uri uri(RINGTONE_PATH_URI);
678 const int32_t deleteId = 2; // delete id
679 DataShare::DataSharePredicates predicates;
680 predicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + SELECT_STR);
681 predicates.SetWhereArgs({ to_string(deleteId) });
682 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
683 auto dataManager = RingtoneDataManager::GetInstance();
684 EXPECT_NE(dataManager, nullptr);
685 auto retVal = dataManager->Delete(cmd, predicates);
686 EXPECT_EQ(retVal, E_HAS_DB_ERROR);
687 RINGTONE_INFO_LOG("dataManager_Delete_Test_002::End");
688 }
689
690 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_003, TestSize.Level0)
691 {
692 RINGTONE_INFO_LOG("dataManager_Delete_Test_003::Start");
693 Uri uri(RINGTONE_PATH_URI);
694 const int32_t deleteId = 7; // delete id
695 DataShare::DataSharePredicates predicates;
696 predicates.SetWhereArgs({ to_string(deleteId) });
697 RingtoneDataCommand cmd(uri, ERROR_RINGTONE_TABLE, RingtoneOperationType::DELETE);
698 auto dataManager = RingtoneDataManager::GetInstance();
699 EXPECT_NE(dataManager, nullptr);
700 auto retVal = dataManager->Delete(cmd, predicates);
701 EXPECT_EQ(retVal, E_HAS_DB_ERROR);
702 RINGTONE_INFO_LOG("dataManager_Delete_Test_003::End");
703 }
704
705 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_004, TestSize.Level0)
706 {
707 RINGTONE_INFO_LOG("dataManager_Delete_Test_004::Start");
708 Uri uri(RINGTONE_PATH_URI);
709 DataShare::DataSharePredicates predicates;
710 predicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + SELECT_STR);
711 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
712 auto dataManager = RingtoneDataManager::GetInstance();
713 EXPECT_NE(dataManager, nullptr);
714 auto retVal = dataManager->Delete(cmd, predicates);
715 EXPECT_EQ(retVal, E_HAS_DB_ERROR);
716 RINGTONE_INFO_LOG("dataManager_Delete_Test_004::End");
717 }
718
719 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_005, TestSize.Level0)
720 {
721 RINGTONE_INFO_LOG("dataManager_Delete_Test_005::Start");
722 Uri uri(RINGTONE_PATH_URI);
723 int32_t deleteId = -1;
724 DataShare::DataSharePredicates predicates;
725 predicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + SELECT_STR);
726 predicates.SetWhereArgs({ to_string(deleteId) });
727 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
728 auto dataManager = RingtoneDataManager::GetInstance();
729 EXPECT_NE(dataManager, nullptr);
730 auto retVal = dataManager->Delete(cmd, predicates);
731 EXPECT_EQ(retVal, E_HAS_DB_ERROR);
732 RINGTONE_INFO_LOG("dataManager_Delete_Test_005::End");
733 }
734
735 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_006, TestSize.Level0)
736 {
737 RINGTONE_INFO_LOG("dataManager_Delete_Test_006::Start");
738 Uri uri(RINGTONE_PATH_URI);
739 DataShare::DataSharePredicates predicates;
740 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
741 auto dataManager = RingtoneDataManager::GetInstance();
742 ASSERT_NE(dataManager, nullptr);
743 dataManager->ClearRingtoneDataMgr();
744 dataManager->refCnt_ = 0;
745 auto retVal = dataManager->Delete(cmd, predicates);
746 EXPECT_EQ(retVal, E_FAIL);
747 RINGTONE_INFO_LOG("dataManager_Delete_Test_006::retVal = %{public}d. End", retVal);
748 }
749
750 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_007, TestSize.Level0)
751 {
752 RINGTONE_INFO_LOG("dataManager_Delete_Test_007::Start");
753 Uri uri(SIMCARD_SETTING_PATH_URI);
754 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
755 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
756 ASSERT_NE(abilityContextImpl, nullptr);
757 abilityContextImpl->SetStageContext(stageContext);
758 auto dataManager = RingtoneDataManager::GetInstance();
759 ASSERT_NE(dataManager, nullptr);
760 auto result = dataManager->Init(abilityContextImpl);
761 EXPECT_EQ(result, E_OK);
762 DataShare::DataSharePredicates predicates;
763 RingtoneDataCommand cmd(uri, SIMCARD_SETTING_TABLE, RingtoneOperationType::DELETE);
764 auto retVal = dataManager->Delete(cmd, predicates);
765 EXPECT_TRUE(retVal > 0);
766 RINGTONE_INFO_LOG("dataManager_Delete_Test_007::retVal = %{public}d. End", retVal);
767 }
768
769 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_GetOwner_Test_001, TestSize.Level0)
770 {
771 auto dataManager = RingtoneDataManager::GetInstance();
772 EXPECT_NE(dataManager, nullptr);
773 shared_ptr<RingtoneDataShareExtension> datashareExternsion = nullptr;
774 dataManager->SetOwner(datashareExternsion);
775 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
776 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
777 abilityContextImpl->SetStageContext(stageContext);
778 auto result = RingtoneDataManager::GetInstance()->Init(abilityContextImpl);
779 EXPECT_EQ(result, E_OK);
780 dataManager->ClearRingtoneDataMgr();
781 auto ret = dataManager->GetOwner();
782 EXPECT_EQ(ret, nullptr);
783 }
784 } // namespace Media
785 } // namespace OHOS
786