1 /*
2 * Copyright (c) 2021 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 "mediadataability_unit_test.h"
17 #include "media_log.h"
18
19 using namespace std;
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace Media {
24 MediaLibraryDataAbility g_rdbStoreTest;
25 string g_createUri1, g_createUri2;
26
27 int g_fd1 = DATA_ABILITY_FAIL;
28 int g_fd2 = DATA_ABILITY_FAIL;
29 int g_albumId1 = DATA_ABILITY_FAIL;
30 int g_albumId2 = DATA_ABILITY_FAIL;
31 shared_ptr<NativeRdb::AbsSharedResultSet> g_resultSet1 = nullptr;
32 shared_ptr<NativeRdb::AbsSharedResultSet> g_resultSet2 = nullptr;
33 shared_ptr<NativeRdb::AbsSharedResultSet> g_resultSet3 = nullptr;
34
SetUpTestCase(void)35 void MediaDataAbilityUnitTest::SetUpTestCase(void)
36 {
37 g_rdbStoreTest.InitMediaLibraryRdbStore();
38 }
39
TearDownTestCase(void)40 void MediaDataAbilityUnitTest::TearDownTestCase(void) {}
SetUp(void)41 void MediaDataAbilityUnitTest::SetUp(void) {}
TearDown(void)42 void MediaDataAbilityUnitTest::TearDown(void) {}
43
44 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_DeleteAllFiles_Test_001, TestSize.Level0)
45 {
46 MEDIA_INFO_LOG("MediaDataAbility_DeleteAllFiles_Test_001::Start");
47
48 unique_ptr<FetchResult> fetchFileResult = nullptr;
49 vector<string> columns;
50 DataAbilityPredicates predicates;
51 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> 8 ";
52 predicates.SetWhereClause(prefix);
53
54 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
55 shared_ptr<AbsSharedResultSet> resultSet = nullptr;
56 resultSet = g_rdbStoreTest.Query(queryFileUri, columns, predicates);
57 EXPECT_NE((resultSet == nullptr), true);
58 // Create FetchResult object using the contents of resultSet
59 fetchFileResult = make_unique<FetchResult>(move(resultSet));
60 EXPECT_NE((fetchFileResult == nullptr), true);
61 EXPECT_NE((fetchFileResult->GetCount() <= 0), true);
62 unique_ptr<FileAsset> fileAsset = fetchFileResult->GetFirstObject();
63 while (fileAsset != nullptr) {
64 Uri deleteAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN + "/" + MEDIA_FILEOPRN_DELETEASSET);
65 NativeRdb::ValuesBucket valuesBucketDelete;
66 MEDIA_INFO_LOG("MediaDataAbility_DeleteAllFiles_Test_001::uri :%{public}s", fileAsset->GetUri().c_str());
67 MEDIA_INFO_LOG("MediaDataAbility_DeleteAllFiles_Test_001::path :%{public}s", fileAsset->GetPath().c_str());
68 valuesBucketDelete.PutString(MEDIA_DATA_DB_URI, fileAsset->GetUri());
69 int retVal = g_rdbStoreTest.Insert(deleteAssetUri, valuesBucketDelete);
70 EXPECT_NE((retVal < 0), true);
71
72 fileAsset = fetchFileResult->GetNextObject();
73 }
74
75 MEDIA_INFO_LOG("MediaDataAbility_DeleteAllFiles_Test_001::End");
76 }
77
78 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_CreateAsset_Test_001, TestSize.Level0)
79 {
80 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_001::Start");
81 int index = DATA_ABILITY_FAIL;
82 string abilityUri = Media::MEDIALIBRARY_DATA_URI;
83 Uri createAssetUri(abilityUri + "/" + Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET);
84 NativeRdb::ValuesBucket valuesBucket;
85 string relativePath = "Pictures/";
86 string displayName = "gtest_new_file001.jpg";
87 MediaType mediaType = MEDIA_TYPE_IMAGE;
88 valuesBucket.PutInt(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
89 valuesBucket.PutString(MEDIA_DATA_DB_NAME, displayName);
90 valuesBucket.PutString(MEDIA_DATA_DB_RELATIVE_PATH, relativePath);
91 index = g_rdbStoreTest.Insert(createAssetUri, valuesBucket);
92 g_createUri1 = MEDIALIBRARY_IMAGE_URI + "/" + to_string(index);
93 EXPECT_NE((index <= 0), true);
94 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_001::End");
95 }
96
97 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_CreateAsset_Test_002, TestSize.Level0)
98 {
99 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_002::Start");
100 int index = DATA_ABILITY_FAIL;
101 string abilityUri = Media::MEDIALIBRARY_DATA_URI;
102 Uri createAssetUri(abilityUri + "/" + Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET);
103 NativeRdb::ValuesBucket valuesBucket;
104 string relativePath = "Pictures/";
105 string displayName = "gtest_new_file_0102.jpg";
106 MediaType mediaType = MEDIA_TYPE_IMAGE;
107 valuesBucket.PutInt(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
108 valuesBucket.PutString(MEDIA_DATA_DB_NAME, displayName);
109 valuesBucket.PutString(MEDIA_DATA_DB_RELATIVE_PATH, relativePath);
110 index = g_rdbStoreTest.Insert(createAssetUri, valuesBucket);
111 g_createUri1 = MEDIALIBRARY_IMAGE_URI + "/" + to_string(index);
112 EXPECT_NE((index <= 0), true);
113 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_002::End");
114 }
115
116 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_CreateAsset_Test_003, TestSize.Level0)
117 {
118 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_003::Start");
119 int index = DATA_ABILITY_FAIL;
120 string abilityUri = Media::MEDIALIBRARY_DATA_URI;
121 Uri createAssetUri(abilityUri + "/" + Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET);
122 NativeRdb::ValuesBucket valuesBucket;
123 string relativePath = "Pictures/createAsset/";
124 string displayName = "gtest_new_file0103.jpg";
125 MediaType mediaType = MEDIA_TYPE_IMAGE;
126 valuesBucket.PutInt(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
127 valuesBucket.PutString(MEDIA_DATA_DB_NAME, displayName);
128 valuesBucket.PutString(MEDIA_DATA_DB_RELATIVE_PATH, relativePath);
129 index = g_rdbStoreTest.Insert(createAssetUri, valuesBucket);
130 g_createUri1 = MEDIALIBRARY_IMAGE_URI + "/" + to_string(index);
131 EXPECT_NE((index <= 0), true);
132 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_003::End");
133 }
134
135 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_CreateAsset_Test_004, TestSize.Level0)
136 {
137 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_004::Start");
138 int index = DATA_ABILITY_FAIL;
139 string abilityUri = Media::MEDIALIBRARY_DATA_URI;
140 Uri createAssetUri(abilityUri + "/" + Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET);
141 NativeRdb::ValuesBucket valuesBucket;
142 string relativePath = "Pictures/createAsset/";
143 string displayName = ".gtest_new_file0103.jpg";
144 MediaType mediaType = MEDIA_TYPE_IMAGE;
145 valuesBucket.PutInt(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
146 valuesBucket.PutString(MEDIA_DATA_DB_NAME, displayName);
147 valuesBucket.PutString(MEDIA_DATA_DB_RELATIVE_PATH, relativePath);
148 index = g_rdbStoreTest.Insert(createAssetUri, valuesBucket);
149 EXPECT_NE((index <= 0), false);
150 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_004::End");
151 }
152
153 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_CreateAsset_Test_005, TestSize.Level0)
154 {
155 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_005::Start");
156 int index = DATA_ABILITY_FAIL;
157 string abilityUri = Media::MEDIALIBRARY_DATA_URI;
158 Uri createAssetUri(abilityUri + "/" + Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET);
159 NativeRdb::ValuesBucket valuesBucket;
160 string relativePath = "Pictures/createAsset/";
161 MediaType mediaType = MEDIA_TYPE_IMAGE;
162 valuesBucket.PutInt(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
163 valuesBucket.PutString(MEDIA_DATA_DB_RELATIVE_PATH, relativePath);
164 index = g_rdbStoreTest.Insert(createAssetUri, valuesBucket);
165 EXPECT_NE((index <= 0), false);
166 MEDIA_INFO_LOG("MediaDataAbility_CreateAsset_Test_005::End");
167 }
168
169 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_DeleteAsset_Test_001, TestSize.Level0)
170 {
171 MEDIA_INFO_LOG("MediaDataAbility_DeleteAsset_Test_001::Start");
172 int index = DATA_ABILITY_FAIL;
173 Uri createAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN + "/" + MEDIA_FILEOPRN_CREATEASSET);
174 NativeRdb::ValuesBucket valuesBucket;
175 string relativePath = "Pictures/";
176 string displayName = "gtest_delete_file001.jpg";
177 MediaType mediaType = MEDIA_TYPE_IMAGE;
178 valuesBucket.PutInt(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
179 valuesBucket.PutString(MEDIA_DATA_DB_NAME, displayName);
180 valuesBucket.PutString(MEDIA_DATA_DB_RELATIVE_PATH, relativePath);
181 index = g_rdbStoreTest.Insert(createAssetUri, valuesBucket);
182 g_createUri1 = MEDIALIBRARY_IMAGE_URI + "/" + to_string(index);
183 EXPECT_NE((index <= 0), true);
184
185 Uri deleteAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN + "/" + MEDIA_FILEOPRN_DELETEASSET);
186 NativeRdb::ValuesBucket valuesBucketDelete;
187 valuesBucketDelete.PutString(MEDIA_DATA_DB_URI, g_createUri1);
188 int retVal = g_rdbStoreTest.Insert(deleteAssetUri, valuesBucketDelete);
189 EXPECT_NE((retVal < 0), true);
190 MEDIA_INFO_LOG("MediaDataAbility_DeleteAsset_Test_001::End");
191 }
192
193 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_QueryFiles_Test_001, TestSize.Level0)
194 {
195 MEDIA_INFO_LOG("MediaDataAbility_QueryFiles_Test_001::Start");
196 vector<string> columns;
197 DataAbilityPredicates predicates;
198 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> 8 ";
199 predicates.SetWhereClause(prefix);
200
201 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
202 shared_ptr<AbsSharedResultSet> resultSet = nullptr;
203 resultSet = g_rdbStoreTest.Query(queryFileUri, columns, predicates);
204 EXPECT_NE((resultSet == nullptr), true);
205 MEDIA_INFO_LOG("MediaDataAbility_QueryFiles_Test_001::End");
206 }
207
208 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_QueryFiles_Test_002, TestSize.Level0)
209 {
210 MEDIA_INFO_LOG("MediaDataAbility_QueryFiles_Test_002::Start");
211 unique_ptr<FetchResult> fetchFileResult = nullptr;
212 vector<string> columns;
213 DataAbilityPredicates predicates;
214 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> 8 ";
215 predicates.SetWhereClause(prefix);
216
217 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
218 shared_ptr<AbsSharedResultSet> resultSet = nullptr;
219 resultSet = g_rdbStoreTest.Query(queryFileUri, columns, predicates);
220 EXPECT_NE((resultSet == nullptr), true);
221 MEDIA_INFO_LOG("MediaDataAbility_QueryFiles_Test_002::resultSet != nullptr");
222
223 // Create FetchResult object using the contents of resultSet
224 fetchFileResult = make_unique<FetchResult>(move(resultSet));
225 EXPECT_NE((fetchFileResult == nullptr), true);
226 MEDIA_INFO_LOG("MediaDataAbility_QueryFiles_Test_002::fetchFileResult != nullptr");
227 EXPECT_NE((fetchFileResult->GetCount() <= 0), true);
228 MEDIA_INFO_LOG("MediaDataAbility_QueryFiles_Test_002::GetCount > 0");
229
230 unique_ptr<FileAsset> fileAsset = nullptr;
231 fileAsset = fetchFileResult->GetFirstObject();
232 EXPECT_NE((fileAsset == nullptr), true);
233 MEDIA_INFO_LOG("MediaDataAbility_QueryFiles_Test_002::fileAsset != nullptr");
234 MEDIA_INFO_LOG("MediaDataAbility_QueryFiles_Test_002::End");
235 }
236
237 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_UpdateAsset_Test_001, TestSize.Level0)
238 {
239 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_001::Start");
240 unique_ptr<FetchResult> fetchFileResult = nullptr;
241 vector<string> columns;
242 DataAbilityPredicates predicates;
243 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> 8 ";
244 predicates.SetWhereClause(prefix);
245
246 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
247 shared_ptr<AbsSharedResultSet> resultSet = nullptr;
248 resultSet = g_rdbStoreTest.Query(queryFileUri, columns, predicates);
249 EXPECT_NE((resultSet == nullptr), true);
250
251 // Create FetchResult object using the contents of resultSet
252 fetchFileResult = make_unique<FetchResult>(move(resultSet));
253 EXPECT_NE((fetchFileResult == nullptr), true);
254 EXPECT_NE((fetchFileResult->GetCount() <= 0), true);
255
256 unique_ptr<FileAsset> fileAsset = nullptr;
257 fileAsset = fetchFileResult->GetFirstObject();
258 EXPECT_NE((fileAsset == nullptr), true);
259
260 NativeRdb::ValuesBucket valuesBucketUpdate;
261 valuesBucketUpdate.PutString(MEDIA_DATA_DB_TITLE, "UpdateAsset_Test_001");
262 valuesBucketUpdate.PutString(MEDIA_DATA_DB_URI, fileAsset->GetUri());
263 valuesBucketUpdate.PutString(MEDIA_DATA_DB_NAME, fileAsset->GetDisplayName());
264 valuesBucketUpdate.PutString(MEDIA_DATA_DB_RELATIVE_PATH, fileAsset->GetRelativePath());
265
266 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_001::GetId = %{public}d", fileAsset->GetId());
267 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_001::GetUri = %{public}s", fileAsset->GetUri().c_str());
268 Uri updateAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN + "/" + MEDIA_FILEOPRN_MODIFYASSET);
269 int changedRows = g_rdbStoreTest.Update(updateAssetUri, valuesBucketUpdate, predicates);
270 EXPECT_NE(changedRows < 0, true);
271 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_001::changedRows = %{public}d", changedRows);
272 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_001::End");
273 }
274
275 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_UpdateAsset_Test_002, TestSize.Level0)
276 {
277 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_002::Start");
278 unique_ptr<FetchResult> fetchFileResult = nullptr;
279 vector<string> columns;
280 DataAbilityPredicates predicates;
281 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> 8 ";
282 predicates.SetWhereClause(prefix);
283
284 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
285 shared_ptr<AbsSharedResultSet> resultSet = nullptr;
286 resultSet = g_rdbStoreTest.Query(queryFileUri, columns, predicates);
287 EXPECT_NE((resultSet == nullptr), true);
288
289 // Create FetchResult object using the contents of resultSet
290 fetchFileResult = make_unique<FetchResult>(move(resultSet));
291 EXPECT_NE((fetchFileResult == nullptr), true);
292 EXPECT_NE((fetchFileResult->GetCount() <= 0), true);
293
294 unique_ptr<FileAsset> fileAsset = nullptr;
295 fileAsset = fetchFileResult->GetFirstObject();
296 EXPECT_NE((fileAsset == nullptr), true);
297
298 NativeRdb::ValuesBucket valuesBucketUpdate;
299 valuesBucketUpdate.PutString(MEDIA_DATA_DB_URI, fileAsset->GetUri());
300 valuesBucketUpdate.PutString(MEDIA_DATA_DB_NAME, fileAsset->GetDisplayName());
301 valuesBucketUpdate.PutString(MEDIA_DATA_DB_RELATIVE_PATH, fileAsset->GetRelativePath());
302 valuesBucketUpdate.PutInt(MEDIA_DATA_DB_ORIENTATION, 1);
303
304 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_002::GetUri = %{public}s", fileAsset->GetUri().c_str());
305 Uri updateAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN + "/" + MEDIA_FILEOPRN_MODIFYASSET);
306 int changedRows = g_rdbStoreTest.Update(updateAssetUri, valuesBucketUpdate, predicates);
307 EXPECT_NE(changedRows < 0, true);
308 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_002::changedRows = %{public}d", changedRows);
309 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_002::End");
310 }
311
312 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_UpdateAsset_Test_003, TestSize.Level0)
313 {
314 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_003::Start");
315 unique_ptr<FetchResult> fetchFileResult = nullptr;
316 vector<string> columns;
317 DataAbilityPredicates predicates;
318 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> 8 ";
319 predicates.SetWhereClause(prefix);
320
321 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
322 shared_ptr<AbsSharedResultSet> resultSet = nullptr;
323 resultSet = g_rdbStoreTest.Query(queryFileUri, columns, predicates);
324 EXPECT_NE((resultSet == nullptr), true);
325
326 // Create FetchResult object using the contents of resultSet
327 fetchFileResult = make_unique<FetchResult>(move(resultSet));
328 EXPECT_NE((fetchFileResult == nullptr), true);
329 EXPECT_NE((fetchFileResult->GetCount() <= 0), true);
330
331 unique_ptr<FileAsset> fileAsset = nullptr;
332 fileAsset = fetchFileResult->GetFirstObject();
333 EXPECT_NE((fileAsset == nullptr), true);
334
335 NativeRdb::ValuesBucket valuesBucketUpdate;
336 valuesBucketUpdate.PutString(MEDIA_DATA_DB_URI, fileAsset->GetUri());
337 valuesBucketUpdate.PutString(MEDIA_DATA_DB_RELATIVE_PATH, fileAsset->GetRelativePath());
338 valuesBucketUpdate.PutString(MEDIA_DATA_DB_NAME, "U" + fileAsset->GetDisplayName());
339
340 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_003::GetUri = %{public}s", fileAsset->GetUri().c_str());
341 Uri updateAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN + "/" + MEDIA_FILEOPRN_MODIFYASSET);
342 int changedRows = g_rdbStoreTest.Update(updateAssetUri, valuesBucketUpdate, predicates);
343 EXPECT_NE(changedRows < 0, true);
344 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_003::changedRows = %{public}d", changedRows);
345 MEDIA_INFO_LOG("MediaDataAbility_UpdateAsset_Test_003::End");
346 }
347
348 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_OpenFile_Test_001, TestSize.Level0)
349 {
350 MEDIA_INFO_LOG("MediaDataAbility_OpenFile_Test_001::Start");
351 unique_ptr<FetchResult> fetchFileResult = nullptr;
352 vector<string> columns;
353 DataAbilityPredicates predicates;
354 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> 8 ";
355 predicates.SetWhereClause(prefix);
356
357 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
358 shared_ptr<AbsSharedResultSet> resultSet = nullptr;
359 resultSet = g_rdbStoreTest.Query(queryFileUri, columns, predicates);
360 EXPECT_NE((resultSet == nullptr), true);
361
362 // Create FetchResult object using the contents of resultSet
363 fetchFileResult = make_unique<FetchResult>(move(resultSet));
364 EXPECT_NE((fetchFileResult == nullptr), true);
365 EXPECT_NE((fetchFileResult->GetCount() <= 0), true);
366
367 unique_ptr<FileAsset> fileAsset = nullptr;
368 fileAsset = fetchFileResult->GetFirstObject();
369 EXPECT_NE((fileAsset == nullptr), true);
370
371 string fileUri = fileAsset->GetUri();
372 string mode = MEDIA_FILEMODE_READONLY;
373
374 Uri openFileUri(fileUri);
375 MEDIA_INFO_LOG("openFileUri = %{public}s", openFileUri.ToString().c_str());
376 int32_t fd = g_rdbStoreTest.OpenFile(openFileUri, mode);
377
378 EXPECT_NE(fd <= 0, true);
379 MEDIA_INFO_LOG("MediaDataAbility_OpenFile_Test_001::fd = %{public}d", fd);
380 MEDIA_INFO_LOG("MediaDataAbility_OpenFile_Test_001::End");
381 }
382
383 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_CloseFile_Test_001, TestSize.Level0)
384 {
385 MEDIA_INFO_LOG("MediaDataAbility_CloseFile_Test_001::Start");
386 unique_ptr<FetchResult> fetchFileResult = nullptr;
387 vector<string> columns;
388 DataAbilityPredicates predicates;
389 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> 8 ";
390 predicates.SetWhereClause(prefix);
391
392 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
393 shared_ptr<AbsSharedResultSet> resultSet = nullptr;
394 resultSet = g_rdbStoreTest.Query(queryFileUri, columns, predicates);
395 EXPECT_NE((resultSet == nullptr), true);
396
397 // Create FetchResult object using the contents of resultSet
398 fetchFileResult = make_unique<FetchResult>(move(resultSet));
399 EXPECT_NE((fetchFileResult == nullptr), true);
400 EXPECT_NE((fetchFileResult->GetCount() <= 0), true);
401
402 unique_ptr<FileAsset> fileAsset = nullptr;
403 fileAsset = fetchFileResult->GetFirstObject();
404 EXPECT_NE((fileAsset == nullptr), true);
405
406 string fileUri = fileAsset->GetUri();
407 string mode = MEDIA_FILEMODE_READWRITE;
408
409 Uri openFileUri(fileUri);
410 MEDIA_INFO_LOG("openFileUri = %{public}s", openFileUri.ToString().c_str());
411 int32_t fd = g_rdbStoreTest.OpenFile(openFileUri, mode);
412
413 EXPECT_NE(fd <= 0, true);
414 MEDIA_INFO_LOG("MediaDataAbility_CloseFile_Test_001::fd = %{public}d", fd);
415
416 Uri closeAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN + "/" + MEDIA_FILEOPRN_CLOSEASSET);
417
418 int32_t retVal = close(fd);
419 EXPECT_NE(retVal != DATA_ABILITY_SUCCESS, true);
420
421 NativeRdb::ValuesBucket valuesBucketClose;
422 valuesBucketClose.PutString(MEDIA_DATA_DB_URI, fileUri);
423 int32_t retValClose = g_rdbStoreTest.Insert(closeAssetUri, valuesBucketClose);
424 EXPECT_NE(retValClose != DATA_ABILITY_SUCCESS, true);
425
426 MEDIA_INFO_LOG("MediaDataAbility_CloseFile_Test_001::End");
427 }
428
429 HWTEST_F(MediaDataAbilityUnitTest, MediaDataAbility_GetAlbum_Test_001, TestSize.Level0)
430 {
431 string abilityUri = Media::MEDIALIBRARY_DATA_URI + "/" + Media::MEDIA_ALBUMOPRN_QUERYALBUM;
432 Uri createAssetUri(abilityUri);
433 string queryAssetUri = Media::MEDIALIBRARY_DATA_URI;
434 Uri createAssetUri1(queryAssetUri);
435 NativeRdb::ValuesBucket valuesBucket;
436 NativeRdb::DataAbilityPredicates predicates1;
437 std::vector<std::string> columns;
438 g_rdbStoreTest.Query(createAssetUri, columns, predicates1);
439
440 NativeRdb::DataAbilityPredicates queryPredicates;
441 queryPredicates.EqualTo(MEDIA_DATA_DB_BUCKET_ID, std::to_string(1));
442 std::vector<std::string> queryColumns;
443 g_rdbStoreTest.Query(createAssetUri1, queryColumns, queryPredicates);
444
445 NativeRdb::DataAbilityPredicates predicates2;
446 NativeRdb::ValuesBucket valuesBucket1;
447 valuesBucket1.PutString(MEDIA_DATA_DB_TITLE, "newTest");
448 predicates2.EqualTo(MEDIA_DATA_DB_ID, std::to_string(1));
449 Uri uri(MEDIALIBRARY_DATA_URI);
450 g_rdbStoreTest.Update(uri, valuesBucket1, predicates2);
451
452 NativeRdb::DataAbilityPredicates filePredicates;
453 NativeRdb::ValuesBucket fileValuesBucket;
454 fileValuesBucket.PutString(MEDIA_DATA_DB_BUCKET_NAME, "newTest");
455 filePredicates.EqualTo(MEDIA_DATA_DB_BUCKET_ID, std::to_string(1));
456 g_rdbStoreTest.Update(uri, fileValuesBucket, filePredicates);
457 }
458 } // namespace Media
459 } // namespace OHOS
460