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