1 /*
2 * Copyright (c) 2022 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 "distributed_sched_adapter_test.h"
17 #include "dtbschedmgr_log.h"
18 #include "mock_remote_stub.h"
19 #include "snapshot.h"
20 #include "test_log.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace DistributedSchedule {
SetUpTestCase()27 void DistributedSchedAdapterTest::SetUpTestCase()
28 {
29 DTEST_LOG << "DistributedSchedAdapterTest::SetUpTestCase" << std::endl;
30 }
31
TearDownTestCase()32 void DistributedSchedAdapterTest::TearDownTestCase()
33 {
34 DTEST_LOG << "DistributedSchedAdapterTest::TearDownTestCase" << std::endl;
35 }
36
TearDown()37 void DistributedSchedAdapterTest::TearDown()
38 {
39 DTEST_LOG << "DistributedSchedAdapterTest::TearDown" << std::endl;
40 }
41
SetUp()42 void DistributedSchedAdapterTest::SetUp()
43 {
44 distributedSchedAdapter_ = std::make_shared<DistributedSchedAdapter>();
45 distributedSchedAdapter_->Init();
46 DTEST_LOG << "DistributedSchedAdapterTest::SetUp" << std::endl;
47 }
48
49 /**
50 * @tc.name: Init_001
51 * @tc.desc: dmsAdapterHandler_ is not nullptr
52 * @tc.type: FUNC
53 * @tc.require: I60TOK
54 */
55 HWTEST_F(DistributedSchedAdapterTest, Init_001, TestSize.Level3)
56 {
57 DTEST_LOG << "DistributedSchedAdapterTest Init_001 begin" << std::endl;
58 distributedSchedAdapter_->Init();
59 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
60 DTEST_LOG << "DistributedSchedAdapterTest Init_001 end" << std::endl;
61 }
62
63 /**
64 * @tc.name: ConnectAbility_001
65 * @tc.desc: invalid params
66 * @tc.type: FUNC
67 * @tc.require: I5WKCK
68 */
69 HWTEST_F(DistributedSchedAdapterTest, ConnectAbility_001, TestSize.Level3)
70 {
71 DTEST_LOG << "DistributedSchedAdapterTest ConnectAbility_001 begin" << std::endl;
72 const OHOS::AAFwk::Want want;
73 const sptr<IRemoteObject> connect;
74 const sptr<IRemoteObject> callerToken;
75 int32_t result = distributedSchedAdapter_->ConnectAbility(want, connect, callerToken);
76 EXPECT_NE(result, ERR_OK);
77 DTEST_LOG << "DistributedSchedAdapterTest ConnectAbility_001 end" << std::endl;
78 }
79
80 /**
81 * @tc.name: DisconnectAbility_001
82 * @tc.desc: invalid params
83 * @tc.type: FUNC
84 * @tc.require: I5WKCK
85 */
86 HWTEST_F(DistributedSchedAdapterTest, DisconnectAbility_001, TestSize.Level3)
87 {
88 DTEST_LOG << "DistributedSchedAdapterTest DisconnectAbility_001 begin" << std::endl;
89 const sptr<IRemoteObject> connect;
90 int32_t result = distributedSchedAdapter_->DisconnectAbility(connect);
91 EXPECT_NE(result, ERR_OK);
92 DTEST_LOG << "DistributedSchedAdapterTest DisconnectAbility_001 end" << std::endl;
93 }
94
95 /**
96 * @tc.name: DeviceOnline_001
97 * @tc.desc: dmsAdapterHandler_ is nullptr
98 * @tc.type: FUNC
99 * @tc.require: I5WKCK
100 */
101 HWTEST_F(DistributedSchedAdapterTest, DeviceOnline_001, TestSize.Level3)
102 {
103 DTEST_LOG << "DistributedSchedAdapterTest DeviceOnline_001 begin" << std::endl;
104 const std::string deviceId = "";
105 distributedSchedAdapter_->dmsAdapterHandler_ = nullptr;
106 distributedSchedAdapter_->DeviceOnline(deviceId);
107 EXPECT_EQ(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
108 DTEST_LOG << "DistributedSchedAdapterTest DeviceOnline_001 end" << std::endl;
109 }
110
111 /**
112 * @tc.name: DeviceOnline_002
113 * @tc.desc: deviceId is empty
114 * @tc.type: FUNC
115 * @tc.require: I5WKCK
116 */
117 HWTEST_F(DistributedSchedAdapterTest, DeviceOnline_002, TestSize.Level3)
118 {
119 DTEST_LOG << "DistributedSchedAdapterTest DeviceOnline_002 begin" << std::endl;
120 const std::string deviceId = "";
121 distributedSchedAdapter_->DeviceOnline(deviceId);
122 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
123 DTEST_LOG << "DistributedSchedAdapterTest DeviceOnline_002 end" << std::endl;
124 }
125
126 /**
127 * @tc.name: DeviceOnline_003
128 * @tc.desc: deviceId is not empty
129 * @tc.type: FUNC
130 * @tc.require: I5WKCK
131 */
132 HWTEST_F(DistributedSchedAdapterTest, DeviceOnline_003, TestSize.Level3)
133 {
134 DTEST_LOG << "DistributedSchedAdapterTest DeviceOnline_003 begin" << std::endl;
135 const std::string deviceId = "mockDeviceId";
136 distributedSchedAdapter_->DeviceOnline(deviceId);
137 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
138 DTEST_LOG << "DistributedSchedAdapterTest DeviceOnline_003 end" << std::endl;
139 }
140
141 /**
142 * @tc.name: DeviceOffline_001
143 * @tc.desc: dmsAdapterHandler_ is nullptr
144 * @tc.type: FUNC
145 * @tc.require: I5WKCK
146 */
147 HWTEST_F(DistributedSchedAdapterTest, DeviceOffline_001, TestSize.Level3)
148 {
149 DTEST_LOG << "DistributedSchedAdapterTest DeviceOffline_001 begin" << std::endl;
150 const std::string deviceId = "";
151 distributedSchedAdapter_->dmsAdapterHandler_ = nullptr;
152 distributedSchedAdapter_->DeviceOffline(deviceId);
153 EXPECT_EQ(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
154 DTEST_LOG << "DistributedSchedAdapterTest DeviceOffline_001 end" << std::endl;
155 }
156
157 /**
158 * @tc.name: DeviceOffline_002
159 * @tc.desc: deviceId is empty
160 * @tc.type: FUNC
161 * @tc.require: I5WKCK
162 */
163 HWTEST_F(DistributedSchedAdapterTest, DeviceOffline_002, TestSize.Level3)
164 {
165 DTEST_LOG << "DistributedSchedAdapterTest DeviceOffline_002 begin" << std::endl;
166 const std::string deviceId = "";
167 distributedSchedAdapter_->DeviceOffline(deviceId);
168 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
169 DTEST_LOG << "DistributedSchedAdapterTest DeviceOffline_002 end" << std::endl;
170 }
171
172 /**
173 * @tc.name: DeviceOffline_003
174 * @tc.desc: deviceId is not empty
175 * @tc.type: FUNC
176 * @tc.require: I5WKCK
177 */
178 HWTEST_F(DistributedSchedAdapterTest, DeviceOffline_003, TestSize.Level3)
179 {
180 DTEST_LOG << "DistributedSchedAdapterTest DeviceOffline_003 begin" << std::endl;
181 const std::string deviceId = "mockDeviceId";
182 distributedSchedAdapter_->DeviceOffline(deviceId);
183 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
184 DTEST_LOG << "DistributedSchedAdapterTest DeviceOffline_003 end" << std::endl;
185 }
186
187 /**
188 * @tc.name: ProcessConnectDied_001
189 * @tc.desc: dmsAdapterHandler_ is nullptr
190 * @tc.type: FUNC
191 * @tc.require: I5WKCK
192 */
193 HWTEST_F(DistributedSchedAdapterTest, ProcessConnectDied_001, TestSize.Level3)
194 {
195 DTEST_LOG << "DistributedSchedAdapterTest ProcessConnectDied_001 begin" << std::endl;
196 const sptr<IRemoteObject> connect;
197 distributedSchedAdapter_->dmsAdapterHandler_ = nullptr;
198 distributedSchedAdapter_->ProcessConnectDied(connect);
199 EXPECT_EQ(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
200 DTEST_LOG << "DistributedSchedAdapterTest ProcessConnectDied_001 end" << std::endl;
201 }
202
203 /**
204 * @tc.name: ProcessConnectDied_002
205 * @tc.desc: connect is nullptr
206 * @tc.type: FUNC
207 * @tc.require: I5WKCK
208 */
209 HWTEST_F(DistributedSchedAdapterTest, ProcessConnectDied_002, TestSize.Level3)
210 {
211 DTEST_LOG << "DistributedSchedAdapterTest ProcessConnectDied_002 begin" << std::endl;
212 const sptr<IRemoteObject> connect = nullptr;
213 distributedSchedAdapter_->ProcessConnectDied(connect);
214 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
215 DTEST_LOG << "DistributedSchedAdapterTest ProcessConnectDied_002 end" << std::endl;
216 }
217
218 /**
219 * @tc.name: ProcessConnectDied_003
220 * @tc.desc: process connect died
221 * @tc.type: FUNC
222 * @tc.require: I60TOK
223 */
224 HWTEST_F(DistributedSchedAdapterTest, ProcessConnectDied_003, TestSize.Level3)
225 {
226 DTEST_LOG << "DistributedSchedAdapterTest ProcessConnectDied_003 begin" << std::endl;
227 const sptr<IRemoteObject> connect = new MockRemoteStub();
228 distributedSchedAdapter_->ProcessConnectDied(connect);
229 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
230 DTEST_LOG << "DistributedSchedAdapterTest ProcessConnectDied_003 end" << std::endl;
231 }
232
233 /**
234 * @tc.name: ProcessCalleeDied_001
235 * @tc.desc: dmsAdapterHandler_ is nullptr
236 * @tc.type: FUNC
237 * @tc.require: I5WKCK
238 */
239 HWTEST_F(DistributedSchedAdapterTest, ProcessCalleeDied_001, TestSize.Level3)
240 {
241 DTEST_LOG << "DistributedSchedAdapterTest ProcessCalleeDied_001 begin" << std::endl;
242 const sptr<IRemoteObject> connect;
243 distributedSchedAdapter_->dmsAdapterHandler_ = nullptr;
244 distributedSchedAdapter_->ProcessCalleeDied(connect);
245 EXPECT_EQ(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
246 DTEST_LOG << "DistributedSchedAdapterTest ProcessCalleeDied_001 end" << std::endl;
247 }
248
249 /**
250 * @tc.name: ProcessCalleeDied_002
251 * @tc.desc: connect is nullptr
252 * @tc.type: FUNC
253 * @tc.require: I5WKCK
254 */
255 HWTEST_F(DistributedSchedAdapterTest, ProcessCalleeDied_002, TestSize.Level3)
256 {
257 DTEST_LOG << "DistributedSchedAdapterTest ProcessCalleeDied_002 begin" << std::endl;
258 const sptr<IRemoteObject> connect = nullptr;
259 distributedSchedAdapter_->ProcessCalleeDied(connect);
260 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
261 DTEST_LOG << "DistributedSchedAdapterTest ProcessCalleeDied_002 end" << std::endl;
262 }
263
264 /**
265 * @tc.name: ProcessCalleeDied_003
266 * @tc.desc: processs callee died
267 * @tc.type: FUNC
268 * @tc.require: I60TOK
269 */
270 HWTEST_F(DistributedSchedAdapterTest, ProcessCalleeDied_003, TestSize.Level3)
271 {
272 DTEST_LOG << "DistributedSchedAdapterTest ProcessCalleeDied_003 begin" << std::endl;
273 const sptr<IRemoteObject> connect = new MockRemoteStub();
274 distributedSchedAdapter_->ProcessCalleeDied(connect);
275 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
276 DTEST_LOG << "DistributedSchedAdapterTest ProcessCalleeDied_003 end" << std::endl;
277 }
278
279 /**
280 * @tc.name: ProcessCallerDied_001
281 * @tc.desc: dmsAdapterHandler_ is nullptr
282 * @tc.type: FUNC
283 * @tc.require: I5WKCK
284 */
285 HWTEST_F(DistributedSchedAdapterTest, ProcessCallerDied_001, TestSize.Level3)
286 {
287 DTEST_LOG << "DistributedSchedAdapterTest ProcessCallerDied_001 begin" << std::endl;
288 const sptr<IRemoteObject> connect;
289 int32_t deviceType = 0;
290 distributedSchedAdapter_->dmsAdapterHandler_ = nullptr;
291 distributedSchedAdapter_->ProcessCallerDied(connect, deviceType);
292 EXPECT_EQ(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
293 DTEST_LOG << "DistributedSchedAdapterTest ProcessCallerDied_001 end" << std::endl;
294 }
295
296 /**
297 * @tc.name: ProcessCallerDied_002
298 * @tc.desc: connect is nullptr
299 * @tc.type: FUNC
300 * @tc.require: I5WKCK
301 */
302 HWTEST_F(DistributedSchedAdapterTest, ProcessCallerDied_002, TestSize.Level3)
303 {
304 DTEST_LOG << "DistributedSchedAdapterTest ProcessCallerDied_002 begin" << std::endl;
305 const sptr<IRemoteObject> connect = nullptr;
306 int32_t deviceType = 0;
307 distributedSchedAdapter_->ProcessCallerDied(connect, deviceType);
308 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
309 DTEST_LOG << "DistributedSchedAdapterTest ProcessCallerDied_002 end" << std::endl;
310 }
311
312 /**
313 * @tc.name: ProcessCallerDied_003
314 * @tc.desc: process caller died
315 * @tc.type: FUNC
316 * @tc.require: I60TOK
317 */
318 HWTEST_F(DistributedSchedAdapterTest, ProcessCallerDied_003, TestSize.Level3)
319 {
320 DTEST_LOG << "DistributedSchedAdapterTest ProcessCallerDied_003 begin" << std::endl;
321 const sptr<IRemoteObject> connect = new MockRemoteStub();
322 int32_t deviceType = 0;
323 distributedSchedAdapter_->ProcessCallerDied(connect, deviceType);
324 EXPECT_NE(distributedSchedAdapter_->dmsAdapterHandler_, nullptr);
325 DTEST_LOG << "DistributedSchedAdapterTest ProcessCallerDied_003 end" << std::endl;
326 }
327
328 /**
329 * @tc.name: GetLocalMissionInfos_001
330 * @tc.desc: numMissions is invalid
331 * @tc.type: FUNC
332 * @tc.require: I5WKCK
333 */
334 HWTEST_F(DistributedSchedAdapterTest, GetLocalMissionInfos_001, TestSize.Level4)
335 {
336 DTEST_LOG << "DistributedSchedAdapterTest GetLocalMissionInfos_001 begin" << std::endl;
337 int32_t numMissions = -1;
338 std::vector<DstbMissionInfo> missionInfos;
339 int32_t result = distributedSchedAdapter_->GetLocalMissionInfos(numMissions, missionInfos);
340 EXPECT_NE(result, ERR_OK);
341 DTEST_LOG << "DistributedSchedAdapterTest GetLocalMissionInfos_001 end" << std::endl;
342 }
343
344 /**
345 * @tc.name: GetLocalMissionInfos_002
346 * @tc.desc: numMissions is zero
347 * @tc.type: FUNC
348 * @tc.require: I5WKCK
349 */
350 HWTEST_F(DistributedSchedAdapterTest, GetLocalMissionInfos_002, TestSize.Level4)
351 {
352 DTEST_LOG << "DistributedSchedAdapterTest GetLocalMissionInfos_002 begin" << std::endl;
353 int32_t numMissions = 0;
354 std::vector<DstbMissionInfo> missionInfos;
355 int32_t result = distributedSchedAdapter_->GetLocalMissionInfos(numMissions, missionInfos);
356 EXPECT_NE(result, ERR_OK);
357 DTEST_LOG << "DistributedSchedAdapterTest GetLocalMissionInfos_002 end" << std::endl;
358 }
359
360 /**
361 * @tc.name: GetLocalMissionInfos_003
362 * @tc.desc: numMissions is not zero
363 * @tc.type: FUNC
364 * @tc.require: I5WKCK
365 */
366 HWTEST_F(DistributedSchedAdapterTest, GetLocalMissionInfos_003, TestSize.Level4)
367 {
368 DTEST_LOG << "DistributedSchedAdapterTest GetLocalMissionInfos_003 begin" << std::endl;
369 int32_t numMissions = 10;
370 std::vector<DstbMissionInfo> missionInfos;
371 int32_t result = distributedSchedAdapter_->GetLocalMissionInfos(numMissions, missionInfos);
372 EXPECT_NE(result, ERR_OK);
373 DTEST_LOG << "DistributedSchedAdapterTest GetLocalMissionInfos_003 end" << std::endl;
374 }
375
376 /**
377 * @tc.name: RegisterMissionListener_001
378 * @tc.desc: listener is nullptr
379 * @tc.type: FUNC
380 * @tc.require: I5WKCK
381 */
382 HWTEST_F(DistributedSchedAdapterTest, RegisterMissionListener_001, TestSize.Level4)
383 {
384 DTEST_LOG << "DistributedSchedAdapterTest RegisterMissionListener_001 begin" << std::endl;
385 const sptr<DistributedMissionChangeListener> listener = nullptr;
386 int32_t result = distributedSchedAdapter_->RegisterMissionListener(listener);
387 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
388 DTEST_LOG << "DistributedSchedAdapterTest RegisterMissionListener_001 end" << std::endl;
389 }
390
391 /**
392 * @tc.name: RegisterMissionListener_002
393 * @tc.desc: listener is not nullptr
394 * @tc.type: FUNC
395 * @tc.require: I5WKCK
396 */
397 HWTEST_F(DistributedSchedAdapterTest, RegisterMissionListener_002, TestSize.Level4)
398 {
399 DTEST_LOG << "DistributedSchedAdapterTest RegisterMissionListener_002 begin" << std::endl;
400 const sptr<IRemoteObject> connect = new MockRemoteStub();
401 distributedSchedAdapter_->ProcessCallResult(connect, nullptr);
402 const sptr<DistributedMissionChangeListener> listener = new DistributedMissionChangeListener();
403 int32_t result = distributedSchedAdapter_->RegisterMissionListener(listener);
404 EXPECT_NE(result, ERR_OK);
405 DTEST_LOG << "DistributedSchedAdapterTest RegisterMissionListener_002 end" << std::endl;
406 }
407
408 /**
409 * @tc.name: UnRegisterMissionListener_001
410 * @tc.desc: listener is nullptr
411 * @tc.type: FUNC
412 * @tc.require: I5WKCK
413 */
414 HWTEST_F(DistributedSchedAdapterTest, UnRegisterMissionListener_001, TestSize.Level4)
415 {
416 DTEST_LOG << "DistributedSchedAdapterTest UnRegisterMissionListener_001 begin" << std::endl;
417 const sptr<IRemoteObject> connect = new MockRemoteStub();
418 distributedSchedAdapter_->ProcessCallResult(nullptr, connect);
419 const sptr<DistributedMissionChangeListener> listener = nullptr;
420 int32_t result = distributedSchedAdapter_->UnRegisterMissionListener(listener);
421 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
422 DTEST_LOG << "DistributedSchedAdapterTest UnRegisterMissionListener_001 end" << std::endl;
423 }
424
425 /**
426 * @tc.name: UnRegisterMissionListener_002
427 * @tc.desc: listener is nullptr
428 * @tc.type: FUNC
429 * @tc.require: I5WKCK
430 */
431 HWTEST_F(DistributedSchedAdapterTest, UnRegisterMissionListener_002, TestSize.Level4)
432 {
433 DTEST_LOG << "DistributedSchedAdapterTest UnRegisterMissionListener_002 begin" << std::endl;
434 const sptr<IRemoteObject> connect = new MockRemoteStub();
435 distributedSchedAdapter_->ProcessCallResult(connect, connect);
436 const sptr<DistributedMissionChangeListener> listener = new DistributedMissionChangeListener();
437 int32_t result = distributedSchedAdapter_->UnRegisterMissionListener(listener);
438 EXPECT_NE(result, INVALID_PARAMETERS_ERR);
439 DTEST_LOG << "DistributedSchedAdapterTest UnRegisterMissionListener_002 end" << std::endl;
440 }
441
442 /**
443 * @tc.name: GetLocalMissionSnapshotInfo_001
444 * @tc.desc: networkId is invalid
445 * @tc.type: FUNC
446 * @tc.require: I5WKCK
447 */
448 HWTEST_F(DistributedSchedAdapterTest, GetLocalMissionSnapshotInfo_001, TestSize.Level4)
449 {
450 DTEST_LOG << "DistributedSchedAdapterTest GetLocalMissionSnapshotInfo_001 begin" << std::endl;
451 distributedSchedAdapter_->ProcessCallResult(nullptr, nullptr);
452 const std::string networkId = "invalidNetworkId";
453 int32_t missionId = 0;
454 AAFwk::MissionSnapshot missionSnapshot;
455 int32_t result = distributedSchedAdapter_->GetLocalMissionSnapshotInfo(networkId, missionId, missionSnapshot);
456 EXPECT_NE(result, ERR_OK);
457 DTEST_LOG << "DistributedSchedAdapterTest GetLocalMissionSnapshotInfo_001 end" << std::endl;
458 }
459 }
460 }