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 
16 #include "ringtone_unittest.h"
17 
18 #include "datashare_helper.h"
19 #include "iservice_registry.h"
20 #include "get_self_permissions.h"
21 #include "ringtone_asset.h"
22 #include "ringtone_db_const.h"
23 #include "ringtone_errno.h"
24 #include "ringtone_fetch_result.h"
25 #include "ringtone_file_utils.h"
26 #include "ringtone_log.h"
27 #include "ringtone_scanner_utils.h"
28 #include "ringtone_tracer.h"
29 #include "ringtone_type.h"
30 
31 using namespace std;
32 using namespace OHOS;
33 using namespace testing::ext;
34 using namespace OHOS::DataShare;
35 using namespace OHOS::AppExecFwk;
36 
37 namespace OHOS {
38 namespace Media {
39 constexpr int STORAGE_MANAGER_ID = 5003;
40 std::shared_ptr<DataShare::DataShareHelper> g_dataShareHelper = nullptr;
41 const int S2MS = 1000;
42 const int MS2NS = 1000000;
43 const string SELECTION = RINGTONE_COLUMN_TONE_ID + " <> ? LIMIT 1, 3 ";
44 const int NUMBER_OF_TIMES = 10;
45 const string RINGTONE_LIBRARY_PATH = "/data/storage/el2/base/files";
46 const int TEST_RINGTONE_COLUMN_SIZE = 1022;
47 const string MTP_FORMAT_OGG = ".ogg"; // OGG audio files
48 const string TEST_INSERT_RINGTONE_LIBRARY = "test_insert_ringtone_library";
49 const string RAINNING = "rainning";
50 const string TITLE_UPDATE = "run";
51 const string ZERO = "0";
52 const string SLASH_STR = "/";
53 
SetUpTestCase()54 void RingtoneUnitTest::SetUpTestCase()
55 {
56     vector<string> perms;
57     perms.push_back("ohos.permission.WRITE_RINGTONE");
58 
59     uint64_t tokenId = 0;
60     RingtonePermissionUtilsUnitTest::SetAccessTokenPermission("RingtoneUnitTest", perms, tokenId);
61     ASSERT_TRUE(tokenId != 0);
62 
63     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
64     ASSERT_TRUE(saManager != nullptr);
65 
66     auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_ID);
67     ASSERT_TRUE(remoteObj != nullptr);
68 
69     g_dataShareHelper = DataShare::DataShareHelper::Creator(remoteObj, RINGTONE_URI);
70     ASSERT_TRUE(g_dataShareHelper != nullptr);
71 }
72 
TearDownTestCase()73 void RingtoneUnitTest::TearDownTestCase()
74 {
75     RINGTONE_ERR_LOG("TearDownTestCase start");
76     if (g_dataShareHelper != nullptr) {
77         g_dataShareHelper->Release();
78     }
79     system("rm -rf /data/storage/el2/base/files/");
80     RINGTONE_INFO_LOG("TearDownTestCase end");
81 }
82 
SetUp(void)83 void RingtoneUnitTest::SetUp(void) {}
84 
TearDown(void)85 void RingtoneUnitTest::TearDown(void)
86 {
87     system("rm -rf /data/storage/el2/base/files/");
88 }
89 
UTCTimeSeconds()90 int64_t UTCTimeSeconds()
91 {
92     struct timespec t;
93     t.tv_sec = 0;
94     t.tv_nsec = 0;
95     clock_gettime(CLOCK_REALTIME, &t);
96     return (int64_t) ((t.tv_sec * S2MS) + (t.tv_nsec / MS2NS));
97 }
98 
99 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_001, TestSize.Level0)
100 {
101     Uri uri(RINGTONE_PATH_URI);
102     DataSharePredicates predicates;
103     vector<string> selectionArgs = { ZERO };
104     predicates.SetWhereClause(SELECTION);
105     predicates.SetWhereArgs(selectionArgs);
106     vector<string> columns {
107         RINGTONE_COLUMN_TONE_ID,
108         RINGTONE_COLUMN_DATA,
109         RINGTONE_COLUMN_SIZE,
110         RINGTONE_COLUMN_DISPLAY_NAME,
111         RINGTONE_COLUMN_TITLE,
112         RINGTONE_COLUMN_MEDIA_TYPE,
113         RINGTONE_COLUMN_TONE_TYPE,
114         RINGTONE_COLUMN_MIME_TYPE,
115     };
116 
117     int64_t start = UTCTimeSeconds();
118     RingtoneTracer tracer;
119     tracer.Start("DataShareQuery10Column");
120     for (int i = 0; i < NUMBER_OF_TIMES; i++) {
121         auto result = g_dataShareHelper->Query(uri, predicates, columns);
122         EXPECT_NE(result, nullptr);
123     }
124     tracer.Finish();
125     int64_t end = UTCTimeSeconds();
126 
127     GTEST_LOG_(INFO) << "DataShareQueryColumn Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
128 }
129 
130 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_002, TestSize.Level0)
131 {
132     Uri uri(RINGTONE_PATH_URI);
133     DataSharePredicates predicates;
134     vector<string> columns;
135 
136     int64_t start = UTCTimeSeconds();
137     RingtoneTracer tracer;
138     tracer.Start("DataShareQuery10Column");
139     for (int i = 0; i < NUMBER_OF_TIMES; i++) {
140         auto result = g_dataShareHelper->Query(uri, predicates, columns);
141         EXPECT_NE(result, nullptr);
142     }
143     tracer.Finish();
144     int64_t end = UTCTimeSeconds();
145 
146     GTEST_LOG_(INFO) << "DataShareQuery Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
147 }
148 
149 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_003, TestSize.Level0)
150 {
151     Uri uri(RINGTONE_PATH_URI);
152     DataSharePredicates predicates;
153     vector<string> selectionArgs = { ZERO };
154     predicates.SetWhereClause(SELECTION);
155     predicates.SetWhereArgs(selectionArgs);
156     vector<string> columns;
157 
158     int64_t start = UTCTimeSeconds();
159     RingtoneTracer tracer;
160     tracer.Start("DataShareQuery10Column");
161     for (int i = 0; i < NUMBER_OF_TIMES; i++) {
162         auto result = g_dataShareHelper->Query(uri, predicates, columns);
163         EXPECT_NE(result, nullptr);
164     }
165     tracer.Finish();
166     int64_t end = UTCTimeSeconds();
167 
168     GTEST_LOG_(INFO) << "DataShareQuery1-3Column Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
169 }
170 
171 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_004, TestSize.Level0)
172 {
173     Uri uri(RINGTONE_PATH_URI);
174     DataSharePredicates predicates;
175     vector<string> columns {
176         RINGTONE_COLUMN_TONE_ID,
177         RINGTONE_COLUMN_DATA,
178         RINGTONE_COLUMN_SIZE,
179         RINGTONE_COLUMN_DISPLAY_NAME,
180         RINGTONE_COLUMN_TITLE,
181         RINGTONE_COLUMN_MEDIA_TYPE,
182         RINGTONE_COLUMN_TONE_TYPE,
183         RINGTONE_COLUMN_MIME_TYPE,
184     };
185 
186     int64_t start = UTCTimeSeconds();
187     RingtoneTracer tracer;
188     tracer.Start("DataShareQuery10Column");
189     for (int i = 0; i < NUMBER_OF_TIMES; i++) {
190         auto result = g_dataShareHelper->Query(uri, predicates, columns);
191         EXPECT_NE(result, nullptr);
192     }
193     tracer.Finish();
194     int64_t end = UTCTimeSeconds();
195 
196     GTEST_LOG_(INFO) << "DataShareQuery Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
197 }
198 
199 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_005, TestSize.Level0)
200 {
201     Uri uri(RINGTONE_URI);
202     DataSharePredicates predicates;
203     vector<string> selectionArgs = { ZERO };
204     predicates.SetWhereClause(SELECTION);
205     predicates.SetWhereArgs(selectionArgs);
206     vector<string> columns {
207         RINGTONE_COLUMN_TONE_ID,
208         RINGTONE_COLUMN_DATA,
209         RINGTONE_COLUMN_SIZE,
210         RINGTONE_COLUMN_DISPLAY_NAME,
211         RINGTONE_COLUMN_TITLE,
212         RINGTONE_COLUMN_MEDIA_TYPE,
213         RINGTONE_COLUMN_TONE_TYPE,
214         RINGTONE_COLUMN_MIME_TYPE,
215     };
216 
217     int64_t start = UTCTimeSeconds();
218     RingtoneTracer tracer;
219     tracer.Start("DataShareQuery10Column");
220     for (int i = 0; i < NUMBER_OF_TIMES; i++) {
221         auto result = g_dataShareHelper->Query(uri, predicates, columns);
222         EXPECT_EQ(result, nullptr);
223     }
224     tracer.Finish();
225     int64_t end = UTCTimeSeconds();
226 
227     GTEST_LOG_(INFO) << "DataShareQueryColumn Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
228 }
229 
230 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_003, TestSize.Level0)
231 {
232     Uri uri(RINGTONE_DEFAULT_STR);
233 
234     int64_t start = UTCTimeSeconds();
235     RingtoneTracer tracer;
236     tracer.Start("DataShareInsertColumn");
237     DataShareValuesBucket values;
238     values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
239     values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
240         TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
241     values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
242     values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
243     values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
244     auto result = g_dataShareHelper->Insert(uri, values);
245     EXPECT_EQ(result, E_INVALID_URI);
246     tracer.Finish();
247     int64_t end = UTCTimeSeconds();
248 
249     GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start)) << "ms";
250 }
251 
252 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_005, TestSize.Level0)
253 {
254     Uri uri(RINGTONE_URI);
255 
256     int64_t start = UTCTimeSeconds();
257     RingtoneTracer tracer;
258     tracer.Start("DataShareInsertColumn");
259     DataShareValuesBucket values;
260     values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
261         TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
262     values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
263     values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
264     values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
265     auto result = g_dataShareHelper->Insert(uri, values);
266     EXPECT_EQ(result, E_INVALID_URI);
267     tracer.Finish();
268     int64_t end = UTCTimeSeconds();
269 
270     GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start)) << "ms";
271 }
272 
273 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_002, TestSize.Level0)
274 {
275     Uri uri(RINGTONE_PATH_URI);
276     DataSharePredicates predicates;
277     vector<string> selectionArgs = { ZERO };
278     predicates.SetWhereClause(SELECTION);
279     predicates.SetWhereArgs(selectionArgs);
280     DataShareValuesBucket updateValues;
281     updateValues.Put(RINGTONE_COLUMN_TITLE, TITLE_UPDATE);
282 
283     int64_t start = UTCTimeSeconds();
284     RingtoneTracer tracer;
285     tracer.Start("DataShareUpdateColumn");
286     for (int i = 0; i < 1; i++) {
287         auto result = g_dataShareHelper->Update(uri, predicates, updateValues);
288         EXPECT_EQ(result, E_HAS_DB_ERROR);
289     }
290     tracer.Finish();
291     int64_t end = UTCTimeSeconds();
292 
293     GTEST_LOG_(INFO) << "DataShareUpdateColumn Cost: " << ((double) (end - start)) << "ms";
294 }
295 
296 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_003, TestSize.Level0)
297 {
298     Uri uri(RINGTONE_PATH_URI);
299     DataSharePredicates predicates;
300     DataShareValuesBucket updateValues;
301 
302     int64_t start = UTCTimeSeconds();
303     RingtoneTracer tracer;
304     tracer.Start("DataShareUpdate10Column");
305     for (int i = 0; i < 1; i++) {
306         auto result = g_dataShareHelper->Update(uri, predicates, updateValues);
307         EXPECT_EQ(result, E_INVALID_VALUES);
308     }
309     tracer.Finish();
310     int64_t end = UTCTimeSeconds();
311 
312     GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
313 }
314 
315 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_004, TestSize.Level0)
316 {
317     Uri uri(RINGTONE_PATH_URI);
318     DataSharePredicates predicates;
319     vector<string> selectionArgs = { ZERO };
320     predicates.SetWhereClause(SELECTION);
321     predicates.SetWhereArgs(selectionArgs);
322     DataShareValuesBucket values;
323     values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
324     values.Put(RINGTONE_COLUMN_DATA, DATA_DEFAULT);
325     values.Put(RINGTONE_COLUMN_SIZE, SIZE_DEFAULT);
326     values.Put(RINGTONE_COLUMN_DISPLAY_NAME, DISPLAY_NAME_DEFAULT);
327     values.Put(RINGTONE_COLUMN_TITLE, TITLE_DEFAULT);
328     values.Put(RINGTONE_COLUMN_MEDIA_TYPE, METADATA_MEDIA_TYPE_DEFAULT);
329     values.Put(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_DEFAULT);
330     values.Put(RINGTONE_COLUMN_MIME_TYPE, MIME_TYPE_DEFAULT);
331 
332 
333     int64_t start = UTCTimeSeconds();
334     RingtoneTracer tracer;
335     tracer.Start("DataShareUpdate10Column");
336     for (int i = 0; i < 1; i++) {
337         auto result = g_dataShareHelper->Update(uri, predicates, values);
338         EXPECT_EQ(result, E_HAS_DB_ERROR);
339     }
340     tracer.Finish();
341     int64_t end = UTCTimeSeconds();
342 
343     GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
344 }
345 
346 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_005, TestSize.Level0)
347 {
348     Uri uri(RINGTONE_URI);
349     DataSharePredicates predicates;
350     vector<string> selectionArgs = { ZERO };
351     predicates.SetWhereClause(SELECTION);
352     predicates.SetWhereArgs(selectionArgs);
353     DataShareValuesBucket values;
354     values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
355     values.Put(RINGTONE_COLUMN_DATA, DATA_DEFAULT);
356     values.Put(RINGTONE_COLUMN_SIZE, SIZE_DEFAULT);
357     values.Put(RINGTONE_COLUMN_DISPLAY_NAME, DISPLAY_NAME_DEFAULT);
358     values.Put(RINGTONE_COLUMN_TITLE, TITLE_DEFAULT);
359     values.Put(RINGTONE_COLUMN_MEDIA_TYPE, METADATA_MEDIA_TYPE_DEFAULT);
360     values.Put(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_DEFAULT);
361     values.Put(RINGTONE_COLUMN_MIME_TYPE, MIME_TYPE_DEFAULT);
362 
363 
364     int64_t start = UTCTimeSeconds();
365     RingtoneTracer tracer;
366     tracer.Start("DataShareUpdate10Column");
367     for (int i = 0; i < 1; i++) {
368         auto result = g_dataShareHelper->Update(uri, predicates, values);
369         EXPECT_EQ(result, E_INVALID_URI);
370     }
371     tracer.Finish();
372     int64_t end = UTCTimeSeconds();
373 
374     GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
375 }
376 
377 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_003, TestSize.Level0)
378 {
379     Uri uri(RINGTONE_DEFAULT_STR);
380 
381     DataSharePredicates predicates;
382 
383     auto result = g_dataShareHelper->Delete(uri, predicates);
384     EXPECT_EQ(result, E_INVALID_URI);
385 }
386 
387 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_004, TestSize.Level0)
388 {
389     Uri uri(RINGTONE_DEFAULT_STR);
390 
391     DataSharePredicates predicates;
392     vector<string> selectionArgs = { ZERO };
393     predicates.SetWhereClause(SELECTION);
394     predicates.SetWhereArgs(selectionArgs);
395 
396     auto result = g_dataShareHelper->Delete(uri, predicates);
397     EXPECT_EQ(result, E_INVALID_URI);
398 }
399 
400 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_005, TestSize.Level0)
401 {
402     Uri uri(RINGTONE_URI);
403 
404     DataSharePredicates predicates;
405     vector<string> selectionArgs = { ZERO };
406     predicates.SetWhereClause(SELECTION);
407     predicates.SetWhereArgs(selectionArgs);
408 
409     auto result = g_dataShareHelper->Delete(uri, predicates);
410     EXPECT_EQ(result, E_INVALID_URI);
411 }
412 
413 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_002, TestSize.Level0)
414 {
415     Uri uri(RINGTONE_PATH_URI);
416     string mode;
417 
418     auto fd = g_dataShareHelper->OpenFile(uri, mode);
419     EXPECT_EQ(fd, E_ERR);
420     if (fd >= 0) {
421         close(fd);
422     }
423 }
424 
425 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_003, TestSize.Level0)
426 {
427     const string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + "1";
428     Uri uri(uriStr);
429     string mode = RINGTONE_FILEMODE_READWRITE;
430 
431     auto fd = g_dataShareHelper->OpenFile(uri, mode);
432     EXPECT_EQ(fd, E_ERR);
433     if (fd >= 0) {
434         close(fd);
435     }
436 }
437 
438 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_004, TestSize.Level0)
439 {
440     Uri uri(RINGTONE_PATH_URI);
441     string mode = RINGTONE_FILEMODE_READWRITE;
442 
443     auto fd = g_dataShareHelper->OpenFile(uri, mode);
444     EXPECT_EQ(fd, E_ERR);
445     if (fd >= 0) {
446         close(fd);
447     }
448 }
449 
450 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_005, TestSize.Level0)
451 {
452     Uri uri(RINGTONE_URI);
453     string mode = RINGTONE_FILEMODE_READWRITE;
454 
455     auto fd = g_dataShareHelper->OpenFile(uri, mode);
456     EXPECT_EQ(fd, E_ERR);
457     if (fd >= 0) {
458         close(fd);
459     }
460 }
461 
462 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_007, TestSize.Level0)
463 {
464     Uri uri(RINGTONE_PATH_URI);
465     DataSharePredicates predicates;
466     g_dataShareHelper->Delete(uri, predicates);;
467 
468     int errCode = 0;
469     DatashareBusinessError businessError;
470     DataSharePredicates queryPredicates;
471     vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
472     auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
473     errCode = businessError.GetCode();
474     cout << "Query errCode=" << errCode << endl;
475 
476     if (resultSet != nullptr) {
477         auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
478         EXPECT_NE(results, nullptr);
479         cout << "query count = " << to_string(results->GetCount()) << endl;
480     }
481 }
482 
483 HWTEST_F(RingtoneUnitTest, medialib_querySystemRingtone_test_001, TestSize.Level0)
484 {
485     Uri uri(RINGTONE_PATH_URI);
486 
487     int errCode = 0;
488     DatashareBusinessError businessError;
489     DataSharePredicates queryPredicates;
490     queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(SourceType::SOURCE_TYPE_PRESET));
491     vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
492     auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
493     errCode = businessError.GetCode();
494     cout << "Query errCode=" << errCode << endl;
495 
496     if (resultSet != nullptr) {
497         auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
498         EXPECT_NE(results, nullptr);
499         cout << "query count = " << to_string(results->GetCount()) << endl;
500     }
501 }
502 
503 HWTEST_F(RingtoneUnitTest, medialib_queryCustomisedRingtone_test_001, TestSize.Level0)
504 {
505     Uri uri(RINGTONE_PATH_URI);
506 
507     int errCode = 0;
508     DatashareBusinessError businessError;
509     DataSharePredicates queryPredicates;
510     queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(SourceType::SOURCE_TYPE_CUSTOMISED));
511     vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
512     auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
513     errCode = businessError.GetCode();
514     cout << "Query errCode=" << errCode << endl;
515 
516     if (resultSet != nullptr) {
517         auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
518         EXPECT_NE(results, nullptr);
519         cout << "query count = " << to_string(results->GetCount()) << endl;
520     }
521 }
522 
523 HWTEST_F(RingtoneUnitTest, medialib_queryAllRingtone_test_001, TestSize.Level0)
524 {
525     Uri uri(RINGTONE_PATH_URI);
526 
527     int errCode = 0;
528     DatashareBusinessError businessError;
529     DataSharePredicates queryPredicates;
530     vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
531     auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
532     errCode = businessError.GetCode();
533     cout << "Query errCode=" << errCode << endl;
534 
535     if (resultSet != nullptr) {
536         auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
537         EXPECT_NE(results, nullptr);
538         cout << "query count = " << to_string(results->GetCount()) << endl;
539     }
540 }
541 } // namespace Media
542 } // namespace OHOS
543