1 /*
2 * Copyright (c) 2025 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_collab_sup_test.h"
17
18 #include "dsched_collab_source_start_state.h"
19 #include "mock_distributed_sched.h"
20 #include "mock_remote_sup_stub.h"
21 #include "test_log.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace DistributedSchedule {
28 namespace {
29 const int32_t WAITTIME = 2000;
30 constexpr int32_t FOREGROUND = 2;
31 constexpr int32_t BACKGROUND = 4;
32 }
33
SetUpTestCase()34 void DSchedCollabSupTest::SetUpTestCase()
35 {
36 DTEST_LOG << "DSchedCollabSupTest::SetUpTestCase" << std::endl;
37 handleMock_ = std::make_shared<EventHandlerMock>();
38 EventHandlerMock::handlerMock = handleMock_;
39 std::string collabToken;
40 DSchedCollabInfo info;
41 dSchedCollab_ = std::make_shared<DSchedCollab>(collabToken, info);
42 (void)dSchedCollab_->Init();
43 usleep(WAITTIME);
44 }
45
TearDownTestCase()46 void DSchedCollabSupTest::TearDownTestCase()
47 {
48 DTEST_LOG << "DSchedCollabSupTest::TearDownTestCase" << std::endl;
49 EventHandlerMock::handlerMock = nullptr;
50 handleMock_ = nullptr;
51 dSchedCollab_ = nullptr;
52 }
53
TearDown()54 void DSchedCollabSupTest::TearDown()
55 {
56 DTEST_LOG << "DSchedCollabSupTest::TearDown" << std::endl;
57 usleep(WAITTIME);
58 }
59
SetUp()60 void DSchedCollabSupTest::SetUp()
61 {
62 DTEST_LOG << "DSchedCollabSupTest::SetUp" << std::endl;
63 }
64
65 /**
66 * @tc.name: PostSrcStartTask_001
67 * @tc.desc: call PostSrcStartTask
68 * @tc.type: FUNC
69 * @tc.require: I6SJQ6
70 */
71 HWTEST_F(DSchedCollabSupTest, PostSrcStartTask_001, TestSize.Level3)
72 {
73 DTEST_LOG << "DSchedCollabSupTest PostSrcStartTask_002 begin" << std::endl;
74 ASSERT_NE(dSchedCollab_, nullptr);
75 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
76 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
77 EXPECT_EQ(dSchedCollab_->PostSrcStartTask(), COLLAB_SEND_EVENT_FAILED);
78
79 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
80 EXPECT_EQ(dSchedCollab_->PostSrcStartTask(), ERR_OK);
81 DTEST_LOG << "DSchedCollabSupTest PostSrcStartTask_001 end" << std::endl;
82 }
83
84 /**
85 * @tc.name: PostSinkStartTask_001
86 * @tc.desc: call PostSinkStartTask
87 * @tc.type: FUNC
88 * @tc.require: I6SJQ6
89 */
90 HWTEST_F(DSchedCollabSupTest, PostSinkStartTask_001, TestSize.Level3)
91 {
92 DTEST_LOG << "DSchedCollabSupTest PostSinkStartTask_001 begin" << std::endl;
93 ASSERT_NE(dSchedCollab_, nullptr);
94 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
95 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
96 EXPECT_EQ(dSchedCollab_->PostSinkStartTask(""), COLLAB_SEND_EVENT_FAILED);
97
98 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
99 EXPECT_EQ(dSchedCollab_->PostSinkStartTask(""), ERR_OK);
100 DTEST_LOG << "DSchedCollabSupTest PostSinkStartTask_001 end" << std::endl;
101 }
102
103 /**
104 * @tc.name: PostSinkPrepareResultTask_001
105 * @tc.desc: call PostSinkPrepareResultTask
106 * @tc.type: FUNC
107 * @tc.require: I6SJQ6
108 */
109 HWTEST_F(DSchedCollabSupTest, PostSinkPrepareResultTask_001, TestSize.Level3)
110 {
111 DTEST_LOG << "DSchedCollabSupTest PostSinkPrepareResultTask_001 begin" << std::endl;
112 ASSERT_NE(dSchedCollab_, nullptr);
113 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
114 int32_t result = 100;
115 DSchedCollabInfo dSchedCollabInfo;
116 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
117 EXPECT_EQ(dSchedCollab_->PostSinkPrepareResultTask(
118 result, dSchedCollabInfo), COLLAB_SEND_EVENT_FAILED);
119
120 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
121 EXPECT_EQ(dSchedCollab_->PostSinkPrepareResultTask(
122 result, dSchedCollabInfo), ERR_OK);
123 DTEST_LOG << "DSchedCollabSupTest PostSinkPrepareResultTask_001 end" << std::endl;
124 }
125
126 /**
127 * @tc.name: PostSrcResultTask_001
128 * @tc.desc: call PostSrcResultTask
129 * @tc.type: FUNC
130 * @tc.require: I6SJQ6
131 */
132 HWTEST_F(DSchedCollabSupTest, PostSrcResultTask_001, TestSize.Level3)
133 {
134 DTEST_LOG << "DSchedCollabSupTest PostSrcResultTask_001 begin" << std::endl;
135 ASSERT_NE(dSchedCollab_, nullptr);
136 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
137 std::shared_ptr<NotifyResultCmd> cmd = std::make_shared<NotifyResultCmd>();
138 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
139 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), COLLAB_SEND_EVENT_FAILED);
140
141 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
142 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), ERR_OK);
143
144 cmd->abilityRejectReason_ = "test";
145 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
146 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), COLLAB_SEND_EVENT_FAILED);
147
148 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
149 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), ERR_OK);
150 DTEST_LOG << "DSchedCollabSupTest PostSrcResultTask_001 end" << std::endl;
151 }
152
153 /**
154 * @tc.name: PostErrEndTask_001
155 * @tc.desc: call PostErrEndTask
156 * @tc.type: FUNC
157 * @tc.require: I6SJQ6
158 */
159 HWTEST_F(DSchedCollabSupTest, PostErrEndTask_001, TestSize.Level3)
160 {
161 DTEST_LOG << "DSchedCollabSupTest PostErrEndTask_001 begin" << std::endl;
162 ASSERT_NE(dSchedCollab_, nullptr);
163 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
164 int32_t result = 100;
165 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
166 EXPECT_EQ(dSchedCollab_->PostErrEndTask(result), COLLAB_SEND_EVENT_FAILED);
167
168 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
169 EXPECT_EQ(dSchedCollab_->PostErrEndTask(result), ERR_OK);
170 DTEST_LOG << "DSchedCollabSupTest PostErrEndTask_001 end" << std::endl;
171 }
172
173 /**
174 * @tc.name: PostAbilityRejectTask_001
175 * @tc.desc: call PostAbilityRejectTask
176 * @tc.type: FUNC
177 * @tc.require: I6SJQ6
178 */
179 HWTEST_F(DSchedCollabSupTest, PostAbilityRejectTask_001, TestSize.Level3)
180 {
181 DTEST_LOG << "DSchedCollabSupTest PostAbilityRejectTask_001 begin" << std::endl;
182 ASSERT_NE(dSchedCollab_, nullptr);
183 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
184 std::string reason = "test";
185 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
186 EXPECT_EQ(dSchedCollab_->PostAbilityRejectTask(reason), COLLAB_SEND_EVENT_FAILED);
187
188 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
189 EXPECT_EQ(dSchedCollab_->PostAbilityRejectTask(reason), ERR_OK);
190 DTEST_LOG << "DSchedCollabSupTest PostAbilityRejectTask_001 end" << std::endl;
191 }
192
193 /**
194 * @tc.name: PostEndTask_001
195 * @tc.desc: call PostEndTask
196 * @tc.type: FUNC
197 * @tc.require: I6SJQ6
198 */
199 HWTEST_F(DSchedCollabSupTest, PostEndTask_001, TestSize.Level3)
200 {
201 DTEST_LOG << "DSchedCollabSupTest PostEndTask_001 begin" << std::endl;
202 ASSERT_NE(dSchedCollab_, nullptr);
203 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
204 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
205 EXPECT_EQ(dSchedCollab_->PostEndTask(), COLLAB_SEND_EVENT_FAILED);
206
207 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
208 EXPECT_EQ(dSchedCollab_->PostEndTask(), ERR_OK);
209 DTEST_LOG << "DSchedCollabSupTest PostEndTask_001 end" << std::endl;
210 }
211
212 /**
213 * @tc.name: OnDataRecv_001
214 * @tc.desc: call OnDataRecv
215 * @tc.type: FUNC
216 * @tc.require: I6SJQ6
217 */
218 HWTEST_F(DSchedCollabSupTest, OnDataRecv_001, TestSize.Level3)
219 {
220 DTEST_LOG << "DSchedCollabSupTest OnDataRecv_001 begin" << std::endl;
221 ASSERT_NE(dSchedCollab_, nullptr);
222 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
223 dSchedCollab_->collabInfo_.direction_ = COLLAB_SINK;
224 dSchedCollab_->collabInfo_.srcClientCB_ = nullptr;
225 dSchedCollab_->collabInfo_.sinkClientCB_ = nullptr;
226 std::shared_ptr<DSchedDataBuffer> dataBuffer = nullptr;
227 int32_t command = static_cast<int32_t>(MAX_CMD);
228 dSchedCollab_->OnDataRecv("", command, dataBuffer);
229
230 dataBuffer = std::make_shared<DSchedDataBuffer>(20);
231 dSchedCollab_->OnDataRecv("", command, dataBuffer);
232
233 command = static_cast<int32_t>(SINK_START_CMD);
234 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
235 dSchedCollab_->OnDataRecv("", command, dataBuffer);
236
237 command = static_cast<int32_t>(NOTIFY_RESULT_CMD);
238 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
239 dSchedCollab_->OnDataRecv("", command, dataBuffer);
240
241 command = static_cast<int32_t>(DISCONNECT_CMD);
242 dSchedCollab_->OnDataRecv("", command, dataBuffer);
243 DTEST_LOG << "DSchedCollabSupTest OnDataRecv_001 end" << std::endl;
244 }
245
246 /**
247 * @tc.name: ProcessEvent_001
248 * @tc.desc: call ProcessEvent
249 * @tc.type: FUNC
250 * @tc.require: I6SJQ6
251 */
252 HWTEST_F(DSchedCollabSupTest, ProcessEvent_001, TestSize.Level3)
253 {
254 DTEST_LOG << "DSchedCollabSupTest ProcessEvent_001 begin" << std::endl;
255 ASSERT_NE(dSchedCollab_, nullptr);
256 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
257 dSchedCollab_->stateMachine_ = nullptr;
258 dSchedCollab_->ProcessEvent(AppExecFwk::InnerEvent::Pointer(nullptr, nullptr));
259
260 DSchedCollabEventType eventType = ERR_END_EVENT;
261 auto data = std::make_shared<int32_t>(0);
262 auto msgEvent = AppExecFwk::InnerEvent::Get(eventType, data, 0);
263 dSchedCollab_->ProcessEvent(msgEvent);
264
265 dSchedCollab_->stateMachine_ = std::make_shared<DSchedCollabStateMachine>(dSchedCollab_);
266 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
267 dSchedCollab_->ProcessEvent(msgEvent);
268
269 dSchedCollab_->stateMachine_->currentState_ =
270 std::make_shared<CollabSrcStartState>(dSchedCollab_->stateMachine_);
271 dSchedCollab_->ProcessEvent(msgEvent);
272 DTEST_LOG << "DSchedCollabSupTest ProcessEvent_001 end" << std::endl;
273 }
274
275 /**
276 * @tc.name: PackNotifyResultCmd_001
277 * @tc.desc: call PackNotifyResultCmd
278 * @tc.type: FUNC
279 * @tc.require: I6SJQ6
280 */
281 HWTEST_F(DSchedCollabSupTest, PackNotifyResultCmd_001, TestSize.Level3)
282 {
283 DTEST_LOG << "DSchedCollabSupTest PackNotifyResultCmd_001 begin" << std::endl;
284 ASSERT_NE(dSchedCollab_, nullptr);
285 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
286 std::shared_ptr<NotifyResultCmd> cmd = nullptr;
287 int32_t result = 5;
288 std::string abilityRejectReason = "test";
289 EXPECT_EQ(dSchedCollab_->PackNotifyResultCmd(cmd, result, abilityRejectReason), INVALID_PARAMETERS_ERR);
290
291 cmd = std::make_shared<NotifyResultCmd>();
292 EXPECT_EQ(dSchedCollab_->PackNotifyResultCmd(cmd, result, abilityRejectReason), ERR_OK);
293 EXPECT_EQ(cmd->result_, result);
294 EXPECT_EQ(cmd->abilityRejectReason_, abilityRejectReason);
295 DTEST_LOG << "DSchedCollabSupTest PackNotifyResultCmd_001 end" << std::endl;
296 }
297
298 /**
299 * @tc.name: RegisterAbilityLifecycleObserver_001
300 * @tc.desc: call RegisterAbilityLifecycleObserver
301 * @tc.type: FUNC
302 * @tc.require: I6SJQ6
303 */
304 HWTEST_F(DSchedCollabSupTest, RegisterAbilityLifecycleObserver_001, TestSize.Level3)
305 {
306 DTEST_LOG << "DSchedCollabSupTest RegisterAbilityLifecycleObserver_001 begin" << std::endl;
307 ASSERT_NE(dSchedCollab_, nullptr);
308 std::string bundleName = "test";
309 EXPECT_EQ(dSchedCollab_->RegisterAbilityLifecycleObserver(bundleName), false);
310 EXPECT_NE(dSchedCollab_->appStateObserver_, nullptr);
311 AppExecFwk::AbilityStateData abilityStateData;
312 abilityStateData.abilityState = BACKGROUND;
313 dSchedCollab_->appStateObserver_->OnAbilityStateChanged(abilityStateData);
314
315 abilityStateData.abilityState = FOREGROUND;
316 dSchedCollab_->appStateObserver_->OnAbilityStateChanged(abilityStateData);
317 dSchedCollab_->UnregisterAbilityLifecycleObserver();
318 DTEST_LOG << "DSchedCollabSupTest RegisterAbilityLifecycleObserver_001 end" << std::endl;
319 }
320
321 /**
322 * @tc.name: DSchedCollabEventHandler_001
323 * @tc.desc: call DSchedCollabEventHandler
324 * @tc.type: FUNC
325 * @tc.require: I6SJQ6
326 */
327 HWTEST_F(DSchedCollabSupTest, DSchedCollabEventHandler_001, TestSize.Level3)
328 {
329 DTEST_LOG << "DSchedCollabSupTest DSchedCollabEventHandler_001 begin" << std::endl;
330 auto runner = AppExecFwk::EventRunner::Create(false);
331 auto errHandler = std::make_shared<DSchedCollabEventHandler>(runner, nullptr);
332 errHandler->ProcessEvent(AppExecFwk::InnerEvent::Pointer(nullptr, nullptr));
333
334 DSchedCollabEventType eventType = ERR_END_EVENT;
335 auto msgEvent = AppExecFwk::InnerEvent::Get(eventType);
336 errHandler->ProcessEvent(msgEvent);
337
338 auto handler = std::make_shared<DSchedCollabEventHandler>(runner, dSchedCollab_);
339 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
340 handler->ProcessEvent(msgEvent);
341 DTEST_LOG << "DSchedCollabSupTest DSchedCollabEventHandler_001 end" << std::endl;
342 }
343
344 /**
345 * @tc.name: PostSinkGetVersionTask_001
346 * @tc.desc: call PostSinkGetVersionTask
347 * @tc.type: FUNC
348 * @tc.require: I6SJQ6
349 */
350 HWTEST_F(DSchedCollabSupTest, PostSinkGetVersionTask_001, TestSize.Level3)
351 {
352 DTEST_LOG << "DSchedCollabTest PostSinkGetVersionTask_001 begin" << std::endl;
353 ASSERT_NE(dSchedCollab_, nullptr);
354 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
355 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
356 EXPECT_EQ(dSchedCollab_->PostSinkGetVersionTask(), COLLAB_SEND_EVENT_FAILED);
357
358 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
359 EXPECT_EQ(dSchedCollab_->PostSinkGetVersionTask(), ERR_OK);
360 DTEST_LOG << "DSchedCollabTest PostSinkGetVersionTask_001 end" << std::endl;
361 }
362
363 /**
364 * @tc.name: PostSrcGetVersionTask_001
365 * @tc.desc: call PostSrcGetVersionTask
366 * @tc.type: FUNC
367 * @tc.require: I6SJQ6
368 */
369 HWTEST_F(DSchedCollabSupTest, PostSrcGetVersionTask_001, TestSize.Level3)
370 {
371 DTEST_LOG << "DSchedCollabTest PostSrcGetVersionTask_001 begin" << std::endl;
372 ASSERT_NE(dSchedCollab_, nullptr);
373 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
374 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
375 EXPECT_EQ(dSchedCollab_->PostSrcGetVersionTask(), COLLAB_SEND_EVENT_FAILED);
376
377 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
378 EXPECT_EQ(dSchedCollab_->PostSrcGetVersionTask(), ERR_OK);
379 DTEST_LOG << "DSchedCollabTest PostSrcGetVersionTask_001 end" << std::endl;
380 }
381
382 /**
383 * @tc.name: PostSrcGetPeerVersionTask_001
384 * @tc.desc: call PostSrcGetPeerVersionTask
385 * @tc.type: FUNC
386 * @tc.require: I6SJQ6
387 */
388 HWTEST_F(DSchedCollabSupTest, PostSrcGetPeerVersionTask_001, TestSize.Level3)
389 {
390 DTEST_LOG << "DSchedCollabTest PostSrcGetPeerVersionTask_001 begin" << std::endl;
391 ASSERT_NE(dSchedCollab_, nullptr);
392 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
393 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
394 EXPECT_EQ(dSchedCollab_->PostSrcGetPeerVersionTask(), COLLAB_SEND_EVENT_FAILED);
395
396 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
397 EXPECT_EQ(dSchedCollab_->PostSrcGetPeerVersionTask(), ERR_OK);
398 DTEST_LOG << "DSchedCollabTest PPostSrcGetPeerVersionTask_001 end" << std::endl;
399 }
400
401 /**
402 * @tc.name: SetSinkCollabInfo_001
403 * @tc.desc: call SetSinkCollabInfo
404 * @tc.type: FUNC
405 * @tc.require: I6SJQ6
406 */
407 HWTEST_F(DSchedCollabSupTest, SetSinkCollabInfo_001, TestSize.Level3)
408 {
409 DTEST_LOG << "DSchedCollabTest SetSinkCollabInfo_001 begin" << std::endl;
410 ASSERT_NE(dSchedCollab_, nullptr);
411 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
412 EXPECT_NO_FATAL_FAILURE(dSchedCollab_->SetSinkCollabInfo(nullptr));
413 DTEST_LOG << "DSchedCollabTest SetSinkCollabInfo_001 end" << std::endl;
414 }
415 }
416 }