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 "state_machine_test.h"
17 
18 #include <chrono>
19 
20 #include "finite_state_machine.h"
21 
22 #include "mock_thread_handler.h"
23 #include "relative_timer.h"
24 
25 namespace OHOS {
26 namespace UserIam {
27 namespace UserAuth {
28 using namespace testing;
29 using namespace testing::ext;
30 namespace {
31 auto &timer = RelativeTimer::GetInstance();
32 }
33 enum State : uint32_t {
34     STATE_INIT,
35     STATE_VERIFY_STARING,
36     STATE_COLLECT_STARING,
37     STATE_AUTH_PROCESSING,
38     STATE_VERIFY_STOPPING,
39     STATE_COLLECT_STOPPING,
40     STATE_END
41 };
42 
43 enum Event : uint32_t {
44     EVENT_START_AUTH,
45     EVENT_VERIFY_STARTED,
46     EVENT_COLLECT_STARTED,
47     EVENT_AUTH_RESULT_GET,
48     EVENT_VERIFY_STOPPED,
49     EVENT_COLLECT_STOP,
50     EVENT_USER_CANCEL,
51     EVENT_TIME_OUT,
52 };
53 
SetUpTestCase()54 void StateMachineTest::SetUpTestCase()
55 {
56 }
57 
TearDownTestCase()58 void StateMachineTest::TearDownTestCase()
59 {
60 }
61 
SetUp()62 void StateMachineTest::SetUp()
63 {
64     ThreadHandler::GetSingleThreadInstance()->EnsureTask([]() {});
65 }
66 
TearDown()67 void StateMachineTest::TearDown()
68 {
69     ThreadHandler::GetSingleThreadInstance()->EnsureTask([]() {});
70 }
71 
72 HWTEST_F(StateMachineTest, MachineCreateSelfReturn, TestSize.Level0)
73 {
74     auto handler = ThreadHandler::GetSingleThreadInstance();
75     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine0", STATE_INIT);
76     EXPECT_NE(machineBuilder, nullptr);
77 
78     auto ret1 = machineBuilder->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_VERIFY_STARING);
79     EXPECT_NE(ret1, nullptr);
80 
81     auto ret2 = ret1->MakeTransition(STATE_VERIFY_STARING, EVENT_VERIFY_STARTED, STATE_COLLECT_STARING);
82     EXPECT_EQ(ret2, ret1);
83 }
84 
85 HWTEST_F(StateMachineTest, MachineCreateOnlyBuildOnce, TestSize.Level0)
86 {
87     auto handler = ThreadHandler::GetSingleThreadInstance();
88     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine1", STATE_INIT);
89     EXPECT_NE(machineBuilder, nullptr);
90 
91     machineBuilder->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_VERIFY_STARING)
92         ->MakeTransition(STATE_VERIFY_STARING, EVENT_VERIFY_STARTED, STATE_COLLECT_STARING);
93 
94     auto first = machineBuilder->Build();
95     EXPECT_NE(first, nullptr);
96 
97     auto second = machineBuilder->Build();
98     EXPECT_EQ(second, nullptr);
99 }
100 
101 HWTEST_F(StateMachineTest, MachineCreateCheckTransition, TestSize.Level0)
102 {
103     auto handler = ThreadHandler::GetSingleThreadInstance();
104     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine2", STATE_INIT);
105     EXPECT_NE(machineBuilder, nullptr);
106 
107     machineBuilder->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_VERIFY_STARING)
108         ->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_COLLECT_STARING);
109 
110     auto machine = machineBuilder->Build();
111     EXPECT_EQ(machine, nullptr);
112 }
113 
114 HWTEST_F(StateMachineTest, MachineCreateInitialState, TestSize.Level0)
115 {
116     auto handler = ThreadHandler::GetSingleThreadInstance();
117     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine3", STATE_COLLECT_STOPPING);
118     ASSERT_NE(machineBuilder, nullptr);
119 
120     machineBuilder->MakeTransition(STATE_COLLECT_STOPPING, EVENT_START_AUTH, STATE_VERIFY_STARING);
121     auto machine = machineBuilder->Build();
122     ASSERT_NE(machine, nullptr);
123     EXPECT_EQ(machine->GetCurrentState(), STATE_COLLECT_STOPPING);
124 }
125 
126 HWTEST_F(StateMachineTest, MachineCreateNameCheck, TestSize.Level0)
127 {
128     auto handler = ThreadHandler::GetSingleThreadInstance();
129     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine4", STATE_COLLECT_STOPPING);
130     ASSERT_NE(machineBuilder, nullptr);
131 
132     machineBuilder->MakeTransition(STATE_COLLECT_STOPPING, EVENT_START_AUTH, STATE_VERIFY_STARING);
133     auto machine = machineBuilder->Build();
134     ASSERT_NE(machine, nullptr);
135     EXPECT_EQ(machine->GetMachineName(), "testMachine4");
136 }
137 
138 HWTEST_F(StateMachineTest, MachineScheduleStepIn, TestSize.Level0)
139 {
140     auto handler = ThreadHandler::GetSingleThreadInstance();
141     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine5", STATE_INIT);
142     ASSERT_NE(machineBuilder, nullptr);
143 
144     machineBuilder->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_VERIFY_STARING)
145         ->MakeTransition(STATE_VERIFY_STARING, EVENT_VERIFY_STARTED, STATE_COLLECT_STARING);
146 
147     auto machine = machineBuilder->Build();
148     ASSERT_NE(machine, nullptr);
149     EXPECT_EQ(machine->GetCurrentState(), STATE_INIT);
150 
151     machine->Schedule(EVENT_START_AUTH);
152     EXPECT_EQ(machine->EnsureCurrentState(), STATE_VERIFY_STARING);
153     machine->Schedule(EVENT_VERIFY_STARTED);
154     EXPECT_EQ(machine->EnsureCurrentState(), STATE_COLLECT_STARING);
155     machine->Schedule(EVENT_VERIFY_STARTED);
156     EXPECT_EQ(machine->EnsureCurrentState(), STATE_COLLECT_STARING);
157 }
158 
159 HWTEST_F(StateMachineTest, MachineScheduleWithAction, TestSize.Level0)
160 {
161     auto handler = ThreadHandler::GetSingleThreadInstance();
162     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine6", STATE_INIT);
163     ASSERT_NE(machineBuilder, nullptr);
164 
165     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> action1;
166     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> action2;
167     {
__anon8fdd6ba90402(FiniteStateMachine &machine) 168         auto init = [](FiniteStateMachine &machine) { return machine.GetCurrentState() == STATE_INIT; };
__anon8fdd6ba90502(FiniteStateMachine &machine) 169         auto verify = [](FiniteStateMachine &machine) { return machine.GetCurrentState() == EVENT_VERIFY_STARTED; };
170         InSequence s;
171         EXPECT_CALL(action1, Call(Truly(init), EVENT_START_AUTH)).Times(Exactly(1));
172         EXPECT_CALL(action2, Call(Truly(verify), EVENT_VERIFY_STARTED)).Times(Exactly(1));
173     }
174 
175     machineBuilder
176         ->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_VERIFY_STARING,
__anon8fdd6ba90602(FiniteStateMachine &machine, uint32_t event) 177             [&action1](FiniteStateMachine &machine, uint32_t event) { action1.Call(machine, event); })
178         ->MakeTransition(STATE_VERIFY_STARING, EVENT_VERIFY_STARTED, STATE_COLLECT_STARING,
__anon8fdd6ba90702(FiniteStateMachine &machine, uint32_t event) 179             [&action2](FiniteStateMachine &machine, uint32_t event) { action2.Call(machine, event); });
180 
181     auto machine = machineBuilder->Build();
182     ASSERT_NE(machine, nullptr);
183     EXPECT_EQ(machine->EnsureCurrentState(), STATE_INIT);
184 
185     machine->Schedule(EVENT_START_AUTH);
186     EXPECT_EQ(machine->EnsureCurrentState(), STATE_VERIFY_STARING);
187     machine->Schedule(EVENT_VERIFY_STARTED);
188     EXPECT_EQ(machine->EnsureCurrentState(), STATE_COLLECT_STARING);
189     machine->Schedule(EVENT_VERIFY_STARTED);
190     EXPECT_EQ(machine->EnsureCurrentState(), STATE_COLLECT_STARING);
191 }
192 
193 HWTEST_F(StateMachineTest, MachineScheduleWithComplexActionDirectly, TestSize.Level0)
194 {
195     auto handler = MockThreadHandler::InvokeDirectly();
196     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine7", STATE_INIT);
197     ASSERT_NE(machineBuilder, nullptr);
198 
199     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> action1;
200     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> action2;
201     {
__anon8fdd6ba90802(FiniteStateMachine &machine) 202         auto init = [](FiniteStateMachine &machine) { return machine.GetCurrentState() == STATE_INIT; };
__anon8fdd6ba90902(FiniteStateMachine &machine) 203         auto verify = [](FiniteStateMachine &machine) { return machine.GetCurrentState() == EVENT_VERIFY_STARTED; };
204 
205         InSequence s;
206         EXPECT_CALL(action1, Call(Truly(init), EVENT_START_AUTH)).Times(Exactly(1));
207         EXPECT_CALL(action2, Call(Truly(verify), EVENT_VERIFY_STARTED)).Times(Exactly(1));
208     }
209 
210     machineBuilder
211         ->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_VERIFY_STARING,
__anon8fdd6ba90a02(FiniteStateMachine &machine, uint32_t event) 212             [&action1](FiniteStateMachine &machine, uint32_t event) {
213                 action1.Call(machine, event);
214                 machine.Schedule(EVENT_VERIFY_STARTED);
215             })
216         ->MakeTransition(STATE_VERIFY_STARING, EVENT_VERIFY_STARTED, STATE_COLLECT_STARING,
__anon8fdd6ba90b02(FiniteStateMachine &machine, uint32_t event) 217             [&action2](FiniteStateMachine &machine, uint32_t event) {
218                 action2.Call(machine, event);
219                 machine.Schedule(EVENT_COLLECT_STARTED);
220             })
221         ->MakeTransition(STATE_COLLECT_STARING, EVENT_COLLECT_STARTED, STATE_AUTH_PROCESSING, nullptr);
222 
223     auto machine = machineBuilder->Build();
224     ASSERT_NE(machine, nullptr);
225     EXPECT_EQ(machine->EnsureCurrentState(), STATE_INIT);
226 
227     machine->Schedule(EVENT_START_AUTH);
228     EXPECT_EQ(machine->EnsureCurrentState(), STATE_AUTH_PROCESSING);
229 }
230 
231 HWTEST_F(StateMachineTest, MachineScheduleWithComplexActionBackGround, TestSize.Level0)
232 {
233     auto handler = ThreadHandler::GetSingleThreadInstance();
234     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine8", STATE_INIT);
235     ASSERT_NE(machineBuilder, nullptr);
236 
237     machineBuilder
238         ->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_VERIFY_STARING,
__anon8fdd6ba90c02(FiniteStateMachine &machine, [[maybe_unused]] uint32_t event) 239             [](FiniteStateMachine &machine, [[maybe_unused]] uint32_t event) {
240                 machine.Schedule(EVENT_VERIFY_STARTED);
241                 machine.Schedule(EVENT_COLLECT_STARTED);
242                 machine.Schedule(EVENT_USER_CANCEL);
243             })
244         ->MakeTransition(STATE_VERIFY_STARING, EVENT_VERIFY_STARTED, STATE_COLLECT_STARING, nullptr)
245         ->MakeTransition(STATE_COLLECT_STARING, EVENT_COLLECT_STARTED, STATE_AUTH_PROCESSING, nullptr)
246         ->MakeTransition(STATE_AUTH_PROCESSING, EVENT_USER_CANCEL, STATE_END, nullptr);
247     auto machine = machineBuilder->Build();
248     ASSERT_NE(machine, nullptr);
249     EXPECT_EQ(machine->EnsureCurrentState(), STATE_INIT);
250 
251     machine->Schedule(EVENT_START_AUTH);
252     EXPECT_EQ(machine->EnsureCurrentState(), STATE_END);
253 }
254 
255 HWTEST_F(StateMachineTest, MachineScheduleDeadlock, TestSize.Level0)
256 {
257     auto handler = ThreadHandler::GetSingleThreadInstance();
258     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine9", STATE_INIT);
259     ASSERT_NE(machineBuilder, nullptr);
__anon8fdd6ba90d02(FiniteStateMachine &machine, uint32_t event) 260     machineBuilder->MakeTransition(STATE_INIT, STATE_INIT, STATE_INIT, [](FiniteStateMachine &machine, uint32_t event) {
261         machine.Schedule(STATE_INIT);
262         machine.Schedule(STATE_INIT);
263         machine.Schedule(STATE_INIT);
264     });
265     auto machine = machineBuilder->Build();
266     ASSERT_NE(machine, nullptr);
267     EXPECT_EQ(machine->EnsureCurrentState(), STATE_INIT);
268 
269     machine->Schedule(EVENT_START_AUTH);
270     EXPECT_EQ(machine->EnsureCurrentState(), STATE_INIT);
271 }
272 
273 HWTEST_F(StateMachineTest, MachineScheduleContinues, TestSize.Level0)
274 {
275     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> action;
276     EXPECT_CALL(action, Call(_, STATE_INIT)).Times(Exactly(3));
277     auto handler = ThreadHandler::GetSingleThreadInstance();
278     ASSERT_NE(handler, nullptr);
279     {
280         auto machineBuilder = FiniteStateMachine::Builder::New("testMachine10", STATE_INIT);
281         ASSERT_NE(machineBuilder, nullptr);
282         machineBuilder->MakeTransition(STATE_INIT, STATE_INIT, STATE_INIT,
__anon8fdd6ba90e02(FiniteStateMachine &machine, [[maybe_unused]] uint32_t event) 283             [&action](FiniteStateMachine &machine, [[maybe_unused]] uint32_t event) {
284                 action.Call(machine, STATE_INIT);
285             });
286         auto machine = machineBuilder->Build();
287         ASSERT_NE(machine, nullptr);
288         machine->Schedule(STATE_INIT);
289         machine->Schedule(STATE_INIT);
290         machine->Schedule(STATE_INIT);
__anon8fdd6ba90f02() 291         handler->EnsureTask([]() {});
292     }
293 }
294 
295 HWTEST_F(StateMachineTest, MachineScheduleExpireNodeTimeout, TestSize.Level0)
296 {
297     auto handler = ThreadHandler::GetSingleThreadInstance();
298 
299     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> action;
300     EXPECT_CALL(action, Call(_, STATE_INIT)).Times(Exactly(5));
301     {
302         auto machineBuilder = FiniteStateMachine::Builder::New("testMachine11", STATE_INIT);
303         ASSERT_NE(machineBuilder, nullptr);
304         machineBuilder->MakeTransition(STATE_INIT, STATE_INIT, STATE_INIT,
__anon8fdd6ba91002(FiniteStateMachine &machine, [[maybe_unused]] uint32_t event) 305             [&action](FiniteStateMachine &machine, [[maybe_unused]] uint32_t event) {
306                 std::this_thread::sleep_for(std::chrono::milliseconds(200));
307                 action.Call(machine, STATE_INIT);
308             });
309         auto machine = machineBuilder->Build();
310         ASSERT_NE(machine, nullptr);
311 
312         machine->SetThreadHandler(handler);
__anon8fdd6ba91102() 313         handler->EnsureTask([]() {});
314         machine->Schedule(STATE_INIT);
315         machine->Schedule(STATE_INIT);
316         machine->Schedule(STATE_INIT);
317         machine->Schedule(STATE_INIT);
318         machine->Schedule(STATE_INIT);
319         std::this_thread::sleep_for(std::chrono::milliseconds(100));
320         machine = nullptr;
__anon8fdd6ba91202() 321         handler->EnsureTask([]() {});
322     }
323 }
324 
325 HWTEST_F(StateMachineTest, MachineScheduleExpireNodeExpire, TestSize.Level0)
326 {
327     auto handler = ThreadHandler::GetSingleThreadInstance();
328     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> action;
329     EXPECT_CALL(action, Call(_, STATE_INIT)).Times(Exactly(0));
330     {
331         auto machineBuilder = FiniteStateMachine::Builder::New("testMachine12", STATE_INIT);
332         ASSERT_NE(machineBuilder, nullptr);
333         machineBuilder->MakeTransition(STATE_INIT, STATE_INIT, STATE_INIT,
__anon8fdd6ba91302(FiniteStateMachine &machine, [[maybe_unused]] uint32_t event) 334             [&action](FiniteStateMachine &machine, [[maybe_unused]] uint32_t event) {
335                 action.Call(machine, STATE_INIT);
336             });
337         auto machine = machineBuilder->Build();
338         ASSERT_NE(machine, nullptr);
__anon8fdd6ba91402() 339         handler->PostTask([]() { std::this_thread::sleep_for(std::chrono::milliseconds(1000)); });
340         machine->Schedule(STATE_INIT);
341         machine->Schedule(STATE_INIT);
342         machine->Schedule(STATE_INIT);
343         machine->Schedule(STATE_INIT);
344         machine->Schedule(STATE_INIT);
345         machine = nullptr;
346     }
__anon8fdd6ba91502() 347     handler->EnsureTask([]() {});
348 }
349 
MakeTestMachine(std::shared_ptr<FiniteStateMachine::Builder> & machineBuilder,MockFunction<void (FiniteStateMachine & machine,uint32_t event)> & action,MockFunction<void (FiniteStateMachine & machine,uint32_t event)> & enter,MockFunction<void (FiniteStateMachine & machine,uint32_t event)> & leave)350 void MakeTestMachine(std::shared_ptr<FiniteStateMachine::Builder> &machineBuilder,
351     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> &action,
352     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> &enter,
353     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> &leave)
354 {
355     machineBuilder
356         ->MakeTransition(STATE_INIT, EVENT_START_AUTH, STATE_VERIFY_STARING,
357         [&action](FiniteStateMachine &machine, uint32_t event) {
358         action.Call(machine, event);
359         machine.Schedule(EVENT_VERIFY_STARTED);
360         machine.Schedule(EVENT_COLLECT_STARTED);
361         })
362         ->MakeTransition(STATE_VERIFY_STARING, EVENT_VERIFY_STARTED, STATE_COLLECT_STARING,
363         [&action](FiniteStateMachine &machine, uint32_t event) { action.Call(machine, event); })
364         ->MakeTransition(STATE_COLLECT_STARING, EVENT_COLLECT_STARTED, STATE_AUTH_PROCESSING,
365         [&action](FiniteStateMachine &machine, uint32_t event) { action.Call(machine, event); })
366         ->MakeTransition(STATE_AUTH_PROCESSING, EVENT_USER_CANCEL, STATE_END,
367         [&action](FiniteStateMachine &machine, uint32_t event) { action.Call(machine, event); });
368 
369     machineBuilder->MakeOnStateEnter(STATE_INIT,
370         [&enter](FiniteStateMachine &machine, uint32_t event) { enter.Call(machine, event); });
371     machineBuilder->MakeOnStateLeave(STATE_INIT,
372         [&leave](FiniteStateMachine &machine, uint32_t event) { leave.Call(machine, event); });
373 
374     machineBuilder->MakeOnStateEnter(STATE_VERIFY_STARING,
375         [&enter](FiniteStateMachine &machine, uint32_t event) { enter.Call(machine, event); });
376     machineBuilder->MakeOnStateLeave(STATE_VERIFY_STARING,
377         [&leave](FiniteStateMachine &machine, uint32_t event) { leave.Call(machine, event); });
378 
379     machineBuilder->MakeOnStateEnter(STATE_COLLECT_STARING,
380         [&enter](FiniteStateMachine &machine, uint32_t event) { enter.Call(machine, event); });
381     machineBuilder->MakeOnStateLeave(STATE_COLLECT_STARING,
382         [&leave](FiniteStateMachine &machine, uint32_t event) { leave.Call(machine, event); });
383 
384     machineBuilder->MakeOnStateEnter(STATE_AUTH_PROCESSING,
385         [&enter](FiniteStateMachine &machine, uint32_t event) { enter.Call(machine, event); });
386     machineBuilder->MakeOnStateLeave(STATE_AUTH_PROCESSING,
387         [&leave](FiniteStateMachine &machine, uint32_t event) { leave.Call(machine, event); });
388 
389     machineBuilder->MakeOnStateEnter(STATE_END,
390         [&enter](FiniteStateMachine &machine, uint32_t event) { enter.Call(machine, event); });
391 }
392 
393 HWTEST_F(StateMachineTest, MachineScheduleEnterAndLeave, TestSize.Level0)
394 {
395     auto handler = ThreadHandler::GetSingleThreadInstance();
396     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> action;
397     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> enter;
398     MockFunction<void(FiniteStateMachine & machine, uint32_t event)> leave;
399 
400     InSequence s;
401     EXPECT_CALL(action, Call(_, EVENT_START_AUTH));
402     EXPECT_CALL(leave, Call(_, STATE_INIT));
403     EXPECT_CALL(enter, Call(_, STATE_VERIFY_STARING));
404 
405     EXPECT_CALL(action, Call(_, EVENT_VERIFY_STARTED));
406     EXPECT_CALL(leave, Call(_, STATE_VERIFY_STARING));
407     EXPECT_CALL(enter, Call(_, STATE_COLLECT_STARING));
408 
409     EXPECT_CALL(action, Call(_, EVENT_COLLECT_STARTED));
410     EXPECT_CALL(leave, Call(_, STATE_COLLECT_STARING));
411     EXPECT_CALL(enter, Call(_, STATE_AUTH_PROCESSING));
412 
413     EXPECT_CALL(action, Call(_, EVENT_USER_CANCEL));
414     EXPECT_CALL(leave, Call(_, STATE_AUTH_PROCESSING));
415     EXPECT_CALL(enter, Call(_, STATE_END));
416 
417     auto machineBuilder = FiniteStateMachine::Builder::New("testMachine13", STATE_INIT);
418     ASSERT_NE(machineBuilder, nullptr);
419     MakeTestMachine(machineBuilder, action, enter, leave);
420 
421     auto machine = machineBuilder->Build();
422     ASSERT_NE(machine, nullptr);
423 
424     machine->SetThreadHandler(handler);
__anon8fdd6ba92302() 425     handler->EnsureTask([]() {});
426     machine->Schedule(EVENT_START_AUTH);
__anon8fdd6ba92402() 427     handler->EnsureTask([]() {});
428     machine->Schedule(EVENT_USER_CANCEL);
429     EXPECT_EQ(STATE_END, machine->EnsureCurrentState());
430 
__anon8fdd6ba92502() 431     handler->EnsureTask([]() {});
432 }
433 } // namespace UserAuth
434 } // namespace UserIam
435 } // namespace OHOS