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
16
17 #include "dm_auth_state_machine_mock.h"
18 #include "UTTest_auth_pin_auth_state.h"
19
20 using namespace testing;
21
22 namespace OHOS {
23 namespace DistributedHardware {
24
SetUpTestCase()25 void AuthPinAuthStateTest::SetUpTestCase()
26 {
27 LOGI("AuthPinAuthStateTest::SetUpTestCase start.");
28 DmHiChainAuthConnector::dmHiChainAuthConnector = hiChainAuthConnectorMock;
29 DmAuthStateMachineMock::dmAuthStateMachineMock = std::make_shared<DmAuthStateMachineMock>();
30 }
31
TearDownTestCase()32 void AuthPinAuthStateTest::TearDownTestCase()
33 {
34 LOGI("AuthPinAuthStateTest::TearDownTestCase start.");
35 DmHiChainAuthConnector::dmHiChainAuthConnector = nullptr;
36 DmAuthStateMachineMock::dmAuthStateMachineMock = nullptr;
37 hiChainAuthConnectorMock = nullptr;
38 }
39
SetUp()40 void AuthPinAuthStateTest::SetUp()
41 {
42 LOGI("AuthPinAuthStateTest::SetUp start.");
43 softbusConnector = std::make_shared<SoftbusConnector>();
44 listener = std::make_shared<DeviceManagerServiceListener>();
45 hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
46 hiChainConnector = std::make_shared<HiChainConnector>();
47 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
48 hiChainAuthConnector);
49 context = authManager->GetAuthContext();
50
51 Mock::VerifyAndClearExpectations(&*hiChainAuthConnectorMock);
52 Mock::VerifyAndClearExpectations(&*DmAuthStateMachineMock::dmAuthStateMachineMock);
53 }
54
TearDown()55 void AuthPinAuthStateTest::TearDown()
56 {
57 LOGI("AuthPinAuthStateTest::TearDown start.");
58 softbusConnector = nullptr;
59 listener = nullptr;
60 hiChainAuthConnector = nullptr;
61 authManager = nullptr;
62 context = nullptr;
63 }
64
IsScreenLocked()65 bool DmAuthState::IsScreenLocked()
66 {
67 return false;
68 }
69
70 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthStartState_001, testing::ext::TestSize.Level1)
71 {
72 std::shared_ptr<AuthSrcPinAuthStartState> authState = std::make_shared<AuthSrcPinAuthStartState>();
73 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_PIN_AUTH_START_STATE);
74 }
75
76 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthStartState_002, testing::ext::TestSize.Level1)
77 {
78 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthStartState>();
79
80 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
81 .WillOnce(Return(DM_OK));
82
83 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
84 .WillOnce(Return(ON_TRANSMIT));
85
86 EXPECT_EQ(authState->Action(context), DM_OK);
87 }
88
89 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthStartState_003, testing::ext::TestSize.Level1)
90 {
91 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthStartState>();
92
93 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
94 .WillOnce(Return(DM_OK));
95
96 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
97 .WillOnce(Return(ON_ERROR));
98
99 EXPECT_EQ(authState->Action(context), DM_OK);
100 }
101
102 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthStartState_004, testing::ext::TestSize.Level1)
103 {
104 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthStartState>();
105
106 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
107 .WillOnce(Return(ERR_DM_FAILED));
108
109 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
110 }
111
112 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthStartState_005, testing::ext::TestSize.Level1)
113 {
114 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthStartState>();
115
116 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
117 .WillOnce(Return(DM_OK));
118
119 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
120 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
121
122 EXPECT_EQ(authState->Action(context), STOP_BIND);
123 }
124
125 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthStartState_001, testing::ext::TestSize.Level1)
126 {
127 std::shared_ptr<AuthSinkPinAuthStartState> authState = std::make_shared<AuthSinkPinAuthStartState>();
128 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_PIN_AUTH_START_STATE);
129 }
130
131 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthStartState_002, testing::ext::TestSize.Level1)
132 {
133 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthStartState>();
134 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
135 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
136
137 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
138 .WillOnce(Return(DM_OK));
139
140 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
141 .WillOnce(Return(ON_TRANSMIT));
142
143 EXPECT_EQ(authState->Action(context), DM_OK);
144 }
145
146 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthStartState_003, testing::ext::TestSize.Level1)
147 {
148 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthStartState>();
149 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
150 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
151
152 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
153 .WillOnce(Return(DM_OK));
154
155 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
156 .WillOnce(Return(ON_ERROR));
157
158 EXPECT_EQ(authState->Action(context), DM_OK);
159 }
160
161 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthStartState_004, testing::ext::TestSize.Level1)
162 {
163 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthStartState>();
164 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
165 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
166
167 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
168 .WillOnce(Return(ERR_DM_FAILED));
169
170 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
171 }
172
173 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthStartState_005, testing::ext::TestSize.Level1)
174 {
175 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthStartState>();
176 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
177 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
178
179 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
180 .WillOnce(Return(DM_OK));
181
182 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
183 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
184
185 EXPECT_EQ(authState->Action(context), STOP_BIND);
186 }
187
188 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthMsgNegotiateState_001, testing::ext::TestSize.Level1)
189 {
190 std::shared_ptr<AuthSrcPinAuthMsgNegotiateState> authState = std::make_shared<AuthSrcPinAuthMsgNegotiateState>();
191 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_PIN_AUTH_MSG_NEGOTIATE_STATE);
192 }
193
194 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthMsgNegotiateState_002, testing::ext::TestSize.Level1)
195 {
196 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthMsgNegotiateState>();
197
198 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
199 .WillOnce(Return(DM_OK));
200
201 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
202 .WillOnce(Return(ON_TRANSMIT));
203
204 EXPECT_EQ(authState->Action(context), DM_OK);
205 }
206
207 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthMsgNegotiateState_003, testing::ext::TestSize.Level1)
208 {
209 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthMsgNegotiateState>();
210
211 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
212 .WillOnce(Return(DM_OK));
213
214 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
215 .WillOnce(Return(ON_ERROR));
216
217 EXPECT_EQ(authState->Action(context), DM_OK);
218 }
219
220 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthMsgNegotiateState_004, testing::ext::TestSize.Level1)
221 {
222 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthMsgNegotiateState>();
223
224 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
225 .WillOnce(Return(ERR_DM_FAILED));
226
227 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
228 }
229
230 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthMsgNegotiateState_005, testing::ext::TestSize.Level1)
231 {
232 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthMsgNegotiateState>();
233
234 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
235 .WillOnce(Return(DM_OK));
236
237 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
238 .WillOnce(Return(ON_REQUEST));
239
240 EXPECT_EQ(authState->Action(context), STOP_BIND);
241 }
242
243 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthMsgNegotiateState_001, testing::ext::TestSize.Level1)
244 {
245 std::shared_ptr<AuthSinkPinAuthMsgNegotiateState> authState = std::make_shared<AuthSinkPinAuthMsgNegotiateState>();
246 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_PIN_AUTH_MSG_NEGOTIATE_STATE);
247 }
248
249 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthMsgNegotiateState_002, testing::ext::TestSize.Level1)
250 {
251 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthMsgNegotiateState>();
252
253 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
254 .WillOnce(Return(DM_OK));
255
256 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
257 .WillOnce(Return(ON_TRANSMIT))
258 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
259 .WillOnce(Return(ON_FINISH));
260
261 EXPECT_EQ(authState->Action(context), DM_OK);
262 }
263
264 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthMsgNegotiateState_003, testing::ext::TestSize.Level1)
265 {
266 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthMsgNegotiateState>();
267
268 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
269 .WillOnce(Return(ERR_DM_FAILED));
270
271 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
272 }
273
274 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthMsgNegotiateState_004, testing::ext::TestSize.Level1)
275 {
276 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthMsgNegotiateState>();
277
278 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
279 .WillOnce(Return(DM_OK));
280
281 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
282 .WillOnce(Return(ON_ERROR));
283
284 EXPECT_EQ(authState->Action(context), DM_OK);
285 }
286
287 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthMsgNegotiateState_005, testing::ext::TestSize.Level1)
288 {
289 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthMsgNegotiateState>();
290
291 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
292 .WillOnce(Return(DM_OK));
293
294 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
295 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
296
297 EXPECT_EQ(authState->Action(context), STOP_BIND);
298 }
299
300 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthMsgNegotiateState_006, testing::ext::TestSize.Level1)
301 {
302 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthMsgNegotiateState>();
303
304 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
305 .WillOnce(Return(DM_OK));
306
307 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
308 .WillOnce(Return(ON_TRANSMIT))
309 .WillOnce(Return(ON_ERROR));
310
311 EXPECT_EQ(authState->Action(context), DM_OK);
312 }
313
314 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthMsgNegotiateState_007, testing::ext::TestSize.Level1)
315 {
316 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthMsgNegotiateState>();
317
318 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
319 .WillOnce(Return(DM_OK));
320
321 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
322 .WillOnce(Return(ON_TRANSMIT))
323 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
324 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
325
326 EXPECT_EQ(authState->Action(context), STOP_BIND);
327 }
328
329 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthDoneState_001, testing::ext::TestSize.Level1)
330 {
331 std::shared_ptr<AuthSrcPinAuthDoneState> authState = std::make_shared<AuthSrcPinAuthDoneState>();
332 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_PIN_AUTH_DONE_STATE);
333 }
334
335 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthDoneState_002, testing::ext::TestSize.Level1)
336 {
337 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthDoneState>();
338
339 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
340 .WillOnce(Return(DM_OK));
341
342 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
343 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
344 .WillOnce(Return(ON_FINISH));
345
346 EXPECT_EQ(authState->Action(context), DM_OK);
347 }
348
349 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthDoneState_003, testing::ext::TestSize.Level1)
350 {
351 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthDoneState>();
352
353 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
354 .WillOnce(Return(ERR_DM_FAILED));
355
356 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
357 }
358
359 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthDoneState_004, testing::ext::TestSize.Level1)
360 {
361 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthDoneState>();
362
363 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
364 .WillOnce(Return(DM_OK));
365
366 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
367 .WillOnce(Return(ON_ERROR));
368
369 EXPECT_EQ(authState->Action(context), DM_OK);
370 }
371
372 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthDoneState_005, testing::ext::TestSize.Level1)
373 {
374 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthDoneState>();
375
376 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
377 .WillOnce(Return(DM_OK));
378
379 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
380 .WillOnce(Return(ON_REQUEST));
381
382 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
383 }
384
385 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthDoneState_006, testing::ext::TestSize.Level1)
386 {
387 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthDoneState>();
388
389 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
390 .WillOnce(Return(DM_OK));
391
392 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
393 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
394 .WillOnce(Return(ON_ERROR));
395
396 EXPECT_EQ(authState->Action(context), DM_OK);
397 }
398
399 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinAuthDoneState_007, testing::ext::TestSize.Level1)
400 {
401 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinAuthDoneState>();
402
403 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
404 .WillOnce(Return(DM_OK));
405
406 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
407 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
408 .WillOnce(Return(ON_REQUEST));
409
410 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
411 }
412
413 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthDoneState_001, testing::ext::TestSize.Level1)
414 {
415 std::shared_ptr<AuthSinkPinAuthDoneState> authState = std::make_shared<AuthSinkPinAuthDoneState>();
416 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_PIN_AUTH_DONE_STATE);
417 }
418
419 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinAuthDoneState_002, testing::ext::TestSize.Level1)
420 {
421 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinAuthDoneState>();
422
423 EXPECT_EQ(authState->Action(context), DM_OK);
424 }
425
426 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicStartState_001, testing::ext::TestSize.Level1)
427 {
428 std::shared_ptr<AuthSrcReverseUltrasonicStartState> authState =
429 std::make_shared<AuthSrcReverseUltrasonicStartState>();
430 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_REVERSE_ULTRASONIC_START_STATE);
431 }
432
433 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicStartState_002, testing::ext::TestSize.Level1)
434 {
435 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicStartState>();
436 EXPECT_EQ(authState->Action(context), DM_OK);
437 }
438
439 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicStartState_003, testing::ext::TestSize.Level1)
440 {
441 std::shared_ptr<AuthSrcReverseUltrasonicStartState> authState =
442 std::make_shared<AuthSrcReverseUltrasonicStartState>();
443 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_REVERSE_ULTRASONIC_START_STATE);
444 }
445
446 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicStartState_004, testing::ext::TestSize.Level1)
447 {
448 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicStartState>();
449 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
450 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
451 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
452 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
453 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
454
455 EXPECT_EQ(authState->Action(context), DM_OK);
456 }
457
458 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_001, testing::ext::TestSize.Level1)
459 {
460 std::shared_ptr<AuthSrcReverseUltrasonicDoneState> authState =
461 std::make_shared<AuthSrcReverseUltrasonicDoneState>();
462 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_REVERSE_ULTRASONIC_DONE_STATE);
463 }
464
465 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_002, testing::ext::TestSize.Level1)
466 {
467 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicDoneState>();
468 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
469 .WillOnce(Return(ERR_DM_FAILED));
470 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
471 }
472
473 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_003, testing::ext::TestSize.Level1)
474 {
475 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicDoneState>();
476 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
477 .WillOnce(Return(DM_OK));
478 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
479 .WillOnce(Return(ON_TRANSMIT));
480 EXPECT_EQ(authState->Action(context), DM_OK);
481 }
482
483 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_004, testing::ext::TestSize.Level1)
484 {
485 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicDoneState>();
486 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
487 .WillOnce(Return(DM_OK));
488 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
489 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
490 EXPECT_EQ(authState->Action(context), STOP_BIND);
491 }
492
493 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_005, testing::ext::TestSize.Level1)
494 {
495 std::shared_ptr<AuthSrcReverseUltrasonicDoneState> authState =
496 std::make_shared<AuthSrcReverseUltrasonicDoneState>();
497 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_REVERSE_ULTRASONIC_DONE_STATE);
498 }
499
500 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_006, testing::ext::TestSize.Level1)
501 {
502 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicDoneState>();
503 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
504 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
505 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
506 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
507 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
508 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
509 .WillOnce(Return(DM_OK));
510
511 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
512 .WillOnce(Return(DmEventType::ON_TRANSMIT));
513 EXPECT_EQ(authState->Action(context), DM_OK);
514 }
515
516 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_007, testing::ext::TestSize.Level1)
517 {
518 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicDoneState>();
519 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
520 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
521 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
522 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
523 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
524 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
525 .WillOnce(Return(DM_OK));
526
527 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
528 .WillOnce(Return(DmEventType::ON_ERROR));
529 EXPECT_EQ(authState->Action(context), DM_OK);
530 }
531
532 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_008, testing::ext::TestSize.Level1)
533 {
534 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicDoneState>();
535 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
536 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
537 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
538 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
539 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
540 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
541 .WillOnce(Return(DM_OK));
542
543 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
544 .WillOnce(Return(DmEventType::ON_FAIL));
545 EXPECT_EQ(authState->Action(context), STOP_BIND);
546 }
547 HWTEST_F(AuthPinAuthStateTest, AuthSrcReverseUltrasonicDoneState_009, testing::ext::TestSize.Level1)
548 {
549 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcReverseUltrasonicDoneState>();
550 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
551 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
552 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
553 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
554 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
555 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
556 .WillOnce(Return(STOP_BIND));
557
558 EXPECT_EQ(authState->Action(context), STOP_BIND);
559 }
560
561 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicStartState_001, testing::ext::TestSize.Level1)
562 {
563 std::shared_ptr<AuthSrcForwardUltrasonicStartState> authState =
564 std::make_shared<AuthSrcForwardUltrasonicStartState>();
565 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_FORWARD_ULTRASONIC_START_STATE);
566 }
567
568 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicStartState_002, testing::ext::TestSize.Level1)
569 {
570 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicStartState>();
571 EXPECT_EQ(authState->Action(context), DM_OK);
572 }
573
574 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicStartState_003, testing::ext::TestSize.Level1)
575 {
576 std::shared_ptr<AuthSrcForwardUltrasonicStartState> authState =
577 std::make_shared<AuthSrcForwardUltrasonicStartState>();
578 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_FORWARD_ULTRASONIC_START_STATE);
579 }
580
581 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicStartState_004, testing::ext::TestSize.Level1)
582 {
583 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicStartState>();
584 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
585 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
586 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
587 context->ultrasonicInfo = DM_Ultrasonic_Forward;
588 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
589
590 EXPECT_EQ(authState->Action(context), DM_OK);
591 }
592
593 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_001, testing::ext::TestSize.Level1)
594 {
595 std::shared_ptr<AuthSrcForwardUltrasonicDoneState> authState =
596 std::make_shared<AuthSrcForwardUltrasonicDoneState>();
597 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_FORWARD_ULTRASONIC_DONE_STATE);
598 }
599
600 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_002, testing::ext::TestSize.Level1)
601 {
602 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
603 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
604 .WillOnce(Return(ON_ULTRASONIC_PIN_CHANGED));
605 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
606 .WillOnce(Return(ERR_DM_FAILED));
607 EXPECT_EQ(authState->Action(context), STOP_BIND);
608 }
609
610 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_003, testing::ext::TestSize.Level1)
611 {
612 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
613 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
614 .WillOnce(Return(ON_ULTRASONIC_PIN_CHANGED))
615 .WillOnce(Return(ON_TRANSMIT));
616 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
617 .WillOnce(Return(DM_OK));
618 EXPECT_EQ(authState->Action(context), DM_OK);
619 }
620
621 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_004, testing::ext::TestSize.Level1)
622 {
623 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
624 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
625 .WillOnce(Return(ON_ULTRASONIC_PIN_CHANGED))
626 .WillOnce(Return(ON_ERROR));
627 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
628 .WillOnce(Return(DM_OK));
629 EXPECT_EQ(authState->Action(context), DM_OK);
630 }
631
632 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_005, testing::ext::TestSize.Level1)
633 {
634 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
635 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
636 .WillOnce(Return(ON_ULTRASONIC_PIN_TIMEOUT));
637 EXPECT_EQ(authState->Action(context), DM_OK);
638 }
639
640 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_006, testing::ext::TestSize.Level1)
641 {
642 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
643 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
644 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
645 EXPECT_EQ(authState->Action(context), STOP_BIND);
646 }
647
648 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_007, testing::ext::TestSize.Level1)
649 {
650 std::shared_ptr<AuthSrcForwardUltrasonicDoneState> authState =
651 std::make_shared<AuthSrcForwardUltrasonicDoneState>();
652 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_FORWARD_ULTRASONIC_DONE_STATE);
653 }
654
655 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_008, testing::ext::TestSize.Level1)
656 {
657 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
658 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
659 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
660 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
661 context->ultrasonicInfo = DM_Ultrasonic_Forward;
662 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
663 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
664 .WillOnce(Return(DM_OK));
665
666 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
667 .WillOnce(Return(DmEventType::ON_ULTRASONIC_PIN_CHANGED))
668 .WillOnce(Return(DmEventType::ON_TRANSMIT));
669
670 EXPECT_EQ(authState->Action(context), DM_OK);
671 }
672
673 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_009, testing::ext::TestSize.Level1)
674 {
675 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
676 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
677 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
678 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
679 context->ultrasonicInfo = DM_Ultrasonic_Forward;
680 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
681 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
682 .WillOnce(Return(DM_OK));
683
684 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
685 .WillOnce(Return(DmEventType::ON_ULTRASONIC_PIN_CHANGED))
686 .WillOnce(Return(DmEventType::ON_ERROR));
687
688 EXPECT_EQ(authState->Action(context), DM_OK);
689 }
690
691 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_010, testing::ext::TestSize.Level1)
692 {
693 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
694 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
695 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
696 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
697 context->ultrasonicInfo = DM_Ultrasonic_Forward;
698 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
699
700 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
701 .WillOnce(Return(DmEventType::ON_ULTRASONIC_PIN_TIMEOUT));
702
703 EXPECT_EQ(authState->Action(context), DM_OK);
704 }
705
706 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_011, testing::ext::TestSize.Level1)
707 {
708 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
709 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
710 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
711 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
712 context->ultrasonicInfo = DM_Ultrasonic_Forward;
713 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
714
715 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
716 .WillOnce(Return(DmEventType::ON_FAIL));
717
718 EXPECT_EQ(authState->Action(context), STOP_BIND);
719 }
720
721 HWTEST_F(AuthPinAuthStateTest, AuthSrcForwardUltrasonicDoneState_012, testing::ext::TestSize.Level1)
722 {
723 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcForwardUltrasonicDoneState>();
724 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
725 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
726 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
727 context->ultrasonicInfo = DM_Ultrasonic_Forward;
728 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
729 EXPECT_CALL(*hiChainAuthConnectorMock, AuthCredentialPinCode(_, _, _))
730 .WillOnce(Return(STOP_BIND));
731
732 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
733 .WillOnce(Return(DmEventType::ON_ULTRASONIC_PIN_CHANGED));
734
735 EXPECT_EQ(authState->Action(context), STOP_BIND);
736 }
737
738 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicStartState_001, testing::ext::TestSize.Level1)
739 {
740 std::shared_ptr<AuthSinkReverseUltrasonicStartState> authState =
741 std::make_shared<AuthSinkReverseUltrasonicStartState>();
742 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_REVERSE_ULTRASONIC_START_STATE);
743 }
744
745 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicStartState_002, testing::ext::TestSize.Level1)
746 {
747 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicStartState>();
748 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
749 .WillOnce(Return(ON_ULTRASONIC_PIN_CHANGED));
750 EXPECT_EQ(authState->Action(context), DM_OK);
751 }
752
753 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicStartState_003, testing::ext::TestSize.Level1)
754 {
755 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicStartState>();
756 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
757 .WillOnce(Return(ON_ULTRASONIC_PIN_TIMEOUT));
758 EXPECT_EQ(authState->Action(context), DM_OK);
759 }
760
761 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicStartState_004, testing::ext::TestSize.Level1)
762 {
763 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicStartState>();
764 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
765 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
766 EXPECT_EQ(authState->Action(context), STOP_BIND);
767 }
768
769 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicStartState_005, testing::ext::TestSize.Level1)
770 {
771 std::shared_ptr<AuthSinkReverseUltrasonicStartState> authState =
772 std::make_shared<AuthSinkReverseUltrasonicStartState>();
773 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_REVERSE_ULTRASONIC_START_STATE);
774 }
775
776 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicStartState_006, testing::ext::TestSize.Level1)
777 {
778 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicStartState>();
779 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
780 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
781 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
782 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
783 context->direction = DmAuthDirection::DM_AUTH_SINK;
784 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
785 .WillOnce(Return(DmEventType::ON_ULTRASONIC_PIN_CHANGED));
786 EXPECT_EQ(authState->Action(context), DM_OK);
787 }
788
789 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicStartState_007, testing::ext::TestSize.Level1)
790 {
791 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicStartState>();
792 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
793 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
794 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
795 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
796 context->direction = DmAuthDirection::DM_AUTH_SINK;
797 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
798 .WillOnce(Return(DmEventType::ON_ULTRASONIC_PIN_TIMEOUT));
799 EXPECT_EQ(authState->Action(context), DM_OK);
800 }
801
802 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicStartState_008, testing::ext::TestSize.Level1)
803 {
804 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicStartState>();
805 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
806 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
807 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
808 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
809 context->direction = DmAuthDirection::DM_AUTH_SINK;
810 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
811 .WillOnce(Return(DmEventType::ON_FAIL));
812 EXPECT_EQ(authState->Action(context), STOP_BIND);
813 }
814
815 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_001, testing::ext::TestSize.Level1)
816 {
817 std::shared_ptr<AuthSinkReverseUltrasonicDoneState> authState =
818 std::make_shared<AuthSinkReverseUltrasonicDoneState>();
819 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_REVERSE_ULTRASONIC_DONE_STATE);
820 }
821
822 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_002, testing::ext::TestSize.Level1)
823 {
824 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicDoneState>();
825 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
826 .WillOnce(Return(ERR_DM_FAILED));
827 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
828 }
829
830 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_003, testing::ext::TestSize.Level1)
831 {
832 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicDoneState>();
833 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
834 .WillOnce(Return(DM_OK));
835 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
836 .WillOnce(Return(ON_TRANSMIT));
837 EXPECT_EQ(authState->Action(context), DM_OK);
838 }
839
840 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_004, testing::ext::TestSize.Level1)
841 {
842 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicDoneState>();
843 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
844 .WillOnce(Return(DM_OK));
845 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
846 .WillOnce(Return(ON_ERROR));
847 EXPECT_EQ(authState->Action(context), DM_OK);
848 }
849
850 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_005, testing::ext::TestSize.Level1)
851 {
852 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicDoneState>();
853 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
854 .WillOnce(Return(DM_OK));
855 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
856 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
857 EXPECT_EQ(authState->Action(context), STOP_BIND);
858 }
859
860 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_006, testing::ext::TestSize.Level1)
861 {
862 std::shared_ptr<AuthSinkReverseUltrasonicDoneState> authState =
863 std::make_shared<AuthSinkReverseUltrasonicDoneState>();
864 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_REVERSE_ULTRASONIC_DONE_STATE);
865 }
866
867 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_007, testing::ext::TestSize.Level1)
868 {
869 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicDoneState>();
870 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
871 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
872 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
873 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
874 context->direction = DmAuthDirection::DM_AUTH_SINK;
875 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
876 .WillOnce(Return(DM_OK));
877 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
878 .WillOnce(Return(DmEventType::ON_TRANSMIT));
879
880 EXPECT_EQ(authState->Action(context), DM_OK);
881 }
882
883 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_008, testing::ext::TestSize.Level1)
884 {
885 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicDoneState>();
886 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
887 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
888 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
889 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
890 context->direction = DmAuthDirection::DM_AUTH_SINK;
891 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
892 .WillOnce(Return(DM_OK));
893 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
894 .WillOnce(Return(DmEventType::ON_ERROR));
895
896 EXPECT_EQ(authState->Action(context), DM_OK);
897 }
898
899 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_009, testing::ext::TestSize.Level1)
900 {
901 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicDoneState>();
902 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
903 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
904 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
905 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
906 context->direction = DmAuthDirection::DM_AUTH_SINK;
907 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
908 .WillOnce(Return(DM_OK));
909 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
910 .WillOnce(Return(DmEventType::ON_FAIL));
911
912 EXPECT_EQ(authState->Action(context), STOP_BIND);
913 }
914
915 HWTEST_F(AuthPinAuthStateTest, AuthSinkReverseUltrasonicDoneState_010, testing::ext::TestSize.Level1)
916 {
917 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkReverseUltrasonicDoneState>();
918 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
919 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
920 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
921 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
922 context->direction = DmAuthDirection::DM_AUTH_SINK;
923 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
924 .WillOnce(Return(STOP_BIND));
925
926 EXPECT_EQ(authState->Action(context), STOP_BIND);
927 }
928
929 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicStartState_001, testing::ext::TestSize.Level1)
930 {
931 std::shared_ptr<AuthSinkForwardUltrasonicStartState> authState =
932 std::make_shared<AuthSinkForwardUltrasonicStartState>();
933 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_FORWARD_ULTRASONIC_START_STATE);
934 }
935
936 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicStartState_002, testing::ext::TestSize.Level1)
937 {
938 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicStartState>();
939 EXPECT_EQ(authState->Action(context), DM_OK);
940 }
941
942 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicStartState_003, testing::ext::TestSize.Level1)
943 {
944 std::shared_ptr<AuthSinkForwardUltrasonicStartState> authState =
945 std::make_shared<AuthSinkForwardUltrasonicStartState>();
946 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_FORWARD_ULTRASONIC_START_STATE);
947 }
948
949 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicStartState_004, testing::ext::TestSize.Level1)
950 {
951 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicStartState>();
952 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
953 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
954 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
955 context->ultrasonicInfo = DM_Ultrasonic_Forward;
956 context->direction = DmAuthDirection::DM_AUTH_SINK;
957
958 EXPECT_EQ(authState->Action(context), DM_OK);
959 }
960
961 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_001, testing::ext::TestSize.Level1)
962 {
963 std::shared_ptr<AuthSinkForwardUltrasonicDoneState> authState =
964 std::make_shared<AuthSinkForwardUltrasonicDoneState>();
965 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_FORWARD_ULTRASONIC_DONE_STATE);
966 }
967
968 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_002, testing::ext::TestSize.Level1)
969 {
970 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicDoneState>();
971 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
972 .WillOnce(Return(ERR_DM_FAILED));
973 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
974 }
975
976 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_003, testing::ext::TestSize.Level1)
977 {
978 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicDoneState>();
979 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
980 .WillOnce(Return(DM_OK));
981 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
982 .WillOnce(Return(ON_TRANSMIT));
983 EXPECT_EQ(authState->Action(context), DM_OK);
984 }
985
986 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_004, testing::ext::TestSize.Level1)
987 {
988 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicDoneState>();
989 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
990 .WillOnce(Return(DM_OK));
991 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
992 .WillOnce(Return(ON_ERROR));
993 EXPECT_EQ(authState->Action(context), DM_OK);
994 }
995
996 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_005, testing::ext::TestSize.Level1)
997 {
998 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicDoneState>();
999 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
1000 .WillOnce(Return(DM_OK));
1001 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
1002 .WillOnce(Return(ON_SESSION_KEY_RETURNED));
1003 EXPECT_EQ(authState->Action(context), STOP_BIND);
1004 }
1005
1006 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_006, testing::ext::TestSize.Level1)
1007 {
1008 std::shared_ptr<AuthSinkForwardUltrasonicDoneState> authState =
1009 std::make_shared<AuthSinkForwardUltrasonicDoneState>();
1010 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_FORWARD_ULTRASONIC_DONE_STATE);
1011 }
1012
1013 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_007, testing::ext::TestSize.Level1)
1014 {
1015 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicDoneState>();
1016 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1017 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
1018 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
1019 context->ultrasonicInfo = DM_Ultrasonic_Forward;
1020 context->direction = DmAuthDirection::DM_AUTH_SINK;
1021 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
1022 .WillOnce(Return(DM_OK));
1023 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
1024 .WillOnce(Return(DmEventType::ON_TRANSMIT));
1025 EXPECT_EQ(authState->Action(context), DM_OK);
1026 }
1027
1028 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_008, testing::ext::TestSize.Level1)
1029 {
1030 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicDoneState>();
1031 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1032 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
1033 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
1034 context->ultrasonicInfo = DM_Ultrasonic_Forward;
1035 context->direction = DmAuthDirection::DM_AUTH_SINK;
1036 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
1037 .WillOnce(Return(DM_OK));
1038 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
1039 .WillOnce(Return(DmEventType::ON_ERROR));
1040 EXPECT_EQ(authState->Action(context), DM_OK);
1041 }
1042
1043 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_009, testing::ext::TestSize.Level1)
1044 {
1045 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicDoneState>();
1046 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1047 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
1048 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
1049 context->ultrasonicInfo = DM_Ultrasonic_Forward;
1050 context->direction = DmAuthDirection::DM_AUTH_SINK;
1051 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
1052 .WillOnce(Return(DM_OK));
1053 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
1054 .WillOnce(Return(DmEventType::ON_FAIL));
1055 EXPECT_EQ(authState->Action(context), STOP_BIND);
1056 }
1057
1058 HWTEST_F(AuthPinAuthStateTest, AuthSinkForwardUltrasonicDoneState_010, testing::ext::TestSize.Level1)
1059 {
1060 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkForwardUltrasonicDoneState>();
1061 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1062 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
1063 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
1064 context->ultrasonicInfo = DM_Ultrasonic_Forward;
1065 context->direction = DmAuthDirection::DM_AUTH_SINK;
1066 EXPECT_CALL(*hiChainAuthConnectorMock, ProcessCredData(_, _))
1067 .WillOnce(Return(STOP_BIND));
1068
1069 EXPECT_EQ(authState->Action(context), STOP_BIND);
1070 }
1071
1072 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_001, testing::ext::TestSize.Level1)
1073 {
1074 std::shared_ptr<AuthSrcPinNegotiateStartState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1075 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_PIN_NEGOTIATE_START_STATE);
1076 }
1077
1078 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_002, testing::ext::TestSize.Level1)
1079 {
1080 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1081 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1082 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1083 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1084 context->pinNegotiateStarted = false;
1085
1086 EXPECT_EQ(authState->Action(context), DM_OK);
1087 }
1088
1089 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_003, testing::ext::TestSize.Level1)
1090 {
1091 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1092 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1093 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
1094 context->ultrasonicInfo = DM_Ultrasonic_Forward;
1095 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1096 context->pinNegotiateStarted = false;
1097 EXPECT_EQ(authState->Action(context), DM_OK);
1098 }
1099
1100 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_004, testing::ext::TestSize.Level1)
1101 {
1102 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1103 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1104 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
1105 context->ultrasonicInfo = DM_Ultrasonic_Reverse;
1106 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1107 context->pinNegotiateStarted = false;
1108 EXPECT_EQ(authState->Action(context), DM_OK);
1109 }
1110
1111 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_005, testing::ext::TestSize.Level1)
1112 {
1113 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1114 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1115 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_IMPORT_AUTH_CODE);
1116 context->importAuthCode = "123456";
1117 context->importPkgName = "com.test.example";
1118 context->pkgName = "com.test.example";
1119 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1120 context->pinNegotiateStarted = false;
1121 EXPECT_EQ(authState->Action(context), DM_OK);
1122 }
1123
1124 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_006, testing::ext::TestSize.Level1)
1125 {
1126 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1127 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1128 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1129 context->authType = DmAuthType::AUTH_TYPE_PIN;
1130 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1131 context->accesser.credentialInfos[DM_IDENTICAL_ACCOUNT] = R"({"credId": 1234})";
1132
1133 context->pinNegotiateStarted = true;
1134 context->needBind = false;
1135 context->needAgreeCredential = false;
1136 context->needAuth = true;
1137 context->accesser.credTypeList = R"({"identicalCredType": 1})";
1138 EXPECT_EQ(authState->Action(context), DM_OK);
1139 context->accesser.credTypeList = R"({"shareCredType": 2})";
1140 EXPECT_EQ(authState->Action(context), DM_OK);
1141 context->accesser.credTypeList = R"({"pointTopointCredType": 256})";
1142 EXPECT_EQ(authState->Action(context), DM_OK);
1143 context->accesser.credTypeList = R"({"lnnCredType": 3})";
1144 EXPECT_EQ(authState->Action(context), DM_OK);
1145 }
1146
1147 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_007, testing::ext::TestSize.Level1)
1148 {
1149 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1150 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1151 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1152 context->authType = DmAuthType::AUTH_TYPE_PIN;
1153 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1154 context->pinNegotiateStarted = true;
1155 context->needBind = false;
1156 context->needAgreeCredential = false;
1157 context->needAuth = false;
1158 EXPECT_EQ(authState->Action(context), DM_OK);
1159 }
1160
1161 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_008, testing::ext::TestSize.Level1)
1162 {
1163 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1164 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1165 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1166 context->authType = DmAuthType::AUTH_TYPE_PIN;
1167 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1168 context->pinNegotiateStarted = true;
1169 context->needBind = false;
1170 context->needAgreeCredential = true;
1171 context->needAuth = false;
1172 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
1173 }
1174
1175 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_009, testing::ext::TestSize.Level1)
1176 {
1177 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1178 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1179 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1180 context->authType = DmAuthType::AUTH_TYPE_PIN;
1181 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1182 context->pinNegotiateStarted = false;
1183
1184 EXPECT_EQ(authState->Action(context), DM_OK);
1185 EXPECT_EQ(context->pinNegotiateStarted, true);
1186 context->needBind = true;
1187 EXPECT_EQ(authState->Action(context), DM_OK);
1188 }
1189
1190 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinNegotiateStartState_010, testing::ext::TestSize.Level1)
1191 {
1192 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinNegotiateStartState>();
1193 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1194 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_UNKNOW);
1195 context->authType = DmAuthType::AUTH_TYPE_UNKNOW;
1196 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1197 context->pinNegotiateStarted = true;
1198 context->needBind = true;
1199 EXPECT_EQ(authState->Action(context), ERR_DM_BIND_PIN_CODE_ERROR);
1200 }
1201
1202 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinInputState_001, testing::ext::TestSize.Level1)
1203 {
1204 std::shared_ptr<AuthSrcPinInputState> authState = std::make_shared<AuthSrcPinInputState>();
1205 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_PIN_INPUT_STATE);
1206 }
1207
1208 HWTEST_F(AuthPinAuthStateTest, AuthSrcPinInputState_002, testing::ext::TestSize.Level1)
1209 {
1210 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcPinInputState>();
1211 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1212 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1213 context->authType = DmAuthType::AUTH_TYPE_PIN;
1214 context->direction = DmAuthDirection::DM_AUTH_SOURCE;
1215 EXPECT_CALL(*DmAuthStateMachineMock::dmAuthStateMachineMock, WaitExpectEvent(_))
1216 .WillOnce(Return(DmEventType::ON_USER_OPERATION))
1217 .WillOnce(Return(DmEventType::ON_USER_OPERATION))
1218 .WillOnce(Return(DmEventType::ON_USER_OPERATION))
1219 .WillOnce(Return(DmEventType::ON_FAIL));
1220
1221 context->pinInputResult = USER_OPERATION_TYPE_DONE_PINCODE_INPUT;
1222 EXPECT_EQ(authState->Action(context), DM_OK);
1223 context->inputPinAuthFailTimes = 1;
1224 EXPECT_EQ(authState->Action(context), DM_OK);
1225
1226 context->pinInputResult = USER_OPERATION_TYPE_CANCEL_PINCODE_INPUT;
1227 EXPECT_EQ(authState->Action(context), STOP_BIND);
1228
1229 context->pinInputResult = USER_OPERATION_TYPE_DONE_PINCODE_INPUT;
1230 EXPECT_EQ(authState->Action(context), STOP_BIND);
1231 }
1232
1233 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinNegotiateStartState_001, testing::ext::TestSize.Level1)
1234 {
1235 std::shared_ptr<AuthSinkPinNegotiateStartState> authState = std::make_shared<AuthSinkPinNegotiateStartState>();
1236 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_PIN_NEGOTIATE_START_STATE);
1237 }
1238
1239 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinNegotiateStartState_002, testing::ext::TestSize.Level1)
1240 {
1241 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinNegotiateStartState>();
1242 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1243 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1244 context->authType = DmAuthType::AUTH_TYPE_PIN;
1245 context->direction = DmAuthDirection::DM_AUTH_SINK;
1246 context->pinNegotiateStarted = false;
1247 EXPECT_EQ(authState->Action(context), DM_OK);
1248
1249 EXPECT_EQ(context->pinNegotiateStarted, true);
1250 EXPECT_EQ(authState->Action(context), DM_OK);
1251 }
1252
1253 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinNegotiateStartState_003, testing::ext::TestSize.Level1)
1254 {
1255 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinNegotiateStartState>();
1256 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1257 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_IMPORT_AUTH_CODE);
1258 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1259 context->authType = DmAuthType::AUTH_TYPE_IMPORT_AUTH_CODE;
1260 context->direction = DmAuthDirection::DM_AUTH_SINK;
1261 context->pinNegotiateStarted = false;
1262 EXPECT_EQ(authState->Action(context), DM_OK);
1263
1264 EXPECT_EQ(context->pinNegotiateStarted, true);
1265 EXPECT_EQ(authState->Action(context), DM_OK);
1266 }
1267
1268 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinNegotiateStartState_004, testing::ext::TestSize.Level1)
1269 {
1270 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinNegotiateStartState>();
1271 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1272 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_IMPORT_AUTH_CODE);
1273 context->authType = DmAuthType::AUTH_TYPE_IMPORT_AUTH_CODE;
1274 context->direction = DmAuthDirection::DM_AUTH_SINK;
1275 context->pinNegotiateStarted = false;
1276 EXPECT_EQ(authState->Action(context), DM_OK);
1277
1278 EXPECT_EQ(context->pinNegotiateStarted, true);
1279 EXPECT_EQ(authState->Action(context), ERR_DM_BIND_PIN_CODE_ERROR);
1280 }
1281
1282 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinNegotiateStartState_005, testing::ext::TestSize.Level1)
1283 {
1284 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinNegotiateStartState>();
1285 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1286 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN_ULTRASONIC);
1287 context->authType = DmAuthType::AUTH_TYPE_PIN_ULTRASONIC;
1288 context->direction = DmAuthDirection::DM_AUTH_SINK;
1289 context->pinNegotiateStarted = false;
1290 EXPECT_EQ(authState->Action(context), DM_OK);
1291 }
1292
1293 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinNegotiateStartState_006, testing::ext::TestSize.Level1)
1294 {
1295 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinNegotiateStartState>();
1296 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1297 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_UNKNOW);
1298 context->authType = DmAuthType::AUTH_TYPE_UNKNOW;
1299 context->direction = DmAuthDirection::DM_AUTH_SINK;
1300 context->pinNegotiateStarted = false;
1301 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
1302 }
1303
1304 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinDisplayState_001, testing::ext::TestSize.Level1)
1305 {
1306 std::shared_ptr<AuthSinkPinDisplayState> authState = std::make_shared<AuthSinkPinDisplayState>();
1307 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_PIN_DISPLAY_STATE);
1308 }
1309
1310 HWTEST_F(AuthPinAuthStateTest, AuthSinkPinDisplayState_002, testing::ext::TestSize.Level1)
1311 {
1312 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkPinDisplayState>();
1313 context->confirmOperation = UiAction::USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
1314 context->authTypeList.push_back(DmAuthType::AUTH_TYPE_PIN);
1315 context->authType = DmAuthType::AUTH_TYPE_PIN;
1316 context->direction = DmAuthDirection::DM_AUTH_SINK;
1317 context->inputPinAuthFailTimes = 0;
1318 EXPECT_EQ(authState->Action(context), DM_OK);
1319
1320 context->inputPinAuthFailTimes = 1;
1321 EXPECT_EQ(authState->Action(context), DM_OK);
1322 }
1323
1324 }
1325 }