1 /*
2  * Copyright (C) 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 "schedule_node_test.h"
17 
18 #include "iam_ptr.h"
19 #include "schedule_node.h"
20 
21 #include "mock_executor_callback.h"
22 #include "mock_resource_node.h"
23 #include "mock_schedule_node_callback.h"
24 #include "mock_thread_handler.h"
25 #include "relative_timer.h"
26 
27 namespace OHOS {
28 namespace UserIam {
29 namespace UserAuth {
30 using namespace testing;
31 using namespace testing::ext;
32 namespace {
33 auto &timer = RelativeTimer::GetInstance();
34 }
SetUpTestCase()35 void ScheduleNodeTest::SetUpTestCase()
36 {
37 }
38 
TearDownTestCase()39 void ScheduleNodeTest::TearDownTestCase()
40 {
41 }
42 
SetUp()43 void ScheduleNodeTest::SetUp()
44 {
45 }
46 
TearDown()47 void ScheduleNodeTest::TearDown()
48 {
49 }
50 
51 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderWithNullptr, TestSize.Level0)
52 {
53     auto builder = ScheduleNode::Builder::New(nullptr, nullptr);
54     EXPECT_EQ(builder, nullptr);
55 }
56 
57 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderOneCollectorFailed, TestSize.Level0)
58 {
59     {
60         auto faceCollector = MockResourceNode::CreateWithExecuteIndex(1, FACE, COLLECTOR);
61         auto builder = ScheduleNode::Builder::New(faceCollector, faceCollector);
62         EXPECT_EQ(builder, nullptr);
63     }
64     {
65         auto faceVerifier = MockResourceNode::CreateWithExecuteIndex(1, FACE, VERIFIER);
66         auto builder = ScheduleNode::Builder::New(faceVerifier, faceVerifier);
67         EXPECT_EQ(builder, nullptr);
68     }
69 
70     {
71         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
72         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
73         ASSERT_NE(builder, nullptr);
74         auto scheduleNode = builder->Build();
75         ASSERT_NE(scheduleNode, nullptr);
76 
77         EXPECT_EQ(scheduleNode->GetCollectorExecutor().lock(), faceAllInOne);
78         EXPECT_EQ(scheduleNode->GetVerifyExecutor().lock(), faceAllInOne);
79     }
80 
81     {
82         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
83         auto faceVerifier = MockResourceNode::CreateWithExecuteIndex(1, FACE, VERIFIER);
84         auto builder = ScheduleNode::Builder::New(faceVerifier, faceAllInOne);
85         EXPECT_EQ(builder, nullptr);
86     }
87 
88     {
89         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
90         auto faceVerifier = MockResourceNode::CreateWithExecuteIndex(1, FACE, VERIFIER);
91         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceVerifier);
92         EXPECT_EQ(builder, nullptr);
93     }
94 
95     {
96         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
97         auto faceCollector = MockResourceNode::CreateWithExecuteIndex(1, FACE, COLLECTOR);
98         auto builder = ScheduleNode::Builder::New(faceCollector, faceAllInOne);
99         EXPECT_EQ(builder, nullptr);
100     }
101 
102     {
103         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
104         auto faceCollector = MockResourceNode::CreateWithExecuteIndex(1, FACE, COLLECTOR);
105         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceCollector);
106         EXPECT_EQ(builder, nullptr);
107     }
108 }
109 
110 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderOneCollectorSuccess, TestSize.Level0)
111 {
112     {
113         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
114         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
115         ASSERT_NE(builder, nullptr);
116         auto scheduleNode = builder->Build();
117         ASSERT_NE(scheduleNode, nullptr);
118 
119         EXPECT_EQ(scheduleNode->GetCollectorExecutor().lock(), faceAllInOne);
120         EXPECT_EQ(scheduleNode->GetVerifyExecutor().lock(), faceAllInOne);
121     }
122 }
123 
124 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderTwoExecutorsFailed, TestSize.Level0)
125 {
126     {
127         auto faceCollector = MockResourceNode::CreateWithExecuteIndex(1, FACE, COLLECTOR);
128         auto builder = ScheduleNode::Builder::New(faceCollector, faceCollector);
129         EXPECT_EQ(builder, nullptr);
130     }
131 
132     {
133         auto faceVerifier = MockResourceNode::CreateWithExecuteIndex(1, FACE, VERIFIER);
134         auto builder = ScheduleNode::Builder::New(faceVerifier, faceVerifier);
135         EXPECT_EQ(builder, nullptr);
136     }
137 
138     {
139         auto faceCollector = MockResourceNode::CreateWithExecuteIndex(1, FACE, COLLECTOR);
140         auto faceVerifier = MockResourceNode::CreateWithExecuteIndex(1, FACE, VERIFIER);
141         // test paras error
142         auto builder = ScheduleNode::Builder::New(faceVerifier, faceCollector);
143         EXPECT_EQ(builder, nullptr);
144     }
145 
146     {
147         auto faceCollector = MockResourceNode::CreateWithExecuteIndex(1, FACE, COLLECTOR);
148         auto pinVerifier = MockResourceNode::CreateWithExecuteIndex(1, PIN, VERIFIER);
149         auto builder = ScheduleNode::Builder::New(faceCollector, pinVerifier);
150         EXPECT_EQ(builder, nullptr);
151     }
152 }
153 
154 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderTwoExecutorsSuccess, TestSize.Level0)
155 {
156     {
157         auto faceCollector = MockResourceNode::CreateWithExecuteIndex(1, FACE, COLLECTOR);
158         auto faceVerifier = MockResourceNode::CreateWithExecuteIndex(1, FACE, VERIFIER);
159         auto builder = ScheduleNode::Builder::New(faceCollector, faceVerifier);
160         ASSERT_NE(builder, nullptr);
161 
162         auto scheduleNode = builder->Build();
163         ASSERT_NE(scheduleNode, nullptr);
164 
165         EXPECT_EQ(scheduleNode->GetCollectorExecutor().lock(), faceCollector);
166         EXPECT_EQ(scheduleNode->GetVerifyExecutor().lock(), faceVerifier);
167     }
168 }
169 
170 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderMismatchAuthType, TestSize.Level0)
171 {
172     {
173         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
174         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
175         ASSERT_NE(builder, nullptr);
176         auto scheduleNode = builder->Build();
177         ASSERT_NE(scheduleNode, nullptr);
178     }
179 
180     {
181         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
182         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
183         ASSERT_NE(builder, nullptr);
184         builder->SetAuthType(PIN);
185         auto scheduleNode = builder->Build();
186         ASSERT_EQ(scheduleNode, nullptr);
187     }
188 }
189 
190 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderOtherParameters, TestSize.Level0)
191 {
192     {
193         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
194         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
195         std::vector<uint64_t> TEMPLATE_LIST = {1, 2, 3, 4};
196         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
197         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
198         ASSERT_NE(builder, nullptr);
199 
200         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
201         builder->SetScheduleId(SCHEDULE_ID);
202         builder->SetScheduleMode(IDENTIFY);
203         builder->SetTemplateIdList(TEMPLATE_LIST);
204 
205         auto scheduleNode = builder->Build();
206         ASSERT_NE(scheduleNode, nullptr);
207 
208         EXPECT_EQ(scheduleNode->GetCollectorExecutor().lock(), faceAllInOne);
209         EXPECT_EQ(scheduleNode->GetVerifyExecutor().lock(), faceAllInOne);
210 
211         EXPECT_EQ(scheduleNode->GetAuthType(), FACE);
212         EXPECT_EQ(scheduleNode->GetExecutorMatcher(), EXECUTOR_MATCHER);
213         EXPECT_EQ(scheduleNode->GetScheduleId(), SCHEDULE_ID);
214         EXPECT_EQ(scheduleNode->GetScheduleMode(), IDENTIFY);
215         EXPECT_TRUE(scheduleNode->GetTemplateIdList().has_value());
216         EXPECT_THAT(scheduleNode->GetTemplateIdList().value(), ElementsAreArray(TEMPLATE_LIST));
217     }
218 }
219 
220 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderOtherParametersNoTemplate, TestSize.Level0)
221 {
222     {
223         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
224         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
225         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
226         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
227         ASSERT_NE(builder, nullptr);
228         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
229         builder->SetScheduleId(SCHEDULE_ID);
230         builder->SetScheduleMode(IDENTIFY);
231         auto scheduleNode = builder->Build();
232         ASSERT_NE(scheduleNode, nullptr);
233 
234         EXPECT_EQ(scheduleNode->GetCollectorExecutor().lock(), faceAllInOne);
235         EXPECT_EQ(scheduleNode->GetVerifyExecutor().lock(), faceAllInOne);
236 
237         EXPECT_EQ(scheduleNode->GetAuthType(), FACE);
238         EXPECT_EQ(scheduleNode->GetExecutorMatcher(), EXECUTOR_MATCHER);
239         EXPECT_EQ(scheduleNode->GetScheduleId(), SCHEDULE_ID);
240         EXPECT_EQ(scheduleNode->GetScheduleMode(), IDENTIFY);
241         EXPECT_FALSE(scheduleNode->GetTemplateIdList().has_value());
242     }
243 }
244 
245 HWTEST_F(ScheduleNodeTest, ScheduleNodeStartAllInOneFailed, TestSize.Level0)
246 {
247     MockExecutorCallback executor;
248     EXPECT_CALL(executor, OnBeginExecute(_, _, _)).WillOnce(Return(1));
249 
250     auto callback = MockScheduleNodeCallback::Create();
251     EXPECT_CALL(*callback, OnScheduleStarted()).Times(0);
252     EXPECT_CALL(*callback, OnScheduleStoped(_, _)).Times(1);
253 
254     auto handler = ThreadHandler::GetSingleThreadInstance();
255     ASSERT_NE(handler, nullptr);
256     {
257         constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
258         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
259         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
260         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, ALL_IN_ONE, executor);
261         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
262         ASSERT_NE(builder, nullptr);
263         builder->SetThreadHandler(handler);
264         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
265         builder->SetScheduleId(SCHEDULE_ID);
266         builder->SetScheduleMode(IDENTIFY);
267         builder->SetScheduleCallback(callback);
268 
269         auto scheduleNode = builder->Build();
270         ASSERT_NE(scheduleNode, nullptr);
271 
272         EXPECT_TRUE(scheduleNode->StartSchedule());
__anon772159460202() 273         handler->EnsureTask([]() {});
274 
275         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_END);
276     }
__anon772159460302() 277     handler->EnsureTask([]() {});
278 }
279 
280 HWTEST_F(ScheduleNodeTest, ScheduleNodeStartAllInOneSuccess, TestSize.Level0)
281 {
282     MockExecutorCallback executor;
283     EXPECT_CALL(executor, OnBeginExecute(_, _, _)).WillOnce(Return(0));
284 
285     auto callback = MockScheduleNodeCallback::Create();
286     EXPECT_CALL(*callback, OnScheduleStarted()).Times(1);
287 
288     auto handler = ThreadHandler::GetSingleThreadInstance();
289     ASSERT_NE(handler, nullptr);
290     {
291         constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
292         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
293         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
294         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, ALL_IN_ONE, executor);
295         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
296         ASSERT_NE(builder, nullptr);
297         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
298         builder->SetThreadHandler(handler);
299         builder->SetScheduleId(SCHEDULE_ID);
300         builder->SetScheduleMode(IDENTIFY);
301         builder->SetScheduleCallback(callback);
302 
303         auto scheduleNode = builder->Build();
304         ASSERT_NE(scheduleNode, nullptr);
305 
306         EXPECT_TRUE(scheduleNode->StartSchedule());
__anon772159460402() 307         handler->EnsureTask([]() {});
308         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_AUTH_PROCESSING);
309     }
__anon772159460502() 310     handler->EnsureTask([]() {});
311 }
312 
313 HWTEST_F(ScheduleNodeTest, ScheduleNodeStartAllInOneSuccessButTimeout, TestSize.Level0)
314 {
315     using namespace std::chrono;
316 
317     std::promise<void> ensure;
318     MockExecutorCallback executor;
319     auto callback = MockScheduleNodeCallback::Create();
320     ON_CALL(*callback, OnScheduleStoped(_, _))
321         .WillByDefault(
__anon772159460602(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) 322             [&ensure](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) { ensure.set_value(); });
323 
324     auto handler = ThreadHandler::GetSingleThreadInstance();
325     ASSERT_NE(handler, nullptr);
326     {
327         constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
328         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
329         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
330         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, ALL_IN_ONE, executor);
331         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
332         ASSERT_NE(builder, nullptr);
333         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
334         builder->SetThreadHandler(handler);
335         builder->SetScheduleId(SCHEDULE_ID);
336         builder->SetScheduleMode(IDENTIFY);
337         builder->SetExpiredTime(550);
338         builder->SetScheduleCallback(callback);
339 
340         auto scheduleNode = builder->Build();
341         ASSERT_NE(scheduleNode, nullptr);
342 
343         InSequence s; // the following four method will be invoke in sequence
344         EXPECT_CALL(executor, OnBeginExecute(_, _, _)).WillOnce(Return(0));
345         EXPECT_CALL(*callback, OnScheduleStarted()).Times(1);
346         EXPECT_CALL(executor, OnEndExecute(_, _)).WillOnce(Return(0));
347         EXPECT_CALL(*callback, OnScheduleStoped(TIMEOUT, _)).Times(1);
348 
349         const time_point<system_clock> start = system_clock::now();
350         EXPECT_TRUE(scheduleNode->StartSchedule());
__anon772159460702() 351         handler->EnsureTask([]() {});
352         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_AUTH_PROCESSING);
353         ensure.get_future().get();
354         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_END);
355         time_point<system_clock> finish = system_clock::now();
356         auto cost = duration_cast<milliseconds>(finish - start).count();
357         EXPECT_GT(cost, 540);
358         EXPECT_LT(cost, 700);
359     }
__anon772159460802() 360     handler->EnsureTask([]() {});
361 }
362 
363 HWTEST_F(ScheduleNodeTest, ScheduleNodeStartAllInOneSuccessButTimeoutAndEndFail, TestSize.Level0)
364 {
365     using namespace std::chrono;
366 
367     std::promise<void> ensure;
368     MockExecutorCallback executor;
369     auto callback = MockScheduleNodeCallback::Create();
370     ON_CALL(*callback, OnScheduleStoped(_, _))
371         .WillByDefault(
__anon772159460902(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) 372             [&ensure](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) { ensure.set_value(); });
373 
374     auto handler = ThreadHandler::GetSingleThreadInstance();
375     ASSERT_NE(handler, nullptr);
376     {
377         constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
378         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
379         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
380         std::vector<uint64_t> TEMPLATE_LIST = {1};
381         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, ALL_IN_ONE, executor);
382         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
383         ASSERT_NE(builder, nullptr);
384         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
385         builder->SetThreadHandler(handler);
386         builder->SetScheduleId(SCHEDULE_ID);
387         builder->SetScheduleMode(IDENTIFY);
388         builder->SetExpiredTime(550);
389         builder->SetScheduleCallback(callback);
390         auto parameters = Common::MakeShared<Attributes>();
391         EXPECT_NE(parameters, nullptr);
392         builder->SetTemplateIdList(TEMPLATE_LIST);
393 
394         auto scheduleNode = builder->Build();
395         ASSERT_NE(scheduleNode, nullptr);
396 
397         InSequence s; // the following four method will be invoke in sequence
398         EXPECT_CALL(executor, OnBeginExecute(_, _, _)).WillOnce(Return(0));
399         EXPECT_CALL(*callback, OnScheduleStarted()).Times(1);
400         EXPECT_CALL(executor, OnEndExecute(_, _)).WillOnce(Return(1)); // mock end failed
401         EXPECT_CALL(*callback, OnScheduleStoped(TIMEOUT, _)).Times(1);
402 
403         const time_point<system_clock> start = system_clock::now();
404         EXPECT_TRUE(scheduleNode->StartSchedule());
__anon772159460a02() 405         handler->EnsureTask([]() {});
406         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_AUTH_PROCESSING);
407         ensure.get_future().get();
408         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_END);
409         time_point<system_clock> finish = system_clock::now();
410         auto cost = duration_cast<milliseconds>(finish - start).count();
411         EXPECT_GT(cost, 540);
412         EXPECT_LT(cost, 700);
413     }
__anon772159460b02() 414     handler->EnsureTask([]() {});
415 }
416 
417 HWTEST_F(ScheduleNodeTest, ScheduleNodeStartAllInOneSuccessGetResult, TestSize.Level0)
418 {
419     using namespace std::chrono;
420 
421     std::promise<void> ensure;
422     MockExecutorCallback executor;
423     auto callback = MockScheduleNodeCallback::Create();
424     ON_CALL(*callback, OnScheduleStoped(_, _))
425         .WillByDefault(
__anon772159460c02(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) 426             [&ensure](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) { ensure.set_value(); });
427 
428     auto handler = ThreadHandler::GetSingleThreadInstance();
429     ASSERT_NE(handler, nullptr);
430     {
431         constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
432         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
433         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
434         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, ALL_IN_ONE, executor);
435         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
436         ASSERT_NE(builder, nullptr);
437         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
438         builder->SetThreadHandler(handler);
439         builder->SetScheduleId(SCHEDULE_ID);
440         builder->SetScheduleMode(IDENTIFY);
441         builder->SetScheduleCallback(callback);
442 
443         auto scheduleNode = builder->Build();
444         ASSERT_NE(scheduleNode, nullptr);
445 
446         InSequence s; // the following four method will be invoke in sequence
447         EXPECT_CALL(executor, OnBeginExecute(_, _, _)).WillOnce(Return(0));
448         EXPECT_CALL(*callback, OnScheduleStarted()).Times(1);
449         EXPECT_CALL(*callback, OnScheduleStoped(SUCCESS, _)).Times(1);
450 
451         const time_point<system_clock> start = system_clock::now();
452 
453         // return success after 550ms
__anon772159460d02() 454         timer.Register([&scheduleNode]() { scheduleNode->ContinueSchedule(SUCCESS, nullptr); },
455             550);
456 
457         EXPECT_TRUE(scheduleNode->StartSchedule());
__anon772159460e02() 458         handler->EnsureTask([]() {});
459         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_AUTH_PROCESSING);
460         ensure.get_future().get();
461         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_END);
462         time_point<system_clock> finish = system_clock::now();
463         auto cost = duration_cast<milliseconds>(finish - start).count();
464         EXPECT_GT(cost, 540);
465         EXPECT_LT(cost, 700);
466     }
__anon772159460f02() 467     handler->EnsureTask([]() {});
468 }
469 
470 HWTEST_F(ScheduleNodeTest, ScheduleNodeStartAllInOneUserStop, TestSize.Level0)
471 {
472     using namespace std::chrono;
473 
474     std::promise<void> ensure;
475     MockExecutorCallback executor;
476     auto callback = MockScheduleNodeCallback::Create();
477     ON_CALL(*callback, OnScheduleStoped(_, _))
478         .WillByDefault(
__anon772159461002(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) 479             [&ensure](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) { ensure.set_value(); });
480 
481     auto handler = ThreadHandler::GetSingleThreadInstance();
482     ASSERT_NE(handler, nullptr);
483     {
484         constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
485         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
486         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
487         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, ALL_IN_ONE, executor);
488         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
489         ASSERT_NE(builder, nullptr);
490         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
491         builder->SetThreadHandler(handler);
492         builder->SetScheduleId(SCHEDULE_ID);
493         builder->SetScheduleMode(IDENTIFY);
494         builder->SetScheduleCallback(callback);
495 
496         auto scheduleNode = builder->Build();
497         ASSERT_NE(scheduleNode, nullptr);
498 
499         InSequence s; // the following four method will be invoke in sequence
500         EXPECT_CALL(executor, OnBeginExecute(_, _, _)).WillOnce(Return(0));
501         EXPECT_CALL(*callback, OnScheduleStarted()).Times(1);
502         EXPECT_CALL(executor, OnEndExecute(_, _)).WillOnce(Return(0));
503         EXPECT_CALL(*callback, OnScheduleStoped(CANCELED, _)).Times(1);
504 
505         const time_point<system_clock> start = system_clock::now();
506 
507         // stop schedule after 550ms
__anon772159461102() 508         timer.Register([&scheduleNode]() { scheduleNode->StopSchedule(); }, 550);
509 
510         EXPECT_TRUE(scheduleNode->StartSchedule());
__anon772159461202() 511         handler->EnsureTask([]() {});
512         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_AUTH_PROCESSING);
513         ensure.get_future().get();
514         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_END);
515         time_point<system_clock> finish = system_clock::now();
516         auto cost = duration_cast<milliseconds>(finish - start).count();
517         EXPECT_GT(cost, 540);
518         EXPECT_LT(cost, 700);
519     }
__anon772159461302() 520     handler->EnsureTask([]() {});
521 }
522 
523 HWTEST_F(ScheduleNodeTest, ScheduleNodeStartAllInOneUserStopAndEndFailed, TestSize.Level0)
524 {
525     using namespace std::chrono;
526 
527     std::promise<void> ensure;
528     MockExecutorCallback executor;
529     auto callback = MockScheduleNodeCallback::Create();
530     ON_CALL(*callback, OnScheduleStoped(_, _))
531         .WillByDefault(
__anon772159461402(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) 532             [&ensure](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) { ensure.set_value(); });
533 
534     auto handler = ThreadHandler::GetSingleThreadInstance();
535     ASSERT_NE(handler, nullptr);
536     {
537         constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
538         constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
539         constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
540         auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, ALL_IN_ONE, executor);
541         auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
542         ASSERT_NE(builder, nullptr);
543         builder->SetExecutorMatcher(EXECUTOR_MATCHER);
544         builder->SetThreadHandler(handler);
545         builder->SetScheduleId(SCHEDULE_ID);
546         builder->SetScheduleMode(IDENTIFY);
547         builder->SetScheduleCallback(callback);
548         builder->SetAccessTokenId(12330);
549         builder->SetPinSubType(PIN_SIX);
550 
551         auto scheduleNode = builder->Build();
552         ASSERT_NE(scheduleNode, nullptr);
553 
554         InSequence s; // the following four method will be invoke in sequence
555         EXPECT_CALL(executor, OnBeginExecute(_, _, _)).WillOnce(Return(0));
556         EXPECT_CALL(*callback, OnScheduleStarted()).Times(1);
557         EXPECT_CALL(executor, OnEndExecute(_, _)).WillOnce(Return(1)); // Mock end failed
558         EXPECT_CALL(*callback, OnScheduleStoped(CANCELED, _)).Times(1);
559 
560         const time_point<system_clock> start = system_clock::now();
561 
562         // stop schedule after 550ms
__anon772159461502() 563         timer.Register([&scheduleNode]() { scheduleNode->StopSchedule(); }, 550);
564 
565         EXPECT_TRUE(scheduleNode->StartSchedule());
__anon772159461602() 566         handler->EnsureTask([]() {});
567         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_AUTH_PROCESSING);
568         ensure.get_future().get();
569         EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_END);
570         time_point<system_clock> finish = system_clock::now();
571         auto cost = duration_cast<milliseconds>(finish - start).count();
572         EXPECT_GT(cost, 540);
573         EXPECT_LT(cost, 700);
574     }
__anon772159461702() 575     handler->EnsureTask([]() {});
576 }
577 
578 HWTEST_F(ScheduleNodeTest, ScheduleNodeTestSendMessage, TestSize.Level0)
579 {
580     std::vector<uint8_t> testMsg;
581 
582     constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
583     constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
584     constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
585     MockExecutorCallback executor;
586     auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, ALL_IN_ONE, executor);
587     auto builder = ScheduleNode::Builder::New(faceAllInOne, faceAllInOne);
588     EXPECT_NE(builder, nullptr);
589     builder->SetExecutorMatcher(EXECUTOR_MATCHER);
590     builder->SetScheduleId(SCHEDULE_ID);
591     builder->SetScheduleMode(IDENTIFY);
592     std::shared_ptr<MockScheduleNodeCallback> callback = nullptr;
593     builder->SetScheduleCallback(callback);
594 
595     auto scheduleNode = builder->Build();
596     EXPECT_NE(scheduleNode, nullptr);
597 
598     ExecutorRole testDstRole = COLLECTOR;
599     EXPECT_TRUE(scheduleNode->SendMessage(testDstRole, testMsg));
600     testDstRole = SCHEDULER;
601     scheduleNode = builder->Build();
602     EXPECT_NE(scheduleNode, nullptr);
603     Attributes attr;
604     EXPECT_TRUE(attr.SetInt32Value(Attributes::ATTR_TIP_INFO, 40));
605     testMsg = attr.Serialize();
606     EXPECT_FALSE(scheduleNode->SendMessage(testDstRole, testMsg));
607     callback = Common::MakeShared<MockScheduleNodeCallback>();
608     EXPECT_NE(callback, nullptr);
609     EXPECT_CALL(*callback, OnScheduleProcessed(_, _, _)).Times(1);
610     builder->SetScheduleCallback(callback);
611     builder->SetAuthType(FACE);
612     scheduleNode = builder->Build();
613     EXPECT_NE(scheduleNode, nullptr);
614     EXPECT_TRUE(scheduleNode->SendMessage(testDstRole, testMsg));
615 }
616 } // namespace UserAuth
617 } // namespace UserIam
618 } // namespace OHOS
619