1 /*
2 * Copyright (c) 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 "distributed_radar_test.h"
17
18 using namespace testing;
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace DistributedSchedule {
23
24 namespace {
25 const std::string DEVICE_ID = "DeviceId";
26 const std::string BUNDLE_NAME = "BundleName";
27 }
28
SetUpTestCase()29 void DistributedRadarTest::SetUpTestCase()
30 {
31 DTEST_LOG << "DistributedRadarTest::SetUpTestCase" << std::endl;
32 }
33
TearDownTestCase()34 void DistributedRadarTest::TearDownTestCase()
35 {
36 DTEST_LOG << "DistributedRadarTest::TearDownTestCase" << std::endl;
37 }
38
TearDown()39 void DistributedRadarTest::TearDown()
40 {
41 DTEST_LOG << "DistributedRadarTest::TearDown" << std::endl;
42 }
43
SetUp()44 void DistributedRadarTest::SetUp()
45 {
46 DTEST_LOG << "DistributedRadarTest::SetUp" << std::endl;
47 }
48
49 /**
50 * @tc.name: RegisterSoftbusCallbackRes_001
51 * @tc.desc: check RegisterSoftbusCallbackRes
52 * @tc.type: FUNC
53 */
54 HWTEST_F(DistributedRadarTest, RegisterSoftbusCallbackRes_001, TestSize.Level3)
55 {
56 DTEST_LOG << "DistributedRadarTest RegisterSoftbusCallbackRes_001 begin" << std::endl;
57 bool ret = DmsRadar::GetInstance().RegisterSoftbusCallbackRes(FUNC, ERR_OK);
58 EXPECT_EQ(ret, true);
59 DTEST_LOG << "DistributedRadarTest RegisterSoftbusCallbackRes_001 end" << std::endl;
60 }
61
62 /**
63 * @tc.name: RegisterSoftbusCallbackRes_002
64 * @tc.desc: check RegisterSoftbusCallbackRes
65 * @tc.type: FUNC
66 */
67 HWTEST_F(DistributedRadarTest, RegisterSoftbusCallbackRes_002, TestSize.Level3)
68 {
69 DTEST_LOG << "DistributedRadarTest RegisterSoftbusCallbackRes_002 begin" << std::endl;
70 bool ret = DmsRadar::GetInstance().RegisterSoftbusCallbackRes(FUNC, ERR_NO);
71 EXPECT_EQ(ret, true);
72 DTEST_LOG << "DistributedRadarTest RegisterSoftbusCallbackRes_002 end" << std::endl;
73 }
74
75 /**
76 * @tc.name: RegisterFocusedRes_001
77 * @tc.desc: check RegisterFocusedRes
78 * @tc.type: FUNC
79 */
80 HWTEST_F(DistributedRadarTest, RegisterFocusedRes_001, TestSize.Level3)
81 {
82 DTEST_LOG << "DistributedRadarTest RegisterFocusedRes_001 begin" << std::endl;
83 bool ret = DmsRadar::GetInstance().RegisterFocusedRes(FUNC, ERR_OK);
84 EXPECT_EQ(ret, true);
85 DTEST_LOG << "DistributedRadarTest RegisterFocusedRes_001 end" << std::endl;
86 }
87
88 /**
89 * @tc.name: RegisterFocusedRes_002
90 * @tc.desc: check RegisterFocusedRes
91 * @tc.type: FUNC
92 */
93 HWTEST_F(DistributedRadarTest, RegisterFocusedRes_002, TestSize.Level3)
94 {
95 DTEST_LOG << "DistributedRadarTest RegisterFocusedRes_002 begin" << std::endl;
96 bool ret = DmsRadar::GetInstance().RegisterFocusedRes(FUNC, ERR_NO);
97 EXPECT_EQ(ret, true);
98 DTEST_LOG << "DistributedRadarTest RegisterFocusedRes_002 end" << std::endl;
99 }
100
101 /**
102 * @tc.name: DmsFocused_001
103 * @tc.desc: check DmsFocused
104 * @tc.type: FUNC
105 */
106 HWTEST_F(DistributedRadarTest, DmsFocused_001, TestSize.Level3)
107 {
108 DTEST_LOG << "DistributedRadarTest DmsFocused_001 begin" << std::endl;
109 bool ret = DmsRadar::GetInstance().DmsFocused(FUNC, NORMAL);
110 EXPECT_EQ(ret, true);
111 DTEST_LOG << "DistributedRadarTest DmsFocused_001 end" << std::endl;
112 }
113
114 /**
115 * @tc.name: NormalFocusedSendEventRes_001
116 * @tc.desc: check NormalFocusedSendEventRes
117 * @tc.type: FUNC
118 */
119 HWTEST_F(DistributedRadarTest, NormalFocusedSendEventRes_001, TestSize.Level3)
120 {
121 DTEST_LOG << "DistributedRadarTest NormalFocusedSendEventRes_001 begin" << std::endl;
122 bool ret = DmsRadar::GetInstance().NormalFocusedSendEventRes(FUNC, ERR_OK);
123 EXPECT_EQ(ret, true);
124 DTEST_LOG << "DistributedRadarTest NormalFocusedSendEventRes_001 end" << std::endl;
125 }
126
127 /**
128 * @tc.name: NormalFocusedSendEventRes_002
129 * @tc.desc: check NormalFocusedSendEventRes
130 * @tc.type: FUNC
131 */
132 HWTEST_F(DistributedRadarTest, NormalFocusedSendEventRes_002, TestSize.Level3)
133 {
134 DTEST_LOG << "DistributedRadarTest NormalFocusedSendEventRes_002 begin" << std::endl;
135 bool ret = DmsRadar::GetInstance().NormalFocusedSendEventRes(FUNC, ERR_NO);
136 EXPECT_EQ(ret, true);
137 DTEST_LOG << "DistributedRadarTest NormalFocusedSendEventRes_002 end" << std::endl;
138 }
139
140 /**
141 * @tc.name: SetFocusedState_001
142 * @tc.desc: check SetFocusedState
143 * @tc.type: FUNC
144 */
145 HWTEST_F(DistributedRadarTest, SetFocusedState_001, TestSize.Level3)
146 {
147 DTEST_LOG << "DistributedRadarTest SetFocusedState_001 begin" << std::endl;
148 bool ret = DmsRadar::GetInstance().SetFocusedState(FUNC);
149 EXPECT_EQ(ret, true);
150 DTEST_LOG << "DistributedRadarTest SetFocusedState_001 end" << std::endl;
151 }
152
153 /**
154 * @tc.name: ChangeStateFocusedGetAccessTokenIdRes_001
155 * @tc.desc: check ChangeStateFocusedGetAccessTokenIdRes
156 * @tc.type: FUNC
157 */
158 HWTEST_F(DistributedRadarTest, ChangeStateFocusedGetAccessTokenIdRes_001, TestSize.Level3)
159 {
160 DTEST_LOG << "DistributedRadarTest ChangeStateFocusedGetAccessTokenIdRes_001 begin" << std::endl;
161 bool ret = DmsRadar::GetInstance().ChangeStateFocusedGetAccessTokenIdRes(FUNC, ERR_OK);
162 EXPECT_EQ(ret, true);
163 DTEST_LOG << "DistributedRadarTest ChangeStateFocusedGetAccessTokenIdRes_001 end" << std::endl;
164 }
165
166 /**
167 * @tc.name: ChangeStateFocusedGetAccessTokenIdRes_002
168 * @tc.desc: check ChangeStateFocusedGetAccessTokenIdRes
169 * @tc.type: FUNC
170 */
171 HWTEST_F(DistributedRadarTest, ChangeStateFocusedGetAccessTokenIdRes_002, TestSize.Level3)
172 {
173 DTEST_LOG << "DistributedRadarTest ChangeStateFocusedGetAccessTokenIdRes_002 begin" << std::endl;
174 bool ret = DmsRadar::GetInstance().ChangeStateFocusedGetAccessTokenIdRes(FUNC, ERR_NO);
175 EXPECT_EQ(ret, true);
176 DTEST_LOG << "DistributedRadarTest ChangeStateFocusedGetAccessTokenIdRes_002 end" << std::endl;
177 }
178
179 /**
180 * @tc.name: ChangeStateFocusedSendEventRes_001
181 * @tc.desc: check ChangeStateFocusedSendEventRes
182 * @tc.type: FUNC
183 */
184 HWTEST_F(DistributedRadarTest, ChangeStateFocusedSendEventRes_001, TestSize.Level3)
185 {
186 DTEST_LOG << "DistributedRadarTest ChangeStateFocusedSendEventRes_001 begin" << std::endl;
187 bool ret = DmsRadar::GetInstance().ChangeStateFocusedSendEventRes(FUNC, ERR_OK);
188 EXPECT_EQ(ret, true);
189 DTEST_LOG << "DistributedRadarTest ChangeStateFocusedSendEventRes_001 end" << std::endl;
190 }
191
192 /**
193 * @tc.name: ChangeStateFocusedSendEventRes_002
194 * @tc.desc: check ChangeStateFocusedSendEventRes
195 * @tc.type: FUNC
196 */
197 HWTEST_F(DistributedRadarTest, ChangeStateFocusedSendEventRes_002, TestSize.Level3)
198 {
199 DTEST_LOG << "DistributedRadarTest ChangeStateFocusedSendEventRes_002 begin" << std::endl;
200 bool ret = DmsRadar::GetInstance().ChangeStateFocusedSendEventRes(FUNC, ERR_NO);
201 EXPECT_EQ(ret, true);
202 DTEST_LOG << "DistributedRadarTest ChangeStateFocusedSendEventRes_002 end" << std::endl;
203 }
204
205 /**
206 * @tc.name: DmsUnfocused_001
207 * @tc.desc: check DmsUnfocused
208 * @tc.type: FUNC
209 */
210 HWTEST_F(DistributedRadarTest, DmsUnfocused_001, TestSize.Level3)
211 {
212 DTEST_LOG << "DistributedRadarTest DmsUnfocused_001 begin" << std::endl;
213 bool ret = DmsRadar::GetInstance().DmsUnfocused(FUNC);
214 EXPECT_EQ(ret, true);
215 DTEST_LOG << "DistributedRadarTest DmsUnfocused_001 end" << std::endl;
216 }
217
218 /**
219 * @tc.name: NormalUnfocusedGetAccessTokenIdRes_001
220 * @tc.desc: check NormalUnfocusedGetAccessTokenIdRes
221 * @tc.type: FUNC
222 */
223 HWTEST_F(DistributedRadarTest, NormalUnfocusedGetAccessTokenIdRes_001, TestSize.Level3)
224 {
225 DTEST_LOG << "DistributedRadarTest NormalUnfocusedGetAccessTokenIdRes_001 begin" << std::endl;
226 bool ret = DmsRadar::GetInstance().NormalUnfocusedGetAccessTokenIdRes(FUNC, ERR_OK);
227 EXPECT_EQ(ret, true);
228 DTEST_LOG << "DistributedRadarTest NormalUnfocusedGetAccessTokenIdRes_001 end" << std::endl;
229 }
230
231 /**
232 * @tc.name: NormalUnfocusedGetAccessTokenIdRes_002
233 * @tc.desc: check NormalUnfocusedGetAccessTokenIdRes
234 * @tc.type: FUNC
235 */
236 HWTEST_F(DistributedRadarTest, NormalUnfocusedGetAccessTokenIdRes_002, TestSize.Level3)
237 {
238 DTEST_LOG << "DistributedRadarTest NormalUnfocusedGetAccessTokenIdRes_002 begin" << std::endl;
239 bool ret = DmsRadar::GetInstance().NormalUnfocusedGetAccessTokenIdRes(FUNC, ERR_NO);
240 EXPECT_EQ(ret, true);
241 DTEST_LOG << "DistributedRadarTest NormalUnfocusedGetAccessTokenIdRes_002 end" << std::endl;
242 }
243
244 /**
245 * @tc.name: NormalUnfocusedSendEventRes_001
246 * @tc.desc: check NormalUnfocusedSendEventRes
247 * @tc.type: FUNC
248 */
249 HWTEST_F(DistributedRadarTest, NormalUnfocusedSendEventRes_001, TestSize.Level3)
250 {
251 DTEST_LOG << "DistributedRadarTest NormalUnfocusedSendEventRes_001 begin" << std::endl;
252 bool ret = DmsRadar::GetInstance().NormalUnfocusedSendEventRes(FUNC, ERR_OK);
253 EXPECT_EQ(ret, true);
254 DTEST_LOG << "DistributedRadarTest NormalUnfocusedSendEventRes_001 end" << std::endl;
255 }
256
257 /**
258 * @tc.name: NormalUnfocusedSendEventRes_002
259 * @tc.desc: check NormalUnfocusedSendEventRes
260 * @tc.type: FUNC
261 */
262 HWTEST_F(DistributedRadarTest, NormalUnfocusedSendEventRes_002, TestSize.Level3)
263 {
264 DTEST_LOG << "DistributedRadarTest NormalUnfocusedSendEventRes_002 begin" << std::endl;
265 bool ret = DmsRadar::GetInstance().NormalUnfocusedSendEventRes(FUNC, ERR_NO);
266 EXPECT_EQ(ret, true);
267 DTEST_LOG << "DistributedRadarTest NormalUnfocusedSendEventRes_002 end" << std::endl;
268 }
269
270 /**
271 * @tc.name: RecordTime_001
272 * @tc.desc: check RecordTime
273 * @tc.type: FUNC
274 */
275 HWTEST_F(DistributedRadarTest, RecordTime_001, TestSize.Level3)
276 {
277 DTEST_LOG << "DistributedRadarTest RecordTime_001 begin" << std::endl;
278 bool ret = DmsRadar::GetInstance().RecordTime(FUNC);
279 EXPECT_EQ(ret, true);
280 DTEST_LOG << "DistributedRadarTest RecordTime_001 end" << std::endl;
281 }
282
283 /**
284 * @tc.name: MultimodeUnfocusedGetAccessTokenIdRes_001
285 * @tc.desc: check MultimodeUnfocusedGetAccessTokenIdRes
286 * @tc.type: FUNC
287 */
288 HWTEST_F(DistributedRadarTest, MultimodeUnfocusedGetAccessTokenIdRes_001, TestSize.Level3)
289 {
290 DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedGetAccessTokenIdRes_001 begin" << std::endl;
291 bool ret = DmsRadar::GetInstance().MultimodeUnfocusedGetAccessTokenIdRes(FUNC, ERR_OK);
292 EXPECT_EQ(ret, true);
293 DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedGetAccessTokenIdRes_001 end" << std::endl;
294 }
295
296 /**
297 * @tc.name: MultimodeUnfocusedGetAccessTokenIdRes_002
298 * @tc.desc: check MultimodeUnfocusedGetAccessTokenIdRes
299 * @tc.type: FUNC
300 */
301 HWTEST_F(DistributedRadarTest, MultimodeUnfocusedGetAccessTokenIdRes_002, TestSize.Level3)
302 {
303 DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedGetAccessTokenIdRes_002 begin" << std::endl;
304 bool ret = DmsRadar::GetInstance().MultimodeUnfocusedGetAccessTokenIdRes(FUNC, ERR_NO);
305 EXPECT_EQ(ret, true);
306 DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedGetAccessTokenIdRes_002 end" << std::endl;
307 }
308
309 /**
310 * @tc.name: MultimodeUnfocusedSendEventRes_001
311 * @tc.desc: check MultimodeUnfocusedSendEventRes
312 * @tc.type: FUNC
313 */
314 HWTEST_F(DistributedRadarTest, MultimodeUnfocusedSendEventRes_001, TestSize.Level3)
315 {
316 DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedSendEventRes_001 begin" << std::endl;
317 bool ret = DmsRadar::GetInstance().MultimodeUnfocusedSendEventRes(FUNC, ERR_OK);
318 EXPECT_EQ(ret, true);
319 DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedSendEventRes_001 end" << std::endl;
320 }
321
322 /**
323 * @tc.name: MultimodeUnfocusedSendEventRes_002
324 * @tc.desc: check MultimodeUnfocusedSendEventRes
325 * @tc.type: FUNC
326 */
327 HWTEST_F(DistributedRadarTest, MultimodeUnfocusedSendEventRes_002, TestSize.Level3)
328 {
329 DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedSendEventRes_002 begin" << std::endl;
330 bool ret = DmsRadar::GetInstance().MultimodeUnfocusedSendEventRes(FUNC, ERR_NO);
331 EXPECT_EQ(ret, true);
332 DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedSendEventRes_002 end" << std::endl;
333 }
334
335 /**
336 * @tc.name: SetUnfocusedState_001
337 * @tc.desc: check SetUnfocusedState
338 * @tc.type: FUNC
339 */
340 HWTEST_F(DistributedRadarTest, SetUnfocusedState_001, TestSize.Level3)
341 {
342 DTEST_LOG << "DistributedRadarTest SetUnfocusedState_001 begin" << std::endl;
343 bool ret = DmsRadar::GetInstance().SetUnfocusedState(FUNC);
344 EXPECT_EQ(ret, true);
345 DTEST_LOG << "DistributedRadarTest SetUnfocusedState_001 end" << std::endl;
346 }
347
348 /**
349 * @tc.name: ChangeStateUnfocusedGetAccessTokenIdRes_001
350 * @tc.desc: check ChangeStateUnfocusedGetAccessTokenIdRes
351 * @tc.type: FUNC
352 */
353 HWTEST_F(DistributedRadarTest, ChangeStateUnfocusedGetAccessTokenIdRes_001, TestSize.Level3)
354 {
355 DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedGetAccessTokenIdRes_001 begin" << std::endl;
356 bool ret = DmsRadar::GetInstance().ChangeStateUnfocusedGetAccessTokenIdRes(FUNC, ERR_OK);
357 EXPECT_EQ(ret, true);
358 DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedGetAccessTokenIdRes_001 end" << std::endl;
359 }
360
361 /**
362 * @tc.name: ChangeStateUnfocusedGetAccessTokenIdRes_002
363 * @tc.desc: check ChangeStateUnfocusedGetAccessTokenIdRes
364 * @tc.type: FUNC
365 */
366 HWTEST_F(DistributedRadarTest, ChangeStateUnfocusedGetAccessTokenIdRes_002, TestSize.Level3)
367 {
368 DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedGetAccessTokenIdRes_002 begin" << std::endl;
369 bool ret = DmsRadar::GetInstance().ChangeStateUnfocusedGetAccessTokenIdRes(FUNC, ERR_NO);
370 EXPECT_EQ(ret, true);
371 DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedGetAccessTokenIdRes_002 end" << std::endl;
372 }
373
374 /**
375 * @tc.name: ChangeStateUnfocusedSendEventRes_001
376 * @tc.desc: check ChangeStateUnfocusedSendEventRes
377 * @tc.type: FUNC
378 */
379 HWTEST_F(DistributedRadarTest, ChangeStateUnfocusedSendEventRes_001, TestSize.Level3)
380 {
381 DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedSendEventRes_001 begin" << std::endl;
382 bool ret = DmsRadar::GetInstance().ChangeStateUnfocusedSendEventRes(FUNC, ERR_OK);
383 EXPECT_EQ(ret, true);
384 DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedSendEventRes_001 end" << std::endl;
385 }
386
387 /**
388 * @tc.name: ChangeStateUnfocusedSendEventRes_002
389 * @tc.desc: check ChangeStateUnfocusedSendEventRes
390 * @tc.type: FUNC
391 */
392 HWTEST_F(DistributedRadarTest, ChangeStateUnfocusedSendEventRes_002, TestSize.Level3)
393 {
394 DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedSendEventRes_002 begin" << std::endl;
395 bool ret = DmsRadar::GetInstance().ChangeStateUnfocusedSendEventRes(FUNC, ERR_NO);
396 EXPECT_EQ(ret, true);
397 DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedSendEventRes_002 end" << std::endl;
398 }
399
400 /**
401 * @tc.name: RecvFocused_001
402 * @tc.desc: check RecvFocused
403 * @tc.type: FUNC
404 */
405 HWTEST_F(DistributedRadarTest, RecvFocused_001, TestSize.Level3)
406 {
407 DTEST_LOG << "DistributedRadarTest RecvFocused_001 begin" << std::endl;
408 bool ret = DmsRadar::GetInstance().RecvFocused(FUNC);
409 EXPECT_EQ(ret, true);
410 DTEST_LOG << "DistributedRadarTest RecvFocused_001 end" << std::endl;
411 }
412
413 /**
414 * @tc.name: FocusedGetBundleName_001
415 * @tc.desc: check FocusedGetBundleName
416 * @tc.type: FUNC
417 */
418 HWTEST_F(DistributedRadarTest, FocusedGetBundleName_001, TestSize.Level3)
419 {
420 DTEST_LOG << "DistributedRadarTest FocusedGetBundleName_001 begin" << std::endl;
421 bool ret = DmsRadar::GetInstance().FocusedGetBundleName(FUNC, ERR_OK);
422 EXPECT_EQ(ret, true);
423 DTEST_LOG << "DistributedRadarTest FocusedGetBundleName_001 end" << std::endl;
424 }
425
426 /**
427 * @tc.name: FocusedGetBundleName_002
428 * @tc.desc: check FocusedGetBundleName
429 * @tc.type: FUNC
430 */
431 HWTEST_F(DistributedRadarTest, FocusedGetBundleName_002, TestSize.Level3)
432 {
433 DTEST_LOG << "DistributedRadarTest FocusedGetBundleName_002 begin" << std::endl;
434 bool ret = DmsRadar::GetInstance().FocusedGetBundleName(FUNC, ERR_NO);
435 EXPECT_EQ(ret, true);
436 DTEST_LOG << "DistributedRadarTest FocusedGetBundleName_002 end" << std::endl;
437 }
438
439 /**
440 * @tc.name: NotifyDockFocused_001
441 * @tc.desc: check NotifyDockFocused
442 * @tc.type: FUNC
443 */
444 HWTEST_F(DistributedRadarTest, NotifyDockFocused_001, TestSize.Level3)
445 {
446 DTEST_LOG << "DistributedRadarTest NotifyDockFocused_001 begin" << std::endl;
447 bool ret = DmsRadar::GetInstance().NotifyDockFocused(FUNC, ERR_OK);
448 EXPECT_EQ(ret, true);
449 DTEST_LOG << "DistributedRadarTest NotifyDockFocused_001 end" << std::endl;
450 }
451
452 /**
453 * @tc.name: NotifyDockFocused_002
454 * @tc.desc: check NotifyDockFocused
455 * @tc.type: FUNC
456 */
457 HWTEST_F(DistributedRadarTest, NotifyDockFocused_002, TestSize.Level3)
458 {
459 DTEST_LOG << "DistributedRadarTest NotifyDockFocused_002 begin" << std::endl;
460 bool ret = DmsRadar::GetInstance().NotifyDockFocused(FUNC, ERR_NO);
461 EXPECT_EQ(ret, true);
462 DTEST_LOG << "DistributedRadarTest NotifyDockFocused_002 end" << std::endl;
463 }
464
465 /**
466 * @tc.name: RecvUnfocused_001
467 * @tc.desc: check RecvUnfocused
468 * @tc.type: FUNC
469 */
470 HWTEST_F(DistributedRadarTest, RecvUnfocused_001, TestSize.Level3)
471 {
472 DTEST_LOG << "DistributedRadarTest RecvUnfocused_001 begin" << std::endl;
473 bool ret = DmsRadar::GetInstance().RecvUnfocused(FUNC);
474 EXPECT_EQ(ret, true);
475 DTEST_LOG << "DistributedRadarTest RecvUnfocused_001 end" << std::endl;
476 }
477
478 /**
479 * @tc.name: UnfocusedGetBundleName_001
480 * @tc.desc: check UnfocusedGetBundleName
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DistributedRadarTest, UnfocusedGetBundleName_001, TestSize.Level3)
484 {
485 DTEST_LOG << "DistributedRadarTest UnfocusedGetBundleName_001 begin" << std::endl;
486 bool ret = DmsRadar::GetInstance().UnfocusedGetBundleName(FUNC, ERR_OK);
487 EXPECT_EQ(ret, true);
488 DTEST_LOG << "DistributedRadarTest UnfocusedGetBundleName_001 end" << std::endl;
489 }
490
491 /**
492 * @tc.name: UnfocusedGetBundleName_002
493 * @tc.desc: check UnfocusedGetBundleName
494 * @tc.type: FUNC
495 */
496 HWTEST_F(DistributedRadarTest, UnfocusedGetBundleName_002, TestSize.Level3)
497 {
498 DTEST_LOG << "DistributedRadarTest UnfocusedGetBundleName_002 begin" << std::endl;
499 bool ret = DmsRadar::GetInstance().UnfocusedGetBundleName(FUNC, ERR_NO);
500 EXPECT_EQ(ret, true);
501 DTEST_LOG << "DistributedRadarTest UnfocusedGetBundleName_002 end" << std::endl;
502 }
503
504 /**
505 * @tc.name: NotifyDockUnfocused_001
506 * @tc.desc: check NotifyDockUnfocused
507 * @tc.type: FUNC
508 */
509 HWTEST_F(DistributedRadarTest, NotifyDockUnfocused_001, TestSize.Level3)
510 {
511 DTEST_LOG << "DistributedRadarTest NotifyDockUnfocused_001 begin" << std::endl;
512 bool ret = DmsRadar::GetInstance().NotifyDockUnfocused(FUNC, ERR_OK);
513 EXPECT_EQ(ret, true);
514 DTEST_LOG << "DistributedRadarTest NotifyDockUnfocused_001 end" << std::endl;
515 }
516
517 /**
518 * @tc.name: NotifyDockUnfocused_002
519 * @tc.desc: check NotifyDockUnfocused
520 * @tc.type: FUNC
521 */
522 HWTEST_F(DistributedRadarTest, NotifyDockUnfocused_002, TestSize.Level3)
523 {
524 DTEST_LOG << "DistributedRadarTest NotifyDockUnfocused_002 begin" << std::endl;
525 bool ret = DmsRadar::GetInstance().NotifyDockUnfocused(FUNC, ERR_NO);
526 EXPECT_EQ(ret, true);
527 DTEST_LOG << "DistributedRadarTest NotifyDockUnfocused_002 end" << std::endl;
528 }
529
530 /**
531 * @tc.name: ClickIconDmsContinue_001
532 * @tc.desc: check ClickIconDmsContinue
533 * @tc.type: FUNC
534 */
535 HWTEST_F(DistributedRadarTest, ClickIconDmsContinue_001, TestSize.Level3)
536 {
537 DTEST_LOG << "DistributedRadarTest ClickIconDmsContinue_001 begin" << std::endl;
538 bool ret = DmsRadar::GetInstance().ClickIconDmsContinue(FUNC, ERR_OK, DEVICE_ID, BUNDLE_NAME, BUNDLE_NAME);
539 EXPECT_EQ(ret, true);
540 DTEST_LOG << "DistributedRadarTest ClickIconDmsContinue_001 end" << std::endl;
541 }
542
543 /**
544 * @tc.name: ClickIconDmsContinue_002
545 * @tc.desc: check ClickIconDmsContinue
546 * @tc.type: FUNC
547 */
548 HWTEST_F(DistributedRadarTest, ClickIconDmsContinue_002, TestSize.Level3)
549 {
550 DTEST_LOG << "DistributedRadarTest ClickIconDmsContinue_002 begin" << std::endl;
551 bool ret = DmsRadar::GetInstance().ClickIconDmsContinue(FUNC, ERR_NO, DEVICE_ID, BUNDLE_NAME, BUNDLE_NAME);
552 EXPECT_EQ(ret, true);
553 DTEST_LOG << "DistributedRadarTest ClickIconDmsContinue_002 end" << std::endl;
554 }
555
556 /**
557 * @tc.name: ClickIconDmsStartAbility_001
558 * @tc.desc: check ClickIconDmsStartAbility
559 * @tc.type: FUNC
560 */
561 HWTEST_F(DistributedRadarTest, ClickIconDmsStartAbility_001, TestSize.Level3)
562 {
563 DTEST_LOG << "DistributedRadarTest ClickIconDmsStartAbility_001 begin" << std::endl;
564 bool ret = DmsRadar::GetInstance().ClickIconDmsStartAbility(FUNC, ERR_OK);
565 EXPECT_EQ(ret, true);
566 DTEST_LOG << "DistributedRadarTest ClickIconDmsStartAbility_001 end" << std::endl;
567 }
568
569 /**
570 * @tc.name: ClickIconDmsStartAbility_002
571 * @tc.desc: check ClickIconDmsStartAbility
572 * @tc.type: FUNC
573 */
574 HWTEST_F(DistributedRadarTest, ClickIconDmsStartAbility_002, TestSize.Level3)
575 {
576 DTEST_LOG << "DistributedRadarTest ClickIconDmsStartAbility_002 begin" << std::endl;
577 bool ret = DmsRadar::GetInstance().ClickIconDmsStartAbility(FUNC, ERR_NO);
578 EXPECT_EQ(ret, true);
579 DTEST_LOG << "DistributedRadarTest ClickIconDmsStartAbility_002 end" << std::endl;
580 }
581
582 /**
583 * @tc.name: ClickIconDmsRecvOver_001
584 * @tc.desc: check ClickIconDmsRecvOver
585 * @tc.type: FUNC
586 */
587 HWTEST_F(DistributedRadarTest, ClickIconDmsRecvOver_001, TestSize.Level3)
588 {
589 DTEST_LOG << "DistributedRadarTest ClickIconDmsRecvOver_001 begin" << std::endl;
590 bool ret = DmsRadar::GetInstance().ClickIconDmsRecvOver(FUNC, ERR_OK);
591 EXPECT_EQ(ret, true);
592 DTEST_LOG << "DistributedRadarTest ClickIconDmsRecvOver_001 end" << std::endl;
593 }
594
595 /**
596 * @tc.name: ClickIconDmsRecvOver_002
597 * @tc.desc: check ClickIconDmsRecvOver
598 * @tc.type: FUNC
599 */
600 HWTEST_F(DistributedRadarTest, ClickIconDmsRecvOver_002, TestSize.Level3)
601 {
602 DTEST_LOG << "DistributedRadarTest ClickIconDmsRecvOver_002 begin" << std::endl;
603 bool ret = DmsRadar::GetInstance().ClickIconDmsRecvOver(FUNC, ERR_NO);
604 EXPECT_EQ(ret, true);
605 DTEST_LOG << "DistributedRadarTest ClickIconDmsRecvOver_002 end" << std::endl;
606 }
607
608 /**
609 * @tc.name: SaveDataDmsContinue_001
610 * @tc.desc: check SaveDataDmsContinue
611 * @tc.type: FUNC
612 */
613 HWTEST_F(DistributedRadarTest, SaveDataDmsContinue_001, TestSize.Level3)
614 {
615 DTEST_LOG << "DistributedRadarTest SaveDataDmsContinue_001 begin" << std::endl;
616 bool ret = DmsRadar::GetInstance().SaveDataDmsContinue(FUNC, ERR_OK);
617 EXPECT_EQ(ret, true);
618 DTEST_LOG << "DistributedRadarTest SaveDataDmsContinue_001 end" << std::endl;
619 }
620
621 /**
622 * @tc.name: SaveDataDmsContinue_002
623 * @tc.desc: check SaveDataDmsContinue
624 * @tc.type: FUNC
625 */
626 HWTEST_F(DistributedRadarTest, SaveDataDmsContinue_002, TestSize.Level3)
627 {
628 DTEST_LOG << "DistributedRadarTest SaveDataDmsContinue_002 begin" << std::endl;
629 bool ret = DmsRadar::GetInstance().SaveDataDmsContinue(FUNC, ERR_NO);
630 EXPECT_EQ(ret, true);
631 DTEST_LOG << "DistributedRadarTest SaveDataDmsContinue_002 end" << std::endl;
632 }
633
634 /**
635 * @tc.name: SaveDataDmsRemoteWant_001
636 * @tc.desc: check SaveDataDmsRemoteWant
637 * @tc.type: FUNC
638 */
639 HWTEST_F(DistributedRadarTest, SaveDataDmsRemoteWant_001, TestSize.Level3)
640 {
641 DTEST_LOG << "DistributedRadarTest SaveDataDmsRemoteWant_001 begin" << std::endl;
642 bool ret = DmsRadar::GetInstance().SaveDataDmsRemoteWant(FUNC, ERR_OK);
643 EXPECT_EQ(ret, true);
644 DTEST_LOG << "DistributedRadarTest SaveDataDmsRemoteWant_001 end" << std::endl;
645 }
646
647 /**
648 * @tc.name: SaveDataDmsRemoteWant_002
649 * @tc.desc: check SaveDataDmsRemoteWant
650 * @tc.type: FUNC
651 */
652 HWTEST_F(DistributedRadarTest, SaveDataDmsRemoteWant_002, TestSize.Level3)
653 {
654 DTEST_LOG << "DistributedRadarTest SaveDataDmsRemoteWant_002 begin" << std::endl;
655 bool ret = DmsRadar::GetInstance().SaveDataDmsRemoteWant(FUNC, ERR_NO);
656 EXPECT_EQ(ret, true);
657 DTEST_LOG << "DistributedRadarTest SaveDataDmsRemoteWant_002 end" << std::endl;
658 }
659 }
660 }