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_test.h"
17
18 #include "mock_distributed_sched.h"
19 #include "mock_remote_sup_stub.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 int32_t WAITTIME = 2000;
29 }
SetUpTestCase()30 void DSchedCollabTest::SetUpTestCase()
31 {
32 DTEST_LOG << "DSchedCollabTest::SetUpTestCase" << std::endl;
33 messageParcelMock_ = std::make_shared<MessageParcelMock>();
34 MessageParcelMock::messageParcel = messageParcelMock_;
35 adapterMock_ = std::make_shared<DSchedTransportSoftbusAdapterMock>();
36 DSchedTransportSoftbusAdapterMock::adapterMock = adapterMock_;
37 bundleMgrMock_ = std::make_shared<BundleManagerInternalMock>();
38 BundleManagerInternalMock::bundleMgrMock = bundleMgrMock_;
39 dmsPermMock_ = std::make_shared<DistributedSchedPermMock>();
40 DistributedSchedPermMock::dmsPermMock = dmsPermMock_;
41 dmsSrvMock_ = std::make_shared<DistributedSchedServiceMock>();
42 DistributedSchedServiceMock::dmsSrvMock = dmsSrvMock_;
43 std::string collabToken;
44 DSchedCollabInfo info;
45 dSchedCollab_ = std::make_shared<DSchedCollab>(collabToken, info);
46 usleep(WAITTIME);
47 }
48
TearDownTestCase()49 void DSchedCollabTest::TearDownTestCase()
50 {
51 DTEST_LOG << "DSchedCollabTest::TearDownTestCase" << std::endl;
52 MessageParcelMock::messageParcel = nullptr;
53 messageParcelMock_ = nullptr;
54 DSchedTransportSoftbusAdapterMock::adapterMock = nullptr;
55 adapterMock_ = nullptr;
56 BundleManagerInternalMock::bundleMgrMock = nullptr;
57 bundleMgrMock_ = nullptr;
58 DistributedSchedPermMock::dmsPermMock = nullptr;
59 dmsPermMock_ = nullptr;
60 DistributedSchedServiceMock::dmsSrvMock = nullptr;
61 dmsSrvMock_ = nullptr;
62 dSchedCollab_ = nullptr;
63 }
64
TearDown()65 void DSchedCollabTest::TearDown()
66 {
67 DTEST_LOG << "DSchedCollabTest::TearDown" << std::endl;
68 usleep(WAITTIME);
69 }
70
SetUp()71 void DSchedCollabTest::SetUp()
72 {
73 DTEST_LOG << "DSchedCollabTest::SetUp" << std::endl;
74 }
75
76 /**
77 * @tc.name: DSchedCollab_001
78 * @tc.desc: call DSchedCollab
79 * @tc.type: FUNC
80 * @tc.require: I6SJQ6
81 */
82 HWTEST_F(DSchedCollabTest, DSchedCollab_001, TestSize.Level3)
83 {
84 DTEST_LOG << "DSchedCollabTest DSchedCollab_001 begin" << std::endl;
85 int32_t softbusSessionId = 0;
86 auto getSinkCollabVersionCmd = std::make_shared<GetSinkCollabVersionCmd>();
87 auto newCollab = std::make_shared<DSchedCollab>(getSinkCollabVersionCmd, softbusSessionId);
88 EXPECT_EQ(newCollab->softbusSessionId_, softbusSessionId);
89 DTEST_LOG << "DSchedCollabTest DSchedCollab_001 end" << std::endl;
90 }
91
92 /**
93 * @tc.name: PostSrcStartTask_001
94 * @tc.desc: call PostSrcStartTask
95 * @tc.type: FUNC
96 * @tc.require: I6SJQ6
97 */
98 HWTEST_F(DSchedCollabTest, PostSrcStartTask_001, TestSize.Level3)
99 {
100 DTEST_LOG << "DSchedCollabTest PostSrcStartTask_002 begin" << std::endl;
101 ASSERT_NE(dSchedCollab_, nullptr);
102 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
103 EXPECT_EQ(dSchedCollab_->PostSrcStartTask(), INVALID_PARAMETERS_ERR);
104 DTEST_LOG << "DSchedCollabTest PostSrcStartTask_001 end" << std::endl;
105 }
106
107 /**
108 * @tc.name: PostSinkStartTask_001
109 * @tc.desc: call PostSinkStartTask
110 * @tc.type: FUNC
111 * @tc.require: I6SJQ6
112 */
113 HWTEST_F(DSchedCollabTest, PostSinkStartTask_001, TestSize.Level3)
114 {
115 DTEST_LOG << "DSchedCollabTest PostSinkStartTask_001 begin" << std::endl;
116 ASSERT_NE(dSchedCollab_, nullptr);
117 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
118 EXPECT_EQ(dSchedCollab_->PostSinkStartTask(""), INVALID_PARAMETERS_ERR);
119 DTEST_LOG << "DSchedCollabTest PostSinkStartTask_001 end" << std::endl;
120 }
121
122 /**
123 * @tc.name: PostSinkPrepareResultTask_001
124 * @tc.desc: call PostSinkPrepareResultTask
125 * @tc.type: FUNC
126 * @tc.require: I6SJQ6
127 */
128 HWTEST_F(DSchedCollabTest, PostSinkPrepareResultTask_001, TestSize.Level3)
129 {
130 DTEST_LOG << "DSchedCollabTest PostSinkPrepareResultTask_001 begin" << std::endl;
131 ASSERT_NE(dSchedCollab_, nullptr);
132 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
133 int32_t result = 100;
134 int32_t collabSessionId = 0;
135 std::string socketName = "test";
136 sptr<IRemoteObject> clientCB = sptr<DistributedSchedService>(new DistributedSchedService());
137 EXPECT_EQ(dSchedCollab_->PostSinkPrepareResultTask(
138 result, collabSessionId, socketName, clientCB), INVALID_PARAMETERS_ERR);
139 DTEST_LOG << "DSchedCollabTest PostSinkPrepareResultTask_001 end" << std::endl;
140 }
141
142 /**
143 * @tc.name: PostSrcResultTask_001
144 * @tc.desc: call PostSrcResultTask
145 * @tc.type: FUNC
146 * @tc.require: I6SJQ6
147 */
148 HWTEST_F(DSchedCollabTest, PostSrcResultTask_001, TestSize.Level3)
149 {
150 DTEST_LOG << "DSchedCollabTest PostSrcResultTask_001 begin" << std::endl;
151 ASSERT_NE(dSchedCollab_, nullptr);
152 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
153 std::shared_ptr<NotifyResultCmd> cmd = std::make_shared<NotifyResultCmd>();
154 EXPECT_EQ(dSchedCollab_->PostSrcResultTask(cmd), INVALID_PARAMETERS_ERR);
155 DTEST_LOG << "DSchedCollabTest PostSrcResultTask_001 end" << std::endl;
156 }
157
158 /**
159 * @tc.name: PostErrEndTask_001
160 * @tc.desc: call PostErrEndTask
161 * @tc.type: FUNC
162 * @tc.require: I6SJQ6
163 */
164 HWTEST_F(DSchedCollabTest, PostErrEndTask_001, TestSize.Level3)
165 {
166 DTEST_LOG << "DSchedCollabTest PostErrEndTask_001 begin" << std::endl;
167 ASSERT_NE(dSchedCollab_, nullptr);
168 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
169 int32_t result = 100;
170 EXPECT_EQ(dSchedCollab_->PostErrEndTask(result), INVALID_PARAMETERS_ERR);
171 DTEST_LOG << "DSchedCollabTest PostErrEndTask_001 end" << std::endl;
172 }
173
174 /**
175 * @tc.name: PostAbilityRejectTask_001
176 * @tc.desc: call PostAbilityRejectTask
177 * @tc.type: FUNC
178 * @tc.require: I6SJQ6
179 */
180 HWTEST_F(DSchedCollabTest, PostAbilityRejectTask_001, TestSize.Level3)
181 {
182 DTEST_LOG << "DSchedCollabTest PostAbilityRejectTask_001 begin" << std::endl;
183 ASSERT_NE(dSchedCollab_, nullptr);
184 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
185 std::string reason = "test";
186 EXPECT_EQ(dSchedCollab_->PostAbilityRejectTask(reason), INVALID_PARAMETERS_ERR);
187 DTEST_LOG << "DSchedCollabTest PostAbilityRejectTask_001 end" << std::endl;
188 }
189
190 /**
191 * @tc.name: PostEndTask_001
192 * @tc.desc: call PostEndTask
193 * @tc.type: FUNC
194 * @tc.require: I6SJQ6
195 */
196 HWTEST_F(DSchedCollabTest, PostEndTask_001, TestSize.Level3)
197 {
198 DTEST_LOG << "DSchedCollabTest PostEndTask_001 begin" << std::endl;
199 ASSERT_NE(dSchedCollab_, nullptr);
200 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
201 EXPECT_EQ(dSchedCollab_->PostEndTask(), INVALID_PARAMETERS_ERR);
202 DTEST_LOG << "DSchedCollabTest PostEndTask_001 end" << std::endl;
203 }
204
205 /**
206 * @tc.name: ExeSrcClientNotify_001
207 * @tc.desc: call ExeSrcClientNotify
208 * @tc.type: FUNC
209 * @tc.require: I6SJQ6
210 */
211 HWTEST_F(DSchedCollabTest, ExeSrcClientNotify_001, TestSize.Level3)
212 {
213 DTEST_LOG << "DSchedCollabTest ExeSrcClientNotify_001 begin" << std::endl;
214 ASSERT_NE(dSchedCollab_, nullptr);
215 int32_t result = 0;
216 std::string reason = "test";
217 auto ret = dSchedCollab_->ExeSrcClientNotify(result, reason);
218 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
219
220 dSchedCollab_->collabInfo_.srcClientCB_ = sptr<DistributedSchedService>(new DistributedSchedService());
221 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
222 ret = dSchedCollab_->ExeSrcClientNotify(result, reason);
223 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
224
225 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
226 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
227 ret = dSchedCollab_->ExeSrcClientNotify(result, reason);
228 EXPECT_EQ(ret, ERR_FLATTEN_OBJECT);
229
230 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
231 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
232 ret = dSchedCollab_->ExeSrcClientNotify(result, reason);
233 EXPECT_EQ(ret, ERR_FLATTEN_OBJECT);
234
235 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
236 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
237 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
238 ret = dSchedCollab_->ExeSrcClientNotify(result, reason);
239 EXPECT_EQ(ret, ERR_FLATTEN_OBJECT);
240
241 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
242 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
243 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
244 ret = dSchedCollab_->ExeSrcClientNotify(result, reason);
245 EXPECT_EQ(ret, ERR_FLATTEN_OBJECT);
246
247 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
248 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
249 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true))
250 .WillOnce(Return(true)).WillOnce(Return(false));
251 ret = dSchedCollab_->ExeSrcClientNotify(result, reason);
252 EXPECT_EQ(ret, ERR_FLATTEN_OBJECT);
253 DTEST_LOG << "DSchedCollabTest ExeSrcClientNotify_001 end" << std::endl;
254 }
255
256 /**
257 * @tc.name: ExeSrcClientNotify_002
258 * @tc.desc: call ExeSrcClientNotify
259 * @tc.type: FUNC
260 * @tc.require: I6SJQ6
261 */
262 HWTEST_F(DSchedCollabTest, ExeSrcClientNotify_002, TestSize.Level3)
263 {
264 DTEST_LOG << "DSchedCollabTest ExeSrcClientNotify_002 begin" << std::endl;
265 ASSERT_NE(dSchedCollab_, nullptr);
266 int32_t result = 0;
267 std::string reason = "test";
268 auto mock_ = sptr<MockRemoteSupStub>(new MockRemoteSupStub());
269 dSchedCollab_->collabInfo_.srcClientCB_ = mock_;
270 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
271 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
272 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true))
273 .WillOnce(Return(true)).WillOnce(Return(true));
274 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
275 EXPECT_EQ(dSchedCollab_->ExeSrcClientNotify(result, reason), ERR_OK);
276 DTEST_LOG << "DSchedCollabTest ExeSrcClientNotify_002 end" << std::endl;
277 }
278
279 /**
280 * @tc.name: ExeSrcClientNotify_003
281 * @tc.desc: call ExeSrcClientNotify
282 * @tc.type: FUNC
283 * @tc.require: I6SJQ6
284 */
285 HWTEST_F(DSchedCollabTest, ExeSrcClientNotify_003, TestSize.Level3)
286 {
287 DTEST_LOG << "DSchedCollabTest ExeSrcClientNotify_003 begin" << std::endl;
288 ASSERT_NE(dSchedCollab_, nullptr);
289 int32_t result = 0;
290 std::string reason = "test";
291 auto mock_ = sptr<MockRemoteSupStub>(new MockRemoteSupStub());
292 dSchedCollab_->collabInfo_.srcClientCB_ = mock_;
293 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
294 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
295 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true))
296 .WillOnce(Return(true)).WillOnce(Return(true));
297 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
298 EXPECT_EQ(dSchedCollab_->ExeSrcClientNotify(result, reason), -1);
299 DTEST_LOG << "DSchedCollabTest ExeSrcClientNotify_003 end" << std::endl;
300 }
301
302 /**
303 * @tc.name: ExeClientDisconnectNotify_001
304 * @tc.desc: call ExeClientDisconnectNotify
305 * @tc.type: FUNC
306 * @tc.require: I6SJQ6
307 */
308 HWTEST_F(DSchedCollabTest, ExeClientDisconnectNotify_001, TestSize.Level3)
309 {
310 DTEST_LOG << "DSchedCollabTest ExeClientDisconnectNotify_001 begin" << std::endl;
311 ASSERT_NE(dSchedCollab_, nullptr);
312 dSchedCollab_->collabInfo_.direction_ = COLLAB_SOURCE;
313 dSchedCollab_->collabInfo_.srcClientCB_ = nullptr;
314 auto ret = dSchedCollab_->ExeClientDisconnectNotify();
315 EXPECT_EQ(ret, ERR_NULL_OBJECT);
316
317 auto mock_ = sptr<MockRemoteSupStub>(new MockRemoteSupStub());
318 dSchedCollab_->collabInfo_.srcClientCB_ = mock_;
319 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
320 EXPECT_EQ(dSchedCollab_->ExeClientDisconnectNotify(), SEND_REQUEST_DEF_FAIL);
321
322 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
323 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
324 EXPECT_EQ(dSchedCollab_->ExeClientDisconnectNotify(), ERR_FLATTEN_OBJECT);
325
326 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
327 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
328 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
329 EXPECT_EQ(dSchedCollab_->ExeClientDisconnectNotify(), SEND_REQUEST_DEF_FAIL);
330
331 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
332 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
333 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
334 EXPECT_EQ(dSchedCollab_->ExeClientDisconnectNotify(), ERR_OK);
335 DTEST_LOG << "DSchedCollabTest ExeClientDisconnectNotify_001 end" << std::endl;
336 }
337
338 /**
339 * @tc.name: ExeClientDisconnectNotify_002
340 * @tc.desc: call ExeClientDisconnectNotify
341 * @tc.type: FUNC
342 * @tc.require: I6SJQ6
343 */
344 HWTEST_F(DSchedCollabTest, ExeClientDisconnectNotify_002, TestSize.Level3)
345 {
346 DTEST_LOG << "DSchedCollabTest ExeClientDisconnectNotify_002 begin" << std::endl;
347 ASSERT_NE(dSchedCollab_, nullptr);
348 dSchedCollab_->collabInfo_.direction_ = COLLAB_SINK;
349 dSchedCollab_->collabInfo_.sinkClientCB_ = nullptr;
350 auto ret = dSchedCollab_->ExeClientDisconnectNotify();
351 EXPECT_EQ(ret, ERR_NULL_OBJECT);
352
353 auto mock_ = sptr<MockRemoteSupStub>(new MockRemoteSupStub());
354 dSchedCollab_->collabInfo_.sinkClientCB_ = mock_;
355 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
356 EXPECT_EQ(dSchedCollab_->ExeClientDisconnectNotify(), SEND_REQUEST_DEF_FAIL);
357
358 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
359 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
360 EXPECT_EQ(dSchedCollab_->ExeClientDisconnectNotify(), ERR_FLATTEN_OBJECT);
361
362 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
363 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
364 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
365 EXPECT_EQ(dSchedCollab_->ExeClientDisconnectNotify(), SEND_REQUEST_DEF_FAIL);
366
367 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
368 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
369 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
370 EXPECT_EQ(dSchedCollab_->ExeClientDisconnectNotify(), ERR_OK);
371 DTEST_LOG << "DSchedCollabTest ExeClientDisconnectNotify_002 end" << std::endl;
372 }
373
374 /**
375 * @tc.name: NotifyWifiOpen_001
376 * @tc.desc: call ExeClientDisconnectNotify
377 * @tc.type: FUNC
378 * @tc.require: I6SJQ6
379 */
380 HWTEST_F(DSchedCollabTest, NotifyWifiOpen_001, TestSize.Level3)
381 {
382 DTEST_LOG << "DSchedCollabTest NotifyWifiOpen_001 begin" << std::endl;
383 ASSERT_NE(dSchedCollab_, nullptr);
384 dSchedCollab_->collabInfo_.direction_ = COLLAB_SOURCE;
385 dSchedCollab_->collabInfo_.srcClientCB_ = nullptr;
386 auto ret = dSchedCollab_->NotifyWifiOpen();
387 EXPECT_EQ(ret, ERR_NULL_OBJECT);
388
389 auto mock_ = sptr<MockRemoteSupStub>(new MockRemoteSupStub());
390 dSchedCollab_->collabInfo_.srcClientCB_ = mock_;
391 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
392 EXPECT_EQ(dSchedCollab_->NotifyWifiOpen(), SEND_REQUEST_DEF_FAIL);
393
394 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
395 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
396 EXPECT_EQ(dSchedCollab_->NotifyWifiOpen(), ERR_FLATTEN_OBJECT);
397
398 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
399 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
400 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
401 EXPECT_EQ(dSchedCollab_->NotifyWifiOpen(), SEND_REQUEST_DEF_FAIL);
402
403 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
404 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
405 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
406 EXPECT_EQ(dSchedCollab_->NotifyWifiOpen(), ERR_OK);
407 DTEST_LOG << "DSchedCollabTest NotifyWifiOpen_001 end" << std::endl;
408 }
409
410 /**
411 * @tc.name: NotifyWifiOpen_002
412 * @tc.desc: call NotifyWifiOpen
413 * @tc.type: FUNC
414 * @tc.require: I6SJQ6
415 */
416 HWTEST_F(DSchedCollabTest, NotifyWifiOpen_002, TestSize.Level3)
417 {
418 DTEST_LOG << "DSchedCollabTest NotifyWifiOpen_002 begin" << std::endl;
419 ASSERT_NE(dSchedCollab_, nullptr);
420 dSchedCollab_->collabInfo_.direction_ = COLLAB_SINK;
421 dSchedCollab_->collabInfo_.sinkClientCB_ = nullptr;
422 auto ret = dSchedCollab_->NotifyWifiOpen();
423 EXPECT_EQ(ret, ERR_NULL_OBJECT);
424
425 auto mock_ = sptr<MockRemoteSupStub>(new MockRemoteSupStub());
426 dSchedCollab_->collabInfo_.sinkClientCB_ = mock_;
427 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
428 EXPECT_EQ(dSchedCollab_->NotifyWifiOpen(), SEND_REQUEST_DEF_FAIL);
429
430 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
431 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
432 EXPECT_EQ(dSchedCollab_->NotifyWifiOpen(), ERR_FLATTEN_OBJECT);
433
434 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
435 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
436 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
437 EXPECT_EQ(dSchedCollab_->NotifyWifiOpen(), SEND_REQUEST_DEF_FAIL);
438
439 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
440 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
441 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
442 EXPECT_EQ(dSchedCollab_->NotifyWifiOpen(), ERR_OK);
443 DTEST_LOG << "DSchedCollabTest NotifyWifiOpen_002 end" << std::endl;
444 }
445
446 /**
447 * @tc.name: CleanUpSession_001
448 * @tc.desc: call CleanUpSession
449 * @tc.type: FUNC
450 * @tc.require: I6SJQ6
451 */
452 HWTEST_F(DSchedCollabTest, CleanUpSession_001, TestSize.Level3)
453 {
454 DTEST_LOG << "DSchedCollabTest CleanUpSession_001 begin" << std::endl;
455 ASSERT_NE(dSchedCollab_, nullptr);
456 dSchedCollab_->collabInfo_.direction_ = COLLAB_SINK;
457 dSchedCollab_->collabInfo_.srcClientCB_ = nullptr;
458 dSchedCollab_->collabInfo_.sinkClientCB_ = nullptr;
459 EXPECT_NE(dSchedCollab_->CleanUpSession(), ERR_OK);
460
461 dSchedCollab_->collabInfo_.direction_ = COLLAB_SOURCE;
462 EXPECT_NE(dSchedCollab_->CleanUpSession(), ERR_OK);
463 DTEST_LOG << "DSchedCollabTest CleanUpSession_001 end" << std::endl;
464 }
465
466 /**
467 * @tc.name: SendCommand_001
468 * @tc.desc: call SendCommand
469 * @tc.type: FUNC
470 * @tc.require: I6SJQ6
471 */
472 HWTEST_F(DSchedCollabTest, SendCommand_001, TestSize.Level3)
473 {
474 DTEST_LOG << "DSchedCollabTest SendCommand_001 begin" << std::endl;
475 ASSERT_NE(dSchedCollab_, nullptr);
476 std::shared_ptr<DisconnectCmd> cmd = nullptr;
477 EXPECT_EQ(dSchedCollab_->PackDisconnectCmd(cmd), INVALID_PARAMETERS_ERR);
478 EXPECT_EQ(dSchedCollab_->SendCommand(cmd), INVALID_PARAMETERS_ERR);
479
480 cmd = std::make_shared<DisconnectCmd>();
481 EXPECT_CALL(*adapterMock_, SendData(_, _, _)).WillOnce(Return(-1));
482 EXPECT_EQ(dSchedCollab_->SendCommand(cmd), -1);
483
484 EXPECT_CALL(*adapterMock_, SendData(_, _, _)).WillOnce(Return(0));
485 EXPECT_EQ(dSchedCollab_->SendCommand(cmd), ERR_OK);
486 DTEST_LOG << "DSchedCollabTest SendCommand_001 end" << std::endl;
487 }
488
489 /**
490 * @tc.name: ExeSinkPrepareResult_001
491 * @tc.desc: call ExeSinkPrepareResult
492 * @tc.type: FUNC
493 * @tc.require: I6SJQ6
494 */
495 HWTEST_F(DSchedCollabTest, ExeSinkPrepareResult_001, TestSize.Level3)
496 {
497 DTEST_LOG << "DSchedCollabTest ExeSinkPrepareResult_001 begin" << std::endl;
498 ASSERT_NE(dSchedCollab_, nullptr);
499 int32_t result = COLLAB_ABILITY_TIMEOUT_ERR;
500 EXPECT_EQ(dSchedCollab_->ExeSinkPrepareResult(result), INVALID_PARAMETERS_ERR);
501
502 result = ERR_OK;
503 EXPECT_CALL(*adapterMock_, SendData(_, _, _)).WillOnce(Return(-1));
504 EXPECT_EQ(dSchedCollab_->ExeSinkPrepareResult(result), -1);
505
506 EXPECT_CALL(*adapterMock_, SendData(_, _, _)).WillOnce(Return(0));
507 EXPECT_EQ(dSchedCollab_->ExeSinkPrepareResult(result), ERR_OK);
508
509 result = COLLAB_ABILITY_REJECT_ERR;
510 EXPECT_CALL(*adapterMock_, SendData(_, _, _)).WillOnce(Return(0));
511 EXPECT_EQ(dSchedCollab_->ExeSinkPrepareResult(result), ERR_OK);
512 DTEST_LOG << "DSchedCollabTest ExeSinkPrepareResult_001 end" << std::endl;
513 }
514
515 /**
516 * @tc.name: ExeSrcCollabResult_001
517 * @tc.desc: call ExeSrcCollabResult
518 * @tc.type: FUNC
519 * @tc.require: I6SJQ6
520 */
521 HWTEST_F(DSchedCollabTest, ExeSrcCollabResult_001, TestSize.Level3)
522 {
523 DTEST_LOG << "DSchedCollabTest ExeSrcCollabResult_001 begin" << std::endl;
524 ASSERT_NE(dSchedCollab_, nullptr);
525 int32_t result = COLLAB_ABILITY_TIMEOUT_ERR;
526 std::string reason;
527 EXPECT_EQ(dSchedCollab_->ExeSrcCollabResult(result, reason), INVALID_PARAMETERS_ERR);
528
529 result = ERR_OK;
530 dSchedCollab_->collabInfo_.srcClientCB_ = nullptr;
531 dSchedCollab_->collabInfo_.sinkClientCB_ = nullptr;
532 EXPECT_EQ(dSchedCollab_->ExeSrcCollabResult(result, reason), INVALID_PARAMETERS_ERR);
533
534 result = COLLAB_ABILITY_REJECT_ERR;
535 auto mock_ = sptr<MockRemoteSupStub>(new MockRemoteSupStub());
536 dSchedCollab_->collabInfo_.srcClientCB_ = mock_;
537 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
538 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
539 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true))
540 .WillOnce(Return(true)).WillOnce(Return(true));
541 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
542 EXPECT_EQ(dSchedCollab_->ExeSrcCollabResult(result, reason), ERR_OK);
543
544 dSchedCollab_->collabInfo_.srcClientCB_ = nullptr;
545 reason = "test";
546 EXPECT_NE(dSchedCollab_->ExeSrcCollabResult(result, reason), ERR_OK);
547 DTEST_LOG << "DSchedCollabTest ExeSinkPrepareResult_001 end" << std::endl;
548 }
549
550 /**
551 * @tc.name: PackStartCmd_001
552 * @tc.desc: call PackStartCmd
553 * @tc.type: FUNC
554 * @tc.require: I6SJQ6
555 */
556 HWTEST_F(DSchedCollabTest, PackStartCmd_001, TestSize.Level3)
557 {
558 DTEST_LOG << "DSchedCollabTest PackStartCmd_001 begin" << std::endl;
559 ASSERT_NE(dSchedCollab_, nullptr);
560 std::shared_ptr<SinkStartCmd> cmd = nullptr;
561 EXPECT_EQ(dSchedCollab_->PackStartCmd(cmd), INVALID_PARAMETERS_ERR);
562 DTEST_LOG << "DSchedCollabTest PackStartCmd_001 end" << std::endl;
563 }
564
565 /**
566 * @tc.name: ExeSrcStart_001
567 * @tc.desc: call ExeSrcStart
568 * @tc.type: FUNC
569 * @tc.require: I6SJQ6
570 */
571 HWTEST_F(DSchedCollabTest, ExeSrcStart_001, TestSize.Level3)
572 {
573 DTEST_LOG << "DSchedCollabTest ExeSrcStart_001 begin" << std::endl;
574 ASSERT_NE(dSchedCollab_, nullptr);
575 EXPECT_NE(dSchedCollab_->ExeSrcStart(), ERR_OK);
576 DTEST_LOG << "DSchedCollabTest ExeSrcStart_001 end" << std::endl;
577 }
578
579 /**
580 * @tc.name: ExeStartAbility_001
581 * @tc.desc: call ExeStartAbility
582 * @tc.type: FUNC
583 * @tc.require: I6SJQ6
584 */
585 HWTEST_F(DSchedCollabTest, ExeStartAbility_001, TestSize.Level3)
586 {
587 DTEST_LOG << "DSchedCollabTest ExeStartAbility_001 begin" << std::endl;
588 ASSERT_NE(dSchedCollab_, nullptr);
589 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillRepeatedly(Return(true));
590 EXPECT_CALL(*dmsSrvMock_, CheckCollabStartPermission(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
591 EXPECT_EQ(dSchedCollab_->ExeStartAbility(""), INVALID_PARAMETERS_ERR);
592
593 EXPECT_CALL(*dmsSrvMock_, CheckCollabStartPermission(_, _, _, _)).WillOnce(Return(ERR_OK));
594 EXPECT_NE(dSchedCollab_->ExeStartAbility(""), ERR_OK);
595 DTEST_LOG << "DSchedCollabTest ExeStartAbility_001 end" << std::endl;
596 }
597
598 /**
599 * @tc.name: ExeSrcGetPeerVersion_001
600 * @tc.desc: call ExeSrcGetPeerVersion
601 * @tc.type: FUNC
602 * @tc.require: I6SJQ6
603 */
604 HWTEST_F(DSchedCollabTest, ExeSrcGetPeerVersion_001, TestSize.Level3)
605 {
606 DTEST_LOG << "DSchedCollabTest ExeSrcGetPeerVersion_001 begin" << std::endl;
607 ASSERT_NE(dSchedCollab_, nullptr);
608 EXPECT_CALL(*adapterMock_, ConnectDevice(_, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
609 EXPECT_EQ(dSchedCollab_->ExeSrcGetPeerVersion(), INVALID_PARAMETERS_ERR);
610
611 EXPECT_CALL(*adapterMock_, ConnectDevice(_, _, _)).WillOnce(Return(ERR_OK));
612 EXPECT_CALL(*adapterMock_, SendData(_, _, _)).WillOnce(Return(-1));
613 EXPECT_EQ(dSchedCollab_->ExeSrcGetPeerVersion(), -1);
614
615 EXPECT_CALL(*adapterMock_, ConnectDevice(_, _, _)).WillOnce(Return(ERR_OK));
616 EXPECT_CALL(*adapterMock_, SendData(_, _, _)).WillOnce(Return(0));
617 EXPECT_EQ(dSchedCollab_->ExeSrcGetPeerVersion(), ERR_OK);
618 DTEST_LOG << "DSchedCollabTest ExeSrcGetPeerVersion_001 end" << std::endl;
619 }
620
621 /**
622 * @tc.name: PostSinkGetVersionTask_001
623 * @tc.desc: call PostSinkGetVersionTask
624 * @tc.type: FUNC
625 * @tc.require: I6SJQ6
626 */
627 HWTEST_F(DSchedCollabTest, PostSinkGetVersionTask_001, TestSize.Level3)
628 {
629 DTEST_LOG << "DSchedCollabTest PostSinkGetVersionTask_001 begin" << std::endl;
630 ASSERT_NE(dSchedCollab_, nullptr);
631 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
632 EXPECT_EQ(dSchedCollab_->PostSinkGetVersionTask(), INVALID_PARAMETERS_ERR);
633 DTEST_LOG << "DSchedCollabTest PostSinkGetVersionTask_001 end" << std::endl;
634 }
635
636 /**
637 * @tc.name: PostSrcGetVersionTask_001
638 * @tc.desc: call PostSrcGetVersionTask
639 * @tc.type: FUNC
640 * @tc.require: I6SJQ6
641 */
642 HWTEST_F(DSchedCollabTest, PostSrcGetVersionTask_001, TestSize.Level3)
643 {
644 DTEST_LOG << "DSchedCollabTest PostSrcGetVersionTask_001 begin" << std::endl;
645 ASSERT_NE(dSchedCollab_, nullptr);
646 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
647 EXPECT_EQ(dSchedCollab_->PostSrcGetVersionTask(), INVALID_PARAMETERS_ERR);
648 DTEST_LOG << "DSchedCollabTest PostSrcGetVersionTask_001 end" << std::endl;
649 }
650
651 /**
652 * @tc.name: PostSrcGetPeerVersionTask_001
653 * @tc.desc: call PostSrcGetPeerVersionTask
654 * @tc.type: FUNC
655 * @tc.require: I6SJQ6
656 */
657 HWTEST_F(DSchedCollabTest, PostSrcGetPeerVersionTask_001, TestSize.Level3)
658 {
659 DTEST_LOG << "DSchedCollabTest PostSrcGetPeerVersionTask_001 begin" << std::endl;
660 ASSERT_NE(dSchedCollab_, nullptr);
661 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
662 EXPECT_EQ(dSchedCollab_->PostSrcGetPeerVersionTask(), INVALID_PARAMETERS_ERR);
663 DTEST_LOG << "DSchedCollabTest PostSrcGetPeerVersionTask_001 end" << std::endl;
664 }
665
666 /**
667 * @tc.name: PackGetPeerVersionCmd_001
668 * @tc.desc: call PackGetPeerVersionCmd
669 * @tc.type: FUNC
670 * @tc.require: I6SJQ6
671 */
672 HWTEST_F(DSchedCollabTest, PackGetPeerVersionCmd_001, TestSize.Level3)
673 {
674 DTEST_LOG << "DSchedCollabTest PackGetPeerVersionCmd_001 begin" << std::endl;
675 ASSERT_NE(dSchedCollab_, nullptr);
676 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
677 std::shared_ptr<GetSinkCollabVersionCmd> cmd = nullptr;
678 EXPECT_EQ(dSchedCollab_->PackGetPeerVersionCmd(cmd), INVALID_PARAMETERS_ERR);
679 DTEST_LOG << "DSchedCollabTest PackGetPeerVersionCmd_001 end" << std::endl;
680 }
681
682 /**
683 * @tc.name: PackSinkCollabVersionCmd_001
684 * @tc.desc: call PackSinkCollabVersionCmd
685 * @tc.type: FUNC
686 * @tc.require: I6SJQ6
687 */
688 HWTEST_F(DSchedCollabTest, PackSinkCollabVersionCmd_001, TestSize.Level3)
689 {
690 DTEST_LOG << "DSchedCollabTest PackSinkCollabVersionCmd_001 begin" << std::endl;
691 ASSERT_NE(dSchedCollab_, nullptr);
692 ASSERT_EQ(dSchedCollab_->eventHandler_, nullptr);
693 std::shared_ptr<GetSinkCollabVersionCmd> cmd = nullptr;
694 EXPECT_EQ(dSchedCollab_->PackSinkCollabVersionCmd(cmd), INVALID_PARAMETERS_ERR);
695 DTEST_LOG << "DSchedCollabTest PackSinkCollabVersionCmd_001 end" << std::endl;
696 }
697
698 /**
699 * @tc.name: ExeStartAbility_002
700 * @tc.desc: call ExeStartAbility
701 * @tc.type: FUNC
702 * @tc.require: I6SJQ6
703 */
704 HWTEST_F(DSchedCollabTest, ExeStartAbility_002, TestSize.Level3)
705 {
706 DTEST_LOG << "DSchedCollabTest ExeStartAbility_002 begin" << std::endl;
707 ASSERT_NE(dSchedCollab_, nullptr);
708 dSchedCollab_->collabInfo_.callerInfo_.sourceDeviceId = "sourceDeviceId";
709 EXPECT_EQ(dSchedCollab_->ExeStartAbility(""), INVALID_PARAMETERS_ERR);
710 DTEST_LOG << "DSchedCollabTest ExeStartAbility_002 end" << std::endl;
711 }
712 }
713 }