1 /*
2 * Copyright (c) 2022-2024 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 "dms_callback_task_test.h"
17 #include "dtbschedmgr_log.h"
18 #include "mock_remote_stub.h"
19 #include "test_log.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace DistributedSchedule {
SetUpTestCase()26 void DmsCallbackTaskTest::SetUpTestCase()
27 {
28 DTEST_LOG << "DmsCallbackTaskTest::SetUpTestCase" << std::endl;
29 }
30
TearDownTestCase()31 void DmsCallbackTaskTest::TearDownTestCase()
32 {
33 DTEST_LOG << "DmsCallbackTaskTest::TearDownTestCase" << std::endl;
34 }
35
TearDown()36 void DmsCallbackTaskTest::TearDown()
37 {
38 DTEST_LOG << "DmsCallbackTaskTest::TearDown" << std::endl;
39 }
40
SetUp()41 void DmsCallbackTaskTest::SetUp()
42 {
43 DmsCallbackTaskInitCallbackFunc mockCallback = [this] (int64_t taskId) {};
44 dmsCallbackTask_ = std::make_shared<DmsCallbackTask>();
45 dmsCallbackTask_->Init(mockCallback);
46 DTEST_LOG << "DmsCallbackTaskTest::SetUp" << std::endl;
47 }
48
PushMockTask(int64_t taskId,std::string & deviceId)49 void DmsCallbackTaskTest::PushMockTask(int64_t taskId, std::string& deviceId)
50 {
51 sptr<IRemoteObject> callback = nullptr;
52 LaunchType launchType = LaunchType::FREEINSTALL_CONTINUE;
53 OHOS::AAFwk::Want want;
54 CallbackTaskItem item {
55 .callback = callback,
56 .taskId = taskId,
57 .launchType = launchType,
58 .deviceId = deviceId,
59 .want = want,
60 };
61 dmsCallbackTask_->callbackMap_.emplace(taskId, item);
62 }
63
64 /**
65 * @tc.name: GenerateTaskId_001
66 * @tc.desc: currTaskId_ is INT64_MAX
67 * @tc.type: FUNC
68 * @tc.require: I5VIZT
69 */
70 HWTEST_F(DmsCallbackTaskTest, GenerateTaskId_001, TestSize.Level4)
71 {
72 DTEST_LOG << "DmsCallbackTaskTest GenerateTaskId_001 begin" << std::endl;
73 dmsCallbackTask_->currTaskId_ = INT64_MAX;
74 int64_t currValue = dmsCallbackTask_->GenerateTaskId();
75 EXPECT_EQ(currValue, INT64_MAX);
76 EXPECT_EQ(dmsCallbackTask_->currTaskId_, 1);
77 DTEST_LOG << "DmsCallbackTaskTest GenerateTaskId_001 end" << std::endl;
78 }
79
80 /**
81 * @tc.name: GenerateTaskId_002
82 * @tc.desc: currTaskId_ is greater than zero
83 * @tc.type: FUNC
84 * @tc.require: I5VIZT
85 */
86 HWTEST_F(DmsCallbackTaskTest, GenerateTaskId_002, TestSize.Level3)
87 {
88 DTEST_LOG << "DmsCallbackTaskTest GenerateTaskId_002 begin" << std::endl;
89 dmsCallbackTask_->currTaskId_ = 1;
90 int64_t currValue = dmsCallbackTask_->GenerateTaskId();
91 EXPECT_EQ(currValue, 1);
92 EXPECT_EQ(dmsCallbackTask_->currTaskId_, 2);
93 DTEST_LOG << "DmsCallbackTaskTest GenerateTaskId_002 end" << std::endl;
94 }
95
96 /**
97 * @tc.name: PushCallback_001
98 * @tc.desc: invalid taskId
99 * @tc.type: FUNC
100 * @tc.require: I5VIZT
101 */
102 HWTEST_F(DmsCallbackTaskTest, PushCallback_001, TestSize.Level3)
103 {
104 DTEST_LOG << "DmsCallbackTaskTest PushCallback_001 begin" << std::endl;
105 int64_t taskId = -1;
106 sptr<IRemoteObject> callback = nullptr;
107 std::string deviceId = "mockDeviceId";
108 LaunchType launchType = LaunchType::FREEINSTALL_START;
109 OHOS::AAFwk::Want want;
110 int32_t result = dmsCallbackTask_->PushCallback(taskId, callback, deviceId,
111 launchType, want);
112 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
113 DTEST_LOG << "DmsCallbackTaskTest PushCallback_001 end" << std::endl;
114 }
115
116 /**
117 * @tc.name: PushCallback_002
118 * @tc.desc: callback is nullptr
119 * @tc.type: FUNC
120 * @tc.require: I5VIZT
121 */
122 HWTEST_F(DmsCallbackTaskTest, PushCallback_002, TestSize.Level3)
123 {
124 DTEST_LOG << "DmsCallbackTaskTest PushCallback_002 begin" << std::endl;
125 int64_t taskId = 1;
126 sptr<IRemoteObject> callback = nullptr;
127 std::string deviceId = "mockDeviceId";
128 LaunchType launchType = LaunchType::FREEINSTALL_START;
129 OHOS::AAFwk::Want want;
130 int32_t result = dmsCallbackTask_->PushCallback(taskId, callback, deviceId,
131 launchType, want);
132 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
133 DTEST_LOG << "DmsCallbackTaskTest PushCallback_002 end" << std::endl;
134 }
135
136 /**
137 * @tc.name: PushCallback_003
138 * @tc.desc: dmsCallbackHandler_ is nullptr
139 * @tc.type: FUNC
140 * @tc.require: I5VIZT
141 */
142 HWTEST_F(DmsCallbackTaskTest, PushCallback_003, TestSize.Level3)
143 {
144 DTEST_LOG << "DmsCallbackTaskTest PushCallback_003 begin" << std::endl;
145 int64_t taskId = 1;
146 sptr<IRemoteObject> callback(new MockRemoteStub());
147 std::string deviceId = "mockDeviceId";
148 LaunchType launchType = LaunchType::FREEINSTALL_START;
149 OHOS::AAFwk::Want want;
150 dmsCallbackTask_->dmsCallbackHandler_ = nullptr;
151 int32_t result = dmsCallbackTask_->PushCallback(taskId, callback, deviceId,
152 launchType, want);
153 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
154 DTEST_LOG << "DmsCallbackTaskTest PushCallback_003 end" << std::endl;
155 }
156
157 /**
158 * @tc.name: PushCallback_004
159 * @tc.desc: launchType is FREEINSTALL_CONTINUE
160 * @tc.type: FUNC
161 * @tc.require: I5VIZT
162 */
163 HWTEST_F(DmsCallbackTaskTest, PushCallback_004, TestSize.Level3)
164 {
165 DTEST_LOG << "DmsCallbackTaskTest PushCallback_004 begin" << std::endl;
166 int64_t taskId = 1;
167 sptr<IRemoteObject> callback(new MockRemoteStub());
168 std::string deviceId = "mockDeviceId";
169 LaunchType launchType = LaunchType::FREEINSTALL_CONTINUE;
170 OHOS::AAFwk::Want want;
171 dmsCallbackTask_->dmsCallbackHandler_ = nullptr;
172 int32_t result = dmsCallbackTask_->PushCallback(taskId, callback, deviceId,
173 launchType, want);
174 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
175 DTEST_LOG << "DmsCallbackTaskTest PushCallback_004 end" << std::endl;
176 }
177
178 /**
179 * @tc.name: PushCallback_005
180 * @tc.desc: taskId is exist
181 * @tc.type: FUNC
182 * @tc.require: I5VIZT
183 */
184 HWTEST_F(DmsCallbackTaskTest, PushCallback_005, TestSize.Level3)
185 {
186 DTEST_LOG << "DmsCallbackTaskTest PushCallback_005 begin" << std::endl;
187 int64_t taskId = 1;
188 sptr<IRemoteObject> callback(new MockRemoteStub());
189 std::string deviceId = "mockDeviceId";
190 LaunchType launchType = LaunchType::FREEINSTALL_CONTINUE;
191 OHOS::AAFwk::Want want;
192 PushMockTask(taskId, deviceId);
193 int32_t result = dmsCallbackTask_->PushCallback(taskId, callback, deviceId,
194 launchType, want);
195 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
196 DTEST_LOG << "DmsCallbackTaskTest PushCallback_005 end" << std::endl;
197 }
198
199 /**
200 * @tc.name: PushCallback_006
201 * @tc.desc: PushCallback success
202 * @tc.type: FUNC
203 * @tc.require: I5VIZT
204 */
205 HWTEST_F(DmsCallbackTaskTest, PushCallback_006, TestSize.Level1)
206 {
207 DTEST_LOG << "DmsCallbackTaskTest PushCallback_006 begin" << std::endl;
208 int64_t taskId = 1;
209 sptr<IRemoteObject> callback(new MockRemoteStub());
210 std::string deviceId = "mockDeviceId";
211 LaunchType launchType = LaunchType::FREEINSTALL_CONTINUE;
212 OHOS::AAFwk::Want want;
213 int32_t result = dmsCallbackTask_->PushCallback(taskId, callback, deviceId,
214 launchType, want);
215 EXPECT_EQ(result, ERR_OK);
216 DTEST_LOG << "DmsCallbackTaskTest PushCallback_006 end" << std::endl;
217 }
218
219 /**
220 * @tc.name: PopCallback_001
221 * @tc.desc: taskId is not exist
222 * @tc.type: FUNC
223 * @tc.require: I5VIZT
224 */
225 HWTEST_F(DmsCallbackTaskTest, PopCallback_001, TestSize.Level3)
226 {
227 DTEST_LOG << "DmsCallbackTaskTest PopCallback_001 begin" << std::endl;
228 int64_t taskId = 1;
229 CallbackTaskItem result = dmsCallbackTask_->PopCallback(taskId);
230 EXPECT_EQ(result.taskId, -1);
231 DTEST_LOG << "DmsCallbackTaskTest PopCallback_001 end" << std::endl;
232 }
233
234 /**
235 * @tc.name: PopCallback_002
236 * @tc.desc: taskId is exist
237 * @tc.type: FUNC
238 * @tc.require: I5VIZT
239 */
240 HWTEST_F(DmsCallbackTaskTest, PopCallback_002, TestSize.Level1)
241 {
242 DTEST_LOG << "DmsCallbackTaskTest PopCallback_002 begin" << std::endl;
243 int64_t taskId = 1;
244 std::string deviceId = "";
245 PushMockTask(taskId, deviceId);
246 CallbackTaskItem result = dmsCallbackTask_->PopCallback(taskId);
247 EXPECT_EQ(result.taskId, 1);
248 DTEST_LOG << "DmsCallbackTaskTest PopCallback_002 end" << std::endl;
249 }
250
251 /**
252 * @tc.name: PopContinuationMissionMap_001
253 * @tc.desc: taskId is exsit
254 * @tc.type: FUNC
255 * @tc.require: I5VIZT
256 */
257 HWTEST_F(DmsCallbackTaskTest, PopContinuationMissionMap_001, TestSize.Level3)
258 {
259 DTEST_LOG << "DmsCallbackTaskTest PopContinuationMissionMap_001 begin" << std::endl;
260 int64_t taskId = 1;
261 int64_t mockMissionId = 2;
262 dmsCallbackTask_->continuationMissionMap_.emplace(taskId, mockMissionId);
263 dmsCallbackTask_->PopContinuationMissionMap(taskId);
264 EXPECT_EQ(dmsCallbackTask_->continuationMissionMap_.size(), 0);
265 DTEST_LOG << "DmsCallbackTaskTest PopContinuationMissionMap_001 end" << std::endl;
266 }
267
268 /**
269 * @tc.name: PopContinuationMissionMap_002
270 * @tc.desc: taskId is not exsit
271 * @tc.type: FUNC
272 * @tc.require: I5VIZT
273 */
274 HWTEST_F(DmsCallbackTaskTest, PopContinuationMissionMap_002, TestSize.Level3)
275 {
276 DTEST_LOG << "DmsCallbackTaskTest PopContinuationMissionMap_002 begin" << std::endl;
277 int64_t taskId = 1;
278 int64_t mockTaskId = 2;
279 int64_t mockMissionId = 2;
280 dmsCallbackTask_->continuationMissionMap_.emplace(mockTaskId, mockMissionId);
281 dmsCallbackTask_->PopContinuationMissionMap(taskId);
282 EXPECT_EQ(dmsCallbackTask_->continuationMissionMap_.size(), 1);
283 DTEST_LOG << "DmsCallbackTaskTest PopContinuationMissionMap_002 end" << std::endl;
284 }
285
286 /**
287 * @tc.name: GetContinuaionMissionId_001
288 * @tc.desc: taskId is less than zero
289 * @tc.type: FUNC
290 * @tc.require: I5VIZT
291 */
292 HWTEST_F(DmsCallbackTaskTest, GetContinuaionMissionId_001, TestSize.Level3)
293 {
294 DTEST_LOG << "DmsCallbackTaskTest GetContinuaionMissionId_001 begin" << std::endl;
295 int64_t taskId = -1;
296 int32_t result = dmsCallbackTask_->GetContinuaionMissionId(taskId);
297 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
298 DTEST_LOG << "DmsCallbackTaskTest GetContinuaionMissionId_001 end" << std::endl;
299 }
300
301 /**
302 * @tc.name: GetContinuaionMissionId_002
303 * @tc.desc: taskId is not exsit
304 * @tc.type: FUNC
305 * @tc.require: I5VIZT
306 */
307 HWTEST_F(DmsCallbackTaskTest, GetContinuaionMissionId_002, TestSize.Level3)
308 {
309 DTEST_LOG << "DmsCallbackTaskTest GetContinuaionMissionId_002 begin" << std::endl;
310 int64_t taskId = 1;
311 int64_t result = dmsCallbackTask_->GetContinuaionMissionId(taskId);
312 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
313 DTEST_LOG << "DmsCallbackTaskTest GetContinuaionMissionId_002 end" << std::endl;
314 }
315
316 /**
317 * @tc.name: GetContinuaionMissionId_003
318 * @tc.desc: taskId is exsit
319 * @tc.type: FUNC
320 * @tc.require: I5VIZT
321 */
322 HWTEST_F(DmsCallbackTaskTest, GetContinuaionMissionId_003, TestSize.Level3)
323 {
324 DTEST_LOG << "DmsCallbackTaskTest GetContinuaionMissionId_003 begin" << std::endl;
325 int64_t taskId = 1;
326 int64_t mockMissionId = 2;
327 dmsCallbackTask_->continuationMissionMap_.emplace(taskId, mockMissionId);
328 int64_t result = dmsCallbackTask_->GetContinuaionMissionId(taskId);
329 EXPECT_EQ(result, mockMissionId);
330 DTEST_LOG << "DmsCallbackTaskTest GetContinuaionMissionId_003 end" << std::endl;
331 }
332
333 /**
334 * @tc.name: SetContinuationMissionMap_001
335 * @tc.desc: taskId is less than zero
336 * @tc.type: FUNC
337 * @tc.require: I5VIZT
338 */
339 HWTEST_F(DmsCallbackTaskTest, SetContinuationMissionMap_001, TestSize.Level3)
340 {
341 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_001 begin" << std::endl;
342 int64_t taskId = -1;
343 int64_t missionId = 1;
344 dmsCallbackTask_->SetContinuationMissionMap(taskId, missionId);
345 EXPECT_EQ(dmsCallbackTask_->continuationMissionMap_.size(), 0);
346 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_001 end" << std::endl;
347 }
348
349 /**
350 * @tc.name: SetContinuationMissionMap_002
351 * @tc.desc: missionId is less than zero
352 * @tc.type: FUNC
353 * @tc.require: I5VIZT
354 */
355 HWTEST_F(DmsCallbackTaskTest, SetContinuationMissionMap_002, TestSize.Level3)
356 {
357 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_002 begin" << std::endl;
358 int64_t taskId = 1;
359 int64_t missionId = -1;
360 dmsCallbackTask_->SetContinuationMissionMap(taskId, missionId);
361 EXPECT_EQ(dmsCallbackTask_->continuationMissionMap_.size(), 0);
362 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_002 end" << std::endl;
363 }
364
365 /**
366 * @tc.name: SetContinuationMissionMap_003
367 * @tc.desc: taskId is less than zero, missionId is less than zero
368 * @tc.type: FUNC
369 * @tc.require: I5VIZT
370 */
371 HWTEST_F(DmsCallbackTaskTest, SetContinuationMissionMap_003, TestSize.Level3)
372 {
373 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_003 begin" << std::endl;
374 int64_t taskId = -1;
375 int64_t missionId = -1;
376 dmsCallbackTask_->SetContinuationMissionMap(taskId, missionId);
377 EXPECT_EQ(dmsCallbackTask_->continuationMissionMap_.size(), 0);
378 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_003 end" << std::endl;
379 }
380
381 /**
382 * @tc.name: SetContinuationMissionMap_004
383 * @tc.desc: taskId is less than zero, missionId is less than zero
384 * @tc.type: FUNC
385 * @tc.require: I5VIZT
386 */
387 HWTEST_F(DmsCallbackTaskTest, SetContinuationMissionMap_004, TestSize.Level3)
388 {
389 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_004 begin" << std::endl;
390 int64_t taskId = -1;
391 int64_t missionId = -1;
392 dmsCallbackTask_->SetContinuationMissionMap(taskId, missionId);
393 EXPECT_EQ(dmsCallbackTask_->continuationMissionMap_.size(), 0);
394 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_004 end" << std::endl;
395 }
396
397 /**
398 * @tc.name: SetContinuationMissionMap_005
399 * @tc.desc: taskId is exsit
400 * @tc.type: FUNC
401 * @tc.require: I5VIZT
402 */
403 HWTEST_F(DmsCallbackTaskTest, SetContinuationMissionMap_005, TestSize.Level3)
404 {
405 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_005 begin" << std::endl;
406 int64_t taskId = 1;
407 int64_t missionId = 1;
408 dmsCallbackTask_->continuationMissionMap_.emplace(taskId, missionId);
409 dmsCallbackTask_->SetContinuationMissionMap(taskId, missionId);
410 EXPECT_EQ(dmsCallbackTask_->continuationMissionMap_.size(), 1);
411 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_005 end" << std::endl;
412 }
413
414 /**
415 * @tc.name: SetContinuationMissionMap_006
416 * @tc.desc: taskId is not exsit
417 * @tc.type: FUNC
418 * @tc.require: I5VIZT
419 */
420 HWTEST_F(DmsCallbackTaskTest, SetContinuationMissionMap_006, TestSize.Level1)
421 {
422 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_006 begin" << std::endl;
423 int64_t taskId = 1;
424 int64_t missionId = 1;
425 dmsCallbackTask_->SetContinuationMissionMap(taskId, missionId);
426 EXPECT_EQ(dmsCallbackTask_->continuationMissionMap_.size(), 1);
427 DTEST_LOG << "DmsCallbackTaskTest SetContinuationMissionMap_006 end" << std::endl;
428 }
429
430 /**
431 * @tc.name: GetLaunchType_001
432 * @tc.desc: taskId is less than zero
433 * @tc.type: FUNC
434 * @tc.require: I5VIZT
435 */
436 HWTEST_F(DmsCallbackTaskTest, GetLaunchType_001, TestSize.Level3)
437 {
438 DTEST_LOG << "DmsCallbackTaskTest GetLaunchType_001 begin" << std::endl;
439 int64_t taskId = -1;
440 LaunchType launchType = dmsCallbackTask_->GetLaunchType(taskId);
441 EXPECT_EQ(launchType, LaunchType::FREEINSTALL_START);
442 DTEST_LOG << "DmsCallbackTaskTest GetLaunchType_001 end" << std::endl;
443 }
444
445 /**
446 * @tc.name: GetLaunchType_002
447 * @tc.desc: taskId is less than zero
448 * @tc.type: FUNC
449 * @tc.require: I5VIZT
450 */
451 HWTEST_F(DmsCallbackTaskTest, GetLaunchType_002, TestSize.Level3)
452 {
453 DTEST_LOG << "DmsCallbackTaskTest GetLaunchType_002 begin" << std::endl;
454 int64_t taskId = -1;
455 LaunchType launchType = dmsCallbackTask_->GetLaunchType(taskId);
456 EXPECT_EQ(launchType, LaunchType::FREEINSTALL_START);
457 DTEST_LOG << "DmsCallbackTaskTest GetLaunchType_002 end" << std::endl;
458 }
459
460 /**
461 * @tc.name: GetLaunchType_003
462 * @tc.desc: taskId is not exsit
463 * @tc.type: FUNC
464 * @tc.require: I5VIZT
465 */
466 HWTEST_F(DmsCallbackTaskTest, GetLaunchType_003, TestSize.Level3)
467 {
468 DTEST_LOG << "DmsCallbackTaskTest GetLaunchType_003 begin" << std::endl;
469 int64_t taskId = 1;
470 LaunchType launchType = dmsCallbackTask_->GetLaunchType(taskId);
471 EXPECT_EQ(launchType, LaunchType::FREEINSTALL_START);
472 DTEST_LOG << "DmsCallbackTaskTest GetLaunchType_003 end" << std::endl;
473 }
474
475 /**
476 * @tc.name: GetLaunchType_004
477 * @tc.desc: taskId is exsit
478 * @tc.type: FUNC
479 * @tc.require: I5VIZT
480 */
481 HWTEST_F(DmsCallbackTaskTest, GetLaunchType_004, TestSize.Level3)
482 {
483 DTEST_LOG << "DmsCallbackTaskTest GetLaunchType_004 begin" << std::endl;
484 int64_t taskId = 1;
485 std::string deviceId = "";
486 PushMockTask(taskId, deviceId);
487 LaunchType launchType = dmsCallbackTask_->GetLaunchType(taskId);
488 EXPECT_EQ(launchType, LaunchType::FREEINSTALL_CONTINUE);
489 DTEST_LOG << "DmsCallbackTaskTest GetLaunchType_004 end" << std::endl;
490 }
491
492 /**
493 * @tc.name: NotifyDeviceOffline_001
494 * @tc.desc: taskId is exsit
495 * @tc.type: FUNC
496 * @tc.require: I5VIZT
497 */
498 HWTEST_F(DmsCallbackTaskTest, NotifyDeviceOffline_001, TestSize.Level3)
499 {
500 DTEST_LOG << "DmsCallbackTaskTest NotifyDeviceOffline_001 begin" << std::endl;
501 int64_t taskId = 1;
502 std::string deviceId = "mockDeviceId";
503 PushMockTask(taskId, deviceId);
504 dmsCallbackTask_->NotifyDeviceOffline(deviceId);
505 EXPECT_EQ(dmsCallbackTask_->callbackMap_.size(), 0);
506 DTEST_LOG << "DmsCallbackTaskTest NotifyDeviceOffline_001 end" << std::endl;
507 }
508
509 /**
510 * @tc.name: NotifyDeviceOffline_002
511 * @tc.desc: taskId is not exsit
512 * @tc.type: FUNC
513 * @tc.require: I5VIZT
514 */
515 HWTEST_F(DmsCallbackTaskTest, NotifyDeviceOffline_002, TestSize.Level3)
516 {
517 DTEST_LOG << "DmsCallbackTaskTest NotifyDeviceOffline_002 begin" << std::endl;
518 int64_t mockTaskId = 1;
519 std::string mockDeviceId = "mockDeviceId";
520 PushMockTask(mockTaskId, mockDeviceId);
521 std::string deviceId = "deviceId";
522 dmsCallbackTask_->NotifyDeviceOffline(deviceId);
523 EXPECT_EQ(dmsCallbackTask_->callbackMap_.size(), 1);
524 DTEST_LOG << "DmsCallbackTaskTest NotifyDeviceOffline_002 end" << std::endl;
525 }
526
527 /**
528 * @tc.name: NotifyDeviceOffline_003
529 * @tc.desc: dmsCallbackHandler_ is nullptr
530 * @tc.type: FUNC
531 * @tc.require: I5VIZT
532 */
533 HWTEST_F(DmsCallbackTaskTest, NotifyDeviceOffline_003, TestSize.Level3)
534 {
535 DTEST_LOG << "DmsCallbackTaskTest NotifyDeviceOffline_003 begin" << std::endl;
536 int64_t taskId = 1;
537 std::string deviceId = "mockDeviceId";
538 dmsCallbackTask_->dmsCallbackHandler_ = nullptr;
539 PushMockTask(taskId, deviceId);
540 dmsCallbackTask_->NotifyDeviceOffline(deviceId);
541 EXPECT_EQ(dmsCallbackTask_->callbackMap_.size(), 0);
542 DTEST_LOG << "DmsCallbackTaskTest NotifyDeviceOffline_003 end" << std::endl;
543 }
544
545 /**
546 * @tc.name: ProcessEvent_001
547 * @tc.desc: event is nullptr
548 * @tc.type: FUNC
549 * @tc.require: I64FU7
550 */
551 HWTEST_F(DmsCallbackTaskTest, ProcessEvent_001, TestSize.Level3)
552 {
553 DTEST_LOG << "DmsCallbackTaskTest ProcessEvent_001 begin" << std::endl;
554 AppExecFwk::InnerEvent *event = nullptr;
__anon40baf4180202(AppExecFwk::InnerEvent *event) 555 auto destructor = [](AppExecFwk::InnerEvent *event) {
556 if (event != nullptr) {
557 delete event;
558 }
559 };
560 dmsCallbackTask_->dmsCallbackHandler_->ProcessEvent(AppExecFwk::InnerEvent::Pointer(event, destructor));
561 EXPECT_EQ(event, nullptr);
562 DTEST_LOG << "DmsCallbackTaskTest ProcessEvent_001 end" << std::endl;
563 }
564
565 /**
566 * @tc.name: ProcessEvent_002
567 * @tc.desc: taskId is invalid
568 * @tc.type: FUNC
569 * @tc.require: I64FU7
570 */
571 HWTEST_F(DmsCallbackTaskTest, ProcessEvent_002, TestSize.Level3)
572 {
573 DTEST_LOG << "DmsCallbackTaskTest ProcessEvent_002 begin" << std::endl;
574 AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
575 event->innerEventId_ = static_cast<uint32_t>(-1);
__anon40baf4180302(AppExecFwk::InnerEvent *event) 576 auto destructor = [](AppExecFwk::InnerEvent *event) {
577 if (event != nullptr) {
578 delete event;
579 }
580 };
581 dmsCallbackTask_->dmsCallbackHandler_->ProcessEvent(AppExecFwk::InnerEvent::Pointer(event, destructor));
582 EXPECT_NE(event, nullptr);
583 DTEST_LOG << "DmsCallbackTaskTest ProcessEvent_002 end" << std::endl;
584 }
585
586 /**
587 * @tc.name: ProcessEvent_003
588 * @tc.desc: callback_ is nullptr
589 * @tc.type: FUNC
590 * @tc.require: I64FU7
591 */
592 HWTEST_F(DmsCallbackTaskTest, ProcessEvent_003, TestSize.Level3)
593 {
594 DTEST_LOG << "DmsCallbackTaskTest ProcessEvent_003 begin" << std::endl;
595 AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
596 event->innerEventId_ = 1u;
__anon40baf4180402(AppExecFwk::InnerEvent *event) 597 auto destructor = [](AppExecFwk::InnerEvent *event) {
598 if (event != nullptr) {
599 delete event;
600 }
601 };
602 dmsCallbackTask_->dmsCallbackHandler_->callback_ = nullptr;
603 dmsCallbackTask_->dmsCallbackHandler_->ProcessEvent(AppExecFwk::InnerEvent::Pointer(event, destructor));
604 EXPECT_NE(event, nullptr);
605 DTEST_LOG << "DmsCallbackTaskTest ProcessEvent_003 end" << std::endl;
606 }
607
608 /**
609 * @tc.name: ProcessEvent_004
610 * @tc.desc: callback_ is not nullptr
611 * @tc.type: FUNC
612 * @tc.require: I64FU7
613 */
614 HWTEST_F(DmsCallbackTaskTest, ProcessEvent_004, TestSize.Level3)
615 {
616 DTEST_LOG << "DmsCallbackTaskTest ProcessEvent_004 begin" << std::endl;
617 AppExecFwk::InnerEvent *event = new AppExecFwk::InnerEvent();
618 event->innerEventId_ = 1u;
__anon40baf4180502(AppExecFwk::InnerEvent *event) 619 auto destructor = [](AppExecFwk::InnerEvent *event) {
620 if (event != nullptr) {
621 delete event;
622 }
623 };
624 dmsCallbackTask_->dmsCallbackHandler_->ProcessEvent(AppExecFwk::InnerEvent::Pointer(event, destructor));
625 EXPECT_NE(event, nullptr);
626 DTEST_LOG << "DmsCallbackTaskTest ProcessEvent_004 end" << std::endl;
627 }
628 }
629 }