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