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