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_check_utils.h"
23 #include "ringtone_db_const.h"
24 #include "ringtone_errno.h"
25 #include "ringtone_fetch_result.h"
26 #include "ringtone_file_utils.h"
27 #include "ringtone_log.h"
28 #include "ringtone_scanner_utils.h"
29 #include "ringtone_tracer.h"
30 #include "ringtone_type.h"
31 #include "accesstoken_kit.h"
32 #include "hap_token_info.h"
33 #include "token_setproc.h"
34 #include "ringtone_proxy_uri.h"
35
36 using namespace std;
37 using namespace OHOS;
38 using namespace testing::ext;
39 using namespace OHOS::DataShare;
40 using namespace OHOS::AppExecFwk;
41 using namespace OHOS::Security::AccessToken;
42 namespace OHOS {
43 namespace Media {
44 constexpr int STORAGE_MANAGER_ID = 5003;
45 std::shared_ptr<DataShare::DataShareHelper> g_dataShareHelper = nullptr;
46 std::shared_ptr<DataShare::DataShareHelper> g_dataShareHelperProxy = nullptr;
47 const int S2MS = 1000;
48 const int MS2NS = 1000000;
49 const string SELECTION = RINGTONE_COLUMN_TONE_ID + " <> ?";
50 const int NUMBER_OF_TIMES = 10;
51 const string RINGTONE_LIBRARY_PATH = "/data/storage/el2/base/files";
52 const int TEST_RINGTONE_COLUMN_SIZE = 1022;
53 const string MTP_FORMAT_OGG = ".ogg"; // OGG audio files
54 const string TEST_INSERT_RINGTONE_LIBRARY = "test_insert_ringtone_library";
55 const string RAINNING = "rainning";
56 const string TITLE_UPDATE = "run";
57 const string ZERO = "0";
58 const string SLASH_STR = "/";
59 const string MTP_FORMAT_JSON = ".json"; // OGG audio files
60
GetPermissionStateFulls()61 std::vector<PermissionStateFull> GetPermissionStateFulls()
62 {
63 std::vector<PermissionStateFull> permissionStateFulls = {
64 {
65 .permissionName = "ohos.permission.WRITE_RINGTONE",
66 .isGeneral = true,
67 .resDeviceID = { "local" },
68 .grantStatus = { PermissionState::PERMISSION_GRANTED },
69 .grantFlags = { 1 }
70 },
71 {
72 .permissionName = "ohos.permission.READ_AUDIO",
73 .isGeneral = true,
74 .resDeviceID = { "local" },
75 .grantStatus = { PermissionState::PERMISSION_GRANTED },
76 .grantFlags = { 1 }
77 }
78 };
79 return permissionStateFulls;
80 }
81
SetUpTestCase()82 void RingtoneUnitTest::SetUpTestCase()
83 {
84 vector<string> perms;
85 perms.push_back("ohos.permission.WRITE_RINGTONE");
86
87 uint64_t tokenId = 0;
88 RingtonePermissionUtilsUnitTest::SetAccessTokenPermission("RingtoneUnitTest", perms, tokenId);
89 ASSERT_TRUE(tokenId != 0);
90
91 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
92 ASSERT_TRUE(saManager != nullptr);
93
94 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_ID);
95 ASSERT_TRUE(remoteObj != nullptr);
96
97 g_dataShareHelper = DataShare::DataShareHelper::Creator(remoteObj, RINGTONE_URI);
98 ASSERT_TRUE(g_dataShareHelper != nullptr);
99
100 HapInfoParams info = {
101 .userID = 100,
102 .bundleName = "ohos.datashareclienttest.demo",
103 .instIndex = 0,
104 .appIDDesc = "ohos.datashareclienttest.demo"
105 };
106
107 auto permStateList = GetPermissionStateFulls();
108 HapPolicyParams policy = {
109 .apl = APL_NORMAL,
110 .domain = "test.domain",
111 .permList = {
112 {
113 .permissionName = "ohos.permission.test",
114 .bundleName = "ohos.datashareclienttest.demo",
115 .grantMode = 1,
116 .availableLevel = APL_NORMAL,
117 .label = "label",
118 .labelId = 1,
119 .description = "ohos.datashareclienttest.demo",
120 .descriptionId = 1
121 }
122 },
123 .permStateList = permStateList
124 };
125 AccessTokenKit::AllocHapToken(info, policy);
126 auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
127 info.userID, info.bundleName, info.instIndex);
128 SetSelfTokenID(testTokenId.tokenIDEx);
129
130 CreateOptions options;
131 options.enabled_ = true;
132 g_dataShareHelperProxy = DataShare::DataShareHelper::Creator(RINGTONE_LIBRARY_PROXY_URI, options);
133 }
134
TearDownTestCase()135 void RingtoneUnitTest::TearDownTestCase()
136 {
137 RINGTONE_ERR_LOG("TearDownTestCase start");
138 if (g_dataShareHelper != nullptr) {
139 g_dataShareHelper->Release();
140 }
141 system("rm -rf /data/storage/el2/base/files/");
142 RINGTONE_INFO_LOG("TearDownTestCase end");
143 }
144
SetUp(void)145 void RingtoneUnitTest::SetUp(void) {}
146
TearDown(void)147 void RingtoneUnitTest::TearDown(void)
148 {
149 system("rm -rf /data/storage/el2/base/files/");
150 }
151
UTCTimeSeconds()152 int64_t UTCTimeSeconds()
153 {
154 struct timespec t;
155 t.tv_sec = 0;
156 t.tv_nsec = 0;
157 clock_gettime(CLOCK_REALTIME, &t);
158 return (int64_t) ((t.tv_sec * S2MS) + (t.tv_nsec / MS2NS));
159 }
160
161 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_001, TestSize.Level0)
162 {
163 Uri uri(RINGTONE_PATH_URI);
164 DataSharePredicates predicates;
165 vector<string> selectionArgs = { ZERO };
166 predicates.SetWhereClause(SELECTION);
167 predicates.SetWhereArgs(selectionArgs);
168 vector<string> columns {
169 RINGTONE_COLUMN_TONE_ID,
170 RINGTONE_COLUMN_DATA,
171 RINGTONE_COLUMN_SIZE,
172 RINGTONE_COLUMN_DISPLAY_NAME,
173 RINGTONE_COLUMN_TITLE,
174 RINGTONE_COLUMN_MEDIA_TYPE,
175 RINGTONE_COLUMN_TONE_TYPE,
176 RINGTONE_COLUMN_MIME_TYPE,
177 };
178
179 int64_t start = UTCTimeSeconds();
180 RingtoneTracer tracer;
181 tracer.Start("DataShareQuery10Column");
182 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
183 auto result = g_dataShareHelper->Query(uri, predicates, columns);
184 EXPECT_NE(result, nullptr);
185 }
186 tracer.Finish();
187 int64_t end = UTCTimeSeconds();
188
189 GTEST_LOG_(INFO) << "DataShareQueryColumn Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
190 }
191
192 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_002, TestSize.Level0)
193 {
194 Uri uri(RINGTONE_PATH_URI);
195 DataSharePredicates predicates;
196 vector<string> columns;
197
198 int64_t start = UTCTimeSeconds();
199 RingtoneTracer tracer;
200 tracer.Start("DataShareQuery10Column");
201 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
202 auto result = g_dataShareHelper->Query(uri, predicates, columns);
203 EXPECT_NE(result, nullptr);
204 }
205 tracer.Finish();
206 int64_t end = UTCTimeSeconds();
207
208 GTEST_LOG_(INFO) << "DataShareQuery Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
209 }
210
211 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_003, TestSize.Level0)
212 {
213 Uri uri(RINGTONE_PATH_URI);
214 DataSharePredicates predicates;
215 vector<string> selectionArgs = { ZERO };
216 predicates.SetWhereClause(SELECTION);
217 predicates.SetWhereArgs(selectionArgs);
218 vector<string> columns;
219
220 int64_t start = UTCTimeSeconds();
221 RingtoneTracer tracer;
222 tracer.Start("DataShareQuery10Column");
223 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
224 auto result = g_dataShareHelper->Query(uri, predicates, columns);
225 EXPECT_NE(result, nullptr);
226 }
227 tracer.Finish();
228 int64_t end = UTCTimeSeconds();
229
230 GTEST_LOG_(INFO) << "DataShareQuery1-3Column Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
231 }
232
233 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_004, TestSize.Level0)
234 {
235 Uri uri(RINGTONE_PATH_URI);
236 DataSharePredicates predicates;
237 vector<string> columns {
238 RINGTONE_COLUMN_TONE_ID,
239 RINGTONE_COLUMN_DATA,
240 RINGTONE_COLUMN_SIZE,
241 RINGTONE_COLUMN_DISPLAY_NAME,
242 RINGTONE_COLUMN_TITLE,
243 RINGTONE_COLUMN_MEDIA_TYPE,
244 RINGTONE_COLUMN_TONE_TYPE,
245 RINGTONE_COLUMN_MIME_TYPE,
246 };
247
248 int64_t start = UTCTimeSeconds();
249 RingtoneTracer tracer;
250 tracer.Start("DataShareQuery10Column");
251 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
252 auto result = g_dataShareHelper->Query(uri, predicates, columns);
253 EXPECT_NE(result, nullptr);
254 }
255 tracer.Finish();
256 int64_t end = UTCTimeSeconds();
257
258 GTEST_LOG_(INFO) << "DataShareQuery Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
259 }
260
261 HWTEST_F(RingtoneUnitTest, medialib_datashareQuery_test_005, TestSize.Level0)
262 {
263 Uri uri(RINGTONE_URI);
264 DataSharePredicates predicates;
265 vector<string> selectionArgs = { ZERO };
266 predicates.SetWhereClause(SELECTION);
267 predicates.SetWhereArgs(selectionArgs);
268 vector<string> columns {
269 RINGTONE_COLUMN_TONE_ID,
270 RINGTONE_COLUMN_DATA,
271 RINGTONE_COLUMN_SIZE,
272 RINGTONE_COLUMN_DISPLAY_NAME,
273 RINGTONE_COLUMN_TITLE,
274 RINGTONE_COLUMN_MEDIA_TYPE,
275 RINGTONE_COLUMN_TONE_TYPE,
276 RINGTONE_COLUMN_MIME_TYPE,
277 };
278
279 int64_t start = UTCTimeSeconds();
280 RingtoneTracer tracer;
281 tracer.Start("DataShareQuery10Column");
282 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
283 auto result = g_dataShareHelper->Query(uri, predicates, columns);
284 EXPECT_EQ(result, nullptr);
285 }
286 tracer.Finish();
287 int64_t end = UTCTimeSeconds();
288
289 GTEST_LOG_(INFO) << "DataShareQueryColumn Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
290 }
291
292 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_001, TestSize.Level0)
293 {
294 Uri uri(RINGTONE_PATH_URI);
295
296 int64_t start = UTCTimeSeconds();
297 RingtoneTracer tracer;
298 tracer.Start("DataShareInsert10Column");
299 for (int index = 0; index < NUMBER_OF_TIMES; index++) {
300 DataShareValuesBucket values;
301 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
302 TEST_INSERT_RINGTONE_LIBRARY + to_string(index) + MTP_FORMAT_OGG));
303 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
304 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
305 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
306 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
307 auto result = g_dataShareHelper->Insert(uri, values);
308 EXPECT_EQ((result > 0), true);
309 }
310 tracer.Finish();
311 int64_t end = UTCTimeSeconds();
312
313 DataSharePredicates predicates;
314 auto ret = g_dataShareHelper->Delete(uri, predicates);
315 EXPECT_EQ((ret > 0), true);
316 GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
317 }
318
319 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_002, TestSize.Level0)
320 {
321 Uri uri(RINGTONE_PATH_URI);
322
323 int64_t start = UTCTimeSeconds();
324 RingtoneTracer tracer;
325 tracer.Start("DataShareInsertColumn");
326 DataShareValuesBucket values;
327 auto result = g_dataShareHelper->Insert(uri, values);
328 EXPECT_EQ(result, E_INVALID_VALUES);
329 tracer.Finish();
330 int64_t end = UTCTimeSeconds();
331
332 GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start)) << "ms";
333 }
334
335 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_003, TestSize.Level0)
336 {
337 Uri uri(RINGTONE_DEFAULT_STR);
338
339 int64_t start = UTCTimeSeconds();
340 RingtoneTracer tracer;
341 tracer.Start("DataShareInsertColumn");
342 DataShareValuesBucket values;
343 values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
344 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
345 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
346 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
347 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
348 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
349 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
350 auto result = g_dataShareHelper->Insert(uri, values);
351 EXPECT_EQ(result, E_INVALID_URI);
352 tracer.Finish();
353 int64_t end = UTCTimeSeconds();
354
355 GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start)) << "ms";
356 }
357
358 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_004, TestSize.Level0)
359 {
360 Uri uri(RINGTONE_PATH_URI);
361 const string errorRingtoneLibraryPath =
362 "/storage/media/files/data/com.ohos.ringtonelibrary.ringtonelibrarydata";
363
364 int64_t start = UTCTimeSeconds();
365 RingtoneTracer tracer;
366 tracer.Start("DataShareInsertColumn");
367 DataShareValuesBucket values;
368 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(errorRingtoneLibraryPath + RINGTONE_SLASH_CHAR +
369 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
370 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
371 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
372 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
373 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
374 auto result = g_dataShareHelper->Insert(uri, values);
375 EXPECT_EQ(result, E_ERR);
376 tracer.Finish();
377 int64_t end = UTCTimeSeconds();
378
379 GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start)) << "ms";
380 }
381
382 HWTEST_F(RingtoneUnitTest, medialib_datashareInsert_test_005, TestSize.Level0)
383 {
384 Uri uri(RINGTONE_URI);
385
386 int64_t start = UTCTimeSeconds();
387 RingtoneTracer tracer;
388 tracer.Start("DataShareInsertColumn");
389 DataShareValuesBucket values;
390 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
391 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
392 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
393 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
394 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
395 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
396 auto result = g_dataShareHelper->Insert(uri, values);
397 EXPECT_EQ(result, E_INVALID_URI);
398 tracer.Finish();
399 int64_t end = UTCTimeSeconds();
400
401 GTEST_LOG_(INFO) << "DataShareInsertColumn Cost: " << ((double) (end - start)) << "ms";
402 }
403
404 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_001, TestSize.Level0)
405 {
406 Uri uri(RINGTONE_PATH_URI);
407 DataShareValuesBucket values;
408 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
409 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
410 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
411 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
412 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
413 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
414 auto result = g_dataShareHelper->Insert(uri, values);
415 EXPECT_EQ((result > 0), true);
416
417 DataSharePredicates predicates;
418 DataShareValuesBucket updateValues;
419 updateValues.Put(RINGTONE_COLUMN_TITLE, TITLE_UPDATE);
420
421 int64_t start = UTCTimeSeconds();
422 RingtoneTracer tracer;
423 tracer.Start("DataShareUpdate10Column");
424 for (int i = 0; i < NUMBER_OF_TIMES; i++) {
425 auto result = g_dataShareHelper->Update(uri, predicates, updateValues);
426 EXPECT_EQ((result > 0), true);
427 }
428 tracer.Finish();
429 int64_t end = UTCTimeSeconds();
430
431 result = g_dataShareHelper->Delete(uri, predicates);
432 EXPECT_EQ((result > 0), true);
433 GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start) / NUMBER_OF_TIMES) << "ms";
434 }
435
436 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_002, TestSize.Level0)
437 {
438 Uri uri(RINGTONE_PATH_URI);
439 DataShareValuesBucket valuesInsert;
440 valuesInsert.Put(RINGTONE_COLUMN_DATA,
441 static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
442 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
443 valuesInsert.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
444 valuesInsert.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
445 valuesInsert.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
446 valuesInsert.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
447 auto result = g_dataShareHelper->Insert(uri, valuesInsert);
448 EXPECT_GT(result, E_OK);
449
450 DataSharePredicates predicates;
451 vector<string> selectionArgs = { ZERO };
452 predicates.SetWhereClause(SELECTION);
453 predicates.SetWhereArgs(selectionArgs);
454 DataShareValuesBucket updateValues;
455 updateValues.Put(RINGTONE_COLUMN_TITLE, TITLE_UPDATE);
456
457 int64_t start = UTCTimeSeconds();
458 RingtoneTracer tracer;
459 tracer.Start("DataShareUpdateColumn");
460 for (int i = 0; i < 1; i++) {
461 auto result = g_dataShareHelper->Update(uri, predicates, updateValues);
462 EXPECT_EQ(result, 1);
463 }
464 DataSharePredicates predicatesDel;
465 predicatesDel.EqualTo(RINGTONE_COLUMN_TITLE, TITLE_UPDATE);
466 EXPECT_GT(g_dataShareHelper->Delete(uri, predicatesDel), E_OK);
467 tracer.Finish();
468 int64_t end = UTCTimeSeconds();
469
470 GTEST_LOG_(INFO) << "DataShareUpdateColumn Cost: " << ((double) (end - start)) << "ms";
471 }
472
473 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_003, TestSize.Level0)
474 {
475 Uri uri(RINGTONE_PATH_URI);
476 DataSharePredicates predicates;
477 DataShareValuesBucket updateValues;
478
479 int64_t start = UTCTimeSeconds();
480 RingtoneTracer tracer;
481 tracer.Start("DataShareUpdate10Column");
482 for (int i = 0; i < 1; i++) {
483 auto result = g_dataShareHelper->Update(uri, predicates, updateValues);
484 EXPECT_EQ(result, E_INVALID_VALUES);
485 }
486 tracer.Finish();
487 int64_t end = UTCTimeSeconds();
488
489 GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
490 }
491
492 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_004, TestSize.Level0)
493 {
494 Uri uri(RINGTONE_PATH_URI);
495 DataSharePredicates predicates;
496 vector<string> selectionArgs = { ZERO };
497 predicates.SetWhereClause(SELECTION);
498 predicates.SetWhereArgs(selectionArgs);
499 DataShareValuesBucket values;
500 values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
501 values.Put(RINGTONE_COLUMN_DATA, DATA_DEFAULT);
502 values.Put(RINGTONE_COLUMN_SIZE, SIZE_DEFAULT);
503 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, DISPLAY_NAME_DEFAULT);
504 values.Put(RINGTONE_COLUMN_TITLE, TITLE_DEFAULT);
505 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, METADATA_MEDIA_TYPE_DEFAULT);
506 values.Put(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_DEFAULT);
507 values.Put(RINGTONE_COLUMN_MIME_TYPE, MIME_TYPE_DEFAULT);
508
509
510 int64_t start = UTCTimeSeconds();
511 RingtoneTracer tracer;
512 tracer.Start("DataShareUpdate10Column");
513 for (int i = 0; i < 1; i++) {
514 auto result = g_dataShareHelper->Update(uri, predicates, values);
515 EXPECT_EQ(result, E_HAS_DB_ERROR);
516 }
517 tracer.Finish();
518 int64_t end = UTCTimeSeconds();
519
520 GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
521 }
522
523 HWTEST_F(RingtoneUnitTest, medialib_datashareUpdate_test_005, TestSize.Level0)
524 {
525 Uri uri(RINGTONE_URI);
526 DataSharePredicates predicates;
527 vector<string> selectionArgs = { ZERO };
528 predicates.SetWhereClause(SELECTION);
529 predicates.SetWhereArgs(selectionArgs);
530 DataShareValuesBucket values;
531 values.Put(RINGTONE_COLUMN_TONE_ID, TONE_ID_DEFAULT);
532 values.Put(RINGTONE_COLUMN_DATA, DATA_DEFAULT);
533 values.Put(RINGTONE_COLUMN_SIZE, SIZE_DEFAULT);
534 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, DISPLAY_NAME_DEFAULT);
535 values.Put(RINGTONE_COLUMN_TITLE, TITLE_DEFAULT);
536 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, METADATA_MEDIA_TYPE_DEFAULT);
537 values.Put(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_DEFAULT);
538 values.Put(RINGTONE_COLUMN_MIME_TYPE, MIME_TYPE_DEFAULT);
539
540
541 int64_t start = UTCTimeSeconds();
542 RingtoneTracer tracer;
543 tracer.Start("DataShareUpdate10Column");
544 for (int i = 0; i < 1; i++) {
545 auto result = g_dataShareHelper->Update(uri, predicates, values);
546 EXPECT_EQ(result, E_INVALID_URI);
547 }
548 tracer.Finish();
549 int64_t end = UTCTimeSeconds();
550
551 GTEST_LOG_(INFO) << "DataShareUpdate1-3Column Cost: " << ((double) (end - start)) << "ms";
552 }
553
554 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_001, TestSize.Level0)
555 {
556 Uri uri(RINGTONE_PATH_URI);
557 DataShareValuesBucket values;
558 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
559 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
560 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
561 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
562 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
563 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
564 auto result = g_dataShareHelper->Insert(uri, values);
565 EXPECT_EQ((result > 0), true);
566
567 DataSharePredicates predicates;
568
569 result = g_dataShareHelper->Delete(uri, predicates);
570 EXPECT_EQ((result > 0), true);
571 }
572
573 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_002, TestSize.Level0)
574 {
575 Uri uri(RINGTONE_PATH_URI);
576
577 DataSharePredicates predicates;
578 vector<string> selectionArgs = { ZERO };
579 predicates.SetWhereClause(SELECTION);
580 predicates.SetWhereArgs(selectionArgs);
581
582 auto result = g_dataShareHelper->Delete(uri, predicates);
583 EXPECT_EQ(result, E_HAS_DB_ERROR);
584 }
585
586 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_003, TestSize.Level0)
587 {
588 Uri uri(RINGTONE_DEFAULT_STR);
589
590 DataSharePredicates predicates;
591
592 auto result = g_dataShareHelper->Delete(uri, predicates);
593 EXPECT_EQ(result, E_INVALID_URI);
594 }
595
596 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_004, TestSize.Level0)
597 {
598 Uri uri(RINGTONE_DEFAULT_STR);
599
600 DataSharePredicates predicates;
601 vector<string> selectionArgs = { ZERO };
602 predicates.SetWhereClause(SELECTION);
603 predicates.SetWhereArgs(selectionArgs);
604
605 auto result = g_dataShareHelper->Delete(uri, predicates);
606 EXPECT_EQ(result, E_INVALID_URI);
607 }
608
609 HWTEST_F(RingtoneUnitTest, medialib_datashareDelete_test_005, TestSize.Level0)
610 {
611 Uri uri(RINGTONE_URI);
612
613 DataSharePredicates predicates;
614 vector<string> selectionArgs = { ZERO };
615 predicates.SetWhereClause(SELECTION);
616 predicates.SetWhereArgs(selectionArgs);
617
618 auto result = g_dataShareHelper->Delete(uri, predicates);
619 EXPECT_EQ(result, E_INVALID_URI);
620 }
621
622 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_001, TestSize.Level0)
623 {
624 Uri uri(RINGTONE_PATH_URI);
625 DataShareValuesBucket values;
626 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
627 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
628 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
629 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
630 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
631 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
632 auto result = g_dataShareHelper->Insert(uri, values);
633 EXPECT_EQ((result > 0), true);
634
635 int errCode = 0;
636 DatashareBusinessError businessError;
637 DataSharePredicates queryPredicates;
638 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA } };
639 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
640 errCode = businessError.GetCode();
641 cout << "Query errCode=" << errCode << endl;
642
643 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
644 cout << "query count = " << to_string(results->GetCount()) << endl;
645 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
646 if (ringtoneAsset != nullptr && ringtoneAsset->GetPath() != RINGTONE_DEFAULT_STR) {
647 string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(ringtoneAsset->GetId());
648 Uri ofUri(uriStr);
649 string mode = RINGTONE_FILEMODE_READWRITE;
650 auto fd = g_dataShareHelper->OpenFile(ofUri, mode);
651 EXPECT_GE(fd, 0);
652 cout << "OpenFile fd = " << fd << endl;
653 if (fd >= 0) {
654 close(fd);
655 }
656 }
657 DataSharePredicates predicates;
658 result = g_dataShareHelper->Delete(uri, predicates);
659 EXPECT_EQ((result > 0), true);
660 }
661
662 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_002, TestSize.Level0)
663 {
664 Uri uri(RINGTONE_PATH_URI);
665 string mode;
666
667 auto fd = g_dataShareHelper->OpenFile(uri, mode);
668 EXPECT_EQ(fd, E_ERR);
669 if (fd >= 0) {
670 close(fd);
671 }
672 }
673
674 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_003, TestSize.Level0)
675 {
676 const string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + "1";
677 Uri uri(uriStr);
678 string mode = RINGTONE_FILEMODE_READWRITE;
679
680 auto fd = g_dataShareHelper->OpenFile(uri, mode);
681 EXPECT_EQ(fd, E_ERR);
682 if (fd >= 0) {
683 close(fd);
684 }
685 }
686
687 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_004, TestSize.Level0)
688 {
689 Uri uri(RINGTONE_PATH_URI);
690 string mode = RINGTONE_FILEMODE_READWRITE;
691
692 auto fd = g_dataShareHelper->OpenFile(uri, mode);
693 EXPECT_EQ(fd, E_ERR);
694 if (fd >= 0) {
695 close(fd);
696 }
697 }
698
699 HWTEST_F(RingtoneUnitTest, medialib_datashareOpenFile_test_005, TestSize.Level0)
700 {
701 Uri uri(RINGTONE_URI);
702 string mode = RINGTONE_FILEMODE_READWRITE;
703
704 auto fd = g_dataShareHelper->OpenFile(uri, mode);
705 EXPECT_EQ(fd, E_ERR);
706 if (fd >= 0) {
707 close(fd);
708 }
709 }
710
711
712 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_001, TestSize.Level0)
713 {
714 Uri uri(RINGTONE_PATH_URI);
715 DataSharePredicates predicates;
716 g_dataShareHelper->Delete(uri, predicates);
717 DataShareValuesBucket values;
718 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
719 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
720 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
721 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
722 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
723 values.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(2));
724 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
725 auto result = g_dataShareHelper->Insert(uri, values);
726 cout << "Insert result=" << result << endl;
727 EXPECT_EQ((result > 0), true);
728
729 int errCode = 0;
730 DatashareBusinessError businessError;
731 DataSharePredicates queryPredicates;
732 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
733 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
734 errCode = businessError.GetCode();
735 cout << "Query errCode=" << errCode << endl;
736
737 if (resultSet != nullptr) {
738 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
739 cout << "query count = " << to_string(results->GetCount()) << endl;
740 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetLastObject();
741 if (ringtoneAsset == nullptr) {
742 exit(1);
743 }
744 cout << "GetSourceType() = " << to_string(ringtoneAsset->GetSourceType()) << endl;
745 result = g_dataShareHelper->Delete(uri, predicates);
746 EXPECT_EQ((result > 0), true);
747 }
748 }
749
750 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_002, TestSize.Level0)
751 {
752 Uri uri(RINGTONE_PATH_URI);
753 DataSharePredicates predicates;
754 g_dataShareHelper->Delete(uri, predicates);
755 DataShareValuesBucket values;
756 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
757 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
758 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
759 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
760 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
761 values.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(1));
762 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
763 auto result = g_dataShareHelper->Insert(uri, values);
764 cout << "Insert result=" << result << endl;
765 EXPECT_EQ((result > 0), true);
766
767 int errCode = 0;
768 DatashareBusinessError businessError;
769 DataSharePredicates queryPredicates;
770 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
771 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
772 errCode = businessError.GetCode();
773 cout << "Query errCode=" << errCode << endl;
774
775 if (resultSet != nullptr) {
776 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
777 cout << "query count = " << to_string(results->GetCount()) << endl;
778 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetLastObject();
779 if (ringtoneAsset == nullptr) {
780 exit(1);
781 }
782 cout << "GetSourceType() = " << to_string(ringtoneAsset->GetSourceType()) << endl;
783 result = g_dataShareHelper->Delete(uri, predicates);
784 EXPECT_EQ((result > 0), true);
785 }
786 }
787
788 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_003, TestSize.Level0)
789 {
790 Uri uri(RINGTONE_PATH_URI);
791 DataSharePredicates predicates;
792 g_dataShareHelper->Delete(uri, predicates);
793 DataShareValuesBucket values;
794 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
795 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
796 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
797 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
798 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
799 values.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(2));
800 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
801 auto result = g_dataShareHelper->Insert(uri, values);
802 cout << "Insert result=" << result << endl;
803 EXPECT_EQ((result > 0), true);
804
805 DataShareValuesBucket valuesInsert;
806 valuesInsert.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
807 TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_OGG));
808 valuesInsert.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
809 valuesInsert.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
810 valuesInsert.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
811 valuesInsert.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(1));
812 valuesInsert.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
813 result = g_dataShareHelper->Insert(uri, valuesInsert);
814 cout << "Insert2 result=" << result << endl;
815 EXPECT_EQ((result > 0), true);
816
817 int errCode = 0;
818 DatashareBusinessError businessError;
819 DataSharePredicates queryPredicates;
820 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(2));
821 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
822 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
823 errCode = businessError.GetCode();
824 cout << "Query errCode=" << errCode << endl;
825
826 if (resultSet != nullptr) {
827 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
828 cout << "query count = " << to_string(results->GetCount()) << endl;
829 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetLastObject();
830 if (ringtoneAsset == nullptr) {
831 exit(1);
832 }
833 cout << "GetSourceType() = " << to_string(ringtoneAsset->GetSourceType()) << endl;
834 result = g_dataShareHelper->Delete(uri, predicates);
835 EXPECT_EQ((result > 0), true);
836 }
837 }
838
839 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_004, TestSize.Level0)
840 {
841 Uri uri(RINGTONE_PATH_URI);
842 DataSharePredicates predicates;
843 g_dataShareHelper->Delete(uri, predicates);
844 DataShareValuesBucket values;
845 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
846 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
847 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
848 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
849 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
850 values.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(2));
851 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
852 auto result = g_dataShareHelper->Insert(uri, values);
853 cout << "Insert result=" << result << endl;
854 EXPECT_EQ((result > 0), true);
855
856 DataShareValuesBucket valuesInsert;
857 valuesInsert.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
858 TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_OGG));
859 valuesInsert.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
860 valuesInsert.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
861 valuesInsert.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
862 valuesInsert.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(1));
863 valuesInsert.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
864 result = g_dataShareHelper->Insert(uri, valuesInsert);
865 cout << "Insert2 result=" << result << endl;
866 EXPECT_EQ((result > 0), true);
867
868 int errCode = 0;
869 DatashareBusinessError businessError;
870 DataSharePredicates queryPredicates;
871 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(1));
872 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
873 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
874 errCode = businessError.GetCode();
875 cout << "Query errCode=" << errCode << endl;
876
877 if (resultSet != nullptr) {
878 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
879 cout << "query count = " << to_string(results->GetCount()) << endl;
880 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetLastObject();
881 if (ringtoneAsset == nullptr) {
882 exit(1);
883 }
884 cout << "GetSourceType() = " << to_string(ringtoneAsset->GetSourceType()) << endl;
885 result = g_dataShareHelper->Delete(uri, predicates);
886 EXPECT_EQ((result > 0), true);
887 }
888 }
889
890 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_005, TestSize.Level0)
891 {
892 Uri uri(RINGTONE_PATH_URI);
893 DataSharePredicates predicates;
894 g_dataShareHelper->Delete(uri, predicates);
895 DataShareValuesBucket values;
896 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
897 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
898 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
899 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
900 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
901 values.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(2));
902 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
903 auto result = g_dataShareHelper->Insert(uri, values);
904 cout << "Insert result=" << result << endl;
905 EXPECT_EQ((result > 0), true);
906
907 int errCode = 0;
908 DatashareBusinessError businessError;
909 DataSharePredicates queryPredicates;
910 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(1));
911 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
912 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
913 errCode = businessError.GetCode();
914 cout << "Query errCode=" << errCode << endl;
915
916 if (resultSet != nullptr) {
917 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
918 cout << "query count = " << to_string(results->GetCount()) << endl;
919 result = g_dataShareHelper->Delete(uri, predicates);
920 EXPECT_EQ((result > 0), true);
921 }
922 }
923
924 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_006, TestSize.Level0)
925 {
926 Uri uri(RINGTONE_PATH_URI);
927 DataSharePredicates predicates;
928 g_dataShareHelper->Delete(uri, predicates);
929 DataShareValuesBucket valuesInsert;
930 valuesInsert.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
931 TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_OGG));
932 valuesInsert.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
933 valuesInsert.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
934 valuesInsert.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
935 valuesInsert.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(1));
936 valuesInsert.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
937 auto result = g_dataShareHelper->Insert(uri, valuesInsert);
938 cout << "Insert2 result=" << result << endl;
939 EXPECT_EQ((result > 0), true);
940
941 int errCode = 0;
942 DatashareBusinessError businessError;
943 DataSharePredicates queryPredicates;
944 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(2));
945 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
946 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
947 errCode = businessError.GetCode();
948 cout << "Query errCode=" << errCode << endl;
949
950 if (resultSet != nullptr) {
951 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
952 cout << "query count = " << to_string(results->GetCount()) << endl;
953 result = g_dataShareHelper->Delete(uri, predicates);
954 EXPECT_EQ((result > 0), true);
955 }
956 }
957
958 HWTEST_F(RingtoneUnitTest, medialib_ringtoneRead_test_007, TestSize.Level0)
959 {
960 Uri uri(RINGTONE_PATH_URI);
961 DataSharePredicates predicates;
962 g_dataShareHelper->Delete(uri, predicates);;
963
964 int errCode = 0;
965 DatashareBusinessError businessError;
966 DataSharePredicates queryPredicates;
967 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, {RINGTONE_COLUMN_SOURCE_TYPE} };
968 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
969 errCode = businessError.GetCode();
970 cout << "Query errCode=" << errCode << endl;
971
972 if (resultSet != nullptr) {
973 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
974 EXPECT_NE(results, nullptr);
975 cout << "query count = " << to_string(results->GetCount()) << endl;
976 }
977 }
978
979 HWTEST_F(RingtoneUnitTest, medialib_querySystemRingtone_test_001, TestSize.Level0)
980 {
981 Uri uri(RINGTONE_PATH_URI);
982
983 int errCode = 0;
984 DatashareBusinessError businessError;
985 DataSharePredicates queryPredicates;
986 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(SourceType::SOURCE_TYPE_PRESET));
987 vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
988 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
989 errCode = businessError.GetCode();
990 cout << "Query errCode=" << errCode << endl;
991
992 if (resultSet != nullptr) {
993 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
994 EXPECT_NE(results, nullptr);
995 cout << "query count = " << to_string(results->GetCount()) << endl;
996 }
997 }
998
999 HWTEST_F(RingtoneUnitTest, medialib_queryCustomisedRingtone_test_001, TestSize.Level0)
1000 {
1001 Uri uri(RINGTONE_PATH_URI);
1002
1003 int errCode = 0;
1004 DatashareBusinessError businessError;
1005 DataSharePredicates queryPredicates;
1006 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(SourceType::SOURCE_TYPE_CUSTOMISED));
1007 vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
1008 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
1009 errCode = businessError.GetCode();
1010 cout << "Query errCode=" << errCode << endl;
1011
1012 if (resultSet != nullptr) {
1013 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1014 EXPECT_NE(results, nullptr);
1015 cout << "query count = " << to_string(results->GetCount()) << endl;
1016 }
1017 }
1018
1019 HWTEST_F(RingtoneUnitTest, medialib_queryAllRingtone_test_001, TestSize.Level0)
1020 {
1021 Uri uri(RINGTONE_PATH_URI);
1022
1023 int errCode = 0;
1024 DatashareBusinessError businessError;
1025 DataSharePredicates queryPredicates;
1026 vector<string> columns = { {RINGTONE_COLUMN_SOURCE_TYPE} };
1027 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
1028 errCode = businessError.GetCode();
1029 cout << "Query errCode=" << errCode << endl;
1030
1031 if (resultSet != nullptr) {
1032 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1033 EXPECT_NE(results, nullptr);
1034 cout << "query count = " << to_string(results->GetCount()) << endl;
1035 }
1036 }
1037
1038 HWTEST_F(RingtoneUnitTest, medialib_deleteRingtone_test_001, TestSize.Level0)
1039 {
1040 Uri uri(RINGTONE_PATH_URI);
1041 DataShareValuesBucket values;
1042 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
1043 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_OGG));
1044 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
1045 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_OGG);
1046 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
1047 values.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(SourceType::SOURCE_TYPE_CUSTOMISED));
1048 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
1049 auto result = g_dataShareHelper->Insert(uri, values);
1050 EXPECT_EQ((result > 0), true);
1051
1052 int errCode = 0;
1053 DatashareBusinessError businessError;
1054 DataSharePredicates queryPredicates;
1055 queryPredicates.EqualTo(RINGTONE_COLUMN_SOURCE_TYPE, to_string(SourceType::SOURCE_TYPE_CUSTOMISED));
1056 vector<string> columns = { { RINGTONE_COLUMN_SOURCE_TYPE } };
1057 auto resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
1058 errCode = businessError.GetCode();
1059 cout << "Query errCode=" << errCode << endl;
1060 if (resultSet != nullptr) {
1061 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1062 EXPECT_NE(results, nullptr);
1063 cout << "query count = " << to_string(results->GetCount()) << endl;
1064 }
1065
1066 DataSharePredicates predicates;
1067 predicates.SetWhereClause(RINGTONE_COLUMN_SOURCE_TYPE + " = ? ");
1068 predicates.SetWhereArgs({ to_string(SourceType::SOURCE_TYPE_CUSTOMISED) });
1069 result = g_dataShareHelper->Delete(uri, predicates);
1070 EXPECT_EQ((result > 0), true);
1071
1072 resultSet = g_dataShareHelper->Query(uri, queryPredicates, columns, &businessError);
1073 errCode = businessError.GetCode();
1074 cout << "Query errCode=" << errCode << endl;
1075 if (resultSet != nullptr) {
1076 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1077 EXPECT_NE(results, nullptr);
1078 cout << "query count = " << to_string(results->GetCount()) << endl;
1079 }
1080 }
1081
1082 HWTEST_F(RingtoneUnitTest, medialib_setVibrateSetting_test_001, TestSize.Level0)
1083 {
1084 Uri uri(SIMCARD_SETTING_PATH_URI);
1085
1086 int64_t start = UTCTimeSeconds();
1087 const int oldMode = 1;
1088 RingtoneTracer tracer;
1089 tracer.Start("DataShareInsert->SetVibrateSetting");
1090
1091 DataShareValuesBucket values;
1092
1093 values.Put(SIMCARD_SETTING_COLUMN_MODE, RING_TONE_TYPE_NOT);
1094 values.Put(SIMCARD_SETTING_COLUMN_TONE_FILE, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
1095 TEST_INSERT_RINGTONE_LIBRARY + MTP_FORMAT_OGG));
1096 values.Put(SIMCARD_SETTING_COLUMN_VIBRATE_FILE, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
1097 TEST_INSERT_RINGTONE_LIBRARY + MTP_FORMAT_JSON));
1098 values.Put(SIMCARD_SETTING_COLUMN_VIBRATE_MODE, oldMode);
1099 auto result = g_dataShareHelper->Insert(uri, values);
1100 GTEST_LOG_(INFO)<< "setVibrateSetting -> Insert result=" << result;
1101 EXPECT_EQ((result > 0), true);
1102
1103 tracer.Finish();
1104 int64_t end = UTCTimeSeconds();
1105 GTEST_LOG_(INFO) << "SetVibrateSetting Cost: " << (double) (end - start) << "ms";
1106 }
1107
1108 HWTEST_F(RingtoneUnitTest, medialib_updateVibrateSetting_test_001, TestSize.Level0)
1109 {
1110 Uri uri(SIMCARD_SETTING_PATH_URI);
1111
1112 int64_t start = UTCTimeSeconds();
1113 const int newMode = 2;
1114 RingtoneTracer tracer;
1115 tracer.Start("DataShareInsert->SetVibrateSetting");
1116
1117 DataSharePredicates predicates;
1118 vector<string> selectionArgs = {std::to_string(RING_TONE_TYPE_NOT)};
1119 const std::string selection = SIMCARD_SETTING_COLUMN_MODE + " = ? ";
1120 predicates.SetWhereClause(selection);
1121 predicates.SetWhereArgs(selectionArgs);
1122
1123 DataShareValuesBucket values;
1124 values.Put(SIMCARD_SETTING_COLUMN_MODE, RING_TONE_TYPE_NOT);
1125 values.Put(SIMCARD_SETTING_COLUMN_TONE_FILE, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
1126 TEST_INSERT_RINGTONE_LIBRARY + MTP_FORMAT_OGG));
1127 values.Put(SIMCARD_SETTING_COLUMN_VIBRATE_FILE, static_cast<string>(RINGTONE_LIBRARY_PATH + RINGTONE_SLASH_CHAR +
1128 TEST_INSERT_RINGTONE_LIBRARY + MTP_FORMAT_JSON));
1129 values.Put(SIMCARD_SETTING_COLUMN_VIBRATE_MODE, newMode);
1130 auto result = g_dataShareHelper->Update(uri, predicates, values);
1131 GTEST_LOG_(INFO)<< "updateVibrateSetting -> update result=" << result;
1132 EXPECT_EQ((result > 0), true);
1133
1134 tracer.Finish();
1135 int64_t end = UTCTimeSeconds();
1136 GTEST_LOG_(INFO) << "updateVibrateSetting Cost: " << (double) (end - start) << "ms";
1137 }
1138
1139 HWTEST_F(RingtoneUnitTest, medialib_GetVibrateSetting_test_001, TestSize.Level0)
1140 {
1141 Uri uri(SIMCARD_SETTING_PATH_URI);
1142
1143 int64_t start = UTCTimeSeconds();
1144 const int newMode = 2;
1145 RingtoneTracer tracer;
1146 tracer.Start("DataShareInsert->GetVibrateSetting");
1147
1148 DataSharePredicates predicates;
1149 vector<string> selectionArgs = {std::to_string(RING_TONE_TYPE_NOT)};
1150 const std::string selection = SIMCARD_SETTING_COLUMN_MODE + " = ? ";
1151 predicates.SetWhereClause(selection);
1152 predicates.SetWhereArgs(selectionArgs);
1153 vector<string> columns {
1154 SIMCARD_SETTING_COLUMN_MODE,
1155 SIMCARD_SETTING_COLUMN_TONE_FILE,
1156 SIMCARD_SETTING_COLUMN_VIBRATE_FILE,
1157 SIMCARD_SETTING_COLUMN_VIBRATE_MODE
1158 };
1159
1160 int errCode = 0;
1161 DatashareBusinessError businessError;
1162 auto resultSet = g_dataShareHelper->Query(uri, predicates, columns, &businessError);
1163 errCode = businessError.GetCode();
1164 GTEST_LOG_(INFO)<< "GetVibrateSetting -> Query errCode=" << errCode;
1165
1166 EXPECT_NE(resultSet, nullptr);
1167 if (resultSet != nullptr) {
1168 auto results = make_unique<RingtoneFetchResult<SimcardSettingAsset>>(move(resultSet));
1169 EXPECT_NE(results, nullptr);
1170 auto simcardSettingAsset = results->GetFirstObject();
1171 EXPECT_NE(simcardSettingAsset, nullptr);
1172 if (simcardSettingAsset != nullptr) {
1173 EXPECT_EQ(simcardSettingAsset->GetVibrateMode(), newMode);
1174 }
1175 }
1176
1177 tracer.Finish();
1178 int64_t end = UTCTimeSeconds();
1179 GTEST_LOG_(INFO) << "GetVibrateSetting Cost: " << (double) (end - start) << "ms";
1180 }
1181
1182 HWTEST_F(RingtoneUnitTest, medialib_deleteVibrateSetting_test_001, TestSize.Level0)
1183 {
1184 Uri uri(SIMCARD_SETTING_PATH_URI);
1185
1186 DataSharePredicates predicates;
1187 vector<string> selectionArgs = {std::to_string(RING_TONE_TYPE_NOT)};
1188 const std::string selection = SIMCARD_SETTING_COLUMN_MODE + " = ? ";
1189 predicates.SetWhereClause(selection);
1190 predicates.SetWhereArgs(selectionArgs);
1191 vector<string> columns {
1192 SIMCARD_SETTING_COLUMN_MODE,
1193 SIMCARD_SETTING_COLUMN_TONE_FILE,
1194 SIMCARD_SETTING_COLUMN_VIBRATE_FILE,
1195 SIMCARD_SETTING_COLUMN_VIBRATE_MODE
1196 };
1197
1198 auto ret = g_dataShareHelper->Delete(uri, predicates);
1199 GTEST_LOG_(INFO)<< "GetVibrateSetting -> Delete result=" << ret;
1200 EXPECT_EQ((ret > 0), true);
1201 }
1202
1203 HWTEST_F(RingtoneUnitTest, medialib_silentAccessQuery_test_001, TestSize.Level0)
1204 {
1205 Uri uri(RINGTONE_LIBRARY_PROXY_DATA_URI_SIMCARD_SETTING);
1206
1207 DataSharePredicates predicates;
1208 vector<string> selectionArgs = {std::to_string(RING_TONE_TYPE_SIM_CARD_1)};
1209 const std::string selection = SIMCARD_SETTING_COLUMN_MODE + " = ? ";
1210 predicates.SetWhereClause(selection);
1211 predicates.SetWhereArgs(selectionArgs);
1212
1213 vector<string> columns {
1214 SIMCARD_SETTING_COLUMN_MODE,
1215 SIMCARD_SETTING_COLUMN_TONE_FILE,
1216 SIMCARD_SETTING_COLUMN_VIBRATE_FILE,
1217 SIMCARD_SETTING_COLUMN_VIBRATE_MODE
1218 };
1219
1220 DatashareBusinessError businessError;
1221 ASSERT_TRUE(g_dataShareHelperProxy);
1222 auto resultSet = g_dataShareHelperProxy->Query(uri, predicates, columns, &businessError);
1223 auto errCode = businessError.GetCode();
1224 GTEST_LOG_(INFO)<< "g_dataShareHelperProxy->Query(uri errCode=" << errCode;
1225 }
1226
1227 HWTEST_F(RingtoneUnitTest, medialib_GetCustomRingtoneCurrentPath_test_001, TestSize.Level0)
1228 {
1229 string testUri = "/data/storage/el2/base/files/Ringtone/ringtones/onlineRingtone-1-testuri.ogg";
1230 string resultUri = RingtoneCheckUtils::GetCustomRingtoneCurrentPath(testUri);
1231 string expectedUri = RINGTONE_CUSTOMIZED_BASE_PATH + "/Ringtone/ringtones/onlineRingtone-1-testuri.ogg";
1232 EXPECT_EQ(resultUri, expectedUri);
1233 GTEST_LOG_(INFO)<< "medialib_GetCustomRingtoneCurrentPath_test_001: out: " << testUri;
1234 GTEST_LOG_(INFO)<< "medialib_GetCustomRingtoneCurrentPath_test_001: out: " << resultUri;
1235 }
1236
1237 HWTEST_F(RingtoneUnitTest, medialib_GetCustomRingtoneCurrentPath_test_002, TestSize.Level0)
1238 {
1239 string testUri = "/storage/media/local/files/Ringtone/ringtones/onlineRingtone-1-testuri.ogg";
1240 string resultUri = RingtoneCheckUtils::GetCustomRingtoneCurrentPath(testUri);
1241 string expectedUri = RINGTONE_CUSTOMIZED_BASE_PATH + "/Ringtone/ringtones/onlineRingtone-1-testuri.ogg";
1242 EXPECT_EQ(resultUri, expectedUri);
1243 GTEST_LOG_(INFO)<< "medialib_GetCustomRingtoneCurrentPath_test_002: out: " << testUri;
1244 GTEST_LOG_(INFO)<< "medialib_GetCustomRingtoneCurrentPath_test_002: out: " << resultUri;
1245 }
1246
1247 HWTEST_F(RingtoneUnitTest, medialib_GetCustomRingtoneCurrentPath_test_003, TestSize.Level0)
1248 {
1249 string testUri = "testuri";
1250 string resultUri = RingtoneCheckUtils::GetCustomRingtoneCurrentPath(testUri);
1251 EXPECT_EQ(resultUri, "testuri");
1252 GTEST_LOG_(INFO)<< "medialib_GetCustomRingtoneCurrentPath_test_003: out: " << testUri;
1253 GTEST_LOG_(INFO)<< "medialib_GetCustomRingtoneCurrentPath_test_003: out: " << resultUri;
1254 }
1255 } // namespace Media
1256 } // namespace OHOS
1257