1 /*
2 * Copyright (c) 2022-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
16 #include "auth_common.h"
17 #include "auth_common_mock.h"
18 #include "auth_hichain.h"
19 #include "auth_interface.h"
20 #include "auth_log.h"
21 #include "auth_manager.h"
22 #include "auth_net_ledger_mock.h"
23 #include "auth_request.h"
24 #include "lnn_connection_fsm.h"
25
26 #include "lnn_hichain_mock.h"
27 #include "lnn_map.h"
28 #include "lnn_socket_mock.h"
29 #include "message_handler.h"
30 #include "softbus_access_token_test.h"
31 #include "softbus_adapter_bt_common.h"
32 #include "softbus_adapter_mem.h"
33 #include "softbus_error_code.h"
34 #include "softbus_feature_config.h"
35 #include <cinttypes>
36 #include <gtest/gtest.h>
37 #include <securec.h>
38 #include <sys/time.h>
39
40 namespace OHOS {
41 using namespace testing;
42 using namespace testing::ext;
43
44 const AuthConnInfo g_connInfo = {
45 .type = AUTH_LINK_TYPE_BR,
46 .info.brInfo.brMac = "11:22:33:44:55:66",
47 .peerUid = "002",
48 };
49 const AuthConnInfo g_connInfo2 = {
50 .type = AUTH_LINK_TYPE_P2P,
51 .info.brInfo.brMac = "11:22:33:44:55:66",
52 .peerUid = "002",
53 };
54 uint32_t g_requestId = 88;
55 const AuthVerifyCallback g_callback = {
56 .onVerifyPassed = AuthCommonInterfaceMock::OnVerifyPassed,
57 .onVerifyFailed = AuthCommonInterfaceMock::OnVerifyFailed,
58 };
59
60 const AuthConnCallback g_connCallback = {
61 .onConnOpened = AuthCommonInterfaceMock::OnConnOpened,
62 .onConnOpenFailed = AuthCommonInterfaceMock::OnConnOpenFailed,
63 };
64 static const int32_t MILLIS = 15;
65 static constexpr int32_t DEFALUT_USERID = 100;
66
67 class AuthEnhanceMockTest : public testing::Test {
68 public:
69 static void SetUpTestCase();
70 static void TearDownTestCase();
71 void SetUp();
72 void TearDown();
73 };
74
SetUpTestCase()75 void AuthEnhanceMockTest::SetUpTestCase()
76 {
77 SetAccessTokenPermission("AuthEnhanceMockTest");
78 AuthCommonInit();
79 }
80
TearDownTestCase()81 void AuthEnhanceMockTest::TearDownTestCase()
82 {
83 SoftBusSleepMs(MILLIS);
84 AuthCommonDeinit();
85 }
86
SetUp()87 void AuthEnhanceMockTest::SetUp()
88 {
89 AUTH_LOGI(AUTH_TEST, "AuthTest start.");
90 }
91
TearDown()92 void AuthEnhanceMockTest::TearDown() { }
93
AuthInitMock(AuthCommonInterfaceMock & connMock,LnnHichainInterfaceMock & hichainMock,GroupAuthManager & authManager,DeviceGroupManager & groupManager)94 void AuthInitMock(AuthCommonInterfaceMock &connMock, LnnHichainInterfaceMock &hichainMock,
95 GroupAuthManager &authManager, DeviceGroupManager &groupManager)
96 {
97 groupManager.regDataChangeListener = LnnHichainInterfaceMock::InvokeDataChangeListener;
98 authManager.authDevice = LnnHichainInterfaceMock::InvokeAuthDevice;
99 groupManager.unRegDataChangeListener = LnnHichainInterfaceMock::ActionofunRegDataChangeListener;
100 ON_CALL(connMock, ConnSetConnectCallback(_, _)).WillByDefault(Return(SOFTBUS_OK));
101 ON_CALL(hichainMock, InitDeviceAuthService()).WillByDefault(Return(0));
102 ON_CALL(hichainMock, GetGaInstance()).WillByDefault(Return(&authManager));
103 ON_CALL(hichainMock, GetGmInstance()).WillByDefault(Return(&groupManager));
104 }
105
106 /*
107 * @tc.name: AUTH_START_LISTENING_Test_001
108 * @tc.desc: auth start listening
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 HWTEST_F(AuthEnhanceMockTest, AUTH_START_LISTENING_Test_001, TestSize.Level0)
113 {
114 int32_t port = 5566;
115 int32_t ret = AuthStartListening(AUTH_LINK_TYPE_P2P, nullptr, port);
116 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
117 ret = AuthStartListening(AUTH_LINK_TYPE_P2P, "192.168.78.1", port);
118 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
119 }
120
121 /*
122 * @tc.name: AUTH_HICHAIN_START_AUTH_Test_001
123 * @tc.desc: hichain start auth
124 * @tc.type: FUNC
125 * @tc.require:
126 */
127 HWTEST_F(AuthEnhanceMockTest, AUTH_HICHAIN_START_AUTH_Test_001, TestSize.Level0)
128 {
129 HiChainAuthParam hiChainParam = {};
130 const char *udid = "1111222233334444";
131 const char *uid = "8888";
132 int64_t authSeq = 5678;
133
134 if (strcpy_s(hiChainParam.udid, UDID_BUF_LEN, (char *)udid) != EOK ||
135 strcpy_s(hiChainParam.uid, MAX_ACCOUNT_HASH_LEN, (char *)uid) != EOK) {
136 return;
137 }
138 hiChainParam.userId = DEFALUT_USERID;
139 NiceMock<AuthCommonInterfaceMock> connMock;
140 NiceMock<LnnHichainInterfaceMock> hichainMock;
141 GroupAuthManager authManager;
142 DeviceGroupManager groupManager;
143 AuthInitMock(connMock, hichainMock, authManager, groupManager);
144 ON_CALL(hichainMock, GetLnnTriggerInfo(_)).WillByDefault(Return());
145 int32_t ret = HichainStartAuth(authSeq, &hiChainParam, HICHAIN_AUTH_DEVICE);
146 EXPECT_TRUE(ret == SOFTBUS_OK);
147 }
148
149 /*
150 * @tc.name: AUTH_INIT_Test_001
151 * @tc.desc: auth init
152 * @tc.type: FUNC
153 * @tc.require:
154 */
155 HWTEST_F(AuthEnhanceMockTest, AUTH_INIT_Test_001, TestSize.Level0)
156 {
157 NiceMock<AuthCommonInterfaceMock> connMock;
158 NiceMock<LnnHichainInterfaceMock> hichainMock;
159 GroupAuthManager authManager;
160 DeviceGroupManager groupManager;
161 NiceMock<AuthCommonInterfaceMock> commMock;
162 AuthInitMock(connMock, hichainMock, authManager, groupManager);
163 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
164 int32_t ret = AuthInit();
165 EXPECT_TRUE(ret == SOFTBUS_OK);
166 }
167
168 /*
169 * @tc.name: AUTH_START_VERIFY_Test_001
170 * @tc.desc: client auth start verify ble
171 * @tc.type: FUNC
172 * @tc.require:
173 */
174 HWTEST_F(AuthEnhanceMockTest, CLINET_AUTH_START_VERIFY_Test_001, TestSize.Level1)
175 {
176 NiceMock<AuthCommonInterfaceMock> connMock;
177 NiceMock<LnnHichainInterfaceMock> hichainMock;
178 NiceMock<LnnSocketInterfaceMock> socketMock;
179 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
180 NiceMock<AuthCommonInterfaceMock> commMock;
181 GroupAuthManager authManager;
182 DeviceGroupManager groupManager;
183 AuthInitMock(connMock, hichainMock, authManager, groupManager);
184 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
185 int32_t ret = AuthInit();
186 EXPECT_EQ(ret, SOFTBUS_OK);
187 ON_CALL(ledgermock, LnnGetLocalStrInfo(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
188 ON_CALL(connMock, ConnConnectDevice(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
189 ON_CALL(socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
190 ON_CALL(commMock, SoftBusGetBtState).WillByDefault(Return(BLE_ENABLE));
191 AuthVerifyParam authVerifyParam;
192 (void)memset_s(&authVerifyParam, sizeof(authVerifyParam), 0, sizeof(authVerifyParam));
193 authVerifyParam.isFastAuth = true;
194 authVerifyParam.module = AUTH_MODULE_LNN;
195 authVerifyParam.requestId = g_requestId;
196 authVerifyParam.deviceKeyId.hasDeviceKeyId = false;
197 authVerifyParam.deviceKeyId.localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
198 authVerifyParam.deviceKeyId.remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
199 ret = AuthStartVerify(&g_connInfo, &authVerifyParam, &g_callback);
200 SoftBusSleepMs(MILLIS);
201 EXPECT_EQ(ret, SOFTBUS_OK);
202 ret = AuthStartConnVerify(&g_connInfo, g_requestId, &g_connCallback, AUTH_MODULE_TRANS, true);
203 SoftBusSleepMs(MILLIS);
204 EXPECT_EQ(ret, SOFTBUS_OK);
205 }
206
207 /*
208 * @tc.name: AUTH_START_VERIFY_Test_002
209 * @tc.desc: client auth start verify wifi
210 * @tc.type: FUNC
211 * @tc.require:
212 */
213 HWTEST_F(AuthEnhanceMockTest, CLINET_AUTH_START_VERIFY_Test_002, TestSize.Level1)
214 {
215 NiceMock<AuthCommonInterfaceMock> connMock;
216 NiceMock<LnnHichainInterfaceMock> hichainMock;
217 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
218 NiceMock<AuthCommonInterfaceMock> commMock;
219 NiceMock<LnnSocketInterfaceMock> socketMock;
220 GroupAuthManager authManager;
221 DeviceGroupManager groupManager;
222 AuthInitMock(connMock, hichainMock, authManager, groupManager);
223 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
224 int32_t ret = AuthInit();
225 EXPECT_EQ(ret, SOFTBUS_OK);
226 ON_CALL(ledgermock, LnnGetLocalStrInfo(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
227 ON_CALL(connMock, ConnConnectDevice(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
228 ON_CALL(socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(2));
229 ON_CALL(socketMock, ConnSetTcpKeepalive(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
230 ON_CALL(socketMock, ConnShutdownSocket(_));
231 AuthVerifyParam authVerifyParam;
232 (void)memset_s(&authVerifyParam, sizeof(authVerifyParam), 0, sizeof(authVerifyParam));
233 authVerifyParam.isFastAuth = true;
234 authVerifyParam.module = AUTH_MODULE_LNN;
235 authVerifyParam.requestId = g_requestId;
236 authVerifyParam.deviceKeyId.hasDeviceKeyId = false;
237 authVerifyParam.deviceKeyId.localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
238 authVerifyParam.deviceKeyId.remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
239 ret = AuthStartVerify(&g_connInfo2, &authVerifyParam, &g_callback);
240 SoftBusSleepMs(MILLIS);
241 EXPECT_EQ(ret, SOFTBUS_OK);
242 ret = AuthStartConnVerify(&g_connInfo2, g_requestId, &g_connCallback, AUTH_MODULE_LNN, true);
243 SoftBusSleepMs(MILLIS);
244 EXPECT_EQ(ret, SOFTBUS_OK);
245 }
246
247 /*
248 * @tc.name: POST_DEVICEID_001
249 * @tc.desc: client auth start verify failed callback
250 * @tc.type: FUNC
251 * @tc.require:
252 */
253 HWTEST_F(AuthEnhanceMockTest, CLINET_CONN_FAILED_001, TestSize.Level1)
254 {
255 NiceMock<AuthCommonInterfaceMock> connMock;
256 NiceMock<LnnHichainInterfaceMock> hichainMock;
257 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
258 NiceMock<LnnSocketInterfaceMock> socketMock;
259 NiceMock<AuthCommonInterfaceMock> commMock;
260 GroupAuthManager authManager;
261 DeviceGroupManager groupManager;
262 AuthInitMock(connMock, hichainMock, authManager, groupManager);
263 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
264 int32_t ret = AuthInit();
265 EXPECT_EQ(ret, SOFTBUS_OK);
266 ON_CALL(connMock, ConnSetConnectCallback(_, _))
267 .WillByDefault(AuthCommonInterfaceMock::ActionofConnSetConnectCallback);
268 ON_CALL(ledgermock, LnnGetLocalStrInfo(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
269 ON_CALL(connMock, ConnConnectDevice(_, _, NotNull()))
270 .WillByDefault(AuthCommonInterfaceMock::ActionofOnConnectFailed);
271 ON_CALL(connMock, ConnPostBytes(_, _)).WillByDefault(Return(SOFTBUS_OK));
272 ON_CALL(socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
273 ON_CALL(commMock, SoftBusGetBtState).WillByDefault(Return(BLE_ENABLE));
274 AuthVerifyParam authVerifyParam;
275 (void)memset_s(&authVerifyParam, sizeof(authVerifyParam), 0, sizeof(authVerifyParam));
276 authVerifyParam.isFastAuth = true;
277 authVerifyParam.module = AUTH_MODULE_LNN;
278 authVerifyParam.requestId = g_requestId;
279 authVerifyParam.deviceKeyId.hasDeviceKeyId = false;
280 authVerifyParam.deviceKeyId.localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
281 authVerifyParam.deviceKeyId.remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
282 ret = AuthStartVerify(&g_connInfo, &authVerifyParam, &g_callback);
283 EXPECT_EQ(ret, SOFTBUS_OK);
284 SoftBusSleepMs(MILLIS);
285 }
286
287 /*
288 * @tc.name: AUTH_START_VERIFY_Test_003
289 * @tc.desc: client auth start verify success callback
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 HWTEST_F(AuthEnhanceMockTest, CLINET_AUTH_START_VERIFY_Test_003, TestSize.Level1)
294 {
295 NiceMock<AuthCommonInterfaceMock> connMock;
296 NiceMock<LnnHichainInterfaceMock> hichainMock;
297 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
298 NiceMock<LnnSocketInterfaceMock> socketMock;
299 NiceMock<AuthCommonInterfaceMock> commMock;
300 GroupAuthManager authManager;
301 DeviceGroupManager groupManager;
302 NodeInfo *info = { 0 };
303 AuthInitMock(connMock, hichainMock, authManager, groupManager);
304 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
305 int32_t ret = AuthInit();
306 EXPECT_TRUE(ret == SOFTBUS_OK);
307 ON_CALL(connMock, ConnSetConnectCallback(_, _))
308 .WillByDefault(AuthCommonInterfaceMock::ActionofConnSetConnectCallback);
309 ON_CALL(ledgermock, LnnGetLocalStrInfo(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
310 ON_CALL(ledgermock, LnnGetLocalNodeInfo).WillByDefault(Return(info));
311 ON_CALL(connMock, ConnConnectDevice(_, _, NotNull()))
312 .WillByDefault(AuthCommonInterfaceMock::ActionofOnConnectSuccessed);
313 ON_CALL(connMock, ConnPostBytes(_, _)).WillByDefault(Return(SOFTBUS_OK));
314 ON_CALL(socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
315 ON_CALL(commMock, SoftBusGetBtState).WillByDefault(Return(BLE_ENABLE));
316 AuthVerifyParam authVerifyParam;
317 (void)memset_s(&authVerifyParam, sizeof(authVerifyParam), 0, sizeof(authVerifyParam));
318 authVerifyParam.isFastAuth = true;
319 authVerifyParam.module = AUTH_MODULE_LNN;
320 authVerifyParam.requestId = g_requestId;
321 authVerifyParam.deviceKeyId.hasDeviceKeyId = false;
322 authVerifyParam.deviceKeyId.localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
323 authVerifyParam.deviceKeyId.remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
324 ret = AuthStartVerify(&g_connInfo, &authVerifyParam, &g_callback);
325 EXPECT_TRUE(ret == SOFTBUS_OK);
326 SoftBusSleepMs(MILLIS);
327 }
328
329 /*
330 * @tc.name: CHECK_SESSIONKEY_VALID_Test_001
331 * @tc.desc: AuthCheckSessionKeyValidByConnInfo test
332 * @tc.type: FUNC
333 * @tc.require:
334 */
335 HWTEST_F(AuthEnhanceMockTest, CHECK_SESSIONKEY_VALID_Test_001, TestSize.Level1)
336 {
337 AuthConnInfo connInfo;
338 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
339 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
340 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
341 NodeInfo node;
342 (void)memset_s(&node, sizeof(NodeInfo), 0, sizeof(NodeInfo));
343 EXPECT_NE(AuthCheckSessionKeyValidByConnInfo(nullptr, &connInfo), SOFTBUS_OK);
344 node.authCapacity = BIT_SUPPORT_NORMALIZED_LINK << 1;
345 ON_CALL(ledgermock, LnnGetRemoteNodeInfoById(_, _, _))
346 .WillByDefault(DoAll(SetArgPointee<2>(node), Return(SOFTBUS_OK)));
347 EXPECT_NE(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo), SOFTBUS_OK);
348 }
349
350 /*
351 * @tc.name: CHECK_SESSIONKEY_VALID_Test_002
352 * @tc.desc: AuthCheckSessionKeyValidByConnInfo test
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356 HWTEST_F(AuthEnhanceMockTest, CHECK_SESSIONKEY_VALID_Test_002, TestSize.Level1)
357 {
358 char udidHash[UDID_HASH_LEN] = { 0 };
359 int64_t authSeq = 1;
360 int32_t keyLen = 32;
361 AuthSessionInfo info;
362 AuthConnInfo connInfo;
363 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
364 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
365 info.connInfo.type = AUTH_LINK_TYPE_BLE;
366 connInfo.type = AUTH_LINK_TYPE_BLE;
367 ASSERT_TRUE(memcpy_s(info.connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) == EOK);
368 ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) == EOK);
369 EXPECT_EQ(AuthDirectOnlineCreateAuthManager(authSeq, &info), SOFTBUS_OK);
370
371 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
372 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
373 NodeInfo node;
374 (void)memset_s(&node, sizeof(NodeInfo), 0, sizeof(NodeInfo));
375 node.authCapacity = BIT_SUPPORT_NORMALIZED_LINK << 1;
376 ON_CALL(ledgermock, LnnGetRemoteNodeInfoById(_, _, _))
377 .WillByDefault(DoAll(SetArgPointee<2>(node), Return(SOFTBUS_OK)));
378 EXPECT_EQ(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo), SOFTBUS_AUTH_SESSION_KEY_INVALID);
379 SessionKey sessionKey;
380 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
381 sessionKey.len = keyLen;
382 EXPECT_EQ(AuthManagerSetSessionKey(authSeq, &info, &sessionKey, true, false), SOFTBUS_OK);
383 EXPECT_EQ(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo), SOFTBUS_OK);
384 }
385
386 /*
387 * @tc.name: CHECK_SESSION_KEY_VALID_BY_AUTH_HANDLE_Test_001
388 * @tc.desc: AuthCheckSessionKeyValidByAuthHandle test
389 * @tc.type: FUNC
390 * @tc.require:
391 */
392 HWTEST_F(AuthEnhanceMockTest, CHECK_SESSION_KEY_VALID_BY_AUTH_HANDLE_Test_001, TestSize.Level1)
393 {
394 char udidHash[UDID_HASH_LEN] = { 0 };
395 int64_t authSeq = 1;
396 int32_t keyLen = 32;
397 AuthSessionInfo info;
398 AuthConnInfo connInfo;
399 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
400 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
401 info.connInfo.type = AUTH_LINK_TYPE_BLE;
402 connInfo.type = AUTH_LINK_TYPE_BLE;
403 ASSERT_TRUE(memcpy_s(info.connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) == EOK);
404 ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) == EOK);
405 EXPECT_EQ(AuthDirectOnlineCreateAuthManager(authSeq, &info), SOFTBUS_OK);
406 AuthHandle authHandle = { .authId = authSeq, .type = connInfo.type };
407 SessionKey sessionKey;
408 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
409 sessionKey.len = keyLen;
410 EXPECT_EQ(AuthManagerSetSessionKey(authSeq, &info, &sessionKey, true, false), SOFTBUS_OK);
411 EXPECT_EQ(AuthCheckSessionKeyValidByAuthHandle(&authHandle), SOFTBUS_OK);
412 }
413 } // namespace OHOS
414