1 /*
2 * Copyright (C) 2023 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 "mediadatashare_unit_test.h"
17
18 #include <gtest/gtest.h>
19 #include <unistd.h>
20
21 #include "abs_shared_result_set.h"
22 #include "accesstoken_kit.h"
23 #include "dataobs_mgr_changeinfo.h"
24 #include "datashare_log.h"
25 #include "datashare_valuebucket_convert.h"
26 #include "data_proxy_observer_stub.h"
27 #include "hap_token_info.h"
28 #include "iservice_registry.h"
29 #include "rdb_data_ability_utils.h"
30 #include "system_ability_definition.h"
31 #include "token_setproc.h"
32
33 namespace OHOS {
34 namespace DataShare {
35 using namespace testing::ext;
36 using namespace OHOS::Security::AccessToken;
37
38 template <typename T>
39 class ConditionLock {
40 public:
ConditionLock()41 explicit ConditionLock() {}
~ConditionLock()42 ~ConditionLock() {}
43 public:
Notify(const T & data)44 void Notify(const T &data)
45 {
46 std::lock_guard<std::mutex> lock(mutex_);
47 data_ = data;
48 isSet_ = true;
49 cv_.notify_one();
50 }
51
Wait()52 T Wait()
53 {
54 std::unique_lock<std::mutex> lock(mutex_);
55 cv_.wait_for(lock, std::chrono::seconds(INTERVAL), [this]() { return isSet_; });
56 T data = data_;
57 cv_.notify_one();
58 return data;
59 }
60
Clear()61 void Clear()
62 {
63 std::lock_guard<std::mutex> lock(mutex_);
64 isSet_ = false;
65 cv_.notify_one();
66 }
67
68 private:
69 bool isSet_ = false;
70 T data_;
71 std::mutex mutex_;
72 std::condition_variable cv_;
73 static constexpr int64_t INTERVAL = 2;
74 };
75
76 class DataShareObserverTest : public DataShare::DataShareObserver {
77 public:
DataShareObserverTest()78 DataShareObserverTest() {}
~DataShareObserverTest()79 ~DataShareObserverTest() {}
80
OnChange(const ChangeInfo & changeInfo)81 void OnChange(const ChangeInfo &changeInfo) override
82 {
83 changeInfo_ = changeInfo;
84 data.Notify(changeInfo);
85 }
86
Clear()87 void Clear()
88 {
89 changeInfo_.changeType_ = INVAILD;
90 changeInfo_.uris_.clear();
91 changeInfo_.data_ = nullptr;
92 changeInfo_.size_ = 0;
93 changeInfo_.valueBuckets_ = {};
94 data.Clear();
95 }
96
97 ChangeInfo changeInfo_;
98 ConditionLock<ChangeInfo> data;
99 };
100
101 constexpr int STORAGE_MANAGER_MANAGER_ID = 5003;
102 std::string DATA_SHARE_URI = "datashare:///com.acts.datasharetest";
103 std::string MEDIALIBRARY_DATA_URI = "datashare:///com.acts.datasharetest";
104 std::string MEDIALIBRARY_DATA_URI_ERROR = "test:///com.acts.datasharetest";
105 std::string FILE_DATA_URI = "file://com.acts.datasharetest";
106 std::string NORMALIZE_URI = "normalize+datashare:///com.acts.datasharetest";
107 std::string DENORMALIZE_URI = "denormalize+datashare:///com.acts.datasharetest";
108 std::shared_ptr<DataShare::DataShareHelper> g_dataShareHelper;
109
CreateDataShareHelper(int32_t systemAbilityId)110 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int32_t systemAbilityId)
111 {
112 LOG_INFO("CreateDataShareHelper start");
113 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
114 if (saManager == nullptr) {
115 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
116 return nullptr;
117 }
118 auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
119 if (remoteObj == nullptr) {
120 LOG_ERROR("GetSystemAbility service failed.");
121 return nullptr;
122 }
123 return DataShare::DataShareHelper::Creator(remoteObj, DATA_SHARE_URI);
124 }
125
UrisEqual(std::list<Uri> uri1,std::list<Uri> uri2)126 bool MediaDataShareUnitTest::UrisEqual(std::list<Uri> uri1, std::list<Uri> uri2)
127 {
128 if (uri1.size() != uri2.size()) {
129 return false;
130 }
131 auto cmp = [](const Uri &first, const Uri &second) {
132 return first.ToString() < second.ToString();
133 };
134 uri1.sort(cmp);
135 uri2.sort(cmp);
136 auto it1 = uri1.begin();
137 auto it2 = uri2.begin();
138 for (; it1 != uri1.end() && it2 != uri2.end(); it1++, it2++) {
139 if (!it1->Equals(*it2)) {
140 return false;
141 }
142 }
143 return true;
144 }
145
ValueBucketEqual(const VBuckets & v1,const VBuckets & v2)146 bool MediaDataShareUnitTest::ValueBucketEqual(const VBuckets& v1, const VBuckets& v2)
147 {
148 if (v1.size() != v2.size()) {
149 return false;
150 }
151 for (size_t i = 0; i < v1.size(); i++) {
152 const VBucket& vb1 = v1[i];
153 const VBucket& vb2 = v2[i];
154 if (vb1.size() != vb2.size()) {
155 return false;
156 }
157 for (const auto& pair1 : vb1) {
158 const auto& key = pair1.first;
159 const auto& value1 = pair1.second;
160 auto it2 = vb2.find(key);
161 if (it2 == vb2.end() || it2->second != value1) {
162 return false;
163 }
164 }
165 }
166 return true;
167 }
168
ChangeInfoEqual(const ChangeInfo & changeInfo,const ChangeInfo & expectChangeInfo)169 bool MediaDataShareUnitTest::ChangeInfoEqual(const ChangeInfo &changeInfo, const ChangeInfo &expectChangeInfo)
170 {
171 if (changeInfo.changeType_ != expectChangeInfo.changeType_) {
172 return false;
173 }
174
175 if (!UrisEqual(changeInfo.uris_, expectChangeInfo.uris_)) {
176 return false;
177 }
178
179 if (changeInfo.size_ != expectChangeInfo.size_) {
180 return false;
181 }
182
183 if (changeInfo.size_ != 0) {
184 if (changeInfo.data_ == nullptr && expectChangeInfo.data_ == nullptr) {
185 return false;
186 }
187 return memcmp(changeInfo.data_, expectChangeInfo.data_, expectChangeInfo.size_) == 0;
188 }
189
190 return ValueBucketEqual(changeInfo.valueBuckets_, expectChangeInfo.valueBuckets_);
191 }
192
193
SetUpTestCase(void)194 void MediaDataShareUnitTest::SetUpTestCase(void)
195 {
196 LOG_INFO("SetUpTestCase invoked");
197 g_dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
198 ASSERT_TRUE(g_dataShareHelper != nullptr);
199 int sleepTime = 1;
200 sleep(sleepTime);
201
202 Uri uri(MEDIALIBRARY_DATA_URI);
203 DataShare::DataShareValuesBucket valuesBucket;
204 double valueD1 = 20.07;
205 valuesBucket.Put("phoneNumber", valueD1);
206 valuesBucket.Put("name", "dataShareTest003");
207 int value1 = 1001;
208 valuesBucket.Put("age", value1);
209 int retVal = g_dataShareHelper->Insert(uri, valuesBucket);
210 EXPECT_EQ((retVal > 0), true);
211
212 valuesBucket.Clear();
213 double valueD2 = 20.08;
214 valuesBucket.Put("phoneNumber", valueD2);
215 valuesBucket.Put("name", "dataShareTest004");
216 int value2 = 1000;
217 valuesBucket.Put("age", value2);
218 retVal = g_dataShareHelper->Insert(uri, valuesBucket);
219 EXPECT_EQ((retVal > 0), true);
220
221 valuesBucket.Clear();
222 double valueD3 = 20.09;
223 valuesBucket.Put("phoneNumber", valueD3);
224 valuesBucket.Put("name", "dataShareTest005");
225 int value3 = 999;
226 valuesBucket.Put("age", value3);
227 retVal = g_dataShareHelper->Insert(uri, valuesBucket);
228 EXPECT_EQ((retVal > 0), true);
229 LOG_INFO("SetUpTestCase end");
230 }
231
TearDownTestCase(void)232 void MediaDataShareUnitTest::TearDownTestCase(void)
233 {
234 LOG_INFO("TearDownTestCase invoked");
235 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
236 ASSERT_TRUE(g_dataShareHelper != nullptr);
237 Uri deleteAssetUri(MEDIALIBRARY_DATA_URI);
238 DataShare::DataSharePredicates predicates;
239 predicates.GreaterThan("id", 0);
240 int retVal = helper->Delete(deleteAssetUri, predicates);
241 LOG_INFO("TearDownTestCase Delete retVal: %{public}d", retVal);
242 EXPECT_EQ((retVal >= 0), true);
243
244 bool result = helper->Release();
245 EXPECT_EQ(result, true);
246 LOG_INFO("TearDownTestCase end");
247 }
248
SetUp(void)249 void MediaDataShareUnitTest::SetUp(void) {}
TearDown(void)250 void MediaDataShareUnitTest::TearDown(void) {}
251
252 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_001, TestSize.Level0)
253 {
254 LOG_INFO("MediaDataShare_Predicates_Test_001::Start");
255 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
256 Uri uri(MEDIALIBRARY_DATA_URI);
257 DataShare::DataSharePredicates predicates;
258 predicates.EqualTo("name", "dataShareTest003");
259 predicates.Limit(1, 0);
260 vector<string> columns;
261 auto resultSet = helper->Query(uri, predicates, columns);
262 int result = 0;
263 if (resultSet != nullptr) {
264 resultSet->GetRowCount(result);
265 }
266 EXPECT_EQ(result, 1);
267 LOG_INFO("MediaDataShare_Predicates_Test_001, End");
268 }
269
270 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_002, TestSize.Level0)
271 {
272 LOG_INFO("MediaDataShare_Predicates_Test_002::Start");
273 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
274 DataShare::DataSharePredicates predicates;
275 predicates.NotEqualTo("name", "dataShareTest003");
276 vector<string> columns;
277 Uri uri(MEDIALIBRARY_DATA_URI);
278 auto resultSet = helper->Query(uri, predicates, columns);
279 int result = 0;
280 if (resultSet != nullptr) {
281 resultSet->GetRowCount(result);
282 }
283 EXPECT_EQ(result, 2);
284 LOG_INFO("MediaDataShare_Predicates_Test_002, End");
285 }
286
287 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_003, TestSize.Level0)
288 {
289 LOG_INFO("MediaDataShare_Predicates_Test_003::Start");
290 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
291 DataShare::DataSharePredicates predicates;
292 predicates.Contains("name", "dataShareTest");
293 vector<string> columns;
294 Uri uri(MEDIALIBRARY_DATA_URI);
295 auto resultSet = helper->Query(uri, predicates, columns);
296 int result = 0;
297 if (resultSet != nullptr) {
298 resultSet->GetRowCount(result);
299 }
300 EXPECT_EQ(result, 3);
301 LOG_INFO("MediaDataShare_Predicates_Test_003, End");
302 }
303
304 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_004, TestSize.Level0)
305 {
306 LOG_INFO("MediaDataShare_Predicates_Test_004::Start");
307 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
308 DataShare::DataSharePredicates predicates;
309 predicates.BeginsWith("name", "dataShare");
310 vector<string> columns;
311 Uri uri(MEDIALIBRARY_DATA_URI);
312 auto resultSet = helper->Query(uri, predicates, columns);
313 int result = 0;
314 if (resultSet != nullptr) {
315 resultSet->GetRowCount(result);
316 }
317 EXPECT_EQ(result, 3);
318 LOG_INFO("MediaDataShare_Predicates_Test_004, End");
319 }
320
321 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_005, TestSize.Level0)
322 {
323 LOG_INFO("MediaDataShare_Predicates_Test_005::Start");
324 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
325 DataShare::DataSharePredicates predicates;
326 predicates.EndsWith("name", "003");
327 vector<string> columns;
328 Uri uri(MEDIALIBRARY_DATA_URI);
329 auto resultSet = helper->Query(uri, predicates, columns);
330 int result = 0;
331 if (resultSet != nullptr) {
332 resultSet->GetRowCount(result);
333 }
334 EXPECT_EQ(result, 1);
335 LOG_INFO("MediaDataShare_Predicates_Test_005, End");
336 }
337
338 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_006, TestSize.Level0)
339 {
340 LOG_INFO("MediaDataShare_Predicates_Test_006::Start");
341 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
342 DataShare::DataSharePredicates predicates;
343 predicates.IsNull("name");
344 vector<string> columns;
345 Uri uri(MEDIALIBRARY_DATA_URI);
346 auto resultSet = helper->Query(uri, predicates, columns);
347 int result = -1;
348 if (resultSet != nullptr) {
349 resultSet->GetRowCount(result);
350 }
351 EXPECT_EQ(result, 0);
352 LOG_INFO("MediaDataShare_Predicates_Test_006, End");
353 }
354
355 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_007, TestSize.Level0)
356 {
357 LOG_INFO("MediaDataShare_Predicates_Test_007::Start");
358 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
359 DataShare::DataSharePredicates predicates;
360 predicates.IsNotNull("name");
361 vector<string> columns;
362 Uri uri(MEDIALIBRARY_DATA_URI);
363 auto resultSet = helper->Query(uri, predicates, columns);
364 int result = 0;
365 if (resultSet != nullptr) {
366 resultSet->GetRowCount(result);
367 }
368 EXPECT_EQ(result, 3);
369 LOG_INFO("MediaDataShare_Predicates_Test_007, End");
370 }
371
372 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_008, TestSize.Level0)
373 {
374 LOG_INFO("MediaDataShare_Predicates_Test_008::Start");
375 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
376 DataShare::DataSharePredicates predicates;
377 predicates.Like("name", "%Test003");
378 vector<string> columns;
379 Uri uri(MEDIALIBRARY_DATA_URI);
380 auto resultSet = helper->Query(uri, predicates, columns);
381 int result = 0;
382 if (resultSet != nullptr) {
383 resultSet->GetRowCount(result);
384 }
385 EXPECT_EQ(result, 1);
386 LOG_INFO("MediaDataShare_Predicates_Test_008, End");
387 }
388
389 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_009, TestSize.Level0)
390 {
391 LOG_INFO("MediaDataShare_Predicates_Test_009::Start");
392 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
393 DataShare::DataSharePredicates predicates;
394 predicates.Glob("name", "dataShareTes?003");
395 vector<string> columns;
396 Uri uri(MEDIALIBRARY_DATA_URI);
397 auto resultSet = helper->Query(uri, predicates, columns);
398 int result = 0;
399 if (resultSet != nullptr) {
400 resultSet->GetRowCount(result);
401 }
402 EXPECT_EQ(result, 1);
403 LOG_INFO("MediaDataShare_Predicates_Test_009, End");
404 }
405
406 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_010, TestSize.Level0)
407 {
408 LOG_INFO("MediaDataShare_Predicates_Test_010::Start");
409 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
410 DataShare::DataSharePredicates predicates;
411 predicates.Between("age", "0", "999");
412 vector<string> columns;
413 Uri uri(MEDIALIBRARY_DATA_URI);
414 auto resultSet = helper->Query(uri, predicates, columns);
415 int result = 0;
416 if (resultSet != nullptr) {
417 resultSet->GetRowCount(result);
418 }
419 EXPECT_EQ(result, 1);
420 LOG_INFO("MediaDataShare_Predicates_Test_010, End");
421 }
422
423 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_011, TestSize.Level0)
424 {
425 LOG_INFO("MediaDataShare_Predicates_Test_011::Start");
426 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
427 DataShare::DataSharePredicates predicates;
428 predicates.NotBetween("age", "0", "999");
429 vector<string> columns;
430 Uri uri(MEDIALIBRARY_DATA_URI);
431 auto resultSet = helper->Query(uri, predicates, columns);
432 int result = 0;
433 if (resultSet != nullptr) {
434 resultSet->GetRowCount(result);
435 }
436 EXPECT_EQ(result, 2);
437 LOG_INFO("MediaDataShare_Predicates_Test_011, End");
438 }
439
440 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_012, TestSize.Level0)
441 {
442 LOG_INFO("MediaDataShare_Predicates_Test_012::Start");
443 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
444 DataShare::DataSharePredicates predicates;
445 predicates.GreaterThan("age", 999);
446 vector<string> columns;
447 Uri uri(MEDIALIBRARY_DATA_URI);
448 auto resultSet = helper->Query(uri, predicates, columns);
449 int result = 0;
450 if (resultSet != nullptr) {
451 resultSet->GetRowCount(result);
452 }
453 EXPECT_EQ(result, 2);
454 LOG_INFO("MediaDataShare_Predicates_Test_012, End");
455 }
456
457 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_013, TestSize.Level0)
458 {
459 LOG_INFO("MediaDataShare_Predicates_Test_013::Start");
460 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
461 DataShare::DataSharePredicates predicates;
462 predicates.LessThan("age", 1000);
463 vector<string> columns;
464 Uri uri(MEDIALIBRARY_DATA_URI);
465 auto resultSet = helper->Query(uri, predicates, columns);
466 int result = 0;
467 if (resultSet != nullptr) {
468 resultSet->GetRowCount(result);
469 }
470 EXPECT_EQ(result, 1);
471 LOG_INFO("MediaDataShare_Predicates_Test_013, End");
472 }
473
474 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_014, TestSize.Level0)
475 {
476 LOG_INFO("MediaDataShare_Predicates_Test_014::Start");
477 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
478 DataShare::DataSharePredicates predicates;
479 predicates.GreaterThanOrEqualTo("age", 1000);
480 vector<string> columns;
481 Uri uri(MEDIALIBRARY_DATA_URI);
482 auto resultSet = helper->Query(uri, predicates, columns);
483 int result = 0;
484 if (resultSet != nullptr) {
485 resultSet->GetRowCount(result);
486 }
487 EXPECT_EQ(result, 2);
488 LOG_INFO("MediaDataShare_Predicates_Test_014, End");
489 }
490
491 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_015, TestSize.Level0)
492 {
493 LOG_INFO("MediaDataShare_Predicates_Test_015::Start");
494 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
495 DataShare::DataSharePredicates predicates;
496 predicates.LessThanOrEqualTo("age", 1000);
497 vector<string> columns;
498 Uri uri(MEDIALIBRARY_DATA_URI);
499 auto resultSet = helper->Query(uri, predicates, columns);
500 int result = 0;
501 if (resultSet != nullptr) {
502 resultSet->GetRowCount(result);
503 }
504 EXPECT_EQ(result, 2);
505 LOG_INFO("MediaDataShare_Predicates_Test_015, End");
506 }
507
508 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_016, TestSize.Level0)
509 {
510 LOG_INFO("MediaDataShare_Predicates_Test_016::Start");
511 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
512 DataShare::DataSharePredicates predicates;
513 predicates.EqualTo("phoneNumber", 20.08)
514 ->BeginWrap()
515 ->EqualTo("name", "dataShareTest004")
516 ->Or()
517 ->EqualTo("age", 1000)
518 ->EndWrap();
519 vector<string> columns;
520 Uri uri(MEDIALIBRARY_DATA_URI);
521 auto resultSet = helper->Query(uri, predicates, columns);
522 int result = 0;
523 if (resultSet != nullptr) {
524 resultSet->GetRowCount(result);
525 }
526 EXPECT_EQ(result, 1);
527 LOG_INFO("MediaDataShare_Predicates_Test_016, End");
528 }
529
530 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_017, TestSize.Level0)
531 {
532 LOG_INFO("MediaDataShare_Predicates_Test_017::Start");
533 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
534 DataShare::DataSharePredicates predicates;
535 predicates.EqualTo("phoneNumber", 20.08)->And()->EqualTo("name", "dataShareTest004");
536 vector<string> columns;
537 Uri uri(MEDIALIBRARY_DATA_URI);
538 auto resultSet = helper->Query(uri, predicates, columns);
539 int result = 0;
540 if (resultSet != nullptr) {
541 resultSet->GetRowCount(result);
542 }
543 EXPECT_EQ(result, 1);
544 LOG_INFO("MediaDataShare_Predicates_Test_017, End");
545 }
546
547 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_018, TestSize.Level0)
548 {
549 LOG_INFO("MediaDataShare_Predicates_Test_018::Start");
550 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
551 DataShare::DataSharePredicates predicates;
552 predicates.OrderByAsc("age");
553 vector<string> columns;
554 Uri uri(MEDIALIBRARY_DATA_URI);
555 auto resultSet = helper->Query(uri, predicates, columns);
556 int columnIndex = 0;
557 std::string stringResult = "";
558 if (resultSet != nullptr) {
559 resultSet->GoToFirstRow();
560 resultSet->GetColumnIndex("name", columnIndex);
561 resultSet->GetString(columnIndex, stringResult);
562 }
563 EXPECT_EQ(stringResult, "dataShareTest005");
564 LOG_INFO("MediaDataShare_Predicates_Test_018, End");
565 }
566
567 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_019, TestSize.Level0)
568 {
569 LOG_INFO("MediaDataShare_Predicates_Test_019::Start");
570 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
571 DataShare::DataSharePredicates predicates;
572 predicates.OrderByDesc("phoneNumber");
573 vector<string> columns;
574 Uri uri(MEDIALIBRARY_DATA_URI);
575 auto resultSet = helper->Query(uri, predicates, columns);
576 int columnIndex = 0;
577 std::string stringResult = "";
578 if (resultSet != nullptr) {
579 resultSet->GoToFirstRow();
580 resultSet->GetColumnIndex("name", columnIndex);
581 resultSet->GetString(columnIndex, stringResult);
582 }
583 EXPECT_EQ(stringResult, "dataShareTest005");
584 LOG_INFO("MediaDataShare_Predicates_Test_019, End");
585 }
586
587 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_020, TestSize.Level0)
588 {
589 LOG_INFO("MediaDataShare_Predicates_Test_020::Start");
590 DataShare::DataSharePredicates predicates;
591 predicates.SetSettingMode(DataShare::SettingMode::PREDICATES_METHOD);
592 int16_t setting = predicates.GetSettingMode();
593 EXPECT_EQ(setting, DataShare::SettingMode::PREDICATES_METHOD);
594 LOG_INFO("MediaDataShare_Predicates_Test_020, End");
595 }
596
597 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_021, TestSize.Level0)
598 {
599 LOG_INFO("MediaDataShare_Predicates_Test_021::Start");
600 DataShare::DataSharePredicates predicates;
601 predicates.EqualTo("name", "dataShareTest003");
602
603 std::vector<DataShare::OperationItem> operationItems = predicates.GetOperationList();
604 DataShare::OperationItem operationItem = operationItems[0];
605 EXPECT_EQ(operationItem.operation, DataShare::OperationType::EQUAL_TO);
606 DataShare::SingleValue sv1 = operationItem.singleParams[0];
607 string param1 = sv1;
608 DataShare::SingleValue sv2 = operationItem.singleParams[1];
609 string param2 = sv2;
610 EXPECT_EQ(param1, "name");
611 EXPECT_EQ(param2, "dataShareTest003");
612 LOG_INFO("MediaDataShare_Predicates_Test_021, End");
613 }
614
615 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_022, TestSize.Level0)
616 {
617 LOG_INFO("MediaDataShare_Predicates_Test_023::Start");
618 DataShare::DataSharePredicates predicates;
619 int res = predicates.SetWhereClause("`data2` > ?");
620 EXPECT_EQ(res, 0);
621 string clause = predicates.GetWhereClause();
622 EXPECT_EQ(clause, "`data2` > ?");
623 LOG_INFO("MediaDataShare_Predicates_Test_023, End");
624 }
625
626 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_023, TestSize.Level0)
627 {
628 LOG_INFO("MediaDataShare_Predicates_Test_024::Start");
629 DataShare::DataSharePredicates predicates;
630 int res = predicates.SetWhereArgs(std::vector<std::string>{ "-5" });
631 EXPECT_EQ(res, 0);
632 vector<string> args = predicates.GetWhereArgs();
633 EXPECT_EQ(args[0], "-5");
634 LOG_INFO("MediaDataShare_Predicates_Test_024, End");
635 }
636
637 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_024, TestSize.Level0)
638 {
639 LOG_INFO("MediaDataShare_Predicates_Test_025::Start");
640 DataShare::DataSharePredicates predicates;
641 int res = predicates.SetOrder("data3");
642 EXPECT_EQ(res, 0);
643 string order = predicates.GetOrder();
644 EXPECT_EQ(order, "data3");
645 LOG_INFO("MediaDataShare_Predicates_Test_025, End");
646 }
647
648 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ValuesBucket_Test_001, TestSize.Level0)
649 {
650 LOG_INFO("MediaDataShare_ValuesBucket_Test_001::Start");
651 DataShare::DataShareValuesBucket valuesBucket;
652 EXPECT_EQ(valuesBucket.IsEmpty(), true);
653
654 valuesBucket.Put("name", "dataShare_Test_001");
655 EXPECT_EQ(valuesBucket.IsEmpty(), false);
656
657 bool isValid;
658 DataShare::DataShareValueObject object = valuesBucket.Get("name", isValid);
659 string value = object;
660 EXPECT_EQ(value, "dataShare_Test_001");
661
662 valuesBucket.Clear();
663 EXPECT_EQ(valuesBucket.IsEmpty(), true);
664 LOG_INFO("MediaDataShare_ValuesBucket_Test_001 End");
665 }
666
667 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ValueObject_Test_001, TestSize.Level0)
668 {
669 LOG_INFO("MediaDataShare_ValueObject_Test_001::Start");
670
671 int base = 100;
672 DataShare::DataShareValueObject object(base);
673 int value = object;
674 EXPECT_EQ(value, base);
675
676 int64_t base64 = 100;
677 DataShare::DataShareValueObject object64(base64);
678 int64_t value64 = object64;
679 EXPECT_EQ(value64, base64);
680
681 double baseD = 10.0;
682 DataShare::DataShareValueObject objectD(baseD);
683 double valueD = objectD;
684 EXPECT_EQ(valueD, baseD);
685
686 bool baseB = true;
687 DataShare::DataShareValueObject objectB(baseB);
688 bool valueB = objectB;
689 EXPECT_EQ(valueB, baseB);
690
691 vector<uint8_t> baseV;
692 DataShare::DataShareValueObject objectV(baseV);
693 vector<uint8_t> valueV = objectV;
694 EXPECT_EQ(valueV, baseV);
695
696 DataShare::DataShareValueObject objectCopy(object);
697 int valueCopy = objectCopy;
698 EXPECT_EQ(valueCopy, value);
699
700 DataShare::DataShareValueObject objectMove(std::move(object));
701 int valueMove = objectMove;
702 EXPECT_EQ(valueMove, value);
703
704 LOG_INFO("MediaDataShare_ValueObject_Test_001 End");
705 }
706
707 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_batchInsert_Test_001, TestSize.Level0)
708 {
709 LOG_INFO("MediaDataShare_batchInsert_Test_001::Start");
710 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
711 ASSERT_TRUE(helper != nullptr);
712 Uri uri(MEDIALIBRARY_DATA_URI);
713 DataShare::DataShareValuesBucket valuesBucket1;
714 valuesBucket1.Put("name", "dataShareTest006");
715 valuesBucket1.Put("phoneNumber", 20.6);
716 DataShare::DataShareValuesBucket valuesBucket2;
717 valuesBucket2.Put("name", "dataShareTest007");
718 valuesBucket2.Put("phoneNumber", 20.5);
719 std::vector<DataShare::DataShareValuesBucket> values;
720 values.push_back(valuesBucket1);
721 values.push_back(valuesBucket2);
722 int result = helper->BatchInsert(uri, values);
723 EXPECT_EQ(result, 2);
724 LOG_INFO("MediaDataShare_batchInsert_Test_001 End");
725 }
726
727 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_NormalizeUri_Test_001, TestSize.Level0)
728 {
729 LOG_INFO("MediaDataShare_NormalizeUri_Test_001::Start");
730 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
731 Uri uri(NORMALIZE_URI);
732 Uri uri_media(MEDIALIBRARY_DATA_URI);
733 auto normalUri = helper->NormalizeUri(uri_media);
734 EXPECT_EQ(normalUri, uri);
735 LOG_INFO("MediaDataShare_NormalizeUri_Test_001 End");
736 }
737
738 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_DenormalizeUri_Test_001, TestSize.Level0)
739 {
740 LOG_INFO("MediaDataShare_DenormalizeUri_Test_001::Start");
741 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
742 Uri uri(DENORMALIZE_URI);
743 Uri uri_media(MEDIALIBRARY_DATA_URI);
744 auto denormalUri = helper->DenormalizeUri(uri_media);
745 EXPECT_EQ(denormalUri, uri);
746 LOG_INFO("MediaDataShare_DenormalizeUri_Test_001 End");
747 }
748
749 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_SingleValue_Test_001, TestSize.Level0)
750 {
751 LOG_INFO("MediaDataShare_SingleValue_Test_001::Start");
752 int base = 100;
753 DataShare::SingleValue sv(base);
754 int value = sv;
755 EXPECT_EQ(value, base);
756
757 int64_t base64 = 100;
758 DataShare::SingleValue sv64(base64);
759 int64_t value64 = sv64;
760 EXPECT_EQ(value64, base64);
761
762 double baseD = 10.0;
763 DataShare::SingleValue svD(baseD);
764 double valueD = svD;
765 EXPECT_DOUBLE_EQ(valueD, baseD);
766
767 bool baseB = true;
768 DataShare::SingleValue svB(baseB);
769 bool valueB = svB;
770 EXPECT_EQ(valueB, baseB);
771
772 string baseS = "dataShare_Test_001";
773 DataShare::SingleValue svS(baseS);
774 string valueS = svS;
775 EXPECT_EQ(valueS, baseS);
776
777 DataShare::SingleValue svCopy(sv);
778 int valueCopy = svCopy;
779 EXPECT_EQ(valueCopy, value);
780
781 DataShare::SingleValue svMove(std::move(sv));
782 int valueMove = svMove;
783 EXPECT_EQ(valueMove, value);
784 LOG_INFO("MediaDataShare_SingleValue_Test_001 End");
785 }
786
787 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_MutliValue_Test_001, TestSize.Level0)
788 {
789 LOG_INFO("MediaDataShare_MutliValue_Test_001::Start");
790 vector<int> base;
791 base.push_back(100);
792 DataShare::MutliValue mv(base);
793 vector<int> value = mv;
794 EXPECT_EQ(value[0], base[0]);
795
796 vector<int64_t> base64;
797 base64.push_back(100);
798 DataShare::MutliValue mv64(base64);
799 vector<int64_t> value64 = mv64;
800 EXPECT_EQ(value64[0], base64[0]);
801
802 vector<double> baseD;
803 baseD.push_back(10.0);
804 DataShare::MutliValue mvD(baseD);
805 vector<double> valueD = mvD;
806 EXPECT_DOUBLE_EQ(valueD[0], baseD[0]);
807
808 vector<string> baseS;
809 baseS.push_back("dataShare_Test_001");
810 DataShare::MutliValue mvS(baseS);
811 vector<string> valueS = mvS;
812 EXPECT_EQ(valueS[0], baseS[0]);
813
814 DataShare::MutliValue mvCopy(mv);
815 vector<int> valueCopy = mvCopy;
816 EXPECT_EQ(valueCopy[0], value[0]);
817
818 DataShare::MutliValue mvMove(std::move(mv));
819 vector<int> valueMove = mvMove;
820 EXPECT_EQ(valueMove[0], value[0]);
821 LOG_INFO("MediaDataShare_MutliValue_Test_001 End");
822 }
823
824 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ResultSet_Test_001, TestSize.Level0)
825 {
826 LOG_INFO("MediaDataShare_ResultSet_Test_005::Start");
827 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
828 DataShare::DataSharePredicates predicates;
829 predicates.Contains("name", "dataShareTest");
830 DataShare::DataShareResultSet resultSet;
831 std::vector<string> names;
832 int err = resultSet.GetAllColumnNames(names);
833 EXPECT_NE(err, 0);
834 int count;
835 err = resultSet.GetRowCount(count);
836 EXPECT_NE(err, 0);
837 err = resultSet.GoToRow(1);
838 EXPECT_NE(err, 0);
839 std::vector<uint8_t> blob;
840 err = resultSet.GetBlob(0, blob);
841 EXPECT_NE(err, 0);
842 int64_t longValue;
843 err = resultSet.GetLong(0, longValue);
844 EXPECT_NE(err, 0);
845 double doubleValue;
846 err = resultSet.GetDouble(0, doubleValue);
847 EXPECT_NE(err, 0);
848
849 bool isNull;
850 err = resultSet.IsColumnNull(0, isNull);
851 EXPECT_NE(err, 0);
852 bool flag = resultSet.OnGo(0, 1);
853 EXPECT_EQ(flag, false);
854 LOG_INFO("MediaDataShare_ResultSet_Test_005, End");
855 }
856
857 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ResultSet_Test_002, TestSize.Level0)
858 {
859 LOG_INFO("MediaDataShare_ResultSet_Test_002::Start");
860 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
861 ASSERT_TRUE(helper != nullptr);
862 DataShare::DataSharePredicates predicates;
863 predicates.EqualTo("name", "dataShareTest003");
864 vector<string> columns;
865 Uri uri(MEDIALIBRARY_DATA_URI);
866 auto resultSet = helper->Query(uri, predicates, columns);
867 int columnIndex = 0;
868 vector<uint8_t> blob;
869 vector<string> columnNames;
870 if (resultSet != nullptr) {
871 resultSet->GoToFirstRow();
872 resultSet->GetColumnIndex("name", columnIndex);
873 std::string columnName;
874 int err = resultSet->GetColumnName(columnIndex, columnName);
875 EXPECT_EQ(err, 0);
876 EXPECT_EQ(columnName, "name");
877 err = resultSet->GetBlob(columnIndex, blob);
878 EXPECT_EQ(err, 0);
879 EXPECT_NE(blob.size(), 0);
880
881 err = resultSet->GetAllColumnNames(columnNames);
882 EXPECT_EQ(err, 0);
883 EXPECT_NE(columnNames.size(), 0);
884 }
885 LOG_INFO("MediaDataShare_ResultSet_Test_002, End");
886 }
887
888 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ResultSet_Test_003, TestSize.Level0)
889 {
890 LOG_INFO("MediaDataShare_ResultSet_Test_003::Start");
891 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
892 ASSERT_TRUE(helper != nullptr);
893 DataShare::DataSharePredicates predicates;
894 predicates.EqualTo("name", "dataShareTest003");
895 vector<string> columns;
896 Uri uri(MEDIALIBRARY_DATA_URI);
897 auto resultSet = helper->Query(uri, predicates, columns);
898 AppDataFwk::SharedBlock *block = nullptr;
899 ASSERT_TRUE(resultSet != nullptr);
900
901 bool hasBlock = resultSet->HasBlock();
902 EXPECT_EQ(hasBlock, true);
903 EXPECT_NE(resultSet->GetBlock(), nullptr);
904 block = (resultSet->GetBlock()).get();
905 resultSet->SetBlock(block);
906 EXPECT_EQ(block, (resultSet->GetBlock()).get());
907 resultSet->FillBlock(0, block);
908 EXPECT_EQ(block, (resultSet->GetBlock()).get());
909 LOG_INFO("MediaDataShare_ResultSet_Test_003, End");
910 }
911
912 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ResultSet_Test_004, TestSize.Level0)
913 {
914 LOG_INFO("MediaDataShare_ResultSet_Test_004::Start");
915 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
916 ASSERT_TRUE(helper != nullptr);
917 DataShare::DataSharePredicates predicates;
918 predicates.Contains("name", "dataShareTest");
919 vector<string> columns;
920 Uri uri(MEDIALIBRARY_DATA_URI);
921 auto resultSet = helper->Query(uri, predicates, columns);
922 if (resultSet != nullptr) {
923 resultSet->GoToFirstRow();
924 bool ok = resultSet->OnGo(0, 1);
925 EXPECT_EQ(ok, true);
926 }
927 LOG_INFO("MediaDataShare_ResultSet_Test_004, End");
928 }
929
930 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ResultSet_Test_005, TestSize.Level0)
931 {
932 LOG_INFO("MediaDataShare_ResultSet_Test_005::Start");
933 DataShare::DataShareResultSet resultSet;
934 std::vector<string> names;
935 int err = resultSet.GetAllColumnNames(names);
936 EXPECT_NE(err, 0);
937 int count;
938 err = resultSet.GetRowCount(count);
939 EXPECT_NE(err, 0);
940 err = resultSet.GoToRow(1);
941 EXPECT_NE(err, 0);
942 std::vector<uint8_t> blob;
943 err = resultSet.GetBlob(0, blob);
944 EXPECT_NE(err, 0);
945 int64_t longValue;
946 err = resultSet.GetLong(0, longValue);
947 EXPECT_NE(err, 0);
948 double doubleValue;
949 err = resultSet.GetDouble(0, doubleValue);
950 EXPECT_NE(err, 0);
951
952 bool isNull;
953 err = resultSet.IsColumnNull(0, isNull);
954 EXPECT_NE(err, 0);
955 bool flag = resultSet.OnGo(0, 1);
956 EXPECT_EQ(flag, false);
957 LOG_INFO("MediaDataShare_ResultSet_Test_005, End");
958 }
959
960 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ResultSet_Test_006, TestSize.Level0)
961 {
962 LOG_INFO("MediaDataShare_ResultSet_Test_006::Start");
963 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
964 ASSERT_TRUE(helper != nullptr);
965 Uri uri(MEDIALIBRARY_DATA_URI);
966 DataShare::DataShareValuesBucket valuesBucket;
967 int value = 1112;
968 valuesBucket.Put("age", value);
969 int retVal = helper->Insert(uri, valuesBucket);
970 EXPECT_EQ((retVal > 0), true);
971
972 DataShare::DataSharePredicates predicates;
973 predicates.EqualTo("age", value);
974 vector<string> columns;
975 auto resultSet = helper->Query(uri, predicates, columns);
976 int columnIndex = 0;
977 int result = 0;
978 ASSERT_TRUE(resultSet != nullptr);
979 resultSet->GoToFirstRow();
980 resultSet->GetColumnIndex("age", columnIndex);
981 DataShare::DataType dt;
982 resultSet->GetDataType(0, dt);
983 EXPECT_EQ(dt, DataShare::DataType::TYPE_INTEGER);
984 resultSet->GetInt(columnIndex, result);
985 EXPECT_EQ(result, value);
986
987 DataShare::DataSharePredicates deletePredicates;
988 deletePredicates.EqualTo("age", 1112);
989 retVal = helper->Delete(uri, deletePredicates);
990 EXPECT_EQ((retVal >= 0), true);
991 LOG_INFO("MediaDataShare_ResultSet_Test_006, End");
992 }
993
994 HWTEST_F(MediaDataShareUnitTest, Creator_IRemoteObjectNull_Test_001, TestSize.Level0)
995 {
996 LOG_INFO("Creator_IRemoteObjectNull_Test_001::Start");
997 sptr<IRemoteObject> remoteObjNull = nullptr;
998 auto remoteNull = DataShare::DataShareHelper::Creator(remoteObjNull, MEDIALIBRARY_DATA_URI);
999 EXPECT_EQ(remoteNull, nullptr);
1000 LOG_INFO("Creator_IRemoteObjectNull_Test_001 End");
1001 }
1002
1003 HWTEST_F(MediaDataShareUnitTest, Creator_UriError_Test_001, TestSize.Level0)
1004 {
1005 LOG_INFO("Creator_UriError_Test_001::Start");
1006 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1007 EXPECT_NE(saManager, nullptr);
1008 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
1009 EXPECT_NE(remoteObj, nullptr);
1010 auto uriError = DataShare::DataShareHelper::Creator(remoteObj, MEDIALIBRARY_DATA_URI_ERROR);
1011 EXPECT_EQ(uriError, nullptr);
1012 LOG_INFO("Creator_UriError_Test_001 End");
1013 }
1014
1015 HWTEST_F(MediaDataShareUnitTest, Insert_ConnectionNull_Test_001, TestSize.Level0)
1016 {
1017 LOG_INFO("Insert_ConnectionNull_Test_001::Start");
1018 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1019 ASSERT_TRUE(helper != nullptr);
1020 auto ret = helper->Release();
1021 EXPECT_TRUE(ret);
1022 Uri uri(MEDIALIBRARY_DATA_URI);
1023 DataShare::DataShareValuesBucket valuesBucket;
1024
1025 valuesBucket.Clear();
1026 double valueD4 = 20.10;
1027 valuesBucket.Put("phoneNumber", valueD4);
1028 valuesBucket.Put("name", "dataShareTest006");
1029 int value4 = 998;
1030 valuesBucket.Put("age", value4);
1031 auto resultInsert = helper->Insert(uri, valuesBucket);
1032 EXPECT_EQ(resultInsert, -1);
1033
1034 auto resultGetType = helper->GetType(uri);
1035 EXPECT_EQ(resultGetType.size(), 0);
1036 valuesBucket.Clear();
1037 LOG_INFO("Insert_ConnectionNull_Test_001 End");
1038 }
1039
1040 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_CRUD_Test_001, TestSize.Level0)
1041 {
1042 LOG_INFO("MediaDataShare_CRUD_Test_001::Start");
1043 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1044 ASSERT_TRUE(helper != nullptr);
1045 Uri uri(MEDIALIBRARY_DATA_URI);
1046 DataShare::DataShareValuesBucket valuesBucket;
1047 valuesBucket.Put("name", "Datashare_CRUD_Test001");
1048 int retVal = helper->Insert(uri, valuesBucket);
1049 EXPECT_EQ((retVal > 0), true);
1050
1051 DataShare::DataSharePredicates predicates;
1052 predicates.EqualTo("name", "Datashare_CRUD_Test001");
1053
1054 valuesBucket.Clear();
1055 valuesBucket.Put("name", "Datashare_CRUD_Test002");
1056 retVal = helper->Update(uri, predicates, valuesBucket);
1057 EXPECT_EQ((retVal >= 0), true);
1058
1059 DataShare::DataSharePredicates queryPredicates;
1060 queryPredicates.EqualTo("name", "Datashare_CRUD_Test002");
1061 vector<string> columns;
1062 auto resultSet = helper->Query(uri, queryPredicates, columns);
1063 int result = 0;
1064 if (resultSet != nullptr) {
1065 resultSet->GetRowCount(result);
1066 }
1067 EXPECT_EQ(result, 1);
1068
1069 DataShare::DataSharePredicates deletePredicates;
1070 deletePredicates.EqualTo("name", "Datashare_CRUD_Test002'");
1071 retVal = helper->Delete(uri, deletePredicates);
1072 EXPECT_EQ((retVal >= 0), true);
1073 LOG_INFO("MediaDataShare_CRUD_Test_001, End");
1074 }
1075
1076 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_CRUDEX_Test_001, TestSize.Level0)
1077 {
1078 LOG_INFO("MediaDataShare_CRUDEX_Test_001::Start");
1079 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1080 ASSERT_TRUE(helper != nullptr);
1081 Uri uri(MEDIALIBRARY_DATA_URI);
1082 DataShare::DataShareValuesBucket valuesBucket;
1083 valuesBucket.Put("name", "Datashare_CRUDEX_Test001");
1084 auto [errCode, retVal] = helper->InsertEx(uri, valuesBucket);
1085 EXPECT_EQ((errCode == 0), true);
1086 EXPECT_EQ((retVal >= 0), true);
1087 DataShare::DataSharePredicates predicates;
1088 predicates.EqualTo("name", "Datashare_CRUDEX_Test001");
1089
1090 valuesBucket.Clear();
1091 valuesBucket.Put("name", "Datashare_CRUDEX_Test002");
1092 auto [errCode1, retVal1] = helper->UpdateEx(uri, predicates, valuesBucket);
1093 EXPECT_EQ((errCode1 == 0), true);
1094 EXPECT_EQ((retVal1 >= 0), true);
1095 DataShare::DataSharePredicates queryPredicates;
1096 queryPredicates.EqualTo("name", "Datashare_CRUDEX_Test002");
1097 vector<string> columns;
1098 auto resultSet = helper->Query(uri, queryPredicates, columns);
1099 int result = 0;
1100 if (resultSet != nullptr) {
1101 resultSet->GetRowCount(result);
1102 }
1103 EXPECT_EQ(result, 1);
1104
1105 DataShare::DataSharePredicates deletePredicates;
1106 deletePredicates.EqualTo("name", "Datashare_CRUDEX_Test002'");
1107 auto [errCode2, retVal2] = helper->DeleteEx(uri, deletePredicates);
1108 EXPECT_EQ((errCode2 == 0), true);
1109 EXPECT_EQ((retVal2 >= 0), true);
1110 LOG_INFO("MediaDataShare_CRUDEX_Test_001, End");
1111 }
1112
1113 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ImplPredicates_Test_001, TestSize.Level0)
1114 {
1115 LOG_INFO("MediaDataShare_ImplPredicates_Test_001::Start");
1116 DataShare::DataSharePredicates predicates;
1117 vector<int> inColumn;
1118 inColumn.push_back(1);
1119 inColumn.push_back(2);
1120 inColumn.push_back(3);
1121 predicates.In("name", inColumn);
1122
1123 std::vector<DataShare::OperationItem> operationItems = predicates.GetOperationList();
1124 std::string str = std::get<string>(operationItems[0].singleParams[0]);
1125 std::vector<int> ret = std::get<std::vector<int>>(operationItems[0].multiParams[0]);
1126 EXPECT_EQ(operationItems.size(), 1);
1127 // index of variant, 3 is string
1128 EXPECT_EQ(operationItems[0].singleParams[0].index(), 3);
1129 EXPECT_EQ(str, "name");
1130 EXPECT_EQ(operationItems[0].multiParams[0].index(), 1);
1131 for (int i = 0; i < ret.size(); i++) {
1132 EXPECT_EQ(ret[i], i + 1);
1133 }
1134 operationItems.clear();
1135 LOG_INFO("MediaDataShare_ImplPredicates_Test_001, End");
1136 }
1137
1138 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_NotImplPredicates_Test_001, TestSize.Level0)
1139 {
1140 LOG_INFO("MediaDataShare_NotImplPredicates_Test_001::Start");
1141 DataShare::DataSharePredicates predicates;
1142 vector<string> inColumn;
1143 inColumn.push_back("dataShare_Test_001");
1144 inColumn.push_back("dataShare_Test_002");
1145 predicates.In("name", inColumn);
1146
1147 vector<string> notInColumn;
1148 notInColumn.push_back("dataShare_Test_003");
1149 notInColumn.push_back("dataShare_Test_004");
1150 predicates.NotIn("name", notInColumn);
1151 predicates.Unlike("name", "%Test003");
1152
1153 vector<string> preV;
1154 preV.push_back("name");
1155 predicates.GroupBy(preV);
1156 predicates.Distinct();
1157 predicates.IndexedBy("name");
1158 predicates.KeyPrefix("%Test");
1159 predicates.InKeys(preV);
1160
1161 std::vector<DataShare::OperationItem> operationItems = predicates.GetOperationList();
1162 EXPECT_EQ(operationItems.size(), 8);
1163 LOG_INFO("MediaDataShare_NotImplPredicates_Test_001, End");
1164 }
1165
1166 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Observer_001, TestSize.Level0)
1167 {
1168 LOG_INFO("MediaDataShare_Observer_001 start");
1169 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1170 ASSERT_TRUE(helper != nullptr);
1171 Uri uri(MEDIALIBRARY_DATA_URI);
1172 sptr<IDataAbilityObserverTest> dataObserver;
1173 helper->RegisterObserver(uri, dataObserver);
1174
1175 DataShare::DataShareValuesBucket valuesBucket;
1176 valuesBucket.Put("name", "Datashare_Observer_Test001");
1177 int retVal = helper->Insert(uri, valuesBucket);
1178 EXPECT_EQ((retVal > 0), true);
1179 helper->NotifyChange(uri);
1180
1181 DataShare::DataSharePredicates deletePredicates;
1182 deletePredicates.EqualTo("name", "Datashare_Observer_Test001");
1183 retVal = helper->Delete(uri, deletePredicates);
1184 EXPECT_EQ((retVal >= 0), true);
1185 helper->NotifyChange(uri);
1186 helper->UnregisterObserver(uri, dataObserver);
1187 LOG_INFO("MediaDataShare_Observer_001 end");
1188 }
1189
1190 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ObserverExt_001, TestSize.Level0)
1191 {
1192 LOG_INFO("MediaDataShare_ObserverExt_001 start");
1193 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1194 ASSERT_TRUE(helper != nullptr);
1195 Uri uri(MEDIALIBRARY_DATA_URI);
1196 std::shared_ptr<DataShareObserverTest> dataObserver = std::make_shared<DataShareObserverTest>();
1197 helper->RegisterObserverExt(uri, dataObserver, true);
1198 DataShare::DataShareValuesBucket valuesBucket;
1199 valuesBucket.Put("name", "Datashare_Observer_Test001");
1200 int retVal = helper->Insert(uri, valuesBucket);
1201 EXPECT_EQ((retVal > 0), true);
1202 ChangeInfo uriChanges = { DataShareObserver::ChangeType::INSERT, { uri } };
1203 helper->NotifyChangeExt(uriChanges);
1204
1205 dataObserver->data.Wait();
1206 EXPECT_TRUE(ChangeInfoEqual(dataObserver->changeInfo_, uriChanges));
1207 dataObserver->Clear();
1208
1209 Uri descendantsUri(MEDIALIBRARY_DATA_URI + "/com.ohos.example");
1210 helper->Insert(descendantsUri, valuesBucket);
1211 EXPECT_EQ((retVal > 0), true);
1212 ChangeInfo descendantsChanges = { DataShareObserver::ChangeType::INSERT, { descendantsUri } };
1213 helper->NotifyChangeExt(descendantsChanges);
1214
1215 dataObserver->data.Wait();
1216 EXPECT_TRUE(ChangeInfoEqual(dataObserver->changeInfo_, descendantsChanges));
1217 dataObserver->Clear();
1218
1219 DataShare::DataSharePredicates deletePredicates;
1220 deletePredicates.EqualTo("name", "Datashare_Observer_Test001");
1221 retVal = helper->Delete(uri, deletePredicates);
1222 EXPECT_EQ((retVal >= 0), true);
1223 char data[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
1224 ChangeInfo delChanges = { DataShareObserver::ChangeType::DELETE, { uri }, data, sizeof(data) / sizeof(data[0]) };
1225 helper->NotifyChangeExt(delChanges);
1226
1227 dataObserver->data.Wait();
1228 EXPECT_TRUE(ChangeInfoEqual(dataObserver->changeInfo_, delChanges));
1229 dataObserver->Clear();
1230
1231 helper->UnregisterObserverExt(uri, dataObserver);
1232 LOG_INFO("MediaDataShare_ObserverExt_001 end");
1233 }
1234
1235 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_UnregisterObserverExt_001, TestSize.Level0)
1236 {
1237 LOG_INFO("MediaDataShare_UnregisterObserverExt_001 start");
1238 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1239 ASSERT_TRUE(helper != nullptr);
1240 Uri uri(MEDIALIBRARY_DATA_URI);
1241 std::shared_ptr<DataShareObserverTest> dataObserver = std::make_shared<DataShareObserverTest>();
1242 helper->RegisterObserverExt(uri, dataObserver, true);
1243
1244 DataShare::DataShareValuesBucket valuesBucket;
1245 valuesBucket.Put("name", "Datashare_Observer_Test001");
1246 int retVal = helper->Insert(uri, valuesBucket);
1247 EXPECT_EQ((retVal > 0), true);
1248 ChangeInfo uriChanges = { DataShareObserver::ChangeType::INSERT, { uri } };
1249 helper->NotifyChangeExt(uriChanges);
1250
1251 dataObserver->data.Wait();
1252 EXPECT_TRUE(ChangeInfoEqual(dataObserver->changeInfo_, uriChanges));
1253 dataObserver->Clear();
1254
1255 helper->UnregisterObserverExt(uri, dataObserver);
1256 helper->NotifyChangeExt({ DataShareObserver::ChangeType::DELETE, { uri } });
1257
1258 dataObserver->data.Wait();
1259 EXPECT_FALSE(ChangeInfoEqual(dataObserver->changeInfo_, uriChanges));
1260 dataObserver->Clear();
1261 LOG_INFO("MediaDataShare_UnregisterObserverExt_001 end");
1262 }
1263
1264 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ToAbsSharedResultSet_Test_001, TestSize.Level0)
1265 {
1266 LOG_INFO("MediaDataShare_ToAbsSharedResultSet_Test_001::Start");
1267 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1268 DataShare::DataSharePredicates predicates;
1269 predicates.EqualTo("name", "dataShareTest003");
1270 vector<string> columns;
1271 Uri uri(MEDIALIBRARY_DATA_URI);
1272 auto resultSet = helper->Query(uri, predicates, columns);
1273 std::shared_ptr<NativeRdb::AbsSharedResultSet> absSharedResultSet =
1274 RdbDataAbilityAdapter::RdbDataAbilityUtils::ToAbsSharedResultSet(resultSet);
1275 int rowCount = 0;
1276 if (absSharedResultSet != nullptr) {
1277 absSharedResultSet->GetRowCount(rowCount);
1278 }
1279 EXPECT_EQ(rowCount, 1);
1280 LOG_INFO("MediaDataShare_ToAbsSharedResultSet_Test_001 End");
1281 }
1282
1283 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ExecuteBatch_Test_001, TestSize.Level0)
1284 {
1285 LOG_INFO("MediaDataShare_ExecuteBatch_Test_001::Start");
1286 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1287
1288 std::vector<DataShare::OperationStatement> statements;
1289 DataShare::OperationStatement statement1;
1290 statement1.operationType = Operation::INSERT;
1291 statement1.uri = "datashare:///uri1";
1292 DataShare::DataShareValuesBucket valuesBucket;
1293 valuesBucket.Put("DB_NUM", 150);
1294 valuesBucket.Put("DB_TITLE", "ExecuteBatch_Test002");
1295 statement1.valuesBucket = valuesBucket;
1296 DataShare::DataSharePredicates predicates;
1297 predicates.SetWhereClause("`DB_NUM` > 100");
1298 statement1.predicates = predicates;
1299 statements.emplace_back(statement1);
1300
1301 DataShare::OperationStatement statement2;
1302 statement2.operationType = Operation::DELETE;
1303 statement2.uri = "datashareproxy://com.uri2";
1304 DataShare::DataShareValuesBucket valuesBucket1;
1305 valuesBucket1.Put("DB_TITLE2", "ExecuteBatch_Test002");
1306 statement2.valuesBucket = valuesBucket1;
1307 DataShare::DataSharePredicates predicates1;
1308 predicates1.SetWhereClause("`DB_TITLE` = ExecuteBatch_Test002");
1309 statement2.predicates = predicates1;
1310 statements.emplace_back(statement2);
1311
1312 DataShare::ExecResultSet resultSet;
1313 auto ret = helper->ExecuteBatch(statements, resultSet);
1314 EXPECT_EQ(ret, 0);
1315 LOG_INFO("MediaDataShare_ExecuteBatch_Test_001 End");
1316 }
1317
1318 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_InsertExt_Test_001, TestSize.Level0)
1319 {
1320 LOG_INFO("MediaDataShare_InsertExt_Test_001::Start");
1321 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1322 ASSERT_TRUE(helper != nullptr);
1323 Uri uri(MEDIALIBRARY_DATA_URI);
1324 DataShare::DataShareValuesBucket valuesBucket;
1325 valuesBucket.Put("name", "Datashare_CRUD_Test001");
1326 std::string str;
1327 int ret = helper->InsertExt(uri, valuesBucket, str);
1328 EXPECT_EQ(ret, 0);
1329 LOG_INFO("MediaDataShare_InsertExt_Test_001 End");
1330 }
1331
1332 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_TransferUri_Test_001, TestSize.Level0)
1333 {
1334 LOG_INFO("MediaDataShare_TransferUri_Test_001::Start");
1335 Uri uri(FILE_DATA_URI);
1336
1337 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1338 EXPECT_NE(saManager, nullptr);
1339 if (saManager == nullptr) {
1340 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
1341 }
1342 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
1343 EXPECT_NE(remoteObj, nullptr);
1344 if (remoteObj == nullptr) {
1345 LOG_ERROR("GetSystemAbility service failed.");
1346 }
1347 std::shared_ptr<DataShare::DataShareHelper> helper = DataShare::DataShareHelper::Creator(remoteObj, FILE_DATA_URI);
1348 EXPECT_NE(helper, nullptr);
1349 LOG_INFO("MediaDataShare_TransferUri_Test_001 End");
1350 }
1351
1352 HWTEST_F(MediaDataShareUnitTest, ControllerTest_HelperInsertExtControllerNullTest_001, TestSize.Level0)
1353 {
1354 LOG_INFO("ControllerTest_HelperInsertExtControllerNullTest_001::Start");
1355 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1356 ASSERT_TRUE(helper != nullptr);
1357 Uri uri(DATA_SHARE_URI);
1358 helper->Release();
1359 DataShare::DataShareValuesBucket valuesBucket;
1360 double valueD1 = 20.07;
1361 valuesBucket.Put("phoneNumber", valueD1);
1362 valuesBucket.Put("name", "dataShareTest003");
1363 int value1 = 1001;
1364 valuesBucket.Put("age", value1);
1365 std::string result;
1366 int retVal = helper->InsertExt(uri, valuesBucket, result);
1367 EXPECT_EQ((retVal < 0), true);
1368 LOG_INFO("ControllerTest_HelperInsertExtControllerNullTest_001::End");
1369 }
1370
1371 HWTEST_F(MediaDataShareUnitTest, ControllerTest_HelperUpdateControllerNullTest_001, TestSize.Level0)
1372 {
1373 LOG_INFO("ControllerTest_HelperUpdateControllerNullTest_001::Start");
1374 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1375 ASSERT_TRUE(helper != nullptr);
1376 Uri uri(DATA_SHARE_URI);
1377 helper->Release();
1378 DataShare::DataSharePredicates predicates;
1379 predicates.EqualTo("name", "Datashare_CRUD_Test001");
1380 DataShare::DataShareValuesBucket valuesBucket;
1381 valuesBucket.Put("name", "Datashare_CRUD_Test002");
1382 int retVal = helper->Update(uri, predicates, valuesBucket);
1383 EXPECT_EQ((retVal < 0), true);
1384 LOG_INFO("ControllerTest_HelperUpdateControllerNullTest_001::End");
1385 }
1386
1387 HWTEST_F(MediaDataShareUnitTest, ControllerTest_HelperDeleteControllerNullTest_001, TestSize.Level0)
1388 {
1389 LOG_INFO("ControllerTest_HelperDeleteControllerNullTest_001::Start");
1390 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1391 ASSERT_TRUE(helper != nullptr);
1392 Uri uri(DATA_SHARE_URI);
1393 helper->Release();
1394 DataShare::DataSharePredicates deletePredicates;
1395 deletePredicates.EqualTo("age", 1112);
1396 int retVal = helper->Delete(uri, deletePredicates);
1397 EXPECT_EQ((retVal < 0), true);
1398 LOG_INFO("ControllerTest_HelperDeleteControllerNullTest_001::End");
1399 }
1400
1401 HWTEST_F(MediaDataShareUnitTest, ControllerTest_HelperQueryControllerNullTest_001, TestSize.Level0)
1402 {
1403 LOG_INFO("ControllerTest_HelperQueryControllerNullTest_001::Start");
1404 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1405 ASSERT_TRUE(helper != nullptr);
1406 Uri uri(DATA_SHARE_URI);
1407 helper->Release();
1408 DataShare::DataSharePredicates predicates;
1409 predicates.EqualTo("name", "dataShareTest003");
1410 predicates.Limit(1, 0);
1411 vector<string> columns;
1412 auto resultSet = helper->Query(uri, predicates, columns);
1413 EXPECT_EQ(resultSet, nullptr);
1414 LOG_INFO("ControllerTest_HelperQueryControllerNullTest_001::End");
1415 }
1416
1417 HWTEST_F(MediaDataShareUnitTest, ControllerTest_HelperBatchInsertControllerNullTest_001, TestSize.Level0)
1418 {
1419 LOG_INFO("ControllerTest_HelperBatchInsertControllerNullTest_001::Start");
1420 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1421 ASSERT_TRUE(helper != nullptr);
1422 Uri uri(DATA_SHARE_URI);
1423 helper->Release();
1424 DataShare::DataShareValuesBucket valuesBucket1;
1425 valuesBucket1.Put("name", "dataShareTest006");
1426 valuesBucket1.Put("phoneNumber", 20.6);
1427 DataShare::DataShareValuesBucket valuesBucket2;
1428 valuesBucket2.Put("name", "dataShareTest007");
1429 valuesBucket2.Put("phoneNumber", 20.5);
1430 std::vector<DataShare::DataShareValuesBucket> values;
1431 values.push_back(valuesBucket1);
1432 values.push_back(valuesBucket2);
1433 int result = helper->BatchInsert(uri, values);
1434 EXPECT_EQ((result < 0), true);
1435 LOG_INFO("ControllerTest_HelperBatchInsertControllerNullTest_001::End");
1436 }
1437
1438 HWTEST_F(MediaDataShareUnitTest, ControllerTest_HelperExecuteBatchControllerNullTest_001, TestSize.Level0)
1439 {
1440 LOG_INFO("ControllerTest_HelperExecuteBatchControllerNullTest_001::Start");
1441 auto helper= CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1442 ASSERT_TRUE(helper != nullptr);
1443 Uri uri(DATA_SHARE_URI);
1444 helper->Release();
1445 std::vector<DataShare::OperationStatement> statements;
1446 DataShare::OperationStatement statement1;
1447 statement1.operationType = Operation::INSERT;
1448 statement1.uri = "datashare:///uri1";
1449 DataShare::DataShareValuesBucket valuesBucket;
1450 valuesBucket.Put("DB_NUM", 150);
1451 valuesBucket.Put("DB_TITLE", "ExecuteBatch_Test002");
1452 statement1.valuesBucket = valuesBucket;
1453 DataShare::DataSharePredicates predicates;
1454 predicates.SetWhereClause("`DB_NUM` > 100");
1455 statement1.predicates = predicates;
1456 statements.emplace_back(statement1);
1457
1458 DataShare::OperationStatement statement2;
1459 statement2.operationType = Operation::DELETE;
1460 statement2.uri = "datashareproxy://com.uri2";
1461 DataShare::DataShareValuesBucket valuesBucket1;
1462 valuesBucket1.Put("DB_TITLE2", "ExecuteBatch_Test002");
1463 statement2.valuesBucket = valuesBucket1;
1464 DataShare::DataSharePredicates predicates1;
1465 predicates1.SetWhereClause("`DB_TITLE` = ExecuteBatch_Test002");
1466 statement2.predicates = predicates1;
1467 statements.emplace_back(statement2);
1468
1469 DataShare::ExecResultSet resultSet;
1470 auto ret = helper->ExecuteBatch(statements, resultSet);
1471 EXPECT_EQ((ret < 0), true);
1472 LOG_INFO("ControllerTest_HelperExecuteBatchControllerNullTest_001::End");
1473 }
1474
1475 HWTEST_F(MediaDataShareUnitTest, ControllerTest_HelperRegisterObserverControllerNullTest_001, TestSize.Level0)
1476 {
1477 LOG_INFO("ControllerTest_HelperRegisterObserverControllerNullTest_001 start");
1478 auto helper= CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1479 ASSERT_TRUE(helper != nullptr);
1480 Uri uri(MEDIALIBRARY_DATA_URI);
1481 helper->Release();
1482 sptr<IDataAbilityObserverTest> dataObserver;
1483 helper->RegisterObserver(uri, dataObserver);
1484
1485 DataShare::DataShareValuesBucket valuesBucket;
1486 valuesBucket.Put("name", "Datashare_Observer_Test001");
1487 int retVal = helper->Insert(uri, valuesBucket);
1488 EXPECT_EQ((retVal < 0), true);
1489 helper->NotifyChange(uri);
1490
1491 DataShare::DataSharePredicates deletePredicates;
1492 deletePredicates.EqualTo("name", "Datashare_Observer_Test001");
1493 retVal = helper->Delete(uri, deletePredicates);
1494 EXPECT_EQ((retVal < 0), true);
1495 helper->NotifyChange(uri);
1496 helper->UnregisterObserver(uri, dataObserver);
1497 LOG_INFO("ControllerTest_HelperRegisterObserverControllerNullTest_001 end");
1498 }
1499
1500 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ObserverExt_002, TestSize.Level0)
1501 {
1502 LOG_INFO("MediaDataShare_ObserverExt_002 start");
1503 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1504 ASSERT_TRUE(helper != nullptr);
1505 Uri uri(MEDIALIBRARY_DATA_URI);
1506 std::shared_ptr<DataShareObserverTest> dataObserver = std::make_shared<DataShareObserverTest>();
1507 helper->RegisterObserverExt(uri, dataObserver, false);
1508 DataShare::DataShareValuesBucket valuesBucket1;
1509 DataShare::DataShareValuesBucket valuesBucket2;
1510 valuesBucket1.Put("name", "Datashare_Observer_Test001");
1511 valuesBucket2.Put("name", "Datashare_Observer_Test002");
1512 std::vector<DataShareValuesBucket> VBuckets = {valuesBucket1, valuesBucket2};
1513 int retVal = helper->BatchInsert(uri, VBuckets);
1514 EXPECT_EQ((retVal > 0), true);
1515 DataShareObserver::ChangeInfo::VBuckets extends;
1516 extends = ValueProxy::Convert(std::move(VBuckets));
1517 ChangeInfo uriChanges = { DataShareObserver::ChangeType::INSERT, { uri }, nullptr, 0, extends};
1518 helper->NotifyChangeExt(uriChanges);
1519
1520 dataObserver->data.Wait();
1521 EXPECT_TRUE(ChangeInfoEqual(dataObserver->changeInfo_, uriChanges));
1522 dataObserver->Clear();
1523
1524 helper->UnregisterObserverExt(uri, dataObserver);
1525 LOG_INFO("MediaDataShare_ObserverExt_002 end");
1526 }
1527
1528 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ObserverExt_003, TestSize.Level0)
1529 {
1530 LOG_INFO("MediaDataShare_ObserverExt_003 start");
1531 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1532 ASSERT_TRUE(helper != nullptr);
1533 Uri uri(MEDIALIBRARY_DATA_URI);
1534 std::shared_ptr<DataShareObserverTest> dataObserver = std::make_shared<DataShareObserverTest>();
1535 helper->RegisterObserverExt(uri, dataObserver, false);
1536 DataShare::DataShareValuesBucket valuesBucket;
1537 valuesBucket.Put("name", "Datashare_Observer_Test003");
1538 std::vector<DataShareValuesBucket> VBuckets = {valuesBucket};
1539 DataShare::DataSharePredicates predicates;
1540 predicates.EqualTo("name", "Datashare_Observer_Test002");
1541 int retVal = helper->Update(uri, predicates, valuesBucket);
1542 EXPECT_EQ((retVal > 0), true);
1543 DataShareObserver::ChangeInfo::VBuckets extends;
1544 extends = ValueProxy::Convert(std::move(VBuckets));
1545 ChangeInfo uriChanges = { DataShareObserver::ChangeType::UPDATE, { uri }, nullptr, 0, extends};
1546 helper->NotifyChangeExt(uriChanges);
1547
1548 dataObserver->data.Wait();
1549 EXPECT_TRUE(ChangeInfoEqual(dataObserver->changeInfo_, uriChanges));
1550 dataObserver->Clear();
1551
1552 helper->UnregisterObserverExt(uri, dataObserver);
1553 LOG_INFO("MediaDataShare_ObserverExt_003 end");
1554 }
1555
1556 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ObserverExt_004, TestSize.Level0)
1557 {
1558 LOG_INFO("MediaDataShare_ObserverExt_004 start");
1559 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1560 ASSERT_TRUE(helper != nullptr);
1561 Uri uri(MEDIALIBRARY_DATA_URI);
1562 std::shared_ptr<DataShareObserverTest> dataObserver = std::make_shared<DataShareObserverTest>();
1563 helper->RegisterObserverExt(uri, dataObserver, false);
1564 DataShare::DataShareValuesBucket valuesBucket;
1565 valuesBucket.Put("name", "Datashare_Observer_Test003");
1566 std::vector<DataShareValuesBucket> VBuckets = {valuesBucket};
1567 DataShare::DataSharePredicates predicates;
1568 predicates.EqualTo("name", "Datashare_Observer_Test003");
1569 int retVal = helper->Delete(uri, predicates);
1570 EXPECT_EQ((retVal > 0), true);
1571 DataShareObserver::ChangeInfo::VBuckets extends;
1572 extends = ValueProxy::Convert(std::move(VBuckets));
1573 ChangeInfo uriChanges = { DataShareObserver::ChangeType::DELETE, { uri }, nullptr, 0, extends};
1574 helper->NotifyChangeExt(uriChanges);
1575
1576 dataObserver->data.Wait();
1577 EXPECT_TRUE(ChangeInfoEqual(dataObserver->changeInfo_, uriChanges));
1578 dataObserver->Clear();
1579
1580 helper->UnregisterObserverExt(uri, dataObserver);
1581 LOG_INFO("MediaDataShare_ObserverExt_004 end");
1582 }
1583
1584 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_UnregisterObserverExt_002, TestSize.Level0)
1585 {
1586 LOG_INFO("MediaDataShare_UnregisterObserverExt_002 start");
1587 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1588 ASSERT_TRUE(helper != nullptr);
1589 Uri uri(MEDIALIBRARY_DATA_URI);
1590 std::shared_ptr<DataShareObserverTest> dataObserver = std::make_shared<DataShareObserverTest>();
1591 helper->RegisterObserverExt(uri, dataObserver, true);
1592
1593 DataShare::DataShareValuesBucket valuesBucket;
1594 valuesBucket.Put("name", "Datashare_Observer_Test003");
1595 int retVal = helper->Insert(uri, valuesBucket);
1596 EXPECT_EQ((retVal > 0), true);
1597 std::vector<DataShareValuesBucket> Buckets = {valuesBucket};
1598 DataShareObserver::ChangeInfo::VBuckets extends;
1599 extends = ValueProxy::Convert(std::move(Buckets));
1600 ChangeInfo uriChanges = { DataShareObserver::ChangeType::INSERT, { uri }, nullptr, 0, extends};
1601 helper->NotifyChangeExt(uriChanges);
1602
1603 dataObserver->data.Wait();
1604 EXPECT_TRUE(ChangeInfoEqual(dataObserver->changeInfo_, uriChanges));
1605 dataObserver->Clear();
1606
1607 helper->UnregisterObserverExt(uri, dataObserver);
1608 helper->NotifyChangeExt({ DataShareObserver::ChangeType::DELETE, { uri }, nullptr, 0, extends });
1609
1610 dataObserver->data.Wait();
1611 EXPECT_FALSE(ChangeInfoEqual(dataObserver->changeInfo_, uriChanges));
1612 dataObserver->Clear();
1613 LOG_INFO("MediaDataShare_UnregisterObserverExt_002 end");
1614 }
1615
1616 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_BatchUpdate_Test_001, TestSize.Level0)
1617 {
1618 LOG_INFO("MediaDataShare_BatchUpdate_Test_001::Start");
1619 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1620 ASSERT_TRUE(helper != nullptr);
1621 Uri uri(MEDIALIBRARY_DATA_URI);
1622 DataShare::DataShareValuesBucket valuesBucket;
1623 valuesBucket.Put("name", "batchUpdateTest");
1624 int ret = helper->Insert(uri, valuesBucket);
1625 EXPECT_GT(ret, 0);
1626
1627 DataShare::UpdateOperations operations;
1628 std::vector<DataShare::UpdateOperation> updateOperations1;
1629 DataShare::UpdateOperation updateOperation1;
1630 updateOperation1.valuesBucket.Put("name", "batchUpdateTested");
1631 updateOperation1.predicates.EqualTo("name", "batchUpdateTest");
1632 updateOperations1.push_back(updateOperation1);
1633
1634 std::vector<DataShare::UpdateOperation> updateOperations2;
1635 DataShare::UpdateOperation updateOperation2;
1636 updateOperation2.valuesBucket.Put("name", "undefined1");
1637 updateOperation2.predicates.EqualTo("name", "undefined");
1638 updateOperations1.push_back(updateOperation2);
1639 updateOperations2.push_back(updateOperation2);
1640
1641 operations.emplace("uri1", updateOperations1);
1642 operations.emplace("uri2", updateOperations2);
1643 std::vector<BatchUpdateResult> results;
1644 ret = helper->BatchUpdate(operations, results);
1645 EXPECT_EQ(results.size(), 2);
1646 EXPECT_EQ(results[0].codes[0], 1);
1647 EXPECT_EQ(results[0].codes[1], 0);
1648 EXPECT_EQ(results[1].codes[0], 0);
1649 DataShare::DataSharePredicates predicates3;
1650 predicates3.EqualTo("name", "batchUpdateTested");
1651 ret = helper->Delete(uri, predicates3);
1652 EXPECT_GT(ret, 0);
1653 LOG_INFO("MediaDataShare_BatchUpdate_Test_001 End");
1654 }
1655
1656 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_BatchUpdateThanLimit_Test_001, TestSize.Level0)
1657 {
1658 LOG_INFO("MediaDataShare_BatchUpdateThanLimit_Test_001::Start");
1659 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
1660 ASSERT_TRUE(helper != nullptr);
1661 Uri uri(MEDIALIBRARY_DATA_URI);
1662
1663 DataShare::UpdateOperations operations;
1664 std::vector<DataShare::UpdateOperation> updateOperations1;
1665 DataShare::UpdateOperation updateOperation1;
1666 updateOperation1.valuesBucket.Put("name", "batchUpdateTested");
1667 updateOperation1.predicates.EqualTo("name", "batchUpdateTest");
1668 for (int i = 0; i < 4001; i++) {
1669 updateOperations1.push_back(updateOperation1);
1670 }
1671 operations.emplace("uri1", updateOperations1);
1672 std::vector<BatchUpdateResult> results;
1673 int ret = helper->BatchUpdate(operations, results);
1674 EXPECT_EQ(ret, -1);
1675 EXPECT_EQ(results.size(), 0);
1676 LOG_INFO("MediaDataShare_BatchUpdateThanLimit_Test_001 End");
1677 }
1678
OnChangeCallback(const RdbChangeNode & changeNode)1679 void OnChangeCallback(const RdbChangeNode &changeNode)
1680 {
1681 // In test, put 2 uris into the data vec
1682 int vecLen = 2;
1683 EXPECT_EQ(changeNode.data_.size(), vecLen);
1684 for (int i = 0; i < vecLen; i++) {
1685 EXPECT_EQ(changeNode.data_[i], DATA_SHARE_URI);
1686 }
1687 }
1688
PrepareNodeContent(RdbChangeNode & node)1689 void PrepareNodeContent(RdbChangeNode &node)
1690 {
1691 OHOS::sptr<Ashmem> memory = Ashmem::CreateAshmem("PrepareNodeContent", DATA_SIZE_ASHMEM_TRANSFER_LIMIT);
1692 EXPECT_NE(memory, nullptr);
1693 bool mapRet = memory->MapReadAndWriteAshmem();
1694 ASSERT_TRUE(mapRet);
1695 // write 2 uris
1696 int vecLen = 2;
1697 int intByteLen = 4;
1698 int offset = 0;
1699 bool writeRet = memory->WriteToAshmem((void*)&vecLen, intByteLen, offset);
1700 ASSERT_TRUE(writeRet);
1701 offset += intByteLen;
1702 int len = DATA_SHARE_URI.length();
1703 const char *str = DATA_SHARE_URI.c_str();
1704 for (int i = 0; i < vecLen; i++) {
1705 writeRet = memory->WriteToAshmem((void*)&len, intByteLen, offset);
1706 ASSERT_TRUE(writeRet);
1707 offset += intByteLen;
1708 writeRet = memory->WriteToAshmem((void*)str, len, offset);
1709 ASSERT_TRUE(writeRet);
1710 offset += len;
1711 }
1712 node.memory_ = memory;
1713 node.size_ = offset;
1714 node.isSharedMemory_ = true;
1715 }
1716
1717 /**
1718 * @tc.name: ReadAshmem
1719 * @tc.desc: test ReadAshmem function.
1720 * @tc.type: FUNC
1721 * @tc.require:
1722 */
1723 HWTEST_F(MediaDataShareUnitTest, ReadAshmem, TestSize.Level1)
1724 {
1725 LOG_INFO("ReadAshmem starts");
1726 RdbChangeNode node;
1727
1728 OHOS::sptr<Ashmem> memory = Ashmem::CreateAshmem("ReadAshmem", DATA_SIZE_ASHMEM_TRANSFER_LIMIT);
1729 EXPECT_NE(memory, nullptr);
1730 bool mapRet = memory->MapReadAndWriteAshmem();
1731 ASSERT_TRUE(mapRet);
1732 int len = DATA_SHARE_URI.length();
1733 bool writeRet = memory->WriteToAshmem((void*)&len, 4, 0);
1734 ASSERT_TRUE(writeRet);
1735 const char *str = DATA_SHARE_URI.c_str();
1736 writeRet = memory->WriteToAshmem((void*)str, len, 4);
1737 ASSERT_TRUE(writeRet);
1738 node.memory_ = memory;
1739
1740 RdbObserverStub stub(OnChangeCallback);
1741 // Read an int
1742 const int *lenRead;
1743 int offset = 0;
1744 int readRet = stub.ReadAshmem(node, (const void**)&lenRead, 4, offset);
1745 EXPECT_EQ(readRet, E_OK);
1746 EXPECT_EQ(offset, 4);
1747 int lenFromAshmem = *lenRead;
1748 EXPECT_EQ(lenFromAshmem, len);
1749 // Read a string
1750 readRet = stub.ReadAshmem(node, (const void**)&str, lenFromAshmem, offset);
1751 EXPECT_EQ(readRet, E_OK);
1752 EXPECT_EQ(offset, 4 + len);
1753 std::string strRead(str, lenFromAshmem);
1754 EXPECT_EQ(strRead, DATA_SHARE_URI);
1755
1756 // Error path test
1757 readRet = stub.ReadAshmem(node, (const void**)&str, DATA_SIZE_ASHMEM_TRANSFER_LIMIT, offset);
1758 EXPECT_EQ(readRet, E_ERROR);
1759 LOG_INFO("ReadAshmem ends");
1760 }
1761
1762 /**
1763 * @tc.name: DeserializeDataFromAshmem001
1764 * @tc.desc: test DeserializeDataFromAshmem function.
1765 * @tc.type: FUNC
1766 * @tc.require:
1767 */
1768 HWTEST_F(MediaDataShareUnitTest, DeserializeDataFromAshmem001, TestSize.Level1)
1769 {
1770 LOG_INFO("DeserializeDataFromAshmem001::Start");
1771 RdbChangeNode node;
1772 PrepareNodeContent(node);
1773
1774 RdbObserverStub stub(OnChangeCallback);
1775 int readRet = stub.DeserializeDataFromAshmem(node);
1776 EXPECT_EQ(readRet, E_OK);
1777 EXPECT_EQ(node.data_.size(), 2);
1778 for (int i = 0; i < 2; i++) {
1779 EXPECT_EQ(node.data_[i], DATA_SHARE_URI);
1780 }
1781 LOG_INFO("DeserializeDataFromAshmem001::End");
1782 }
1783
1784 /**
1785 * @tc.name: DeserializeDataFromAshmem002
1786 * @tc.desc: test DeserializeDataFromAshmem function, error tests.
1787 * @tc.type: FUNC
1788 * @tc.require:
1789 */
1790 HWTEST_F(MediaDataShareUnitTest, DeserializeDataFromAshmem002, TestSize.Level1)
1791 {
1792 LOG_INFO("DeserializeDataFromAshmem002::Start");
1793 RdbChangeNode node;
1794 RdbObserverStub stub(OnChangeCallback);
1795 // memory_ is null.
1796 int ret = stub.DeserializeDataFromAshmem(node);
1797 EXPECT_EQ(ret, E_ERROR);
1798
1799 // Error in read from Ashmem with error string length.
1800 OHOS::sptr<Ashmem> memory = Ashmem::CreateAshmem("DeserializeDataFromAshmem002", DATA_SIZE_ASHMEM_TRANSFER_LIMIT);
1801 EXPECT_NE(memory, nullptr);
1802 bool mapRet = memory->MapReadAndWriteAshmem();
1803 ASSERT_TRUE(mapRet);
1804 int vecLen = 1;
1805 int offset = 0;
1806 bool writeRet = memory->WriteToAshmem((void*)&vecLen, 4, offset);
1807 ASSERT_TRUE(writeRet);
1808 offset += 4;
1809 int len = DATA_SHARE_URI.length();
1810 int errorLen = DATA_SIZE_ASHMEM_TRANSFER_LIMIT;
1811 const char *str = DATA_SHARE_URI.c_str();
1812 writeRet = memory->WriteToAshmem((void*)&errorLen, 4, offset);
1813 ASSERT_TRUE(writeRet);
1814 offset += 4;
1815 writeRet = memory->WriteToAshmem((void*)str, len, offset);
1816 ASSERT_TRUE(writeRet);
1817 node.memory_ = memory;
1818
1819 ret = stub.DeserializeDataFromAshmem(node);
1820 EXPECT_EQ(ret, E_ERROR);
1821
1822 // Error in read from Ashmem with vec size
1823 OHOS::sptr<Ashmem> memory2 = Ashmem::CreateAshmem("DeserializeDataFromAshmem002", 2);
1824 EXPECT_NE(memory2, nullptr);
1825 mapRet = memory2->MapReadAndWriteAshmem();
1826 ASSERT_TRUE(mapRet);
1827 node.memory_ = memory2;
1828 ret = stub.DeserializeDataFromAshmem(node);
1829 EXPECT_EQ(ret, E_ERROR);
1830
1831 // Error in read from Ashmem with str size
1832 OHOS::sptr<Ashmem> memory3 = Ashmem::CreateAshmem("DeserializeDataFromAshmem002", 5);
1833 EXPECT_NE(memory3, nullptr);
1834 mapRet = memory3->MapReadAndWriteAshmem();
1835 ASSERT_TRUE(mapRet);
1836 writeRet = memory3->WriteToAshmem((void*)&vecLen, 4, 0);
1837 ASSERT_TRUE(writeRet);
1838 node.memory_ = memory3;
1839 ret = stub.DeserializeDataFromAshmem(node);
1840 EXPECT_EQ(ret, E_ERROR);
1841 LOG_INFO("DeserializeDataFromAshmem002::End");
1842 }
1843
1844 /**
1845 * @tc.name: RecoverRdbChangeNodeData001
1846 * @tc.desc: test RecoverRdbChangeNodeData function
1847 * @tc.type: FUNC
1848 * @tc.require:
1849 */
1850 HWTEST_F(MediaDataShareUnitTest, RecoverRdbChangeNodeData001, TestSize.Level0)
1851 {
1852 LOG_INFO("RecoverRdbChangeNodeData::Start");
1853
1854 // Recover
1855 RdbChangeNode node;
1856 PrepareNodeContent(node);
1857 RdbObserverStub stub(OnChangeCallback);
1858 int ret = stub.RecoverRdbChangeNodeData(node);
1859 EXPECT_EQ(ret, E_OK);
1860 EXPECT_EQ(node.data_.size(), 2);
1861 for (int i = 0; i < 2; i++) {
1862 EXPECT_EQ(node.data_[i], DATA_SHARE_URI);
1863 }
1864 EXPECT_EQ(node.memory_, nullptr);
1865 EXPECT_EQ(node.size_, 0);
1866 ASSERT_FALSE(node.isSharedMemory_);
1867
1868 // Not recover
1869 RdbChangeNode node2;
1870 PrepareNodeContent(node2);
1871 node2.isSharedMemory_ = false;
1872 ret = stub.RecoverRdbChangeNodeData(node2);
1873 EXPECT_EQ(ret, E_OK);
1874 EXPECT_EQ(node2.data_.size(), 0);
1875 EXPECT_NE(node2.memory_, nullptr);
1876 EXPECT_EQ(node2.size_, 82);
1877 ASSERT_FALSE(node2.isSharedMemory_);
1878
1879 LOG_INFO("RecoverRdbChangeNodeData End");
1880 }
1881
1882 /**
1883 * @tc.name: RecoverRdbChangeNodeData002
1884 * @tc.desc: test RecoverRdbChangeNodeData function with error
1885 * @tc.type: FUNC
1886 * @tc.require:
1887 */
1888 HWTEST_F(MediaDataShareUnitTest, RecoverRdbChangeNodeData002, TestSize.Level0)
1889 {
1890 LOG_INFO("RecoverRdbChangeNodeData002::Start");
1891
1892 RdbChangeNode node;
1893 node.isSharedMemory_ = true;
1894 RdbObserverStub stub(OnChangeCallback);
1895 int ret = stub.RecoverRdbChangeNodeData(node);
1896 EXPECT_EQ(ret, E_ERROR);
1897 EXPECT_EQ(node.data_.size(), 0);
1898 EXPECT_EQ(node.memory_, nullptr);
1899 EXPECT_EQ(node.size_, 0);
1900 ASSERT_FALSE(node.isSharedMemory_);
1901 LOG_INFO("RecoverRdbChangeNodeData002::End");
1902 }
1903
1904 /**
1905 * @tc.name: OnChangeFromRdb001
1906 * @tc.desc: test OnChangeFromRdb function
1907 * @tc.type: FUNC
1908 * @tc.require:
1909 */
1910 HWTEST_F(MediaDataShareUnitTest, OnChangeFromRdb001, TestSize.Level0)
1911 {
1912 LOG_INFO("OnChangeFromRdb001::Start");
1913
1914 RdbChangeNode node;
1915 PrepareNodeContent(node);
1916 RdbObserverStub stub(OnChangeCallback);
1917 stub.OnChangeFromRdb(node);
1918 EXPECT_EQ(node.data_.size(), 2);
1919 for (int i = 0; i < 2; i++) {
1920 EXPECT_EQ(node.data_[i], DATA_SHARE_URI);
1921 }
1922 EXPECT_EQ(node.memory_, nullptr);
1923 EXPECT_EQ(node.size_, 0);
1924 ASSERT_FALSE(node.isSharedMemory_);
1925 LOG_INFO("OnChangeFromRdb001::End");
1926 }
1927
1928 /**
1929 * @tc.name: OnChangeFromRdb002
1930 * @tc.desc: test OnChangeFromRdb function with error
1931 * @tc.type: FUNC
1932 * @tc.require:
1933 */
1934 HWTEST_F(MediaDataShareUnitTest, OnChangeFromRdb002, TestSize.Level0)
1935 {
1936 LOG_INFO("OnChangeFromRdb002::Start");
1937 RdbChangeNode node;
1938 node.isSharedMemory_ = true;
1939 RdbObserverStub stub(OnChangeCallback);
1940 stub.OnChangeFromRdb(node);
1941 EXPECT_EQ(node.data_.size(), 0);
1942 EXPECT_EQ(node.memory_, nullptr);
1943 EXPECT_EQ(node.size_, 0);
1944 ASSERT_FALSE(node.isSharedMemory_);
1945 LOG_INFO("OnChangeFromRdb002::End");
1946 }
1947
1948 /**
1949 * @tc.name: OnremoteRequestTest001
1950 * @tc.desc: test OnRemoteRequest function
1951 * @tc.type: FUNC
1952 * @tc.require:
1953 */
1954 HWTEST_F(MediaDataShareUnitTest, OnremoteRequestTest001, TestSize.Level0)
1955 {
1956 LOG_INFO("OnremoteRequestTest001::Start");
1957 RdbObserverStub stub(OnChangeCallback);
1958 MessageParcel data;
1959 MessageParcel reply;
1960 MessageOption option;
1961 std::u16string descriptorError = u"ERROR";
1962 std::u16string descriptorCorrect = RdbObserverStub::GetDescriptor();
1963 data.WriteInterfaceToken(descriptorError);
1964 std::u16string descriptor;
1965 int ret = stub.OnRemoteRequest(0, data, reply, option);
1966 EXPECT_EQ(ret, ERR_INVALID_STATE);
1967 data.WriteInterfaceToken(descriptorCorrect);
1968 ret = stub.OnRemoteRequest(1, data, reply, option);
1969 EXPECT_EQ(ret, ERR_INVALID_STATE);
1970 data.WriteInterfaceToken(descriptorCorrect);
1971 ret = stub.OnRemoteRequest(0, data, reply, option);
1972 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1973 LOG_INFO("OnremoteRequestTest001::End");
1974 }
1975
1976 /**
1977 * @tc.name: ReadAshmemTest001
1978 * @tc.desc: test ReadAshmem function
1979 * @tc.type: FUNC
1980 * @tc.require:
1981 */
1982 HWTEST_F(MediaDataShareUnitTest, ReadAshmemTest001, TestSize.Level0)
1983 {
1984 LOG_INFO("ReadAshmemTest001::Start");
1985 RdbObserverStub stub(OnChangeCallback);
1986 RdbChangeNode changeNode;
1987 changeNode.memory_ = OHOS::sptr<Ashmem>(nullptr);
1988 const void *data = nullptr;
1989 int size = 0;
1990 int offset;
1991 int ret = stub.ReadAshmem(changeNode, &data, size, offset);
1992 EXPECT_EQ(ret, E_ERROR);
1993 LOG_INFO("ReadAshmemTest001::End");
1994 }
1995
1996 /*
1997 * @tc.desc: test UserDefineFunc with no descriptor
1998 * @tc.require: Null
1999 */
2000 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_User_Define_Func_Test_001, TestSize.Level0)
2001 {
2002 LOG_INFO("MediaDataShare_User_Define_Func_Test_001::Start");
2003 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
2004 MessageParcel data;
2005 MessageParcel reply;
2006 MessageOption option;
2007 auto errCode = helper->UserDefineFunc(data, reply, option);
2008 EXPECT_EQ(errCode, -1);
2009 LOG_INFO("MediaDataShare_User_Define_Func_Test_001 End");
2010 }
2011
2012 /*
2013 * @tc.desc: test UserDefineFunc with descriptor
2014 * @tc.require: Null
2015 */
2016 HWTEST_F(MediaDataShareUnitTest, MediaDataShare_User_Define_Func_Test_002, TestSize.Level0)
2017 {
2018 LOG_INFO("MediaDataShare_User_Define_Func_Test_002::Start");
2019 std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
2020 MessageParcel data;
2021 std::u16string descriptor = u"OHOS.DataShare.IDataShare";
2022 MessageParcel reply;
2023 MessageOption option;
2024 if (data.WriteInterfaceToken(descriptor)) {
2025 auto errCode = helper->UserDefineFunc(data, reply, option);
2026 EXPECT_EQ(errCode, 0);
2027 }
2028 LOG_INFO("MediaDataShare_User_Define_Func_Test_002 End");
2029 }
2030 } // namespace DataShare
2031 } // namespace OHOS