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 #include <gtest/gtest.h>
16 #include <unistd.h>
17 
18 #include "accesstoken_kit.h"
19 #include "datashare_helper.h"
20 #include "datashare_log.h"
21 #include "hap_token_info.h"
22 #include "iservice_registry.h"
23 #include "system_ability_definition.h"
24 #include "token_setproc.h"
25 
26 namespace OHOS {
27 namespace DataShare {
28 using namespace testing::ext;
29 using namespace OHOS::Security::AccessToken;
30 constexpr int STORAGE_MANAGER_MANAGER_ID = 5003;
31 std::string DATA_SHARE_URI = "datashare:///com.acts.datasharetest";
32 std::string SLIENT_ACCESS_URI = "datashare:///com.acts.datasharetest/entry/DB00/TBL00?Proxy=true";
33 std::string DATA_SHARE_PROXY_URI = "datashare:///com.acts.ohos.data.datasharetest/test";
34 constexpr int SUBSCRIBER_ID = 1000;
35 std::string TBL_STU_NAME = "name";
36 std::string TBL_STU_AGE = "age";
37 int32_t ERROR = -1;
38 std::shared_ptr<DataShare::DataShareHelper> g_slientAccessHelper;
39 
40 class SlientSwitchTest : public testing::Test {
41 public:
42     static void SetUpTestCase(void);
43     static void TearDownTestCase(void);
44     void SetUp();
45     void TearDown();
46 };
47 
CreateDataShareHelper(int32_t systemAbilityId,const std::string & silentProxyUri,const std::string & providerUri="")48 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int32_t systemAbilityId,
49     const std::string &silentProxyUri, const std::string &providerUri = "")
50 {
51     LOG_INFO("CreateDataShareHelper start");
52     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
53     if (saManager == nullptr) {
54         LOG_ERROR("GetSystemAbilityManager get samgr failed.");
55         return nullptr;
56     }
57     auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
58     if (remoteObj == nullptr) {
59         LOG_ERROR("GetSystemAbility service failed.");
60         return nullptr;
61     }
62     return DataShare::DataShareHelper::Creator(remoteObj, silentProxyUri, providerUri);
63 }
64 
SetUpTestCase(void)65 void SlientSwitchTest::SetUpTestCase(void)
66 {
67     LOG_INFO("SetUpTestCase invoked");
68     auto dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, DATA_SHARE_URI);
69     ASSERT_TRUE(dataShareHelper != nullptr);
70     int sleepTime = 3;
71     sleep(sleepTime);
72 
73     HapInfoParams info = {
74         .userID = 100,
75         .bundleName = "com.acts.datasharetest",
76         .instIndex = 0,
77         .appIDDesc = "com.acts.datasharetest"
78     };
79     HapPolicyParams policy = {
80         .apl = APL_NORMAL,
81         .domain = "test.domain",
82         .permList = {
83             {
84                 .permissionName = "ohos.permission.test",
85                 .bundleName = "com.acts.datasharetest",
86                 .grantMode = 1,
87                 .availableLevel = APL_NORMAL,
88                 .label = "label",
89                 .labelId = 1,
90                 .description = "com.acts.datasharetest",
91                 .descriptionId = 1
92             }
93         },
94         .permStateList = {
95             {
96                 .permissionName = "ohos.permission.test",
97                 .isGeneral = true,
98                 .resDeviceID = { "local" },
99                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
100                 .grantFlags = { 1 }
101             }
102         }
103     };
104     AccessTokenKit::AllocHapToken(info, policy);
105     auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenID(
106         info.userID, info.bundleName, info.instIndex);
107     SetSelfTokenID(testTokenId);
108 
109     g_slientAccessHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
110     ASSERT_TRUE(g_slientAccessHelper != nullptr);
111     LOG_INFO("SetUpTestCase end");
112 }
113 
TearDownTestCase(void)114 void SlientSwitchTest::TearDownTestCase(void)
115 {
116     auto tokenId = AccessTokenKit::GetHapTokenID(100, "com.acts.datasharetest", 0);
117     AccessTokenKit::DeleteToken(tokenId);
118     g_slientAccessHelper = nullptr;
119 }
120 
SetUp(void)121 void SlientSwitchTest::SetUp(void) {}
TearDown(void)122 void SlientSwitchTest::TearDown(void) {}
123 
124 HWTEST_F(SlientSwitchTest, SlientSwitch_SetSilentSwitch_Test_001, TestSize.Level0)
125 {
126     LOG_INFO("SlientSwitch_SetSilentSwitch_Test_001::Start");
127     Uri uri(SLIENT_ACCESS_URI);
128     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
129     EXPECT_EQ(retVal, E_OK);
130     LOG_INFO("SlientSwitch_SetSilentSwitch_Test_001::End");
131 }
132 
133 HWTEST_F(SlientSwitchTest, SlientSwitch_SetSilentSwitch_Test_002, TestSize.Level0)
134 {
135     LOG_INFO("SlientSwitch_SetSilentSwitch_Test_002::Start");
136     Uri uri(SLIENT_ACCESS_URI);
137     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
138     EXPECT_EQ(retVal, E_OK);
139     LOG_INFO("SlientSwitch_SetSilentSwitch_Test_002::End");
140 }
141 
142 HWTEST_F(SlientSwitchTest, SlientSwitch_SetSilentSwitch_Test_003, TestSize.Level0)
143 {
144     LOG_INFO("SlientSwitch_SetSilentSwitch_Test_003::Start");
145     Uri uri("");
146     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
147     EXPECT_EQ(retVal, E_OK);
148     LOG_INFO("SlientSwitch_SetSilentSwitch_Test_003::End");
149 }
150 
151 HWTEST_F(SlientSwitchTest, SlientSwitch_SetSilentSwitch_Test_004, TestSize.Level0)
152 {
153     LOG_INFO("SlientSwitch_SetSilentSwitch_Test_004::Start");
154     Uri uri("");
155     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
156     EXPECT_EQ(retVal, E_OK);
157     LOG_INFO("SlientSwitch_SetSilentSwitch_Test_004::End");
158 }
159 
160 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_Insert_Test_001, TestSize.Level0)
161 {
162     LOG_INFO("SlientSwitch_SwitchDisable_Insert_Test_001::Start");
163     Uri uri(SLIENT_ACCESS_URI);
164     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
165     EXPECT_EQ(retVal, E_OK);
166 
167     auto helper = g_slientAccessHelper;
168     DataShare::DataShareValuesBucket valuesBucket;
169     std::string value = "lisi";
170     valuesBucket.Put(TBL_STU_NAME, value);
171     int age = 25;
172     valuesBucket.Put(TBL_STU_AGE, age);
173 
174     retVal = helper->Insert(uri, valuesBucket);
175     EXPECT_EQ((retVal > 0), false);
176     LOG_INFO("SlientSwitch_SwitchDisable_Insert_Test_001::End");
177 }
178 
179 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_Insert_Test_002, TestSize.Level0)
180 {
181     LOG_INFO("SlientSwitch_SwitchDisable_Insert_Test_002::Start");
182     Uri uri("");
183     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
184     EXPECT_EQ(retVal, E_OK);
185 
186     auto helper = g_slientAccessHelper;
187     DataShare::DataShareValuesBucket valuesBucket;
188     std::string value = "wangwu";
189     valuesBucket.Put(TBL_STU_NAME, value);
190     int age = 25;
191     valuesBucket.Put(TBL_STU_AGE, age);
192     uri = Uri(SLIENT_ACCESS_URI);
193     retVal = helper->Insert(uri, valuesBucket);
194     EXPECT_EQ((retVal > 0), false);
195     LOG_INFO("SlientSwitch_SwitchDisable_Insert_Test_002::End");
196 }
197 
198 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_Insert_Test_001, TestSize.Level0)
199 {
200     LOG_INFO("SlientSwitch_SwitchEnable_Insert_Test_001::Start");
201     Uri uri(SLIENT_ACCESS_URI);
202     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
203     EXPECT_EQ(retVal, E_OK);
204 
205     auto helper = g_slientAccessHelper;
206     DataShare::DataShareValuesBucket valuesBucket;
207     std::string value = "lisi";
208     valuesBucket.Put(TBL_STU_NAME, value);
209     int age = 25;
210     valuesBucket.Put(TBL_STU_AGE, age);
211 
212     retVal = helper->Insert(uri, valuesBucket);
213     EXPECT_EQ((retVal > 0), true);
214     LOG_INFO("SlientSwitch_SwitchEnable_Insert_Test_001::End");
215 }
216 
217 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_Insert_Test_002, TestSize.Level0)
218 {
219     LOG_INFO("SlientSwitch_SwitchEnable_Insert_Test_002::Start");
220     Uri uri("");
221     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
222     EXPECT_EQ(retVal, E_OK);
223 
224     auto helper = g_slientAccessHelper;
225     DataShare::DataShareValuesBucket valuesBucket;
226     std::string value = "wangwu";
227     valuesBucket.Put(TBL_STU_NAME, value);
228     int age = 25;
229     valuesBucket.Put(TBL_STU_AGE, age);
230     uri = Uri(SLIENT_ACCESS_URI);
231     retVal = helper->Insert(uri, valuesBucket);
232     EXPECT_EQ((retVal > 0), true);
233     LOG_INFO("SlientSwitch_SwitchEnable_Insert_Test_002::End");
234 }
235 
236 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_Update_Test_001, TestSize.Level0)
237 {
238     LOG_INFO("SlientSwitch_SwitchDisable_Update_Test_001::Start");
239     Uri uri(SLIENT_ACCESS_URI);
240     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
241     EXPECT_EQ(retVal, E_OK);
242 
243     auto helper = g_slientAccessHelper;
244     DataShare::DataShareValuesBucket valuesBucket;
245     int value = 50;
246     valuesBucket.Put(TBL_STU_AGE, value);
247     DataShare::DataSharePredicates predicates;
248     std::string selections = TBL_STU_NAME + " = 'lisi'";
249     predicates.SetWhereClause(selections);
250     retVal = helper->Update(uri, predicates, valuesBucket);
251     EXPECT_EQ((retVal > 0), false);
252     LOG_INFO("SlientSwitch_SwitchDisable_Update_Test_001::End");
253 }
254 
255 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_Update_Test_002, TestSize.Level0)
256 {
257     LOG_INFO("SlientSwitch_SwitchDisable_Update_Test_002::Start");
258     Uri uri("");
259     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
260     EXPECT_EQ(retVal, E_OK);
261 
262     auto helper = g_slientAccessHelper;
263     DataShare::DataShareValuesBucket valuesBucket;
264     int value = 50;
265     valuesBucket.Put(TBL_STU_AGE, value);
266     DataShare::DataSharePredicates predicates;
267     std::string selections = TBL_STU_NAME + " = 'wangwu'";
268     predicates.SetWhereClause(selections);
269     uri = Uri(SLIENT_ACCESS_URI);
270     retVal = helper->Update(uri, predicates, valuesBucket);
271     EXPECT_EQ((retVal > 0), false);
272     LOG_INFO("SlientSwitch_SwitchDisable_Update_Test_002::End");
273 }
274 
275 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_Update_Test_001, TestSize.Level0)
276 {
277     LOG_INFO("SlientSwitch_SwitchEnable_Update_Test_001::Start");
278     Uri uri(SLIENT_ACCESS_URI);
279     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
280     EXPECT_EQ(retVal, E_OK);
281 
282     auto helper = g_slientAccessHelper;
283     DataShare::DataShareValuesBucket valuesBucket;
284     int value = 50;
285     valuesBucket.Put(TBL_STU_AGE, value);
286     DataShare::DataSharePredicates predicates;
287     std::string selections = TBL_STU_NAME + " = 'lisi'";
288     predicates.SetWhereClause(selections);
289     retVal = helper->Update(uri, predicates, valuesBucket);
290     EXPECT_EQ((retVal > 0), true);
291     LOG_INFO("SlientSwitch_SwitchEnable_Update_Test_001::End");
292 }
293 
294 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_Update_Test_002, TestSize.Level0)
295 {
296     LOG_INFO("SlientSwitch_SwitchEnable_Update_Test_002::Start");
297     Uri uri("");
298     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
299     EXPECT_EQ(retVal, E_OK);
300 
301     auto helper = g_slientAccessHelper;
302     DataShare::DataShareValuesBucket valuesBucket;
303     int value = 50;
304     valuesBucket.Put(TBL_STU_AGE, value);
305     DataShare::DataSharePredicates predicates;
306     std::string selections = TBL_STU_NAME + " = 'wangwu'";
307     predicates.SetWhereClause(selections);
308     uri = Uri(SLIENT_ACCESS_URI);
309     retVal = helper->Update(uri, predicates, valuesBucket);
310     EXPECT_EQ((retVal > 0), true);
311     LOG_INFO("SlientSwitch_SwitchEnable_Update_Test_002::End");
312 }
313 
314 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_Query_Test_001, TestSize.Level0)
315 {
316     LOG_INFO("SlientSwitch_SwitchDisable_Query_Test_001::Start");
317     Uri uri(SLIENT_ACCESS_URI);
318     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
319     EXPECT_EQ(retVal, E_OK);
320 
321     auto helper = g_slientAccessHelper;
322     DataShare::DataSharePredicates predicates;
323     predicates.EqualTo(TBL_STU_NAME, "lisi");
324     vector<string> columns;
325     auto resultSet = helper->Query(uri, predicates, columns);
326     ASSERT_TRUE(resultSet == nullptr);
327     LOG_INFO("SlientSwitch_SwitchDisable_Query_Test_001::End");
328 }
329 
330 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_Query_Test_002, TestSize.Level0)
331 {
332     LOG_INFO("SlientSwitch_SwitchDisable_Query_Test_002::Start");
333     Uri uri("");
334     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
335     EXPECT_EQ(retVal, E_OK);
336 
337     auto helper = g_slientAccessHelper;
338     DataShare::DataSharePredicates predicates;
339     predicates.EqualTo(TBL_STU_NAME, "wangwu");
340     vector<string> columns;
341     uri = Uri(SLIENT_ACCESS_URI);
342     auto resultSet = helper->Query(uri, predicates, columns);
343     ASSERT_TRUE(resultSet == nullptr);
344     LOG_INFO("SlientSwitch_SwitchDisable_Query_Test_002::End");
345 }
346 
347 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_Query_Test_001, TestSize.Level0)
348 {
349     LOG_INFO("SlientSwitch_SwitchEnable_Query_Test_001::Start");
350     Uri uri(SLIENT_ACCESS_URI);
351     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
352     EXPECT_EQ(retVal, E_OK);
353 
354     auto helper = g_slientAccessHelper;
355     DataShare::DataSharePredicates predicates;
356     predicates.EqualTo(TBL_STU_NAME, "lisi");
357     vector<string> columns;
358     auto resultSet = helper->Query(uri, predicates, columns);
359     int result = 0;
360     if (resultSet != nullptr) {
361         resultSet->GetRowCount(result);
362     }
363     EXPECT_EQ(result, 1);
364     LOG_INFO("SlientSwitch_SwitchEnable_Query_Test_001::End");
365 }
366 
367 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_Query_Test_002, TestSize.Level0)
368 {
369     LOG_INFO("SlientSwitch_SwitchEnable_Query_Test_002::Start");
370     Uri uri("");
371     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
372     EXPECT_EQ(retVal, E_OK);
373 
374     auto helper = g_slientAccessHelper;
375     DataShare::DataSharePredicates predicates;
376     predicates.EqualTo(TBL_STU_NAME, "wangwu");
377     vector<string> columns;
378     uri = Uri(SLIENT_ACCESS_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("SlientSwitch_SwitchEnable_Query_Test_002::End");
386 }
387 
388 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_Delete_Test_001, TestSize.Level0)
389 {
390     LOG_INFO("SlientSwitch_SwitchDisable_Delete_Test_001::Start");
391     Uri uri(SLIENT_ACCESS_URI);
392     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
393     EXPECT_EQ(retVal, E_OK);
394 
395     auto helper = g_slientAccessHelper;
396     DataShare::DataSharePredicates deletePredicates;
397     std::string selections = TBL_STU_NAME + " = 'lisi'";
398     deletePredicates.SetWhereClause(selections);
399     retVal = helper->Delete(uri, deletePredicates);
400     EXPECT_EQ((retVal > 0), false);
401     LOG_INFO("SlientSwitch_SwitchDisable_Delete_Test_001::End");
402 }
403 
404 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_Delete_Test_002, TestSize.Level0)
405 {
406     LOG_INFO("SlientSwitch_SwitchDisable_Delete_Test_002::Start");
407     Uri uri("");
408     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
409     EXPECT_EQ(retVal, E_OK);
410 
411     auto helper = g_slientAccessHelper;
412     DataShare::DataSharePredicates deletePredicates;
413     std::string selections = TBL_STU_NAME + " = 'wangwu'";
414     deletePredicates.SetWhereClause(selections);
415     uri = Uri(SLIENT_ACCESS_URI);
416     retVal = helper->Delete(uri, deletePredicates);
417     EXPECT_EQ((retVal > 0), false);
418     LOG_INFO("SlientSwitch_SwitchDisable_Delete_Test_002::End");
419 }
420 
421 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_Delete_Test_001, TestSize.Level0)
422 {
423     LOG_INFO("SlientSwitch_SwitchEnable_Delete_Test_001::Start");
424     Uri uri(SLIENT_ACCESS_URI);
425     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
426     EXPECT_EQ(retVal, E_OK);
427 
428     auto helper = g_slientAccessHelper;
429     DataShare::DataSharePredicates deletePredicates;
430     std::string selections = TBL_STU_NAME + " = 'lisi'";
431     deletePredicates.SetWhereClause(selections);
432     retVal = helper->Delete(uri, deletePredicates);
433     EXPECT_EQ((retVal > 0), true);
434     LOG_INFO("SlientSwitch_SwitchEnable_Delete_Test_001::End");
435 }
436 
437 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_Delete_Test_002, TestSize.Level0)
438 {
439     LOG_INFO("SlientSwitch_SwitchEnable_Delete_Test_002::Start");
440     Uri uri("");
441     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
442     EXPECT_EQ(retVal, E_OK);
443 
444     auto helper = g_slientAccessHelper;
445     DataShare::DataSharePredicates deletePredicates;
446     std::string selections = TBL_STU_NAME + " = 'wangwu'";
447     deletePredicates.SetWhereClause(selections);
448     uri = Uri(SLIENT_ACCESS_URI);
449     retVal = helper->Delete(uri, deletePredicates);
450     EXPECT_EQ((retVal > 0), true);
451     LOG_INFO("SlientSwitch_SwitchEnable_Delete_Test_002::End");
452 }
453 
454 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_CreateHelper_Test_001, TestSize.Level0)
455 {
456     LOG_INFO("SlientSwitch_SwitchDisable_CreateHelper_Test_001::Start");
457     auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
458     ASSERT_TRUE(helper != nullptr);
459 
460     Uri uri("");
461     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
462     EXPECT_EQ(retVal, E_OK);
463 
464     helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
465     ASSERT_TRUE(helper == nullptr);
466     retVal = DataShareHelper::SetSilentSwitch(uri, true);
467     EXPECT_EQ(retVal, E_OK);
468     LOG_INFO("SlientSwitch_SwitchDisable_CreateHelper_Test_001::End");
469 }
470 
GetTemplate()471 Template GetTemplate()
472 {
473     PredicateTemplateNode node1("p1", "select name0 as name from TBL00");
474     PredicateTemplateNode node2("p2", "select name1 as name from TBL00");
475     std::vector<PredicateTemplateNode> nodes;
476     nodes.emplace_back(node1);
477     nodes.emplace_back(node2);
478     Template tpl(nodes, "select name1 as name from TBL00");
479     return tpl;
480 }
481 
482 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchDisable_CreateHelper_Test_002, TestSize.Level0)
483 {
484     LOG_INFO("SlientSwitch_SwitchDisable_CreateHelper_Test_002::Start");
485     Uri uri("");
486     int retVal = DataShareHelper::SetSilentSwitch(uri, false);
487     EXPECT_EQ(retVal, E_OK);
488 
489     auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI, DATA_SHARE_URI);
490     ASSERT_TRUE(helper != nullptr);
491 
492     auto tpl = GetTemplate();
493     auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl);
494     EXPECT_EQ(result, ERROR);
495     retVal = DataShareHelper::SetSilentSwitch(uri, true);
496     EXPECT_EQ(retVal, E_OK);
497     LOG_INFO("SlientSwitch_SwitchDisable_CreateHelper_Test_002::End");
498 }
499 
500 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_CreateHelper_Test_001, TestSize.Level0)
501 {
502     LOG_INFO("SlientSwitch_SwitchEnable_CreateHelper_Test_001::Start");
503     Uri uri("");
504     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
505     EXPECT_EQ(retVal, E_OK);
506 
507     auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
508     ASSERT_TRUE(helper != nullptr);
509 
510     auto tpl = GetTemplate();
511     auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl);
512     EXPECT_EQ(result, E_BUNDLE_NAME_NOT_EXIST);
513     LOG_INFO("SlientSwitch_SwitchEnable_CreateHelper_Test_001::End");
514 }
515 
516 HWTEST_F(SlientSwitchTest, SlientSwitch_SwitchEnable_CreateHelper_Test_002, TestSize.Level0)
517 {
518     LOG_INFO("SlientSwitch_SwitchEnable_CreateHelper_Test_002::Start");
519     Uri uri("");
520     int retVal = DataShareHelper::SetSilentSwitch(uri, true);
521     EXPECT_EQ(retVal, E_OK);
522 
523     auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI, DATA_SHARE_URI);
524     ASSERT_TRUE(helper != nullptr);
525 
526     auto tpl = GetTemplate();
527     auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl);
528     EXPECT_EQ(result, E_BUNDLE_NAME_NOT_EXIST);
529     LOG_INFO("SlientSwitch_SwitchEnable_CreateHelper_Test_002::End");
530 }
531 } // namespace DataShare
532 } // namespace OHOS