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 #include "ringtone_data_manager.h"
26 #include "ringtone_errno.h"
27 #include "ringtone_fetch_result.h"
28 #include "ringtone_file_utils.h"
29 #include "ringtone_log.h"
30 
31 using namespace std;
32 using namespace testing::ext;
33 
34 namespace OHOS {
35 namespace Media {
36 const string RINGTONE_LIBRARY_PATH = "/storage/cloud/files/Ringtone";
37 const string MTP_FORMAT_OGG = ".ogg"; // OGG audio files
38 const string MTP_FORMAT_MP3 = ".mp3"; // MP3 audio files
39 const string TEST_INSERT_RINGTONE_LIBRARY = "test_insert_ringtone_library";
40 const int TEST_RINGTONE_COLUMN_SIZE = 1022;
41 const string RAINNING = "rainning";
42 const int TEST_RINGTONE_COLUMN_TONE_TYPE = 2;
43 const string MP3 = "mp3";
44 const string ERROR_RINGTONE_TABLE = "ThotoFiles";
45 const string SELECT_STR = " < ? ";
46 
SetUpTestCase()47 void RingtoneDataManagerUnitTest::SetUpTestCase()
48 {
49     auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
50     auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
51     abilityContextImpl->SetStageContext(stageContext);
52     auto ret = RingtoneDataManager::GetInstance()->Init(abilityContextImpl);
53     CHECK_AND_RETURN_LOG(ret == E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
54 
55     vector<string> perms;
56     perms.push_back("ohos.permission.WRITE_RINGTONE");
57 
58     uint64_t tokenId = 0;
59     RingtonePermissionUtilsUnitTest::SetAccessTokenPermission("RingtoneDataManagerUnitTest", perms, tokenId);
60     ASSERT_TRUE(tokenId != 0);
61 }
62 
TearDownTestCase()63 void RingtoneDataManagerUnitTest::TearDownTestCase()
64 {
65     system("rm -rf /storage/cloud/files/");
66     auto dataManager = RingtoneDataManager::GetInstance();
67     EXPECT_NE(dataManager, nullptr);
68     dataManager->ClearRingtoneDataMgr();
69 }
70 
SetUp(void)71 void RingtoneDataManagerUnitTest::SetUp(void)
72 {
73     system("rm -rf /storage/cloud/files/");
74     system("mkdir /storage/cloud/files");
75     system("mkdir /storage/cloud/files/Ringtone");
76 }
77 
TearDown(void)78 void RingtoneDataManagerUnitTest::TearDown(void) {}
79 
80 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_001, TestSize.Level0)
81 {
82     RINGTONE_INFO_LOG("dataManager_Insert_Test_001::Start");
83     Uri uri(RINGTONE_PATH_URI);
84     DataShare::DataShareValuesBucket valuesBucket;
85     valuesBucket.Put(RINGTONE_COLUMN_DATA,
86         static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
87         TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
88     valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
89     valuesBucket.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
90     valuesBucket.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
91     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
92     auto dataManager = RingtoneDataManager::GetInstance();
93     EXPECT_NE(dataManager, nullptr);
94     auto retVal = dataManager->Insert(cmd, valuesBucket);
95     EXPECT_EQ((retVal > 0), true);
96     RINGTONE_INFO_LOG("dataManager_Insert_Test_001::retVal = %{public}d. End", retVal);
97 }
98 
99 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_002, TestSize.Level0)
100 {
101     RINGTONE_INFO_LOG("dataManager_Insert_Test_002::Start");
102     Uri uri(RINGTONE_PATH_URI);
103     DataShare::DataShareValuesBucket valuesBucket;
104     valuesBucket.Put(RINGTONE_COLUMN_DATA,
105         static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
106         TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
107     valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
108     valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
109     valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3);
110     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
111     auto dataManager = RingtoneDataManager::GetInstance();
112     EXPECT_NE(dataManager, nullptr);
113     auto retVal = dataManager->Insert(cmd, valuesBucket);
114     EXPECT_EQ((retVal > 0), true);
115     RINGTONE_INFO_LOG("dataManager_Insert_Test_002::retVal = %{public}d. End", retVal);
116 }
117 
118 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_003, TestSize.Level0)
119 {
120     RINGTONE_INFO_LOG("dataManager_Insert_Test_003::Start");
121     Uri uri(RINGTONE_PATH_URI);
122     DataShare::DataShareValuesBucket valuesBucket;
123     valuesBucket.Put(RINGTONE_COLUMN_DATA, RINGTONE_DEFAULT_STR);
124     valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
125     valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
126     valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3);
127     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
128     auto dataManager = RingtoneDataManager::GetInstance();
129     EXPECT_NE(dataManager, nullptr);
130     auto retVal = dataManager->Insert(cmd, valuesBucket);
131     EXPECT_EQ(retVal, E_VIOLATION_PARAMETERS);
132     RINGTONE_INFO_LOG("dataManager_Insert_Test_003::retVal = %{public}d. End", retVal);
133 }
134 
135 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_004, TestSize.Level0)
136 {
137     RINGTONE_INFO_LOG("dataManager_Insert_Test_004::Start");
138     Uri uri(RINGTONE_PATH_URI);
139     const string errorRingtoneLibraryPath = "/storage/cloud/files/Photo";
140     DataShare::DataShareValuesBucket valuesBucket;
141     valuesBucket.Put(RINGTONE_COLUMN_DATA,
142         static_cast<string>(errorRingtoneLibraryPath + RINGTONE_SLASH_CHAR +
143         TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
144     valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
145     valuesBucket.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
146     valuesBucket.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
147     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
148     auto dataManager = RingtoneDataManager::GetInstance();
149     EXPECT_NE(dataManager, nullptr);
150     auto retVal = dataManager->Insert(cmd, valuesBucket);
151     EXPECT_EQ(retVal, E_ERR);
152     RINGTONE_INFO_LOG("dataManager_Insert_Test_004::retVal = %{public}d. End", retVal);
153 }
154 
155 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Insert_Test_005, TestSize.Level0)
156 {
157     RINGTONE_INFO_LOG("dataManager_Insert_Test_005::Start");
158     Uri uri(RINGTONE_PATH_URI);
159     DataShare::DataShareValuesBucket valuesBucket;
160     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
161     auto dataManager = RingtoneDataManager::GetInstance();
162     EXPECT_NE(dataManager, nullptr);
163     auto retVal = dataManager->Insert(cmd, valuesBucket);
164     EXPECT_EQ(retVal, E_INVALID_VALUES);
165     RINGTONE_INFO_LOG("dataManager_Insert_Test_005::retVal = %{public}d. End", retVal);
166 }
167 
168 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_001, TestSize.Level0)
169 {
170     RINGTONE_INFO_LOG("dataManager_Query_Test_001::Start");
171     vector<string> columns;
172     DataShare::DataSharePredicates predicates;
173     const string specialStr = " <> ";
174     const int index = 3;
175     string prefix = RINGTONE_COLUMN_MEDIA_TYPE + specialStr + to_string(index);
176     predicates.SetWhereClause(prefix);
177     Uri uri(RINGTONE_PATH_URI);
178     int errCode = 0;
179     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
180     auto dataManager = RingtoneDataManager::GetInstance();
181     EXPECT_NE(dataManager, nullptr);
182     auto queryResultSet = dataManager->Query(cmd, columns, predicates, errCode);
183     EXPECT_NE((queryResultSet == nullptr), true);
184     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
185         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
186     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
187     EXPECT_EQ(results->GetCount() > 0, true);
188     cout << "query count = " << to_string(results->GetCount()) << endl;
189     RINGTONE_INFO_LOG("dataManager_Query_Test_001::End");
190 }
191 
192 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_002, TestSize.Level0)
193 {
194     RINGTONE_INFO_LOG("dataManager_Query_Test_002::Start");
195     Uri uri(RINGTONE_PATH_URI);
196     int errCode = 0;
197     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
198     DataShare::DataSharePredicates queryPredicates;
199     queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, to_string(TEST_RINGTONE_COLUMN_TONE_TYPE));
200     vector<string> columns;
201     auto dataManager = RingtoneDataManager::GetInstance();
202     EXPECT_NE(dataManager, nullptr);
203     auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
204     EXPECT_NE((queryResultSet == nullptr), true);
205     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
206         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
207     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
208     cout << "query count = " << to_string(results->GetCount()) << endl;
209     RINGTONE_INFO_LOG("dataManager_Query_Test_002::End");
210 }
211 
212 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_003, TestSize.Level0)
213 {
214     RINGTONE_INFO_LOG("dataManager_Query_Test_003::Start");
215     Uri uri(RINGTONE_PATH_URI);
216     int errCode = 0;
217     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
218     DataShare::DataSharePredicates queryPredicates;
219     queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
220     vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DISPLAY_NAME },
221         { RINGTONE_COLUMN_DATA }, { RINGTONE_COLUMN_SHOT_TONE_TYPE } };
222     auto dataManager = RingtoneDataManager::GetInstance();
223     EXPECT_NE(dataManager, nullptr);
224     auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
225     EXPECT_NE((queryResultSet == nullptr), true);
226     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
227         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
228     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
229     cout << "query count = " << to_string(results->GetCount()) << endl;
230     RINGTONE_INFO_LOG("dataManager_Query_Test_003::End");
231 }
232 
233 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_004, TestSize.Level0)
234 {
235     RINGTONE_INFO_LOG("dataManager_Query_Test_004::Start");
236     Uri uri(RINGTONE_PATH_URI);
237     int errCode = 0;
238     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
239     DataShare::DataSharePredicates queryPredicates;
240     queryPredicates.EqualTo(RINGTONE_COLUMN_ALARM_TONE_TYPE, to_string(1));
241     vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DISPLAY_NAME },
242         { RINGTONE_COLUMN_DATE_ADDED }, { RINGTONE_COLUMN_SHOT_TONE_TYPE } };
243     auto dataManager = RingtoneDataManager::GetInstance();
244     EXPECT_NE(dataManager, nullptr);
245     auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
246     EXPECT_NE((queryResultSet == nullptr), true);
247     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
248         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
249     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
250     EXPECT_EQ(results->GetCount() == 0, true);
251     cout << "query count = " << to_string(results->GetCount()) << endl;
252     RINGTONE_INFO_LOG("dataManager_Query_Test_004::End");
253 }
254 
255 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Query_Test_005, TestSize.Level0)
256 {
257     RINGTONE_INFO_LOG("dataManager_Query_Test_005::Start");
258     Uri uri(RINGTONE_PATH_URI);
259     int errCode = 0;
260     RingtoneDataCommand cmd(uri, ERROR_RINGTONE_TABLE, RingtoneOperationType::QUERY);
261     DataShare::DataSharePredicates queryPredicates;
262     vector<string> columns;
263     auto dataManager = RingtoneDataManager::GetInstance();
264     EXPECT_NE(dataManager, nullptr);
265     auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
266     EXPECT_NE((queryResultSet == nullptr), true);
267     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
268         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
269     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
270     EXPECT_EQ(results->GetCount() == 0, true);
271     cout << "query count = " << to_string(results->GetCount()) << endl;
272     RINGTONE_INFO_LOG("dataManager_Query_Test_005::End");
273 }
274 
275 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_001, TestSize.Level0)
276 {
277     RINGTONE_INFO_LOG("dataManager_Update_Test_001::Start");
278     DataShare::DataSharePredicates predicates;
279 
280     DataShare::DataShareValuesBucket valuesBucketUpdate;
281     valuesBucketUpdate.Put(RINGTONE_COLUMN_TONE_TYPE, 0);
282 
283     Uri uri(RINGTONE_PATH_URI);
284     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
285     auto dataManager = RingtoneDataManager::GetInstance();
286     EXPECT_NE(dataManager, nullptr);
287     auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
288     EXPECT_EQ((retVal > 0), true);
289     RINGTONE_INFO_LOG("dataManager_Update_Test_001::retVal = %{public}d. End", retVal);
290 }
291 
292 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_002, TestSize.Level0)
293 {
294     RINGTONE_INFO_LOG("dataManager_Update_Test_002::Start");
295     vector<string> updateIds;
296     updateIds.push_back(to_string(1));
297     DataShare::DataSharePredicates predicates;
298 
299     DataShare::DataShareValuesBucket valuesBucketUpdate;
300 
301     Uri uri(RINGTONE_PATH_URI);
302     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
303     auto dataManager = RingtoneDataManager::GetInstance();
304     EXPECT_NE(dataManager, nullptr);
305     auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
306     EXPECT_EQ(retVal, E_INVALID_VALUES);
307     RINGTONE_INFO_LOG("dataManager_Update_Test_002::retVal = %{public}d. End", retVal);
308 }
309 
310 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_003, TestSize.Level0)
311 {
312     RINGTONE_INFO_LOG("dataManager_Update_Test_003::Start");
313     DataShare::DataSharePredicates predicates;
314     predicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + SELECT_STR);
315 
316     DataShare::DataShareValuesBucket valuesBucketUpdate;
317     valuesBucketUpdate.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, 0);
318     valuesBucketUpdate.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, 0);
319 
320     Uri uri(RINGTONE_PATH_URI);
321     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
322     auto dataManager = RingtoneDataManager::GetInstance();
323     EXPECT_NE(dataManager, nullptr);
324     auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
325     EXPECT_EQ(retVal, E_HAS_DB_ERROR);
326     RINGTONE_INFO_LOG("dataManager_Update_Test_003::retVal = %{public}d. End", retVal);
327 }
328 
329 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_004, TestSize.Level0)
330 {
331     RINGTONE_INFO_LOG("dataManager_Update_Test_004::Start");
332     vector<string> updateIds;
333     updateIds.push_back(to_string(1));
334     DataShare::DataSharePredicates predicates;
335     predicates.In(RINGTONE_COLUMN_TONE_ID, updateIds);
336 
337     DataShare::DataShareValuesBucket valuesBucketUpdate;
338 
339     Uri uri(RINGTONE_PATH_URI);
340     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
341     auto dataManager = RingtoneDataManager::GetInstance();
342     EXPECT_NE(dataManager, nullptr);
343     auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
344     EXPECT_EQ(retVal, E_INVALID_VALUES);
345     RINGTONE_INFO_LOG("dataManager_Update_Test_004::retVal = %{public}d. End", retVal);
346 }
347 
348 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Update_Test_005, TestSize.Level0)
349 {
350     RINGTONE_INFO_LOG("dataManager_Update_Test_005::Start");
351     vector<string> updateIds;
352     updateIds.push_back(to_string(1));
353     DataShare::DataSharePredicates predicates;
354     predicates.In(RINGTONE_COLUMN_TONE_ID, updateIds);
355 
356     DataShare::DataShareValuesBucket valuesBucketUpdate;
357     valuesBucketUpdate.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, 0);
358     valuesBucketUpdate.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, 0);
359 
360     Uri uri(RINGTONE_PATH_URI);
361     RingtoneDataCommand cmd(uri, ERROR_RINGTONE_TABLE, RingtoneOperationType::UPDATE);
362     auto dataManager = RingtoneDataManager::GetInstance();
363     EXPECT_NE(dataManager, nullptr);
364     auto retVal = dataManager->Update(cmd, valuesBucketUpdate, predicates);
365     EXPECT_EQ(retVal, E_HAS_DB_ERROR);
366     RINGTONE_INFO_LOG("dataManager_Update_Test_005::retVal = %{public}d. End", retVal);
367 }
368 
369 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_001, TestSize.Level0)
370 {
371     Uri uri(RINGTONE_PATH_URI);
372     DataShare::DataShareValuesBucket valuesBucket;
373     valuesBucket.Put(RINGTONE_COLUMN_DATA,
374         static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
375         TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
376     valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
377     valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
378     valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3);
379     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
380     auto dataManager = RingtoneDataManager::GetInstance();
381     EXPECT_NE(dataManager, nullptr);
382     auto retVal = dataManager->Insert(cmd, valuesBucket);
383     EXPECT_EQ((retVal > 0), true);
384 
385     int errCode = 0;
386     RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
387     DataShare::DataSharePredicates queryPredicates;
388     queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
389     vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA } };
390     auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
391     EXPECT_NE((queryResultSet == nullptr), true);
392     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
393         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
394     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
395     cout << "query count = " << to_string(results->GetCount()) << endl;
396 
397     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
398     if (ringtoneAsset != nullptr && ringtoneAsset->GetPath() != RINGTONE_DEFAULT_STR) {
399         string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(ringtoneAsset->GetId());
400         Uri ofUri(uriStr);
401         RingtoneDataCommand cmdOpen(ofUri, RINGTONE_TABLE, RingtoneOperationType::OPEN);
402         auto fd = dataManager->OpenFile(cmdOpen, RINGTONE_FILEMODE_READWRITE);
403         EXPECT_GE(fd, 0);
404         cout << "OpenFile fd = " << fd << endl;
405         if (fd >= 0) {
406             close(fd);
407         }
408     }
409 }
410 
411 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_002, TestSize.Level0)
412 {
413     RINGTONE_INFO_LOG("dataManager_OpenFile_Test_002::Start");
414     Uri uri(RINGTONE_PATH_URI);
415     int errCode = 0;
416     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
417     DataShare::DataSharePredicates queryPredicates;
418     queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
419     vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA } };
420     auto dataManager = RingtoneDataManager::GetInstance();
421     EXPECT_NE(dataManager, nullptr);
422     auto queryResultSet = dataManager->Query(cmd, columns, queryPredicates, errCode);
423     EXPECT_NE((queryResultSet == nullptr), true);
424     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
425         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
426     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
427     cout << "query count = " << to_string(results->GetCount()) << endl;
428 
429     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
430     if (ringtoneAsset != nullptr && ringtoneAsset->GetPath() != RINGTONE_DEFAULT_STR) {
431         string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(ringtoneAsset->GetId());
432         Uri ofUri(uriStr);
433         auto dataManager = RingtoneDataManager::GetInstance();
434         EXPECT_NE(dataManager, nullptr);
435         RingtoneDataCommand cmd(ofUri, ERROR_RINGTONE_TABLE, RingtoneOperationType::OPEN);
436         auto fd = dataManager->OpenFile(cmd, RINGTONE_FILEMODE_READWRITE);
437         EXPECT_LT(fd, 0);
438         cout << "OpenFile fd = " << fd << endl;
439         if (fd >= 0) {
440             close(fd);
441         }
442     }
443     RINGTONE_INFO_LOG("dataManager_OpenFile_Test_002::End");
444 }
445 
446 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_003, TestSize.Level0)
447 {
448     RINGTONE_INFO_LOG("dataManager_OpenFile_Test_003::Start");
449     string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR;
450     Uri ofUri(uriStr);
451     auto dataManager = RingtoneDataManager::GetInstance();
452     EXPECT_NE(dataManager, nullptr);
453     RingtoneDataCommand cmd(ofUri, RINGTONE_TABLE, RingtoneOperationType::OPEN);
454     auto fd = dataManager->OpenFile(cmd, RINGTONE_FILEMODE_READWRITE);
455     EXPECT_LT(fd, 0);
456     if (fd >= 0) {
457         close(fd);
458     }
459     RINGTONE_INFO_LOG("dataManager_OpenFile_Test_003::End");
460 }
461 
462 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_004, TestSize.Level0)
463 {
464     RINGTONE_INFO_LOG("dataManager_OpenFile_Test_004::Start");
465     string uriStr;
466     Uri ofUri(uriStr);
467     auto dataManager = RingtoneDataManager::GetInstance();
468     EXPECT_NE(dataManager, nullptr);
469     RingtoneDataCommand cmd(ofUri, RINGTONE_TABLE, RingtoneOperationType::OPEN);
470     auto fd = dataManager->OpenFile(cmd, RINGTONE_FILEMODE_READWRITE);
471     EXPECT_LT(fd, 0);
472     if (fd >= 0) {
473         close(fd);
474     }
475     RINGTONE_INFO_LOG("dataManager_OpenFile_Test_004::End");
476 }
477 
478 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_OpenFile_Test_005, TestSize.Level0)
479 {
480     RINGTONE_INFO_LOG("dataManager_OpenFile_Test_005::Start");
481     Uri ofUri(RINGTONE_DEFAULT_STR);
482     auto dataManager = RingtoneDataManager::GetInstance();
483     EXPECT_NE(dataManager, nullptr);
484     RingtoneDataCommand cmd(ofUri, RINGTONE_TABLE, RingtoneOperationType::OPEN);
485     auto fd = dataManager->OpenFile(cmd, RINGTONE_FILEMODE_READWRITE);
486     EXPECT_LT(fd, 0);
487     if (fd >= 0) {
488         close(fd);
489     }
490     RINGTONE_INFO_LOG("dataManager_OpenFile_Test_005::End");
491 }
492 
493 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_001, TestSize.Level0)
494 {
495     RINGTONE_INFO_LOG("dataManager_Delete_Test_001::Start");
496     Uri uri(RINGTONE_PATH_URI);
497     DataShare::DataSharePredicates predicates;
498     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
499     auto dataManager = RingtoneDataManager::GetInstance();
500     EXPECT_NE(dataManager, nullptr);
501     auto retVal = dataManager->Delete(cmd, predicates);
502     EXPECT_EQ((retVal > 0), true);
503     RINGTONE_INFO_LOG("dataManager_Delete_Test_001::End");
504 }
505 
506 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_002, TestSize.Level0)
507 {
508     RINGTONE_INFO_LOG("dataManager_Delete_Test_002::Start");
509     Uri uri(RINGTONE_PATH_URI);
510     const int32_t deleteId = 2; // delete id
511     DataShare::DataSharePredicates predicates;
512     predicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + SELECT_STR);
513     predicates.SetWhereArgs({ to_string(deleteId) });
514     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
515     auto dataManager = RingtoneDataManager::GetInstance();
516     EXPECT_NE(dataManager, nullptr);
517     auto retVal = dataManager->Delete(cmd, predicates);
518     EXPECT_EQ(retVal, E_HAS_DB_ERROR);
519     RINGTONE_INFO_LOG("dataManager_Delete_Test_002::End");
520 }
521 
522 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_003, TestSize.Level0)
523 {
524     RINGTONE_INFO_LOG("dataManager_Delete_Test_003::Start");
525     Uri uri(RINGTONE_PATH_URI);
526     const int32_t deleteId = 7; // delete id
527     DataShare::DataSharePredicates predicates;
528     predicates.SetWhereArgs({ to_string(deleteId) });
529     RingtoneDataCommand cmd(uri, ERROR_RINGTONE_TABLE, RingtoneOperationType::DELETE);
530     auto dataManager = RingtoneDataManager::GetInstance();
531     EXPECT_NE(dataManager, nullptr);
532     auto retVal = dataManager->Delete(cmd, predicates);
533     EXPECT_EQ(retVal, E_HAS_DB_ERROR);
534     RINGTONE_INFO_LOG("dataManager_Delete_Test_003::End");
535 }
536 
537 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_004, TestSize.Level0)
538 {
539     RINGTONE_INFO_LOG("dataManager_Delete_Test_004::Start");
540     Uri uri(RINGTONE_PATH_URI);
541     DataShare::DataSharePredicates predicates;
542     predicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + SELECT_STR);
543     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
544     auto dataManager = RingtoneDataManager::GetInstance();
545     EXPECT_NE(dataManager, nullptr);
546     auto retVal = dataManager->Delete(cmd, predicates);
547     EXPECT_EQ(retVal, E_HAS_DB_ERROR);
548     RINGTONE_INFO_LOG("dataManager_Delete_Test_004::End");
549 }
550 
551 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_Delete_Test_005, TestSize.Level0)
552 {
553     RINGTONE_INFO_LOG("dataManager_Delete_Test_005::Start");
554     Uri uri(RINGTONE_PATH_URI);
555     int32_t deleteId = -1;
556     DataShare::DataSharePredicates predicates;
557     predicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + SELECT_STR);
558     predicates.SetWhereArgs({ to_string(deleteId) });
559     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
560     auto dataManager = RingtoneDataManager::GetInstance();
561     EXPECT_NE(dataManager, nullptr);
562     auto retVal = dataManager->Delete(cmd, predicates);
563     EXPECT_EQ(retVal, E_HAS_DB_ERROR);
564     RINGTONE_INFO_LOG("dataManager_Delete_Test_005::End");
565 }
566 
567 HWTEST_F(RingtoneDataManagerUnitTest, dataManager_GetOwner_Test_001, TestSize.Level0)
568 {
569     auto dataManager = RingtoneDataManager::GetInstance();
570     EXPECT_NE(dataManager, nullptr);
571     shared_ptr<RingtoneDataShareExtension> datashareExternsion =  nullptr;
572     dataManager->SetOwner(datashareExternsion);
573     auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
574     auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
575     abilityContextImpl->SetStageContext(stageContext);
576     auto result = RingtoneDataManager::GetInstance()->Init(abilityContextImpl);
577     EXPECT_EQ(result, E_OK);
578     dataManager->ClearRingtoneDataMgr();
579     auto ret = dataManager->GetOwner();
580     EXPECT_EQ(ret, nullptr);
581 }
582 } // namespace Media
583 } // namespace OHOS
584