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 int32_t collabSessionId = 0;
116 std::string socketName = "test";
117 sptr<IRemoteObject> clientCB = sptr<DistributedSchedService>(new DistributedSchedService());
118 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
119 EXPECT_EQ(dSchedCollab_->PostSinkPrepareResultTask(
120 result, collabSessionId, socketName, clientCB), COLLAB_SEND_EVENT_FAILED);
121
122 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
123 EXPECT_EQ(dSchedCollab_->PostSinkPrepareResultTask(
124 result, collabSessionId, socketName, clientCB), ERR_OK);
125 DTEST_LOG << "DSchedCollabSupTest PostSinkPrepareResultTask_001 end" << std::endl;
126 }
127
128 /**
129 * @tc.name: PostSrcResultTask_001
130 * @tc.desc: call PostSrcResultTask
131 * @tc.type: FUNC
132 * @tc.require: I6SJQ6
133 */
134 HWTEST_F(DSchedCollabSupTest, PostSrcResultTask_001, TestSize.Level3)
135 {
136 DTEST_LOG << "DSchedCollabSupTest PostSrcResultTask_001 begin" << std::endl;
137 ASSERT_NE(dSchedCollab_, nullptr);
138 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
139 std::shared_ptr<NotifyResultCmd> cmd = std::make_shared<NotifyResultCmd>();
140 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
141 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), COLLAB_SEND_EVENT_FAILED);
142
143 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
144 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), ERR_OK);
145
146 cmd->abilityRejectReason_ = "test";
147 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
148 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), COLLAB_SEND_EVENT_FAILED);
149
150 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
151 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), ERR_OK);
152 DTEST_LOG << "DSchedCollabSupTest PostSrcResultTask_001 end" << std::endl;
153 }
154
155 /**
156 * @tc.name: PostErrEndTask_001
157 * @tc.desc: call PostErrEndTask
158 * @tc.type: FUNC
159 * @tc.require: I6SJQ6
160 */
161 HWTEST_F(DSchedCollabSupTest, PostErrEndTask_001, TestSize.Level3)
162 {
163 DTEST_LOG << "DSchedCollabSupTest PostErrEndTask_001 begin" << std::endl;
164 ASSERT_NE(dSchedCollab_, nullptr);
165 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
166 int32_t result = 100;
167 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
168 EXPECT_EQ(dSchedCollab_->PostErrEndTask(result), COLLAB_SEND_EVENT_FAILED);
169
170 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
171 EXPECT_EQ(dSchedCollab_->PostErrEndTask(result), ERR_OK);
172 DTEST_LOG << "DSchedCollabSupTest PostErrEndTask_001 end" << std::endl;
173 }
174
175 /**
176 * @tc.name: PostAbilityRejectTask_001
177 * @tc.desc: call PostAbilityRejectTask
178 * @tc.type: FUNC
179 * @tc.require: I6SJQ6
180 */
181 HWTEST_F(DSchedCollabSupTest, PostAbilityRejectTask_001, TestSize.Level3)
182 {
183 DTEST_LOG << "DSchedCollabSupTest PostAbilityRejectTask_001 begin" << std::endl;
184 ASSERT_NE(dSchedCollab_, nullptr);
185 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
186 std::string reason = "test";
187 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
188 EXPECT_EQ(dSchedCollab_->PostAbilityRejectTask(reason), COLLAB_SEND_EVENT_FAILED);
189
190 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
191 EXPECT_EQ(dSchedCollab_->PostAbilityRejectTask(reason), ERR_OK);
192 DTEST_LOG << "DSchedCollabSupTest PostAbilityRejectTask_001 end" << std::endl;
193 }
194
195 /**
196 * @tc.name: PostEndTask_001
197 * @tc.desc: call PostEndTask
198 * @tc.type: FUNC
199 * @tc.require: I6SJQ6
200 */
201 HWTEST_F(DSchedCollabSupTest, PostEndTask_001, TestSize.Level3)
202 {
203 DTEST_LOG << "DSchedCollabSupTest PostEndTask_001 begin" << std::endl;
204 ASSERT_NE(dSchedCollab_, nullptr);
205 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
206 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
207 EXPECT_EQ(dSchedCollab_->PostEndTask(), COLLAB_SEND_EVENT_FAILED);
208
209 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
210 EXPECT_EQ(dSchedCollab_->PostEndTask(), ERR_OK);
211 DTEST_LOG << "DSchedCollabSupTest PostEndTask_001 end" << std::endl;
212 }
213
214 /**
215 * @tc.name: OnDataRecv_001
216 * @tc.desc: call OnDataRecv
217 * @tc.type: FUNC
218 * @tc.require: I6SJQ6
219 */
220 HWTEST_F(DSchedCollabSupTest, OnDataRecv_001, TestSize.Level3)
221 {
222 DTEST_LOG << "DSchedCollabSupTest OnDataRecv_001 begin" << std::endl;
223 ASSERT_NE(dSchedCollab_, nullptr);
224 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
225 dSchedCollab_->collabInfo_.direction_ = COLLAB_SINK;
226 dSchedCollab_->collabInfo_.srcClientCB_ = nullptr;
227 dSchedCollab_->collabInfo_.sinkClientCB_ = nullptr;
228 std::shared_ptr<DSchedDataBuffer> dataBuffer = nullptr;
229 int32_t command = static_cast<int32_t>(MAX_CMD);
230 dSchedCollab_->OnDataRecv("", command, dataBuffer);
231
232 dataBuffer = std::make_shared<DSchedDataBuffer>(20);
233 dSchedCollab_->OnDataRecv("", command, dataBuffer);
234
235 command = static_cast<int32_t>(SINK_START_CMD);
236 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
237 dSchedCollab_->OnDataRecv("", command, dataBuffer);
238
239 command = static_cast<int32_t>(NOTIFY_RESULT_CMD);
240 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
241 dSchedCollab_->OnDataRecv("", command, dataBuffer);
242
243 command = static_cast<int32_t>(DISCONNECT_CMD);
244 dSchedCollab_->OnDataRecv("", command, dataBuffer);
245 DTEST_LOG << "DSchedCollabSupTest OnDataRecv_001 end" << std::endl;
246 }
247
248 /**
249 * @tc.name: ProcessEvent_001
250 * @tc.desc: call ProcessEvent
251 * @tc.type: FUNC
252 * @tc.require: I6SJQ6
253 */
254 HWTEST_F(DSchedCollabSupTest, ProcessEvent_001, TestSize.Level3)
255 {
256 DTEST_LOG << "DSchedCollabSupTest ProcessEvent_001 begin" << std::endl;
257 ASSERT_NE(dSchedCollab_, nullptr);
258 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
259 dSchedCollab_->stateMachine_ = nullptr;
260 dSchedCollab_->ProcessEvent(AppExecFwk::InnerEvent::Pointer(nullptr, nullptr));
261
262 DSchedCollabEventType eventType = ERR_END_EVENT;
263 auto data = std::make_shared<int32_t>(0);
264 auto msgEvent = AppExecFwk::InnerEvent::Get(eventType, data, 0);
265 dSchedCollab_->ProcessEvent(msgEvent);
266
267 dSchedCollab_->stateMachine_ = std::make_shared<DSchedCollabStateMachine>(dSchedCollab_);
268 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
269 dSchedCollab_->ProcessEvent(msgEvent);
270
271 dSchedCollab_->stateMachine_->currentState_ =
272 std::make_shared<CollabSrcStartState>(dSchedCollab_->stateMachine_);
273 dSchedCollab_->ProcessEvent(msgEvent);
274 DTEST_LOG << "DSchedCollabSupTest ProcessEvent_001 end" << std::endl;
275 }
276
277 /**
278 * @tc.name: PackNotifyResultCmd_001
279 * @tc.desc: call PackNotifyResultCmd
280 * @tc.type: FUNC
281 * @tc.require: I6SJQ6
282 */
283 HWTEST_F(DSchedCollabSupTest, PackNotifyResultCmd_001, TestSize.Level3)
284 {
285 DTEST_LOG << "DSchedCollabSupTest PackNotifyResultCmd_001 begin" << std::endl;
286 ASSERT_NE(dSchedCollab_, nullptr);
287 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
288 std::shared_ptr<NotifyResultCmd> cmd = nullptr;
289 int32_t result = 5;
290 std::string abilityRejectReason = "test";
291 EXPECT_EQ(dSchedCollab_->PackNotifyResultCmd(cmd, result, abilityRejectReason), INVALID_PARAMETERS_ERR);
292
293 cmd = std::make_shared<NotifyResultCmd>();
294 EXPECT_EQ(dSchedCollab_->PackNotifyResultCmd(cmd, result, abilityRejectReason), ERR_OK);
295 EXPECT_EQ(cmd->result_, result);
296 EXPECT_EQ(cmd->abilityRejectReason_, abilityRejectReason);
297 DTEST_LOG << "DSchedCollabSupTest PackNotifyResultCmd_001 end" << std::endl;
298 }
299
300 /**
301 * @tc.name: RegisterAbilityLifecycleObserver_001
302 * @tc.desc: call RegisterAbilityLifecycleObserver
303 * @tc.type: FUNC
304 * @tc.require: I6SJQ6
305 */
306 HWTEST_F(DSchedCollabSupTest, RegisterAbilityLifecycleObserver_001, TestSize.Level3)
307 {
308 DTEST_LOG << "DSchedCollabSupTest RegisterAbilityLifecycleObserver_001 begin" << std::endl;
309 ASSERT_NE(dSchedCollab_, nullptr);
310 std::string bundleName = "test";
311 EXPECT_EQ(dSchedCollab_->RegisterAbilityLifecycleObserver(bundleName), false);
312 EXPECT_NE(dSchedCollab_->appStateObserver_, nullptr);
313 AppExecFwk::AbilityStateData abilityStateData;
314 abilityStateData.abilityState = BACKGROUND;
315 dSchedCollab_->appStateObserver_->OnAbilityStateChanged(abilityStateData);
316
317 abilityStateData.abilityState = FOREGROUND;
318 dSchedCollab_->appStateObserver_->OnAbilityStateChanged(abilityStateData);
319 dSchedCollab_->UnregisterAbilityLifecycleObserver();
320 DTEST_LOG << "DSchedCollabSupTest RegisterAbilityLifecycleObserver_001 end" << std::endl;
321 }
322
323 /**
324 * @tc.name: DSchedCollabEventHandler_001
325 * @tc.desc: call DSchedCollabEventHandler
326 * @tc.type: FUNC
327 * @tc.require: I6SJQ6
328 */
329 HWTEST_F(DSchedCollabSupTest, DSchedCollabEventHandler_001, TestSize.Level3)
330 {
331 DTEST_LOG << "DSchedCollabSupTest DSchedCollabEventHandler_001 begin" << std::endl;
332 auto runner = AppExecFwk::EventRunner::Create(false);
333 auto errHandler = std::make_shared<DSchedCollabEventHandler>(runner, nullptr);
334 errHandler->ProcessEvent(AppExecFwk::InnerEvent::Pointer(nullptr, nullptr));
335
336 DSchedCollabEventType eventType = ERR_END_EVENT;
337 auto msgEvent = AppExecFwk::InnerEvent::Get(eventType);
338 errHandler->ProcessEvent(msgEvent);
339
340 auto handler = std::make_shared<DSchedCollabEventHandler>(runner, dSchedCollab_);
341 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
342 handler->ProcessEvent(msgEvent);
343 DTEST_LOG << "DSchedCollabSupTest DSchedCollabEventHandler_001 end" << std::endl;
344 }
345
346 /**
347 * @tc.name: PostSinkGetVersionTask_001
348 * @tc.desc: call PostSinkGetVersionTask
349 * @tc.type: FUNC
350 * @tc.require: I6SJQ6
351 */
352 HWTEST_F(DSchedCollabSupTest, PostSinkGetVersionTask_001, TestSize.Level3)
353 {
354 DTEST_LOG << "DSchedCollabTest PostSinkGetVersionTask_001 begin" << std::endl;
355 ASSERT_NE(dSchedCollab_, nullptr);
356 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
357 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
358 EXPECT_EQ(dSchedCollab_->PostSinkGetVersionTask(), COLLAB_SEND_EVENT_FAILED);
359
360 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
361 EXPECT_EQ(dSchedCollab_->PostSinkGetVersionTask(), ERR_OK);
362 DTEST_LOG << "DSchedCollabTest PostSinkGetVersionTask_001 end" << std::endl;
363 }
364
365 /**
366 * @tc.name: PostSrcGetVersionTask_001
367 * @tc.desc: call PostSrcGetVersionTask
368 * @tc.type: FUNC
369 * @tc.require: I6SJQ6
370 */
371 HWTEST_F(DSchedCollabSupTest, PostSrcGetVersionTask_001, TestSize.Level3)
372 {
373 DTEST_LOG << "DSchedCollabTest PostSrcGetVersionTask_001 begin" << std::endl;
374 ASSERT_NE(dSchedCollab_, nullptr);
375 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
376 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
377 EXPECT_EQ(dSchedCollab_->PostSrcGetVersionTask(), COLLAB_SEND_EVENT_FAILED);
378
379 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
380 EXPECT_EQ(dSchedCollab_->PostSrcGetVersionTask(), ERR_OK);
381 DTEST_LOG << "DSchedCollabTest PostSrcGetVersionTask_001 end" << std::endl;
382 }
383
384 /**
385 * @tc.name: PostSrcGetPeerVersionTask_001
386 * @tc.desc: call PostSrcGetPeerVersionTask
387 * @tc.type: FUNC
388 * @tc.require: I6SJQ6
389 */
390 HWTEST_F(DSchedCollabSupTest, PostSrcGetPeerVersionTask_001, TestSize.Level3)
391 {
392 DTEST_LOG << "DSchedCollabTest PostSrcGetPeerVersionTask_001 begin" << std::endl;
393 ASSERT_NE(dSchedCollab_, nullptr);
394 ASSERT_NE(dSchedCollab_->eventHandler_, nullptr);
395 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(false));
396 EXPECT_EQ(dSchedCollab_->PostSrcGetPeerVersionTask(), COLLAB_SEND_EVENT_FAILED);
397
398 EXPECT_CALL(*handleMock_, SendEvent(_, _, _)).WillOnce(Return(true));
399 EXPECT_EQ(dSchedCollab_->PostSrcGetPeerVersionTask(), ERR_OK);
400 DTEST_LOG << "DSchedCollabTest PPostSrcGetPeerVersionTask_001 end" << std::endl;
401 }
402 }
403 }