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