1 /*
2 * Copyright (c) 2022-2023 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 "daudio_source_dev_test.h"
17
18 #include "audio_encode_transport.h"
19 #include "audio_decode_transport.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace DistributedHardware {
25 const std::string ATTRS = "attrs";
26 const std::string DEV_ID = "devId";
27 const std::string FUNC_NAME = "funcName";
28 const std::string ARGS = "args";
29 const std::string DH_ID_MIC = "134217728";
30 const std::string DH_ID_SPK = "1";
31 const std::string DH_ID_UNKNOWN = "0";
32 const int32_t TASK_QUEUE_LEN = 20;
33 const size_t AUDIO_DATA_CAP = 1;
34
SetUpTestCase(void)35 void DAudioSourceDevTest::SetUpTestCase(void) {}
36
TearDownTestCase(void)37 void DAudioSourceDevTest::TearDownTestCase(void) {}
38
SetUp(void)39 void DAudioSourceDevTest::SetUp(void)
40 {
41 auto daudioMgrCallback = std::make_shared<DAudioSourceMgrCallback>();
42 sourceDev_ = std::make_shared<DAudioSourceDev>(DEV_ID, daudioMgrCallback);
43 }
44
TearDown(void)45 void DAudioSourceDevTest::TearDown(void)
46 {
47 sourceDev_ = nullptr;
48 }
49
50 /**
51 * @tc.name: CreatTasks_001
52 * @tc.desc: Verify AwakeAudioDev function and creat tasks to process.
53 * @tc.type: FUNC
54 * @tc.require: AR000H0E5F
55 */
56 HWTEST_F(DAudioSourceDevTest, CreatTasks_001, TestSize.Level1)
57 {
58 EXPECT_EQ(DH_SUCCESS, sourceDev_->AwakeAudioDev());
59 EXPECT_EQ(DH_SUCCESS, sourceDev_->EnableDAudio(DH_ID_SPK, ATTRS));
60
61 AudioEvent event = AudioEvent(OPEN_SPEAKER, "");
62 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenDSpeaker(event));
63 event.type = SPEAKER_OPENED;
64 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDSpeakerOpened(event));
65 event.type = CLOSE_SPEAKER;
66 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCloseDSpeaker(event));
67 event.type = SPEAKER_CLOSED;
68 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDSpeakerClosed(event));
69
70 event.type = OPEN_MIC;
71 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenDMic(event));
72 event.type = MIC_OPENED;
73 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicOpened(event));
74 event.type = CLOSE_MIC;
75 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCloseDMic(event));
76 event.type = MIC_CLOSED;
77 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicClosed(event));
78
79 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
80 sourceDev_->speaker_->isOpened_ = true;
81 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
82 sourceDev_->mic_->isOpened_ = true;
83 event.type = CTRL_CLOSED;
84 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event));
85
86 event.type = VOLUME_SET;
87 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleVolumeSet(event));
88 event.type = VOLUME_MUTE_SET;
89 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleVolumeSet(event));
90 event.type = VOLUME_CHANGE;
91 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleVolumeChange(event));
92
93 event.type = AUDIO_FOCUS_CHANGE;
94 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleFocusChange(event));
95 event.type = AUDIO_RENDER_STATE_CHANGE;
96 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleRenderStateChange(event));
97
98 EXPECT_EQ(DH_SUCCESS, sourceDev_->DisableDAudio(DH_ID_SPK));
99 sourceDev_->SleepAudioDev();
100 }
101
102 /**
103 * @tc.name: CreatTasks_002
104 * @tc.desc: Verify creat tasks to process, without AwakeAudioDev function.
105 * @tc.type: FUNC
106 * @tc.require: AR000H0E5F
107 */
108 HWTEST_F(DAudioSourceDevTest, CreatTasks_002, TestSize.Level1)
109 {
110 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->EnableDAudio(DH_ID_SPK, ATTRS));
111
112 AudioEvent event = AudioEvent(OPEN_SPEAKER, "");
113 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleOpenDSpeaker(event));
114 event.type = SPEAKER_OPENED;
115 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDSpeakerOpened(event));
116 event.type = CLOSE_SPEAKER;
117 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleCloseDSpeaker(event));
118 event.type = SPEAKER_CLOSED;
119 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDSpeakerClosed(event));
120
121 event.type = OPEN_MIC;
122 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleOpenDMic(event));
123 event.type = MIC_OPENED;
124 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicOpened(event));
125 event.type = CLOSE_MIC;
126 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleCloseDMic(event));
127 event.type = MIC_CLOSED;
128 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicClosed(event));
129
130 event.type = CTRL_CLOSED;
131 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event));
132
133 event.type = VOLUME_SET;
134 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleVolumeSet(event));
135 event.type = VOLUME_MUTE_SET;
136 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleVolumeSet(event));
137 event.type = VOLUME_CHANGE;
138 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleVolumeChange(event));
139
140 event.type = AUDIO_FOCUS_CHANGE;
141 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleFocusChange(event));
142 event.type = AUDIO_RENDER_STATE_CHANGE;
143 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleRenderStateChange(event));
144
145 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->DisableDAudio(DH_ID_SPK));
146 }
147
148 /**
149 * @tc.name: CreatTasks_003
150 * @tc.desc: Verify HandleOpenDSpeaker, HandleOpenDMic and HandleOpenCtrlTrans function produce task fail.
151 * @tc.type: FUNC
152 * @tc.require: AR000H0E5F
153 */
154 HWTEST_F(DAudioSourceDevTest, CreatTasks_003, TestSize.Level1)
155 {
156 sourceDev_->AwakeAudioDev();
157 AudioEvent event = AudioEvent(OPEN_SPEAKER, "");
158 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenDSpeaker(event));
159
160 event.type = OPEN_MIC;
161 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenDMic(event));
162 }
163
164 /**
165 * @tc.name: NotifyEvent_001
166 * @tc.desc: Verify NotifyEvent function with VOLUME_SET event, after AwakeAudioDev function.
167 * @tc.type: FUNC
168 * @tc.require: AR000H0E5F
169 */
170 HWTEST_F(DAudioSourceDevTest, NotifyEvent_001, TestSize.Level1)
171 {
172 EXPECT_EQ(DH_SUCCESS, sourceDev_->AwakeAudioDev());
173 AudioEvent event = AudioEvent(EVENT_UNKNOWN, "");
174 sourceDev_->NotifyEvent(event);
175
176 event.type = VOLUME_SET;
177 sourceDev_->NotifyEvent(event);
178 sourceDev_->SleepAudioDev();
179 }
180
181 /**
182 * @tc.name: HandlePlayStatusChange_001
183 * @tc.desc: Verify the HandlePlayStatusChange function.
184 * @tc.type: FUNC
185 * @tc.require: AR000H0E5F
186 */
187 HWTEST_F(DAudioSourceDevTest, HandlePlayStatusChange_001, TestSize.Level1)
188 {
189 AudioEvent event = AudioEvent(CHANGE_PLAY_STATUS, "");
190 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandlePlayStatusChange(event));
191
192 sourceDev_->AwakeAudioDev();
193 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandlePlayStatusChange(event));
194 }
195
196 /**
197 * @tc.name: WaitForRPC_001
198 * @tc.desc: Verify the WaitForRPC function.
199 * @tc.type: FUNC
200 * @tc.require: AR000H0E5F
201 */
202 HWTEST_F(DAudioSourceDevTest, WaitForRPC_001, TestSize.Level1)
203 {
204 AudioEventType type = NOTIFY_OPEN_SPEAKER_RESULT;
205 EXPECT_EQ(ERR_DH_AUDIO_SA_RPC_WAIT_TIMEOUT, sourceDev_->WaitForRPC(type));
206
207 type = CHANGE_PLAY_STATUS;
208 EXPECT_EQ(ERR_DH_AUDIO_SA_RPC_WAIT_TIMEOUT, sourceDev_->WaitForRPC(type));
209
210 sourceDev_->rpcResult_ = false;
211 type = NOTIFY_OPEN_SPEAKER_RESULT;
212 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_SPK;
213 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->WaitForRPC(type));
214 }
215
216 /**
217 * @tc.name: WaitForRPC_002
218 * @tc.desc: Verify the WaitForRPC function.
219 * @tc.type: FUNC
220 * @tc.require: AR000H0E5F
221 */
222 HWTEST_F(DAudioSourceDevTest, WaitForRPC_002, TestSize.Level1)
223 {
224 sourceDev_->rpcResult_ = true;
225 AudioEventType type = NOTIFY_OPEN_SPEAKER_RESULT;
226 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_SPK;
227 EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type));
228
229 sourceDev_->rpcResult_ = true;
230 type = NOTIFY_CLOSE_SPEAKER_RESULT;
231 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_CLOSE_SPK;
232 EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type));
233
234 sourceDev_->rpcResult_ = true;
235 type = NOTIFY_OPEN_MIC_RESULT;
236 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_MIC;
237 EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type));
238
239 sourceDev_->rpcResult_ = true;
240 type = NOTIFY_CLOSE_MIC_RESULT;
241 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_CLOSE_MIC;
242 EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type));
243
244 sourceDev_->rpcResult_ = true;
245 type = NOTIFY_OPEN_CTRL_RESULT;
246 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_CTRL;
247 EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type));
248
249 sourceDev_->rpcResult_ = true;
250 type = NOTIFY_CLOSE_CTRL_RESULT;
251 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_CLOSE_CTRL;
252 EXPECT_EQ(DH_SUCCESS, sourceDev_->WaitForRPC(type));
253 }
254
255 /**
256 * @tc.name: HandleDMicClosed_001
257 * @tc.desc: Verify the HandleDMicClosed function.
258 * @tc.type: FUNC
259 * @tc.require: AR000H0E5F
260 */
261 HWTEST_F(DAudioSourceDevTest, HandleDMicClosed_001, TestSize.Level1)
262 {
263 AudioEvent event;
264 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicClosed(event));
265 sourceDev_->SleepAudioDev();
266 }
267
268 /**
269 * @tc.name: HandleDMicClosed_002
270 * @tc.desc: Verify the HandleDMicClosed function.
271 * @tc.type: FUNC
272 * @tc.require: AR000H0E5F
273 */
274 HWTEST_F(DAudioSourceDevTest, HandleDMicClosed_002, TestSize.Level1)
275 {
276 AudioEvent event;
277 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
278 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicClosed(event));
279 }
280
281 /**
282 * @tc.name: OpenCtrlTrans_001
283 * @tc.desc: Verify the OpenCtrlTrans function.
284 * @tc.type: FUNC
285 * @tc.require: AR000H0E5F
286 */
287 HWTEST_F(DAudioSourceDevTest, OpenCtrlTrans_001, TestSize.Level1)
288 {
289 AudioEvent event;
290 EXPECT_NE(ERR_DH_AUDIO_SA_OPEN_CTRL_FAILED, sourceDev_->OpenCtrlTrans(event));
291 EXPECT_EQ(DH_SUCCESS, sourceDev_->OpenCtrlTrans(event));
292 sourceDev_->audioCtrlMgr_ = std::make_shared<DAudioSourceDevCtrlMgr>(DEV_ID, sourceDev_);
293 sourceDev_->audioCtrlMgr_->isOpened_ = true;
294 EXPECT_EQ(DH_SUCCESS, sourceDev_->OpenCtrlTrans(event));
295
296 sourceDev_->audioCtrlMgr_->isOpened_ = false;
297 sourceDev_->AwakeAudioDev();
298 EXPECT_EQ(DH_SUCCESS, sourceDev_->OpenCtrlTrans(event));
299 sourceDev_->audioCtrlMgr_ = nullptr;
300 }
301
302 /**
303 * @tc.name: CloseCtrlTrans_001
304 * @tc.desc: Verify the CloseCtrlTrans function without task queue.
305 * @tc.type: FUNC
306 * @tc.require: AR000H0E5F
307 */
308 HWTEST_F(DAudioSourceDevTest, CloseCtrlTrans_001, TestSize.Level1)
309 {
310 AudioEvent event;
311 bool isSpk = false;
312 EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk));
313 sourceDev_->audioCtrlMgr_ = std::make_shared<DAudioSourceDevCtrlMgr>(DEV_ID, sourceDev_);
314 EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sourceDev_->CloseCtrlTrans(event, isSpk));
315 EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk));
316 }
317
318 /**
319 * @tc.name: CloseCtrlTrans_002
320 * @tc.desc: Verify the CloseCtrlTrans function with task queue run.
321 * @tc.type: FUNC
322 * @tc.require: AR000H0E5F
323 */
324 HWTEST_F(DAudioSourceDevTest, CloseCtrlTrans_002, TestSize.Level1)
325 {
326 AudioEvent event;
327 sourceDev_->AwakeAudioDev();
328
329 bool isSpk = false;
330 sourceDev_->mic_ = nullptr;
331 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
332 sourceDev_->speaker_->isOpened_ = false;
333 EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk));
334
335 sourceDev_->speaker_->isOpened_ = true;
336 EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk));
337
338 isSpk = true;
339 sourceDev_->speaker_ = nullptr;
340 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
341 sourceDev_->mic_->isOpened_ = false;
342 EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk));
343
344 sourceDev_->mic_->isOpened_ = true;
345 EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk));
346 }
347
348 /**
349 * @tc.name: HandleOpenCtrlTrans_001
350 * @tc.desc: Verify the HandleOpenCtrlTrans function.
351 * @tc.type: FUNC
352 * @tc.require: AR000H0E5F
353 */
354 HWTEST_F(DAudioSourceDevTest, HandleOpenCtrlTrans_001, TestSize.Level1)
355 {
356 AudioEvent event;
357 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleOpenCtrlTrans(event));
358
359 sourceDev_->AwakeAudioDev();
360 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenCtrlTrans(event));
361 }
362
363 /**
364 * @tc.name: HandleCloseCtrlTrans_001
365 * @tc.desc: Verify the HandleCloseCtrlTrans function.
366 * @tc.type: FUNC
367 * @tc.require: AR000H0E5F
368 */
369 HWTEST_F(DAudioSourceDevTest, HandleCloseCtrlTrans_001, TestSize.Level1)
370 {
371 AudioEvent event;
372 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleCloseCtrlTrans(event));
373
374 sourceDev_->AwakeAudioDev();
375 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCloseCtrlTrans(event));
376 }
377
378 /**
379 * @tc.name: HandleCtrlTransClosed_001
380 * @tc.desc: Verify the HandleCtrlTransClosed function.
381 * @tc.type: FUNC
382 * @tc.require: AR000H0E5F
383 */
384 HWTEST_F(DAudioSourceDevTest, HandleCtrlTransClosed_001, TestSize.Level1)
385 {
386 AudioEvent event = AudioEvent(CTRL_CLOSED, "");
387 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event));
388
389 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
390 sourceDev_->speaker_->isOpened_ = false;
391 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event));
392 sourceDev_->speaker_->isOpened_ = true;
393 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event));
394
395 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
396 sourceDev_->speaker_->isOpened_ = false;
397 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event));
398 sourceDev_->speaker_->isOpened_ = true;
399 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event));
400 }
401
402 /**
403 * @tc.name: HandleNotifyRPC_001
404 * @tc.desc: Verify the HandleNotifyRPC function.
405 * @tc.type: FUNC
406 * @tc.require: AR000H0E5F
407 */
408 HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_001, TestSize.Level1)
409 {
410 AudioEvent event(NOTIFY_OPEN_SPEAKER_RESULT, "");
411 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->HandleNotifyRPC(event));
412
413 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
414 event.content = tempLongStr;
415 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->HandleNotifyRPC(event));
416 }
417
418
419 /**
420 * @tc.name: HandleNotifyRPC_002
421 * @tc.desc: Verify the HandleNotifyRPC function.
422 * @tc.type: FUNC
423 * @tc.require: AR000H0E5F
424 */
425 HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_002, TestSize.Level1)
426 {
427 AudioEvent event(NOTIFY_OPEN_SPEAKER_RESULT, "result");
428 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleNotifyRPC(event));
429 }
430
431 /**
432 * @tc.name: HandleNotifyRPC_003
433 * @tc.desc: Verify the HandleNotifyRPC function.
434 * @tc.type: FUNC
435 * @tc.require: AR000H0E5F
436 */
437 HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_003, TestSize.Level1)
438 {
439 json jParam = { { KEY_RESULT, DH_SUCCESS } };
440 AudioEvent event(CHANGE_PLAY_STATUS, jParam.dump());
441 EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, sourceDev_->HandleNotifyRPC(event));
442
443 event.type = NOTIFY_OPEN_SPEAKER_RESULT;
444 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleNotifyRPC(event));
445 }
446
447 /**
448 * @tc.name: HandleSpkMmapStart_001
449 * @tc.desc: Verify the HandleSpkMmapStart function.
450 * @tc.type: FUNC
451 * @tc.require: AR000H0E5F
452 */
453 HWTEST_F(DAudioSourceDevTest, HandleSpkMmapStart_001, TestSize.Level1)
454 {
455 AudioEvent event;
456 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleSpkMmapStart(event));
457
458 sourceDev_->AwakeAudioDev();
459 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleSpkMmapStart(event));
460 }
461
462 /**
463 * @tc.name: HandleSpkMmapStop_001
464 * @tc.desc: Verify the HandleSpkMmapStop function.
465 * @tc.type: FUNC
466 * @tc.require: AR000H0E5F
467 */
468 HWTEST_F(DAudioSourceDevTest, HandleSpkMmapStop_001, TestSize.Level1)
469 {
470 AudioEvent event;
471 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleSpkMmapStop(event));
472
473 sourceDev_->AwakeAudioDev();
474 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleSpkMmapStop(event));
475 }
476
477 /**
478 * @tc.name: HandleMicMmapStart_001
479 * @tc.desc: Verify the HandleMicMmapStart function.
480 * @tc.type: FUNC
481 * @tc.require: AR000H0E5F
482 */
483 HWTEST_F(DAudioSourceDevTest, HandleMicMmapStart_001, TestSize.Level1)
484 {
485 AudioEvent event;
486 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleMicMmapStart(event));
487
488 sourceDev_->AwakeAudioDev();
489 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleMicMmapStart(event));
490 }
491
492 /**
493 * @tc.name: HandleMicMmapStop_001
494 * @tc.desc: Verify the HandleMicMmapStop function.
495 * @tc.type: FUNC
496 * @tc.require: AR000H0E5F
497 */
498 HWTEST_F(DAudioSourceDevTest, HandleMicMmapStop_001, TestSize.Level1)
499 {
500 AudioEvent event;
501 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleMicMmapStop(event));
502
503 sourceDev_->AwakeAudioDev();
504 EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleMicMmapStop(event));
505 }
506
507 /**
508 * @tc.name: TaskEnableDAudio_001
509 * @tc.desc: Verify the TaskEnableDAudio function.
510 * @tc.type: FUNC
511 * @tc.require: AR000H0E5F
512 */
513 HWTEST_F(DAudioSourceDevTest, TaskEnableDAudio_001, TestSize.Level1)
514 {
515 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskEnableDAudio(""));
516
517 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
518 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskEnableDAudio(tempLongStr));
519
520 json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } };
521 EXPECT_EQ(ERR_DH_AUDIO_SA_ENABLE_PARAM_INVALID, sourceDev_->TaskEnableDAudio(jParam.dump()));
522
523 jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, "testDhId" }, { KEY_ATTRS, "" } };
524 EXPECT_EQ(ERR_DH_AUDIO_SA_ENABLE_PARAM_INVALID, sourceDev_->TaskEnableDAudio(jParam.dump()));
525
526 jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_UNKNOWN }, { KEY_ATTRS, "" } };
527 EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->TaskEnableDAudio(jParam.dump()));
528
529 json jParam_spk = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK }, { KEY_ATTRS, "" } };
530 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio(jParam_spk.dump()));
531
532 json jParam_mic = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_MIC }, { KEY_ATTRS, "" } };
533 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio(jParam_mic.dump()));
534 }
535
536 /**
537 * @tc.name: TaskDisableDAudio_001
538 * @tc.desc: Verify the TaskDisableDAudio function.
539 * @tc.type: FUNC
540 * @tc.require: AR000H0E5F
541 */
542 HWTEST_F(DAudioSourceDevTest, TaskDisableDAudio_001, TestSize.Level1)
543 {
544 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskDisableDAudio(""));
545
546 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
547 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskDisableDAudio(tempLongStr));
548
549 json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } };
550 EXPECT_EQ(ERR_DH_AUDIO_SA_DISABLE_PARAM_INVALID, sourceDev_->TaskDisableDAudio(jParam.dump()));
551
552 jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, "testDhId" } };
553 EXPECT_EQ(ERR_DH_AUDIO_SA_DISABLE_PARAM_INVALID, sourceDev_->TaskDisableDAudio(jParam.dump()));
554
555 jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_UNKNOWN } };
556 EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->TaskDisableDAudio(jParam.dump()));
557
558 json jParam_spk = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } };
559 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam_spk.dump()));
560
561 json jParam_mic = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_MIC } };
562 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam_mic.dump()));
563 }
564
565 /**
566 * @tc.name: OnEnableTaskResult_001
567 * @tc.desc: Verify the OnEnableTaskResult and OnEnableAudioResult function.
568 * @tc.type: FUNC
569 * @tc.require: AR000H0E5F
570 */
571 HWTEST_F(DAudioSourceDevTest, OnEnableTaskResult_001, TestSize.Level1)
572 {
573 sourceDev_->OnEnableTaskResult(DH_SUCCESS, "", FUNC_NAME);
574
575 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
576 sourceDev_->OnEnableTaskResult(DH_SUCCESS, tempLongStr, FUNC_NAME);
577
578 json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } };
579 sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME);
580
581 jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } };
582 sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME);
583 sourceDev_->OnEnableTaskResult(ERR_DH_AUDIO_NULLPTR, jParam.dump(), FUNC_NAME);
584
585 sourceDev_->mgrCallback_ = nullptr;
586 sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME);
587
588 auto mgrCb = std::make_shared<DAudioSourceMgrCallback>();
589 EXPECT_NE(DH_SUCCESS, mgrCb->OnEnableAudioResult(DEV_ID, DH_ID_SPK, DH_SUCCESS));
590 }
591
592 /**
593 * @tc.name: OnDisableTaskResult_001
594 * @tc.desc: Verify the OnDisableTaskResult and OnDisableAudioResult function.
595 * @tc.type: FUNC
596 * @tc.require: AR000H0E5F
597 */
598 HWTEST_F(DAudioSourceDevTest, OnDisableTaskResult_001, TestSize.Level1)
599 {
600 sourceDev_->OnDisableTaskResult(DH_SUCCESS, "", FUNC_NAME);
601
602 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
603 sourceDev_->OnDisableTaskResult(DH_SUCCESS, tempLongStr, FUNC_NAME);
604
605 json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } };
606 sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME);
607
608 jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } };
609 sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME);
610 sourceDev_->OnDisableTaskResult(ERR_DH_AUDIO_NULLPTR, jParam.dump(), FUNC_NAME);
611
612 sourceDev_->mgrCallback_ = nullptr;
613 sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME);
614
615 auto mgrCb = std::make_shared<DAudioSourceMgrCallback>();
616 EXPECT_NE(DH_SUCCESS, mgrCb->OnDisableAudioResult(DEV_ID, DH_ID_SPK, DH_SUCCESS));
617 }
618
619 /**
620 * @tc.name: EnableDSpeaker_001
621 * @tc.desc: Verify the EnableDSpeaker function.
622 * @tc.type: FUNC
623 * @tc.require: AR000H0E5F
624 */
625 HWTEST_F(DAudioSourceDevTest, EnableDSpeaker_001, TestSize.Level1)
626 {
627 int32_t dhId = 0;
628 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
629 EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDSpeaker(dhId, ATTRS));
630 sourceDev_->speaker_ = nullptr;
631
632 EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDSpeaker(dhId, ATTRS));
633 }
634
635 /**
636 * @tc.name: EnableDMic_001
637 * @tc.desc: Verify the EnableDMic function.
638 * @tc.type: FUNC
639 * @tc.require: AR000H0E5F
640 */
641 HWTEST_F(DAudioSourceDevTest, EnableDMic_001, TestSize.Level1)
642 {
643 int32_t dhId = 0;
644 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
645 EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDMic(dhId, ATTRS));
646 sourceDev_->mic_ = nullptr;
647
648 EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDMic(dhId, ATTRS));
649 }
650
651 /**
652 * @tc.name: DisableDSpeaker_001
653 * @tc.desc: Verify the DisableDSpeaker function.
654 * @tc.type: FUNC
655 * @tc.require: AR000H0E5F
656 */
657 HWTEST_F(DAudioSourceDevTest, DisableDSpeaker_001, TestSize.Level1)
658 {
659 int32_t dhId = 0;
660 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->DisableDSpeaker(dhId));
661
662 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
663 EXPECT_NE(DH_SUCCESS, sourceDev_->DisableDSpeaker(dhId));
664 sourceDev_->speaker_ = nullptr;
665 }
666
667 /**
668 * @tc.name: DisableDMic_001
669 * @tc.desc: Verify the DisableDMic function.
670 * @tc.type: FUNC
671 * @tc.require: AR000H0E5F
672 */
673 HWTEST_F(DAudioSourceDevTest, DisableDMic_001, TestSize.Level1)
674 {
675 int32_t dhId = 0;
676 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->DisableDMic(dhId));
677
678 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
679 EXPECT_NE(DH_SUCCESS, sourceDev_->DisableDMic(dhId));
680 sourceDev_->mic_ = nullptr;
681 }
682
683 /**
684 * @tc.name: TaskOpenDSpeaker_001
685 * @tc.desc: Verify the TaskOpenDSpeaker function.
686 * @tc.type: FUNC
687 * @tc.require: AR000H0E5F
688 */
689 HWTEST_F(DAudioSourceDevTest, TaskOpenDSpeaker_001, TestSize.Level1)
690 {
691 EXPECT_EQ(ERR_DH_AUDIO_SA_SPEAKER_DEVICE_NOT_INIT, sourceDev_->TaskOpenDSpeaker(""));
692
693 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
694 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenDSpeaker(""));
695
696 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
697 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenDSpeaker(tempLongStr));
698
699 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskOpenDSpeaker(ARGS));
700
701 json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } };
702 sourceDev_->isRpcOpen_.store(false);
703 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDSpeaker(jParam_spk.dump()));
704
705 sourceDev_->isRpcOpen_.store(true);
706 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDSpeaker(jParam_spk.dump()));
707
708 sourceDev_->rpcResult_ = true;
709 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_SPK;
710 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskOpenDSpeaker(jParam_spk.dump()));
711 }
712
713 /**
714 * @tc.name: TaskCloseDSpeaker_001
715 * @tc.desc: Verify the TaskCloseDSpeaker function.
716 * @tc.type: FUNC
717 * @tc.require: AR000H0E5F
718 */
719 HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_001, TestSize.Level1)
720 {
721 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(ARGS));
722
723 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
724 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDSpeaker(""));
725
726 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
727 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDSpeaker(tempLongStr));
728
729 sourceDev_->speaker_->isOpened_ = true;
730 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(ARGS));
731
732 sourceDev_->speaker_->isOpened_ = false;
733 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(ARGS));
734
735 json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } };
736 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(jParam_spk.dump()));
737 }
738
739 /**
740 * @tc.name: TaskCloseDSpeaker_002
741 * @tc.desc: Verify the TaskCloseDSpeaker function.
742 * @tc.type: FUNC
743 * @tc.require: AR000H0E5F
744 */
745 HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_002, TestSize.Level1)
746 {
747 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
748 sourceDev_->speaker_->speakerTrans_ = std::make_shared<AudioEncodeTransport>(DEV_ID);
749
750 json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } };
751 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(jParam_spk.dump()));
752 }
753
754 /**
755 * @tc.name: TaskOpenDMic_001
756 * @tc.desc: Verify the TaskOpenDMic function.
757 * @tc.type: FUNC
758 * @tc.require: AR000H0E5F
759 */
760 HWTEST_F(DAudioSourceDevTest, TaskOpenDMic_001, TestSize.Level1)
761 {
762 EXPECT_EQ(ERR_DH_AUDIO_SA_MIC_DEVICE_NOT_INIT, sourceDev_->TaskOpenDMic(""));
763
764 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
765 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDMic(""));
766
767 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDMic(""));
768
769 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
770 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDMic(tempLongStr));
771
772 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDMic(ARGS));
773
774 json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } };
775 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDMic(jParam_mic.dump()));
776 }
777
778 /**
779 * @tc.name: TaskCloseDMic_001
780 * @tc.desc: Verify the TaskCloseDMic function.
781 * @tc.type: FUNC
782 * @tc.require: AR000H0E5F
783 */
784 HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_001, TestSize.Level1)
785 {
786 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(ARGS));
787
788 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
789 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDMic(""));
790
791 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
792 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDMic(tempLongStr));
793
794 sourceDev_->mic_->isOpened_ = true;
795 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDMic(ARGS));
796
797 sourceDev_->mic_->isOpened_ = false;
798 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDMic(ARGS));
799
800 json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } };
801 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(jParam_mic.dump()));
802 }
803
804 /**
805 * @tc.name: TaskCloseDMic_002
806 * @tc.desc: Verify the TaskCloseDMic function.
807 * @tc.type: FUNC
808 * @tc.require: AR000H0E5F
809 */
810 HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_002, TestSize.Level1)
811 {
812 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
813 sourceDev_->mic_->micTrans_ = std::make_shared<AudioDecodeTransport>(DEV_ID);
814
815 json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } };
816 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(jParam_mic.dump()));
817 }
818
819 /**
820 * @tc.name: TaskOpenCtrlChannel_001
821 * @tc.desc: Verify the TaskOpenCtrlChannel function.
822 * @tc.type: FUNC
823 * @tc.require: AR000H0E5F
824 */
825 HWTEST_F(DAudioSourceDevTest, TaskOpenCtrlChannel_001, TestSize.Level1)
826 {
827 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskOpenCtrlChannel(""));
828
829 sourceDev_->audioCtrlMgr_ = std::make_shared<DAudioSourceDevCtrlMgr>(DEV_ID, sourceDev_);
830 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskOpenCtrlChannel(""));
831
832 std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a');
833 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskOpenCtrlChannel(tempLongStr));
834
835 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskOpenCtrlChannel(ARGS));
836
837 json jParam = { { KEY_DH_ID, DH_ID_SPK } };
838 sourceDev_->isRpcOpen_.store(false);
839 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskOpenCtrlChannel(jParam.dump()));
840
841 sourceDev_->isRpcOpen_.store(true);
842 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskOpenCtrlChannel(jParam.dump()));
843
844 sourceDev_->rpcResult_ = true;
845 sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_MIC;
846 jParam = { { KEY_DH_ID, DH_ID_SPK } };
847 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskOpenCtrlChannel(jParam.dump()));
848 }
849
850 /**
851 * @tc.name: TaskCloseCtrlChannel_001
852 * @tc.desc: Verify the TaskCloseCtrlChannel function.
853 * @tc.type: FUNC
854 * @tc.require: AR000H0E5F
855 */
856 HWTEST_F(DAudioSourceDevTest, TaskCloseCtrlChannel_001, TestSize.Level1)
857 {
858 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseCtrlChannel(ARGS));
859 sourceDev_->OnTaskResult(DH_SUCCESS, "", FUNC_NAME);
860 }
861
862 /**
863 * @tc.name: TaskCloseCtrlChannel_002
864 * @tc.desc: Verify the TaskCloseCtrlChannel function.
865 * @tc.type: FUNC
866 * @tc.require: AR000H0E5F
867 */
868 HWTEST_F(DAudioSourceDevTest, TaskCloseCtrlChannel_002, TestSize.Level1)
869 {
870 sourceDev_->audioCtrlMgr_ = std::make_shared<DAudioSourceDevCtrlMgr>(DEV_ID, sourceDev_);
871 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseCtrlChannel(ARGS));
872
873 sourceDev_->OnTaskResult(DH_SUCCESS, "", FUNC_NAME);
874 }
875
876 /**
877 * @tc.name: TaskSetVolume_001
878 * @tc.desc: Verify the TaskSetVolume function.
879 * @tc.type: FUNC
880 * @tc.require: AR000H0E5F
881 */
882 HWTEST_F(DAudioSourceDevTest, TaskSetVolume_001, TestSize.Level1)
883 {
884 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskSetVolume(ARGS));
885 }
886
887 /**
888 * @tc.name: TaskSetVolume_002
889 * @tc.desc: Verify the TaskSetVolume function.
890 * @tc.type: FUNC
891 * @tc.require: AR000H0E5F
892 */
893 HWTEST_F(DAudioSourceDevTest, TaskSetVolume_002, TestSize.Level1)
894 {
895 sourceDev_->audioCtrlMgr_ = std::make_shared<DAudioSourceDevCtrlMgr>(DEV_ID, sourceDev_);
896 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskSetVolume(ARGS));
897
898 json jParam = { { STREAM_MUTE_STATUS, 1 } };
899 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskSetVolume(jParam.dump()));
900
901 sourceDev_->OnTaskResult(ERR_DH_AUDIO_NULLPTR, "", FUNC_NAME);
902 }
903
904 /**
905 * @tc.name: TaskChangeVolume_001
906 * @tc.desc: Verify the TaskChangeVolume function.
907 * @tc.type: FUNC
908 * @tc.require: AR000H0E5F
909 */
910 HWTEST_F(DAudioSourceDevTest, TaskChangeVolume_001, TestSize.Level1)
911 {
912 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskChangeVolume(ARGS));
913 }
914
915 /**
916 * @tc.name: TaskChangeFocus_001
917 * @tc.desc: Verify the TaskChangeFocus function.
918 * @tc.type: FUNC
919 * @tc.require: AR000H0E5F
920 */
921 HWTEST_F(DAudioSourceDevTest, TaskChangeFocus_001, TestSize.Level1)
922 {
923 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskChangeFocus(ARGS));
924 }
925
926 /**
927 * @tc.name: TaskChangeRenderState_001
928 * @tc.desc: Verify the TaskChangeRenderState function.
929 * @tc.type: FUNC
930 * @tc.require: AR000H0E5F
931 */
932 HWTEST_F(DAudioSourceDevTest, TaskChangeRenderState_001, TestSize.Level1)
933 {
934 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskChangeRenderState(ARGS));
935 }
936
937 /**
938 * @tc.name: TaskPlayStatusChange
939 * @tc.desc: Verify the TaskPlayStatusChange function.
940 * @tc.type: FUNC
941 * @tc.require: AR000H0E5F
942 */
943 HWTEST_F(DAudioSourceDevTest, TaskPlayStatusChange_001, TestSize.Level1)
944 {
945 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskPlayStatusChange(AUDIO_EVENT_PAUSE));
946
947 sourceDev_->audioCtrlMgr_ = std::make_shared<DAudioSourceDevCtrlMgr>(DEV_ID, sourceDev_);
948 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, nullptr);
949 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskPlayStatusChange(AUDIO_EVENT_PAUSE));
950 EXPECT_NE(DH_SUCCESS, sourceDev_->TaskPlayStatusChange(AUDIO_EVENT_RESTART));
951 }
952
953 /**
954 * @tc.name: TaskSpkMmapStart
955 * @tc.desc: Verify the TaskSpkMmapStart function.
956 * @tc.type: FUNC
957 * @tc.require: AR000H0E5F
958 */
959 HWTEST_F(DAudioSourceDevTest, TaskSpkMmapStart_001, TestSize.Level1)
960 {
961 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskSpkMmapStart(ARGS));
962
963 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, nullptr);
964 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskSpkMmapStart(ARGS));
965 EXPECT_EQ(DH_SUCCESS, sourceDev_->speaker_->MmapStop());
966 }
967
968 /**
969 * @tc.name: TaskSpkMmapStop
970 * @tc.desc: Verify the TaskSpkMmapStop function.
971 * @tc.type: FUNC
972 * @tc.require: AR000H0E5F
973 */
974 HWTEST_F(DAudioSourceDevTest, TaskSpkMmapStop_001, TestSize.Level1)
975 {
976 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskSpkMmapStop(ARGS));
977
978 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, nullptr);
979 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskSpkMmapStop(ARGS));
980 }
981
982 /**
983 * @tc.name: TaskMicMmapStart
984 * @tc.desc: Verify the TaskMicMmapStart function.
985 * @tc.type: FUNC
986 * @tc.require: AR000H0E5F
987 */
988 HWTEST_F(DAudioSourceDevTest, TaskMicMmapStart_001, TestSize.Level1)
989 {
990 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStart(ARGS));
991
992 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, nullptr);
993 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStart(ARGS));
994 std::shared_ptr<AudioData> data = std::make_shared<AudioData>(AUDIO_DATA_CAP);
995 for (size_t i = 0; i < TASK_QUEUE_LEN; i++) {
996 sourceDev_->mic_->dataQueue_.push(data);
997 }
998 EXPECT_EQ(DH_SUCCESS, sourceDev_->mic_->MmapStop());
999 }
1000
1001 /**
1002 * @tc.name: TaskMicMmapStop
1003 * @tc.desc: Verify the TaskMicMmapStop function.
1004 * @tc.type: FUNC
1005 * @tc.require: AR000H0E5F
1006 */
1007 HWTEST_F(DAudioSourceDevTest, TaskMicMmapStop_001, TestSize.Level1)
1008 {
1009 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStop(ARGS));
1010
1011 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, nullptr);
1012 EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskMicMmapStop(ARGS));
1013 }
1014
1015
1016 /**
1017 * @tc.name: NotifyHDF_001
1018 * @tc.desc: Verify the NotifyHDF function.
1019 * @tc.type: FUNC
1020 * @tc.require: AR000H0E5F
1021 */
1022 HWTEST_F(DAudioSourceDevTest, NotifyHDF_001, TestSize.Level1)
1023 {
1024 AudioEventType type = NOTIFY_CLOSE_MIC_RESULT;
1025 std::string result = "result";
1026 EXPECT_NE(DH_SUCCESS, sourceDev_->NotifyHDF(type, result));
1027
1028 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
1029 EXPECT_EQ(DH_SUCCESS, sourceDev_->NotifyHDF(type, result));
1030 }
1031
1032 /**
1033 * @tc.name: NotifyHDF_002
1034 * @tc.desc: Verify the NotifyHDF function.
1035 * @tc.type: FUNC
1036 * @tc.require: AR000H0E5F
1037 */
1038 HWTEST_F(DAudioSourceDevTest, NotifyHDF_002, TestSize.Level1)
1039 {
1040 AudioEventType type = AUDIO_FOCUS_CHANGE;
1041 std::string result = "result";
1042 EXPECT_NE(DH_SUCCESS, sourceDev_->NotifyHDF(type, result));
1043
1044 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
1045 EXPECT_EQ(DH_SUCCESS, sourceDev_->NotifyHDF(type, result));
1046 }
1047
1048 /**
1049 * @tc.name: NotifyHDF_003
1050 * @tc.desc: Verify the NotifyHDF function.
1051 * @tc.type: FUNC
1052 * @tc.require: AR000H0E5F
1053 */
1054 HWTEST_F(DAudioSourceDevTest, NotifyHDF_003, TestSize.Level1)
1055 {
1056 AudioEventType type = EVENT_UNKNOWN;
1057 std::string result = "result";
1058 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->NotifyHDF(type, result));
1059 }
1060
1061 /**
1062 * @tc.name: NotifySinkDev_001
1063 * @tc.desc: Verify the NotifySinkDev function.
1064 * @tc.type: FUNC
1065 * @tc.require: AR000H0E5F
1066 */
1067 HWTEST_F(DAudioSourceDevTest, NotifySinkDev_001, TestSize.Level1)
1068 {
1069 json jAudioParam;
1070 sourceDev_->isRpcOpen_.store(false);
1071 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->NotifySinkDev(CLOSE_MIC, jAudioParam, DH_ID_SPK));
1072
1073 sourceDev_->isRpcOpen_.store(true);
1074 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->NotifySinkDev(CLOSE_MIC, jAudioParam, DH_ID_SPK));
1075 sourceDev_->mic_ = std::make_shared<DMicDev>(DEV_ID, sourceDev_);
1076 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
1077 EXPECT_EQ(DH_SUCCESS, sourceDev_->NotifySinkDev(CLOSE_MIC, jAudioParam, DH_ID_SPK));
1078 }
1079
1080 /**
1081 * @tc.name: SendAudioEventToRemote_002
1082 * @tc.desc: Verify the SendAudioEventToRemote function.
1083 * @tc.type: FUNC
1084 * @tc.require: AR000H0E5F
1085 */
1086 HWTEST_F(DAudioSourceDevTest, SendAudioEventToRemote_002, TestSize.Level1)
1087 {
1088 AudioEvent event;
1089 sourceDev_->speaker_ = nullptr;
1090 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->SendAudioEventToRemote(event));
1091 sourceDev_->speaker_ = std::make_shared<DSpeakerDev>(DEV_ID, sourceDev_);
1092 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->SendAudioEventToRemote(event));
1093 }
1094 } // namespace DistributedHardware
1095 } // namespace OHOS
1096