1 /*
2 * Copyright (c) 2025 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 #define LOG_TAG "DataShareProxyHandleTest"
16
17 #include "data_share_service_impl.h"
18
19 #include <gtest/gtest.h>
20
21 #include "accesstoken_kit.h"
22 #include "dataproxy_handle_common.h"
23 #include "hap_token_info.h"
24 #include "ipc_skeleton.h"
25 #include "iservice_registry.h"
26 #include "log_print.h"
27 #include "proxy_data_manager.h"
28 #include "system_ability_definition.h"
29 #include "token_setproc.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::DataShare;
33 using namespace OHOS::DistributedData;
34 using namespace OHOS::Security::AccessToken;
35
36 namespace OHOS::Test {
37 using OHOS::DataShare::LogLabel;
38 class DataShareProxyHandleTest : public testing::Test {
39 public:
40 static constexpr int64_t USER_TEST = 100;
41 std::string TEST_URI1 = "datashareproxy://com.test.dataprxoyhandle/test1";
42 std::string TEST_URI2 = "datashareproxy://com.test.dataprxoyhandle/test2";
43 std::string TEST_URI3 = "datashareproxy://com.test.dataprxoyhandle/test3";
44 std::string TEST_URI_OTHER = "datashareproxy://com.test.dataprxoyhandle.other/test";
45 // value1, value2, value3 are the values in profile
46 DataProxyValue VALUE1 = "value1";
47 DataProxyValue VALUE2 = "value2";
48 DataProxyValue VALUE3 = "value3";
49 std::string APPIDENTIFIER1 = "appIdentifier1";
50 std::string APPIDENTIFIER2 = "appIdentifier2";
51 std::string APPIDENTIFIER3 = "appIdentifier3";
52 std::string BUNDLE_NAME = "com.test.dataprxoyhandle";
SetUpTestCase(void)53 static void SetUpTestCase(void){};
TearDownTestCase(void)54 static void TearDownTestCase(void){};
55 void SetSelfTokenInfo(int32_t user);
56 void SetUp();
57 void TearDown();
58 };
59
SetUp(void)60 void DataShareProxyHandleTest::SetUp(void)
61 {
62 HapInfoParams info = {
63 .userID = USER_TEST,
64 .bundleName = BUNDLE_NAME,
65 .instIndex = 0,
66 .appIDDesc = BUNDLE_NAME
67 };
68 HapPolicyParams policy = {
69 .apl = APL_NORMAL,
70 .domain = "test.domain",
71 .permList = {
72 {
73 .permissionName = "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED",
74 .bundleName = BUNDLE_NAME,
75 .grantMode = 1,
76 .availableLevel = APL_NORMAL,
77 .label = "label",
78 .labelId = 1,
79 .description = BUNDLE_NAME,
80 .descriptionId = 1
81 }
82 },
83 .permStateList = {
84 {
85 .permissionName = "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED",
86 .isGeneral = true,
87 .resDeviceID = { "local" },
88 .grantStatus = { PermissionState::PERMISSION_GRANTED },
89 .grantFlags = { 1 }
90 }
91 }
92 };
93 AccessTokenKit::AllocHapToken(info, policy);
94 auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenID(
95 info.userID, info.bundleName, info.instIndex);
96 SetSelfTokenID(testTokenId);
97 }
98
TearDown(void)99 void DataShareProxyHandleTest::TearDown(void)
100 {
101 auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "com.test.dataprxoyhandle", 0);
102 AccessTokenKit::DeleteToken(tokenId);
103 }
104
105 /**
106 * @tc.name: OnAppInstallTest001
107 * @tc.desc: test receive app install event
108 * @tc.type: FUNC
109 * @tc.require:SQL
110 */
111 HWTEST_F(DataShareProxyHandleTest, OnAppInstallTest001, TestSize.Level1)
112 {
113 ZLOGI("DataShareProxyHandleTest OnAppInstallTest001 start");
114 auto testTokenId = GetSelfTokenID();
115 ProxyDataManager::GetInstance().OnAppInstall(BUNDLE_NAME, USER_TEST, 0, testTokenId);
116 DataShareServiceImpl dataShareServiceImpl;
117 std::vector<std::string> uris = { TEST_URI1, TEST_URI2 };
118 DataProxyConfig config;
119 config.type_ = DataProxyType::SHARED_CONFIG;
120 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
121 ASSERT_EQ(getResults.size(), uris.size());
122 for (auto const &result : getResults) {
123 EXPECT_EQ(result.result_, OHOS::DataShare::SUCCESS);
124 }
125 // see details in profile
126 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
127 EXPECT_EQ(getResults[0].value_, VALUE1);
128 EXPECT_EQ(getResults[0].allowList_.size(), 1);
129
130 EXPECT_EQ(getResults[1].uri_, TEST_URI2);
131 EXPECT_EQ(getResults[1].value_, VALUE2);
132 EXPECT_EQ(getResults[1].allowList_.size(), 1);
133
134 auto results = dataShareServiceImpl.DeleteProxyData(uris, config);
135 ASSERT_EQ(results.size(), uris.size());
136 EXPECT_EQ(results[0].uri_, TEST_URI1);
137 EXPECT_EQ(results[1].uri_, TEST_URI2);
138 for (auto const &result : results) {
139 EXPECT_EQ(result.result_, OHOS::DataShare::SUCCESS);
140 }
141 ZLOGI("DataShareProxyHandleTest OnAppInstallTest001 end");
142 }
143
144 /**
145 * @tc.name: OnAppInstallTest001
146 * @tc.desc: test receive app uninstall event
147 * @tc.type: FUNC
148 * @tc.require:SQL
149 */
150 HWTEST_F(DataShareProxyHandleTest, OnAppUninstallTest001, TestSize.Level1)
151 {
152 ZLOGI("DataShareProxyHandleTest OnAppUninstallTest001 start");
153 DataShareServiceImpl dataShareServiceImpl;
154 std::vector<DataShareProxyData> proxyDatas;
155 std::vector<std::string> allowList = { APPIDENTIFIER1 };
156 proxyDatas.emplace_back(TEST_URI1, VALUE1, allowList);
157 DataProxyConfig config;
158 config.type_ = DataProxyType::SHARED_CONFIG;
159 auto results = dataShareServiceImpl.PublishProxyData(proxyDatas, config);
160 ASSERT_EQ(results.size(), proxyDatas.size());
161 for (auto const &result : results) {
162 EXPECT_EQ(result.result_, OHOS::DataShare::SUCCESS);
163 }
164 EXPECT_EQ(results[0].uri_, TEST_URI1);
165
166 std::vector<std::string> uris = { TEST_URI1 };
167 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
168 ASSERT_EQ(getResults.size(), uris.size());
169 for (auto const &result : getResults) {
170 EXPECT_EQ(result.result_, OHOS::DataShare::SUCCESS);
171 }
172 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
173 EXPECT_EQ(getResults[0].value_, VALUE1);
174 EXPECT_EQ(getResults[0].allowList_.size(), 1);
175
176 auto testTokenId = GetSelfTokenID();
177 ProxyDataManager::GetInstance().OnAppUninstall(BUNDLE_NAME, USER_TEST, 0, testTokenId);
178
179 getResults = dataShareServiceImpl.GetProxyData(uris, config);
180 ASSERT_EQ(results.size(), uris.size());
181 for (auto const &result : getResults) {
182 EXPECT_EQ(result.result_, OHOS::DataShare::URI_NOT_EXIST);
183 }
184 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
185 ZLOGI("DataShareProxyHandleTest OnAppUninstallTest001 end");
186 }
187
188 /**
189 * @tc.name: OnAppUpdate001
190 * @tc.desc: test receive app update event
191 * @tc.type: FUNC
192 * @tc.require:SQL
193 */
194 HWTEST_F(DataShareProxyHandleTest, OnAppUpdateTest001, TestSize.Level1)
195 {
196 ZLOGI("DataShareProxyHandleTest OnAppUpdateTest001 start");
197 DataShareServiceImpl dataShareServiceImpl;
198 std::vector<DataShareProxyData> proxyDatas;
199 std::vector<std::string> allowList = { APPIDENTIFIER3 };
200 proxyDatas.emplace_back(TEST_URI3, VALUE3, allowList);
201 DataProxyConfig config;
202 config.type_ = DataProxyType::SHARED_CONFIG;
203 auto results = dataShareServiceImpl.PublishProxyData(proxyDatas, config);
204 ASSERT_EQ(results.size(), proxyDatas.size());
205 for (auto const &result : results) {
206 EXPECT_EQ(result.result_, OHOS::DataShare::SUCCESS);
207 }
208 EXPECT_EQ(results[0].uri_, TEST_URI3);
209
210 std::vector<std::string> uris = { TEST_URI3 };
211 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
212 ASSERT_EQ(getResults.size(), uris.size());
213 for (auto const &result : getResults) {
214 EXPECT_EQ(result.result_, OHOS::DataShare::SUCCESS);
215 }
216 EXPECT_EQ(getResults[0].uri_, TEST_URI3);
217 EXPECT_EQ(getResults[0].value_, VALUE3);
218 EXPECT_EQ(getResults[0].allowList_.size(), 1);
219
220 auto testTokenId = GetSelfTokenID();
221 ProxyDataManager::GetInstance().OnAppUpdate(BUNDLE_NAME, USER_TEST, 0, testTokenId);
222
223 std::vector<std::string> urisAfterUpdate = { TEST_URI1, TEST_URI2, TEST_URI3 };
224 getResults = dataShareServiceImpl.GetProxyData(urisAfterUpdate, config);
225 ASSERT_EQ(getResults.size(), urisAfterUpdate.size());
226 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
227 EXPECT_EQ(getResults[0].result_, OHOS::DataShare::SUCCESS);
228 EXPECT_EQ(getResults[1].uri_, TEST_URI2);
229 EXPECT_EQ(getResults[1].result_, OHOS::DataShare::SUCCESS);
230 EXPECT_EQ(getResults[2].uri_, TEST_URI3);
231 EXPECT_EQ(getResults[2].result_, OHOS::DataShare::URI_NOT_EXIST);
232
233 std::vector<std::string> urisToDelete = { TEST_URI1, TEST_URI2 };
234 results = dataShareServiceImpl.DeleteProxyData(uris, config);
235 ASSERT_EQ(results.size(), uris.size());
236 EXPECT_EQ(results[0].uri_, TEST_URI1);
237 EXPECT_EQ(results[1].uri_, TEST_URI2);
238 for (auto const &result : results) {
239 EXPECT_EQ(result.result_, OHOS::DataShare::SUCCESS);
240 }
241 ZLOGI("DataShareProxyHandleTest OnAppUpdateTest001 end");
242 }
243
244 /**
245 * @tc.name: PublishProxyData001
246 * @tc.desc: test publish proxyData with string value function
247 * @tc.type: FUNC
248 * @tc.require:SQL
249 */
250 HWTEST_F(DataShareProxyHandleTest, PublishProxyData001, TestSize.Level1)
251 {
252 ZLOGI("DataShareProxyHandleTest PublishProxyData001 start");
253 DataShareServiceImpl dataShareServiceImpl;
254 std::vector<DataShareProxyData> proxyDatas;
255 DataProxyValue strValue = "strValue";
256 std::vector<std::string> allowList = { APPIDENTIFIER1 };
257 proxyDatas.emplace_back(TEST_URI1, strValue, allowList);
258 DataProxyConfig config;
259 config.type_ = DataProxyType::SHARED_CONFIG;
260 auto results = dataShareServiceImpl.PublishProxyData(proxyDatas, config);
261 ASSERT_EQ(results.size(), proxyDatas.size());
262 EXPECT_EQ(results[0].uri_, TEST_URI1);
263 EXPECT_EQ(results[0].result_, OHOS::DataShare::SUCCESS);
264
265 std::vector<std::string> uris = { TEST_URI1 };
266 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
267 ASSERT_EQ(getResults.size(), uris.size());
268 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
269 EXPECT_EQ(getResults[0].result_, OHOS::DataShare::SUCCESS);
270 EXPECT_EQ(getResults[0].value_, strValue);
271 EXPECT_EQ(getResults[0].allowList_.size(), 1);
272
273 results = dataShareServiceImpl.DeleteProxyData(uris, config);
274 ASSERT_EQ(results.size(), uris.size());
275 EXPECT_EQ(results[0].uri_, TEST_URI1);
276 EXPECT_EQ(results[0].result_, OHOS::DataShare::SUCCESS);
277 ZLOGI("DataShareProxyHandleTest PublishProxyData001 end");
278 }
279
280 /**
281 * @tc.name: PublishProxyData002
282 * @tc.desc: test publish proxyData with int value function
283 * @tc.type: FUNC
284 * @tc.require:SQL
285 */
286 HWTEST_F(DataShareProxyHandleTest, PublishProxyData002, TestSize.Level1)
287 {
288 ZLOGI("DataShareProxyHandleTest PublishProxyData002 start");
289 DataShareServiceImpl dataShareServiceImpl;
290 std::vector<DataShareProxyData> proxyDatas;
291 DataProxyValue intValue = 100;
292 std::vector<std::string> allowList = { APPIDENTIFIER1 };
293 proxyDatas.emplace_back(TEST_URI1, intValue, allowList);
294 DataProxyConfig config;
295 config.type_ = DataProxyType::SHARED_CONFIG;
296 auto results = dataShareServiceImpl.PublishProxyData(proxyDatas, config);
297 ASSERT_EQ(results.size(), proxyDatas.size());
298 EXPECT_EQ(results[0].uri_, TEST_URI1);
299 EXPECT_EQ(results[0].result_, OHOS::DataShare::SUCCESS);
300
301 std::vector<std::string> uris = { TEST_URI1 };
302 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
303 ASSERT_EQ(getResults.size(), uris.size());
304 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
305 EXPECT_EQ(getResults[0].result_, OHOS::DataShare::SUCCESS);
306 EXPECT_EQ(getResults[0].value_, intValue);
307 EXPECT_EQ(getResults[0].allowList_.size(), 1);
308
309 results = dataShareServiceImpl.DeleteProxyData(uris, config);
310 ASSERT_EQ(results.size(), uris.size());
311 EXPECT_EQ(results[0].uri_, TEST_URI1);
312 EXPECT_EQ(results[0].result_, OHOS::DataShare::SUCCESS);
313 ZLOGI("DataShareProxyHandleTest PublishProxyData002 end");
314 }
315
316 /**
317 * @tc.name: PublishProxyData003
318 * @tc.desc: test publish proxyData with double value function
319 * @tc.type: FUNC
320 * @tc.require:SQL
321 */
322 HWTEST_F(DataShareProxyHandleTest, PublishProxyData003, TestSize.Level1)
323 {
324 ZLOGI("DataShareProxyHandleTest PublishProxyData003 start");
325 DataShareServiceImpl dataShareServiceImpl;
326 std::vector<DataShareProxyData> proxyDatas;
327 DataProxyValue fValue = 100.00;
328 std::vector<std::string> allowList = { APPIDENTIFIER1 };
329 proxyDatas.emplace_back(TEST_URI1, fValue, allowList);
330 DataProxyConfig config;
331 config.type_ = DataProxyType::SHARED_CONFIG;
332 auto results = dataShareServiceImpl.PublishProxyData(proxyDatas, config);
333 ASSERT_EQ(results.size(), proxyDatas.size());
334 EXPECT_EQ(results[0].uri_, TEST_URI1);
335 EXPECT_EQ(results[0].result_, OHOS::DataShare::SUCCESS);
336
337 std::vector<std::string> uris = { TEST_URI1 };
338 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
339 ASSERT_EQ(getResults.size(), uris.size());
340 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
341 EXPECT_EQ(getResults[0].result_, OHOS::DataShare::SUCCESS);
342 EXPECT_EQ(getResults[0].value_, fValue);
343 EXPECT_EQ(getResults[0].allowList_.size(), 1);
344
345 results = dataShareServiceImpl.DeleteProxyData(uris, config);
346 ASSERT_EQ(results.size(), uris.size());
347 EXPECT_EQ(results[0].uri_, TEST_URI1);
348 EXPECT_EQ(results[0].result_, OHOS::DataShare::SUCCESS);
349 ZLOGI("DataShareProxyHandleTest PublishProxyData003 end");
350 }
351
352 /**
353 * @tc.name: PublishProxyData004
354 * @tc.desc: test publish proxyData with bool value function
355 * @tc.type: FUNC
356 * @tc.require:SQL
357 */
358 HWTEST_F(DataShareProxyHandleTest, PublishProxyData004, TestSize.Level1)
359 {
360 ZLOGI("DataShareProxyHandleTest PublishProxyData004 start");
361 DataShareServiceImpl dataShareServiceImpl;
362 std::vector<DataShareProxyData> proxyDatas;
363 DataProxyValue boolValue = true;
364 std::vector<std::string> allowList = { APPIDENTIFIER1 };
365 proxyDatas.emplace_back(TEST_URI1, boolValue, allowList);
366 DataProxyConfig config;
367 config.type_ = DataProxyType::SHARED_CONFIG;
368 auto results = dataShareServiceImpl.PublishProxyData(proxyDatas, config);
369 ASSERT_EQ(results.size(), proxyDatas.size());
370 EXPECT_EQ(results[0].uri_, TEST_URI1);
371 EXPECT_EQ(results[0].result_, OHOS::DataShare::SUCCESS);
372
373 std::vector<std::string> uris = { TEST_URI1 };
374 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
375 ASSERT_EQ(getResults.size(), uris.size());
376 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
377 EXPECT_EQ(getResults[0].result_, OHOS::DataShare::SUCCESS);
378 EXPECT_EQ(getResults[0].value_, boolValue);
379 EXPECT_EQ(getResults[0].allowList_.size(), 1);
380
381 results = dataShareServiceImpl.DeleteProxyData(uris, config);
382 ASSERT_EQ(results.size(), uris.size());
383 EXPECT_EQ(results[0].uri_, TEST_URI1);
384 EXPECT_EQ(results[0].result_, OHOS::DataShare::SUCCESS);
385 ZLOGI("DataShareProxyHandleTest PublishProxyData004 end");
386 }
387
388 /**
389 * @tc.name: PublishProxyData005
390 * @tc.desc: test publish proxyData of other bundle function
391 * @tc.type: FUNC
392 * @tc.require:SQL
393 */
394 HWTEST_F(DataShareProxyHandleTest, PublishProxyData005, TestSize.Level1)
395 {
396 ZLOGI("DataShareProxyHandleTest PublishProxyData005 start");
397 DataShareServiceImpl dataShareServiceImpl;
398 std::vector<DataShareProxyData> proxyDatas;
399 DataProxyValue boolValue = true;
400 std::vector<std::string> allowList = { APPIDENTIFIER1 };
401 proxyDatas.emplace_back(TEST_URI_OTHER, boolValue, allowList);
402 DataProxyConfig config;
403 config.type_ = DataProxyType::SHARED_CONFIG;
404 std::vector<std::string> uris = { TEST_URI_OTHER };
405 auto results = dataShareServiceImpl.PublishProxyData(proxyDatas, config);
406 ASSERT_EQ(results.size(), proxyDatas.size());
407 EXPECT_EQ(results[0].uri_, TEST_URI_OTHER);
408 EXPECT_EQ(results[0].result_, OHOS::DataShare::NO_PERMISSION);
409 ZLOGI("DataShareProxyHandleTest PublishProxyData005 end");
410 }
411
412 /**
413 * @tc.name: DeleteProxyData001
414 * @tc.desc: test delete proxyData which is not published function
415 * @tc.type: FUNC
416 * @tc.require:SQL
417 */
418 HWTEST_F(DataShareProxyHandleTest, DeleteProxyData001, TestSize.Level1)
419 {
420 ZLOGI("DataShareProxyHandleTest DeleteProxyData001 start");
421 DataShareServiceImpl dataShareServiceImpl;
422 DataProxyConfig config;
423 config.type_ = DataProxyType::SHARED_CONFIG;
424 std::vector<std::string> uris = { TEST_URI1 };
425 auto results = dataShareServiceImpl.DeleteProxyData(uris, config);
426 ASSERT_EQ(results.size(), uris.size());
427 EXPECT_EQ(results[0].uri_, TEST_URI1);
428 EXPECT_EQ(results[0].result_, OHOS::DataShare::URI_NOT_EXIST);
429 ZLOGI("DataShareProxyHandleTest DeleteProxyData001 end");
430 }
431
432 /**
433 * @tc.name: DeleteProxyData002
434 * @tc.desc: test delete proxyData without permission function
435 * @tc.type: FUNC
436 * @tc.require:SQL
437 */
438 HWTEST_F(DataShareProxyHandleTest, DeleteProxyData002, TestSize.Level1)
439 {
440 ZLOGI("DataShareProxyHandleTest DeleteProxyData002 start");
441 DataShareServiceImpl dataShareServiceImpl;
442 DataProxyConfig config;
443 config.type_ = DataProxyType::SHARED_CONFIG;
444 std::vector<std::string> uris = { TEST_URI_OTHER };
445 auto results = dataShareServiceImpl.DeleteProxyData(uris, config);
446 ASSERT_EQ(results.size(), uris.size());
447 EXPECT_EQ(results[0].uri_, TEST_URI_OTHER);
448 EXPECT_EQ(results[0].result_, OHOS::DataShare::NO_PERMISSION);
449 ZLOGI("DataShareProxyHandleTest DeleteProxyData002 end");
450 }
451
452 /**
453 * @tc.name: GetProxyData001
454 * @tc.desc: test get proxyData without permission function
455 * @tc.type: FUNC
456 * @tc.require:SQL
457 */
458 HWTEST_F(DataShareProxyHandleTest, GetProxyData001, TestSize.Level1)
459 {
460 ZLOGI("DataShareProxyHandleTest GetProxyData001 start");
461 DataShareServiceImpl dataShareServiceImpl;
462 DataProxyConfig config;
463 config.type_ = DataProxyType::SHARED_CONFIG;
464 std::vector<std::string> uris = { TEST_URI1 };
465 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
466 ASSERT_EQ(getResults.size(), uris.size());
467 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
468 EXPECT_EQ(getResults[0].result_, OHOS::DataShare::URI_NOT_EXIST);
469 ZLOGI("DataShareProxyHandleTest GetProxyData001 end");
470 }
471
472 /**
473 * @tc.name: GetProxyData002
474 * @tc.desc: test get proxyData without permission function
475 * @tc.type: FUNC
476 * @tc.require:SQL
477 */
478 HWTEST_F(DataShareProxyHandleTest, GetProxyData002, TestSize.Level1)
479 {
480 ZLOGI("DataShareProxyHandleTest GetProxyData002 start");
481 auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, BUNDLE_NAME, 0);
482 AccessTokenKit::DeleteToken(tokenId);
483 DataShareServiceImpl dataShareServiceImpl;
484 DataProxyConfig config;
485 config.type_ = DataProxyType::SHARED_CONFIG;
486 std::vector<std::string> uris = { TEST_URI1 };
487 auto getResults = dataShareServiceImpl.GetProxyData(uris, config);
488 ASSERT_EQ(getResults.size(), uris.size());
489 EXPECT_EQ(getResults[0].uri_, TEST_URI1);
490 EXPECT_EQ(getResults[0].result_, OHOS::DataShare::NO_PERMISSION);
491 SetSelfTokenID(tokenId);
492 ZLOGI("DataShareProxyHandleTest GetProxyData002 end");
493 }
494 } // namespace OHOS::Test