1 /*
2  * Copyright (c) 2024 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 "dsched_continue_state_test.h"
17 
18 #include "dsched_continue.h"
19 #include "dtbschedmgr_log.h"
20 #include "test_log.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS {
26 namespace DistributedSchedule {
27 namespace {
28     const std::string BASEDIR = "/data/service/el1/public/database/DistributedSchedule";
29     const int32_t WAITTIME = 2000;
30 }
31 //DSchedContinueDataStateTest
SetUpTestCase()32 void DSchedContinueDataStateTest::SetUpTestCase()
33 {
34     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
35     DTEST_LOG << "DSchedContinueDataStateTest::SetUpTestCase" << std::endl;
36 }
37 
TearDownTestCase()38 void DSchedContinueDataStateTest::TearDownTestCase()
39 {
40     (void)remove(BASEDIR.c_str());
41     DTEST_LOG << "DSchedContinueDataStateTest::TearDownTestCase" << std::endl;
42 }
43 
TearDown()44 void DSchedContinueDataStateTest::TearDown()
45 {
46     usleep(WAITTIME);
47     DTEST_LOG << "DSchedContinueDataStateTest::TearDown" << std::endl;
48 }
49 
SetUp()50 void DSchedContinueDataStateTest::SetUp()
51 {
52     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
53     std::shared_ptr<DSchedContinueStateMachine> stateMachine = std::make_shared<DSchedContinueStateMachine>(dContinue);
54     dataStateTest_ = std::make_shared<DSchedContinueDataState>(stateMachine);
55     DTEST_LOG << "DSchedContinueDataStateTest::SetUp" << std::endl;
56     usleep(WAITTIME);
57 }
58 
CreateObject()59 std::shared_ptr<DSchedContinue> DSchedContinueDataStateTest::CreateObject()
60 {
61     int32_t subServiceType = 0;
62     int32_t direction = 0;
63     sptr<IRemoteObject> callback = nullptr;
64     DSchedContinueInfo continueInfo;
65     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
66         callback, continueInfo);
67     dContinue->Init();
68     return dContinue;
69 }
70 
71 //DSchedContinueSinkEndStateTest
SetUpTestCase()72 void DSchedContinueSinkEndStateTest::SetUpTestCase()
73 {
74     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
75     DTEST_LOG << "DSchedContinueSinkEndStateTest::SetUpTestCase" << std::endl;
76 }
77 
TearDownTestCase()78 void DSchedContinueSinkEndStateTest::TearDownTestCase()
79 {
80     (void)remove(BASEDIR.c_str());
81     DTEST_LOG << "DSchedContinueSinkEndStateTest::TearDownTestCase" << std::endl;
82 }
83 
TearDown()84 void DSchedContinueSinkEndStateTest::TearDown()
85 {
86     usleep(WAITTIME);
87     DTEST_LOG << "DSchedContinueSinkEndStateTest::TearDown" << std::endl;
88 }
89 
SetUp()90 void DSchedContinueSinkEndStateTest::SetUp()
91 {
92     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
93     std::shared_ptr<DSchedContinueStateMachine> stateMachine = std::make_shared<DSchedContinueStateMachine>(dContinue);
94     sinkEndStateTest_ = std::make_shared<DSchedContinueSinkEndState>(stateMachine);
95     DTEST_LOG << "DSchedContinueSinkEndStateTest::SetUp" << std::endl;
96     usleep(WAITTIME);
97 }
98 
CreateObject()99 std::shared_ptr<DSchedContinue> DSchedContinueSinkEndStateTest::CreateObject()
100 {
101     int32_t subServiceType = 0;
102     int32_t direction = 0;
103     sptr<IRemoteObject> callback = nullptr;
104     DSchedContinueInfo continueInfo;
105     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
106         callback, continueInfo);
107     dContinue->Init();
108     return dContinue;
109 }
110 
111 //DSchedContinueSinkStartStateTest
SetUpTestCase()112 void DSchedContinueSinkStartStateTest::SetUpTestCase()
113 {
114     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
115     DTEST_LOG << "DSchedContinueSinkStartStateTest::SetUpTestCase" << std::endl;
116 }
117 
TearDownTestCase()118 void DSchedContinueSinkStartStateTest::TearDownTestCase()
119 {
120     (void)remove(BASEDIR.c_str());
121     DTEST_LOG << "DSchedContinueSinkStartStateTest::TearDownTestCase" << std::endl;
122 }
123 
TearDown()124 void DSchedContinueSinkStartStateTest::TearDown()
125 {
126     usleep(WAITTIME);
127     DTEST_LOG << "DSchedContinueSinkStartStateTest::TearDown" << std::endl;
128 }
129 
SetUp()130 void DSchedContinueSinkStartStateTest::SetUp()
131 {
132     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
133     std::shared_ptr<DSchedContinueStateMachine> stateMachine = std::make_shared<DSchedContinueStateMachine>(dContinue);
134     sinkStartStateTest_ = std::make_shared<DSchedContinueSinkStartState>(stateMachine);
135     DTEST_LOG << "DSchedContinueSinkStartStateTest::SetUp" << std::endl;
136     usleep(WAITTIME);
137 }
138 
CreateObject()139 std::shared_ptr<DSchedContinue> DSchedContinueSinkStartStateTest::CreateObject()
140 {
141     int32_t subServiceType = 0;
142     int32_t direction = 0;
143     sptr<IRemoteObject> callback = nullptr;
144     DSchedContinueInfo continueInfo;
145     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
146         callback, continueInfo);
147     dContinue->Init();
148     return dContinue;
149 }
150 
151 //DSchedContinueSinkWaitEndStateTest
SetUpTestCase()152 void DSchedContinueSinkWaitEndStateTest::SetUpTestCase()
153 {
154     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
155     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest::SetUpTestCase" << std::endl;
156 }
157 
TearDownTestCase()158 void DSchedContinueSinkWaitEndStateTest::TearDownTestCase()
159 {
160     (void)remove(BASEDIR.c_str());
161     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest::TearDownTestCase" << std::endl;
162 }
163 
TearDown()164 void DSchedContinueSinkWaitEndStateTest::TearDown()
165 {
166     usleep(WAITTIME);
167     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest::TearDown" << std::endl;
168 }
169 
SetUp()170 void DSchedContinueSinkWaitEndStateTest::SetUp()
171 {
172     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
173     std::shared_ptr<DSchedContinueStateMachine> stateMachine =
174         std::make_shared<DSchedContinueStateMachine>(dContinue);
175     sinkWaitEndTest_ = std::make_shared<DSchedContinueSinkWaitEndState>(stateMachine);
176     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest::SetUp" << std::endl;
177     usleep(WAITTIME);
178 }
179 
CreateObject()180 std::shared_ptr<DSchedContinue> DSchedContinueSinkWaitEndStateTest::CreateObject()
181 {
182     int32_t subServiceType = 0;
183     int32_t direction = 0;
184     sptr<IRemoteObject> callback = nullptr;
185     DSchedContinueInfo continueInfo;
186     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
187         callback, continueInfo);
188     dContinue->Init();
189     return dContinue;
190 }
191 
192 //DSchedContinueAbilityStateTest
SetUpTestCase()193 void DSchedContinueAbilityStateTest::SetUpTestCase()
194 {
195     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
196     DTEST_LOG << "DSchedContinueAbilityStateTest::SetUpTestCase" << std::endl;
197 }
198 
TearDownTestCase()199 void DSchedContinueAbilityStateTest::TearDownTestCase()
200 {
201     (void)remove(BASEDIR.c_str());
202     DTEST_LOG << "DSchedContinueAbilityStateTest::TearDownTestCase" << std::endl;
203 }
204 
TearDown()205 void DSchedContinueAbilityStateTest::TearDown()
206 {
207     usleep(WAITTIME);
208     DTEST_LOG << "DSchedContinueAbilityStateTest::TearDown" << std::endl;
209 }
210 
SetUp()211 void DSchedContinueAbilityStateTest::SetUp()
212 {
213     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
214     std::shared_ptr<DSchedContinueStateMachine> stateMachine =
215         std::make_shared<DSchedContinueStateMachine>(dContinue);
216     ASSERT_NE(dContinue, nullptr);
217     ASSERT_NE(stateMachine, nullptr);
218     abilityStateTest_ = std::make_shared<DSchedContinueAbilityState>(stateMachine);
219     DTEST_LOG << "DSchedContinueAbilityStateTest::SetUp" << std::endl;
220     usleep(WAITTIME);
221 }
222 
CreateObject()223 std::shared_ptr<DSchedContinue> DSchedContinueAbilityStateTest::CreateObject()
224 {
225     int32_t subServiceType = 0;
226     int32_t direction = 0;
227     sptr<IRemoteObject> callback = nullptr;
228     DSchedContinueInfo continueInfo;
229     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
230         callback, continueInfo);
231     dContinue->Init();
232     return dContinue;
233 }
234 
235 //DSchedContinueEndStateTest
SetUpTestCase()236 void DSchedContinueEndStateTest::SetUpTestCase()
237 {
238     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
239     DTEST_LOG << "DSchedContinueEndStateTest::SetUpTestCase" << std::endl;
240 }
241 
TearDownTestCase()242 void DSchedContinueEndStateTest::TearDownTestCase()
243 {
244     (void)remove(BASEDIR.c_str());
245     DTEST_LOG << "DSchedContinueEndStateTest::TearDownTestCase" << std::endl;
246 }
247 
TearDown()248 void DSchedContinueEndStateTest::TearDown()
249 {
250     usleep(WAITTIME);
251     DTEST_LOG << "DSchedContinueEndStateTest::TearDown" << std::endl;
252 }
253 
SetUp()254 void DSchedContinueEndStateTest::SetUp()
255 {
256     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
257     std::shared_ptr<DSchedContinueStateMachine> stateMachine =
258         std::make_shared<DSchedContinueStateMachine>(dContinue);
259     srcEndStateTest_ = std::make_shared<DSchedContinueEndState>(stateMachine);
260     DTEST_LOG << "DSchedContinueEndStateTest::SetUp" << std::endl;
261     usleep(WAITTIME);
262 }
263 
CreateObject()264 std::shared_ptr<DSchedContinue> DSchedContinueEndStateTest::CreateObject()
265 {
266     int32_t subServiceType = 0;
267     int32_t direction = 0;
268     sptr<IRemoteObject> callback = nullptr;
269     DSchedContinueInfo continueInfo;
270     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
271         callback, continueInfo);
272     dContinue->Init();
273     return dContinue;
274 }
275 
276 //DSchedContinueSourceStartStateTest
SetUpTestCase()277 void DSchedContinueSourceStartStateTest::SetUpTestCase()
278 {
279     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
280     DTEST_LOG << "DSchedContinueSourceStartStateTest::SetUpTestCase" << std::endl;
281 }
282 
TearDownTestCase()283 void DSchedContinueSourceStartStateTest::TearDownTestCase()
284 {
285     (void)remove(BASEDIR.c_str());
286     DTEST_LOG << "DSchedContinueSourceStartStateTest::TearDownTestCase" << std::endl;
287 }
288 
TearDown()289 void DSchedContinueSourceStartStateTest::TearDown()
290 {
291     usleep(WAITTIME);
292     DTEST_LOG << "DSchedContinueSourceStartStateTest::TearDown" << std::endl;
293 }
294 
SetUp()295 void DSchedContinueSourceStartStateTest::SetUp()
296 {
297     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
298     std::shared_ptr<DSchedContinueStateMachine> stateMachine =
299         std::make_shared<DSchedContinueStateMachine>(dContinue);
300     srcStartStateTest_ = std::make_shared<DSchedContinueSourceStartState>(stateMachine);
301     DTEST_LOG << "DSchedContinueSourceStartStateTest::SetUp" << std::endl;
302     usleep(WAITTIME);
303 }
304 
CreateObject()305 std::shared_ptr<DSchedContinue> DSchedContinueSourceStartStateTest::CreateObject()
306 {
307     int32_t subServiceType = 0;
308     int32_t direction = 0;
309     sptr<IRemoteObject> callback = nullptr;
310     DSchedContinueInfo continueInfo;
311     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
312         callback, continueInfo);
313     dContinue->Init();
314     return dContinue;
315 }
316 
317 //DSchedContinueWaitEndStateTest
SetUpTestCase()318 void DSchedContinueWaitEndStateTest::SetUpTestCase()
319 {
320     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
321     DTEST_LOG << "DSchedContinueWaitEndStateTest::SetUpTestCase" << std::endl;
322 }
323 
TearDownTestCase()324 void DSchedContinueWaitEndStateTest::TearDownTestCase()
325 {
326     (void)remove(BASEDIR.c_str());
327     DTEST_LOG << "DSchedContinueWaitEndStateTest::TearDownTestCase" << std::endl;
328 }
329 
TearDown()330 void DSchedContinueWaitEndStateTest::TearDown()
331 {
332     usleep(WAITTIME);
333     DTEST_LOG << "DSchedContinueWaitEndStateTest::TearDown" << std::endl;
334 }
335 
SetUp()336 void DSchedContinueWaitEndStateTest::SetUp()
337 {
338     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
339     std::shared_ptr<DSchedContinueStateMachine> stateMachine =
340         std::make_shared<DSchedContinueStateMachine>(dContinue);
341     srcWaitEndTest_ = std::make_shared<DSchedContinueWaitEndState>(stateMachine);
342     DTEST_LOG << "DSchedContinueWaitEndStateTest::SetUp" << std::endl;
343     usleep(WAITTIME);
344 }
345 
CreateObject()346 std::shared_ptr<DSchedContinue> DSchedContinueWaitEndStateTest::CreateObject()
347 {
348     int32_t subServiceType = 0;
349     int32_t direction = 0;
350     sptr<IRemoteObject> callback = nullptr;
351     DSchedContinueInfo continueInfo;
352     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
353         callback, continueInfo);
354     dContinue->Init();
355     return dContinue;
356 }
357 
358 //DSchedContinueStateMachineTest
SetUpTestCase()359 void DSchedContinueStateMachineTest::SetUpTestCase()
360 {
361     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
362     DTEST_LOG << "DSchedContinueStateMachineTest::SetUpTestCase" << std::endl;
363 }
364 
TearDownTestCase()365 void DSchedContinueStateMachineTest::TearDownTestCase()
366 {
367     (void)remove(BASEDIR.c_str());
368     DTEST_LOG << "DSchedContinueStateMachineTest::TearDownTestCase" << std::endl;
369 }
370 
TearDown()371 void DSchedContinueStateMachineTest::TearDown()
372 {
373     usleep(WAITTIME);
374     DTEST_LOG << "DSchedContinueStateMachineTest::TearDown" << std::endl;
375 }
376 
SetUp()377 void DSchedContinueStateMachineTest::SetUp()
378 {
379     std::shared_ptr<DSchedContinue> dContinue = CreateObject();
380     stateMachineTest_ = std::make_shared<DSchedContinueStateMachine>(dContinue);
381     DTEST_LOG << "DSchedContinueStateMachineTest::SetUp" << std::endl;
382     usleep(WAITTIME);
383 }
384 
CreateObject()385 std::shared_ptr<DSchedContinue> DSchedContinueStateMachineTest::CreateObject()
386 {
387     int32_t subServiceType = 0;
388     int32_t direction = 0;
389     sptr<IRemoteObject> callback = nullptr;
390     DSchedContinueInfo continueInfo;
391     std::shared_ptr<DSchedContinue> dContinue = std::make_shared<DSchedContinue>(subServiceType, direction,
392         callback, continueInfo);
393     dContinue->Init();
394     return dContinue;
395 }
396 
397 /**
398  * @tc.name: SinkExecuteTest001
399  * @tc.desc: Execute
400  * @tc.type: FUNC
401  */
402 HWTEST_F(DSchedContinueDataStateTest, SinkExecuteTest001, TestSize.Level3)
403 {
404     DTEST_LOG << "DSchedContinueDataStateTest SinkExecuteTest001 begin" << std::endl;
405     ASSERT_NE(dataStateTest_, nullptr);
406     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
407     ASSERT_NE(event, nullptr);
408     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390202(AppExecFwk::InnerEvent *event) 409     auto destructor = [](AppExecFwk::InnerEvent *event) {
410         if (event != nullptr) {
411             delete event;
412         }
413     };
414     int32_t ret = dataStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
415     EXPECT_EQ(ret, CONTINUE_STATE_MACHINE_INVALID_STATE);
416     DTEST_LOG << "DSchedContinueDataStateTest SinkExecuteTest001 end" << std::endl;
417 }
418 
419 /**
420  * @tc.name: SinkExecuteTest002
421  * @tc.desc: Execute
422  * @tc.type: FUNC
423  */
424 HWTEST_F(DSchedContinueDataStateTest, SinkExecuteTest002, TestSize.Level3)
425 {
426     DTEST_LOG << "DSchedContinueDataStateTest SinkExecuteTest002 begin" << std::endl;
427     ASSERT_NE(dataStateTest_, nullptr);
428     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
429     ASSERT_NE(event, nullptr);
430     event->innerEventId_ = static_cast<uint32_t>(DSCHED_CONTINUE_DATA_EVENT);
__anon0d8557390302(AppExecFwk::InnerEvent *event) 431     auto destructor = [](AppExecFwk::InnerEvent *event) {
432         if (event != nullptr) {
433             delete event;
434         }
435     };
436     int32_t ret = dataStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
437     EXPECT_NE(ret, ERR_OK);
438     DTEST_LOG << "DSchedContinueDataStateTest SinkExecuteTest002 end" << std::endl;
439 }
440 
441 /**
442  * @tc.name: SinkGetStateType001
443  * @tc.desc: GetStateType
444  * @tc.type: FUNC
445  */
446 HWTEST_F(DSchedContinueDataStateTest, SinkGetStateType001, TestSize.Level3)
447 {
448     DTEST_LOG << "DSchedContinueDataStateTest SinkGetStateType001 begin" << std::endl;
449     ASSERT_NE(dataStateTest_, nullptr);
450     int32_t ret = dataStateTest_->GetStateType();
451     EXPECT_EQ(ret, DSCHED_CONTINUE_DATA_STATE);
452     DTEST_LOG << "DSchedContinueDataStateTest SinkGetStateType001 end" << std::endl;
453 }
454 
455  /**
456  * @tc.name: SinkDoContinueDataTask001
457  * @tc.desc: DoContinueData
458  * @tc.type: FUNC
459  */
460 HWTEST_F(DSchedContinueDataStateTest, SinkDoContinueDataTask001, TestSize.Level3)
461 {
462     DTEST_LOG << "DSchedContinueDataStateTest SinkDoContinueDataTask001 begin" << std::endl;
463     ASSERT_NE(dataStateTest_, nullptr);
464     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
465     ASSERT_NE(event, nullptr);
466     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390402(AppExecFwk::InnerEvent *event) 467     auto destructor = [](AppExecFwk::InnerEvent *event) {
468         if (event != nullptr) {
469             delete event;
470         }
471     };
472     int32_t ret = dataStateTest_->DoContinueDataTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
473     EXPECT_NE(ret, DSCHED_CONTINUE_DATA_STATE);
474     DTEST_LOG << "DSchedContinueDataStateTest SinkDoContinueDataTask001 end" << std::endl;
475 }
476 
477  /**
478  * @tc.name: SinkDoContinueEndTask001
479  * @tc.desc: DoContinueEndTask
480  * @tc.type: FUNC
481  */
482 HWTEST_F(DSchedContinueDataStateTest, SinkDoContinueEndTask001, TestSize.Level3)
483 {
484     DTEST_LOG << "DSchedContinueDataStateTest SinkDoContinueEndTask001 begin" << std::endl;
485     ASSERT_NE(dataStateTest_, nullptr);
486     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
487     ASSERT_NE(event, nullptr);
488     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390502(AppExecFwk::InnerEvent *event) 489     auto destructor = [](AppExecFwk::InnerEvent *event) {
490         if (event != nullptr) {
491             delete event;
492         }
493     };
494     int32_t ret = dataStateTest_->DoContinueEndTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
495     EXPECT_NE(ret, ERR_OK);
496     DTEST_LOG << "DSchedContinueDataStateTest SinkDoContinueEndTask001 end" << std::endl;
497 }
498 
499  /**
500  * @tc.name: SinkDoContinueErrorTask001
501  * @tc.desc: DoContinueErrorTask
502  * @tc.type: FUNC
503  */
504 HWTEST_F(DSchedContinueDataStateTest, SinkDoContinueErrorTask001, TestSize.Level3)
505 {
506     DTEST_LOG << "DSchedContinueDataStateTest SinkDoContinueErrorTask001 begin" << std::endl;
507     ASSERT_NE(dataStateTest_, nullptr);
508     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
509     ASSERT_NE(event, nullptr);
510     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390602(AppExecFwk::InnerEvent *event) 511     auto destructor = [](AppExecFwk::InnerEvent *event) {
512         if (event != nullptr) {
513             delete event;
514         }
515     };
516     int32_t ret = dataStateTest_->DoContinueErrorTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
517     EXPECT_NE(ret, ERR_OK);
518     DTEST_LOG << "DSchedContinueDataStateTest SinkDoContinueErrorTask001 end" << std::endl;
519 }
520 
521  /**
522  * @tc.name: TestSinkExecute001
523  * @tc.desc: Execute
524  * @tc.type: FUNC
525  */
526 HWTEST_F(DSchedContinueSinkEndStateTest, TestSinkExecute001, TestSize.Level3)
527 {
528     DTEST_LOG << "DSchedContinueSinkEndStateTest SinkExecuteTest001 begin" << std::endl;
529     ASSERT_NE(sinkEndStateTest_, nullptr);
530     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
531     ASSERT_NE(event, nullptr);
532     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390702(AppExecFwk::InnerEvent *event) 533     auto destructor = [](AppExecFwk::InnerEvent *event) {
534         if (event != nullptr) {
535             delete event;
536         }
537     };
538     int32_t ret = sinkEndStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
539     EXPECT_EQ(ret, CONTINUE_STATE_MACHINE_INVALID_STATE);
540     DTEST_LOG << "DSchedContinueSinkEndStateTest TestSinkExecute001 end" << std::endl;
541 }
542 
543  /**
544  * @tc.name: TestSinkExecute002
545  * @tc.desc: Execute
546  * @tc.type: FUNC
547  */
548 HWTEST_F(DSchedContinueSinkEndStateTest, TestSinkExecute002, TestSize.Level3)
549 {
550     DTEST_LOG << "DSchedContinueSinkEndStateTest SinkExecuteTest001 begin" << std::endl;
551     ASSERT_NE(sinkEndStateTest_, nullptr);
552     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
553     ASSERT_NE(event, nullptr);
554     event->innerEventId_ = static_cast<uint32_t>(DSCHED_CONTINUE_END_EVENT);
__anon0d8557390802(AppExecFwk::InnerEvent *event) 555     auto destructor = [](AppExecFwk::InnerEvent *event) {
556         if (event != nullptr) {
557             delete event;
558         }
559     };
560     int32_t ret = sinkEndStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
561     EXPECT_NE(ret, ERR_OK);
562     DTEST_LOG << "DSchedContinueSinkEndStateTest TestSinkExecute002 end" << std::endl;
563 }
564 
565 /**
566  * @tc.name: TestSinkGetStateType001
567  * @tc.desc: GetStateType
568  * @tc.type: FUNC
569  */
570 HWTEST_F(DSchedContinueSinkEndStateTest, TestSinkGetStateType001, TestSize.Level3)
571 {
572     DTEST_LOG << "DSchedContinueSinkEndStateTest TestSinkGetStateType001 begin" << std::endl;
573     ASSERT_NE(sinkEndStateTest_, nullptr);
574     int32_t ret = sinkEndStateTest_->GetStateType();
575     EXPECT_EQ(ret, DSCHED_CONTINUE_SINK_END_STATE);
576     DTEST_LOG << "DSchedContinueSinkEndStateTest TestSinkGetStateType001 end" << std::endl;
577 }
578 
579 /**
580  * @tc.name: TestSinkDoContinueEndTask001
581  * @tc.desc: DoContinueEndTask
582  * @tc.type: FUNC
583  */
584 HWTEST_F(DSchedContinueSinkEndStateTest, TestSinkDoContinueEndTask001, TestSize.Level3)
585 {
586     DTEST_LOG << "DSchedContinueSinkEndStateTest TestSinkDoContinueEndTask001 begin" << std::endl;
587     ASSERT_NE(sinkEndStateTest_, nullptr);
588     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
589     ASSERT_NE(event, nullptr);
590     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390902(AppExecFwk::InnerEvent *event) 591     auto destructor = [](AppExecFwk::InnerEvent *event) {
592         if (event != nullptr) {
593             delete event;
594         }
595     };
596     int32_t ret = sinkEndStateTest_->DoContinueEndTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
597     EXPECT_NE(ret, ERR_OK);
598     DTEST_LOG << "DSchedContinueSinkEndStateTest TestSinkDoContinueEndTask001 end" << std::endl;
599 }
600 
601  /**
602  * @tc.name: SinkExecuteTest_001
603  * @tc.desc: Execute
604  * @tc.type: FUNC
605  */
606 HWTEST_F(DSchedContinueSinkStartStateTest, SinkExecuteTest_001, TestSize.Level3)
607 {
608     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkExecuteTest_001 begin" << std::endl;
609     ASSERT_NE(sinkStartStateTest_, nullptr);
610     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
611     ASSERT_NE(event, nullptr);
612     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390a02(AppExecFwk::InnerEvent *event) 613     auto destructor = [](AppExecFwk::InnerEvent *event) {
614         if (event != nullptr) {
615             delete event;
616         }
617     };
618     int32_t ret = sinkStartStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
619     EXPECT_EQ(ret, CONTINUE_STATE_MACHINE_INVALID_STATE);
620     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkExecuteTest_001 end" << std::endl;
621 }
622 
623  /**
624  * @tc.name: SinkExecuteTest_002
625  * @tc.desc: Execute
626  * @tc.type: FUNC
627  */
628 HWTEST_F(DSchedContinueSinkStartStateTest, SinkExecuteTest_002, TestSize.Level3)
629 {
630     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkExecuteTest_002 begin" << std::endl;
631     ASSERT_NE(sinkStartStateTest_, nullptr);
632     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
633     ASSERT_NE(event, nullptr);
634     event->innerEventId_ = static_cast<uint32_t>(DSCHED_CONTINUE_REQ_PULL_EVENT);
__anon0d8557390b02(AppExecFwk::InnerEvent *event) 635     auto destructor = [](AppExecFwk::InnerEvent *event) {
636         if (event != nullptr) {
637             delete event;
638         }
639     };
640     int32_t ret = sinkStartStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
641     EXPECT_NE(ret, ERR_OK);
642     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkExecuteTest_002 end" << std::endl;
643 }
644 
645  /**
646  * @tc.name: SinkGetStateTypeTest_001
647  * @tc.desc: GetStateTypeTest
648  * @tc.type: FUNC
649  */
650 HWTEST_F(DSchedContinueSinkStartStateTest, SinkGetStateTypeTest_001, TestSize.Level3)
651 {
652     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkGetStateTypeTest_001 begin" << std::endl;
653     ASSERT_NE(sinkStartStateTest_, nullptr);
654     int32_t ret = sinkStartStateTest_->GetStateType();
655     EXPECT_EQ(ret, DSCHED_CONTINUE_SINK_START_STATE);
656     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkGetStateTypeTest_001 end" << std::endl;
657 }
658 
659  /**
660  * @tc.name: SinkDoContinuePullReqTaskTest_001
661  * @tc.desc: DoContinuePullReqTask
662  * @tc.type: FUNC
663  */
664 HWTEST_F(DSchedContinueSinkStartStateTest, SinkDoContinuePullReqTaskTest_001, TestSize.Level3)
665 {
666     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkDoContinuePullReqTaskTest_001 begin" << std::endl;
667     ASSERT_NE(sinkStartStateTest_, nullptr);
668     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
669     ASSERT_NE(event, nullptr);
670     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390c02(AppExecFwk::InnerEvent *event) 671     auto destructor = [](AppExecFwk::InnerEvent *event) {
672         if (event != nullptr) {
673             delete event;
674         }
675     };
676     int32_t ret = sinkStartStateTest_->DoContinuePullReqTask(nullptr,
677         AppExecFwk::InnerEvent::Pointer(event, destructor));
678     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
679     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkDoContinuePullReqTaskTest_001 end" << std::endl;
680 }
681 
682  /**
683  * @tc.name: SinkDoContinueAbilityTaskTest_001
684  * @tc.desc: DoContinueAbilityTask
685  * @tc.type: FUNC
686  */
687 HWTEST_F(DSchedContinueSinkStartStateTest, SinkDoContinueAbilityTaskTest_001, TestSize.Level3)
688 {
689     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkDoContinueAbilityTaskTest_001 begin" << std::endl;
690     ASSERT_NE(sinkStartStateTest_, nullptr);
691     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
692     ASSERT_NE(event, nullptr);
693     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390d02(AppExecFwk::InnerEvent *event) 694     auto destructor = [](AppExecFwk::InnerEvent *event) {
695         if (event != nullptr) {
696             delete event;
697         }
698     };
699     int32_t ret = sinkStartStateTest_->DoContinueAbilityTask(nullptr,
700         AppExecFwk::InnerEvent::Pointer(event, destructor));
701     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
702     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkDoContinueAbilityTaskTest_001 end" << std::endl;
703 }
704 
705  /**
706  * @tc.name: SinkDoContinueEndTaskTest_001
707  * @tc.desc: DoContinueEndTask
708  * @tc.type: FUNC
709  */
710 HWTEST_F(DSchedContinueSinkStartStateTest, SinkDoContinueEndTaskTest_001, TestSize.Level3)
711 {
712     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkDoContinueEndTaskTest_001 begin" << std::endl;
713     ASSERT_NE(sinkStartStateTest_, nullptr);
714     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
715     ASSERT_NE(event, nullptr);
716     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390e02(AppExecFwk::InnerEvent *event) 717     auto destructor = [](AppExecFwk::InnerEvent *event) {
718         if (event != nullptr) {
719             delete event;
720         }
721     };
722     int32_t ret = sinkStartStateTest_->DoContinueEndTask(nullptr,
723         AppExecFwk::InnerEvent::Pointer(event, destructor));
724     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
725     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkDoContinueEndTaskTest_001 end" << std::endl;
726 }
727 
728  /**
729  * @tc.name: SinkDoContinueErrorTask001
730  * @tc.desc: DoContinueErrorTask
731  * @tc.type: FUNC
732  */
733 HWTEST_F(DSchedContinueSinkStartStateTest, SinkDoContinueErrorTask001, TestSize.Level3)
734 {
735     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkDoContinueErrorTask001 begin" << std::endl;
736     ASSERT_NE(sinkStartStateTest_, nullptr);
737     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
738     ASSERT_NE(event, nullptr);
739     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557390f02(AppExecFwk::InnerEvent *event) 740     auto destructor = [](AppExecFwk::InnerEvent *event) {
741         if (event != nullptr) {
742             delete event;
743         }
744     };
745     int32_t ret = sinkStartStateTest_->DoContinueErrorTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
746     EXPECT_NE(ret, ERR_OK);
747     DTEST_LOG << "DSchedContinueSinkStartStateTest SinkDoContinueErrorTask001 end" << std::endl;
748 }
749 
750  /**
751  * @tc.name: SinkExecute001
752  * @tc.desc: Execute
753  * @tc.type: FUNC
754  */
755 HWTEST_F(DSchedContinueSinkWaitEndStateTest, SinkExecute001, TestSize.Level3)
756 {
757     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkExecute001 begin" << std::endl;
758     ASSERT_NE(sinkWaitEndTest_, nullptr);
759     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
760     ASSERT_NE(event, nullptr);
761     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391002(AppExecFwk::InnerEvent *event) 762     auto destructor = [](AppExecFwk::InnerEvent *event) {
763         if (event != nullptr) {
764             delete event;
765         }
766     };
767     int32_t ret = sinkWaitEndTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
768     EXPECT_EQ(ret, CONTINUE_STATE_MACHINE_INVALID_STATE);
769     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkExecute001 end" << std::endl;
770 }
771 
772  /**
773  * @tc.name: SinkExecute002
774  * @tc.desc: Execute
775  * @tc.type: FUNC
776  */
777 HWTEST_F(DSchedContinueSinkWaitEndStateTest, SinkExecute002, TestSize.Level3)
778 {
779     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkExecute002 begin" << std::endl;
780     ASSERT_NE(sinkWaitEndTest_, nullptr);
781     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
782     ASSERT_NE(event, nullptr);
783     event->innerEventId_ = static_cast<uint32_t>(DSCHED_CONTINUE_COMPLETE_EVENT);
__anon0d8557391102(AppExecFwk::InnerEvent *event) 784     auto destructor = [](AppExecFwk::InnerEvent *event) {
785         if (event != nullptr) {
786             delete event;
787         }
788     };
789     int32_t ret = sinkWaitEndTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
790     EXPECT_NE(ret, ERR_OK);
791     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkExecute002 end" << std::endl;
792 }
793 
794  /**
795  * @tc.name: SinkGetStateType001
796  * @tc.desc: GetStateType
797  * @tc.type: FUNC
798  */
799 HWTEST_F(DSchedContinueSinkWaitEndStateTest, SinkGetStateType001, TestSize.Level3)
800 {
801     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkGetStateType001 begin" << std::endl;
802     ASSERT_NE(sinkWaitEndTest_, nullptr);
803     int32_t ret = sinkWaitEndTest_->GetStateType();
804     EXPECT_EQ(ret, DSCHED_CONTINUE_SINK_WAIT_END_STATE);
805     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkGetStateType001 end" << std::endl;
806 }
807 
808 
809  /**
810  * @tc.name: SinkDoNotifyCompleteTask001
811  * @tc.desc: DoNotifyCompleteTask
812  * @tc.type: FUNC
813  */
814 HWTEST_F(DSchedContinueSinkWaitEndStateTest, SinkDoNotifyCompleteTask001, TestSize.Level3)
815 {
816     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkDoNotifyCompleteTask001 begin" << std::endl;
817     ASSERT_NE(sinkWaitEndTest_, nullptr);
818     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
819     ASSERT_NE(event, nullptr);
820     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391202(AppExecFwk::InnerEvent *event) 821     auto destructor = [](AppExecFwk::InnerEvent *event) {
822         if (event != nullptr) {
823             delete event;
824         }
825     };
826     int32_t ret = sinkWaitEndTest_->DoNotifyCompleteTask(nullptr,
827         AppExecFwk::InnerEvent::Pointer(event, destructor));
828     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
829     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkDoNotifyCompleteTask001 end" << std::endl;
830 }
831 
832  /**
833  * @tc.name: SinkDoContinueEndTask001
834  * @tc.desc: DoContinueEndTask
835  * @tc.type: FUNC
836  */
837 HWTEST_F(DSchedContinueSinkWaitEndStateTest, SinkDoContinueEndTask001, TestSize.Level3)
838 {
839     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkDoContinueEndTask001 begin" << std::endl;
840     ASSERT_NE(sinkWaitEndTest_, nullptr);
841     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
842     ASSERT_NE(event, nullptr);
843     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391302(AppExecFwk::InnerEvent *event) 844     auto destructor = [](AppExecFwk::InnerEvent *event) {
845         if (event != nullptr) {
846             delete event;
847         }
848     };
849     int32_t ret = sinkWaitEndTest_->DoContinueEndTask(nullptr,
850         AppExecFwk::InnerEvent::Pointer(event, destructor));
851     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
852     DTEST_LOG << "DSchedContinueSinkWaitEndStateTest SinkDoContinueEndTask001 end" << std::endl;
853 }
854 
855  /**
856  * @tc.name: SrcExecuteTest001
857  * @tc.desc: Execute
858  * @tc.type: FUNC
859  */
860 HWTEST_F(DSchedContinueAbilityStateTest, SrcExecuteTest001, TestSize.Level3)
861 {
862     DTEST_LOG << "DSchedContinueAbilityStateTest SrcExecuteTest001 begin" << std::endl;
863     ASSERT_NE(abilityStateTest_, nullptr);
864     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
865     ASSERT_NE(event, nullptr);
866     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391402(AppExecFwk::InnerEvent *event) 867     auto destructor = [](AppExecFwk::InnerEvent *event) {
868         if (event != nullptr) {
869             delete event;
870         }
871     };
872     int32_t ret = abilityStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
873     EXPECT_EQ(ret, CONTINUE_STATE_MACHINE_INVALID_STATE);
874     DTEST_LOG << "DSchedContinueAbilityStateTest SrcExecuteTest001 end" << std::endl;
875 }
876 
877  /**
878  * @tc.name: SrcExecuteTest002
879  * @tc.desc: Execute
880  * @tc.type: FUNC
881  */
882 HWTEST_F(DSchedContinueAbilityStateTest, SrcExecuteTest002, TestSize.Level3)
883 {
884     DTEST_LOG << "DSchedContinueAbilityStateTest SrcExecuteTest002 begin" << std::endl;
885     ASSERT_NE(abilityStateTest_, nullptr);
886     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
887     ASSERT_NE(event, nullptr);
888     event->innerEventId_ = static_cast<uint32_t>(DSHCED_CONTINUE_SEND_DATA_EVENT);
__anon0d8557391502(AppExecFwk::InnerEvent *event) 889     auto destructor = [](AppExecFwk::InnerEvent *event) {
890         if (event != nullptr) {
891             delete event;
892         }
893     };
894     int32_t ret = abilityStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
895     EXPECT_NE(ret, ERR_OK);
896     DTEST_LOG << "DSchedContinueAbilityStateTest SrcExecuteTest002 end" << std::endl;
897 }
898 
899  /**
900  * @tc.name: SrcGetStateType001
901  * @tc.desc: GetStateType
902  * @tc.type: FUNC
903  */
904 HWTEST_F(DSchedContinueAbilityStateTest, SrcGetStateType001, TestSize.Level3)
905 {
906     DTEST_LOG << "DSchedContinueAbilityStateTest SrcGetStateType001 begin" << std::endl;
907     ASSERT_NE(abilityStateTest_, nullptr);
908     int32_t ret = abilityStateTest_->GetStateType();
909     EXPECT_EQ(ret, DSCHED_CONTINUE_ABILITY_STATE);
910     DTEST_LOG << "DSchedContinueAbilityStateTest SrcGetStateType001 end" << std::endl;
911 }
912 
913  /**
914  * @tc.name: SrcDoContinueSendTask001
915  * @tc.desc: DoContinueSendTask
916  * @tc.type: FUNC
917  */
918 HWTEST_F(DSchedContinueAbilityStateTest, SrcDoContinueSendTask001, TestSize.Level3)
919 {
920     DTEST_LOG << "DSchedContinueAbilityStateTest SrcDoContinueSendTask001 begin" << std::endl;
921     ASSERT_NE(abilityStateTest_, nullptr);
922     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
923     ASSERT_NE(event, nullptr);
924     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391602(AppExecFwk::InnerEvent *event) 925     auto destructor = [](AppExecFwk::InnerEvent *event) {
926         if (event != nullptr) {
927             delete event;
928         }
929     };
930     int32_t ret = abilityStateTest_->DoContinueSendTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
931     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
932     DTEST_LOG << "DSchedContinueAbilityStateTest SrcDoContinueSendTask001 end" << std::endl;
933 }
934 
935  /**
936  * @tc.name: SrcDoContinueEndTask001
937  * @tc.desc: DoContinueEndTask
938  * @tc.type: FUNC
939  */
940 HWTEST_F(DSchedContinueAbilityStateTest, SrcDoContinueEndTask001, TestSize.Level3)
941 {
942     DTEST_LOG << "DSchedContinueAbilityStateTest SrcDoContinueEndTask001 begin" << std::endl;
943     ASSERT_NE(abilityStateTest_, nullptr);
944     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
945     ASSERT_NE(event, nullptr);
946     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391702(AppExecFwk::InnerEvent *event) 947     auto destructor = [](AppExecFwk::InnerEvent *event) {
948         if (event != nullptr) {
949             delete event;
950         }
951     };
952     int32_t ret = abilityStateTest_->DoContinueEndTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
953     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
954     DTEST_LOG << "DSchedContinueAbilityStateTest SrcDoContinueEndTask001 end" << std::endl;
955 }
956 
957  /**
958  * @tc.name: SrcDoContinueErrorTask001
959  * @tc.desc: DoContinueErrorTask
960  * @tc.type: FUNC
961  */
962 HWTEST_F(DSchedContinueAbilityStateTest, SrcDoContinueErrorTask001, TestSize.Level3)
963 {
964     DTEST_LOG << "DSchedContinueAbilityStateTest SrcDoContinueErrorTask001 begin" << std::endl;
965     ASSERT_NE(abilityStateTest_, nullptr);
966     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
967     ASSERT_NE(event, nullptr);
968     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391802(AppExecFwk::InnerEvent *event) 969     auto destructor = [](AppExecFwk::InnerEvent *event) {
970         if (event != nullptr) {
971             delete event;
972         }
973     };
974     int32_t ret = abilityStateTest_->DoContinueErrorTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
975     EXPECT_NE(ret, ERR_OK);
976     DTEST_LOG << "DSchedContinueAbilityStateTest SrcDoContinueErrorTask001 end" << std::endl;
977 }
978 
979  /**
980  * @tc.name: SrcExecuteTest001
981  * @tc.desc: Execute
982  * @tc.type: FUNC
983  */
984 HWTEST_F(DSchedContinueEndStateTest, SrcExecuteTest001, TestSize.Level3)
985 {
986     DTEST_LOG << "DSchedContinueEndStateTest SrcExecuteTest001 begin" << std::endl;
987     ASSERT_NE(srcEndStateTest_, nullptr);
988     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
989     ASSERT_NE(event, nullptr);
990     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391902(AppExecFwk::InnerEvent *event) 991     auto destructor = [](AppExecFwk::InnerEvent *event) {
992         if (event != nullptr) {
993             delete event;
994         }
995     };
996     int32_t ret = srcEndStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
997     EXPECT_EQ(ret, CONTINUE_STATE_MACHINE_INVALID_STATE);
998     DTEST_LOG << "DSchedContinueEndStateTest SrcExecuteTest001 end" << std::endl;
999 }
1000 
1001  /**
1002  * @tc.name: SrcExecuteTest002
1003  * @tc.desc: Execute
1004  * @tc.type: FUNC
1005  */
1006 HWTEST_F(DSchedContinueEndStateTest, SrcExecuteTest002, TestSize.Level3)
1007 {
1008     DTEST_LOG << "DSchedContinueEndStateTest SrcExecuteTest002 begin" << std::endl;
1009     ASSERT_NE(srcEndStateTest_, nullptr);
1010     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1011     ASSERT_NE(event, nullptr);
1012     event->innerEventId_ = static_cast<uint32_t>(DSCHED_CONTINUE_END_EVENT);
__anon0d8557391a02(AppExecFwk::InnerEvent *event) 1013     auto destructor = [](AppExecFwk::InnerEvent *event) {
1014         if (event != nullptr) {
1015             delete event;
1016         }
1017     };
1018     int32_t ret = srcEndStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
1019     EXPECT_NE(ret, ERR_OK);
1020     DTEST_LOG << "DSchedContinueEndStateTest SrcExecuteTest002 end" << std::endl;
1021 }
1022 
1023  /**
1024  * @tc.name: SrcGetStateTypeTest001
1025  * @tc.desc: GetStateTypeTest
1026  * @tc.type: FUNC
1027  */
1028 HWTEST_F(DSchedContinueEndStateTest, SrcGetStateTypeTest001, TestSize.Level3)
1029 {
1030     DTEST_LOG << "DSchedContinueEndStateTest SrcGetStateTypeTest001 begin" << std::endl;
1031     ASSERT_NE(srcEndStateTest_, nullptr);
1032     int32_t ret = srcEndStateTest_->GetStateType();
1033     EXPECT_EQ(ret, DSCHED_CONTINUE_SOURCE_END_STATE);
1034     DTEST_LOG << "DSchedContinueEndStateTest SrcGetStateTypeTest001 end" << std::endl;
1035 }
1036 
1037  /**
1038  * @tc.name: SrcDoContinueEndTaskTest001
1039  * @tc.desc: DoContinueEndTask
1040  * @tc.type: FUNC
1041  */
1042 HWTEST_F(DSchedContinueEndStateTest, SrcDoContinueEndTaskTest001, TestSize.Level3)
1043 {
1044     DTEST_LOG << "DSchedContinueEndStateTest SrcDoContinueEndTaskTest001 begin" << std::endl;
1045     ASSERT_NE(srcEndStateTest_, nullptr);
1046     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1047     ASSERT_NE(event, nullptr);
1048     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391b02(AppExecFwk::InnerEvent *event) 1049     auto destructor = [](AppExecFwk::InnerEvent *event) {
1050         if (event != nullptr) {
1051             delete event;
1052         }
1053     };
1054     int32_t ret = srcEndStateTest_->DoContinueEndTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
1055     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1056     DTEST_LOG << "DSchedContinueEndStateTest SrcDoContinueEndTaskTest001 end" << std::endl;
1057 }
1058 
1059  /**
1060  * @tc.name: SrcExecuteTest_001
1061  * @tc.desc: Execute
1062  * @tc.type: FUNC
1063  */
1064 HWTEST_F(DSchedContinueSourceStartStateTest, SrcExecuteTest_001, TestSize.Level3)
1065 {
1066     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcExecuteTest_001 begin" << std::endl;
1067     ASSERT_NE(srcStartStateTest_, nullptr);
1068     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1069     ASSERT_NE(event, nullptr);
1070     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391c02(AppExecFwk::InnerEvent *event) 1071     auto destructor = [](AppExecFwk::InnerEvent *event) {
1072         if (event != nullptr) {
1073             delete event;
1074         }
1075     };
1076     int32_t ret = srcStartStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
1077     EXPECT_EQ(ret, CONTINUE_STATE_MACHINE_INVALID_STATE);
1078     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcExecuteTest_001 end" << std::endl;
1079 }
1080 
1081  /**
1082  * @tc.name: SrcExecuteTest_002
1083  * @tc.desc: Execute
1084  * @tc.type: FUNC
1085  */
1086 HWTEST_F(DSchedContinueSourceStartStateTest, SrcExecuteTest_002, TestSize.Level3)
1087 {
1088     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcExecuteTest_002 begin" << std::endl;
1089     ASSERT_NE(srcStartStateTest_, nullptr);
1090     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1091     ASSERT_NE(event, nullptr);
1092     event->innerEventId_ = static_cast<uint32_t>(DSHCED_CONTINUE_REQ_PUSH_EVENT);
__anon0d8557391d02(AppExecFwk::InnerEvent *event) 1093     auto destructor = [](AppExecFwk::InnerEvent *event) {
1094         if (event != nullptr) {
1095             delete event;
1096         }
1097     };
1098     int32_t ret = srcStartStateTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
1099     EXPECT_NE(ret, ERR_OK);
1100     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcExecuteTest_002 end" << std::endl;
1101 }
1102 
1103  /**
1104  * @tc.name: SrcGetStateTypeTest_001
1105  * @tc.desc: GetStateType
1106  * @tc.type: FUNC
1107  */
1108 HWTEST_F(DSchedContinueSourceStartStateTest, SrcGetStateTypeTest_001, TestSize.Level3)
1109 {
1110     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcGetStateTypeTest_001 begin" << std::endl;
1111     ASSERT_NE(srcStartStateTest_, nullptr);
1112     int32_t ret = srcStartStateTest_->GetStateType();
1113     EXPECT_EQ(ret, DSCHED_CONTINUE_SOURCE_START_STATE);
1114     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcGetStateTypeTest_001 end" << std::endl;
1115 }
1116 
1117  /**
1118  * @tc.name: SrcDoContinuePushReqTaskTest_001
1119  * @tc.desc: DoContinuePushReqTask
1120  * @tc.type: FUNC
1121  */
1122 HWTEST_F(DSchedContinueSourceStartStateTest, SrcDoContinuePushReqTaskTest_001, TestSize.Level3)
1123 {
1124     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcDoContinuePushReqTaskTest_001 begin" << std::endl;
1125     ASSERT_NE(srcStartStateTest_, nullptr);
1126     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1127     ASSERT_NE(event, nullptr);
1128     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391e02(AppExecFwk::InnerEvent *event) 1129     auto destructor = [](AppExecFwk::InnerEvent *event) {
1130         if (event != nullptr) {
1131             delete event;
1132         }
1133     };
1134     int32_t ret = srcStartStateTest_->DoContinuePushReqTask(nullptr,
1135         AppExecFwk::InnerEvent::Pointer(event, destructor));
1136     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1137     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcDoContinuePushReqTaskTest_001 end" << std::endl;
1138 }
1139 
1140  /**
1141  * @tc.name: SrcDoContinueAbilityTaskTest_001
1142  * @tc.desc: DoContinueAbilityTask
1143  * @tc.type: FUNC
1144  */
1145 HWTEST_F(DSchedContinueSourceStartStateTest, SrcDoContinueAbilityTaskTest_001, TestSize.Level3)
1146 {
1147     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcDoContinueAbilityTaskTest_001 begin" << std::endl;
1148     ASSERT_NE(srcStartStateTest_, nullptr);
1149     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1150     ASSERT_NE(event, nullptr);
1151     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557391f02(AppExecFwk::InnerEvent *event) 1152     auto destructor = [](AppExecFwk::InnerEvent *event) {
1153         if (event != nullptr) {
1154             delete event;
1155         }
1156     };
1157     int32_t ret = srcStartStateTest_->DoContinueAbilityTask(nullptr,
1158         AppExecFwk::InnerEvent::Pointer(event, destructor));
1159     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1160     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcDoContinueAbilityTaskTest_001 end" << std::endl;
1161 }
1162 
1163  /**
1164  * @tc.name: SrcDoContinueEndTaskTest_001
1165  * @tc.desc: DoContinueEndTask
1166  * @tc.type: FUNC
1167  */
1168 HWTEST_F(DSchedContinueSourceStartStateTest, SrcDoContinueEndTaskTest_001, TestSize.Level3)
1169 {
1170     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcDoContinueEndTaskTest_001 begin" << std::endl;
1171     ASSERT_NE(srcStartStateTest_, nullptr);
1172     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1173     ASSERT_NE(event, nullptr);
1174     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557392002(AppExecFwk::InnerEvent *event) 1175     auto destructor = [](AppExecFwk::InnerEvent *event) {
1176         if (event != nullptr) {
1177             delete event;
1178         }
1179     };
1180     int32_t ret = srcStartStateTest_->DoContinueEndTask(nullptr,
1181         AppExecFwk::InnerEvent::Pointer(event, destructor));
1182     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1183     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcDoContinueEndTaskTest_001 end" << std::endl;
1184 }
1185 
1186  /**
1187  * @tc.name: SrcDoContinueErrorTask001
1188  * @tc.desc: DoContinueErrorTask
1189  * @tc.type: FUNC
1190  */
1191 HWTEST_F(DSchedContinueSourceStartStateTest, SrcDoContinueErrorTask001, TestSize.Level3)
1192 {
1193     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcDoContinueErrorTask001 begin" << std::endl;
1194     ASSERT_NE(srcStartStateTest_, nullptr);
1195     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1196     ASSERT_NE(event, nullptr);
1197     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557392102(AppExecFwk::InnerEvent *event) 1198     auto destructor = [](AppExecFwk::InnerEvent *event) {
1199         if (event != nullptr) {
1200             delete event;
1201         }
1202     };
1203     int32_t ret = srcStartStateTest_->DoContinueErrorTask(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
1204     EXPECT_NE(ret, ERR_OK);
1205     DTEST_LOG << "DSchedContinueSourceStartStateTest SrcDoContinueErrorTask001 end" << std::endl;
1206 }
1207 
1208  /**
1209  * @tc.name: SrcExecute_001
1210  * @tc.desc: Execute
1211  * @tc.type: FUNC
1212  */
1213 HWTEST_F(DSchedContinueWaitEndStateTest, SrcExecute_001, TestSize.Level3)
1214 {
1215     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcExecute_001 begin" << std::endl;
1216     ASSERT_NE(srcWaitEndTest_, nullptr);
1217     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1218     ASSERT_NE(event, nullptr);
1219     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557392202(AppExecFwk::InnerEvent *event) 1220     auto destructor = [](AppExecFwk::InnerEvent *event) {
1221         if (event != nullptr) {
1222             delete event;
1223         }
1224     };
1225     int32_t ret = srcWaitEndTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
1226     EXPECT_EQ(ret, CONTINUE_STATE_MACHINE_INVALID_STATE);
1227     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcExecute_001 end" << std::endl;
1228 }
1229 
1230  /**
1231  * @tc.name: SrcExecute_002
1232  * @tc.desc: Execute
1233  * @tc.type: FUNC
1234  */
1235 HWTEST_F(DSchedContinueWaitEndStateTest, SrcExecute_002, TestSize.Level3)
1236 {
1237     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcExecute_002 begin" << std::endl;
1238     ASSERT_NE(srcWaitEndTest_, nullptr);
1239     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1240     ASSERT_NE(event, nullptr);
1241     event->innerEventId_ = static_cast<uint32_t>(DSCHED_CONTINUE_COMPLETE_EVENT);
__anon0d8557392302(AppExecFwk::InnerEvent *event) 1242     auto destructor = [](AppExecFwk::InnerEvent *event) {
1243         if (event != nullptr) {
1244             delete event;
1245         }
1246     };
1247     int32_t ret = srcWaitEndTest_->Execute(nullptr, AppExecFwk::InnerEvent::Pointer(event, destructor));
1248     EXPECT_NE(ret, ERR_OK);
1249     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcExecute_002 end" << std::endl;
1250 }
1251 
1252  /**
1253  * @tc.name: SrcGetStateType_001
1254  * @tc.desc: GetStateType
1255  * @tc.type: FUNC
1256  */
1257 HWTEST_F(DSchedContinueWaitEndStateTest, SrcGetStateType_001, TestSize.Level3)
1258 {
1259     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcGetStateType_001 begin" << std::endl;
1260     ASSERT_NE(srcWaitEndTest_, nullptr);
1261     int32_t ret = srcWaitEndTest_->GetStateType();
1262     EXPECT_EQ(ret, DSCHED_CONTINUE_SOURCE_WAIT_END_STATE);
1263     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcGetStateType_001 end" << std::endl;
1264 }
1265 
1266  /**
1267  * @tc.name: SrcDoNotifyCompleteTask_001
1268  * @tc.desc: DoNotifyCompleteTask
1269  * @tc.type: FUNC
1270  */
1271 HWTEST_F(DSchedContinueWaitEndStateTest, SrcDoNotifyCompleteTask_001, TestSize.Level3)
1272 {
1273     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcDoNotifyCompleteTask_001 begin" << std::endl;
1274     ASSERT_NE(srcWaitEndTest_, nullptr);
1275     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1276     ASSERT_NE(event, nullptr);
1277     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557392402(AppExecFwk::InnerEvent *event) 1278     auto destructor = [](AppExecFwk::InnerEvent *event) {
1279         if (event != nullptr) {
1280             delete event;
1281         }
1282     };
1283     int32_t ret = srcWaitEndTest_->DoNotifyCompleteTask(nullptr,
1284         AppExecFwk::InnerEvent::Pointer(event, destructor));
1285     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1286     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcDoNotifyCompleteTask_001 end" << std::endl;
1287 }
1288 
1289  /**
1290  * @tc.name: SrcDoContinueEndTask_001
1291  * @tc.desc: DoContinueEndTask
1292  * @tc.type: FUNC
1293  */
1294 HWTEST_F(DSchedContinueWaitEndStateTest, SrcDoContinueEndTask_001, TestSize.Level3)
1295 {
1296     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcDoContinueEndTask_001 begin" << std::endl;
1297     ASSERT_NE(srcWaitEndTest_, nullptr);
1298     AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
1299     ASSERT_NE(event, nullptr);
1300     event->innerEventId_ = static_cast<uint32_t>(-1);
__anon0d8557392502(AppExecFwk::InnerEvent *event) 1301     auto destructor = [](AppExecFwk::InnerEvent *event) {
1302         if (event != nullptr) {
1303             delete event;
1304         }
1305     };
1306     int32_t ret = srcWaitEndTest_->DoContinueEndTask(nullptr,
1307         AppExecFwk::InnerEvent::Pointer(event, destructor));
1308     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1309     DTEST_LOG << "DSchedContinueWaitEndStateTest SrcDoContinueEndTask_001 end" << std::endl;
1310 }
1311 
1312 
1313  /**
1314  * @tc.name: Execute_001
1315  * @tc.desc: Execute
1316  * @tc.type: FUNC
1317  */
1318 HWTEST_F(DSchedContinueStateMachineTest, Execute_001, TestSize.Level3)
1319 {
1320     DTEST_LOG << "DSchedContinueStateMachineTest Execute_001 begin" << std::endl;
1321     ASSERT_NE(stateMachineTest_, nullptr);
1322     AppExecFwk::InnerEvent *event = nullptr;
__anon0d8557392602(AppExecFwk::InnerEvent *event) 1323     auto destructor = [](AppExecFwk::InnerEvent *event) {
1324         if (event != nullptr) {
1325             delete event;
1326         }
1327     };
1328     stateMachineTest_->currentState_ = nullptr;
1329     int32_t ret = stateMachineTest_->Execute(AppExecFwk::InnerEvent::Pointer(event, destructor));
1330     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1331     DTEST_LOG << "DSchedContinueStateMachineTest Execute_001 end" << std::endl;
1332 }
1333 
1334  /**
1335  * @tc.name: UpdateState_001
1336  * @tc.desc: UpdateState
1337  * @tc.type: FUNC
1338  */
1339 HWTEST_F(DSchedContinueStateMachineTest, UpdateState_001, TestSize.Level3)
1340 {
1341     DTEST_LOG << "DSchedContinueStateMachineTest UpdateState_001 begin" << std::endl;
1342     ASSERT_NE(stateMachineTest_, nullptr);
1343     DSchedContinueStateType stateType = DSCHED_CONTINUE_SOURCE_START_STATE;
1344     stateMachineTest_->UpdateState(stateType);
1345     EXPECT_NE(stateMachineTest_->currentState_, nullptr);
1346     DTEST_LOG << "DSchedContinueStateMachineTest UpdateState_001 end" << std::endl;
1347 }
1348 
1349  /**
1350  * @tc.name: UpdateState_002
1351  * @tc.desc: UpdateState
1352  * @tc.type: FUNC
1353  */
1354 HWTEST_F(DSchedContinueStateMachineTest, UpdateState_002, TestSize.Level3)
1355 {
1356     DTEST_LOG << "DSchedContinueStateMachineTest UpdateState_002 begin" << std::endl;
1357     ASSERT_NE(stateMachineTest_, nullptr);
1358     DSchedContinueStateType stateType = DSCHED_CONTINUE_ABILITY_STATE;
1359     stateMachineTest_->currentState_ = stateMachineTest_->CreateState(stateType);
1360     stateMachineTest_->UpdateState(stateType);
1361     EXPECT_NE(stateMachineTest_->currentState_, nullptr);
1362     DTEST_LOG << "DSchedContinueStateMachineTest UpdateState_002 end" << std::endl;
1363 }
1364 
1365  /**
1366  * @tc.name: CreateState_001
1367  * @tc.desc: CreateState
1368  * @tc.type: FUNC
1369  */
1370 HWTEST_F(DSchedContinueStateMachineTest, CreateState_001, TestSize.Level3)
1371 {
1372     DTEST_LOG << "DSchedContinueStateMachineTest CreateState_001 begin" << std::endl;
1373     ASSERT_NE(stateMachineTest_, nullptr);
1374     std::shared_ptr<DSchedContinueState> state = stateMachineTest_->CreateState(DSCHED_CONTINUE_SOURCE_START_STATE);
1375     EXPECT_TRUE(state != nullptr);
1376 
1377     state = stateMachineTest_->CreateState(DSCHED_CONTINUE_ABILITY_STATE);
1378     EXPECT_TRUE(state != nullptr);
1379 
1380     state = stateMachineTest_->CreateState(DSCHED_CONTINUE_SOURCE_WAIT_END_STATE);
1381     EXPECT_TRUE(state != nullptr);
1382 
1383     state = stateMachineTest_->CreateState(DSCHED_CONTINUE_SOURCE_END_STATE);
1384     EXPECT_TRUE(state != nullptr);
1385 
1386     state = stateMachineTest_->CreateState(DSCHED_CONTINUE_SINK_START_STATE);
1387     EXPECT_TRUE(state != nullptr);
1388 
1389     state = stateMachineTest_->CreateState(DSCHED_CONTINUE_DATA_STATE);
1390     EXPECT_TRUE(state != nullptr);
1391 
1392     state = stateMachineTest_->CreateState(DSCHED_CONTINUE_SINK_WAIT_END_STATE);
1393     EXPECT_TRUE(state != nullptr);
1394 
1395     state = stateMachineTest_->CreateState(DSCHED_CONTINUE_SINK_END_STATE);
1396     EXPECT_TRUE(state != nullptr);
1397 
1398     state = stateMachineTest_->CreateState(static_cast<DSchedContinueStateType>(-1));
1399     EXPECT_TRUE(state == nullptr);
1400     DTEST_LOG << "DSchedContinueStateMachineTest CreateState_001 end" << std::endl;
1401 }
1402 
1403  /**
1404  * @tc.name: GetStateType_001
1405  * @tc.desc: GetStateType
1406  * @tc.type: FUNC
1407  */
1408 HWTEST_F(DSchedContinueStateMachineTest, GetStateType_001, TestSize.Level3)
1409 {
1410     DTEST_LOG << "DSchedContinueStateMachineTest GetStateType_001 begin" << std::endl;
1411     ASSERT_NE(stateMachineTest_, nullptr);
1412     stateMachineTest_->currentState_ = nullptr;
1413     DSchedContinueStateType ret = stateMachineTest_->GetStateType();
1414     EXPECT_EQ(ret, DSCHED_CONTINUE_SOURCE_START_STATE);
1415     DTEST_LOG << "DSchedContinueStateMachineTest GetStateType_001 end" << std::endl;
1416 }
1417 }
1418 }