1 /*
2  * Copyright (c) 2022-2024 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 "remote_token_kit_test.h"
17 #include <thread>
18 
19 #include "accesstoken_kit.h"
20 #include "accesstoken_log.h"
21 #include "access_token_error.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 
25 using namespace testing::ext;
26 using namespace OHOS::Security::AccessToken;
27 
28 namespace {
29 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "RemoteTokenKitTest"};
30 
31 static const std::string TEST_BUNDLE_NAME = "ohos";
32 static const std::string TEST_PKG_NAME = "com.softbus.test";
33 static const int TEST_USER_ID = 0;
34 
35 PermissionDef g_infoManagerTestPermDef1 = {
36     .permissionName = "ohos.permission.test1",
37     .bundleName = "accesstoken_test",
38     .grantMode = 1,
39     .availableLevel = APL_NORMAL,
40     .label = "label4",
41     .labelId = 1,
42     .description = "open the door",
43     .descriptionId = 1,
44 };
45 
46 PermissionDef g_infoManagerTestPermDef2 = {
47     .permissionName = "ohos.permission.test2",
48     .bundleName = "accesstoken_test",
49     .grantMode = 1,
50     .availableLevel = APL_NORMAL,
51     .label = "label4",
52     .labelId = 1,
53     .description = "break the door",
54     .descriptionId = 1,
55 };
56 
57 PermissionStateFull g_infoManagerTestState1 = {
58     .permissionName = "ohos.permission.test1",
59     .isGeneral = true,
60     .resDeviceID = {"local4"},
61     .grantStatus = {PermissionState::PERMISSION_GRANTED},
62     .grantFlags = {1},
63 };
64 
65 PermissionStateFull g_infoManagerTestState2 = {
66     .permissionName = "ohos.permission.test2",
67     .isGeneral = false,
68     .resDeviceID = {"device 1", "device 2"},
69     .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED},
70     .grantFlags = {1, 2},
71 };
72 
73 HapInfoParams g_infoManagerTestInfoParms = {
74     .userID = 1,
75     .bundleName = "accesstoken_test",
76     .instIndex = 0,
77     .appIDDesc = "test4"
78 };
79 
80 HapPolicyParams g_infoManagerTestPolicyPrams = {
81     .apl = APL_NORMAL,
82     .domain = "test.domain4",
83     .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
84     .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
85 };
86 
87 HapInfoParams g_infoManagerTestInfoParmsBak = {
88     .userID = 1,
89     .bundleName = "accesstoken_test",
90     .instIndex = 0,
91     .appIDDesc = "test4"
92 };
93 
94 HapPolicyParams g_infoManagerTestPolicyPramsBak = {
95     .apl = APL_NORMAL,
96     .domain = "test.domain4",
97     .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
98     .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
99 };
100 
101 HapTokenInfo g_baseInfo = {
102     .apl = APL_NORMAL,
103     .ver = 1,
104     .userID = 1,
105     .bundleName = "com.ohos.access_token",
106     .instIndex = 1,
107     .appID = "test4",
108     .tokenID = 0x20100000,
109     .tokenAttr = 0
110 };
111 
NativeTokenGet()112 void NativeTokenGet()
113 {
114     uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service");
115     ASSERT_NE(tokenId, INVALID_TOKENID);
116     EXPECT_EQ(0, SetSelfTokenID(tokenId));
117 }
118 
119 #ifdef TOKEN_SYNC_ENABLE
120 static const int32_t FAKE_SYNC_RET = 0xabcdef;
121 class TokenSyncCallbackImpl : public TokenSyncKitInterface {
122 public:
~TokenSyncCallbackImpl()123     ~TokenSyncCallbackImpl()
124     {}
125 
GetRemoteHapTokenInfo(const std::string & deviceID,AccessTokenID tokenID) const126     int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override
127     {
128         ACCESSTOKEN_LOG_INFO(LABEL, "GetRemoteHapTokenInfo called.");
129         return FAKE_SYNC_RET;
130     };
131 
DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const132     int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override
133     {
134         ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteHapTokenInfo called.");
135         return FAKE_SYNC_RET;
136     };
137 
UpdateRemoteHapTokenInfo(const HapTokenInfoForSync & tokenInfo) const138     int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override
139     {
140         ACCESSTOKEN_LOG_INFO(LABEL, "UpdateRemoteHapTokenInfo called.");
141         return FAKE_SYNC_RET;
142     };
143 };
144 #endif
145 }
146 
SetUpTestCase()147 void RemoteTokenKitTest::SetUpTestCase()
148 {
149     // make test case clean
150     AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
151                                                           g_infoManagerTestInfoParms.bundleName,
152                                                           g_infoManagerTestInfoParms.instIndex);
153     AccessTokenKit::DeleteToken(tokenID);
154 
155     tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
156     AccessTokenKit::DeleteToken(tokenID);
157 
158     NativeTokenGet();
159 
160 #ifdef TOKEN_SYNC_ENABLE
161     std::shared_ptr<TestDmInitCallback> ptrDmInitCallback = std::make_shared<TestDmInitCallback>();
162     int32_t res = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback);
163     ASSERT_EQ(res, RET_SUCCESS);
164 #endif
165 }
166 
TearDownTestCase()167 void RemoteTokenKitTest::TearDownTestCase()
168 {
169 #ifdef TOKEN_SYNC_ENABLE
170     int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME);
171     ASSERT_EQ(res, RET_SUCCESS);
172 #endif
173 }
174 
SetUp()175 void RemoteTokenKitTest::SetUp()
176 {
177     selfTokenId_ = GetSelfTokenID();
178     g_infoManagerTestInfoParms = g_infoManagerTestInfoParmsBak;
179     g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak;
180     AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
181                                                           g_infoManagerTestInfoParms.bundleName,
182                                                           g_infoManagerTestInfoParms.instIndex);
183     AccessTokenKit::DeleteToken(tokenID);
184 
185 #ifdef TOKEN_SYNC_ENABLE
186     DistributedHardware::DmDeviceInfo deviceInfo;
187     int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo);
188     ASSERT_EQ(res, RET_SUCCESS);
189 
190     networkId_ = std::string(deviceInfo.networkId);
191     ASSERT_NE(networkId_, "");
192 
193     res = DistributedHardware::DeviceManager::GetInstance().GetUdidByNetworkId(TEST_PKG_NAME, networkId_, udid_);
194     ASSERT_EQ(res, RET_SUCCESS);
195     ASSERT_NE(udid_, "");
196 #endif
197 
198     ACCESSTOKEN_LOG_INFO(LABEL, "SetUp ok.");
199 }
200 
TearDown()201 void RemoteTokenKitTest::TearDown()
202 {
203     AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
204     AccessTokenKit::DeleteToken(tokenID);
205     EXPECT_EQ(0, SetSelfTokenID(selfTokenId_));
206     udid_.clear();
207     networkId_.clear();
208 }
209 
GetAccessTokenID(int userID,std::string bundleName,int instIndex)210 unsigned int RemoteTokenKitTest::GetAccessTokenID(int userID, std::string bundleName, int instIndex)
211 {
212     return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
213 }
214 
DeleteTestToken() const215 void RemoteTokenKitTest::DeleteTestToken() const
216 {
217     AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
218                                                           g_infoManagerTestInfoParms.bundleName,
219                                                           g_infoManagerTestInfoParms.instIndex);
220     int ret = AccessTokenKit::DeleteToken(tokenID);
221     if (tokenID != 0) {
222         ASSERT_EQ(RET_SUCCESS, ret);
223     }
224 }
225 
AllocTestToken() const226 void RemoteTokenKitTest::AllocTestToken() const
227 {
228     AccessTokenIDEx tokenIdEx = {0};
229     tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
230     ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
231 }
232 
233 #ifdef TOKEN_SYNC_ENABLE
234 /**
235  * @tc.name: SetRemoteHapTokenInfo001
236  * @tc.desc: set remote hap token info success
237  * @tc.type: FUNC
238  * @tc.require:issue I5R4UF
239  */
240 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo001, TestSize.Level1)
241 {
242     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo001 start.");
243     std::string deviceID1 = udid_;
244     AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000);
245     PermissionStateFull infoManagerTestState2 = {
246         .permissionName = "ohos.permission.CAMERA",
247          .isGeneral = true,
248         .resDeviceID = {"local4"},
249         .grantStatus = {PermissionState::PERMISSION_GRANTED},
250         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
251     std::vector<PermissionStateFull> permStateList1;
252     permStateList1.emplace_back(infoManagerTestState2);
253 
254     g_baseInfo.deviceID = deviceID1;
255     HapTokenInfoForSync remoteTokenInfo1 = {
256         .baseInfo = g_baseInfo,
257         .permStateList = permStateList1
258     };
259 
260     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo1);
261     ASSERT_EQ(ret, RET_SUCCESS);
262 
263     // Get local map token ID
264     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
265     ASSERT_NE(mapID, 0);
266 
267     // check local map token
268     HapTokenInfo resultInfo;
269     ret = AccessTokenKit::GetHapTokenInfo(mapID, resultInfo);
270     ASSERT_EQ(ret, RET_SUCCESS);
271     ASSERT_EQ(resultInfo.apl, remoteTokenInfo1.baseInfo.apl);
272     ASSERT_EQ(resultInfo.ver, remoteTokenInfo1.baseInfo.ver);
273     ASSERT_EQ(resultInfo.userID, remoteTokenInfo1.baseInfo.userID);
274     ASSERT_EQ(resultInfo.bundleName, remoteTokenInfo1.baseInfo.bundleName);
275     ASSERT_EQ(resultInfo.instIndex, remoteTokenInfo1.baseInfo.instIndex);
276     ASSERT_EQ(resultInfo.appID, remoteTokenInfo1.baseInfo.appID);
277     ASSERT_EQ(resultInfo.deviceID, remoteTokenInfo1.baseInfo.deviceID);
278     ASSERT_NE(resultInfo.tokenID, remoteTokenInfo1.baseInfo.tokenID); // tokenID already is map tokenID
279     ASSERT_EQ(resultInfo.tokenAttr, remoteTokenInfo1.baseInfo.tokenAttr);
280 
281     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false);
282     ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
283 
284     ret = AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000);
285     ASSERT_EQ(ret, RET_SUCCESS);
286 }
287 
SetRemoteHapTokenInfoWithWrongInfo(HapTokenInfo & wrongBaseInfo,const HapTokenInfo & rightBaseInfo,HapTokenInfoForSync & remoteTokenInfo,const std::string & deviceID)288 void SetRemoteHapTokenInfoWithWrongInfo(HapTokenInfo &wrongBaseInfo, const HapTokenInfo &rightBaseInfo,
289     HapTokenInfoForSync &remoteTokenInfo, const std::string &deviceID)
290 {
291     std::string wrongStr(10241, 'x'); // 10241 means the invalid string length
292 
293     wrongBaseInfo = rightBaseInfo;
294     wrongBaseInfo.appID = wrongStr; // wrong appID
295     remoteTokenInfo.baseInfo = wrongBaseInfo;
296     int32_t ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
297     EXPECT_NE(ret, RET_SUCCESS);
298 
299     wrongBaseInfo = rightBaseInfo;
300     wrongBaseInfo.bundleName = wrongStr; // wrong bundleName
301     remoteTokenInfo.baseInfo = wrongBaseInfo;
302     ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
303     EXPECT_NE(ret, RET_SUCCESS);
304 
305     wrongBaseInfo = rightBaseInfo;
306     wrongBaseInfo.deviceID = wrongStr; // wrong deviceID
307     remoteTokenInfo.baseInfo = wrongBaseInfo;
308     ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
309     EXPECT_NE(ret, RET_SUCCESS);
310 
311     wrongBaseInfo = rightBaseInfo;
312     wrongBaseInfo.tokenID = 0; // wrong tokenID
313     remoteTokenInfo.baseInfo = wrongBaseInfo;
314     ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
315     EXPECT_NE(ret, RET_SUCCESS);
316 }
317 
318 /**
319  * @tc.name: SetRemoteHapTokenInfo002
320  * @tc.desc: set remote hap token info, token info is wrong
321  * @tc.type: FUNC
322  * @tc.require:issue I5R4UF
323  */
324 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo002, TestSize.Level1)
325 {
326     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo002 start.");
327     std::string deviceID2 = udid_;
328     AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
329     HapTokenInfo rightBaseInfo = {
330         .apl = APL_NORMAL,
331         .ver = 1,
332         .userID = 1,
333         .bundleName = "com.ohos.access_token",
334         .instIndex = 1,
335         .appID = "test4",
336         .deviceID = udid_,
337         .tokenID = 0x20100000,
338         .tokenAttr = 0
339     };
340 
341     HapTokenInfo wrongBaseInfo = rightBaseInfo;
342     wrongBaseInfo.apl = (ATokenAplEnum)11; // wrong apl
343 
344     PermissionStateFull infoManagerTestState_2 = {
345         .permissionName = "ohos.permission.test1",
346         .isGeneral = true,
347         .resDeviceID = {"local"},
348         .grantStatus = {PermissionState::PERMISSION_GRANTED},
349         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
350     std::vector<PermissionStateFull> permStateList2;
351     permStateList2.emplace_back(infoManagerTestState_2);
352 
353     HapTokenInfoForSync remoteTokenInfo2 = {
354         .baseInfo = wrongBaseInfo,
355         .permStateList = permStateList2
356     };
357 
358     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo2);
359     ASSERT_NE(ret, RET_SUCCESS);
360 
361     SetRemoteHapTokenInfoWithWrongInfo(wrongBaseInfo, rightBaseInfo, remoteTokenInfo2, deviceID2);
362 }
363 
364 /**
365  * @tc.name: SetRemoteHapTokenInfo003
366  * @tc.desc: set remote hap token wrong permission grant
367  * @tc.type: FUNC
368  * @tc.require:issue I5R4UF
369  */
370 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo003, TestSize.Level1)
371 {
372     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo003 start.");
373     std::string deviceID3 = udid_;
374     AccessTokenKit::DeleteRemoteToken(deviceID3, 0x20100000);
375 
376     PermissionStateFull infoManagerTestState_3 = {
377         .permissionName = "ohos.permission.test1",
378         .isGeneral = true,
379         .resDeviceID = {"local"},
380         .grantStatus = {PermissionState::PERMISSION_GRANTED},
381         .grantFlags = {11}, // wrong flags
382         };
383     std::vector<PermissionStateFull> permStateList3;
384     permStateList3.emplace_back(infoManagerTestState_3);
385 
386     g_baseInfo.deviceID = deviceID3;
387     HapTokenInfoForSync remoteTokenInfo3 = {
388         .baseInfo = g_baseInfo,
389         .permStateList = permStateList3
390     };
391 
392     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID3, remoteTokenInfo3);
393     ASSERT_EQ(ret, RET_SUCCESS);
394 
395     // Get local map token ID
396     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
397     ASSERT_NE(mapID, 0);
398 
399     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1", false);
400     ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
401 
402     ret = AccessTokenKit::DeleteRemoteToken(deviceID3, 0x20100000);
403     ASSERT_EQ(ret, RET_SUCCESS);
404 }
405 
406 /**
407  * @tc.name: SetRemoteHapTokenInfo004
408  * @tc.desc: update remote hap token when remote exist
409  * @tc.type: FUNC
410  * @tc.require:issue I5R4UF
411  */
412 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo004, TestSize.Level1)
413 {
414     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo004 start.");
415     std::string deviceID4 = udid_;
416     AccessTokenKit::DeleteRemoteToken(deviceID4, 0x20100000);
417     PermissionStateFull infoManagerTestState_4 = {
418         .permissionName = "ohos.permission.CAMERA",
419         .isGeneral = true,
420         .resDeviceID = {"local"},
421         .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
422         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
423     std::vector<PermissionStateFull> permStateList4;
424     permStateList4.emplace_back(infoManagerTestState_4);
425 
426     g_baseInfo.deviceID = deviceID4;
427     HapTokenInfoForSync remoteTokenInfo4 = {
428         .baseInfo = g_baseInfo,
429         .permStateList = permStateList4
430     };
431 
432     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID4, remoteTokenInfo4);
433     ASSERT_EQ(ret, RET_SUCCESS);
434 
435     // Get local map token ID
436     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
437     ASSERT_NE(mapID, 0);
438 
439     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false);
440     ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
441 
442     remoteTokenInfo4.permStateList[0].grantStatus[0] = PermissionState::PERMISSION_GRANTED; // second granted
443     ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID4, remoteTokenInfo4);
444     ASSERT_EQ(ret, RET_SUCCESS);
445 
446     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false);
447     ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
448 
449     ret = AccessTokenKit::DeleteRemoteToken(deviceID4, 0x20100000);
450     ASSERT_EQ(ret, RET_SUCCESS);
451 }
452 
453 /**
454  * @tc.name: SetRemoteHapTokenInfo005
455  * @tc.desc: add remote hap token, it can not grant by GrantPermission
456  * @tc.type: FUNC
457  * @tc.require:issue I5R4UF
458  */
459 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo005, TestSize.Level1)
460 {
461     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo005 start.");
462     std::string deviceID5 = udid_;
463     AccessTokenKit::DeleteRemoteToken(deviceID5, 0x20100000);
464     PermissionStateFull infoManagerTestState5 = {
465         .permissionName = "ohos.permission.test1",
466         .isGeneral = true,
467         .resDeviceID = {"local"},
468         .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
469         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
470     std::vector<PermissionStateFull> permStateList5;
471     permStateList5.emplace_back(infoManagerTestState5);
472 
473     g_baseInfo.deviceID = deviceID5;
474     HapTokenInfoForSync remoteTokenInfo5 = {
475         .baseInfo = g_baseInfo,
476         .permStateList = permStateList5
477     };
478 
479     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID5, remoteTokenInfo5);
480     ASSERT_EQ(ret, RET_SUCCESS);
481 
482     // Get local map token ID
483     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
484     ASSERT_NE(mapID, 0);
485 
486     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1", false);
487     ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
488 
489     ret = AccessTokenKit::GrantPermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED);
490     ASSERT_EQ(ret, ERR_PERMISSION_NOT_EXIST);
491 
492     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1", false);
493     ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
494 
495     ret = AccessTokenKit::DeleteRemoteToken(deviceID5, 0x20100000);
496     ASSERT_EQ(ret, RET_SUCCESS);
497 }
498 
499 /**
500  * @tc.name: SetRemoteHapTokenInfo006
501  * @tc.desc: add remote hap token, it can not revoke by RevokePermission
502  * @tc.type: FUNC
503  * @tc.require:issue I5R4UF
504  */
505 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo006, TestSize.Level1)
506 {
507     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo006 start.");
508     std::string deviceID6 = udid_;
509     AccessTokenKit::DeleteRemoteToken(deviceID6, 0x20100000);
510     PermissionStateFull infoManagerTestState6 = {
511         .permissionName = "ohos.permission.test1",
512         .isGeneral = true,
513         .resDeviceID = {"local4"},
514         .grantStatus = {PermissionState::PERMISSION_GRANTED}, // first grant
515         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
516     std::vector<PermissionStateFull> permStateList6;
517     permStateList6.emplace_back(infoManagerTestState6);
518 
519     g_baseInfo.deviceID = deviceID6;
520     HapTokenInfoForSync remoteTokenInfo6 = {
521         .baseInfo = g_baseInfo,
522         .permStateList = permStateList6
523     };
524 
525     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID6, remoteTokenInfo6);
526     ASSERT_EQ(ret, RET_SUCCESS);
527 
528     // Get local map token ID
529     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
530     ASSERT_NE(mapID, 0);
531 
532     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1", false);
533     EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED);
534 
535     ret = AccessTokenKit::RevokePermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED);
536     EXPECT_EQ(ret, ERR_PERMISSION_NOT_EXIST);
537 
538     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1", false);
539     EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED);
540 
541     ret = AccessTokenKit::DeleteRemoteToken(deviceID6, 0x20100000);
542     EXPECT_EQ(ret, RET_SUCCESS);
543 }
544 
545 /**
546  * @tc.name: SetRemoteHapTokenInfo007
547  * @tc.desc: add remote hap token, it can not delete by DeleteToken
548  * @tc.type: FUNC
549  * @tc.require:issue I5R4UF
550  */
551 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo007, TestSize.Level1)
552 {
553     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo007 start.");
554     std::string deviceID7 = udid_;
555     AccessTokenKit::DeleteRemoteToken(deviceID7, 0x20100000);
556     PermissionStateFull infoManagerTestState7 = {
557         .permissionName = "ohos.permission.test1",
558         .isGeneral = true,
559         .resDeviceID = {"local"},
560         .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
561         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
562     std::vector<PermissionStateFull> permStateList7;
563     permStateList7.emplace_back(infoManagerTestState7);
564 
565     g_baseInfo.deviceID = deviceID7;
566     HapTokenInfoForSync remoteTokenInfo7 = {
567         .baseInfo = g_baseInfo,
568         .permStateList = permStateList7
569     };
570 
571     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID7, remoteTokenInfo7);
572     ASSERT_EQ(ret, RET_SUCCESS);
573 
574     // Get local map token ID
575     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
576     ASSERT_NE(mapID, 0);
577 
578     ret = AccessTokenKit::DeleteToken(mapID);
579     ASSERT_NE(ret, RET_SUCCESS);
580 
581     ret = AccessTokenKit::DeleteRemoteToken(deviceID7, 0x20100000);
582     ASSERT_EQ(ret, RET_SUCCESS);
583 }
584 
585 /**
586  * @tc.name: SetRemoteHapTokenInfo008
587  * @tc.desc: add remote hap token, it can not update by UpdateHapToken
588  * @tc.type: FUNC
589  * @tc.require:issue I5R4UF
590  */
591 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo008, TestSize.Level1)
592 {
593     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo008 start.");
594     std::string deviceID8 = udid_;
595     AccessTokenKit::DeleteRemoteToken(deviceID8, 0x20100000);
596     int32_t DEFAULT_API_VERSION = 8;
597     PermissionStateFull infoManagerTestState8 = {
598         .permissionName = "ohos.permission.test1",
599         .isGeneral = true,
600         .resDeviceID = {"local"},
601         .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
602         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
603     std::vector<PermissionStateFull> permStateList8;
604     permStateList8.emplace_back(infoManagerTestState8);
605 
606     g_baseInfo.deviceID = deviceID8;
607     HapTokenInfoForSync remoteTokenInfo8 = {
608         .baseInfo = g_baseInfo,
609         .permStateList = permStateList8
610     };
611 
612     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID8, remoteTokenInfo8);
613     ASSERT_EQ(ret, RET_SUCCESS);
614 
615     // Get local map token ID
616     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
617     ASSERT_NE(mapID, 0);
618     AccessTokenIDEx tokenIdEx {
619         .tokenIdExStruct.tokenID = mapID,
620         .tokenIdExStruct.tokenAttr = 0,
621     };
622     HapPolicyParams policy;
623     UpdateHapInfoParams info;
624     info.appIDDesc = std::string("updateFailed");
625     info.apiVersion = DEFAULT_API_VERSION;
626     info.isSystemApp = false;
627     ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, policy);
628     ASSERT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID);
629 
630     ret = AccessTokenKit::DeleteRemoteToken(deviceID8, 0x20100000);
631     ASSERT_EQ(ret, RET_SUCCESS);
632 }
633 
634 /**
635  * @tc.name: SetRemoteHapTokenInfo009
636  * @tc.desc: add remote hap token, it can not clear by ClearUserGrantedPermissionState
637  * @tc.type: FUNC
638  * @tc.require:issue I5R4UF
639  */
640 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo009, TestSize.Level1)
641 {
642     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo009 start.");
643     std::string deviceID9 = udid_;
644     AccessTokenKit::DeleteRemoteToken(deviceID9, 0x20100000);
645     PermissionStateFull infoManagerTestState9 = {
646         .permissionName = "ohos.permission.CAMERA",
647         .isGeneral = true,
648         .resDeviceID = {"local4"},
649         .grantStatus = {PermissionState::PERMISSION_GRANTED},
650         .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
651     std::vector<PermissionStateFull> permStateList9;
652     permStateList9.emplace_back(infoManagerTestState9);
653 
654     g_baseInfo.deviceID = deviceID9;
655     HapTokenInfoForSync remoteTokenInfo9 = {
656         .baseInfo = g_baseInfo,
657         .permStateList = permStateList9
658     };
659 
660     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID9, remoteTokenInfo9);
661     ASSERT_EQ(ret, RET_SUCCESS);
662 
663     // Get local map token ID
664     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
665     ASSERT_NE(mapID, 0);
666 
667     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false);
668     ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
669 
670     ret = AccessTokenKit::ClearUserGrantedPermissionState(mapID);
671     ASSERT_EQ(ret, RET_SUCCESS);
672 
673     ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false);
674     ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
675 
676     ret = AccessTokenKit::DeleteRemoteToken(deviceID9, 0x20100000);
677     ASSERT_EQ(ret, RET_SUCCESS);
678 }
679 
680 /**
681  * @tc.name: SetRemoteHapTokenInfo010
682  * @tc.desc: tokenID is not hap token
683  * @tc.type: FUNC
684  * @tc.require:issue I5R4UF
685  */
686 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo010, TestSize.Level1)
687 {
688     ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo009 start.");
689     std::string deviceID = udid_;
690     HapTokenInfo baseInfo = {
691         .apl = APL_NORMAL,
692         .ver = 1,
693         .userID = 1,
694         .bundleName = "com.ohos.access_token",
695         .instIndex = 1,
696         .appID = "testtesttesttest",
697         .deviceID = udid_,
698         .tokenID = 0x28100000,
699         .tokenAttr = 0
700     };
701 
702     PermissionStateFull infoManagerTestState = {
703         .permissionName = "ohos.permission.test1",
704         .isGeneral = true,
705         .resDeviceID = {"local"},
706         .grantStatus = {PermissionState::PERMISSION_GRANTED},
707         .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
708     std::vector<PermissionStateFull> permStateList;
709     permStateList.emplace_back(infoManagerTestState);
710 
711     HapTokenInfoForSync remoteTokenInfo = {
712         .baseInfo = baseInfo,
713         .permStateList = permStateList
714     };
715 
716     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
717     ASSERT_NE(ret, RET_SUCCESS);
718 }
719 
720 /**
721  * @tc.name: DeleteRemoteDeviceToken001
722  * @tc.desc: delete exist device mapping tokenId
723  * @tc.type: FUNC
724  * @tc.require:issue I5R4UF
725  */
726 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceToken001, TestSize.Level1)
727 {
728     ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
729     std::string deviceID1 = udid_;
730     AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000);
731     PermissionStateFull infoManagerTestState_3 = {
732         .permissionName = "ohos.permission.test1",
733         .isGeneral = true,
734         .resDeviceID = {"local4"},
735         .grantStatus = {PermissionState::PERMISSION_GRANTED},
736         .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
737     std::vector<PermissionStateFull> permStateList1;
738     permStateList1.emplace_back(infoManagerTestState_3);
739 
740     g_baseInfo.deviceID = deviceID1;
741     HapTokenInfoForSync remoteTokenInfo11 = {
742         .baseInfo = g_baseInfo,
743         .permStateList = permStateList1
744     };
745 
746     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo11);
747     ASSERT_EQ(ret, RET_SUCCESS);
748 
749     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
750     ASSERT_NE(mapID, 0);
751 
752     HapTokenInfo info;
753     ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
754     ASSERT_EQ(ret, RET_SUCCESS);
755 
756     ret = AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000);
757     ASSERT_EQ(ret, RET_SUCCESS);
758 
759     ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
760     ASSERT_NE(ret, RET_SUCCESS);
761 }
762 
763 /**
764  * @tc.name: DeleteRemoteDeviceToken002
765  * @tc.desc: delete exist device mapping tokenId
766  * @tc.type: FUNC
767  * @tc.require:issue I5R4UF
768  */
769 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceToken002, TestSize.Level1)
770 {
771     ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
772     std::string deviceID2 = udid_;
773     AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
774     PermissionStateFull infoManagerTestState_2 = {
775         .permissionName = "ohos.permission.test1",
776         .isGeneral = true,
777         .resDeviceID = {"local4"},
778         .grantStatus = {PermissionState::PERMISSION_GRANTED},
779         .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
780     std::vector<PermissionStateFull> permStateList2;
781     permStateList2.emplace_back(infoManagerTestState_2);
782 
783     g_baseInfo.deviceID = deviceID2;
784     HapTokenInfoForSync remoteTokenInfo2 = {
785         .baseInfo = g_baseInfo,
786         .permStateList = permStateList2
787     };
788 
789     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo2);
790     ASSERT_EQ(ret, RET_SUCCESS);
791 
792     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
793     ASSERT_NE(mapID, 0);
794 
795     HapTokenInfo info;
796     ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
797     ASSERT_EQ(ret, RET_SUCCESS);
798 
799     ret = AccessTokenKit::DeleteRemoteToken(deviceID2, 0);
800     ASSERT_NE(ret, RET_SUCCESS);
801 
802     // deviceID is wrong
803     std::string wrongStr(10241, 'x');
804     deviceID2 = wrongStr;
805     ret = AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
806     ASSERT_NE(ret, RET_SUCCESS);
807 }
808 
809 /**
810  * @tc.name: DeleteRemoteDeviceToken003
811  * @tc.desc: delete exist device mapping tokenId
812  * @tc.type: FUNC
813  * @tc.require:issue I5R4UF
814  */
815 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceToken003, TestSize.Level1)
816 {
817     ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceToken003 start.");
818     std::string deviceID3 = udid_;
819     AccessTokenKit::DeleteRemoteToken(deviceID3, 0x20100000);
820 
821     int ret = AccessTokenKit::DeleteRemoteToken(deviceID3, 0x20100000);
822     ASSERT_NE(ret, RET_SUCCESS);
823 }
824 
825 /**
826  * @tc.name: DeleteRemoteDeviceTokens001
827  * @tc.desc: delete all mapping tokens of exist device
828  * @tc.type: FUNC
829  * @tc.require:issue I5R4UF
830  */
831 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceTokens001, TestSize.Level1)
832 {
833     ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
834     std::string deviceID1 = udid_;
835     AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000);
836     AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100001);
837     PermissionStateFull infoManagerTestState4 = {
838         .permissionName = "ohos.permission.test1",
839         .isGeneral = true,
840         .resDeviceID = {"local4"},
841         .grantStatus = {PermissionState::PERMISSION_GRANTED},
842         .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
843     std::vector<PermissionStateFull> permStateList1;
844     permStateList1.emplace_back(infoManagerTestState4);
845 
846     g_baseInfo.deviceID = deviceID1;
847     HapTokenInfoForSync remoteTokenInfo1 = {
848         .baseInfo = g_baseInfo,
849         .permStateList = permStateList1
850     };
851 
852     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo1);
853     ASSERT_EQ(ret, RET_SUCCESS);
854 
855     HapTokenInfoForSync remoteTokenInfo2 = remoteTokenInfo1;
856     remoteTokenInfo2.baseInfo.tokenID = 0x20100001;
857     remoteTokenInfo2.baseInfo.bundleName = "com.ohos.access_token1";
858     ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo2);
859     ASSERT_EQ(ret, RET_SUCCESS);
860 
861     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
862     ASSERT_NE(mapID, 0);
863     AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100001);
864     ASSERT_NE(mapID1, 0);
865 
866     ret = AccessTokenKit::DeleteRemoteDeviceTokens(deviceID1);
867     ASSERT_EQ(ret, RET_SUCCESS);
868 
869     HapTokenInfo info;
870     ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
871     ASSERT_NE(ret, RET_SUCCESS);
872     ret = AccessTokenKit::GetHapTokenInfo(mapID1, info);
873     ASSERT_NE(ret, RET_SUCCESS);
874 }
875 
876 /**
877  * @tc.name: DeleteRemoteDeviceTokens002
878  * @tc.desc: delete all mapping tokens of NOT exist device
879  * @tc.type: FUNC
880  * @tc.require:issue I5R4UF
881  */
882 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceTokens002, TestSize.Level1)
883 {
884     ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens002 start.");
885     std::string deviceID2 = udid_;
886     AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
887     AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100001);
888     PermissionStateFull infoManagerTestState2 = {
889         .permissionName = "ohos.permission.test1",
890         .isGeneral = true,
891         .resDeviceID = {"local"},
892         .grantStatus = {PermissionState::PERMISSION_GRANTED},
893         .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
894     std::vector<PermissionStateFull> permStateList2;
895     permStateList2.emplace_back(infoManagerTestState2);
896 
897     g_baseInfo.deviceID = deviceID2;
898     HapTokenInfoForSync remoteTokenInfo2 = {
899         .baseInfo = g_baseInfo,
900         .permStateList = permStateList2
901     };
902 
903     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo2);
904     ASSERT_EQ(ret, RET_SUCCESS);
905 
906     HapTokenInfoForSync remoteTokenInfo1 = remoteTokenInfo2;
907     remoteTokenInfo1.baseInfo.tokenID = 0x20100001;
908     remoteTokenInfo1.baseInfo.bundleName = "com.ohos.access_token1";
909     ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo1);
910     ASSERT_EQ(ret, RET_SUCCESS);
911 
912     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
913     ASSERT_NE(mapID, 0);
914     AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100001);
915     ASSERT_NE(mapID1, 0);
916 
917     ret = AccessTokenKit::DeleteRemoteDeviceTokens("1111111");
918     ASSERT_NE(ret, RET_SUCCESS);
919 
920     AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
921     AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100001);
922 }
923 
924 /**
925  * @tc.name: GetHapTokenInfoFromRemote001
926  * @tc.desc: get normal local tokenInfo
927  * @tc.type: FUNC
928  * @tc.require:issue I5R4UF
929  */
930 HWTEST_F(RemoteTokenKitTest, GetHapTokenInfoFromRemote001, TestSize.Level1)
931 {
932     ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote001 start.");
933     AccessTokenIDEx tokenIdEx = {0};
934     tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
935     AccessTokenID localTokenID = tokenIdEx.tokenIdExStruct.tokenID;
936 
937     HapTokenInfoForSync infoSync;
938     int ret = AccessTokenKit::GetHapTokenInfoFromRemote(localTokenID, infoSync);
939     ASSERT_EQ(ret, RET_SUCCESS);
940     ASSERT_EQ(infoSync.baseInfo.apl, g_infoManagerTestPolicyPrams.apl);
941     ASSERT_EQ(infoSync.permStateList.size(), static_cast<uint32_t>(2));
942     ASSERT_EQ(infoSync.permStateList[1].grantFlags.size(), static_cast<uint32_t>(2));
943 
944     ASSERT_EQ(infoSync.permStateList[0].permissionName, g_infoManagerTestPolicyPrams.permStateList[0].permissionName);
945     ASSERT_EQ(infoSync.permStateList[0].grantFlags[0], g_infoManagerTestPolicyPrams.permStateList[0].grantFlags[0]);
946     ASSERT_EQ(infoSync.permStateList[0].grantStatus[0], g_infoManagerTestPolicyPrams.permStateList[0].grantStatus[0]);
947     ASSERT_EQ(infoSync.permStateList[0].resDeviceID[0], g_infoManagerTestPolicyPrams.permStateList[0].resDeviceID[0]);
948     ASSERT_EQ(infoSync.permStateList[0].isGeneral, g_infoManagerTestPolicyPrams.permStateList[0].isGeneral);
949 
950     ASSERT_EQ(infoSync.permStateList[1].permissionName, g_infoManagerTestPolicyPrams.permStateList[1].permissionName);
951     ASSERT_EQ(infoSync.permStateList[1].grantFlags[0], g_infoManagerTestPolicyPrams.permStateList[1].grantFlags[0]);
952     ASSERT_EQ(infoSync.permStateList[1].grantStatus[0], g_infoManagerTestPolicyPrams.permStateList[1].grantStatus[0]);
953     ASSERT_EQ(infoSync.permStateList[1].resDeviceID[0], g_infoManagerTestPolicyPrams.permStateList[1].resDeviceID[0]);
954     ASSERT_EQ(infoSync.permStateList[1].isGeneral, g_infoManagerTestPolicyPrams.permStateList[1].isGeneral);
955 
956     ASSERT_EQ(infoSync.permStateList[1].grantFlags[1], g_infoManagerTestPolicyPrams.permStateList[1].grantFlags[1]);
957     ASSERT_EQ(infoSync.permStateList[1].grantStatus[1], g_infoManagerTestPolicyPrams.permStateList[1].grantStatus[1]);
958     ASSERT_EQ(infoSync.permStateList[1].resDeviceID[1], g_infoManagerTestPolicyPrams.permStateList[1].resDeviceID[1]);
959 
960     ASSERT_EQ(infoSync.baseInfo.bundleName, g_infoManagerTestInfoParms.bundleName);
961     ASSERT_EQ(infoSync.baseInfo.userID, g_infoManagerTestInfoParms.userID);
962     ASSERT_EQ(infoSync.baseInfo.instIndex, g_infoManagerTestInfoParms.instIndex);
963     ASSERT_EQ(infoSync.baseInfo.appID, g_infoManagerTestInfoParms.appIDDesc);
964     ASSERT_EQ(infoSync.baseInfo.ver, 1);
965     ASSERT_EQ(infoSync.baseInfo.tokenID, localTokenID);
966     ASSERT_EQ(infoSync.baseInfo.tokenAttr, 0);
967 
968     AccessTokenKit::DeleteToken(localTokenID);
969 }
970 
971 /**
972  * @tc.name: GetHapTokenInfoFromRemote002
973  * @tc.desc: get remote mapping tokenInfo
974  * @tc.type: FUNC
975  * @tc.require:issue I5R4UF
976  */
977 HWTEST_F(RemoteTokenKitTest, GetHapTokenInfoFromRemote002, TestSize.Level1)
978 {
979     ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote002 start.");
980     std::string deviceID2 = udid_;
981     AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
982     PermissionStateFull infoManagerTestState2 = {
983         .permissionName = "ohos.permission.test1",
984         .isGeneral = true,
985         .resDeviceID = {"local"},
986         .grantStatus = {PermissionState::PERMISSION_GRANTED},
987         .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
988     std::vector<PermissionStateFull> permStateList2;
989     permStateList2.emplace_back(infoManagerTestState2);
990 
991     g_baseInfo.deviceID = deviceID2;
992     HapTokenInfoForSync remoteTokenInfo2 = {
993         .baseInfo = g_baseInfo,
994         .permStateList = permStateList2
995     };
996 
997     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo2);
998     ASSERT_EQ(ret, RET_SUCCESS);
999 
1000     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
1001     ASSERT_NE(mapID, 0);
1002 
1003     HapTokenInfoForSync infoSync;
1004     ret = AccessTokenKit::GetHapTokenInfoFromRemote(mapID, infoSync);
1005     ASSERT_NE(ret, RET_SUCCESS);
1006 
1007     AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
1008 }
1009 
1010 /**
1011  * @tc.name: GetHapTokenInfoFromRemote003
1012  * @tc.desc: get wrong tokenInfo
1013  * @tc.type: FUNC
1014  * @tc.require:issue I5R4UF
1015  */
1016 HWTEST_F(RemoteTokenKitTest, GetHapTokenInfoFromRemote003, TestSize.Level1)
1017 {
1018     ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote003 start.");
1019     HapTokenInfoForSync infoSync;
1020     int ret = AccessTokenKit::GetHapTokenInfoFromRemote(0, infoSync);
1021     ASSERT_NE(ret, RET_SUCCESS);
1022 }
1023 
1024 /**
1025  * @tc.name: AllocLocalTokenID001
1026  * @tc.desc: get already mapping tokenInfo, makesure ipc right
1027  * @tc.type: FUNC
1028  * @tc.require:issue I5R4UF
1029  */
1030 HWTEST_F(RemoteTokenKitTest, AllocLocalTokenID001, TestSize.Level1)
1031 {
1032     ACCESSTOKEN_LOG_INFO(LABEL, "AllocLocalTokenID001 start.");
1033     std::string deviceID1 = udid_;
1034     AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000);
1035     PermissionStateFull infoManagerTestState_1 = {
1036         .permissionName = "ohos.permission.test1",
1037         .isGeneral = true,
1038         .resDeviceID = {"local4"},
1039         .grantStatus = {PermissionState::PERMISSION_GRANTED},
1040         .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
1041     std::vector<PermissionStateFull> permStateList1;
1042     permStateList1.emplace_back(infoManagerTestState_1);
1043 
1044     g_baseInfo.deviceID = deviceID1;
1045     HapTokenInfoForSync remoteTokenInfo1 = {
1046         .baseInfo = g_baseInfo,
1047         .permStateList = permStateList1
1048     };
1049 
1050     int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo1);
1051     ASSERT_EQ(ret, RET_SUCCESS);
1052 
1053     AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
1054     ASSERT_NE(mapID, 0);
1055 }
1056 
1057 /**
1058  * @tc.name: DeleteRemoteToken001
1059  * @tc.desc: DeleteRemoteToken with invalid parameters.
1060  * @tc.type: FUNC
1061  * @tc.require:Issue Number
1062  */
1063 HWTEST_F(RemoteTokenKitTest, DeleteRemoteToken001, TestSize.Level1)
1064 {
1065     std::string deviceId = "device";
1066     AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
1067                                                           g_infoManagerTestInfoParms.bundleName,
1068                                                           g_infoManagerTestInfoParms.instIndex);
1069     int res = AccessTokenKit::DeleteRemoteToken("", tokenID);
1070     ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
1071 
1072     res = AccessTokenKit::DeleteRemoteToken(deviceId, tokenID);
1073     ASSERT_NE(RET_SUCCESS, res);
1074 }
1075 
1076 /**
1077  * @tc.name: RegisterTokenSyncCallback001
1078  * @tc.desc: set token sync callback with invalid pointer
1079  * @tc.type: FUNC
1080  * @tc.require:
1081  */
1082 HWTEST_F(RemoteTokenKitTest, RegisterTokenSyncCallback001, TestSize.Level1)
1083 {
1084     int32_t ret = AccessTokenKit::RegisterTokenSyncCallback(nullptr);
1085     EXPECT_EQ(ERR_PARAM_INVALID, ret);
1086 }
1087 
1088 /**
1089  * @tc.name: RegisterTokenSyncCallback002
1090  * @tc.desc: set token sync callback with right pointer
1091  * @tc.type: FUNC
1092  * @tc.require:
1093  */
1094 HWTEST_F(RemoteTokenKitTest, RegisterTokenSyncCallback002, TestSize.Level1)
1095 {
1096     std::shared_ptr<TokenSyncKitInterface> callback = std::make_shared<TokenSyncCallbackImpl>();
1097     EXPECT_EQ(RET_SUCCESS, AccessTokenKit::RegisterTokenSyncCallback(callback));
1098     EXPECT_EQ(RET_SUCCESS, AccessTokenKit::AllocLocalTokenID(networkId_, 0)); // invalid input, would ret 0
1099     EXPECT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterTokenSyncCallback());
1100 }
1101 #endif
1102