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