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 #include "accesstoken_kit.h"
31 #include "hap_token_info.h"
32 #include "token_setproc.h"
33 #include "ringtone_proxy_uri.h"
34
35 using namespace std;
36 using namespace OHOS;
37 using namespace testing::ext;
38 using namespace OHOS::DataShare;
39 using namespace OHOS::AppExecFwk;
40 using namespace OHOS::Security::AccessToken;
41 namespace OHOS {
42 namespace Media {
43 constexpr int STORAGE_MANAGER_ID = 5003;
44 std::shared_ptr<DataShare::DataShareHelper> g_dataShareHelper = nullptr;
45 std::shared_ptr<DataShare::DataShareHelper> g_dataShareHelperProxy = nullptr;
46 const int S2MS = 1000;
47 const int MS2NS = 1000000;
48 const string SELECTION = RINGTONE_COLUMN_TONE_ID + " <> ? LIMIT 1, 3 ";
49 const int NUMBER_OF_TIMES = 10;
50 const string RINGTONE_LIBRARY_PATH = "/data/storage/el2/base/files";
51 const int TEST_RINGTONE_COLUMN_SIZE = 1022;
52 const string MTP_FORMAT_OGG = ".ogg"; // OGG audio files
53 const string TEST_INSERT_RINGTONE_LIBRARY = "test_insert_ringtone_library";
54 const string RAINNING = "rainning";
55 const string TITLE_UPDATE = "run";
56 const string ZERO = "0";
57 const string SLASH_STR = "/";
58 const string MTP_FORMAT_JSON = ".json"; // OGG audio files
59
GetPermissionStateFulls()60 std::vector<PermissionStateFull> GetPermissionStateFulls()
61 {
62 std::vector<PermissionStateFull> permissionStateFulls = {
63 {
64 .permissionName = "ohos.permission.WRITE_RINGTONE",
65 .isGeneral = true,
66 .resDeviceID = { "local" },
67 .grantStatus = { PermissionState::PERMISSION_GRANTED },
68 .grantFlags = { 1 }
69 },
70 {
71 .permissionName = "ohos.permission.READ_AUDIO",
72 .isGeneral = true,
73 .resDeviceID = { "local" },
74 .grantStatus = { PermissionState::PERMISSION_GRANTED },
75 .grantFlags = { 1 }
76 }
77 };
78 return permissionStateFulls;
79 }
80
SetUpTestCase()81 void RingtoneUnitTest::SetUpTestCase()
82 {
83 vector<string> perms;
84 perms.push_back("ohos.permission.WRITE_RINGTONE");
85
86 uint64_t tokenId = 0;
87 RingtonePermissionUtilsUnitTest::SetAccessTokenPermission("RingtoneUnitTest", perms, tokenId);
88 ASSERT_TRUE(tokenId != 0);
89
90 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
91 ASSERT_TRUE(saManager != nullptr);
92
93 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_ID);
94 ASSERT_TRUE(remoteObj != nullptr);
95
96 g_dataShareHelper = DataShare::DataShareHelper::Creator(remoteObj, RINGTONE_URI);
97 ASSERT_TRUE(g_dataShareHelper != nullptr);
98
99 HapInfoParams info = {
100 .userID = 100,
101 .bundleName = "com.ohos.ringtonelibrary.ringtonelibrarydata",
102 .instIndex = 0,
103 .appIDDesc = "com.ohos.ringtonelibrary.ringtonelibrarydata"
104 };
105
106 auto permStateList = GetPermissionStateFulls();
107 HapPolicyParams policy = {
108 .apl = APL_NORMAL,
109 .domain = "test.domain",
110 .permList = {
111 {
112 .permissionName = "ohos.permission.test",
113 .bundleName = "ohos.datashareclienttest.demo",
114 .grantMode = 1,
115 .availableLevel = APL_NORMAL,
116 .label = "label",
117 .labelId = 1,
118 .description = "ohos.datashareclienttest.demo",
119 .descriptionId = 1
120 }
121 },
122 .permStateList = permStateList
123 };
124 AccessTokenKit::AllocHapToken(info, policy);
125 auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
126 info.userID, info.bundleName, info.instIndex);
127 SetSelfTokenID(testTokenId.tokenIDEx);
128
129 CreateOptions options;
130 options.enabled_ = true;
131 g_dataShareHelperProxy = DataShare::DataShareHelper::Creator(RINGTONE_LIBRARY_PROXY_URI, options);
132 }
133
TearDownTestCase()134 void RingtoneUnitTest::TearDownTestCase()
135 {
136 RINGTONE_ERR_LOG("TearDownTestCase start");
137 if (g_dataShareHelper != nullptr) {
138 g_dataShareHelper->Release();
139 }
140 system("rm -rf /data/storage/el2/base/files/");
141 RINGTONE_INFO_LOG("TearDownTestCase end");
142 }
143
SetUp(void)144 void RingtoneUnitTest::SetUp(void) {}
145
TearDown(void)146 void RingtoneUnitTest::TearDown(void)
147 {
148 system("rm -rf /data/storage/el2/base/files/");
149 }
150
UTCTimeSeconds()151 int64_t UTCTimeSeconds()
152 {
153 struct timespec t;
154 t.tv_sec = 0;
155 t.tv_nsec = 0;
156 clock_gettime(CLOCK_REALTIME, &t);
157 return (int64_t) ((t.tv_sec * S2MS) + (t.tv_nsec / MS2NS));
158 }
159
160 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_001, TestSize.Level0)
161 {
162 Uri uri(RINGTONE_PATH_URI);
163 DataSharePredicates predicates;
164 vector<string> selectionArgs = { ZERO };
165 predicates.SetWhereClause(SELECTION);
166 predicates.SetWhereArgs(selectionArgs);
167 vector<string> columns {
168 RINGTONE_COLUMN_TONE_ID,
169 RINGTONE_COLUMN_DATA,
170 RINGTONE_COLUMN_SIZE,
171 RINGTONE_COLUMN_DISPLAY_NAME,
172 RINGTONE_COLUMN_TITLE,
173 RINGTONE_COLUMN_MEDIA_TYPE,
174 RINGTONE_COLUMN_TONE_TYPE,
175 RINGTONE_COLUMN_MIME_TYPE,
176 };
177
178 int64_t start = UTCTimeSeconds();
179 RingtoneTracer tracer;
180 tracer.Start("DataShareQuery10Column");
181 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
182 auto result = g_dataShareHelper->Query(uri, predicates, columns);
183 EXPECT_NE(result, nullptr);
184 }
185 tracer.Finish();
186 int64_t end = UTCTimeSeconds();
187
188 GTEST_LOG_(INFO) << "DataShareQueryColumn Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
189 }
190
191 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_002, TestSize.Level0)
192 {
193 Uri uri(RINGTONE_PATH_URI);
194 DataSharePredicates predicates;
195 vector<string> columns;
196
197 int64_t start = UTCTimeSeconds();
198 RingtoneTracer tracer;
199 tracer.Start("DataShareQuery10Column");
200 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
201 auto result = g_dataShareHelper->Query(uri, predicates, columns);
202 EXPECT_NE(result, nullptr);
203 }
204 tracer.Finish();
205 int64_t end = UTCTimeSeconds();
206
207 GTEST_LOG_(INFO) << "DataShareQuery Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
208 }
209
210 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_003, TestSize.Level0)
211 {
212 Uri uri(RINGTONE_PATH_URI);
213 DataSharePredicates predicates;
214 vector<string> selectionArgs = { ZERO };
215 predicates.SetWhereClause(SELECTION);
216 predicates.SetWhereArgs(selectionArgs);
217 vector<string> columns;
218
219 int64_t start = UTCTimeSeconds();
220 RingtoneTracer tracer;
221 tracer.Start("DataShareQuery10Column");
222 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
223 auto result = g_dataShareHelper->Query(uri, predicates, columns);
224 EXPECT_NE(result, nullptr);
225 }
226 tracer.Finish();
227 int64_t end = UTCTimeSeconds();
228
229 GTEST_LOG_(INFO) << "DataShareQuery1-3Column Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
230 }
231
232 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_004, TestSize.Level0)
233 {
234 Uri uri(RINGTONE_PATH_URI);
235 DataSharePredicates predicates;
236 vector<string> columns {
237 RINGTONE_COLUMN_TONE_ID,
238 RINGTONE_COLUMN_DATA,
239 RINGTONE_COLUMN_SIZE,
240 RINGTONE_COLUMN_DISPLAY_NAME,
241 RINGTONE_COLUMN_TITLE,
242 RINGTONE_COLUMN_MEDIA_TYPE,
243 RINGTONE_COLUMN_TONE_TYPE,
244 RINGTONE_COLUMN_MIME_TYPE,
245 };
246
247 int64_t start = UTCTimeSeconds();
248 RingtoneTracer tracer;
249 tracer.Start("DataShareQuery10Column");
250 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
251 auto result = g_dataShareHelper->Query(uri, predicates, columns);
252 EXPECT_NE(result, nullptr);
253 }
254 tracer.Finish();
255 int64_t end = UTCTimeSeconds();
256
257 GTEST_LOG_(INFO) << "DataShareQuery Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
258 }
259
260 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_005, TestSize.Level0)
261 {
262 Uri uri(RINGTONE_URI);
263 DataSharePredicates predicates;
264 vector<string> selectionArgs = { ZERO };
265 predicates.SetWhereClause(SELECTION);
266 predicates.SetWhereArgs(selectionArgs);
267 vector<string> columns {
268 RINGTONE_COLUMN_TONE_ID,
269 RINGTONE_COLUMN_DATA,
270 RINGTONE_COLUMN_SIZE,
271 RINGTONE_COLUMN_DISPLAY_NAME,
272 RINGTONE_COLUMN_TITLE,
273 RINGTONE_COLUMN_MEDIA_TYPE,
274 RINGTONE_COLUMN_TONE_TYPE,
275 RINGTONE_COLUMN_MIME_TYPE,
276 };
277
278 int64_t start = UTCTimeSeconds();
279 RingtoneTracer tracer;
280 tracer.Start("DataShareQuery10Column");
281 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
282 auto result = g_dataShareHelper->Query(uri, predicates, columns);
283 EXPECT_EQ(result, nullptr);
284 }
285 tracer.Finish();
286 int64_t end = UTCTimeSeconds();
287
288 GTEST_LOG_(INFO) << "DataShareQueryColumn Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
289 }
290
291 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_003, TestSize.Level0)
292 {
293 Uri uri(RINGTONE_DEFAULT_STR);
294
295 int64_t start = UTCTimeSeconds();
296 RingtoneTracer tracer;
297 tracer.Start("DataShareInsertColumn");
298 DataShareValuesBucket values;
299 values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
300 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
301 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
302 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
303 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
304 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
305 auto result = g_dataShareHelper->Insert(uri, values);
306 EXPECT_EQ(result, E_INVALID_URI);
307 tracer.Finish();
308 int64_t end = UTCTimeSeconds();
309
310 GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start)) << "ms";
311 }
312
313 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_005, TestSize.Level0)
314 {
315 Uri uri(RINGTONE_URI);
316
317 int64_t start = UTCTimeSeconds();
318 RingtoneTracer tracer;
319 tracer.Start("DataShareInsertColumn");
320 DataShareValuesBucket values;
321 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
322 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
323 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
324 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
325 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
326 auto result = g_dataShareHelper->Insert(uri, values);
327 EXPECT_EQ(result, E_INVALID_URI);
328 tracer.Finish();
329 int64_t end = UTCTimeSeconds();
330
331 GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start)) << "ms";
332 }
333
334 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_002, TestSize.Level0)
335 {
336 Uri uri(RINGTONE_PATH_URI);
337 DataSharePredicates predicates;
338 vector<string> selectionArgs = { ZERO };
339 predicates.SetWhereClause(SELECTION);
340 predicates.SetWhereArgs(selectionArgs);
341 DataShareValuesBucket updateValues;
342 updateValues.Put(RINGTONE_COLUMN_TITLE, TITLE_UPDATE);
343
344 int64_t start = UTCTimeSeconds();
345 RingtoneTracer tracer;
346 tracer.Start("DataShareUpdateColumn");
347 for (int i = 0; i < 1; i++) {
348 auto result = g_dataShareHelper->Update(uri, predicates, updateValues);
349 EXPECT_EQ(result, E_HAS_DB_ERROR);
350 }
351 tracer.Finish();
352 int64_t end = UTCTimeSeconds();
353
354 GTEST_LOG_(INFO) << "DataShareUpdateColumn Cost: " << ((double) (end - start)) << "ms";
355 }
356
357 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_003, TestSize.Level0)
358 {
359 Uri uri(RINGTONE_PATH_URI);
360 DataSharePredicates predicates;
361 DataShareValuesBucket updateValues;
362
363 int64_t start = UTCTimeSeconds();
364 RingtoneTracer tracer;
365 tracer.Start("DataShareUpdate10Column");
366 for (int i = 0; i < 1; i++) {
367 auto result = g_dataShareHelper->Update(uri, predicates, updateValues);
368 EXPECT_EQ(result, E_INVALID_VALUES);
369 }
370 tracer.Finish();
371 int64_t end = UTCTimeSeconds();
372
373 GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
374 }
375
376 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_004, TestSize.Level0)
377 {
378 Uri uri(RINGTONE_PATH_URI);
379 DataSharePredicates predicates;
380 vector<string> selectionArgs = { ZERO };
381 predicates.SetWhereClause(SELECTION);
382 predicates.SetWhereArgs(selectionArgs);
383 DataShareValuesBucket values;
384 values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
385 values.Put(RINGTONE_COLUMN_DATA, DATA_DEFAULT);
386 values.Put(RINGTONE_COLUMN_SIZE, SIZE_DEFAULT);
387 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, DISPLAY_NAME_DEFAULT);
388 values.Put(RINGTONE_COLUMN_TITLE, TITLE_DEFAULT);
389 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, METADATA_MEDIA_TYPE_DEFAULT);
390 values.Put(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_DEFAULT);
391 values.Put(RINGTONE_COLUMN_MIME_TYPE, MIME_TYPE_DEFAULT);
392
393
394 int64_t start = UTCTimeSeconds();
395 RingtoneTracer tracer;
396 tracer.Start("DataShareUpdate10Column");
397 for (int i = 0; i < 1; i++) {
398 auto result = g_dataShareHelper->Update(uri, predicates, values);
399 EXPECT_EQ(result, E_HAS_DB_ERROR);
400 }
401 tracer.Finish();
402 int64_t end = UTCTimeSeconds();
403
404 GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
405 }
406
407 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_005, TestSize.Level0)
408 {
409 Uri uri(RINGTONE_URI);
410 DataSharePredicates predicates;
411 vector<string> selectionArgs = { ZERO };
412 predicates.SetWhereClause(SELECTION);
413 predicates.SetWhereArgs(selectionArgs);
414 DataShareValuesBucket values;
415 values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
416 values.Put(RINGTONE_COLUMN_DATA, DATA_DEFAULT);
417 values.Put(RINGTONE_COLUMN_SIZE, SIZE_DEFAULT);
418 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, DISPLAY_NAME_DEFAULT);
419 values.Put(RINGTONE_COLUMN_TITLE, TITLE_DEFAULT);
420 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, METADATA_MEDIA_TYPE_DEFAULT);
421 values.Put(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_DEFAULT);
422 values.Put(RINGTONE_COLUMN_MIME_TYPE, MIME_TYPE_DEFAULT);
423
424
425 int64_t start = UTCTimeSeconds();
426 RingtoneTracer tracer;
427 tracer.Start("DataShareUpdate10Column");
428 for (int i = 0; i < 1; i++) {
429 auto result = g_dataShareHelper->Update(uri, predicates, values);
430 EXPECT_EQ(result, E_INVALID_URI);
431 }
432 tracer.Finish();
433 int64_t end = UTCTimeSeconds();
434
435 GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
436 }
437
438 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_003, TestSize.Level0)
439 {
440 Uri uri(RINGTONE_DEFAULT_STR);
441
442 DataSharePredicates predicates;
443
444 auto result = g_dataShareHelper->Delete(uri, predicates);
445 EXPECT_EQ(result, E_INVALID_URI);
446 }
447
448 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_004, TestSize.Level0)
449 {
450 Uri uri(RINGTONE_DEFAULT_STR);
451
452 DataSharePredicates predicates;
453 vector<string> selectionArgs = { ZERO };
454 predicates.SetWhereClause(SELECTION);
455 predicates.SetWhereArgs(selectionArgs);
456
457 auto result = g_dataShareHelper->Delete(uri, predicates);
458 EXPECT_EQ(result, E_INVALID_URI);
459 }
460
461 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_005, TestSize.Level0)
462 {
463 Uri uri(RINGTONE_URI);
464
465 DataSharePredicates predicates;
466 vector<string> selectionArgs = { ZERO };
467 predicates.SetWhereClause(SELECTION);
468 predicates.SetWhereArgs(selectionArgs);
469
470 auto result = g_dataShareHelper->Delete(uri, predicates);
471 EXPECT_EQ(result, E_INVALID_URI);
472 }
473
474 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_002, TestSize.Level0)
475 {
476 Uri uri(RINGTONE_PATH_URI);
477 string mode;
478
479 auto fd = g_dataShareHelper->OpenFile(uri, mode);
480 EXPECT_EQ(fd, E_ERR);
481 if (fd >= 0) {
482 close(fd);
483 }
484 }
485
486 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_003, TestSize.Level0)
487 {
488 const string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + "1";
489 Uri uri(uriStr);
490 string mode = RINGTONE_FILEMODE_READWRITE;
491
492 auto fd = g_dataShareHelper->OpenFile(uri, mode);
493 EXPECT_EQ(fd, E_ERR);
494 if (fd >= 0) {
495 close(fd);
496 }
497 }
498
499 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_004, TestSize.Level0)
500 {
501 Uri uri(RINGTONE_PATH_URI);
502 string mode = RINGTONE_FILEMODE_READWRITE;
503
504 auto fd = g_dataShareHelper->OpenFile(uri, mode);
505 EXPECT_EQ(fd, E_ERR);
506 if (fd >= 0) {
507 close(fd);
508 }
509 }
510
511 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_005, TestSize.Level0)
512 {
513 Uri uri(RINGTONE_URI);
514 string mode = RINGTONE_FILEMODE_READWRITE;
515
516 auto fd = g_dataShareHelper->OpenFile(uri, mode);
517 EXPECT_EQ(fd, E_ERR);
518 if (fd >= 0) {
519 close(fd);
520 }
521 }
522
523 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_007, TestSize.Level0)
524 {
525 Uri uri(RINGTONE_PATH_URI);
526 DataSharePredicates predicates;
527 g_dataShareHelper->Delete(uri, predicates);;
528
529 int errCode = 0;
530 DatashareBusinessError businessError;
531 DataSharePredicates queryPredicates;
532 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
533 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
534 errCode = businessError.GetCode();
535 cout << "Query errCode=" << errCode << endl;
536
537 if (resultSet != nullptr) {
538 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
539 EXPECT_NE(results, nullptr);
540 cout << "query count = " << to_string(results->GetCount()) << endl;
541 }
542 }
543
544 HWTEST_F(RingtoneUnitTest, medialib_querySystemRingtone_test_001, TestSize.Level0)
545 {
546 Uri uri(RINGTONE_PATH_URI);
547
548 int errCode = 0;
549 DatashareBusinessError businessError;
550 DataSharePredicates queryPredicates;
551 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(SourceType::SOURCE_TYPE_PRESET));
552 vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
553 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
554 errCode = businessError.GetCode();
555 cout << "Query errCode=" << errCode << endl;
556
557 if (resultSet != nullptr) {
558 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
559 EXPECT_NE(results, nullptr);
560 cout << "query count = " << to_string(results->GetCount()) << endl;
561 }
562 }
563
564 HWTEST_F(RingtoneUnitTest, medialib_queryCustomisedRingtone_test_001, TestSize.Level0)
565 {
566 Uri uri(RINGTONE_PATH_URI);
567
568 int errCode = 0;
569 DatashareBusinessError businessError;
570 DataSharePredicates queryPredicates;
571 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(SourceType::SOURCE_TYPE_CUSTOMISED));
572 vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
573 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
574 errCode = businessError.GetCode();
575 cout << "Query errCode=" << errCode << endl;
576
577 if (resultSet != nullptr) {
578 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
579 EXPECT_NE(results, nullptr);
580 cout << "query count = " << to_string(results->GetCount()) << endl;
581 }
582 }
583
584 HWTEST_F(RingtoneUnitTest, medialib_queryAllRingtone_test_001, TestSize.Level0)
585 {
586 Uri uri(RINGTONE_PATH_URI);
587
588 int errCode = 0;
589 DatashareBusinessError businessError;
590 DataSharePredicates queryPredicates;
591 vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
592 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
593 errCode = businessError.GetCode();
594 cout << "Query errCode=" << errCode << endl;
595
596 if (resultSet != nullptr) {
597 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
598 EXPECT_NE(results, nullptr);
599 cout << "query count = " << to_string(results->GetCount()) << endl;
600 }
601 }
602
603 HWTEST_F(RingtoneUnitTest, medialib_deleteVibrateSetting_test_001, TestSize.Level0)
604 {
605 Uri uri(SIMCARD_SETTING_PATH_URI);
606
607 DataSharePredicates predicates;
608 vector<string> selectionArgs = {std::to_string(RING_TONE_TYPE_NOT)};
609 const std::string selection = SIMCARD_SETTING_COLUMN_MODE + " = ? ";
610 predicates.SetWhereClause(selection);
611 predicates.SetWhereArgs(selectionArgs);
612 vector<string> columns {
613 SIMCARD_SETTING_COLUMN_MODE,
614 SIMCARD_SETTING_COLUMN_TONE_FILE,
615 SIMCARD_SETTING_COLUMN_VIBRATE_FILE,
616 SIMCARD_SETTING_COLUMN_VIBRATE_MODE
617 };
618
619 auto ret = g_dataShareHelper->Delete(uri, predicates);
620 GTEST_LOG_(INFO)<< "GetVibrateSetting -> Delete result=" << ret;
621 EXPECT_EQ((ret > 0), true);
622 }
623
624 HWTEST_F(RingtoneUnitTest, medialib_silentAccessQuery_test_001, TestSize.Level0)
625 {
626 Uri uri(RINGTONE_LIBRARY_PROXY_DATA_URI_SIMCARD_SETTING);
627
628 DataSharePredicates predicates;
629 vector<string> selectionArgs = {std::to_string(RING_TONE_TYPE_SIM_CARD_1)};
630 const std::string selection = SIMCARD_SETTING_COLUMN_MODE + " = ? ";
631 predicates.SetWhereClause(selection);
632 predicates.SetWhereArgs(selectionArgs);
633
634 vector<string> columns {
635 SIMCARD_SETTING_COLUMN_MODE,
636 SIMCARD_SETTING_COLUMN_TONE_FILE,
637 SIMCARD_SETTING_COLUMN_VIBRATE_FILE,
638 SIMCARD_SETTING_COLUMN_VIBRATE_MODE
639 };
640
641 DatashareBusinessError businessError;
642 auto resultSet = g_dataShareHelperProxy->Query(uri, predicates, columns, &businessError);
643 auto errCode = businessError.GetCode();
644 GTEST_LOG_(INFO)<< "g_dataShareHelperProxy->Query(uri errCode=" << errCode;
645 EXPECT_EQ(resultSet, nullptr);
646 }
647 } // namespace Media
648 } // namespace OHOS
649