1 /*
2 * Copyright (c) 2021-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
18 #include <thread>
19 #include <pthread.h>
20
21 #include "executor.h"
22 #include "framework_executor_callback.h"
23 #include "iam_mem.h"
24 #include "iam_ptr.h"
25
26 #include "mock_executor_mgr_wrapper.h"
27 #include "mock_iasync_command.h"
28 #include "mock_iauth_driver_hdi.h"
29 #include "mock_iauth_executor_hdi.h"
30 #include "mock_iexecutor_messenger.h"
31
32 #define IF_FALSE_EXPECT_FAIL_AND_RETURN_VAL(cond, retVal) \
33 do { \
34 if (!(cond)) { \
35 EXPECT_TRUE(cond); \
36 return (retVal); \
37 } \
38 } while (0)
39
40 using namespace std;
41 using namespace testing;
42 using namespace testing::ext;
43 using namespace OHOS::UserIam;
44 using namespace OHOS::UserIam::Common;
45 using namespace OHOS::UserIam::UserAuth;
46
47 namespace OHOS {
48 namespace UserIam {
49 namespace UserAuth {
50 class ExecutorUnitTest : public testing::Test {
51 public:
52 static void SetUpTestCase();
53 static void TearDownTestCase();
54 void SetUp();
55 void TearDown();
56 };
57
SetUpTestCase()58 void ExecutorUnitTest::SetUpTestCase()
59 {
60 }
61
TearDownTestCase()62 void ExecutorUnitTest::TearDownTestCase()
63 {
64 }
65
SetUp()66 void ExecutorUnitTest::SetUp()
67 {
68 }
69
TearDown()70 void ExecutorUnitTest::TearDown()
71 {
72 }
73
74 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnHdiConnectTest_001, TestSize.Level0)
75 {
76 const uint16_t testHdiId = 5;
77 const ExecutorInfo testInfo = {
78 .authType = static_cast<AuthType>(1),
79 .executorRole = static_cast<ExecutorRole>(2),
80 .executorSensorHint = 10,
81 .executorMatcher = 2,
82 .esl = static_cast<ExecutorSecureLevel>(4),
83 .publicKey = {5, 6, 7},
84 };
85 auto executorMgrWrapper = MakeShared<MockExecutorMgrWrapper>();
86 ASSERT_NE(executorMgrWrapper, nullptr);
87 EXPECT_CALL(*executorMgrWrapper, Register(_, _))
88 .Times(Exactly(1))
__anonbf3247130102(const ExecutorInfo &info, std::shared_ptr<ExecutorRegisterCallback> callback) 89 .WillOnce([&testInfo](const ExecutorInfo &info, std::shared_ptr<ExecutorRegisterCallback> callback) {
90 EXPECT_TRUE(static_cast<const uint32_t>(info.executorSensorHint) ==
91 Common::CombineUint16ToUint32(testHdiId, static_cast<uint16_t>(testInfo.executorSensorHint)));
92 EXPECT_EQ(info.authType, testInfo.authType);
93 EXPECT_EQ(info.executorRole, testInfo.executorRole);
94 EXPECT_EQ(info.executorMatcher, testInfo.executorMatcher);
95 EXPECT_EQ(info.esl, testInfo.esl);
96 EXPECT_EQ(info.publicKey, testInfo.publicKey);
97 EXPECT_NE(callback, nullptr);
98 return 0;
99 });
100 auto executorHdi = MakeShared<MockIAuthExecutorHdi>();
101 ASSERT_NE(executorHdi, nullptr);
__anonbf3247130202(ExecutorInfo &info) 102 EXPECT_CALL(*executorHdi, GetExecutorInfo(_)).Times(Exactly(2)).WillRepeatedly([&testInfo](ExecutorInfo &info) {
103 info.executorSensorHint = testInfo.executorSensorHint;
104 info.authType = testInfo.authType;
105 info.executorRole = testInfo.executorRole;
106 info.executorSensorHint = testInfo.executorSensorHint;
107 info.executorMatcher = testInfo.executorMatcher;
108 info.esl = testInfo.esl;
109 info.publicKey.assign(testInfo.publicKey.begin(), testInfo.publicKey.end());
110 return ResultCode::SUCCESS;
111 });
112 auto executor = MakeShared<Executor>(executorMgrWrapper, executorHdi, testHdiId);
113 ASSERT_NE(executor, nullptr);
114 executor->Register();
115 }
116
117 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnFrameworkReadyTest_001, TestSize.Level0)
118 {
119 const uint16_t testHdiId = 5;
120 const ExecutorInfo testInfo = {
121 .authType = static_cast<AuthType>(1),
122 .executorRole = static_cast<ExecutorRole>(2),
123 .executorSensorHint = 10,
124 .executorMatcher = 2,
125 .esl = static_cast<ExecutorSecureLevel>(4),
126 .publicKey = {5, 6, 7},
127 };
128 auto executorMgrWrapper = MakeShared<MockExecutorMgrWrapper>();
129 ASSERT_NE(executorMgrWrapper, nullptr);
130 EXPECT_CALL(*executorMgrWrapper, Register(_, _))
131 .Times(Exactly(1))
__anonbf3247130302(const ExecutorInfo &info, std::shared_ptr<ExecutorRegisterCallback> callback) 132 .WillOnce([&testInfo](const ExecutorInfo &info, std::shared_ptr<ExecutorRegisterCallback> callback) {
133 EXPECT_TRUE(static_cast<const uint32_t>(info.executorSensorHint) ==
134 Common::CombineUint16ToUint32(testHdiId, static_cast<uint16_t>(testInfo.executorSensorHint)));
135 EXPECT_EQ(info.authType, testInfo.authType);
136 EXPECT_EQ(info.executorRole, testInfo.executorRole);
137 EXPECT_EQ(info.executorMatcher, testInfo.executorMatcher);
138 EXPECT_EQ(info.esl, testInfo.esl);
139 EXPECT_EQ(info.publicKey, testInfo.publicKey);
140 EXPECT_NE(callback, nullptr);
141 return 0;
142 });
143 auto executorHdi = MakeShared<MockIAuthExecutorHdi>();
144 ASSERT_NE(executorHdi, nullptr);
__anonbf3247130402(ExecutorInfo &info) 145 EXPECT_CALL(*executorHdi, GetExecutorInfo(_)).Times(Exactly(2)).WillRepeatedly([&testInfo](ExecutorInfo &info) {
146 info.authType = testInfo.authType;
147 info.executorRole = testInfo.executorRole;
148 info.executorSensorHint = testInfo.executorSensorHint;
149 info.executorMatcher = testInfo.executorMatcher;
150 info.esl = testInfo.esl;
151 info.publicKey.assign(testInfo.publicKey.begin(), testInfo.publicKey.end());
152 return ResultCode::SUCCESS;
153 });
154 auto executor = MakeShared<Executor>(executorMgrWrapper, executorHdi, testHdiId);
155 ASSERT_NE(executor, nullptr);
156 executor->Register();
157 }
158
159 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnFrameworkReadyTest_002, TestSize.Level0)
160 {
161 const uint16_t testHdiId = 5;
162 const ExecutorInfo testInfo = {
163 .authType = static_cast<AuthType>(1),
164 .executorRole = static_cast<ExecutorRole>(2),
165 .executorSensorHint = 10,
166 .executorMatcher = 2,
167 .esl = static_cast<ExecutorSecureLevel>(4),
168 .publicKey = {5, 6, 7},
169 };
170 auto executorMgrWrapper = MakeShared<MockExecutorMgrWrapper>();
171 ASSERT_NE(executorMgrWrapper, nullptr);
172 EXPECT_CALL(*executorMgrWrapper, Register(_, _)).Times(Exactly(0));
173 auto executor = MakeShared<Executor>(executorMgrWrapper, nullptr, testHdiId);
174 ASSERT_NE(executor, nullptr);
175 executor->Register();
176 }
177
178 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnFrameworkReadyTest_003, TestSize.Level0)
179 {
180 const uint16_t testHdiId = 5;
181 const ExecutorInfo testInfo = {
182 .authType = static_cast<AuthType>(1),
183 .executorRole = static_cast<ExecutorRole>(2),
184 .executorSensorHint = 10,
185 .executorMatcher = 2,
186 .esl = static_cast<ExecutorSecureLevel>(4),
187 .publicKey = {5, 6, 7},
188 };
189 auto executorMgrWrapper = MakeShared<MockExecutorMgrWrapper>();
190 ASSERT_NE(executorMgrWrapper, nullptr);
191 EXPECT_CALL(*executorMgrWrapper, Register(_, _)).Times(Exactly(0));
192 auto executorHdi = MakeShared<MockIAuthExecutorHdi>();
193 ASSERT_NE(executorHdi, nullptr);
__anonbf3247130502(ExecutorInfo &info) 194 EXPECT_CALL(*executorHdi, GetExecutorInfo(_)).Times(Exactly(2)).WillRepeatedly([&testInfo](ExecutorInfo &info) {
195 return ResultCode::GENERAL_ERROR;
196 });
197 auto executor = MakeShared<Executor>(executorMgrWrapper, executorHdi, testHdiId);
198 ASSERT_NE(executor, nullptr);
199 executor->Register();
200 }
201
202 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnFrameworkReadyTest_004, TestSize.Level0)
203 {
204 const uint16_t testHdiId = 5;
205 const ExecutorInfo testInfo = {
206 .authType = static_cast<AuthType>(1),
207 .executorRole = static_cast<ExecutorRole>(2),
208 .executorSensorHint = 10,
209 .executorMatcher = 2,
210 .esl = static_cast<ExecutorSecureLevel>(4),
211 .publicKey = {5, 6, 7},
212 };
213 auto executorHdi = MakeShared<MockIAuthExecutorHdi>();
214 ASSERT_NE(executorHdi, nullptr);
__anonbf3247130602(ExecutorInfo &info) 215 EXPECT_CALL(*executorHdi, GetExecutorInfo(_)).Times(Exactly(2)).WillRepeatedly([&testInfo](ExecutorInfo &info) {
216 info.executorSensorHint = testInfo.executorSensorHint;
217 info.authType = testInfo.authType;
218 info.executorRole = testInfo.executorRole;
219 info.executorMatcher = testInfo.executorMatcher;
220 info.esl = testInfo.esl;
221 info.publicKey.assign(testInfo.publicKey.begin(), testInfo.publicKey.end());
222 return ResultCode::SUCCESS;
223 });
224 auto executor = MakeShared<Executor>(nullptr, executorHdi, testHdiId);
225 ASSERT_NE(executor, nullptr);
226 executor->Register();
227 }
228
229 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_CommandTest_001, TestSize.Level0)
230 {
231 const uint16_t testHdiId = 5;
232 auto executor = MakeShared<Executor>(nullptr, nullptr, testHdiId);
233 ASSERT_NE(executor, nullptr);
234 auto command1 = MakeShared<MockIAsyncCommand>();
235 ASSERT_NE(command1, nullptr);
236 EXPECT_CALL(*command1, OnHdiDisconnect()).Times(Exactly(1));
237 auto command2 = MakeShared<MockIAsyncCommand>();
238 ASSERT_NE(command2, nullptr);
239 EXPECT_CALL(*command2, OnHdiDisconnect()).Times(Exactly(0));
240 auto command3 = MakeShared<MockIAsyncCommand>();
241 ASSERT_NE(command3, nullptr);
242 EXPECT_CALL(*command3, OnHdiDisconnect()).Times(Exactly(1));
243 executor->AddCommand(command1);
244 executor->AddCommand(command1);
245 executor->AddCommand(command2);
246 executor->AddCommand(command3);
247 executor->RemoveCommand(command2);
248 executor->RemoveCommand(command3);
249 executor->RemoveCommand(command3);
250 executor->AddCommand(command3);
251 executor->OnHdiDisconnect();
252 }
253
254 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_GetExecutorHdiTest_001, TestSize.Level0)
255 {
256 const uint16_t testHdiId = 5;
257 const uint64_t testExecutorId = 10;
258 auto executorHdi = MakeShared<MockIAuthExecutorHdi>();
259 ASSERT_NE(executorHdi, nullptr);
__anonbf3247130702(ExecutorInfo &info) 260 EXPECT_CALL(*executorHdi, GetExecutorInfo(_)).Times(Exactly(1)).WillOnce([&testExecutorId](ExecutorInfo &info) {
261 return ResultCode::SUCCESS;
262 });
263 auto executor = MakeShared<Executor>(nullptr, executorHdi, testHdiId);
264 ASSERT_NE(executor, nullptr);
265 }
266
267 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_GetDescriptionTest_001, TestSize.Level0)
268 {
269 const uint16_t testHdiId = 5;
270 const uint64_t testExecutorId = 10;
271 auto executorHdi = MakeShared<MockIAuthExecutorHdi>();
272 ASSERT_NE(executorHdi, nullptr);
__anonbf3247130802(ExecutorInfo &info) 273 EXPECT_CALL(*executorHdi, GetExecutorInfo(_)).Times(Exactly(1)).WillOnce([&testExecutorId](ExecutorInfo &info) {
274 info.executorSensorHint = testExecutorId;
275 info.executorRole = COLLECTOR;
276 info.authType = PIN;
277 return ResultCode::SUCCESS;
278 });
279 auto executor = MakeShared<Executor>(nullptr, executorHdi, testHdiId);
280 ASSERT_NE(executor, nullptr);
281 const string correctDescription = "Executor(Id:0x0005000a, role:1, authType:1)";
282 const char *description = executor->GetDescription();
283 ASSERT_NE(description, nullptr);
__anonbf3247130902(const char *toTest, const char *correct) 284 ASSERT_PRED2([](const char *toTest, const char *correct) { return strcmp(toTest, correct) == 0; }, description,
285 correctDescription.c_str());
286 }
287
288 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_GetDescriptionTest_002, TestSize.Level0)
289 {
290 const uint16_t testHdiId = 5;
291 auto executor = MakeShared<Executor>(nullptr, nullptr, testHdiId);
292 ASSERT_NE(executor, nullptr);
293 const string correctDescription = "";
294 const char *description = executor->GetDescription();
295 ASSERT_NE(description, nullptr);
__anonbf3247130a02(const char *toTest, const char *correct) 296 ASSERT_PRED2([](const char *toTest, const char *correct) { return strcmp(toTest, correct) == 0; }, description,
297 correctDescription.c_str());
298 }
299
300 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_GetDescriptionTest_003, TestSize.Level0)
301 {
302 const uint16_t testHdiId = 5;
303 auto executorHdi = MakeShared<MockIAuthExecutorHdi>();
304 ASSERT_NE(executorHdi, nullptr);
__anonbf3247130b02(ExecutorInfo &info) 305 EXPECT_CALL(*executorHdi, GetExecutorInfo(_)).Times(Exactly(1)).WillOnce([](ExecutorInfo &info) {
306 return ResultCode::GENERAL_ERROR;
307 });
308 auto executor = MakeShared<Executor>(nullptr, executorHdi, testHdiId);
309 ASSERT_NE(executor, nullptr);
310 const string correctDescription = "";
311 const char *description = executor->GetDescription();
312 ASSERT_NE(description, nullptr);
__anonbf3247130c02(const char *toTest, const char *correct) 313 ASSERT_PRED2([](const char *toTest, const char *correct) { return strcmp(toTest, correct) == 0; }, description,
314 correctDescription.c_str());
315 }
316
317 namespace {
GetExecutorAndMockStub(shared_ptr<Executor> & executor,shared_ptr<ExecutorRegisterCallback> & executorCallback,shared_ptr<MockIAuthExecutorHdi> & mockExecutorHdi,std::shared_ptr<MockIExecutorMessenger> & mockMessenger)318 int32_t GetExecutorAndMockStub(shared_ptr<Executor> &executor, shared_ptr<ExecutorRegisterCallback> &executorCallback,
319 shared_ptr<MockIAuthExecutorHdi> &mockExecutorHdi, std::shared_ptr<MockIExecutorMessenger> &mockMessenger)
320 {
321 static const uint16_t testHdiId = 1;
322 static std::vector<uint8_t> testPublicKey = {2, 3, 4, 5, 6};
323 static std::vector<uint64_t> testTemplateIdList = {7, 8, 9, 10, 11};
324
325 auto executorMgrWrapper = MakeShared<MockExecutorMgrWrapper>();
326 IF_FALSE_EXPECT_FAIL_AND_RETURN_VAL(executorMgrWrapper != nullptr, ResultCode::GENERAL_ERROR);
327 EXPECT_CALL(*executorMgrWrapper, Register(_, _))
328 .Times(Exactly(1))
329 .WillOnce([&executorCallback, &mockMessenger](const ExecutorInfo &info,
330 std::shared_ptr<ExecutorRegisterCallback> callback) {
331 EXPECT_NE(callback, nullptr);
332 executorCallback = callback;
333 auto messenger = MakeShared<MockIExecutorMessenger>();
334 EXPECT_NE(messenger, nullptr);
335 mockMessenger = messenger;
336 executorCallback->OnMessengerReady(messenger, testPublicKey, testTemplateIdList);
337 return 0;
338 });
339
340 mockExecutorHdi = MakeShared<MockIAuthExecutorHdi>();
341 IF_FALSE_EXPECT_FAIL_AND_RETURN_VAL(mockExecutorHdi != nullptr, ResultCode::GENERAL_ERROR);
342 EXPECT_CALL(*mockExecutorHdi, GetExecutorInfo(_)).Times(Exactly(2)).WillRepeatedly([](ExecutorInfo &info) {
343 return ResultCode::SUCCESS;
344 });
345 EXPECT_CALL(*mockExecutorHdi, OnRegisterFinish(_, _, _))
346 .Times(Exactly(1))
347 .WillRepeatedly([](const std::vector<uint64_t> &templateIdList, const std::vector<uint8_t> &frameworkPublicKey,
348 const std::vector<uint8_t> &extraInfo) {
349 EXPECT_EQ(templateIdList, testTemplateIdList);
350 EXPECT_EQ(frameworkPublicKey, testPublicKey);
351 return ResultCode::SUCCESS;
352 });
353
354 executor = MakeShared<Executor>(executorMgrWrapper, mockExecutorHdi, testHdiId);
355 IF_FALSE_EXPECT_FAIL_AND_RETURN_VAL(executor != nullptr, ResultCode::GENERAL_ERROR);
356 executor->Register();
357
358 IF_FALSE_EXPECT_FAIL_AND_RETURN_VAL(executorCallback != nullptr, ResultCode::GENERAL_ERROR);
359 IF_FALSE_EXPECT_FAIL_AND_RETURN_VAL(mockMessenger != nullptr, ResultCode::GENERAL_ERROR);
360 return ResultCode::SUCCESS;
361 }
362 } // namespace
363
364 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_CommonErrorTest_001, TestSize.Level0)
365 {
366 static const uint64_t testScheduleId = 456;
367
368 shared_ptr<Executor> executor;
369 shared_ptr<ExecutorRegisterCallback> executorCallback;
370 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
371 shared_ptr<MockIExecutorMessenger> mockMessenger;
372 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
373 ASSERT_EQ(ret, ResultCode::SUCCESS);
374
375 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
376 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
377
378 vector<uint8_t> uselessPublicKey;
379 Attributes attr;
380 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, attr);
381 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
382 }
383
384 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_CommonErrorTest_002, TestSize.Level0)
385 {
386 static const uint64_t testScheduleId = 456;
387
388 shared_ptr<Executor> executor;
389 shared_ptr<ExecutorRegisterCallback> executorCallback;
390 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
391 shared_ptr<MockIExecutorMessenger> mockMessenger;
392 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
393 ASSERT_EQ(ret, ResultCode::SUCCESS);
394
395 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
396 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
397
398 vector<uint8_t> uselessPublicKey;
399 auto commandAttrs = MakeShared<Attributes>();
400 ASSERT_NE(commandAttrs, nullptr);
401 // Error: auth schedule mode not set
402 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
403 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
404 }
405
406 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_CommonErrorTest_003, TestSize.Level0)
407 {
408 static const uint64_t testScheduleId = 456;
409 static const uint32_t invalidScheduleMode = 78;
410
411 shared_ptr<Executor> executor;
412 shared_ptr<ExecutorRegisterCallback> executorCallback;
413 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
414 shared_ptr<MockIExecutorMessenger> mockMessenger;
415 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
416 ASSERT_EQ(ret, ResultCode::SUCCESS);
417
418 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
419 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
420
421 vector<uint8_t> uselessPublicKey;
422 auto commandAttrs = MakeShared<Attributes>();
423 ASSERT_NE(commandAttrs, nullptr);
424 // Error: invalid auth schedule mode
425 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, invalidScheduleMode);
426 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
427 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
428 }
429
430 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_ExecutorDisconnectTest_001, TestSize.Level0)
431 {
432 static const int32_t testUserId = 100;
433 static const uint64_t testTokenId = 123;
434 static const uint64_t testScheduleId = 456;
435 static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
436 static const std::vector<uint8_t> testCallbackExtraInfo = {};
437
438 shared_ptr<Executor> executor;
439 shared_ptr<ExecutorRegisterCallback> executorCallback;
440 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
441 shared_ptr<MockIExecutorMessenger> mockMessenger;
442 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
443 ASSERT_EQ(ret, ResultCode::SUCCESS);
444
445 EXPECT_CALL(*mockExecutorHdi, Enroll(_, _, _))
446 .Times(Exactly(2))
447 .WillRepeatedly(
448 [](uint64_t scheduleId, const EnrollParam ¶m,
__anonbf3247131102(uint64_t scheduleId, const EnrollParam ¶m, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 449 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) { return ResultCode::SUCCESS; });
450
451 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
452 EXPECT_CALL(*mockMessenger, Finish(_, _, _))
453 .Times(Exactly(2))
454 .WillRepeatedly(
__anonbf3247131202(uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) 455 [](uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) {
456 EXPECT_EQ(scheduleId, testScheduleId);
457 EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
458 std::vector<uint8_t> extraInfo;
459 EXPECT_EQ(finalResult.GetUint8ArrayValue(Attributes::ATTR_RESULT, extraInfo), true);
460 EXPECT_EQ(extraInfo, testCallbackExtraInfo);
461 return ResultCode::SUCCESS;
462 });
463
464 vector<uint8_t> uselessPublicKey;
465 auto commandAttrs = MakeShared<Attributes>();
466 ASSERT_NE(commandAttrs, nullptr);
467 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, ENROLL);
468 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_ACCESS_TOKEN_ID, testTokenId);
469 commandAttrs->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
470 commandAttrs->SetUint32Value(Attributes::ATTR_USER_ID, testUserId);
471 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
472 ASSERT_EQ(ret, ResultCode::SUCCESS);
473 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
474 ASSERT_EQ(ret, ResultCode::SUCCESS);
475 // Error: Simulate hdi disconnect
476 executor->OnHdiDisconnect();
477 executor->OnHdiDisconnect();
478 executor->OnHdiDisconnect();
479 }
480
481 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_EnrollTest_001, TestSize.Level0)
482 {
483 static const int32_t testUserId = 100;
484 static const uint64_t testTokenId = 123;
485 static const uint64_t testScheduleId = 456;
486 static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
487
488 shared_ptr<Executor> executor;
489 shared_ptr<ExecutorRegisterCallback> executorCallback;
490 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
491 shared_ptr<MockIExecutorMessenger> mockMessenger;
492 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
493 ASSERT_EQ(ret, ResultCode::SUCCESS);
494
495 shared_ptr<UserAuth::IExecuteCallback> cmdCallback = nullptr;
496 EXPECT_CALL(*mockExecutorHdi, Enroll(_, _, _))
497 .Times(Exactly(1))
498 .WillOnce([&cmdCallback](uint64_t scheduleId, const EnrollParam ¶m,
__anonbf3247131302(uint64_t scheduleId, const EnrollParam ¶m, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 499 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
500 EXPECT_EQ(scheduleId, testScheduleId);
501 EXPECT_EQ(param.tokenId, testTokenId);
502 EXPECT_EQ(param.extraInfo, testExtraInfo);
503 cmdCallback = callbackObj;
504 return ResultCode::SUCCESS;
505 });
506
507 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
508 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
509
510 vector<uint8_t> uselessPublicKey;
511 auto commandAttrs = MakeShared<Attributes>();
512 ASSERT_NE(commandAttrs, nullptr);
513 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, ENROLL);
514 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_ACCESS_TOKEN_ID, testTokenId);
515 commandAttrs->SetUint8ArrayValue(Attributes::AttributeKey::ATTR_EXTRA_INFO, testExtraInfo);
516 commandAttrs->SetUint32Value(Attributes::ATTR_USER_ID, testUserId);
517 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
518 ASSERT_NE(cmdCallback, nullptr);
519 ASSERT_EQ(ret, ResultCode::SUCCESS);
520 }
521
522 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_EnrollTest_002, TestSize.Level0)
523 {
524 static const uint64_t testScheduleId = 456;
525
526 shared_ptr<Executor> executor;
527 shared_ptr<ExecutorRegisterCallback> executorCallback;
528 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
529 shared_ptr<MockIExecutorMessenger> mockMessenger;
530 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
531 ASSERT_EQ(ret, ResultCode::SUCCESS);
532
533 EXPECT_CALL(*mockExecutorHdi, Enroll(_, _, _)).Times(Exactly(0));
534
535 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
536 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
537
538 vector<uint8_t> uselessPublicKey;
539 auto commandAttrs = MakeShared<Attributes>();
540 ASSERT_NE(commandAttrs, nullptr);
541 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, ENROLL);
542 // Error: missing Attributes::AttributeKey::ATTR_CALLER_UID
543 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
544 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
545 }
546
547 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_EnrollTest_003, TestSize.Level0)
548 {
549 static const uint64_t testCallUid = 123;
550 static const uint64_t testScheduleId = 456;
551
552 shared_ptr<Executor> executor;
553 shared_ptr<ExecutorRegisterCallback> executorCallback;
554 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
555 shared_ptr<MockIExecutorMessenger> mockMessenger;
556 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
557 ASSERT_EQ(ret, ResultCode::SUCCESS);
558
559 EXPECT_CALL(*mockExecutorHdi, Enroll(_, _, _)).Times(Exactly(0));
560
561 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
562 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
563
564 vector<uint8_t> uselessPublicKey;
565 auto commandAttrs = MakeShared<Attributes>();
566 ASSERT_NE(commandAttrs, nullptr);
567 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, ENROLL);
568 commandAttrs->SetUint64Value(Attributes::AttributeKey::ATTR_CALLER_UID, testCallUid);
569 // Error: Executor is disconnected
570 executor->OnHdiDisconnect();
571 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
572 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
573 }
574
575 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_AuthTest_001, TestSize.Level0)
576 {
577 static const uint64_t testTokenId = 123;
578 static const uint64_t testScheduleId = 456;
579 static const std::vector<uint64_t> testTemplateIdList = {7, 8, 9};
580 static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
581 static const bool endAfterFirstFail = true;
582 static int32_t authIntent = 1;
583 static int32_t testUserId = 100;
584
585 shared_ptr<Executor> executor;
586 shared_ptr<ExecutorRegisterCallback> executorCallback;
587 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
588 shared_ptr<MockIExecutorMessenger> mockMessenger;
589 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
590 ASSERT_EQ(ret, ResultCode::SUCCESS);
591
592 shared_ptr<UserAuth::IExecuteCallback> cmdCallback = nullptr;
593 EXPECT_CALL(*mockExecutorHdi, Authenticate(_, _, _))
594 .Times(Exactly(1))
595 .WillOnce(
596 [&cmdCallback](uint64_t scheduleId, const AuthenticateParam ¶m,
__anonbf3247131402(uint64_t scheduleId, const AuthenticateParam ¶m, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 597 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
598 EXPECT_EQ(scheduleId, testScheduleId);
599 EXPECT_EQ(param.tokenId, testTokenId);
600 EXPECT_EQ(param.templateIdList, testTemplateIdList);
601 EXPECT_EQ(param.extraInfo, testExtraInfo);
602 EXPECT_EQ(param.endAfterFirstFail, endAfterFirstFail);
603 EXPECT_EQ(param.authIntent, authIntent);
604 cmdCallback = callbackObj;
605 return ResultCode::SUCCESS;
606 });
607
608 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
609 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
610
611 vector<uint8_t> uselessPublicKey;
612 auto commandAttrs = MakeShared<Attributes>();
613 ASSERT_NE(commandAttrs, nullptr);
614 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, AUTH);
615 commandAttrs->SetUint64ArrayValue(Attributes::AttributeKey::ATTR_TEMPLATE_ID_LIST, testTemplateIdList);
616 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_ACCESS_TOKEN_ID, testTokenId);
617 commandAttrs->SetUint32Value(Attributes::ATTR_USER_ID, testUserId);
618 commandAttrs->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
619 commandAttrs->SetBoolValue(Attributes::ATTR_END_AFTER_FIRST_FAIL, endAfterFirstFail);
620 commandAttrs->SetInt32Value(Attributes::ATTR_AUTH_INTENTION, authIntent);
621 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
622 ASSERT_NE(cmdCallback, nullptr);
623 ASSERT_EQ(ret, ResultCode::SUCCESS);
624 }
625
626 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_AuthTest_002, TestSize.Level0)
627 {
628 static const uint64_t testScheduleId = 456;
629
630 shared_ptr<Executor> executor;
631 shared_ptr<ExecutorRegisterCallback> executorCallback;
632 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
633 shared_ptr<MockIExecutorMessenger> mockMessenger;
634 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
635 ASSERT_EQ(ret, ResultCode::SUCCESS);
636
637 EXPECT_CALL(*mockExecutorHdi, Authenticate(_, _, _)).Times(Exactly(0));
638
639 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
640 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
641
642 vector<uint8_t> uselessPublicKey;
643 auto commandAttrs = MakeShared<Attributes>();
644 ASSERT_NE(commandAttrs, nullptr);
645 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, AUTH);
646 // Error: missing Attributes::AttributeKey::ATTR_TEMPLATE_ID_LIST
647 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
648 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
649 }
650
651 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_AuthTest_003, TestSize.Level0)
652 {
653 static const uint64_t testScheduleId = 456;
654 static const std::vector<uint64_t> testTemplateIdList = {7, 8, 9};
655
656 shared_ptr<Executor> executor;
657 shared_ptr<ExecutorRegisterCallback> executorCallback;
658 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
659 shared_ptr<MockIExecutorMessenger> mockMessenger;
660 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
661 ASSERT_EQ(ret, ResultCode::SUCCESS);
662
663 EXPECT_CALL(*mockExecutorHdi, Authenticate(_, _, _)).Times(Exactly(0));
664
665 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
666 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
667
668 vector<uint8_t> uselessPublicKey;
669 auto commandAttrs = MakeShared<Attributes>();
670 ASSERT_NE(commandAttrs, nullptr);
671 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, AUTH);
672 commandAttrs->SetUint64ArrayValue(Attributes::AttributeKey::ATTR_TEMPLATE_ID_LIST, testTemplateIdList);
673 // Error: missing Attributes::AttributeKey::ATTR_CALLER_UID
674 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
675 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
676 }
677
678 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_AuthTest_004, TestSize.Level0)
679 {
680 static const uint64_t testCallUid = 123;
681 static const uint64_t testScheduleId = 456;
682 static const std::vector<uint64_t> testTemplateIdList = {7, 8, 9};
683
684 shared_ptr<Executor> executor;
685 shared_ptr<ExecutorRegisterCallback> executorCallback;
686 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
687 shared_ptr<MockIExecutorMessenger> mockMessenger;
688 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
689 ASSERT_EQ(ret, ResultCode::SUCCESS);
690
691 EXPECT_CALL(*mockExecutorHdi, Authenticate(_, _, _)).Times(Exactly(0));
692
693 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
694 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
695
696 vector<uint8_t> uselessPublicKey;
697 auto commandAttrs = MakeShared<Attributes>();
698 ASSERT_NE(commandAttrs, nullptr);
699 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, AUTH);
700 commandAttrs->SetUint64ArrayValue(Attributes::AttributeKey::ATTR_TEMPLATE_ID_LIST, testTemplateIdList);
701 commandAttrs->SetUint64Value(Attributes::AttributeKey::ATTR_CALLER_UID, testCallUid);
702 // Error: Executor is disconnected
703 executor->OnHdiDisconnect();
704 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
705 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
706 }
707
708 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_IdentifyTest_001, TestSize.Level0)
709 {
710 static const uint64_t testTokenId = 123;
711 static const uint64_t testScheduleId = 456;
712 static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
713
714 shared_ptr<Executor> executor;
715 shared_ptr<ExecutorRegisterCallback> executorCallback;
716 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
717 shared_ptr<MockIExecutorMessenger> mockMessenger;
718 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
719 ASSERT_EQ(ret, ResultCode::SUCCESS);
720
721 shared_ptr<UserAuth::IExecuteCallback> cmdCallback = nullptr;
722 EXPECT_CALL(*mockExecutorHdi, Identify(_, _, _))
723 .Times(Exactly(1))
724 .WillOnce([&cmdCallback](uint64_t scheduleId, const IdentifyParam ¶m,
__anonbf3247131502(uint64_t scheduleId, const IdentifyParam ¶m, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 725 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
726 EXPECT_EQ(scheduleId, testScheduleId);
727 EXPECT_EQ(param.tokenId, testTokenId);
728 EXPECT_EQ(param.extraInfo, testExtraInfo);
729 cmdCallback = callbackObj;
730 return ResultCode::SUCCESS;
731 });
732
733 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
734 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
735
736 vector<uint8_t> uselessPublicKey;
737 auto commandAttrs = MakeShared<Attributes>();
738 ASSERT_NE(commandAttrs, nullptr);
739 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, IDENTIFY);
740 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_ACCESS_TOKEN_ID, testTokenId);
741 commandAttrs->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
742 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
743 ASSERT_NE(cmdCallback, nullptr);
744 ASSERT_EQ(ret, ResultCode::SUCCESS);
745 }
746
747 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_IdentifyTest_002, TestSize.Level0)
748 {
749 static const uint64_t testScheduleId = 456;
750
751 shared_ptr<Executor> executor;
752 shared_ptr<ExecutorRegisterCallback> executorCallback;
753 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
754 shared_ptr<MockIExecutorMessenger> mockMessenger;
755 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
756 ASSERT_EQ(ret, ResultCode::SUCCESS);
757
758 EXPECT_CALL(*mockExecutorHdi, Identify(_, _, _)).Times(Exactly(0));
759
760 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
761 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
762
763 vector<uint8_t> uselessPublicKey;
764 auto commandAttrs = MakeShared<Attributes>();
765 ASSERT_NE(commandAttrs, nullptr);
766 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, IDENTIFY);
767 // Error: missing Attributes::AttributeKey::ATTR_CALLER_UID
768 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
769 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
770 }
771
772 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_IdentifyTest_003, TestSize.Level0)
773 {
774 static const uint64_t testCallUid = 123;
775 static const uint64_t testScheduleId = 456;
776
777 shared_ptr<Executor> executor;
778 shared_ptr<ExecutorRegisterCallback> executorCallback;
779 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
780 shared_ptr<MockIExecutorMessenger> mockMessenger;
781 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
782 ASSERT_EQ(ret, ResultCode::SUCCESS);
783
784 EXPECT_CALL(*mockExecutorHdi, Identify(_, _, _)).Times(Exactly(0));
785
786 EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
787 EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
788
789 vector<uint8_t> uselessPublicKey;
790 auto commandAttrs = MakeShared<Attributes>();
791 ASSERT_NE(commandAttrs, nullptr);
792 commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, IDENTIFY);
793 commandAttrs->SetUint64Value(Attributes::AttributeKey::ATTR_CALLER_UID, testCallUid);
794 // Error: Executor is disconnected
795 executor->OnHdiDisconnect();
796 ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
797 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
798 }
799
800 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnEndExecute_Success, TestSize.Level0)
801 {
802 static const uint64_t testScheduleId = 456;
803
804 shared_ptr<Executor> executor;
805 shared_ptr<ExecutorRegisterCallback> executorCallback;
806 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
807 shared_ptr<MockIExecutorMessenger> mockMessenger;
808 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
809 ASSERT_EQ(ret, ResultCode::SUCCESS);
810
__anonbf3247131602(uint64_t scheduleId) 811 EXPECT_CALL(*mockExecutorHdi, Cancel(_)).Times(Exactly(1)).WillOnce([](uint64_t scheduleId) {
812 EXPECT_EQ(scheduleId, testScheduleId);
813 return ResultCode::SUCCESS;
814 });
815
816 auto commandAttrs = MakeShared<Attributes>();
817 ASSERT_NE(commandAttrs, nullptr);
818 ret = executorCallback->OnEndExecute(testScheduleId, *commandAttrs);
819 ASSERT_EQ(ret, ResultCode::SUCCESS);
820 }
821
822 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnEndExecute_ErrorTest_001, TestSize.Level0)
823 {
824 static const uint64_t testScheduleId = 456;
825
826 shared_ptr<Executor> executor;
827 shared_ptr<ExecutorRegisterCallback> executorCallback;
828 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
829 shared_ptr<MockIExecutorMessenger> mockMessenger;
830 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
831 ASSERT_EQ(ret, ResultCode::SUCCESS);
832
__anonbf3247131702(uint64_t scheduleId) 833 EXPECT_CALL(*mockExecutorHdi, Cancel(_)).Times(Exactly(1)).WillOnce([](uint64_t scheduleId) {
834 EXPECT_EQ(scheduleId, testScheduleId);
835 // Error: return error
836 return ResultCode::GENERAL_ERROR;
837 });
838
839 auto commandAttrs = MakeShared<Attributes>();
840 ASSERT_NE(commandAttrs, nullptr);
841 ret = executorCallback->OnEndExecute(testScheduleId, *commandAttrs);
842 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
843 }
844
845 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnEndExecute_ErrorTest_002, TestSize.Level0)
846 {
847 static const uint64_t testScheduleId = 456;
848
849 shared_ptr<Executor> executor;
850 shared_ptr<ExecutorRegisterCallback> executorCallback;
851 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
852 shared_ptr<MockIExecutorMessenger> mockMessenger;
853 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
854 ASSERT_EQ(ret, ResultCode::SUCCESS);
855
856 EXPECT_CALL(*mockExecutorHdi, Cancel(_)).Times(Exactly(0));
857
858 auto commandAttrs = MakeShared<Attributes>();
859 ASSERT_NE(commandAttrs, nullptr);
860 // Error: Executor is disconnected
861 executor->OnHdiDisconnect();
862 ret = executorCallback->OnEndExecute(testScheduleId, *commandAttrs);
863 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
864 }
865
866 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnEndExecute_ErrorTest_003, TestSize.Level0)
867 {
868 shared_ptr<Executor> executor;
869 shared_ptr<ExecutorRegisterCallback> executorCallback;
870 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
871 shared_ptr<MockIExecutorMessenger> mockMessenger;
872 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
873 ASSERT_EQ(ret, ResultCode::SUCCESS);
874 }
875
876 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_001, TestSize.Level0)
877 {
878 static const vector<uint64_t> testTemplateIds = { 1, 2, 3 };
879 static const vector<uint32_t> testKeys = { 100021, 100010, 100009, 100035, 100036 };
880 static const int32_t testFreezingTime = 456;
881 static const int32_t testRemainTimes = 789;
882 static const int32_t testAuthSubType = 101112;
883 string testEnrollmentProgress = "abc";
884 string testSensorInfo = "efg";
885
886 shared_ptr<Executor> executor;
887 shared_ptr<ExecutorRegisterCallback> executorCallback;
888 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
889 shared_ptr<MockIExecutorMessenger> mockMessenger;
890 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
891 ASSERT_EQ(ret, ResultCode::SUCCESS);
892
893 EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _))
894 .Times(Exactly(1))
895 .WillOnce([testEnrollmentProgress, testSensorInfo](const std::vector<uint64_t> &templateIdList,
__anonbf3247131802(const std::vector<uint64_t> &templateIdList, const std::vector<Attributes::AttributeKey> &keys, Property &property) 896 const std::vector<Attributes::AttributeKey> &keys, Property &property) {
897 EXPECT_EQ(templateIdList, testTemplateIds);
898 property.lockoutDuration = testFreezingTime;
899 property.remainAttempts = testRemainTimes;
900 property.authSubType = testAuthSubType;
901 property.enrollmentProgress = testEnrollmentProgress;
902 property.sensorInfo = testSensorInfo;
903 return ResultCode::SUCCESS;
904 });
905
906 auto conditions = MakeShared<Attributes>();
907 ASSERT_NE(conditions, nullptr);
908 conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
909 conditions->SetUint64ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, testTemplateIds);
910 conditions->SetUint32ArrayValue(Attributes::ATTR_KEY_LIST, testKeys);
911 auto values = MakeShared<Attributes>();
912 ASSERT_NE(values, nullptr);
913 ret = executorCallback->OnGetProperty(*conditions, *values);
914 ASSERT_EQ(ret, ResultCode::SUCCESS);
915 int32_t pinAuthSubType;
916 ASSERT_EQ(values->GetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, pinAuthSubType), true);
917 ASSERT_EQ(pinAuthSubType, testAuthSubType);
918 int32_t freezingTime;
919 ASSERT_EQ(values->GetInt32Value(Attributes::ATTR_FREEZING_TIME, freezingTime), true);
920 ASSERT_EQ(freezingTime, testFreezingTime);
921 int32_t remainTimes;
922 ASSERT_EQ(values->GetInt32Value(Attributes::ATTR_REMAIN_TIMES, remainTimes), true);
923 ASSERT_EQ(remainTimes, testRemainTimes);
924 string sensorInfo = "efg";
925 ASSERT_EQ(values->GetStringValue(Attributes::ATTR_SENSOR_INFO, sensorInfo), true);
926 ASSERT_EQ(sensorInfo, testSensorInfo);
927 }
928
929 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_002, TestSize.Level0)
930 {
931 static const uint64_t testTemplateId = 123;
932
933 shared_ptr<Executor> executor;
934 shared_ptr<ExecutorRegisterCallback> executorCallback;
935 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
936 shared_ptr<MockIExecutorMessenger> mockMessenger;
937 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
938 ASSERT_EQ(ret, ResultCode::SUCCESS);
939
940 EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
941
942 auto conditions = MakeShared<Attributes>();
943 ASSERT_NE(conditions, nullptr);
944 // Error: missing ATTR_PROPERTY_MODE
945 conditions->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
946 auto values = MakeShared<Attributes>();
947 ASSERT_NE(values, nullptr);
948 ret = executorCallback->OnGetProperty(*conditions, *values);
949 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
950 }
951
952 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_003, TestSize.Level0)
953 {
954 shared_ptr<Executor> executor;
955 shared_ptr<ExecutorRegisterCallback> executorCallback;
956 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
957 shared_ptr<MockIExecutorMessenger> mockMessenger;
958 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
959 ASSERT_EQ(ret, ResultCode::SUCCESS);
960
961 EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
962
963 auto conditions = MakeShared<Attributes>();
964 ASSERT_NE(conditions, nullptr);
965 conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
966 // Error: missing ATTR_TEMPLATE_ID
967 auto values = MakeShared<Attributes>();
968 ASSERT_NE(values, nullptr);
969 ret = executorCallback->OnGetProperty(*conditions, *values);
970 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
971 }
972
973 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_004, TestSize.Level0)
974 {
975 shared_ptr<Executor> executor;
976 shared_ptr<ExecutorRegisterCallback> executorCallback;
977 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
978 shared_ptr<MockIExecutorMessenger> mockMessenger;
979 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
980 ASSERT_EQ(ret, ResultCode::SUCCESS);
981
982 EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
983
984 auto conditions = MakeShared<Attributes>();
985 ASSERT_NE(conditions, nullptr);
986 conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
987 // Error: missing ATTR_TEMPLATE_ID
988 auto values = MakeShared<Attributes>();
989 ASSERT_NE(values, nullptr);
990 ret = executorCallback->OnGetProperty(*conditions, *values);
991 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
992 }
993
994 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_005, TestSize.Level0)
995 {
996 static const uint64_t testTemplateId = 123;
997
998 shared_ptr<Executor> executor;
999 shared_ptr<ExecutorRegisterCallback> executorCallback;
1000 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1001 shared_ptr<MockIExecutorMessenger> mockMessenger;
1002 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1003 ASSERT_EQ(ret, ResultCode::SUCCESS);
1004
1005 EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
1006
1007 auto conditions = MakeShared<Attributes>();
1008 ASSERT_NE(conditions, nullptr);
1009 // Error: invalid ATTR_PROPERTY_MODE
1010 conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET + 1);
1011 conditions->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1012 auto values = MakeShared<Attributes>();
1013 ASSERT_NE(values, nullptr);
1014 ret = executorCallback->OnGetProperty(*conditions, *values);
1015 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1016 // Error: invalid ATTR_PROPERTY_MODE
1017 conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET - 1);
1018 conditions->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1019 ret = executorCallback->OnGetProperty(*conditions, *values);
1020 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1021 }
1022
1023 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_006, TestSize.Level0)
1024 {
1025 shared_ptr<Executor> executor;
1026 shared_ptr<ExecutorRegisterCallback> executorCallback;
1027 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1028 shared_ptr<MockIExecutorMessenger> mockMessenger;
1029 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1030 ASSERT_EQ(ret, ResultCode::SUCCESS);
1031
1032 EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
1033
1034 // Error: conditions is nullptr
1035 auto values = MakeShared<Attributes>();
1036 ASSERT_NE(values, nullptr);
1037 ret = executorCallback->OnGetProperty(*values, *values);
1038 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1039 }
1040
1041 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_007, TestSize.Level0)
1042 {
1043 shared_ptr<Executor> executor;
1044 shared_ptr<ExecutorRegisterCallback> executorCallback;
1045 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1046 shared_ptr<MockIExecutorMessenger> mockMessenger;
1047 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1048 ASSERT_EQ(ret, ResultCode::SUCCESS);
1049
1050 EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
1051
1052 auto conditions = MakeShared<Attributes>();
1053 ASSERT_NE(conditions, nullptr);
1054 conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
1055
1056 Attributes attr;
1057 ret = executorCallback->OnGetProperty(*conditions, attr);
1058 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1059 }
1060
1061 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_008, TestSize.Level0)
1062 {
1063 static const vector<uint64_t> testTemplateIds = { 1, 2, 3 };
1064 static const vector<uint32_t> testKeys = { 100021, 100010, 100009, 100035, 100036 };
1065
1066 shared_ptr<Executor> executor;
1067 shared_ptr<ExecutorRegisterCallback> executorCallback;
1068 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1069 shared_ptr<MockIExecutorMessenger> mockMessenger;
1070 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1071 ASSERT_EQ(ret, ResultCode::SUCCESS);
1072
1073 EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _))
1074 .Times(Exactly(1))
1075 .WillOnce([](const std::vector<uint64_t> &templateIdList,
__anonbf3247131902(const std::vector<uint64_t> &templateIdList, const std::vector<Attributes::AttributeKey> &keys, Property &property) 1076 const std::vector<Attributes::AttributeKey> &keys, Property &property) {
1077 EXPECT_EQ(templateIdList, testTemplateIds);
1078 return ResultCode::GENERAL_ERROR;
1079 });
1080
1081 auto conditions = MakeShared<Attributes>();
1082 ASSERT_NE(conditions, nullptr);
1083 conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
1084 conditions->SetUint64ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, testTemplateIds);
1085 conditions->SetUint32ArrayValue(Attributes::ATTR_KEY_LIST, testKeys);
1086 auto values = MakeShared<Attributes>();
1087 ASSERT_NE(values, nullptr);
1088 ret = executorCallback->OnGetProperty(*conditions, *values);
1089 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1090 }
1091
1092 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_General, TestSize.Level0)
1093 {
1094 shared_ptr<Executor> executor;
1095 shared_ptr<ExecutorRegisterCallback> executorCallback;
1096 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1097 shared_ptr<MockIExecutorMessenger> mockMessenger;
1098 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1099 ASSERT_EQ(ret, ResultCode::SUCCESS);
1100 Attributes attr;
1101 ret = executorCallback->OnSetProperty(attr);
1102 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1103 }
1104
1105 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_DeleteTemplateTest_001, TestSize.Level0)
1106 {
1107 static const uint64_t testTemplateId = 123;
1108
1109 shared_ptr<Executor> executor;
1110 shared_ptr<ExecutorRegisterCallback> executorCallback;
1111 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1112 shared_ptr<MockIExecutorMessenger> mockMessenger;
1113 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1114 ASSERT_EQ(ret, ResultCode::SUCCESS);
1115
1116 EXPECT_CALL(*mockExecutorHdi, Delete(_))
1117 .Times(Exactly(1))
__anonbf3247131a02(const std::vector<uint64_t> &templateIdList) 1118 .WillOnce([](const std::vector<uint64_t> &templateIdList) {
1119 EXPECT_EQ(templateIdList.size(), static_cast<size_t>(1));
1120 EXPECT_EQ(templateIdList[0], testTemplateId);
1121 return ResultCode::SUCCESS;
1122 });
1123
1124 auto property = MakeShared<Attributes>();
1125 ASSERT_NE(property, nullptr);
1126 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_DEL);
1127 property->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1128 ret = executorCallback->OnSetProperty(*property);
1129 ASSERT_EQ(ret, ResultCode::SUCCESS);
1130 }
1131
1132 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_DeleteTemplateTest_002, TestSize.Level0)
1133 {
1134 shared_ptr<Executor> executor;
1135 shared_ptr<ExecutorRegisterCallback> executorCallback;
1136 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1137 shared_ptr<MockIExecutorMessenger> mockMessenger;
1138 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1139 ASSERT_EQ(ret, ResultCode::SUCCESS);
1140
1141 EXPECT_CALL(*mockExecutorHdi, Delete(_)).Times(Exactly(0));
1142
1143 auto property = MakeShared<Attributes>();
1144 ASSERT_NE(property, nullptr);
1145 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_DEL);
1146 // Error: missing template id
1147 ret = executorCallback->OnSetProperty(*property);
1148 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1149 }
1150
1151 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_DeleteTemplateTest_003, TestSize.Level0)
1152 {
1153 static const uint64_t testTemplateId = 123;
1154
1155 shared_ptr<Executor> executor;
1156 shared_ptr<ExecutorRegisterCallback> executorCallback;
1157 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1158 shared_ptr<MockIExecutorMessenger> mockMessenger;
1159 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1160 ASSERT_EQ(ret, ResultCode::SUCCESS);
1161
1162 EXPECT_CALL(*mockExecutorHdi, Delete(_)).Times(Exactly(0));
1163
1164 auto property = MakeShared<Attributes>();
1165 ASSERT_NE(property, nullptr);
1166 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_DEL);
1167 property->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1168 // Error: Executor is disconnected
1169 executor->OnHdiDisconnect();
1170 ret = executorCallback->OnSetProperty(*property);
1171 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1172 }
1173
1174 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_DeleteTemplateTest_004, TestSize.Level0)
1175 {
1176 static const uint64_t testTemplateId = 123;
1177
1178 shared_ptr<Executor> executor;
1179 shared_ptr<ExecutorRegisterCallback> executorCallback;
1180 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1181 shared_ptr<MockIExecutorMessenger> mockMessenger;
1182 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1183 ASSERT_EQ(ret, ResultCode::SUCCESS);
1184
1185 EXPECT_CALL(*mockExecutorHdi, Delete(_))
1186 .Times(Exactly(1))
__anonbf3247131b02(const std::vector<uint64_t> &templateIdList) 1187 .WillOnce([](const std::vector<uint64_t> &templateIdList) {
1188 EXPECT_EQ(templateIdList.size(), static_cast<size_t>(1));
1189 EXPECT_EQ(templateIdList[0], testTemplateId);
1190 // Error: return error
1191 return ResultCode::GENERAL_ERROR;
1192 });
1193
1194 auto property = MakeShared<Attributes>();
1195 ASSERT_NE(property, nullptr);
1196 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_DEL);
1197 property->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1198 ret = executorCallback->OnSetProperty(*property);
1199 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1200 }
1201
1202 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_001, TestSize.Level0)
1203 {
1204 static const int32_t testCommandId = 123;
1205 static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
1206 static std::thread t;
1207 static std::string threadName = "executor_unit_test";
1208
1209 shared_ptr<Executor> executor;
1210 shared_ptr<ExecutorRegisterCallback> executorCallback;
1211 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1212 shared_ptr<MockIExecutorMessenger> mockMessenger;
1213 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1214 ASSERT_EQ(ret, ResultCode::SUCCESS);
1215
1216 EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _))
1217 .Times(Exactly(2))
1218 .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anonbf3247131c02(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1219 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1220 EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1221 EXPECT_EQ(extraInfo, testExtraInfo);
1222 callbackObj->OnResult(ResultCode::SUCCESS, {});
1223 return ResultCode::SUCCESS;
1224 })
1225 .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anonbf3247131d02(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1226 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1227 EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1228 EXPECT_EQ(extraInfo, testExtraInfo);
1229 t = std::thread([callbackObj] {
1230 pthread_setname_np(pthread_self(), threadName.c_str());
1231 const int32_t sleepTime = 500;
1232 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
1233 callbackObj->OnResult(ResultCode::SUCCESS, {});
1234 });
1235 return ResultCode::SUCCESS;
1236 });
1237
1238 auto property = MakeShared<Attributes>();
1239 ASSERT_NE(property, nullptr);
1240 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1241 property->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
1242 ret = executorCallback->OnSetProperty(*property);
1243 ASSERT_EQ(ret, ResultCode::SUCCESS);
1244 ret = executorCallback->OnSetProperty(*property);
1245 ASSERT_EQ(ret, ResultCode::SUCCESS);
1246 t.join();
1247 }
1248
1249 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_002, TestSize.Level0)
1250 {
1251 static const int32_t testCommandId = 123;
1252 static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
1253
1254 shared_ptr<Executor> executor;
1255 shared_ptr<ExecutorRegisterCallback> executorCallback;
1256 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1257 shared_ptr<MockIExecutorMessenger> mockMessenger;
1258 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1259 ASSERT_EQ(ret, ResultCode::SUCCESS);
1260
1261 EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _))
1262 .Times(Exactly(1))
1263 .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anonbf3247131f02(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1264 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1265 EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1266 EXPECT_EQ(extraInfo, testExtraInfo);
1267 // Error: OnResult not invoked
1268 return ResultCode::SUCCESS;
1269 });
1270
1271 auto property = MakeShared<Attributes>();
1272 ASSERT_NE(property, nullptr);
1273 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1274 property->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
1275 ret = executorCallback->OnSetProperty(*property);
1276 ASSERT_EQ(ret, ResultCode::TIMEOUT);
1277 }
1278
1279 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_003, TestSize.Level0)
1280 {
1281 static const int32_t testCommandId = 123;
1282 static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
1283
1284 shared_ptr<Executor> executor;
1285 shared_ptr<ExecutorRegisterCallback> executorCallback;
1286 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1287 shared_ptr<MockIExecutorMessenger> mockMessenger;
1288 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1289 ASSERT_EQ(ret, ResultCode::SUCCESS);
1290
1291 EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _))
1292 .Times(Exactly(1))
1293 .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anonbf3247132002(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1294 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1295 EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1296 EXPECT_EQ(extraInfo, testExtraInfo);
1297 // Error: OnResult NOT_SUPPORT
1298 callbackObj->OnResult(ResultCode::TYPE_NOT_SUPPORT, {});
1299 return ResultCode::SUCCESS;
1300 });
1301
1302 auto property = MakeShared<Attributes>();
1303 ASSERT_NE(property, nullptr);
1304 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1305 property->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
1306 ret = executorCallback->OnSetProperty(*property);
1307 ASSERT_EQ(ret, ResultCode::TYPE_NOT_SUPPORT);
1308 }
1309
1310 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_004, TestSize.Level0)
1311 {
1312 static const int32_t testCommandId = 123;
1313 static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
1314
1315 shared_ptr<Executor> executor;
1316 shared_ptr<ExecutorRegisterCallback> executorCallback;
1317 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1318 shared_ptr<MockIExecutorMessenger> mockMessenger;
1319 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1320 ASSERT_EQ(ret, ResultCode::SUCCESS);
1321
1322 EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _))
1323 .Times(Exactly(1))
1324 .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anonbf3247132102(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1325 const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1326 EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1327 EXPECT_EQ(extraInfo, testExtraInfo);
1328 // Error: return error
1329 return ResultCode::TYPE_NOT_SUPPORT;
1330 });
1331
1332 auto property = MakeShared<Attributes>();
1333 ASSERT_NE(property, nullptr);
1334 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1335 property->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
1336 ret = executorCallback->OnSetProperty(*property);
1337 ASSERT_EQ(ret, ResultCode::TYPE_NOT_SUPPORT);
1338 }
1339
1340 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_005, TestSize.Level0)
1341 {
1342 static const int32_t testCommandId = 123;
1343
1344 shared_ptr<Executor> executor;
1345 shared_ptr<ExecutorRegisterCallback> executorCallback;
1346 shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1347 shared_ptr<MockIExecutorMessenger> mockMessenger;
1348 int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1349 ASSERT_EQ(ret, ResultCode::SUCCESS);
1350
1351 EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _)).Times(Exactly(0));
1352
1353 auto property = MakeShared<Attributes>();
1354 ASSERT_NE(property, nullptr);
1355 property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1356 // Error: ATTR_EXTRA_INFO not set
1357 ret = executorCallback->OnSetProperty(*property);
1358 ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1359 }
1360 } // namespace UserAuth
1361 } // namespace UserIam
1362 } // namespace OHOS
1363