1 /*
2  * Copyright (C) 2021-2022 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 #include <gtest/gtest.h>
16 #include <unistd.h>
17 #include <vector>
18 
19 #include "accesstoken_kit.h"
20 #include "data_ability_observer_stub.h"
21 #include "datashare_helper.h"
22 #include "datashare_log.h"
23 #include "hap_token_info.h"
24 #include "iservice_registry.h"
25 #include "system_ability_definition.h"
26 #include "token_setproc.h"
27 
28 namespace OHOS {
29 namespace DataShare {
30 using namespace testing::ext;
31 using namespace OHOS::Security::AccessToken;
32 constexpr int STORAGE_MANAGER_MANAGER_ID = 5003;
33 static int USER_100 = 100;
34 std::string DATA_SHARE_URI = "datashare:///com.acts.datasharetest";
35 std::string SLIENT_ACCESS_URI = "datashare:///com.acts.datasharetest/entry/DB00/TBL00?Proxy=true";
36 std::string SLIENT_ERROR_URI = "datashare:///com.acts.datashare/entry/DB00/TBL00?Proxy=true";
37 std::string SLIENT_REGISTER_URI = "datashare:///com.acts.datasharetest/entry/DB00/TBL02?Proxy=true";
38 std::string SLIENT_ACCESS_PERMISSION1_URI = "datashare:///com.acts.datasharetest/entry/DB00/permission1?Proxy=true";
39 std::string SLIENT_PROXY_PERMISSION1_URI = "datashareproxy://com.acts.datasharetest/entry/DB00/permission1";
40 std::string SLIENT_ACCESS_PERMISSION2_URI = "datashare:///com.acts.datasharetest/entry/DB00/permission2?Proxy=true";
41 std::string SLIENT_PROXY_PERMISSION2_URI = "datashareproxy://com.acts.datasharetest/entry/DB00/permission2";
42 std::string TBL_STU_NAME = "name";
43 std::string TBL_STU_AGE = "age";
44 std::shared_ptr<DataShare::DataShareHelper> g_slientAccessHelper;
45 
46 template <typename T>
47 class ConditionLock {
48 public:
ConditionLock()49     explicit ConditionLock() {}
~ConditionLock()50     ~ConditionLock() {}
51 public:
Notify()52     void Notify()
53     {
54         std::lock_guard<std::mutex> lock(mutex_);
55         isSet_ = true;
56         cv_.notify_one();
57     }
58 
Wait()59     void Wait()
60     {
61         std::unique_lock<std::mutex> lock(mutex_);
62         cv_.wait_for(lock, std::chrono::seconds(INTERVAL), [this]() { return isSet_; });
63         cv_.notify_one();
64         return;
65     }
66 
Clear()67     void Clear()
68     {
69         std::lock_guard<std::mutex> lock(mutex_);
70         isSet_ = false;
71         cv_.notify_one();
72     }
73 
74 private:
75     bool isSet_ = false;
76     T data_;
77     std::mutex mutex_;
78     std::condition_variable cv_;
79     static constexpr int64_t INTERVAL = 2;
80 };
81 
82 class SlientAccessTest : public testing::Test {
83 public:
84     static void SetUpTestCase(void);
85     static void TearDownTestCase(void);
86     void SetUp();
87     void TearDown();
88 };
89 
90 class IDataShareAbilityObserverTest : public AAFwk::DataAbilityObserverStub {
91 public:
92     IDataShareAbilityObserverTest() =  default;
93 
~IDataShareAbilityObserverTest()94     ~IDataShareAbilityObserverTest()
95     {}
96 
OnChange()97     void OnChange()
98     {
99         name = "OnChangeName";
100         data.Notify();
101     }
102 
GetName()103     std::string GetName()
104     {
105         return name;
106     }
107 
SetName(std::string name)108     void SetName(std::string name)
109     {
110         this->name = name;
111     }
112 
Clear()113     void Clear()
114     {
115         data.Clear();
116     }
117     ConditionLock<std::string> data;
118 private:
119     std::string name;
120 };
121 
CreateDataShareHelper(int32_t systemAbilityId,std::string uri)122 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int32_t systemAbilityId, std::string uri)
123 {
124     LOG_INFO("CreateDataShareHelper start");
125     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
126     if (saManager == nullptr) {
127         LOG_ERROR("GetSystemAbilityManager get samgr failed.");
128         return nullptr;
129     }
130     auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
131     if (remoteObj == nullptr) {
132         LOG_ERROR("GetSystemAbility service failed.");
133         return nullptr;
134     }
135     return DataShare::DataShareHelper::Creator(remoteObj, uri);
136 }
137 
GetPermissionStateFulls()138 std::vector<PermissionStateFull> GetPermissionStateFulls()
139 {
140     std::vector<PermissionStateFull> permissionStateFulls = {
141         {
142             .permissionName = "ohos.permission.WRITE_CONTACTS",
143             .isGeneral = true,
144             .resDeviceID = { "local" },
145             .grantStatus = { PermissionState::PERMISSION_GRANTED },
146             .grantFlags = { 1 }
147         },
148         {
149             .permissionName = "ohos.permission.WRITE_CALL_LOG",
150             .isGeneral = true,
151             .resDeviceID = { "local" },
152             .grantStatus = { PermissionState::PERMISSION_GRANTED },
153             .grantFlags = { 1 }
154         },
155         {
156             .permissionName = "ohos.permission.GET_BUNDLE_INFO",
157             .isGeneral = true,
158             .resDeviceID = { "local" },
159             .grantStatus = { PermissionState::PERMISSION_GRANTED },
160             .grantFlags = { 1 }
161         }
162     };
163     return permissionStateFulls;
164 }
165 
SetUpTestCase(void)166 void SlientAccessTest::SetUpTestCase(void)
167 {
168     LOG_INFO("SetUpTestCase invoked");
169     auto dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, DATA_SHARE_URI);
170     ASSERT_TRUE(dataShareHelper != nullptr);
171     int sleepTime = 3;
172     sleep(sleepTime);
173 
174     HapInfoParams info = {
175         .userID = 100,
176         .bundleName = "ohos.datashareclienttest.demo",
177         .instIndex = 0,
178         .appIDDesc = "ohos.datashareclienttest.demo"
179     };
180     auto permStateList = GetPermissionStateFulls();
181     HapPolicyParams policy = {
182         .apl = APL_NORMAL,
183         .domain = "test.domain",
184         .permList = {
185             {
186                 .permissionName = "ohos.permission.test",
187                 .bundleName = "ohos.datashareclienttest.demo",
188                 .grantMode = 1,
189                 .availableLevel = APL_NORMAL,
190                 .label = "label",
191                 .labelId = 1,
192                 .description = "ohos.datashareclienttest.demo",
193                 .descriptionId = 1
194             }
195         },
196         .permStateList = permStateList
197     };
198     AccessTokenKit::AllocHapToken(info, policy);
199     auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
200         info.userID, info.bundleName, info.instIndex);
201     SetSelfTokenID(testTokenId.tokenIDEx);
202 
203     g_slientAccessHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
204     ASSERT_TRUE(g_slientAccessHelper != nullptr);
205     LOG_INFO("SetUpTestCase end");
206 }
207 
TearDownTestCase(void)208 void SlientAccessTest::TearDownTestCase(void)
209 {
210     auto tokenId = AccessTokenKit::GetHapTokenIDEx(100, "ohos.datashareclienttest.demo", 0);
211     AccessTokenKit::DeleteToken(tokenId.tokenIDEx);
212     g_slientAccessHelper = nullptr;
213 }
214 
SetUp(void)215 void SlientAccessTest::SetUp(void) {}
TearDown(void)216 void SlientAccessTest::TearDown(void) {}
217 
218 HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_001, TestSize.Level0)
219 {
220     LOG_INFO("SlientAccess_Creator_Errorcode_Test_001::Start");
221     std::string uriStr1(SLIENT_ACCESS_URI);
222     std::string uriStr2 (DATA_SHARE_URI);
223     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
224     if (saManager == nullptr) {
225         LOG_ERROR("GetSystemAbilityManager get samgr failed.");
226     }
227     auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
228     if (remoteObj == nullptr) {
229         LOG_ERROR("GetSystemAbility service failed.");
230     }
231     auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
232     EXPECT_EQ(ret, DataShare::E_OK);
233     EXPECT_NE(helper, nullptr);
234     helper = nullptr;
235     LOG_INFO("SlientAccess_Creator_Errorcode_Test_001::End");
236 }
237 
238 HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_002, TestSize.Level0)
239 {
240     LOG_INFO("SlientAccess_Creator_Errorcode_Test_002::Start");
241     std::string uriStr1(SLIENT_ACCESS_URI);
242     std::string uriStr2 (DATA_SHARE_URI);
243     auto [ret, helper] = DataShare::DataShareHelper::Create(nullptr, uriStr1, uriStr2);
244     EXPECT_EQ(ret, DataShare::E_TOKEN_EMPTY);
245     EXPECT_EQ(helper, nullptr);
246     LOG_INFO("SlientAccess_Creator_Errorcode_Test_002::End");
247 }
248 
249 HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_003, TestSize.Level0)
250 {
251     LOG_INFO("SlientAccess_Creator_Errorcode_Test_003::Start");
252     std::string uriStr1(SLIENT_ERROR_URI);
253     std::string uriStr2 (DATA_SHARE_URI);
254     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
255     if (saManager == nullptr) {
256         LOG_ERROR("GetSystemAbilityManager get samgr failed.");
257     }
258     auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
259     if (remoteObj == nullptr) {
260         LOG_ERROR("GetSystemAbility service failed.");
261     }
262     auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
263     EXPECT_EQ(ret, DataShare::E_BUNDLE_NAME_NOT_EXIST);
264     EXPECT_EQ(helper, nullptr);
265     helper = nullptr;
266     LOG_INFO("SlientAccess_Creator_Errorcode_Test_003::End");
267 }
268 
269 HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_004, TestSize.Level0)
270 {
271     LOG_INFO("SlientAccess_Creator_Errorcode_Test_004::Start");
272     std::string uriStr1(DATA_SHARE_URI);
273     std::string uriStr2 (DATA_SHARE_URI);
274     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
275     if (saManager == nullptr) {
276         LOG_ERROR("GetSystemAbilityManager get samgr failed.");
277     }
278     auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
279     if (remoteObj == nullptr) {
280         LOG_ERROR("GetSystemAbility service failed.");
281     }
282     auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
283     EXPECT_EQ(ret, DataShare::E_OK);
284     EXPECT_NE(helper, nullptr);
285     helper = nullptr;
286     LOG_INFO("SlientAccess_Creator_Errorcode_Test_004::End");
287 }
288 
289 HWTEST_F(SlientAccessTest, SlientAccess_InsertEx_Test_001, TestSize.Level0)
290 {
291     LOG_INFO("SlientAccess_InsertEx_Test_001::Start");
292     auto helper = g_slientAccessHelper;
293     Uri uri(SLIENT_ACCESS_URI);
294     DataShare::DataShareValuesBucket valuesBucket;
295     std::string value = "lisi";
296     valuesBucket.Put(TBL_STU_NAME, value);
297     int age = 25;
298     valuesBucket.Put(TBL_STU_AGE, age);
299 
300     auto [errCode, retVal] = helper->InsertEx(uri, valuesBucket);
301     EXPECT_EQ((errCode == 0), true);
302     EXPECT_EQ((retVal > 0), true);
303     LOG_INFO("SlientAccess_InsertEx_Test_001::End");
304 }
305 
306 HWTEST_F(SlientAccessTest, SlientAccess_UpdateEx_Test_001, TestSize.Level0)
307 {
308     LOG_INFO("SlientAccess_UpdateEx_Test_001::Start");
309     auto helper = g_slientAccessHelper;
310     Uri uri(SLIENT_ACCESS_URI);
311     DataShare::DataShareValuesBucket valuesBucket;
312     int value = 50;
313     valuesBucket.Put(TBL_STU_AGE, value);
314     DataShare::DataSharePredicates predicates;
315     std::string selections = TBL_STU_NAME + " = 'lisi'";
316     predicates.SetWhereClause(selections);
317     auto [errCode, retVal] = helper->UpdateEx(uri, predicates, valuesBucket);
318     EXPECT_EQ((errCode == 0), true);
319     EXPECT_EQ((retVal > 0), true);
320     LOG_INFO("SlientAccess_UpdateEx_Test_001::End");
321 }
322 
323 HWTEST_F(SlientAccessTest, SlientAccess_DeleteEx_Test_001, TestSize.Level0)
324 {
325     LOG_INFO("SlientAccess_DeleteEx_Test_001::Start");
326     auto helper = g_slientAccessHelper;
327     Uri uri(SLIENT_ACCESS_URI);
328 
329     DataShare::DataSharePredicates deletePredicates;
330     std::string selections = TBL_STU_NAME + " = 'lisi'";
331     deletePredicates.SetWhereClause(selections);
332     auto [errCode, retVal] = helper->DeleteEx(uri, deletePredicates);
333     EXPECT_EQ((errCode == 0), true);
334     EXPECT_EQ((retVal > 0), true);
335     LOG_INFO("SlientAccess_DeleteEx_Test_001::End");
336 }
337 
338 HWTEST_F(SlientAccessTest, SlientAccess_Insert_Test_001, TestSize.Level0)
339 {
340     LOG_INFO("SlientAccess_Insert_Test_001::Start");
341     auto helper = g_slientAccessHelper;
342     Uri uri(SLIENT_ACCESS_URI);
343     DataShare::DataShareValuesBucket valuesBucket;
344     std::string value = "lisi";
345     valuesBucket.Put(TBL_STU_NAME, value);
346     int age = 25;
347     valuesBucket.Put(TBL_STU_AGE, age);
348 
349     int retVal = helper->Insert(uri, valuesBucket);
350     EXPECT_EQ((retVal > 0), true);
351     LOG_INFO("SlientAccess_Insert_Test_001::End");
352 }
353 
354 HWTEST_F(SlientAccessTest, SlientAccess_Update_Test_001, TestSize.Level0)
355 {
356     LOG_INFO("SlientAccess_Update_Test_001::Start");
357     auto helper = g_slientAccessHelper;
358     Uri uri(SLIENT_ACCESS_URI);
359     DataShare::DataShareValuesBucket valuesBucket;
360     int value = 50;
361     valuesBucket.Put(TBL_STU_AGE, value);
362     DataShare::DataSharePredicates predicates;
363     std::string selections = TBL_STU_NAME + " = 'lisi'";
364     predicates.SetWhereClause(selections);
365     int retVal = helper->Update(uri, predicates, valuesBucket);
366     EXPECT_EQ((retVal > 0), true);
367     LOG_INFO("SlientAccess_Update_Test_001::End");
368 }
369 
370 HWTEST_F(SlientAccessTest, SlientAccess_Query_Test_001, TestSize.Level0)
371 {
372     LOG_INFO("SlientAccess_Query_Test_001::Start");
373     auto helper = g_slientAccessHelper;
374     Uri uri(SLIENT_ACCESS_URI);
375     DataShare::DataSharePredicates predicates;
376     predicates.EqualTo(TBL_STU_NAME, "lisi");
377     vector<string> columns;
378     auto resultSet = helper->Query(uri, predicates, columns);
379     int result = 0;
380     if (resultSet != nullptr) {
381         resultSet->GetRowCount(result);
382     }
383     EXPECT_EQ(result, 1);
384     LOG_INFO("SlientAccess_Query_Test_001::End");
385 }
386 
387 HWTEST_F(SlientAccessTest, SlientAccess_Delete_Test_001, TestSize.Level0)
388 {
389     LOG_INFO("SlientAccess_Delete_Test_001::Start");
390     auto helper = g_slientAccessHelper;
391     Uri uri(SLIENT_ACCESS_URI);
392 
393     DataShare::DataSharePredicates deletePredicates;
394     std::string selections = TBL_STU_NAME + " = 'lisi'";
395     deletePredicates.SetWhereClause(selections);
396     int retVal = helper->Delete(uri, deletePredicates);
397     EXPECT_EQ((retVal > 0), true);
398     LOG_INFO("SlientAccess_Delete_Test_001::End");
399 }
400 
401 HWTEST_F(SlientAccessTest, SlientAccess_Register_Test_001, TestSize.Level0)
402 {
403     LOG_INFO("SlientAccess_Register_Test_001::Start");
404     auto helper = g_slientAccessHelper;
405     Uri uri(SLIENT_ACCESS_URI);
406     sptr<IDataShareAbilityObserverTest> dataObserver(new (std::nothrow) IDataShareAbilityObserverTest());
407     dataObserver->SetName("zhangsan");
408     helper->RegisterObserver(uri, dataObserver);
409     EXPECT_EQ(dataObserver->GetName(), "zhangsan");
410     DataShare::DataShareValuesBucket valuesBucket;
411     std::string value = "lisi";
412     valuesBucket.Put(TBL_STU_NAME, value);
413     int age = 25;
414     valuesBucket.Put(TBL_STU_AGE, age);
415     int retVal = helper->Insert(uri, valuesBucket);
416     EXPECT_EQ((retVal > 0), true);
417     dataObserver->data.Wait();
418     EXPECT_EQ(dataObserver->GetName(), "OnChangeName");
419     dataObserver->Clear();
420 
421     DataShare::DataSharePredicates deletePredicates;
422     deletePredicates.EqualTo(TBL_STU_NAME, "lisi")->And()->EqualTo(TBL_STU_NAME, 25);
423     retVal = helper->Delete(uri, deletePredicates);
424     EXPECT_EQ((retVal >= 0), true);
425     helper->UnregisterObserver(uri, dataObserver);
426     LOG_INFO("SlientAccess_Register_Test_001::End");
427 }
428 
429 HWTEST_F(SlientAccessTest, SlientAccess_RegisterErrorUri_Test_001, TestSize.Level0)
430 {
431     LOG_INFO("SlientAccess_RegisterErrorUri_Test_001::Start");
432     auto helper = g_slientAccessHelper;
433     Uri uri(SLIENT_ACCESS_URI);
434     sptr<IDataShareAbilityObserverTest> dataObserver(new (std::nothrow) IDataShareAbilityObserverTest());
435     dataObserver->SetName("zhangsan");
436     Uri uriRegister(SLIENT_REGISTER_URI);
437     helper->RegisterObserver(uriRegister, dataObserver);
438     EXPECT_EQ(dataObserver->GetName(), "zhangsan");
439     DataShare::DataShareValuesBucket valuesBucket;
440     std::string value = "lisi";
441     valuesBucket.Put(TBL_STU_NAME, value);
442     int age = 25;
443     valuesBucket.Put(TBL_STU_AGE, age);
444     int retVal = helper->Insert(uri, valuesBucket);
445     EXPECT_EQ((retVal > 0), true);
446     EXPECT_NE(dataObserver->GetName(), "OnChangeName");
447 
448     DataShare::DataSharePredicates deletePredicates;
449     deletePredicates.EqualTo(TBL_STU_NAME, "lisi")->And()->EqualTo(TBL_STU_NAME, 25);
450     retVal = helper->Delete(uri, deletePredicates);
451     EXPECT_EQ((retVal >= 0), true);
452     helper->UnregisterObserver(uriRegister, dataObserver);
453     LOG_INFO("SlientAccess_RegisterErrorUri_Test_001::End");
454 }
455 
456 HWTEST_F(SlientAccessTest, SlientAccess_NoRegister_Test_001, TestSize.Level0)
457 {
458     LOG_INFO("SlientAccess_NoRegister_Test_001::Start");
459     auto helper = g_slientAccessHelper;
460     Uri uri(SLIENT_ACCESS_URI);
461     sptr<IDataShareAbilityObserverTest> dataObserver(new (std::nothrow) IDataShareAbilityObserverTest());
462     dataObserver->SetName("zhangsan");
463     EXPECT_EQ(dataObserver->GetName(), "zhangsan");
464     DataShare::DataShareValuesBucket valuesBucket;
465     std::string value = "lisi";
466     valuesBucket.Put(TBL_STU_NAME, value);
467     int age = 25;
468     valuesBucket.Put(TBL_STU_AGE, age);
469     int retVal = helper->Insert(uri, valuesBucket);
470     EXPECT_EQ((retVal > 0), true);
471     EXPECT_NE(dataObserver->GetName(), "OnChangeName");
472 
473     DataShare::DataSharePredicates deletePredicates;
474     deletePredicates.EqualTo(TBL_STU_NAME, "lisi")->And()->EqualTo(TBL_STU_NAME, 25);
475     retVal = helper->Delete(uri, deletePredicates);
476     EXPECT_EQ((retVal >= 0), true);
477     helper->UnregisterObserver(uri, dataObserver);
478     LOG_INFO("SlientAccess_NoRegister_Test_001::End");
479 }
480 
481 HWTEST_F(SlientAccessTest, SlientAccess_NoRegister_Test_002, TestSize.Level0)
482 {
483     LOG_INFO("SlientAccess_NoRegister_Test_002::Start");
484     auto helper = g_slientAccessHelper;
485     Uri uri(SLIENT_ACCESS_URI);
486     sptr<IDataShareAbilityObserverTest> dataObserver(new (std::nothrow) IDataShareAbilityObserverTest());
487     dataObserver->SetName("zhangsan");
488     helper->RegisterObserver(uri, dataObserver);
489     helper->UnregisterObserver(uri, dataObserver);
490     EXPECT_EQ(dataObserver->GetName(), "zhangsan");
491     DataShare::DataShareValuesBucket valuesBucket;
492     std::string value = "lisi";
493     valuesBucket.Put(TBL_STU_NAME, value);
494     int age = 25;
495     valuesBucket.Put(TBL_STU_AGE, age);
496     int retVal = helper->Insert(uri, valuesBucket);
497     EXPECT_EQ((retVal > 0), true);
498     EXPECT_NE(dataObserver->GetName(), "OnChangeName");
499 
500     DataShare::DataSharePredicates deletePredicates;
501     deletePredicates.EqualTo(TBL_STU_NAME, "lisi")->And()->EqualTo(TBL_STU_NAME, 25);
502     retVal = helper->Delete(uri, deletePredicates);
503     EXPECT_EQ((retVal >= 0), true);
504     LOG_INFO("SlientAccess_NoRegister_Test_002::End");
505 }
506 
507 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Insert_Test_001, TestSize.Level0)
508 {
509     LOG_INFO("SlientAccess_Permission_Insert_Test_001::Start");
510     auto helper = g_slientAccessHelper;
511     Uri uri(SLIENT_ACCESS_URI);
512     DataShare::DataShareValuesBucket valuesBucket;
513     std::string value = "lisi";
514     valuesBucket.Put(TBL_STU_NAME, value);
515     int age = 25;
516     valuesBucket.Put(TBL_STU_AGE, age);
517 
518     int retVal = helper->Insert(uri, valuesBucket);
519     EXPECT_EQ((retVal > 0), true);
520     LOG_INFO("SlientAccess_Permission_Insert_Test_001::End");
521 }
522 
523 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Insert_Test_003, TestSize.Level0)
524 {
525     LOG_INFO("SlientAccess_Permission_Insert_Test_003::Start");
526     auto helper = g_slientAccessHelper;
527     Uri uri(SLIENT_PROXY_PERMISSION1_URI);
528     DataShare::DataShareValuesBucket valuesBucket;
529     std::string value = "lisi";
530     valuesBucket.Put(TBL_STU_NAME, value);
531     int age = 25;
532     valuesBucket.Put(TBL_STU_AGE, age);
533 
534     int retVal = helper->Insert(uri, valuesBucket);
535     EXPECT_EQ((retVal > 0), true);
536     LOG_INFO("SlientAccess_Permission_Insert_Test_003::End");
537 }
538 
539 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Update_Test_001, TestSize.Level0)
540 {
541     LOG_INFO("SlientAccess_Permission_Update_Test_001::Start");
542     auto helper = g_slientAccessHelper;
543     Uri uri(SLIENT_PROXY_PERMISSION1_URI);
544     DataShare::DataShareValuesBucket valuesBucket;
545     int value = 50;
546     valuesBucket.Put(TBL_STU_AGE, value);
547     DataShare::DataSharePredicates predicates;
548     std::string selections = TBL_STU_NAME + " = 'lisi'";
549     predicates.SetWhereClause(selections);
550     int retVal = helper->Update(uri, predicates, valuesBucket);
551     EXPECT_EQ((retVal > 0), true);
552     LOG_INFO("SlientAccess_Permission_Update_Test_001::End");
553 }
554 
555 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Query_Test_002, TestSize.Level0)
556 {
557     LOG_INFO("SlientAccess_Permission_Query_Test_002::Start");
558     auto helper = g_slientAccessHelper;
559     Uri uri(SLIENT_PROXY_PERMISSION2_URI);
560     DataShare::DataShareValuesBucket valuesBucket;
561     std::string value = "lisi";
562     valuesBucket.Put(TBL_STU_NAME, value);
563     int age = 25;
564     valuesBucket.Put(TBL_STU_AGE, age);
565 
566     int retVal = helper->Insert(uri, valuesBucket);
567     EXPECT_EQ((retVal > 0), true);
568 
569     DataShare::DataSharePredicates predicates;
570     predicates.EqualTo(TBL_STU_NAME, "lisi");
571     vector<string> columns;
572     DatashareBusinessError businessError;
573     auto resultSet = helper->Query(uri, predicates, columns, &businessError);
574     int result = 0;
575     if (resultSet != nullptr) {
576         resultSet->GetRowCount(result);
577     }
578     EXPECT_EQ(result, 1);
579     EXPECT_EQ(businessError.GetCode(), 0);
580     LOG_INFO("SlientAccess_Permission_Query_Test_002::End");
581 }
582 
583 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Delete_Test_001, TestSize.Level0)
584 {
585     LOG_INFO("SlientAccess_Permission_Delete_Test_001::Start");
586     auto helper = g_slientAccessHelper;
587     Uri uri(SLIENT_PROXY_PERMISSION2_URI);
588 
589     DataShare::DataSharePredicates deletePredicates;
590     std::string selections = TBL_STU_NAME + " = 'lisi'";
591     deletePredicates.SetWhereClause(selections);
592     int retVal = helper->Delete(uri, deletePredicates);
593     EXPECT_EQ(retVal, 1);
594     LOG_INFO("SlientAccess_Permission_Delete_Test_001::End");
595 }
596 
597 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Insert_Test_002, TestSize.Level0)
598 {
599     LOG_INFO("SlientAccess_Permission_Insert_Test_002::Start");
600     HapInfoParams info = {
601         .userID = USER_100,
602         .bundleName = "ohos.permission.write.demo",
603         .instIndex = 0,
604         .isSystemApp = true,
605         .apiVersion = 8,
606         .appIDDesc = "ohos.permission.write.demo"
607     };
608     HapPolicyParams policy = {
609         .apl = APL_SYSTEM_CORE,
610         .domain = "test.domain",
611         .permStateList = {
612             {
613                 .permissionName = "ohos.permission.WRITE_CONTACTS",
614                 .isGeneral = true,
615                 .resDeviceID = { "local" },
616                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
617                 .grantFlags = { 1 }
618             }
619         }
620     };
621     AccessTokenKit::AllocHapToken(info, policy);
622     auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
623         info.userID, info.bundleName, info.instIndex);
624     SetSelfTokenID(testTokenId.tokenIDEx);
625 
626     auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
627     Uri uri(SLIENT_ACCESS_PERMISSION1_URI);
628     DataShare::DataShareValuesBucket valuesBucket;
629     std::string value = "lisi";
630     valuesBucket.Put(TBL_STU_NAME, value);
631     int age = 25;
632     valuesBucket.Put(TBL_STU_AGE, age);
633     int retVal = helper->Insert(uri, valuesBucket);
634     EXPECT_EQ(retVal, -2);
635     helper = nullptr;
636     AccessTokenKit::DeleteToken(testTokenId.tokenIDEx);
637     LOG_INFO("SlientAccess_Permission_Insert_Test_002::End");
638 }
639 
640 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Update_Test_002, TestSize.Level0)
641 {
642     LOG_INFO("SlientAccess_Permission_Update_Test_002::Start");
643     HapInfoParams info = {
644         .userID = USER_100,
645         .bundleName = "ohos.permission.write.demo",
646         .instIndex = 0,
647         .isSystemApp = true,
648         .apiVersion = 8,
649         .appIDDesc = "ohos.permission.write.demo"
650     };
651     HapPolicyParams policy = {
652         .apl = APL_SYSTEM_CORE,
653         .domain = "test.domain",
654         .permStateList = {
655             {
656                 .permissionName = "ohos.permission.WRITE_CONTACTS",
657                 .isGeneral = true,
658                 .resDeviceID = { "local" },
659                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
660                 .grantFlags = { 1 }
661             }
662         }
663     };
664     AccessTokenKit::AllocHapToken(info, policy);
665     auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
666         info.userID, info.bundleName, info.instIndex);
667     SetSelfTokenID(testTokenId.tokenIDEx);
668 
669     auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
670     Uri uri(SLIENT_ACCESS_PERMISSION1_URI);
671     DataShare::DataShareValuesBucket valuesBucket;
672     int value = 50;
673     valuesBucket.Put(TBL_STU_AGE, value);
674     DataShare::DataSharePredicates predicates;
675     std::string selections = TBL_STU_NAME + " = 'lisi'";
676     predicates.SetWhereClause(selections);
677     int retVal = helper->Update(uri, predicates, valuesBucket);
678     EXPECT_EQ(retVal, -2);
679     helper = nullptr;
680     AccessTokenKit::DeleteToken(testTokenId.tokenIDEx);
681     LOG_INFO("SlientAccess_Permission_Update_Test_002::End");
682 }
683 
684 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Query_Test_001, TestSize.Level0)
685 {
686     LOG_INFO("SlientAccess_Permission_Query_Test_001::Start");
687     HapInfoParams info = {
688         .userID = USER_100,
689         .bundleName = "ohos.permission.write.demo",
690         .instIndex = 0,
691         .isSystemApp = true,
692         .apiVersion = 8,
693         .appIDDesc = "ohos.permission.write.demo"
694     };
695     HapPolicyParams policy = {
696         .apl = APL_SYSTEM_CORE,
697         .domain = "test.domain",
698         .permStateList = {
699             {
700                 .permissionName = "ohos.permission.WRITE_CONTACTS",
701                 .isGeneral = true,
702                 .resDeviceID = { "local" },
703                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
704                 .grantFlags = { 1 }
705             }
706         }
707     };
708     AccessTokenKit::AllocHapToken(info, policy);
709     auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
710         info.userID, info.bundleName, info.instIndex);
711     SetSelfTokenID(testTokenId.tokenIDEx);
712 
713     auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
714     Uri uri(SLIENT_ACCESS_PERMISSION2_URI);
715     DataShare::DataSharePredicates predicates;
716     predicates.EqualTo(TBL_STU_NAME, "lisi");
717     vector<string> columns;
718     DatashareBusinessError businessError;
719     auto resultSet = helper->Query(uri, predicates, columns, &businessError);
720     int result = 0;
721     if (resultSet != nullptr) {
722         resultSet->GetRowCount(result);
723     }
724     EXPECT_EQ(result, 0);
725     EXPECT_EQ(resultSet, nullptr);
726     EXPECT_EQ(businessError.GetCode(), -2);
727     helper = nullptr;
728     AccessTokenKit::DeleteToken(testTokenId.tokenIDEx);
729     LOG_INFO("SlientAccess_Permission_Query_Test_001::End");
730 }
731 } // namespace DataShare
732 } // namespace OHOS