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_test.h"
17 
18 #include "distributed_sched_service.h"
19 #include "dsched_continue.h"
20 #include "dtbschedmgr_log.h"
21 #include "test_log.h"
22 
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace DistributedSchedule {
28 
29 namespace {
30     const std::string BASEDIR = "/data/service/el1/public/database/DistributedSchedule";
31     const int32_t WAITTIME = 2000;
32     const uint32_t DSCHED_BUFFER_SIZE = 1024;
33 }
SetUpTestCase()34 void DSchedContinueTest::SetUpTestCase()
35 {
36     mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
37     DTEST_LOG << "DSchedContinueTest::SetUpTestCase" << std::endl;
38     DistributedSchedService::GetInstance().Init();
39 }
40 
TearDownTestCase()41 void DSchedContinueTest::TearDownTestCase()
42 {
43     (void)remove(BASEDIR.c_str());
44     DTEST_LOG << "DSchedContinueTest::TearDownTestCase" << std::endl;
45 }
46 
TearDown()47 void DSchedContinueTest::TearDown()
48 {
49     usleep(WAITTIME);
50     DTEST_LOG << "DSchedContinueTest::TearDown" << std::endl;
51 }
52 
SetUp()53 void DSchedContinueTest::SetUp()
54 {
55     usleep(WAITTIME);
56     DTEST_LOG << "DSchedContinueTest::SetUp" << std::endl;
57 }
58 
59 /**
60  * @tc.name: DSchedContinueTest_001_1
61  * @tc.desc: OnContinueMission and PostStartTask
62  * @tc.type: FUNC
63  */
64 HWTEST_F(DSchedContinueTest, DSchedContinueTest_001_1, TestSize.Level0)
65 {
66     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_001_1 begin" << std::endl;
67     std::string deviceId = "123";
68     std::string bundleName = "test";
69     int32_t subType = CONTINUE_PULL;
70     int32_t direction = CONTINUE_SINK;
71     sptr<IRemoteObject> callback = nullptr;
72     OHOS::AAFwk::WantParams wantParams;
73     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
74     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
75 
76     // eventHandler_ is null
77     int32_t ret = conti->OnContinueMission(wantParams);
78     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
79 
80     ret = conti->PostStartTask(wantParams);
81     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
82 
83     // eventHandler_ not null
84     conti->Init();
85     ret = conti->PostStartTask(wantParams);
86     EXPECT_EQ(ret, ERR_OK);
87     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_001_1 end ret:" << ret << std::endl;
88     usleep(WAITTIME);
89 }
90 
91 /**
92  * @tc.name: DSchedContinueTest_002_1
93  * @tc.desc: OnStartCmd and PostCotinueAbilityTask
94  * @tc.type: FUNC
95  */
96 HWTEST_F(DSchedContinueTest, DSchedContinueTest_002_1, TestSize.Level0)
97 {
98     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_002_1 begin" << std::endl;
99     std::string deviceId = "123";
100     std::string bundleName = "test";
101     int32_t subType = CONTINUE_PULL;
102     int32_t direction = CONTINUE_SINK;
103     sptr<IRemoteObject> callback = nullptr;
104     int32_t appVersion = 0;
105     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
106     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
107 
108     // eventHandler_ is null
109     int32_t ret = conti->OnStartCmd(appVersion);
110     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
111 
112     ret = conti->PostCotinueAbilityTask(appVersion);
113     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
114 
115     // eventHandler_ not null
116     conti->Init();
117     ret = conti->PostCotinueAbilityTask(appVersion);
118     EXPECT_EQ(ret, ERR_OK);
119     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_002_1 end ret:" << ret << std::endl;
120     usleep(WAITTIME);
121 }
122 
123 /**
124  * @tc.name: DSchedContinueTest_003
125  * @tc.desc: OnReplyCmd and PostReplyTask
126  * @tc.type: FUNC
127  */
128 HWTEST_F(DSchedContinueTest, DSchedContinueTest_003_1, TestSize.Level0)
129 {
130     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_003_1 begin" << std::endl;
131     std::string deviceId = "123";
132     std::string bundleName = "test";
133     int32_t subType = CONTINUE_PULL;
134     int32_t direction = CONTINUE_SINK;
135     sptr<IRemoteObject> callback = nullptr;
136     auto cmd = std::make_shared<DSchedContinueReplyCmd>();
137     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
138     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
139 
140     // eventHandler_ is null
141     cmd->replyCmd_ = DSCHED_CONTINUE_CMD_START;
142     int32_t ret = conti->OnReplyCmd(cmd);
143     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
144 
145     ret = conti->PostReplyTask(cmd);
146     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
147 
148     // eventHandler_ not null
149     conti->Init();
150 
151     cmd->replyCmd_ = DSCHED_CONTINUE_END_EVENT;
152     ret = conti->OnReplyCmd(cmd);
153     EXPECT_EQ(ret, ERR_OK);
154 
155     ret = conti->PostReplyTask(cmd);
156     EXPECT_EQ(ret, ERR_OK);
157 
158     cmd->replyCmd_ = DSCHED_CONTINUE_INVALID_EVENT;
159     ret = conti->PostReplyTask(cmd);
160     EXPECT_EQ(ret, ERR_OK);
161 
162     cmd = nullptr;
163     ret = conti->PostReplyTask(cmd);
164     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
165     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_003_1 end ret:" << ret << std::endl;
166     usleep(WAITTIME);
167 }
168 
169 /**
170  * @tc.name: DSchedContinueTest_004_1
171  * @tc.desc: OnStartContinuation and PostContinueSendTask
172  * @tc.type: FUNC
173  */
174 HWTEST_F(DSchedContinueTest, DSchedContinueTest_004_1, TestSize.Level0)
175 {
176     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_004_1 begin" << std::endl;
177     std::string deviceId = "123";
178     std::string bundleName = "test";
179     int32_t subType = CONTINUE_PULL;
180     int32_t direction = CONTINUE_SINK;
181     sptr<IRemoteObject> callback = nullptr;
182     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
183     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
184 
185     OHOS::AAFwk::Want want;
186     int32_t callerUid = 0;
187     int32_t status = ERR_OK;
188     uint32_t accessToken = 0;
189 
190     // eventHandler_ is null
191     int32_t ret = conti->OnStartContinuation(want, callerUid, status, accessToken);
192     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
193 
194     ret = conti->PostContinueSendTask(want, callerUid, status, accessToken);
195     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
196 
197     // eventHandler_ not null
198     conti->Init();
199 
200     ret = conti->OnStartContinuation(want, callerUid, status, accessToken);
201     EXPECT_EQ(ret, ERR_OK);
202 
203     ret = conti->PostContinueSendTask(want, callerUid, status, accessToken);
204     EXPECT_EQ(ret, ERR_OK);
205 
206     status = ERR_NONE;
207     ret = conti->PostContinueSendTask(want, callerUid, status, accessToken);
208     EXPECT_EQ(ret, ERR_OK);
209     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_004_1 end ret:" << ret << std::endl;
210     usleep(WAITTIME);
211 }
212 
213 /**
214  * @tc.name: DSchedContinueTest_005
215  * @tc.desc: OnContinueDataCmd and PostContinueDataTask
216  * @tc.type: FUNC
217  */
218 HWTEST_F(DSchedContinueTest, DSchedContinueTest_005_1, TestSize.Level0)
219 {
220     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_005_1 begin" << std::endl;
221     std::string deviceId = "123";
222     std::string bundleName = "test";
223     int32_t subType = CONTINUE_PULL;
224     int32_t direction = CONTINUE_SINK;
225     sptr<IRemoteObject> callback = nullptr;
226     auto cmd = std::make_shared<DSchedContinueDataCmd>();
227     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
228     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
229 
230     // eventHandler_ is null
231     int32_t ret = conti->OnContinueDataCmd(cmd);
232     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
233 
234     ret = conti->PostContinueDataTask(cmd);
235     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
236 
237     // eventHandler_ not null
238     conti->Init();
239 
240     ret = conti->OnContinueDataCmd(cmd);
241     EXPECT_EQ(ret, ERR_OK);
242 
243     ret = conti->PostContinueDataTask(cmd);
244     EXPECT_EQ(ret, ERR_OK);
245     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_005_1 end ret:" << ret << std::endl;
246     usleep(WAITTIME);
247 }
248 
249 /**
250  * @tc.name: DSchedContinueTest_006_1
251  * @tc.desc: OnNotifyComplete, OnContinueEndCmd and PostNotifyCompleteTask
252  * @tc.type: FUNC
253  */
254 HWTEST_F(DSchedContinueTest, DSchedContinueTest_006_1, TestSize.Level0)
255 {
256     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_006_1 begin" << std::endl;
257     std::string deviceId = "123";
258     std::string bundleName = "test";
259     int32_t subType = CONTINUE_PULL;
260     int32_t direction = CONTINUE_SINK;
261     sptr<IRemoteObject> callback = nullptr;
262     int32_t missionId = 1;
263     bool isSuccess = true;
264     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
265     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
266 
267     // OnNotifyComplete
268     int32_t ret = conti->OnNotifyComplete(missionId, isSuccess);
269     EXPECT_EQ(ret, ERR_OK);
270 
271     missionId = 0;
272     ret = conti->OnNotifyComplete(missionId, isSuccess);
273     EXPECT_EQ(ret, ERR_OK);
274 
275     isSuccess = false;
276     ret = conti->OnNotifyComplete(missionId, isSuccess);
277     EXPECT_EQ(ret, ERR_OK);
278 
279     // eventHandler_ is null
280     auto cmd = std::make_shared<DSchedContinueEndCmd>();
281     ret = conti->OnContinueEndCmd(cmd);
282     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
283 
284     ret = conti->PostNotifyCompleteTask(ERR_OK);
285     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
286 
287     // eventHandler_ not null
288     conti->Init();
289     ret = conti->PostNotifyCompleteTask(ERR_OK);
290     EXPECT_EQ(ret, ERR_OK);
291 
292     cmd = nullptr;
293     ret = conti->OnContinueEndCmd(cmd);
294     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
295     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_006_1 end ret:" << ret << std::endl;
296     usleep(WAITTIME);
297 }
298 
299 /**
300  * @tc.name: DSchedContinueTest_007_1
301  * @tc.desc: OnContinueEnd and PostContinueEndTask
302  * @tc.type: FUNC
303  */
304 HWTEST_F(DSchedContinueTest, DSchedContinueTest_007_1, TestSize.Level0)
305 {
306     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_007_1 begin" << std::endl;
307     std::string deviceId = "123";
308     std::string bundleName = "test";
309     int32_t subType = CONTINUE_PULL;
310     int32_t direction = CONTINUE_SINK;
311     sptr<IRemoteObject> callback = nullptr;
312     int32_t result = ERR_OK;
313     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
314     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
315 
316     // eventHandler_ is null
317     int32_t ret = conti->OnContinueEnd(result);
318     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
319 
320     ret = conti->PostContinueEndTask(result);
321     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
322 
323     // eventHandler_ not null
324     conti->Init();
325     ret = conti->PostContinueEndTask(result);
326     EXPECT_EQ(ret, ERR_OK);
327     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_007_1 end ret:" << ret << std::endl;
328     usleep(WAITTIME);
329 }
330 
331 /**
332  * @tc.name: DSchedContinueTest_008_1
333  * @tc.desc: ExecuteContinueReq
334  * @tc.type: FUNC
335  */
336 HWTEST_F(DSchedContinueTest, DSchedContinueTest_008_1, TestSize.Level0)
337 {
338     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_008_1 begin" << std::endl;
339     std::string deviceId = "123";
340     std::string bundleName = "test";
341     int32_t subType = CONTINUE_PULL;
342     int32_t direction = CONTINUE_SINK;
343     sptr<IRemoteObject> callback = nullptr;
344     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
345     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
346     conti->Init();
347 
348     auto wantParams = std::make_shared<DistributedWantParams>();
349     int32_t ret = conti->ExecuteContinueReq(wantParams);
350     EXPECT_NE(ret, ERR_OK);
351 
352     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_008_1 end ret:" << ret << std::endl;
353     usleep(WAITTIME);
354 }
355 
356 /**
357  * @tc.name: DSchedContinueTest_009_1
358  * @tc.desc: PackStartCmd
359  * @tc.type: FUNC
360  */
361 HWTEST_F(DSchedContinueTest, DSchedContinueTest_009_1, TestSize.Level0)
362 {
363     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_009_1 begin" << std::endl;
364     std::string deviceId = "123";
365     std::string bundleName = "test";
366     int32_t subType = CONTINUE_PUSH;
367     int32_t direction = CONTINUE_SINK;
368     sptr<IRemoteObject> callback = nullptr;
369     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
370     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
371     conti->Init();
372 
373     auto cmd = std::make_shared<DSchedContinueStartCmd>();
374     auto wantParams = std::make_shared<DistributedWantParams>();
375 
376     int32_t ret = conti->PackStartCmd(cmd, wantParams);
377     EXPECT_EQ(ret, ERR_OK);
378 
379     wantParams = nullptr;
380     ret = conti->PackStartCmd(cmd, wantParams);
381     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
382 
383     wantParams = std::make_shared<DistributedWantParams>();
384     conti->continueInfo_.missionId_ = 0;
385     EXPECT_NE(ret, ERR_OK);
386     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_009_1 end ret:" << ret << std::endl;
387     usleep(WAITTIME);
388 }
389 
390 /**
391  * @tc.name: DSchedContinueTest_0010_1
392  * @tc.desc: ExecuteContinueAbility
393  * @tc.type: FUNC
394  */
395 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0010_1, TestSize.Level0)
396 {
397     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0010_1 begin" << std::endl;
398     std::string deviceId = "123";
399     std::string bundleName = "test";
400     int32_t subType = CONTINUE_PULL;
401     int32_t direction = CONTINUE_SINK;
402     int32_t missionId = 1;
403     sptr<IRemoteObject> callback = nullptr;
404     auto info = DSchedContinueInfo(deviceId, deviceId, missionId);
405     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
406     conti->Init();
407 
408     int32_t appVersion = 0;
409     int32_t ret = conti->ExecuteContinueAbility(appVersion);
410     EXPECT_NE(ret, ERR_OK);
411     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0010_1 end ret:" << ret << std::endl;
412     usleep(WAITTIME);
413 }
414 
415 /**
416  * @tc.name: DSchedContinueTest_0011_1
417  * @tc.desc: GetMissionIdByBundleName
418  * @tc.type: FUNC
419  */
420 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0011_1, TestSize.Level0)
421 {
422     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0011_1 begin" << std::endl;
423     std::string deviceId = "123";
424     int32_t subType = CONTINUE_PULL;
425     int32_t direction = CONTINUE_SINK;
426     int32_t missionId = 1;
427     sptr<IRemoteObject> callback = nullptr;
428     auto info = DSchedContinueInfo(deviceId, deviceId, missionId);
429     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
430     conti->Init();
431 
432     int32_t ret = conti->GetMissionIdByBundleName();
433     EXPECT_EQ(ret, ERR_OK);
434     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0011_1 end ret:" << ret << std::endl;
435     usleep(WAITTIME);
436 }
437 
438 /**
439  * @tc.name: DSchedContinueTest_0012_1
440  * @tc.desc: CheckContinueAbilityPermission
441  * @tc.type: FUNC
442  */
443 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0012_1, TestSize.Level0)
444 {
445     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0012_1 begin" << std::endl;
446     std::string deviceId = "123";
447     std::string bundleName = "test";
448     int32_t subType = CONTINUE_PULL;
449     int32_t direction = CONTINUE_SINK;
450     sptr<IRemoteObject> callback = nullptr;
451     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
452     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
453     conti->Init();
454 
455     int32_t ret = conti->CheckContinueAbilityPermission();
456     EXPECT_EQ(ret, NO_MISSION_INFO_FOR_MISSION_ID);
457     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0012_1 end ret:" << ret << std::endl;
458     usleep(WAITTIME);
459 }
460 
461 /**
462  * @tc.name: DSchedContinueTest_0013_1
463  * @tc.desc: ExecuteContinueReply
464  * @tc.type: FUNC
465  */
466 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0013_1, TestSize.Level0)
467 {
468     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0013_1 begin" << std::endl;
469     std::string deviceId = "123";
470     std::string bundleName = "test";
471     int32_t subType = CONTINUE_PULL;
472     int32_t direction = CONTINUE_SINK;
473     sptr<IRemoteObject> callback = nullptr;
474     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
475     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
476     conti->Init();
477 
478     int32_t ret = conti->ExecuteContinueReply();
479     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
480     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0013_1 end ret:" << ret << std::endl;
481     usleep(WAITTIME);
482 }
483 
484 /**
485  * @tc.name: DSchedContinueTest_0014_1
486  * @tc.desc: ExecuteContinueSend
487  * @tc.type: FUNC
488  */
489 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0014_1, TestSize.Level0)
490 {
491     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0014_1 begin" << std::endl;
492     std::string deviceId = "123";
493     std::string bundleName = "test";
494     int32_t subType = CONTINUE_PULL;
495     int32_t direction = CONTINUE_SINK;
496     sptr<IRemoteObject> callback = nullptr;
497     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
498     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
499     conti->Init();
500 
501     auto data = std::make_shared<ContinueAbilityData>();
502     int32_t ret = conti->ExecuteContinueSend(data);
503     EXPECT_EQ(ret, INVALID_REMOTE_PARAMETERS_ERR);
504 
505     data = nullptr;
506     ret = conti->ExecuteContinueSend(data);
507     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
508     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0014_1 end ret:" << ret << std::endl;
509     usleep(WAITTIME);
510 }
511 
512 /**
513  * @tc.name: DSchedContinueTest_0015_1
514  * @tc.desc: SetWantForContinuation
515  * @tc.type: FUNC
516  */
517 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0015_1, TestSize.Level0)
518 {
519     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0015_1 begin" << std::endl;
520     std::string deviceId = "123";
521     std::string bundleName = "test";
522     int32_t subType = CONTINUE_PULL;
523     int32_t direction = CONTINUE_SINK;
524     sptr<IRemoteObject> callback = nullptr;
525     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
526     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
527     conti->Init();
528 
529     AAFwk::Want want;
530     int32_t ret = conti->SetWantForContinuation(want);
531     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
532     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0015_1 end ret:" << ret << std::endl;
533     usleep(WAITTIME);
534 }
535 
536 /**
537  * @tc.name: DSchedContinueTest_0016_1
538  * @tc.desc: PackDataCmd
539  * @tc.type: FUNC
540  */
541 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0016_1, TestSize.Level0)
542 {
543     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0016_1 begin" << std::endl;
544     std::string deviceId = "123";
545     std::string bundleName = "test";
546     int32_t subType = CONTINUE_PULL;
547     int32_t direction = CONTINUE_SINK;
548     sptr<IRemoteObject> callback = nullptr;
549     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
550     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
551     conti->Init();
552 
553     auto cmd = std::make_shared<DSchedContinueDataCmd>();
554     OHOS::AAFwk::Want want;
555     AppExecFwk::AbilityInfo abilityInfo;
556     CallerInfo callerInfo;
557     AccountInfo accountInfo;
558 
559     int32_t ret = conti->PackDataCmd(cmd, want, abilityInfo, callerInfo, accountInfo);
560     EXPECT_EQ(ret, ERR_OK);
561 
562     cmd = nullptr;
563     ret = conti->PackDataCmd(cmd, want, abilityInfo, callerInfo, accountInfo);
564     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
565     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0016_1 end ret:" << ret << std::endl;
566     usleep(WAITTIME);
567 }
568 
569 /**
570  * @tc.name: DSchedContinueTest_0017_1
571  * @tc.desc: ExecuteContinueData
572  * @tc.type: FUNC
573  */
574 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0017_1, TestSize.Level0)
575 {
576     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0017_1 begin" << std::endl;
577     std::string deviceId = "123";
578     std::string bundleName = "test";
579     int32_t subType = CONTINUE_PULL;
580     int32_t direction = CONTINUE_SINK;
581     sptr<IRemoteObject> callback = nullptr;
582     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
583     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
584     conti->Init();
585 
586     auto cmd = std::make_shared<DSchedContinueDataCmd>();
587 
588     int32_t ret = conti->ExecuteContinueData(cmd);
589     EXPECT_EQ(ret, INVALID_REMOTE_PARAMETERS_ERR);
590 
591     cmd = nullptr;
592     ret = conti->ExecuteContinueData(cmd);
593     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
594     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0017_1 end ret:" << ret << std::endl;
595     usleep(WAITTIME);
596 }
597 
598 /**
599  * @tc.name: DSchedContinueTest_0018_1
600  * @tc.desc: ExecuteNotifyComplete
601  * @tc.type: FUNC
602  */
603 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0018_1, TestSize.Level0)
604 {
605     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0018_1 begin" << std::endl;
606     std::string deviceId = "123";
607     std::string bundleName = "test";
608     int32_t subType = CONTINUE_PULL;
609     int32_t direction = CONTINUE_SINK;
610     sptr<IRemoteObject> callback = nullptr;
611     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
612     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
613     conti->Init();
614 
615     int32_t result = ERR_OK;
616     int32_t ret = conti->ExecuteNotifyComplete(result);
617     EXPECT_NE(ret, ERR_OK);
618 
619     direction = CONTINUE_SOURCE;
620     ret = conti->ExecuteNotifyComplete(result);
621     EXPECT_NE(ret, ERR_OK);
622     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0018_1 end ret:" << ret << std::endl;
623     usleep(WAITTIME);
624 }
625 
626 /**
627  * @tc.name: DSchedContinueTest_0019_1
628  * @tc.desc: PackReplyCmd
629  * @tc.type: FUNC
630  */
631 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0019_1, TestSize.Level0)
632 {
633     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0019_1 begin" << std::endl;
634     std::string deviceId = "123";
635     std::string bundleName = "test";
636     int32_t subType = CONTINUE_PULL;
637     int32_t direction = CONTINUE_SINK;
638     sptr<IRemoteObject> callback = nullptr;
639     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
640     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
641     conti->Init();
642 
643     auto cmd = std::make_shared<DSchedContinueReplyCmd>();
644     int32_t replyCmd = 0;
645     int32_t appVersion = 0;
646     int32_t result = 0;
647 
648     int32_t ret = conti->PackReplyCmd(cmd, replyCmd, appVersion, result, "");
649     EXPECT_EQ(ret, ERR_OK);
650 
651     cmd = nullptr;
652     ret = conti->PackReplyCmd(cmd, replyCmd, appVersion, result, "");
653     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
654     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0019_1 end ret:" << ret << std::endl;
655     usleep(WAITTIME);
656 }
657 
658 /**
659  * @tc.name: DSchedContinueTest_0020_1
660  * @tc.desc: ExecuteContinueEnd
661  * @tc.type: FUNC
662  */
663 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0020_1, TestSize.Level0)
664 {
665     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0020_1 begin" << std::endl;
666     std::string deviceId = "123";
667     std::string bundleName = "test";
668     int32_t subType = CONTINUE_PULL;
669     int32_t direction = CONTINUE_SINK;
670     sptr<IRemoteObject> callback = nullptr;
671     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
672     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
673     conti->Init();
674 
675     int32_t result = 0;
676 
677     int32_t ret = conti->ExecuteContinueEnd(result);
678     EXPECT_EQ(ret, ERR_OK);
679     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0020_1 end ret:" << ret << std::endl;
680     usleep(WAITTIME);
681 }
682 
683 /**
684  * @tc.name: DSchedContinueTest_0021_1
685  * @tc.desc: ExecuteContinueError
686  * @tc.type: FUNC
687  */
688 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0021_1, TestSize.Level0)
689 {
690     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0021_1 begin" << std::endl;
691     std::string deviceId = "123";
692     std::string bundleName = "test";
693     int32_t subType = CONTINUE_PULL;
694     int32_t direction = CONTINUE_SINK;
695     sptr<IRemoteObject> callback = nullptr;
696     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
697     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
698     conti->Init();
699 
700     int32_t result = 0;
701     int32_t ret = conti->ExecuteContinueError(result);
702     EXPECT_EQ(ret, ERR_OK);
703 
704     direction = CONTINUE_SOURCE;
705     ret = conti->ExecuteContinueError(result);
706     EXPECT_EQ(ret, ERR_OK);
707     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0021_1 end ret:" << ret << std::endl;
708     usleep(WAITTIME);
709 }
710 
711 /**
712  * @tc.name: DSchedContinueTest_0022_1
713  * @tc.desc: PackEndCmd
714  * @tc.type: FUNC
715  */
716 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0022_1, TestSize.Level0)
717 {
718     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0022_1 begin" << std::endl;
719     std::string deviceId = "123";
720     std::string bundleName = "test";
721     int32_t subType = CONTINUE_PULL;
722     int32_t direction = CONTINUE_SINK;
723     sptr<IRemoteObject> callback = nullptr;
724     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
725     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
726     conti->Init();
727 
728     auto cmd = std::make_shared<DSchedContinueEndCmd>();
729     int32_t result = 0;
730 
731     int32_t ret = conti->PackEndCmd(cmd, result);
732     EXPECT_EQ(ret, ERR_OK);
733 
734     cmd = nullptr;
735     ret = conti->PackEndCmd(cmd, result);
736     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
737     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0022_1 end ret:" << ret << std::endl;
738     usleep(WAITTIME);
739 }
740 
741 /**
742  * @tc.name: DSchedContinueTest_0023_1
743  * @tc.desc: SendCommand
744  * @tc.type: FUNC
745  */
746 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0023_1, TestSize.Level0)
747 {
748     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0023_1 begin" << std::endl;
749     std::string deviceId = "123";
750     std::string bundleName = "test";
751     int32_t subType = CONTINUE_PULL;
752     int32_t direction = CONTINUE_SINK;
753     sptr<IRemoteObject> callback = nullptr;
754     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
755     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
756     conti->Init();
757 
758     auto cmd = std::make_shared<DSchedContinueCmdBase>();
759     int32_t ret = conti->SendCommand(cmd);
760     EXPECT_NE(ret, ERR_OK);
761     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0023_1 end ret:" << ret << std::endl;
762     usleep(WAITTIME);
763 }
764 
765 /**
766  * @tc.name: DSchedContinueTest_0024_1
767  * @tc.desc: GetLocalDeviceId
768  * @tc.type: FUNC
769  */
770 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0024_1, TestSize.Level0)
771 {
772     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0024_1 begin" << std::endl;
773     std::string deviceId = "123";
774     std::string bundleName = "test";
775     int32_t subType = CONTINUE_PULL;
776     int32_t direction = CONTINUE_SINK;
777     sptr<IRemoteObject> callback = nullptr;
778     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
779     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
780     conti->Init();
781 
782     std::string localDeviceId;
783     bool ret = conti->GetLocalDeviceId(localDeviceId);
784     EXPECT_EQ(ret, true);
785     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0024_1 end ret:" << ret << std::endl;
786     usleep(WAITTIME);
787 }
788 
789 /**
790  * @tc.name: DSchedContinueTest_0025_1
791  * @tc.desc: CheckDeviceIdFromRemote
792  * @tc.type: FUNC
793  */
794 HWTEST_F(DSchedContinueTest, DSchedContinueTest_0025_1, TestSize.Level0)
795 {
796     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0025_1 begin" << std::endl;
797     std::string deviceId = "123";
798     std::string bundleName = "test";
799     int32_t subType = CONTINUE_PULL;
800     int32_t direction = CONTINUE_SINK;
801     sptr<IRemoteObject> callback = nullptr;
802     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
803     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
804     conti->Init();
805 
806     bool ret = conti->CheckDeviceIdFromRemote("", "", "");
807     EXPECT_FALSE(ret);
808 
809     std::string localDevId = "localDevId";
810     std::string destDevId = "destDevId";
811     std::string srcDevId = "srcDevId";
812     ret = conti->CheckDeviceIdFromRemote(localDevId, destDevId, srcDevId);
813     EXPECT_FALSE(ret);
814 
815     destDevId = "localDevId";
816     srcDevId = "localDevId";
817     ret = conti->CheckDeviceIdFromRemote(localDevId, destDevId, srcDevId);
818     EXPECT_FALSE(ret);
819 
820     conti->continueInfo_.sourceDeviceId_ = "localDevId";
821     ret = conti->CheckDeviceIdFromRemote(localDevId, destDevId, srcDevId);
822     EXPECT_FALSE(ret);
823 
824     srcDevId = "srcDevId";
825     conti->continueInfo_.sourceDeviceId_ = "srcDevId";
826     ret = conti->CheckDeviceIdFromRemote(localDevId, destDevId, srcDevId);
827     EXPECT_TRUE(ret);
828     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_0025_1 end ret:" << ret << std::endl;
829     usleep(WAITTIME);
830 }
831 
832 /**
833  * @tc.name: WaitAbilityStateInitialTest_0026_1
834  * @tc.desc: WaitAbilityStateInitialTest
835  * @tc.type: FUNC
836  */
837 HWTEST_F(DSchedContinueTest, WaitAbilityStateInitialTest_0026_1, TestSize.Level0)
838 {
839     DTEST_LOG << "DSchedContinueTest WaitAbilityStateInitialTest_0026_1 begin" << std::endl;
840     std::string deviceId = "123";
841     std::string bundleName = "test";
842     int32_t subType = CONTINUE_PULL;
843     int32_t direction = CONTINUE_SINK;
844     sptr<IRemoteObject> callback = nullptr;
845     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
846     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
847     conti->Init();
848 
849     int32_t persistentId = 100;
850     bool ret = conti->WaitAbilityStateInitial(persistentId);
851     EXPECT_FALSE(ret);
852     DTEST_LOG << "DSchedContinueTest WaitAbilityStateInitialTest_0026_1 end ret:" << ret << std::endl;
853     usleep(WAITTIME);
854 }
855 
856 /**
857  * @tc.name: StartAbilityTest_0027_1
858  * @tc.desc: StartAbilityTest
859  * @tc.type: FUNC
860  */
861 HWTEST_F(DSchedContinueTest, StartAbilityTest_0027_1, TestSize.Level0)
862 {
863     DTEST_LOG << "DSchedContinueTest StartAbilityTest_0027_1 begin" << std::endl;
864     std::string deviceId = "123";
865     std::string bundleName = "test";
866     int32_t subType = CONTINUE_PULL;
867     int32_t direction = CONTINUE_SINK;
868     sptr<IRemoteObject> callback = nullptr;
869     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
870     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
871     conti->Init();
872 
873     AAFwk::Want want;
874     AppExecFwk::ElementName element("devicdId", "com.ohos.distributedmusicplayer",
875         "com.ohos.distributedmusicplayer.MainAbility");
876     want.SetElement(element);
877     int32_t ret = conti->StartAbility(want, 0);
878     EXPECT_NE(ret, ERR_OK);
879     DTEST_LOG << "DSchedContinueTest StartAbilityTest_0027_1 end ret:" << ret << std::endl;
880     usleep(WAITTIME);
881 }
882 
883 /**
884  * @tc.name: QuerySinkAbilityNameTest_0028_1
885  * @tc.desc: QuerySinkAbilityNameTest
886  * @tc.type: FUNC
887  */
888 HWTEST_F(DSchedContinueTest, QuerySinkAbilityNameTest_0028_1, TestSize.Level0)
889 {
890     DTEST_LOG << "DSchedContinueTest QuerySinkAbilityNameTest_0028_1 begin" << std::endl;
891     std::string deviceId = "123";
892     std::string bundleName = "test";
893     int32_t subType = CONTINUE_PULL;
894     int32_t direction = CONTINUE_SINK;
895     std::string continueType = "test";
896     sptr<IRemoteObject> callback = nullptr;
897     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, continueType);
898     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
899     conti->Init();
900 
901     std::string sinkBundleName = conti->QuerySinkAbilityName();
902     EXPECT_TRUE(sinkBundleName.empty());
903     DTEST_LOG << "DSchedContinueTest QuerySinkAbilityNameTest_0028_1 end" << std::endl;
904     usleep(WAITTIME);
905 }
906 
907 /**
908  * @tc.name: QuickStartAbilityTest_0029_1
909  * @tc.desc: QuickStartAbilityTest
910  * @tc.type: FUNC
911  */
912 HWTEST_F(DSchedContinueTest, QuickStartAbilityTest_0029_1, TestSize.Level0)
913 {
914     DTEST_LOG << "DSchedContinueTest QuickStartAbilityTest_0029_1 begin" << std::endl;
915     std::string deviceId = "123";
916     std::string bundleName = "test";
917     int32_t subType = CONTINUE_PULL;
918     int32_t direction = CONTINUE_SINK;
919     sptr<IRemoteObject> callback = nullptr;
920     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
921     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
922     conti->Init();
923 
924     int32_t ret = conti->QuickStartAbility();
925     EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
926     DTEST_LOG << "DSchedContinueTest QuickStartAbilityTest_0029_1 end ret:" << ret << std::endl;
927     usleep(WAITTIME);
928 }
929 
930 /**
931  * @tc.name: UpdateWantForContinueTypeTest_0030_1
932  * @tc.desc: UpdateWantForContinueTypeTest
933  * @tc.type: FUNC
934  */
935 HWTEST_F(DSchedContinueTest, UpdateWantForContinueTypeTest_0030_1, TestSize.Level0)
936 {
937     DTEST_LOG << "DSchedContinueTest UpdateWantForContinueTypeTest_0030_1 begin" << std::endl;
938     std::string deviceId = "123";
939     std::string bundleName = "test";
940     int32_t subType = CONTINUE_PULL;
941     int32_t direction = CONTINUE_SINK;
942     sptr<IRemoteObject> callback = nullptr;
943     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
944     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
945     conti->Init();
946 
947     AAFwk::Want want;
948     AppExecFwk::ElementName element("devicdId", "com.ohos.distributedmusicplayer",
949         "com.ohos.distributedmusicplayer.MainAbility");
950     want.SetElement(element);
951     int32_t ret = conti->UpdateWantForContinueType(want);
952     EXPECT_EQ(ret, ERR_OK);
953     DTEST_LOG << "DSchedContinueTest UpdateWantForContinueTypeTest_0030_1 end ret:" << ret << std::endl;
954     usleep(WAITTIME);
955 }
956 
957 /**
958  * @tc.name: DSchedContinueTest_031_1
959  * @tc.desc: DSchedContinue
960  * @tc.type: FUNC
961  */
962 HWTEST_F(DSchedContinueTest, DSchedContinueTest_031_1, TestSize.Level0)
963 {
964     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_031_1 begin" << std::endl;
965     std::string deviceId = "123";
966     std::string bundleName = "test";
967     int32_t subType = CONTINUE_PULL;
968     int32_t direction = CONTINUE_SINK;
969     sptr<IRemoteObject> callback = nullptr;
970     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
971     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
972     conti->Init();
973 
974     AppExecFwk::InnerEvent *event = nullptr;
__anon9c922ad90202(AppExecFwk::InnerEvent *event) 975     auto destructor = [](AppExecFwk::InnerEvent *event) {
976         if (event != nullptr) {
977             delete event;
978         }
979     };
980     conti->ProcessEvent(AppExecFwk::InnerEvent::Pointer(event, destructor));
981     conti->continueInfo_.continueType_ = "";
982     conti->CheckQuickStartConfiguration();
983     conti->GetSessionId();
984     conti->GetAbilityNameByContinueType();
985     EXPECT_NE(nullptr, conti->stateMachine_);
986     DTEST_LOG << "DSchedContinueTest DSchedContinueTest_031_1 end" << std::endl;
987     usleep(WAITTIME);
988 }
989 
990 /**
991  * @tc.name: OnDataRecvTest_032_1
992  * @tc.desc: OnDataRecv
993  * @tc.type: FUNC
994  */
995 HWTEST_F(DSchedContinueTest, OnDataRecvTest_032_1, TestSize.Level0)
996 {
997     DTEST_LOG << "DSchedContinueTest OnDataRecvTest_032_1 begin" << std::endl;
998     std::string deviceId = "123";
999     std::string bundleName = "test";
1000     int32_t subType = CONTINUE_PULL;
1001     int32_t direction = CONTINUE_SINK;
1002     sptr<IRemoteObject> callback = nullptr;
1003     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
1004     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
1005     conti->Init();
1006 
1007     int32_t command = 0;
1008     std::shared_ptr<DSchedDataBuffer> dataBuffer = nullptr;
1009     conti->OnDataRecv(command, dataBuffer);
1010     EXPECT_EQ(nullptr, dataBuffer);
1011     command = DSCHED_CONTINUE_CMD_START;
1012     dataBuffer = std::make_shared<DSchedDataBuffer>(DSCHED_BUFFER_SIZE);
1013     conti->OnDataRecv(command, dataBuffer);
1014     EXPECT_NE(nullptr, dataBuffer);
1015     command = DSCHED_CONTINUE_CMD_DATA;
1016     conti->OnDataRecv(command, dataBuffer);
1017     EXPECT_NE(nullptr, dataBuffer);
1018     command = DSCHED_CONTINUE_CMD_REPLY;
1019     conti->OnDataRecv(command, dataBuffer);
1020     EXPECT_NE(nullptr, dataBuffer);
1021     command = DSCHED_CONTINUE_CMD_END;
1022     conti->OnDataRecv(command, dataBuffer);
1023     EXPECT_NE(nullptr, dataBuffer);
1024     command = DSCHED_CONTINUE_CMD_MIN;
1025     conti->OnDataRecv(command, dataBuffer);
1026     EXPECT_NE(nullptr, dataBuffer);
1027     DTEST_LOG << "DSchedContinueTest OnDataRecvTest_032_1 end" << std::endl;
1028     usleep(WAITTIME);
1029 }
1030 
1031 /**
1032  * @tc.name: UpdateStateTest_033_1
1033  * @tc.desc: UpdateState
1034  * @tc.type: FUNC
1035  */
1036 HWTEST_F(DSchedContinueTest, UpdateStateTest_033_1, TestSize.Level0)
1037 {
1038     DTEST_LOG << "DSchedContinueTest UpdateStateTest_033_1 begin" << std::endl;
1039     std::string deviceId = "123";
1040     std::string bundleName = "test";
1041     int32_t subType = CONTINUE_PULL;
1042     int32_t direction = CONTINUE_SINK;
1043     sptr<IRemoteObject> callback = nullptr;
1044     auto info = DSchedContinueInfo(deviceId, bundleName, deviceId, bundleName, "");
1045     auto conti = std::make_shared<DSchedContinue>(subType, direction, callback, info);
1046     conti->Init();
1047 
1048     DSchedContinueStateType stateType = DSCHED_CONTINUE_SINK_START_STATE;
1049     conti->UpdateState(stateType);
1050     EXPECT_NE(nullptr, conti->stateMachine_);
1051     DTEST_LOG << "DSchedContinueTest UpdateStateTest_033_1 end" << std::endl;
1052 }
1053 }
1054 }
1055