1 /*
2  * Copyright (c) 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 
16 #include <gtest/gtest.h>
17 #include <memory>
18 #include <string>
19 
20 #include "access_token.h"
21 #include "atm_tools_param_info_parcel.h"
22 #include "hap_info_parcel.h"
23 #include "hap_policy_parcel.h"
24 #include "hap_token_info_parcel.h"
25 #include "hap_token_info_for_sync_parcel.h"
26 #include "native_token_info_parcel.h"
27 #include "parcel.h"
28 #include "parcel_utils.h"
29 #include "permission_grant_info_parcel.h"
30 #include "permission_state_change_scope_parcel.h"
31 #include "permission_state_change_info_parcel.h"
32 #include "permission_state_full.h"
33 #include "permission_state_full_parcel.h"
34 
35 using namespace testing::ext;
36 
37 namespace OHOS {
38 namespace Security {
39 namespace AccessToken {
40 namespace {
41 static constexpr int32_t DEFAULT_API_VERSION = 8;
42 static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA";
43 static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA";
44 static constexpr AccessTokenID TEST_TOKEN_ID = 10002;
45 static constexpr int32_t TEST_PERMSTATE_CHANGE_TYPE = 10001;
46 
47 PermissionDef g_permDefAlpha = {
48     .permissionName = TEST_PERMISSION_NAME_ALPHA,
49     .bundleName = "accesstoken_test",
50     .grantMode = 1,
51     .availableLevel = APL_NORMAL,
52     .label = "label",
53     .labelId = 1,
54     .description = "annoying",
55     .descriptionId = 1
56 };
57 PermissionDef g_permDefBeta = {
58     .permissionName = TEST_PERMISSION_NAME_BETA,
59     .bundleName = "accesstoken_test",
60     .grantMode = 1,
61     .availableLevel = APL_NORMAL,
62     .label = "label",
63     .labelId = 1,
64     .description = "so trouble",
65     .descriptionId = 1
66 };
67 
68 PermissionStateFull g_permStatAlpha = {
69     .permissionName = TEST_PERMISSION_NAME_ALPHA,
70     .isGeneral = true,
71     .resDeviceID = {"device"},
72     .grantStatus = {PermissionState::PERMISSION_DENIED},
73     .grantFlags = {PermissionFlag::PERMISSION_USER_SET}
74 };
75 PermissionStateFull g_permStatBeta = {
76     .permissionName = TEST_PERMISSION_NAME_BETA,
77     .isGeneral = true,
78     .resDeviceID = {"device"},
79     .grantStatus = {PermissionState::PERMISSION_GRANTED},
80     .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
81 };
82 }
83 class AccessTokenParcelTest : public testing::Test  {
84 public:
85     static void SetUpTestCase(void);
86     static void TearDownTestCase(void);
87     void SetUp();
88     void TearDown();
89 };
90 
SetUpTestCase(void)91 void AccessTokenParcelTest::SetUpTestCase(void) {}
TearDownTestCase(void)92 void AccessTokenParcelTest::TearDownTestCase(void) {}
SetUp(void)93 void AccessTokenParcelTest::SetUp(void) {}
TearDown(void)94 void AccessTokenParcelTest::TearDown(void) {}
95 
96 /**
97  * @tc.name: HapInfoParcel001
98  * @tc.desc: Test HapInfo Marshalling/Unmarshalling.
99  * @tc.type: FUNC
100  * @tc.require: issueI5QKZF
101  */
HWTEST_F(AccessTokenParcelTest, HapInfoParcel001, TestSize.Level1)102 HWTEST_F(AccessTokenParcelTest, HapInfoParcel001, TestSize.Level1)
103 {
104     HapInfoParcel hapinfoParcel;
105     hapinfoParcel.hapInfoParameter = {
106         .userID = 1,
107         .bundleName = "accesstoken_test",
108         .instIndex = 0,
109         .appIDDesc = "testtesttesttest",
110         .apiVersion = DEFAULT_API_VERSION,
111         .isSystemApp = false,
112     };
113 
114     Parcel parcel;
115     EXPECT_EQ(true, hapinfoParcel.Marshalling(parcel));
116 
117     std::shared_ptr<HapInfoParcel> readedData(HapInfoParcel::Unmarshalling(parcel));
118     EXPECT_NE(nullptr, readedData);
119 
120     EXPECT_EQ(hapinfoParcel.hapInfoParameter.userID, readedData->hapInfoParameter.userID);
121     EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.bundleName == readedData->hapInfoParameter.bundleName);
122     EXPECT_EQ(hapinfoParcel.hapInfoParameter.instIndex, readedData->hapInfoParameter.instIndex);
123     EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.appIDDesc == readedData->hapInfoParameter.appIDDesc);
124     EXPECT_EQ(hapinfoParcel.hapInfoParameter.apiVersion, readedData->hapInfoParameter.apiVersion);
125     EXPECT_EQ(hapinfoParcel.hapInfoParameter.isSystemApp, readedData->hapInfoParameter.isSystemApp);
126 }
127 
128 /**
129  * @tc.name: HapPolicyParcel001
130  * @tc.desc: Test HapPolicy Marshalling/Unmarshalling.
131  * @tc.type: FUNC
132  * @tc.require: issueI5QKZF
133  */
HWTEST_F(AccessTokenParcelTest, HapPolicyParcel001, TestSize.Level1)134 HWTEST_F(AccessTokenParcelTest, HapPolicyParcel001, TestSize.Level1)
135 {
136     HapPolicyParcel hapPolicyParcel;
137 
138     hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL;
139     hapPolicyParcel.hapPolicyParameter.domain = "test.domain";
140     hapPolicyParcel.hapPolicyParameter.permList.emplace_back(g_permDefAlpha);
141     hapPolicyParcel.hapPolicyParameter.permList.emplace_back(g_permDefBeta);
142     hapPolicyParcel.hapPolicyParameter.permStateList.emplace_back(g_permStatAlpha);
143     hapPolicyParcel.hapPolicyParameter.permStateList.emplace_back(g_permStatBeta);
144 
145     Parcel parcel;
146     EXPECT_EQ(true, hapPolicyParcel.Marshalling(parcel));
147 
148     std::shared_ptr<HapPolicyParcel> readedData(HapPolicyParcel::Unmarshalling(parcel));
149     EXPECT_NE(nullptr, readedData);
150 
151     EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.apl, readedData->hapPolicyParameter.apl);
152     EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.domain, readedData->hapPolicyParameter.domain);
153     EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList.size(), readedData->hapPolicyParameter.permList.size());
154     EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList.size(),
155         readedData->hapPolicyParameter.permStateList.size());
156 
157     for (uint32_t i = 0; i < hapPolicyParcel.hapPolicyParameter.permList.size(); i++) {
158         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].permissionName,
159             readedData->hapPolicyParameter.permList[i].permissionName);
160         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].bundleName,
161             readedData->hapPolicyParameter.permList[i].bundleName);
162         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].grantMode,
163             readedData->hapPolicyParameter.permList[i].grantMode);
164         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].availableLevel,
165             readedData->hapPolicyParameter.permList[i].availableLevel);
166         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].label,
167             readedData->hapPolicyParameter.permList[i].label);
168         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].labelId,
169             readedData->hapPolicyParameter.permList[i].labelId);
170         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].description,
171             readedData->hapPolicyParameter.permList[i].description);
172         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].descriptionId,
173             readedData->hapPolicyParameter.permList[i].descriptionId);
174     }
175 
176     for (uint32_t i = 0; i < hapPolicyParcel.hapPolicyParameter.permStateList.size(); i++) {
177         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].permissionName,
178             readedData->hapPolicyParameter.permStateList[i].permissionName);
179         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].isGeneral,
180             readedData->hapPolicyParameter.permStateList[i].isGeneral);
181         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].resDeviceID,
182             readedData->hapPolicyParameter.permStateList[i].resDeviceID);
183         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].grantStatus,
184             readedData->hapPolicyParameter.permStateList[i].grantStatus);
185         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].grantFlags,
186             readedData->hapPolicyParameter.permStateList[i].grantFlags);
187     }
188 }
189 
190 /**
191  * @tc.name: PermissionStateChangeInfoParcel001
192  * @tc.desc: Test PermissionStateChangeInfo Marshalling/Unmarshalling.
193  * @tc.type: FUNC
194  * @tc.require: issueI5QKZF
195  */
HWTEST_F(AccessTokenParcelTest, PermissionStateChangeInfoParcel001, TestSize.Level1)196 HWTEST_F(AccessTokenParcelTest, PermissionStateChangeInfoParcel001, TestSize.Level1)
197 {
198     PermissionStateChangeInfoParcel permissionStateParcel;
199     permissionStateParcel.changeInfo.permStateChangeType = TEST_PERMSTATE_CHANGE_TYPE;
200     permissionStateParcel.changeInfo.tokenID = TEST_TOKEN_ID;
201     permissionStateParcel.changeInfo.permissionName = TEST_PERMISSION_NAME_ALPHA;
202 
203     Parcel parcel;
204     EXPECT_EQ(true, permissionStateParcel.Marshalling(parcel));
205 
206     std::shared_ptr<PermissionStateChangeInfoParcel> readedData(PermissionStateChangeInfoParcel::Unmarshalling(parcel));
207     EXPECT_NE(nullptr, readedData);
208     EXPECT_EQ(permissionStateParcel.changeInfo.permStateChangeType, readedData->changeInfo.permStateChangeType);
209     EXPECT_EQ(permissionStateParcel.changeInfo.tokenID, readedData->changeInfo.tokenID);
210     EXPECT_EQ(permissionStateParcel.changeInfo.permissionName, readedData->changeInfo.permissionName);
211 }
212 
213 /**
214  * @tc.name: PermStateChangeScopeParcel001
215  * @tc.desc: Test PermStateChangeScope Marshalling/Unmarshalling.
216  * @tc.type: FUNC
217  * @tc.require: issueI5QKZF
218  */
HWTEST_F(AccessTokenParcelTest, PermStateChangeScopeParcel001, TestSize.Level1)219 HWTEST_F(AccessTokenParcelTest, PermStateChangeScopeParcel001, TestSize.Level1)
220 {
221     PermStateChangeScopeParcel permStateChangeScopeParcel;
222     permStateChangeScopeParcel.scope.tokenIDs.emplace_back(TEST_TOKEN_ID);
223     permStateChangeScopeParcel.scope.permList.emplace_back(TEST_PERMISSION_NAME_ALPHA);
224 
225     Parcel parcel;
226     EXPECT_EQ(true, permStateChangeScopeParcel.Marshalling(parcel));
227 
228     std::shared_ptr<PermStateChangeScopeParcel> readedData(PermStateChangeScopeParcel::Unmarshalling(parcel));
229     EXPECT_NE(nullptr, readedData);
230 
231     EXPECT_EQ(true,  permStateChangeScopeParcel.scope.tokenIDs.size() == readedData->scope.tokenIDs.size());
232     EXPECT_EQ(true,  permStateChangeScopeParcel.scope.permList.size() == readedData->scope.permList.size());
233 
234     for (uint32_t i = 0; i < readedData->scope.tokenIDs.size(); i++) {
235         EXPECT_EQ(permStateChangeScopeParcel.scope.tokenIDs[i], readedData->scope.tokenIDs[i]);
236     }
237     for (uint32_t i = 0; i < readedData->scope.permList.size(); i++) {
238         EXPECT_EQ(true, permStateChangeScopeParcel.scope.permList[i] == readedData->scope.permList[i]);
239     }
240 }
241 
242 /**
243  * @tc.name: HapTokenInfoForSyncParcel001
244  * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling.
245  * @tc.type: FUNC
246  * @tc.require: issueI5QKZF
247  */
HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel001, TestSize.Level1)248 HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel001, TestSize.Level1)
249 {
250     HapTokenInfoForSyncParcel hapTokenInfoSync;
251 
252     HapTokenInfo hapTokenInfo;
253     hapTokenInfo.apl = ATokenAplEnum::APL_NORMAL;
254     hapTokenInfo.ver = 0;
255     hapTokenInfo.userID = 2;
256     hapTokenInfo.bundleName = "bundle1";
257     hapTokenInfo.apiVersion = 8;
258     hapTokenInfo.instIndex = 0;
259     hapTokenInfo.dlpType = 0;
260     hapTokenInfo.appID = "test1";
261     hapTokenInfo.deviceID = "0";
262     hapTokenInfo.tokenID = 0x53100000;
263     hapTokenInfo.tokenAttr = 0;
264     hapTokenInfoSync.hapTokenInfoForSyncParams.baseInfo = hapTokenInfo;
265     hapTokenInfoSync.hapTokenInfoForSyncParams.permStateList.emplace_back(g_permStatBeta);
266 
267     Parcel parcel;
268     EXPECT_EQ(true, hapTokenInfoSync.Marshalling(parcel));
269     std::shared_ptr<HapTokenInfoForSyncParcel> readedData(HapTokenInfoForSyncParcel::Unmarshalling(parcel));
270     EXPECT_NE(nullptr, readedData);
271 }
272 
WriteParcelable( Parcel& out, const Parcelable& baseInfoParcel, uint32_t size)273 static void WriteParcelable(
274     Parcel& out, const Parcelable& baseInfoParcel, uint32_t size)
275 {
276     out.WriteParcelable(&baseInfoParcel);
277     std::vector<PermissionStateFull> permStateList;
278     for (uint32_t i = 0; i < size; i++) {
279         permStateList.emplace_back(g_permStatBeta);
280     }
281     uint32_t permStateListSize = permStateList.size();
282     out.WriteUint32(permStateListSize);
283     for (uint32_t i = 0; i < permStateListSize; i++) {
284         PermissionStateFullParcel permStateParcel;
285         permStateParcel.permStatFull = permStateList[i];
286         out.WriteParcelable(&permStateParcel);
287     }
288 
289     out.WriteParcelable(&baseInfoParcel);
290     permStateList.emplace_back(g_permStatBeta);
291 
292     permStateListSize = permStateList.size();
293     out.WriteUint32(permStateListSize);
294     for (uint32_t i = 0; i < permStateListSize; i++) {
295         PermissionStateFullParcel permStateParcel;
296         permStateParcel.permStatFull = permStateList[i];
297         out.WriteParcelable(&permStateParcel);
298     }
299 }
300 
301 /**
302  * @tc.name: HapTokenInfoForSyncParcel002
303  * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling.
304  * @tc.type: FUNC
305  * @tc.require: issueI5QKZF
306  */
HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel002, TestSize.Level1)307 HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel002, TestSize.Level1)
308 {
309     HapTokenInfoForSyncParcel hapTokenInfoSync;
310 
311     HapTokenInfo hapTokenInfo;
312     hapTokenInfo.apl = ATokenAplEnum::APL_NORMAL;
313     hapTokenInfo.ver = 0;
314     hapTokenInfo.userID = 2;
315     hapTokenInfo.bundleName = "bundle2";
316     hapTokenInfo.apiVersion = 8;
317     hapTokenInfo.instIndex = 0;
318     hapTokenInfo.dlpType = 0;
319     hapTokenInfo.appID = "test2";
320     hapTokenInfo.deviceID = "0";
321     hapTokenInfo.tokenID = 0x53100000;
322     hapTokenInfo.tokenAttr = 0;
323 
324     Parcel out;
325     HapTokenInfoParcel baseInfoParcel;
326     baseInfoParcel.hapTokenInfoParams = hapTokenInfo;
327     WriteParcelable(out, baseInfoParcel, MAX_PERMLIST_SIZE);
328 
329     std::shared_ptr<HapTokenInfoForSyncParcel> readedData(HapTokenInfoForSyncParcel::Unmarshalling(out));
330     EXPECT_NE(nullptr, readedData);
331 
332     Parcel out1;
333     WriteParcelable(out, baseInfoParcel, MAX_PERMLIST_SIZE + 1);
334     std::shared_ptr<HapTokenInfoForSyncParcel> readedData1(HapTokenInfoForSyncParcel::Unmarshalling(out1));
335     EXPECT_EQ(true, readedData1 == nullptr);
336 }
337 
338 
PutData(Parcel& out, uint32_t deviceSize, uint32_t statusSize, uint32_t flagSize)339 static void PutData(Parcel& out, uint32_t deviceSize, uint32_t statusSize, uint32_t flagSize)
340 {
341     out.WriteString("ohos.permission.LOCATION");
342     out.WriteBool(true);
343     out.WriteUint32(deviceSize);
344     for (uint32_t i = 0; i < deviceSize; i++) {
345         out.WriteString("deviceName");
346     }
347     out.WriteUint32(statusSize);
348     for (uint32_t i = 0; i < statusSize; i++) {
349         out.WriteInt32(0);
350     }
351     out.WriteUint32(flagSize);
352     for (uint32_t i = 0; i < flagSize; i++) {
353         out.WriteInt32(0);
354     }
355 }
356 
357 /**
358  * @tc.name: PermissionStateFullParcel001
359  * @tc.desc: Test permissionStateFullParcel Marshalling/Unmarshalling.
360  * @tc.type: FUNC
361  * @tc.require: issueI5QKZF
362  */
HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel001, TestSize.Level1)363 HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel001, TestSize.Level1)
364 {
365     Parcel out;
366     PutData(out, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE + 1);
367     std::shared_ptr<PermissionStateFullParcel> readedData(PermissionStateFullParcel::Unmarshalling(out));
368     EXPECT_EQ(nullptr, readedData);
369 
370     Parcel out1;
371     PutData(out1, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1);
372     std::shared_ptr<PermissionStateFullParcel> readedData1(PermissionStateFullParcel::Unmarshalling(out1));
373     EXPECT_EQ(readedData1, nullptr);
374 
375     Parcel out2;
376     PutData(out2, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1);
377     std::shared_ptr<PermissionStateFullParcel> readedData2(PermissionStateFullParcel::Unmarshalling(out2));
378     EXPECT_EQ(readedData2, nullptr);
379 
380     Parcel out3;
381     PutData(out3, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE);
382     std::shared_ptr<PermissionStateFullParcel> readedData3(PermissionStateFullParcel::Unmarshalling(out3));
383     EXPECT_NE(readedData3, nullptr);
384 }
385 
386 /**
387  * @tc.name: PermissionStateFullParcel002
388  * @tc.desc: Test permissionStateFullParcel Marshalling/Unmarshalling.
389  * @tc.type: FUNC
390  * @tc.require: issueI5QKZF
391  */
HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel002, TestSize.Level1)392 HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel002, TestSize.Level1)
393 {
394     PermissionStateFullParcel permissionStateFullParcel;
395     permissionStateFullParcel.permStatFull.permissionName = "permissionName";
396     permissionStateFullParcel.permStatFull.isGeneral = false;
397     permissionStateFullParcel.permStatFull.resDeviceID = {"device"};
398     permissionStateFullParcel.permStatFull.grantStatus = {1};
399     permissionStateFullParcel.permStatFull.grantFlags = {0};
400     Parcel parcel;
401     EXPECT_EQ(true, permissionStateFullParcel.Marshalling(parcel));
402 
403     std::shared_ptr<PermissionStateFullParcel> readedData(PermissionStateFullParcel::Unmarshalling(parcel));
404     EXPECT_NE(nullptr, readedData);
405 }
406 
407 /**
408  * @tc.name: PermissionGrantInfoParcel001
409  * @tc.desc: Test PermissionGrantInfo Marshalling/Unmarshalling.
410  * @tc.type: FUNC
411  * @tc.require:
412  */
HWTEST_F(AccessTokenParcelTest, PermissionGrantInfoParcel001, TestSize.Level1)413 HWTEST_F(AccessTokenParcelTest, PermissionGrantInfoParcel001, TestSize.Level1)
414 {
415     PermissionGrantInfoParcel permissionGrantInfoParcel;
416     permissionGrantInfoParcel.info.grantBundleName = "com.ohos.permissionmanager";
417     permissionGrantInfoParcel.info.grantAbilityName = "com.ohos.permissionmanager.GrantAbility";
418 
419     Parcel parcel;
420     EXPECT_EQ(true, permissionGrantInfoParcel.Marshalling(parcel));
421     std::shared_ptr<PermissionGrantInfoParcel> readedData(PermissionGrantInfoParcel::Unmarshalling(parcel));
422     EXPECT_NE(nullptr, readedData);
423 }
424 
425 /**
426  * @tc.name: AtmToolsParamInfoParcel001
427  * @tc.desc: Test AtmToolsParamInfo Marshalling/Unmarshalling.
428  * @tc.type: FUNC
429  * @tc.require:
430  */
HWTEST_F(AccessTokenParcelTest, AtmToolsParamInfoParcel001, TestSize.Level1)431 HWTEST_F(AccessTokenParcelTest, AtmToolsParamInfoParcel001, TestSize.Level1)
432 {
433     AtmToolsParamInfoParcel atmToolsParamInfoParcel;
434     atmToolsParamInfoParcel.info.type = DUMP_TOKEN;
435     atmToolsParamInfoParcel.info.tokenId = INVALID_TOKENID;
436     atmToolsParamInfoParcel.info.permissionName = "ohos.permission.CAMERA";
437     atmToolsParamInfoParcel.info.bundleName = "com.ohos.parceltest";
438     atmToolsParamInfoParcel.info.permissionName = "test_service";
439 
440     Parcel parcel;
441     EXPECT_EQ(true, atmToolsParamInfoParcel.Marshalling(parcel));
442     std::shared_ptr<AtmToolsParamInfoParcel> readedData(AtmToolsParamInfoParcel::Unmarshalling(parcel));
443     EXPECT_NE(nullptr, readedData);
444 }
445 } // namespace AccessToken
446 } // namespace Security
447 } // namespace OHOS
448