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))
__anon0f00ab690102(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);
__anon0f00ab690202(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->OnHdiConnect();
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))
__anon0f00ab690302(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);
__anon0f00ab690402(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->OnFrameworkReady();
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->OnFrameworkReady();
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);
__anon0f00ab690502(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->OnFrameworkReady();
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);
__anon0f00ab690602(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->OnFrameworkReady();
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);
__anon0f00ab690702(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);
__anon0f00ab690802(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);
__anon0f00ab690902(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);
__anon0f00ab690a02(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);
__anon0f00ab690b02(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);
__anon0f00ab690c02(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->OnFrameworkReady();
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 &param,
__anon0f00ab691102(uint64_t scheduleId, const EnrollParam &param, 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(
__anon0f00ab691202(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 &param,
__anon0f00ab691302(uint64_t scheduleId, const EnrollParam &param, 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 &param,
__anon0f00ab691402(uint64_t scheduleId, const AuthenticateParam &param, 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                 cmdCallback = callbackObj;
604                 return ResultCode::SUCCESS;
605             });
606 
607     EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
608     EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
609 
610     vector<uint8_t> uselessPublicKey;
611     auto commandAttrs = MakeShared<Attributes>();
612     ASSERT_NE(commandAttrs, nullptr);
613     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, AUTH);
614     commandAttrs->SetUint64ArrayValue(Attributes::AttributeKey::ATTR_TEMPLATE_ID_LIST, testTemplateIdList);
615     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_ACCESS_TOKEN_ID, testTokenId);
616     commandAttrs->SetUint32Value(Attributes::ATTR_USER_ID, testUserId);
617     commandAttrs->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
618     commandAttrs->SetBoolValue(Attributes::ATTR_END_AFTER_FIRST_FAIL, endAfterFirstFail);
619     commandAttrs->SetInt32Value(Attributes::ATTR_AUTH_INTENTION, authIntent);
620     ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
621     ASSERT_NE(cmdCallback, nullptr);
622     ASSERT_EQ(ret, ResultCode::SUCCESS);
623 }
624 
625 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_AuthTest_002, TestSize.Level0)
626 {
627     static const uint64_t testScheduleId = 456;
628 
629     shared_ptr<Executor> executor;
630     shared_ptr<ExecutorRegisterCallback> executorCallback;
631     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
632     shared_ptr<MockIExecutorMessenger> mockMessenger;
633     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
634     ASSERT_EQ(ret, ResultCode::SUCCESS);
635 
636     EXPECT_CALL(*mockExecutorHdi, Authenticate(_, _, _)).Times(Exactly(0));
637 
638     EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
639     EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
640 
641     vector<uint8_t> uselessPublicKey;
642     auto commandAttrs = MakeShared<Attributes>();
643     ASSERT_NE(commandAttrs, nullptr);
644     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, AUTH);
645     // Error: missing Attributes::AttributeKey::ATTR_TEMPLATE_ID_LIST
646     ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
647     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
648 }
649 
650 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_AuthTest_003, TestSize.Level0)
651 {
652     static const uint64_t testScheduleId = 456;
653     static const std::vector<uint64_t> testTemplateIdList = {7, 8, 9};
654 
655     shared_ptr<Executor> executor;
656     shared_ptr<ExecutorRegisterCallback> executorCallback;
657     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
658     shared_ptr<MockIExecutorMessenger> mockMessenger;
659     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
660     ASSERT_EQ(ret, ResultCode::SUCCESS);
661 
662     EXPECT_CALL(*mockExecutorHdi, Authenticate(_, _, _)).Times(Exactly(0));
663 
664     EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
665     EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
666 
667     vector<uint8_t> uselessPublicKey;
668     auto commandAttrs = MakeShared<Attributes>();
669     ASSERT_NE(commandAttrs, nullptr);
670     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, AUTH);
671     commandAttrs->SetUint64ArrayValue(Attributes::AttributeKey::ATTR_TEMPLATE_ID_LIST, testTemplateIdList);
672     // Error: missing Attributes::AttributeKey::ATTR_CALLER_UID
673     ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
674     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
675 }
676 
677 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_AuthTest_004, TestSize.Level0)
678 {
679     static const uint64_t testCallUid = 123;
680     static const uint64_t testScheduleId = 456;
681     static const std::vector<uint64_t> testTemplateIdList = {7, 8, 9};
682 
683     shared_ptr<Executor> executor;
684     shared_ptr<ExecutorRegisterCallback> executorCallback;
685     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
686     shared_ptr<MockIExecutorMessenger> mockMessenger;
687     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
688     ASSERT_EQ(ret, ResultCode::SUCCESS);
689 
690     EXPECT_CALL(*mockExecutorHdi, Authenticate(_, _, _)).Times(Exactly(0));
691 
692     EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
693     EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
694 
695     vector<uint8_t> uselessPublicKey;
696     auto commandAttrs = MakeShared<Attributes>();
697     ASSERT_NE(commandAttrs, nullptr);
698     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, AUTH);
699     commandAttrs->SetUint64ArrayValue(Attributes::AttributeKey::ATTR_TEMPLATE_ID_LIST, testTemplateIdList);
700     commandAttrs->SetUint64Value(Attributes::AttributeKey::ATTR_CALLER_UID, testCallUid);
701     // Error: Executor is disconnected
702     executor->OnHdiDisconnect();
703     ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
704     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
705 }
706 
707 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_IdentifyTest_001, TestSize.Level0)
708 {
709     static const uint64_t testTokenId = 123;
710     static const uint64_t testScheduleId = 456;
711     static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
712 
713     shared_ptr<Executor> executor;
714     shared_ptr<ExecutorRegisterCallback> executorCallback;
715     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
716     shared_ptr<MockIExecutorMessenger> mockMessenger;
717     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
718     ASSERT_EQ(ret, ResultCode::SUCCESS);
719 
720     shared_ptr<UserAuth::IExecuteCallback> cmdCallback = nullptr;
721     EXPECT_CALL(*mockExecutorHdi, Identify(_, _, _))
722         .Times(Exactly(1))
723         .WillOnce([&cmdCallback](uint64_t scheduleId, const IdentifyParam &param,
__anon0f00ab691502(uint64_t scheduleId, const IdentifyParam &param, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 724                       const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
725             EXPECT_EQ(scheduleId, testScheduleId);
726             EXPECT_EQ(param.tokenId, testTokenId);
727             EXPECT_EQ(param.extraInfo, testExtraInfo);
728             cmdCallback = callbackObj;
729             return ResultCode::SUCCESS;
730         });
731 
732     EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
733     EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
734 
735     vector<uint8_t> uselessPublicKey;
736     auto commandAttrs = MakeShared<Attributes>();
737     ASSERT_NE(commandAttrs, nullptr);
738     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, IDENTIFY);
739     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_ACCESS_TOKEN_ID, testTokenId);
740     commandAttrs->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
741     ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
742     ASSERT_NE(cmdCallback, nullptr);
743     ASSERT_EQ(ret, ResultCode::SUCCESS);
744 }
745 
746 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_IdentifyTest_002, TestSize.Level0)
747 {
748     static const uint64_t testScheduleId = 456;
749 
750     shared_ptr<Executor> executor;
751     shared_ptr<ExecutorRegisterCallback> executorCallback;
752     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
753     shared_ptr<MockIExecutorMessenger> mockMessenger;
754     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
755     ASSERT_EQ(ret, ResultCode::SUCCESS);
756 
757     EXPECT_CALL(*mockExecutorHdi, Identify(_, _, _)).Times(Exactly(0));
758 
759     EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
760     EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
761 
762     vector<uint8_t> uselessPublicKey;
763     auto commandAttrs = MakeShared<Attributes>();
764     ASSERT_NE(commandAttrs, nullptr);
765     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, IDENTIFY);
766     // Error: missing Attributes::AttributeKey::ATTR_CALLER_UID
767     ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
768     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
769 }
770 
771 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnBeginExecute_IdentifyTest_003, TestSize.Level0)
772 {
773     static const uint64_t testCallUid = 123;
774     static const uint64_t testScheduleId = 456;
775 
776     shared_ptr<Executor> executor;
777     shared_ptr<ExecutorRegisterCallback> executorCallback;
778     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
779     shared_ptr<MockIExecutorMessenger> mockMessenger;
780     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
781     ASSERT_EQ(ret, ResultCode::SUCCESS);
782 
783     EXPECT_CALL(*mockExecutorHdi, Identify(_, _, _)).Times(Exactly(0));
784 
785     EXPECT_CALL(*mockMessenger, SendData(_, _, _)).Times(Exactly(0));
786     EXPECT_CALL(*mockMessenger, Finish(_, _, _)).Times(Exactly(0));
787 
788     vector<uint8_t> uselessPublicKey;
789     auto commandAttrs = MakeShared<Attributes>();
790     ASSERT_NE(commandAttrs, nullptr);
791     commandAttrs->SetUint32Value(Attributes::AttributeKey::ATTR_SCHEDULE_MODE, IDENTIFY);
792     commandAttrs->SetUint64Value(Attributes::AttributeKey::ATTR_CALLER_UID, testCallUid);
793     // Error: Executor is disconnected
794     executor->OnHdiDisconnect();
795     ret = executorCallback->OnBeginExecute(testScheduleId, uselessPublicKey, *commandAttrs);
796     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
797 }
798 
799 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnEndExecute_Success, TestSize.Level0)
800 {
801     static const uint64_t testScheduleId = 456;
802 
803     shared_ptr<Executor> executor;
804     shared_ptr<ExecutorRegisterCallback> executorCallback;
805     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
806     shared_ptr<MockIExecutorMessenger> mockMessenger;
807     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
808     ASSERT_EQ(ret, ResultCode::SUCCESS);
809 
__anon0f00ab691602(uint64_t scheduleId) 810     EXPECT_CALL(*mockExecutorHdi, Cancel(_)).Times(Exactly(1)).WillOnce([](uint64_t scheduleId) {
811         EXPECT_EQ(scheduleId, testScheduleId);
812         return ResultCode::SUCCESS;
813     });
814 
815     auto commandAttrs = MakeShared<Attributes>();
816     ASSERT_NE(commandAttrs, nullptr);
817     ret = executorCallback->OnEndExecute(testScheduleId, *commandAttrs);
818     ASSERT_EQ(ret, ResultCode::SUCCESS);
819 }
820 
821 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnEndExecute_ErrorTest_001, TestSize.Level0)
822 {
823     static const uint64_t testScheduleId = 456;
824 
825     shared_ptr<Executor> executor;
826     shared_ptr<ExecutorRegisterCallback> executorCallback;
827     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
828     shared_ptr<MockIExecutorMessenger> mockMessenger;
829     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
830     ASSERT_EQ(ret, ResultCode::SUCCESS);
831 
__anon0f00ab691702(uint64_t scheduleId) 832     EXPECT_CALL(*mockExecutorHdi, Cancel(_)).Times(Exactly(1)).WillOnce([](uint64_t scheduleId) {
833         EXPECT_EQ(scheduleId, testScheduleId);
834         // Error: return error
835         return ResultCode::GENERAL_ERROR;
836     });
837 
838     auto commandAttrs = MakeShared<Attributes>();
839     ASSERT_NE(commandAttrs, nullptr);
840     ret = executorCallback->OnEndExecute(testScheduleId, *commandAttrs);
841     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
842 }
843 
844 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnEndExecute_ErrorTest_002, TestSize.Level0)
845 {
846     static const uint64_t testScheduleId = 456;
847 
848     shared_ptr<Executor> executor;
849     shared_ptr<ExecutorRegisterCallback> executorCallback;
850     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
851     shared_ptr<MockIExecutorMessenger> mockMessenger;
852     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
853     ASSERT_EQ(ret, ResultCode::SUCCESS);
854 
855     EXPECT_CALL(*mockExecutorHdi, Cancel(_)).Times(Exactly(0));
856 
857     auto commandAttrs = MakeShared<Attributes>();
858     ASSERT_NE(commandAttrs, nullptr);
859     // Error: Executor is disconnected
860     executor->OnHdiDisconnect();
861     ret = executorCallback->OnEndExecute(testScheduleId, *commandAttrs);
862     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
863 }
864 
865 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnEndExecute_ErrorTest_003, TestSize.Level0)
866 {
867     shared_ptr<Executor> executor;
868     shared_ptr<ExecutorRegisterCallback> executorCallback;
869     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
870     shared_ptr<MockIExecutorMessenger> mockMessenger;
871     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
872     ASSERT_EQ(ret, ResultCode::SUCCESS);
873 }
874 
875 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_001, TestSize.Level0)
876 {
877     static const vector<uint64_t> testTemplateIds = { 1, 2, 3 };
878     static const vector<uint32_t> testKeys = { 100021, 100010, 100009, 100035, 100036 };
879     static const int32_t testFreezingTime = 456;
880     static const int32_t testRemainTimes = 789;
881     static const int32_t testAuthSubType = 101112;
882     string testEnrollmentProgress = "abc";
883     string testSensorInfo = "efg";
884 
885     shared_ptr<Executor> executor;
886     shared_ptr<ExecutorRegisterCallback> executorCallback;
887     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
888     shared_ptr<MockIExecutorMessenger> mockMessenger;
889     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
890     ASSERT_EQ(ret, ResultCode::SUCCESS);
891 
892     EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _))
893         .Times(Exactly(1))
894         .WillOnce([testEnrollmentProgress, testSensorInfo](const std::vector<uint64_t> &templateIdList,
__anon0f00ab691802(const std::vector<uint64_t> &templateIdList, const std::vector<Attributes::AttributeKey> &keys, Property &property) 895             const std::vector<Attributes::AttributeKey> &keys, Property &property) {
896             EXPECT_EQ(templateIdList, testTemplateIds);
897             property.lockoutDuration = testFreezingTime;
898             property.remainAttempts = testRemainTimes;
899             property.authSubType = testAuthSubType;
900             property.enrollmentProgress = testEnrollmentProgress;
901             property.sensorInfo = testSensorInfo;
902             return ResultCode::SUCCESS;
903         });
904 
905     auto conditions = MakeShared<Attributes>();
906     ASSERT_NE(conditions, nullptr);
907     conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
908     conditions->SetUint64ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, testTemplateIds);
909     conditions->SetUint32ArrayValue(Attributes::ATTR_KEY_LIST, testKeys);
910     auto values = MakeShared<Attributes>();
911     ASSERT_NE(values, nullptr);
912     ret = executorCallback->OnGetProperty(*conditions, *values);
913     ASSERT_EQ(ret, ResultCode::SUCCESS);
914     int32_t pinAuthSubType;
915     ASSERT_EQ(values->GetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, pinAuthSubType), true);
916     ASSERT_EQ(pinAuthSubType, testAuthSubType);
917     int32_t freezingTime;
918     ASSERT_EQ(values->GetInt32Value(Attributes::ATTR_FREEZING_TIME, freezingTime), true);
919     ASSERT_EQ(freezingTime, testFreezingTime);
920     int32_t remainTimes;
921     ASSERT_EQ(values->GetInt32Value(Attributes::ATTR_REMAIN_TIMES, remainTimes), true);
922     ASSERT_EQ(remainTimes, testRemainTimes);
923     string sensorInfo = "efg";
924     ASSERT_EQ(values->GetStringValue(Attributes::ATTR_SENSOR_INFO, sensorInfo), true);
925     ASSERT_EQ(sensorInfo, testSensorInfo);
926 }
927 
928 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_002, TestSize.Level0)
929 {
930     static const uint64_t testTemplateId = 123;
931 
932     shared_ptr<Executor> executor;
933     shared_ptr<ExecutorRegisterCallback> executorCallback;
934     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
935     shared_ptr<MockIExecutorMessenger> mockMessenger;
936     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
937     ASSERT_EQ(ret, ResultCode::SUCCESS);
938 
939     EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
940 
941     auto conditions = MakeShared<Attributes>();
942     ASSERT_NE(conditions, nullptr);
943     // Error: missing ATTR_PROPERTY_MODE
944     conditions->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
945     auto values = MakeShared<Attributes>();
946     ASSERT_NE(values, nullptr);
947     ret = executorCallback->OnGetProperty(*conditions, *values);
948     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
949 }
950 
951 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_003, TestSize.Level0)
952 {
953     shared_ptr<Executor> executor;
954     shared_ptr<ExecutorRegisterCallback> executorCallback;
955     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
956     shared_ptr<MockIExecutorMessenger> mockMessenger;
957     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
958     ASSERT_EQ(ret, ResultCode::SUCCESS);
959 
960     EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
961 
962     auto conditions = MakeShared<Attributes>();
963     ASSERT_NE(conditions, nullptr);
964     conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
965     // Error: missing ATTR_TEMPLATE_ID
966     auto values = MakeShared<Attributes>();
967     ASSERT_NE(values, nullptr);
968     ret = executorCallback->OnGetProperty(*conditions, *values);
969     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
970 }
971 
972 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_004, TestSize.Level0)
973 {
974     shared_ptr<Executor> executor;
975     shared_ptr<ExecutorRegisterCallback> executorCallback;
976     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
977     shared_ptr<MockIExecutorMessenger> mockMessenger;
978     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
979     ASSERT_EQ(ret, ResultCode::SUCCESS);
980 
981     EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
982 
983     auto conditions = MakeShared<Attributes>();
984     ASSERT_NE(conditions, nullptr);
985     conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
986     // Error: missing ATTR_TEMPLATE_ID
987     auto values = MakeShared<Attributes>();
988     ASSERT_NE(values, nullptr);
989     ret = executorCallback->OnGetProperty(*conditions, *values);
990     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
991 }
992 
993 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_005, TestSize.Level0)
994 {
995     static const uint64_t testTemplateId = 123;
996 
997     shared_ptr<Executor> executor;
998     shared_ptr<ExecutorRegisterCallback> executorCallback;
999     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1000     shared_ptr<MockIExecutorMessenger> mockMessenger;
1001     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1002     ASSERT_EQ(ret, ResultCode::SUCCESS);
1003 
1004     EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
1005 
1006     auto conditions = MakeShared<Attributes>();
1007     ASSERT_NE(conditions, nullptr);
1008     // Error: invalid ATTR_PROPERTY_MODE
1009     conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET + 1);
1010     conditions->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1011     auto values = MakeShared<Attributes>();
1012     ASSERT_NE(values, nullptr);
1013     ret = executorCallback->OnGetProperty(*conditions, *values);
1014     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1015     // Error: invalid ATTR_PROPERTY_MODE
1016     conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET - 1);
1017     conditions->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1018     ret = executorCallback->OnGetProperty(*conditions, *values);
1019     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1020 }
1021 
1022 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_006, TestSize.Level0)
1023 {
1024     shared_ptr<Executor> executor;
1025     shared_ptr<ExecutorRegisterCallback> executorCallback;
1026     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1027     shared_ptr<MockIExecutorMessenger> mockMessenger;
1028     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1029     ASSERT_EQ(ret, ResultCode::SUCCESS);
1030 
1031     EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
1032 
1033     // Error: conditions is nullptr
1034     auto values = MakeShared<Attributes>();
1035     ASSERT_NE(values, nullptr);
1036     ret = executorCallback->OnGetProperty(*values, *values);
1037     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1038 }
1039 
1040 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_007, TestSize.Level0)
1041 {
1042     shared_ptr<Executor> executor;
1043     shared_ptr<ExecutorRegisterCallback> executorCallback;
1044     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1045     shared_ptr<MockIExecutorMessenger> mockMessenger;
1046     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1047     ASSERT_EQ(ret, ResultCode::SUCCESS);
1048 
1049     EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _)).Times(Exactly(0));
1050 
1051     auto conditions = MakeShared<Attributes>();
1052     ASSERT_NE(conditions, nullptr);
1053     conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
1054 
1055     Attributes attr;
1056     ret = executorCallback->OnGetProperty(*conditions, attr);
1057     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1058 }
1059 
1060 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnGetPropertyTest_008, TestSize.Level0)
1061 {
1062     static const vector<uint64_t> testTemplateIds = { 1, 2, 3 };
1063     static const vector<uint32_t> testKeys = { 100021, 100010, 100009, 100035, 100036 };
1064 
1065     shared_ptr<Executor> executor;
1066     shared_ptr<ExecutorRegisterCallback> executorCallback;
1067     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1068     shared_ptr<MockIExecutorMessenger> mockMessenger;
1069     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1070     ASSERT_EQ(ret, ResultCode::SUCCESS);
1071 
1072     EXPECT_CALL(*mockExecutorHdi, GetProperty(_, _, _))
1073         .Times(Exactly(1))
1074         .WillOnce([](const std::vector<uint64_t> &templateIdList,
__anon0f00ab691902(const std::vector<uint64_t> &templateIdList, const std::vector<Attributes::AttributeKey> &keys, Property &property) 1075             const std::vector<Attributes::AttributeKey> &keys, Property &property) {
1076             EXPECT_EQ(templateIdList, testTemplateIds);
1077             return ResultCode::GENERAL_ERROR;
1078         });
1079 
1080     auto conditions = MakeShared<Attributes>();
1081     ASSERT_NE(conditions, nullptr);
1082     conditions->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_GET);
1083     conditions->SetUint64ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, testTemplateIds);
1084     conditions->SetUint32ArrayValue(Attributes::ATTR_KEY_LIST, testKeys);
1085     auto values = MakeShared<Attributes>();
1086     ASSERT_NE(values, nullptr);
1087     ret = executorCallback->OnGetProperty(*conditions, *values);
1088     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1089 }
1090 
1091 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_General, TestSize.Level0)
1092 {
1093     shared_ptr<Executor> executor;
1094     shared_ptr<ExecutorRegisterCallback> executorCallback;
1095     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1096     shared_ptr<MockIExecutorMessenger> mockMessenger;
1097     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1098     ASSERT_EQ(ret, ResultCode::SUCCESS);
1099     Attributes attr;
1100     ret = executorCallback->OnSetProperty(attr);
1101     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1102 }
1103 
1104 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_DeleteTemplateTest_001, TestSize.Level0)
1105 {
1106     static const uint64_t testTemplateId = 123;
1107 
1108     shared_ptr<Executor> executor;
1109     shared_ptr<ExecutorRegisterCallback> executorCallback;
1110     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1111     shared_ptr<MockIExecutorMessenger> mockMessenger;
1112     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1113     ASSERT_EQ(ret, ResultCode::SUCCESS);
1114 
1115     EXPECT_CALL(*mockExecutorHdi, Delete(_))
1116         .Times(Exactly(1))
__anon0f00ab691a02(const std::vector<uint64_t> &templateIdList) 1117         .WillOnce([](const std::vector<uint64_t> &templateIdList) {
1118             EXPECT_EQ(templateIdList.size(), static_cast<size_t>(1));
1119             EXPECT_EQ(templateIdList[0], testTemplateId);
1120             return ResultCode::SUCCESS;
1121         });
1122 
1123     auto property = MakeShared<Attributes>();
1124     ASSERT_NE(property, nullptr);
1125     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_DEL);
1126     property->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1127     ret = executorCallback->OnSetProperty(*property);
1128     ASSERT_EQ(ret, ResultCode::SUCCESS);
1129 }
1130 
1131 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_DeleteTemplateTest_002, TestSize.Level0)
1132 {
1133     shared_ptr<Executor> executor;
1134     shared_ptr<ExecutorRegisterCallback> executorCallback;
1135     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1136     shared_ptr<MockIExecutorMessenger> mockMessenger;
1137     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1138     ASSERT_EQ(ret, ResultCode::SUCCESS);
1139 
1140     EXPECT_CALL(*mockExecutorHdi, Delete(_)).Times(Exactly(0));
1141 
1142     auto property = MakeShared<Attributes>();
1143     ASSERT_NE(property, nullptr);
1144     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_DEL);
1145     // Error: missing template id
1146     ret = executorCallback->OnSetProperty(*property);
1147     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1148 }
1149 
1150 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_DeleteTemplateTest_003, TestSize.Level0)
1151 {
1152     static const uint64_t testTemplateId = 123;
1153 
1154     shared_ptr<Executor> executor;
1155     shared_ptr<ExecutorRegisterCallback> executorCallback;
1156     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1157     shared_ptr<MockIExecutorMessenger> mockMessenger;
1158     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1159     ASSERT_EQ(ret, ResultCode::SUCCESS);
1160 
1161     EXPECT_CALL(*mockExecutorHdi, Delete(_)).Times(Exactly(0));
1162 
1163     auto property = MakeShared<Attributes>();
1164     ASSERT_NE(property, nullptr);
1165     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_DEL);
1166     property->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1167     // Error: Executor is disconnected
1168     executor->OnHdiDisconnect();
1169     ret = executorCallback->OnSetProperty(*property);
1170     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1171 }
1172 
1173 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_DeleteTemplateTest_004, TestSize.Level0)
1174 {
1175     static const uint64_t testTemplateId = 123;
1176 
1177     shared_ptr<Executor> executor;
1178     shared_ptr<ExecutorRegisterCallback> executorCallback;
1179     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1180     shared_ptr<MockIExecutorMessenger> mockMessenger;
1181     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1182     ASSERT_EQ(ret, ResultCode::SUCCESS);
1183 
1184     EXPECT_CALL(*mockExecutorHdi, Delete(_))
1185         .Times(Exactly(1))
__anon0f00ab691b02(const std::vector<uint64_t> &templateIdList) 1186         .WillOnce([](const std::vector<uint64_t> &templateIdList) {
1187             EXPECT_EQ(templateIdList.size(), static_cast<size_t>(1));
1188             EXPECT_EQ(templateIdList[0], testTemplateId);
1189             // Error: return error
1190             return ResultCode::GENERAL_ERROR;
1191         });
1192 
1193     auto property = MakeShared<Attributes>();
1194     ASSERT_NE(property, nullptr);
1195     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, PROPERTY_MODE_DEL);
1196     property->SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId);
1197     ret = executorCallback->OnSetProperty(*property);
1198     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1199 }
1200 
1201 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_001, TestSize.Level0)
1202 {
1203     static const int32_t testCommandId = 123;
1204     static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
1205     static std::thread t;
1206     static std::string threadName = "executor_unit_test";
1207 
1208     shared_ptr<Executor> executor;
1209     shared_ptr<ExecutorRegisterCallback> executorCallback;
1210     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1211     shared_ptr<MockIExecutorMessenger> mockMessenger;
1212     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1213     ASSERT_EQ(ret, ResultCode::SUCCESS);
1214 
1215     EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _))
1216         .Times(Exactly(2))
1217         .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anon0f00ab691c02(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1218                       const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1219             EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1220             EXPECT_EQ(extraInfo, testExtraInfo);
1221             callbackObj->OnResult(ResultCode::SUCCESS, {});
1222             return ResultCode::SUCCESS;
1223         })
1224         .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anon0f00ab691d02(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1225                       const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1226             EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1227             EXPECT_EQ(extraInfo, testExtraInfo);
1228             t = std::thread([callbackObj] {
1229                 pthread_setname_np(pthread_self(), threadName.c_str());
1230                 const int32_t sleepTime = 500;
1231                 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
1232                 callbackObj->OnResult(ResultCode::SUCCESS, {});
1233             });
1234             return ResultCode::SUCCESS;
1235         });
1236 
1237     auto property = MakeShared<Attributes>();
1238     ASSERT_NE(property, nullptr);
1239     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1240     property->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
1241     ret = executorCallback->OnSetProperty(*property);
1242     ASSERT_EQ(ret, ResultCode::SUCCESS);
1243     ret = executorCallback->OnSetProperty(*property);
1244     ASSERT_EQ(ret, ResultCode::SUCCESS);
1245     t.join();
1246 }
1247 
1248 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_002, TestSize.Level0)
1249 {
1250     static const int32_t testCommandId = 123;
1251     static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
1252 
1253     shared_ptr<Executor> executor;
1254     shared_ptr<ExecutorRegisterCallback> executorCallback;
1255     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1256     shared_ptr<MockIExecutorMessenger> mockMessenger;
1257     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1258     ASSERT_EQ(ret, ResultCode::SUCCESS);
1259 
1260     EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _))
1261         .Times(Exactly(1))
1262         .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anon0f00ab691f02(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1263                       const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1264             EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1265             EXPECT_EQ(extraInfo, testExtraInfo);
1266             // Error: OnResult not invoked
1267             return ResultCode::SUCCESS;
1268         });
1269 
1270     auto property = MakeShared<Attributes>();
1271     ASSERT_NE(property, nullptr);
1272     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1273     property->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
1274     ret = executorCallback->OnSetProperty(*property);
1275     ASSERT_EQ(ret, ResultCode::TIMEOUT);
1276 }
1277 
1278 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_003, TestSize.Level0)
1279 {
1280     static const int32_t testCommandId = 123;
1281     static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
1282 
1283     shared_ptr<Executor> executor;
1284     shared_ptr<ExecutorRegisterCallback> executorCallback;
1285     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1286     shared_ptr<MockIExecutorMessenger> mockMessenger;
1287     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1288     ASSERT_EQ(ret, ResultCode::SUCCESS);
1289 
1290     EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _))
1291         .Times(Exactly(1))
1292         .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anon0f00ab692002(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1293                       const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1294             EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1295             EXPECT_EQ(extraInfo, testExtraInfo);
1296             // Error: OnResult NOT_SUPPORT
1297             callbackObj->OnResult(ResultCode::TYPE_NOT_SUPPORT, {});
1298             return ResultCode::SUCCESS;
1299         });
1300 
1301     auto property = MakeShared<Attributes>();
1302     ASSERT_NE(property, nullptr);
1303     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1304     property->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
1305     ret = executorCallback->OnSetProperty(*property);
1306     ASSERT_EQ(ret, ResultCode::TYPE_NOT_SUPPORT);
1307 }
1308 
1309 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_004, TestSize.Level0)
1310 {
1311     static const int32_t testCommandId = 123;
1312     static const std::vector<uint8_t> testExtraInfo = {4, 5, 6};
1313 
1314     shared_ptr<Executor> executor;
1315     shared_ptr<ExecutorRegisterCallback> executorCallback;
1316     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1317     shared_ptr<MockIExecutorMessenger> mockMessenger;
1318     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1319     ASSERT_EQ(ret, ResultCode::SUCCESS);
1320 
1321     EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _))
1322         .Times(Exactly(1))
1323         .WillOnce([](UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo,
__anon0f00ab692102(UserAuth::PropertyMode commandId, const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) 1324                       const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj) {
1325             EXPECT_EQ(static_cast<int32_t>(commandId), testCommandId);
1326             EXPECT_EQ(extraInfo, testExtraInfo);
1327             // Error: return error
1328             return ResultCode::TYPE_NOT_SUPPORT;
1329         });
1330 
1331     auto property = MakeShared<Attributes>();
1332     ASSERT_NE(property, nullptr);
1333     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1334     property->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, testExtraInfo);
1335     ret = executorCallback->OnSetProperty(*property);
1336     ASSERT_EQ(ret, ResultCode::TYPE_NOT_SUPPORT);
1337 }
1338 
1339 HWTEST_F(ExecutorUnitTest, UserAuthExecutor_OnSetProperty_CustomCommandTest_005, TestSize.Level0)
1340 {
1341     static const int32_t testCommandId = 123;
1342 
1343     shared_ptr<Executor> executor;
1344     shared_ptr<ExecutorRegisterCallback> executorCallback;
1345     shared_ptr<MockIAuthExecutorHdi> mockExecutorHdi;
1346     shared_ptr<MockIExecutorMessenger> mockMessenger;
1347     int32_t ret = GetExecutorAndMockStub(executor, executorCallback, mockExecutorHdi, mockMessenger);
1348     ASSERT_EQ(ret, ResultCode::SUCCESS);
1349 
1350     EXPECT_CALL(*mockExecutorHdi, SendCommand(_, _, _)).Times(Exactly(0));
1351 
1352     auto property = MakeShared<Attributes>();
1353     ASSERT_NE(property, nullptr);
1354     property->SetUint32Value(Attributes::ATTR_PROPERTY_MODE, testCommandId);
1355     // Error: ATTR_EXTRA_INFO not set
1356     ret = executorCallback->OnSetProperty(*property);
1357     ASSERT_EQ(ret, ResultCode::GENERAL_ERROR);
1358 }
1359 } // namespace UserAuth
1360 } // namespace UserIam
1361 } // namespace OHOS
1362