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_fetch_result_test.h"
17
18 #include "ability_context_impl.h"
19 #include "datashare_helper.h"
20 #include "iservice_registry.h"
21 #include "ringtone_asset.h"
22 #include "ringtone_data_manager.h"
23 #include "ringtone_errno.h"
24 #define private public
25 #include "ringtone_fetch_result.h"
26 #undef private
27 #include "ringtone_type.h"
28 #include "ringtone_log.h"
29 #include "ringtone_rdbstore.h"
30 #include "ringtone_scanner_db.h"
31
32
33 using namespace std;
34 using namespace OHOS;
35 using namespace testing::ext;
36
37 namespace OHOS {
38 namespace Media {
39 const string RINGTONE_LIBRARY_PATH = "/storage/cloud/files/Ringtone";
40 const string MTP_FORMAT_MP3 = ".mp3"; // MP3 audio files
41 const string TEST_INSERT_RINGTONE_LIBRARY = "test_insert_ringtone_library";
42 const int TEST_RINGTONE_COLUMN_SIZE = 1022;
43 const int TEST_RINGTONE_COLUMN_TONE_TYPE = 2;
44 const string SLASH_STR = "/";
45 const string MP3 = "mp3";
46 const string RAINNING = "rainning";
47 const int NUMBER_OF_TIMES = 10;
48 shared_ptr<RingtoneFetchResult<RingtoneAsset>> g_fetchResult;
49 shared_ptr<RingtoneUnistore> g_uniStore = nullptr;
SetUpTestCase()50 void RingtoneFetchResultTest::SetUpTestCase()
51 {
52 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
53 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
54 abilityContextImpl->SetStageContext(stageContext);
55 auto ret = RingtoneDataManager::GetInstance()->Init(abilityContextImpl);
56 CHECK_AND_RETURN_LOG(ret == E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
57 std::shared_ptr<DataShare::DataShareResultSet> dataShare = make_shared<DataShare::DataShareResultSet>();
58 g_fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>(dataShare);
59 EXPECT_NE(g_fetchResult, nullptr);
60
61 g_uniStore = RingtoneRdbStore::GetInstance(abilityContextImpl);
62 EXPECT_NE(g_uniStore, nullptr);
63 ret = g_uniStore->Init();
64 EXPECT_EQ(ret, E_OK);
65 system("rm -rf /storage/cloud/files/");
66 system("mkdir /storage/cloud/files");
67 system("mkdir /storage/cloud/files/Ringtone");
68 }
69
TearDownTestCase()70 void RingtoneFetchResultTest::TearDownTestCase()
71 {
72 system("rm -rf /storage/cloud/files/");
73 auto dataManager = RingtoneDataManager::GetInstance();
74 EXPECT_NE(dataManager, nullptr);
75 dataManager->ClearRingtoneDataMgr();
76 }
77
78 // SetUp:Execute before each test case
SetUp()79 void RingtoneFetchResultTest::SetUp() {}
80
TearDown(void)81 void RingtoneFetchResultTest::TearDown(void) {}
82
83 HWTEST_F(RingtoneFetchResultTest, fetchResult_IsAtLastRow_test_001, TestSize.Level0)
84 {
85 auto ringtoneAsset = g_fetchResult->GetFirstObject();
86 EXPECT_EQ(ringtoneAsset, nullptr);
87 bool ret = g_fetchResult->IsAtLastRow();
88 EXPECT_EQ(ret, false);
89 shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>();
90 ret = fetchResult->IsAtLastRow();
91 EXPECT_EQ(ret, false);
92 }
93
94 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetRowValFromColumn_test_001, TestSize.Level0)
95 {
96 auto ringtoneAsset = g_fetchResult->GetNextObject();
97 EXPECT_EQ(ringtoneAsset, nullptr);
98 string columnName;
99 RingtoneResultSetDataType dataType = RingtoneResultSetDataType::DATA_TYPE_STRING;
100 shared_ptr<NativeRdb::ResultSet> resultSet = nullptr;
101 auto ret = g_fetchResult->GetRowValFromColumn(columnName, dataType, resultSet);
102 variant<int32_t, int64_t, string, double> cellValue = "";
103 EXPECT_EQ(ret, cellValue);
104 shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>();
105 dataType = RingtoneResultSetDataType::DATA_TYPE_INT64;
106 ret = fetchResult->GetRowValFromColumn(columnName, dataType, resultSet);
107 variant<int32_t, int64_t, string, double> longVal = static_cast<int64_t>(0);
108 EXPECT_EQ(ret, longVal);
109 dataType = RingtoneResultSetDataType::DATA_TYPE_DOUBLE;
110 ret = fetchResult->GetRowValFromColumn(columnName, dataType, resultSet);
111 variant<int32_t, int64_t, string, double> doubleVal = 0;
112 EXPECT_EQ(ret, doubleVal);
113 fetchResult->Close();
114 }
115
116 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetValByIndex_test_001, TestSize.Level0)
117 {
118 auto ringtoneAsset = g_fetchResult->GetLastObject();
119 EXPECT_EQ(ringtoneAsset, nullptr);
120 int32_t index = 0;
121 RingtoneResultSetDataType dataType = RingtoneResultSetDataType::DATA_TYPE_STRING;
122 shared_ptr<NativeRdb::ResultSet> resultSet;
123 auto ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
124 variant<int32_t, int64_t, string, double> stringVal = "";
125 EXPECT_EQ(ret, stringVal);
126 dataType = RingtoneResultSetDataType::DATA_TYPE_INT32;
127 ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
128 variant<int32_t, int64_t, string, double> integerVal = 0;
129 EXPECT_EQ(ret, integerVal);
130 dataType = RingtoneResultSetDataType::DATA_TYPE_INT64;
131 ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
132 variant<int32_t, int64_t, string, double> longVal = static_cast<int64_t>(0);
133 EXPECT_EQ(ret, longVal);
134 dataType = RingtoneResultSetDataType::DATA_TYPE_DOUBLE;
135 ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
136 variant<int32_t, int64_t, string, double> doubleVal = 0.0;
137 EXPECT_EQ(ret, doubleVal);
138 dataType = RingtoneResultSetDataType::DATA_TYPE_NULL;
139 ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
140 variant<int32_t, int64_t, string, double> cellValue ;
141 EXPECT_EQ(ret, cellValue);
142 shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>();
143 shared_ptr<NativeRdb::ResultSet> nativeRdbResultSet = nullptr;
144 fetchResult->GetValByIndex(index, dataType, nativeRdbResultSet);
145 EXPECT_EQ(ret, cellValue);
146 }
147
148 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetObjectFromRdb_test_001, TestSize.Level0)
149 {
150 int32_t index = 0;
151 shared_ptr<NativeRdb::ResultSet> resultSet;
152 auto ringtoneAsset = g_fetchResult->GetObjectFromRdb(resultSet, index);
153 EXPECT_EQ(ringtoneAsset, nullptr);
154 auto ringtoneObject = g_fetchResult->GetObject();
155 EXPECT_NE(ringtoneObject, nullptr);
156 shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>();
157 unique_ptr<RingtoneAsset> asset = nullptr;
158 shared_ptr<NativeRdb::ResultSet> nativeRdbResultSet = nullptr;
159 fetchResult->SetRingtoneAsset(asset, nativeRdbResultSet);
160 ringtoneAsset = fetchResult->GetObjectFromRdb(resultSet, index);
161 EXPECT_EQ(ringtoneAsset, nullptr);
162 }
163
164 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetObjectAtPosition_test_001, TestSize.Level0)
165 {
166 int32_t index = 0;
167 auto ringtoneObject = g_fetchResult->GetObjectAtPosition(index);
168 EXPECT_EQ(ringtoneObject, nullptr);
169 auto resultSet = g_fetchResult->GetDataShareResultSet();
170 EXPECT_NE(resultSet, nullptr);
171 }
172
173 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetRowValFromColumn_test_002, TestSize.Level0)
174 {
175 Uri uri(RINGTONE_PATH_URI);
176 DataShare::DataShareValuesBucket valuesBucket;
177 valuesBucket.Put(RINGTONE_COLUMN_DATA,
178 static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
179 TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
180 valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
181 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
182 valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3); // todo construct by us
183 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
184 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
185 auto dataManager = RingtoneDataManager::GetInstance();
186 EXPECT_NE(dataManager, nullptr);
187 auto retVal = dataManager->Insert(cmd, valuesBucket);
188 EXPECT_EQ((retVal > 0), true);
189
190 int errCode = 0;
191 RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
192 DataShare::DataSharePredicates queryPredicates;
193 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
194 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, { RINGTONE_COLUMN_SIZE } };
195 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
196 EXPECT_NE((queryResultSet == nullptr), true);
197 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
198 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
199 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
200 cout << "query count = " << to_string(results->GetCount()) << endl;
201 RingtoneResultSetDataType dataType = RingtoneResultSetDataType::DATA_TYPE_DOUBLE;
202 shared_ptr<NativeRdb::ResultSet> nativeRdbResultSet;
203 results->GetRowValFromColumn(RINGTONE_COLUMN_DATA, dataType, nativeRdbResultSet);
204 int32_t index = 0;
205 auto ringtoneObject = results->GetObjectAtPosition(index);
206 EXPECT_NE(ringtoneObject, nullptr);
207 results->Close();
208
209 DataShare::DataSharePredicates predicates;
210 RingtoneDataCommand cmdDelete(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
211 EXPECT_NE(dataManager, nullptr);
212 retVal = dataManager->Delete(cmdDelete, predicates);
213 EXPECT_EQ((retVal > 0), true);
214 }
215
216 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetNextObject_test_001, TestSize.Level0)
217 {
218 Uri uri(RINGTONE_PATH_URI);
219 DataShare::DataShareValuesBucket valuesBucket;
220 valuesBucket.Put(RINGTONE_COLUMN_DATA,
221 static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
222 TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_MP3));
223 valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
224 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
225 valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3); // todo construct by us
226 valuesBucket.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
227 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
228 auto dataManager = RingtoneDataManager::GetInstance();
229 EXPECT_NE(dataManager, nullptr);
230 auto retVal = dataManager->Insert(cmd, valuesBucket);
231 EXPECT_EQ((retVal > 0), true);
232 DataShare::DataShareValuesBucket valuesBucketInsert;
233 valuesBucketInsert.Put(RINGTONE_COLUMN_DATA,
234 static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
235 TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
236 valuesBucketInsert.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
237 retVal = dataManager->Insert(cmd, valuesBucketInsert);
238 EXPECT_EQ((retVal > 0), true);
239
240 int errCode = 0;
241 RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
242 DataShare::DataSharePredicates queryPredicates;
243 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
244 vector<string> columns = { { RINGTONE_COLUMN_DATA } };
245 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
246 EXPECT_NE((queryResultSet == nullptr), true);
247 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
248 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
249 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
250 cout << "query count = " << to_string(results->GetCount()) << endl;
251 auto ringtoneObject = results->GetNextObject();
252 EXPECT_NE(ringtoneObject, nullptr);
253 ringtoneObject = results->GetFirstObject();
254 EXPECT_NE(ringtoneObject, nullptr);
255 ringtoneObject = results->GetLastObject();
256 EXPECT_NE(ringtoneObject, nullptr);
257 results->Close();
258
259 DataShare::DataSharePredicates predicates;
260 RingtoneDataCommand cmdDelete(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
261 retVal = dataManager->Delete(cmdDelete, predicates);
262 EXPECT_EQ((retVal > 0), true);
263 }
264
265 /*
266 * Feature: Service
267 * Function: Test RingtoneFetchResult with GetCount
268 * SubFunction: NA
269 * FunctionPoints: NA
270 * EnvConditions: NA
271 * CaseDescription: Test GetCount for RingtoneAsset
272 */
273 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetCount_test_001, TestSize.Level0)
274 {
275 RINGTONE_INFO_LOG("fetchResult_GetCount_test_001 start.");
276 std::shared_ptr<DataShare::DataShareResultSet> dataShare = make_shared<DataShare::DataShareResultSet>();
277 std::shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult =
278 make_shared<RingtoneFetchResult<RingtoneAsset>>(dataShare);
279 ASSERT_NE(fetchResult, nullptr);
280 fetchResult->resultset_ = nullptr;
281 int count = fetchResult->GetCount();
282 EXPECT_EQ(count, 0);
283
284 fetchResult->Close();
285 EXPECT_EQ(fetchResult->resultset_, nullptr);
286 fetchResult->Close();
287 RINGTONE_INFO_LOG("fetchResult_GetCount_test_001 end.");
288 }
289
290 /*
291 * Feature: Service
292 * Function: Test RingtoneFetchResult with GetCount
293 * SubFunction: NA
294 * FunctionPoints: NA
295 * EnvConditions: NA
296 * CaseDescription: Test GetCount for VibrateAsset
297 */
298 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetCount_test_002, TestSize.Level0)
299 {
300 RINGTONE_INFO_LOG("fetchResult_GetCount_test_002 start.");
301 std::shared_ptr<DataShare::DataShareResultSet> dataShare = make_shared<DataShare::DataShareResultSet>();
302 std::shared_ptr<RingtoneFetchResult<VibrateAsset>> fetchResult =
303 make_shared<RingtoneFetchResult<VibrateAsset>>(dataShare);
304 ASSERT_NE(fetchResult, nullptr);
305 fetchResult->resultset_ = nullptr;
306 int count = fetchResult->GetCount();
307 EXPECT_EQ(count, 0);
308
309 fetchResult->Close();
310 EXPECT_EQ(fetchResult->resultset_, nullptr);
311 fetchResult->Close();
312 RINGTONE_INFO_LOG("fetchResult_GetCount_test_002 end.");
313 }
314
315 /*
316 * Feature: Service
317 * Function: Test RingtoneFetchResult with GetObjectAtPosition
318 * SubFunction: NA
319 * FunctionPoints: NA
320 * EnvConditions: NA
321 * CaseDescription: Test GetObjectAtPosition for RingtoneAsset
322 */
323 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetObjectAtPosition_test_002, TestSize.Level0)
324 {
325 RINGTONE_INFO_LOG("fetchResult_GetObjectAtPosition_test_002 start.");
326 Uri uri(RINGTONE_PATH_URI);
327 auto dataManager = RingtoneDataManager::GetInstance();
328 ASSERT_NE(dataManager, nullptr);
329 for (int index = 0; index < NUMBER_OF_TIMES; index++) {
330 AbilityRuntime::DataShareValuesBucket values;
331 values.Put(RINGTONE_COLUMN_DATA, static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
332 TEST_INSERT_RINGTONE_LIBRARY + to_string(index) + MTP_FORMAT_MP3));
333 values.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
334 values.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
335 values.Put(RINGTONE_COLUMN_MIME_TYPE, MP3);
336 values.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(RAINNING) + MTP_FORMAT_MP3);
337 values.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(RAINNING));
338 values.Put(RINGTONE_COLUMN_MEDIA_TYPE, static_cast<int>(RINGTONE_MEDIA_TYPE_AUDIO));
339 RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
340 auto retVal = dataManager->Insert(cmd, values);
341 EXPECT_EQ((retVal > 0), true);
342 }
343
344 RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
345 DataShare::DataSharePredicates queryPredicates;
346 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
347 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, { RINGTONE_COLUMN_SIZE } };
348 int32_t errCode;
349 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
350 ASSERT_NE(queryResultSet, nullptr);
351 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
352 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
353 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
354 ASSERT_NE(results, nullptr);
355
356 for (int index = 0; index < NUMBER_OF_TIMES; index++) {
357 auto ringtoneObject = results->GetObjectAtPosition(index);
358 ASSERT_NE(ringtoneObject, nullptr);
359 }
360 results->Close();
361 RINGTONE_INFO_LOG("fetchResult_GetObjectAtPosition_test_002 end.");
362 }
363
364 /*
365 * Feature: Service
366 * Function: Test RingtoneFetchResult with GetObjectAtPosition
367 * SubFunction: NA
368 * FunctionPoints: NA
369 * EnvConditions: NA
370 * CaseDescription: Test GetObjectAtPosition for RingtoneAsset when resultSet row is empty
371 */
372 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetObjectAtPosition_test_003, TestSize.Level0)
373 {
374 RINGTONE_INFO_LOG("fetchResult_GetObjectAtPosition_test_003 start.");
375 Uri uri(RINGTONE_PATH_URI);
376 auto dataManager = RingtoneDataManager::GetInstance();
377 ASSERT_NE(dataManager, nullptr);
378
379 RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
380 DataShare::DataSharePredicates queryPredicates;
381 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, "mp4");
382 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, { RINGTONE_COLUMN_SIZE } };
383 int32_t errCode;
384 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
385 ASSERT_NE(queryResultSet, nullptr);
386 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
387 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
388 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
389 ASSERT_NE(results, nullptr);
390
391 for (int index = 0; index < NUMBER_OF_TIMES; index++) {
392 auto ringtoneObject = results->GetObjectAtPosition(index);
393 EXPECT_EQ(ringtoneObject, nullptr);
394 }
395 results->Close();
396 RINGTONE_INFO_LOG("fetchResult_GetObjectAtPosition_test_003 end.");
397 }
398
399 /*
400 * Feature: Service
401 * Function: Test RingtoneFetchResult with GetObjectAtPosition
402 * SubFunction: NA
403 * FunctionPoints: NA
404 * EnvConditions: NA
405 * CaseDescription: Test GetObjectAtPosition for abnormal branches
406 */
407 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetObjectAtPosition_test_004, TestSize.Level0)
408 {
409 RINGTONE_INFO_LOG("fetchResult_GetObjectAtPosition_test_004 start.");
410 std::shared_ptr<DataShare::DataShareResultSet> dataShare = make_shared<DataShare::DataShareResultSet>();
411 std::shared_ptr<RingtoneFetchResult<VibrateAsset>> fetchResult =
412 make_shared<RingtoneFetchResult<VibrateAsset>>(dataShare);
413 fetchResult->resultset_ = nullptr;
414 std::unique_ptr<VibrateAsset> resultObject = fetchResult->GetObjectAtPosition(0);
415 EXPECT_EQ(resultObject, nullptr);
416
417 std::shared_ptr<RingtoneFetchResult<RingtoneAsset>> result =
418 make_shared<RingtoneFetchResult<RingtoneAsset>>(dataShare);
419 ASSERT_NE(result, nullptr);
420 result->resultset_ = nullptr;
421 std::unique_ptr<RingtoneAsset> object = result->GetObjectAtPosition(0);
422 EXPECT_EQ(object, nullptr);
423
424 RINGTONE_INFO_LOG("fetchResult_GetObjectAtPosition_test_004 end.");
425 }
426
427 /*
428 * Feature: Service
429 * Function: Test RingtoneFetchResult with GetObjectAtPosition
430 * SubFunction: NA
431 * FunctionPoints: NA
432 * EnvConditions: NA
433 * CaseDescription: Test GetObjectAtPosition for VibrateAsset
434 */
435 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetObjectAtPosition_test_005, TestSize.Level0)
436 {
437 RINGTONE_INFO_LOG("fetchResult_GetObjectAtPosition_test_005 start.");
438 Uri uri(VIBRATE_PATH_URI);
439 auto dataManager = RingtoneDataManager::GetInstance();
440 ASSERT_NE(dataManager, nullptr);
441 g_uniStore->ExecuteSql("INSERT INTO " + VIBRATE_TABLE +
442 " VALUES (last_insert_rowid()+1, '/data/storage/el2/base/files/Ringtone/ringtones/Carme.ogg'," +
443 " 26177, 'RingtoneTest.ogg', 'rainning', 'Chinese', 1, 1, 1505707241000, 1505707241846, 1505707241," +
444 " 1, 0)");
445 g_uniStore->ExecuteSql("INSERT INTO " + VIBRATE_TABLE +
446 " VALUES (last_insert_rowid()+1, '/data/storage/el2/base/files/Ringtone/ringtones/Carme.ogg2'," +
447 " 26177, 'RingtoneTest2.ogg', 'rainning', 'Chinese', 1, 1, 1505707241000, 1505707241846, 1505707241," +
448 " 1, 0)");
449 g_uniStore->ExecuteSql("INSERT INTO " + VIBRATE_TABLE +
450 " VALUES (last_insert_rowid()+1, '/data/storage/el2/base/files/Ringtone/ringtones/Carme.ogg3'," +
451 " 26177, 'RingtoneTest3.ogg', 'rainning', 'Chinese', 1, 1, 1505707241000, 1505707241846, 1505707241," +
452 " 1, 0)");
453 RingtoneDataCommand cmdQuery(uri, VIBRATE_TABLE, RingtoneOperationType::QUERY);
454 DataShare::DataSharePredicates queryPredicates;
455 queryPredicates.EqualTo(VIBRATE_COLUMN_TITLE, static_cast<string>(RAINNING));
456 vector<string> columns = { { VIBRATE_COLUMN_VIBRATE_ID }, { VIBRATE_COLUMN_DATA }, { VIBRATE_COLUMN_SIZE } };
457 int32_t errCode;
458 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
459 ASSERT_NE(queryResultSet, nullptr);
460 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
461 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
462 auto results = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSet));
463 ASSERT_NE(results, nullptr);
464
465 auto ringtoneObject = results->GetObjectAtPosition(0);
466 ASSERT_NE(ringtoneObject, nullptr);
467 results->Close();
468 RINGTONE_INFO_LOG("fetchResult_GetObjectAtPosition_test_005 end.");
469 }
470
471 /*
472 * Feature: Service
473 * Function: Test RingtoneFetchResult with GetFirstObject GetNextObject GetLastObject
474 * SubFunction: NA
475 * FunctionPoints: NA
476 * EnvConditions: NA
477 * CaseDescription: Test GetFirstObject GetNextObject GetLastObject for RingtoneAsset when resultSet row is empty
478 */
479 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetFirstObject_test_001, TestSize.Level0)
480 {
481 RINGTONE_INFO_LOG("fetchResult_GetFirstObject_test_001 start.");
482 Uri uri(RINGTONE_PATH_URI);
483 auto dataManager = RingtoneDataManager::GetInstance();
484 ASSERT_NE(dataManager, nullptr);
485
486 RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
487 DataShare::DataSharePredicates queryPredicates;
488 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, "mp4");
489 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, { RINGTONE_COLUMN_SIZE } };
490 int32_t errCode;
491 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
492 ASSERT_NE(queryResultSet, nullptr);
493 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
494 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
495 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
496 ASSERT_NE(results, nullptr);
497 auto ringtoneObject = results->GetFirstObject();
498 EXPECT_EQ(ringtoneObject, nullptr);
499
500 ringtoneObject = results->GetNextObject();
501 EXPECT_EQ(ringtoneObject, nullptr);
502
503 ringtoneObject = results->GetLastObject();
504 EXPECT_EQ(ringtoneObject, nullptr);
505 results->Close();
506 RINGTONE_INFO_LOG("fetchResult_GetFirstObject_test_001 end.");
507 }
508
509 /*
510 * Feature: Service
511 * Function: Test RingtoneFetchResult with GetFirstObject GetNextObject GetLastObject
512 * SubFunction: NA
513 * FunctionPoints: NA
514 * EnvConditions: NA
515 * CaseDescription: Test GetFirstObject GetNextObject GetLastObject for VibrateAsset when resultSet row is empty
516 */
517 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetFirstObject_test_002, TestSize.Level0)
518 {
519 RINGTONE_INFO_LOG("fetchResult_GetFirstObject_test_002 start.");
520 Uri uri(VIBRATE_PATH_URI);
521 auto dataManager = RingtoneDataManager::GetInstance();
522 ASSERT_NE(dataManager, nullptr);
523
524 RingtoneDataCommand cmdQuery(uri, VIBRATE_TABLE, RingtoneOperationType::QUERY);
525 DataShare::DataSharePredicates queryPredicates;
526 queryPredicates.EqualTo(VIBRATE_COLUMN_TITLE, "test");
527 vector<string> columns = { { VIBRATE_COLUMN_VIBRATE_ID }, { VIBRATE_COLUMN_DATA }, { VIBRATE_COLUMN_SIZE } };
528 int32_t errCode;
529 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
530 ASSERT_NE(queryResultSet, nullptr);
531 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
532 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
533 auto results = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSet));
534 ASSERT_NE(results, nullptr);
535 auto ringtoneObject = results->GetFirstObject();
536 EXPECT_EQ(ringtoneObject, nullptr);
537
538 ringtoneObject = results->GetNextObject();
539 EXPECT_EQ(ringtoneObject, nullptr);
540
541 ringtoneObject = results->GetLastObject();
542 EXPECT_EQ(ringtoneObject, nullptr);
543 results->Close();
544 RINGTONE_INFO_LOG("fetchResult_GetFirstObject_test_002 end.");
545 }
546
547 /*
548 * Feature: Service
549 * Function: Test RingtoneFetchResult with IsAtLastRow
550 * SubFunction: NA
551 * FunctionPoints: NA
552 * EnvConditions: NA
553 * CaseDescription: Test IsAtLastRow for RingtoneAsset when resultSet row is not empty
554 */
555 HWTEST_F(RingtoneFetchResultTest, fetchResult_IsAtLastRow_test_002, TestSize.Level0)
556 {
557 RINGTONE_INFO_LOG("fetchResult_IsAtLastRow_test_002 start.");
558 Uri uri(RINGTONE_PATH_URI);
559 auto dataManager = RingtoneDataManager::GetInstance();
560 ASSERT_NE(dataManager, nullptr);
561
562 RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
563 DataShare::DataSharePredicates queryPredicates;
564 queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
565 vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, { RINGTONE_COLUMN_SIZE } };
566 int32_t errCode;
567 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
568 ASSERT_NE(queryResultSet, nullptr);
569 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
570 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
571 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
572 ASSERT_NE(results, nullptr);
573 auto ringtoneObject = results->GetLastObject();
574 EXPECT_NE(ringtoneObject, nullptr);
575
576 bool ret = results->IsAtLastRow();
577 EXPECT_TRUE(ret);
578 results->Close();
579 RINGTONE_INFO_LOG("fetchResult_IsAtLastRow_test_002 end.");
580 }
581
582 /*
583 * Feature: Service
584 * Function: Test RingtoneFetchResult with IsAtLastRow
585 * SubFunction: NA
586 * FunctionPoints: NA
587 * EnvConditions: NA
588 * CaseDescription: Test IsAtLastRow for VibrateAsset when resultSet row is not empty
589 */
590 HWTEST_F(RingtoneFetchResultTest, fetchResult_IsAtLastRow_test_003, TestSize.Level0)
591 {
592 RINGTONE_INFO_LOG("fetchResult_IsAtLastRow_test_003 start.");
593 Uri uri(VIBRATE_PATH_URI);
594 auto dataManager = RingtoneDataManager::GetInstance();
595 ASSERT_NE(dataManager, nullptr);
596
597 RingtoneDataCommand cmdQuery(uri, VIBRATE_TABLE, RingtoneOperationType::QUERY);
598 DataShare::DataSharePredicates queryPredicates;
599 queryPredicates.EqualTo(VIBRATE_COLUMN_TITLE, static_cast<string>(RAINNING));
600 vector<string> columns = { { VIBRATE_COLUMN_VIBRATE_ID }, { VIBRATE_COLUMN_DATA }, { VIBRATE_COLUMN_SIZE } };
601 int32_t errCode;
602 auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
603 ASSERT_NE(queryResultSet, nullptr);
604 shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
605 make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
606 auto results = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSet));
607 ASSERT_NE(results, nullptr);
608 auto ringtoneObject = results->GetLastObject();
609 EXPECT_NE(ringtoneObject, nullptr);
610
611 bool ret = results->IsAtLastRow();
612 EXPECT_TRUE(ret);
613 results->Close();
614 RINGTONE_INFO_LOG("fetchResult_IsAtLastRow_test_003 end.");
615 }
616
617 /*
618 * Feature: Service
619 * Function: Test RingtoneFetchResult with GetRowValFromColumn
620 * SubFunction: NA
621 * FunctionPoints: NA
622 * EnvConditions: NA
623 * CaseDescription: Test GetRowValFromColumn when resultSet is not empty
624 */
625 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetRowValFromColumn_test_003, TestSize.Level0)
626 {
627 RINGTONE_INFO_LOG("fetchResult_GetRowValFromColumn_test_003 start.");
628 RingtoneScannerDb ringtoneScannerDb;
629 g_uniStore->ExecuteSql("INSERT INTO " + RINGTONE_TABLE +
630 " VALUES (last_insert_rowid()+1, '/data/storage/el2/base/files/Ringtone/ringtones/Carme.ogg'," +
631 " 26177, 'RingtoneTest.ogg', 'RingtoneTest', 2, 1, 'audio/ogg', 1, 1505707241000, 1505707241846, 1505707241," +
632 " 1242, 0, -1, 0, -1, 3, 2, 0, -1, '1', 0)");
633 string whereClause = RINGTONE_COLUMN_DISPLAY_NAME + " = ?";
634 vector<string> whereArgs = {};
635 whereArgs.push_back("RingtoneTest.ogg");
636 vector<string> columns = {RINGTONE_COLUMN_SCANNER_FLAG};
637 shared_ptr<NativeRdb::ResultSet> resultSet = nullptr;
638 int ret = ringtoneScannerDb.QueryRingtoneRdb(whereClause, whereArgs, columns, resultSet);
639 EXPECT_EQ(ret, E_OK);
640
641 std::shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_unique<RingtoneFetchResult<RingtoneAsset>>();
642 ASSERT_NE(fetchResult, nullptr);
643 RingtoneResultSetDataType dataType = RingtoneResultSetDataType::DATA_TYPE_DOUBLE;
644 std::string columnName = RINGTONE_COLUMN_DATA;
645 auto res = fetchResult->GetRowValFromColumn(columnName, dataType, resultSet);
646 variant<int32_t, int64_t, string, double> doubleVal = 0;
647 EXPECT_EQ(res, doubleVal);
648
649 dataType = RingtoneResultSetDataType::DATA_TYPE_INT64;
650 res = fetchResult->GetRowValFromColumn(columnName, dataType, resultSet);
651 variant<int32_t, int64_t, string, double> longVal = static_cast<int64_t>(0);
652 EXPECT_EQ(res, longVal);
653
654 std::unique_ptr<RingtoneAsset> asset = std::make_unique<RingtoneAsset>();
655 fetchResult->SetRingtoneAsset(asset, resultSet);
656 RINGTONE_INFO_LOG("fetchResult_GetRowValFromColumn_test_003 end.");
657 }
658
659 } // namespace Media
660 } // namespace OHOS