1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use sinkDev_ 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_sink_dev_test.h"
17 
18 #include "audio_event.h"
19 #include "daudio_constants.h"
20 #include "daudio_errorcode.h"
21 #include "daudio_log.h"
22 #include "iservice_registry.h"
23 #include "daudio_sink_ipc_callback_proxy.h"
24 #include "daudio_sink_load_callback.h"
25 
26 #undef DH_LOG_TAG
27 #define DH_LOG_TAG "DAudioSinkDevTest"
28 
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace DistributedHardware {
SetUpTestCase(void)33 void DAudioSinkDevTest::SetUpTestCase(void) {}
34 
TearDownTestCase(void)35 void DAudioSinkDevTest::TearDownTestCase(void) {}
36 
SetUp()37 void DAudioSinkDevTest::SetUp()
38 {
39     std::string networkId = "networkId";
40     std::string params = "params";
41     samgr_ = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
42     if (samgr_ == nullptr) {
43         return;
44     }
45     sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
46     samgr_->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
47     sptr<IRemoteObject> remoteObject = samgr_->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
48     if (remoteObject == nullptr) {
49         return;
50     }
51     sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
52     sinkDev_ = std::make_shared<DAudioSinkDev>(networkId, dAudioSinkIpcCallbackProxy);
53 }
54 
TearDown()55 void DAudioSinkDevTest::TearDown()
56 {
57     if (samgr_ != nullptr) {
58         samgr_->UnloadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
59     }
60     sinkDev_ = nullptr;
61 }
62 
63 /**
64  * @tc.name: InitAVTransEngines_001
65  * @tc.desc: Verify the InitAVTransEngines function.
66  * @tc.type: FUNC
67  * @tc.require: AR000H0E5F
68  */
69 HWTEST_F(DAudioSinkDevTest, InitAVTransEngines_001, TestSize.Level1)
70 {
71     std::shared_ptr<IAVEngineProvider> senderPtr = std::make_shared<IAVEngineProvider>();
72     std::shared_ptr<IAVEngineProvider> receiverPtr = std::make_shared<IAVEngineProvider>();
73     ChannelState type = ChannelState::UNKNOWN;
74     ASSERT_NE(sinkDev_, nullptr);
75     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->InitAVTransEngines(type, receiverPtr.get()));
76     type = ChannelState::MIC_CONTROL_OPENED;
77     EXPECT_EQ(DH_SUCCESS, sinkDev_->InitAVTransEngines(type, senderPtr.get()));
78     type = ChannelState::SPK_CONTROL_OPENED;
79     EXPECT_EQ(DH_SUCCESS, sinkDev_->InitAVTransEngines(type, receiverPtr.get()));
80 }
81 
82 /**
83  * @tc.name: TaskPlayStatusChange_001
84  * @tc.desc: Verify the TaskPlayStatusChange function.
85  * @tc.type: FUNC
86  * @tc.require: AR000H0E5F
87  */
88 HWTEST_F(DAudioSinkDevTest, TaskPlayStatusChange_001, TestSize.Level1)
89 {
90     ASSERT_NE(sinkDev_, nullptr);
91     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskPlayStatusChange(""));
92 
93     std::string devId = "devid";
94     int32_t dhId = 1;
95     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
96     sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
97     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskPlayStatusChange("{\"dhId\":\"1\"}"));
98 }
99 
100 /**
101  * @tc.name: TaskDisableDevice_001
102  * @tc.desc: Verify the TaskDisableDevice function.
103  * @tc.type: FUNC
104  * @tc.require: AR000H0E5F
105  */
106 HWTEST_F(DAudioSinkDevTest, TaskDisableDevice_001, TestSize.Level1)
107 {
108     std::string spkName = "ohos.dhardware.daudio.dspeaker.ohos.dhardware.daudio.dmic";
109     ASSERT_NE(sinkDev_, nullptr);
110     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskDisableDevice(spkName));
111 }
112 
113 /**
114  * @tc.name: TaskOpenDSpeaker_001
115  * @tc.desc: Verify the TaskOpenDSpeaker function.
116  * @tc.type: FUNC
117  * @tc.require: AR000H0E5F
118  */
119 HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_001, TestSize.Level1)
120 {
121     std::string args;
122     ASSERT_NE(sinkDev_, nullptr);
123     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
124     args.resize(DAUDIO_MAX_JSON_LEN + 1);
125     EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sinkDev_->TaskOpenDSpeaker(args));
126 }
127 
128 /**
129  * @tc.name: TaskOpenDSpeaker_002
130  * @tc.desc: Verify the TaskOpenDSpeaker function.
131  * @tc.type: FUNC
132  * @tc.require: AR000H0E5F
133  */
134 HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_002, TestSize.Level1)
135 {
136     std::string args = "args";
137     ASSERT_NE(sinkDev_, nullptr);
138     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
139 }
140 
141 /**
142  * @tc.name: TaskOpenDSpeaker_003
143  * @tc.desc: Verify the TaskOpenDSpeaker function.
144  * @tc.type: FUNC
145  * @tc.require: AR000H0E5F
146  */
147 HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_003, TestSize.Level1)
148 {
149     std::string devId = "1";
150     int32_t dhId = 1;
151     cJSON *jobject = cJSON_CreateObject();
152     CHECK_NULL_VOID(jobject);
153     cJSON_AddStringToObject(jobject, KEY_DH_ID, "1");
154     cJSON_AddNumberToObject(jobject, KEY_SAMPLING_RATE, 0);
155     cJSON_AddNumberToObject(jobject, KEY_FORMAT, 0);
156     cJSON_AddNumberToObject(jobject, KEY_CHANNELS, 0);
157     cJSON_AddNumberToObject(jobject, KEY_CONTENT_TYPE, 0);
158     cJSON_AddNumberToObject(jobject, KEY_STREAM_USAGE, 0);
159     cJSON_AddNumberToObject(jobject, KEY_SOURCE_TYPE, 0);
160     char *jsonData = cJSON_PrintUnformatted(jobject);
161     if (jsonData == nullptr) {
162         cJSON_Delete(jobject);
163         return;
164     }
165     std::string args(jsonData);
166     cJSON_free(jsonData);
167     cJSON_Delete(jobject);
168     ASSERT_NE(sinkDev_, nullptr);
169     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
170     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
171     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
172     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
173 }
174 
175 /**
176  * @tc.name: TaskCloseDSpeaker_001
177  * @tc.desc: Verify the TaskCloseDSpeaker function.
178  * @tc.type: FUNC
179  * @tc.require: AR000H0E5F
180  */
181 HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_001, TestSize.Level1)
182 {
183     std::string args = "{\"dhId\":\"1\"}";
184     ASSERT_NE(sinkDev_, nullptr);
185     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
186 }
187 
188 /**
189  * @tc.name: TaskCloseDSpeaker_002
190  * @tc.desc: Verify the TaskCloseDSpeaker function.
191  * @tc.type: FUNC
192  * @tc.require: AR000H0E5F
193  */
194 HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1)
195 {
196     std::string args = "{\"dhId\":\"1\"}";
197     std::string devId = "devId";
198     int32_t dhId = 1;
199     ASSERT_NE(sinkDev_, nullptr);
200     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
201     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
202     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
203     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
204 }
205 
206 /**
207  * @tc.name: ParseDhidFromEvent_001
208  * @tc.desc: Verify the ParseDhidFromEvent function.
209  * @tc.type: FUNC
210  * @tc.require: AR000H0E5F
211  */
212 HWTEST_F(DAudioSinkDevTest, ParseDhidFromEvent_001, TestSize.Level1)
213 {
214     std::string args = "{\"devId\":\"1\"}";
215     ASSERT_NE(sinkDev_, nullptr);
216     EXPECT_NE(DH_SUCCESS, sinkDev_->ParseDhidFromEvent(args));
217     std::string dhIdArgs = "{\"dhId\": 1 }";
218     EXPECT_NE(DH_SUCCESS, sinkDev_->ParseDhidFromEvent(dhIdArgs));
219 }
220 
221 /**
222  * @tc.name: ParseResultFromEvent_001
223  * @tc.desc: Verify the ParseResultFromEvent function.
224  * @tc.type: FUNC
225  * @tc.require: AR000H0E5F
226  */
227 HWTEST_F(DAudioSinkDevTest, ParseResultFromEvent_001, TestSize.Level1)
228 {
229     std::string args = "{\"result\":\"-40001\"}";
230     ASSERT_NE(sinkDev_, nullptr);
231     EXPECT_EQ(-1, sinkDev_->ParseResultFromEvent(args));
232     std::string dhIdArgs = "{\"result\": 1 }";
233     EXPECT_NE(DH_SUCCESS, sinkDev_->ParseResultFromEvent(dhIdArgs));
234 
235     cJSON *jobject = cJSON_CreateObject();
236     CHECK_NULL_VOID(jobject);
237     cJSON_AddNumberToObject(jobject, KEY_RESULT, 0);
238     char *jsonData = cJSON_PrintUnformatted(jobject);
239     if (jsonData == nullptr) {
240         cJSON_Delete(jobject);
241         return;
242     }
243     std::string args1(jsonData);
244     cJSON_free(jsonData);
245     cJSON_Delete(jobject);
246     EXPECT_EQ(DH_SUCCESS, sinkDev_->ParseResultFromEvent(args1));
247 }
248 
249 
250 /**
251  * @tc.name: TaskStartRender_001
252  * @tc.desc: Verify the TaskStartRender function.
253  * @tc.type: FUNC
254  * @tc.require: AR000H0E5F
255  */
256 HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1)
257 {
258     std::string devId = "devId";
259     int32_t dhId = 1;
260     std::string args = "{\"dhId\":\"1\"}";
261     ASSERT_NE(sinkDev_, nullptr);
262     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskStartRender(args));
263     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
264     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
265     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskStartRender(args));
266     std::string devIdArgs = "{\"devId\":\"1\"}";
267     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskStartRender(devIdArgs));
268 }
269 
270 /**
271  * @tc.name: TaskOpenDMic_001
272  * @tc.desc: Verify the TaskOpenDMic function.
273  * @tc.type: FUNC
274  * @tc.require: AR000H0E5F
275  */
276 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_001, TestSize.Level1)
277 {
278     std::string args;
279     ASSERT_NE(sinkDev_, nullptr);
280     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
281 }
282 
283 /**
284  * @tc.name: TaskOpenDMic_002
285  * @tc.desc: Verify the TaskOpenDMic function.
286  * @tc.type: FUNC
287  * @tc.require: AR000H0E5F
288  */
289 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_002, TestSize.Level1)
290 {
291     ASSERT_NE(sinkDev_, nullptr);
292     sinkDev_->isDevLevelStatus_ = true;
293     std::string devId = "1";
294     int32_t dhId = 1;
295     cJSON *jobject = cJSON_CreateObject();
296     CHECK_NULL_VOID(jobject);
297     cJSON_AddStringToObject(jobject, KEY_DH_ID, "1");
298     cJSON_AddNumberToObject(jobject, KEY_SAMPLING_RATE, 0);
299     cJSON_AddNumberToObject(jobject, KEY_FORMAT, 0);
300     cJSON_AddNumberToObject(jobject, KEY_CHANNELS, 0);
301     cJSON_AddNumberToObject(jobject, KEY_CONTENT_TYPE, 0);
302     cJSON_AddNumberToObject(jobject, KEY_STREAM_USAGE, 0);
303     cJSON_AddNumberToObject(jobject, KEY_SOURCE_TYPE, 0);
304     char *jsonData = cJSON_PrintUnformatted(jobject);
305     if (jsonData == nullptr) {
306         cJSON_Delete(jobject);
307         return;
308     }
309     std::string args(jsonData);
310     cJSON_free(jsonData);
311     cJSON_Delete(jobject);
312     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
313     auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
314     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
315     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
316 }
317 
318 /**
319  * @tc.name: TaskOpenDMic_003
320  * @tc.desc: Verify the TaskOpenDMic function.
321  * @tc.type: FUNC
322  * @tc.require: AR000H0E5F
323  */
324 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_003, TestSize.Level1)
325 {
326     std::string args;
327     ASSERT_NE(sinkDev_, nullptr);
328     sinkDev_->isDevLevelStatus_ = true;
329     EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sinkDev_->TaskOpenDMic(args));
330     args = "{\"dhId\":\"1\"}";
331     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskOpenDMic(args));
332     args = "{\"KEY_DH_ID\":\"1\", \"KEY_AUDIO_PARAM\":\"param\"}}";
333     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
334 }
335 
336 /**
337  * @tc.name: TaskCloseDMic_001
338  * @tc.desc: Verify the TaskCloseDMic function.
339  * @tc.type: FUNC
340  * @tc.require: AR000H0E5F
341  */
342 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_001, TestSize.Level1)
343 {
344     std::string args = "{\"dhId\":\"1\"}";
345     ASSERT_NE(sinkDev_, nullptr);
346     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
347 }
348 
349 /**
350  * @tc.name: TaskCloseDMic_002
351  * @tc.desc: Verify the TaskCloseDMic function.
352  * @tc.type: FUNC
353  * @tc.require: AR000H0E5F
354  */
355 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_002, TestSize.Level1)
356 {
357     std::string args = "{\"dhId\":\"123\"}";
358     std::string devId;
359     int32_t dhId = 1 << 27 | 1 << 0;
360     auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
361     ASSERT_NE(sinkDev_, nullptr);
362     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
363     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
364     std::string dhIdArgs = "{\"dhId\":1}";
365     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskCloseDMic(dhIdArgs));
366 }
367 
368 /**
369  * @tc.name: TaskCloseDMic_003
370  * @tc.desc: Verify the TaskCloseDMic function.
371  * @tc.type: FUNC
372  * @tc.require: AR000H0E5F
373  */
374 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_003, TestSize.Level1)
375 {
376     std::string args = "{\"dhId\":\"-1\"}";
377     std::string devId;
378     int32_t dhId = 1;
379     ASSERT_NE(sinkDev_, nullptr);
380     sinkDev_->isPageStatus_ = true;
381     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskCloseDMic(args));
382     args = "{\"dhId\":\"1\"}";
383     auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
384     sinkDev_->micClientMap_.insert(std::make_pair(dhId, micClient));
385     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
386 }
387 
388 /**
389  * @tc.name: TaskSetParameter_001
390  * @tc.desc: Verify the TaskSetParameter function.
391  * @tc.type: FUNC
392  * @tc.require: AR000H0E5F
393  */
394 HWTEST_F(DAudioSinkDevTest, TaskSetParameter_001, TestSize.Level1)
395 {
396     std::string args;
397     ASSERT_NE(sinkDev_, nullptr);
398     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
399     int32_t dhId = 1;
400     std::string devId = "devId";
401     args += "{\"dhId\":\"1\"}";
402     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskSetParameter(args));
403     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
404     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
405     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
406 }
407 
408 /**
409  * @tc.name: TaskSetParameter_002
410  * @tc.desc: Verify the TaskSetParameter function.
411  * @tc.type: FUNC
412  * @tc.require: AR000H0E5F
413  */
414 HWTEST_F(DAudioSinkDevTest, TaskSetParameter_002, TestSize.Level1)
415 {
416     std::string args;
417     std::string devId;
418     int32_t dhId = 1;
419     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
420     ASSERT_NE(sinkDev_, nullptr);
421     sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
422     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
423 }
424 
425 /**
426  * @tc.name: TaskSetVolume_001
427  * @tc.desc: Verify the TaskSetVolume function.
428  * @tc.type: FUNC
429  * @tc.require: AR000H0E5F
430  */
431 HWTEST_F(DAudioSinkDevTest, TaskSetVolume_001, TestSize.Level1)
432 {
433     std::string args;
434     ASSERT_NE(sinkDev_, nullptr);
435     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
436 }
437 
438 /**
439  * @tc.name: TaskSetVolume_002
440  * @tc.desc: Verify the TaskSetVolume function.
441  * @tc.type: FUNC
442  * @tc.require: AR000H0E5F
443  */
444 HWTEST_F(DAudioSinkDevTest, TaskSetVolume_002, TestSize.Level1)
445 {
446     std::string args = "{\"dhId\":\"1\"}";
447     std::string devId;
448     int32_t dhId = 1;
449     ASSERT_NE(sinkDev_, nullptr);
450     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
451     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
452     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
453     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
454     std::string args1 = "dhId=1";
455     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args1));
456 }
457 
458 /**
459  * @tc.name: TaskSetMute_001
460  * @tc.desc: Verify the TaskSetMute function.
461  * @tc.type: FUNC
462  * @tc.require: AR000H0E5F
463  */
464 HWTEST_F(DAudioSinkDevTest, TaskSetMute_001, TestSize.Level1)
465 {
466     std::string args;
467     ASSERT_NE(sinkDev_, nullptr);
468     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
469 }
470 
471 /**
472  * @tc.name: TaskSetMute_002
473  * @tc.desc: Verify the TaskSetMute function.
474  * @tc.type: FUNC
475  * @tc.require: AR000H0E5F
476  */
477 HWTEST_F(DAudioSinkDevTest, TaskSetMute_002, TestSize.Level1)
478 {
479     std::string args = "{\"dhId\":\"1\", \"eventType\":\"setMute\"}";
480     std::string devId = "devId";
481     int32_t dhId = 1;
482     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
483     ASSERT_NE(sinkDev_, nullptr);
484     sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
485     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
486     std::string args1 = "dhId=1";
487     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args1));
488 }
489 
490 /**
491  * @tc.name: TaskVolumeChange_001
492  * @tc.desc: Verify the TaskVolumeChange function.
493  * @tc.type: FUNC
494  * @tc.require: AR000H0E5F
495  */
496 HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_001, TestSize.Level1)
497 {
498     std::string args;
499     ASSERT_NE(sinkDev_, nullptr);
500     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskVolumeChange(args));
501 }
502 
503 /**
504  * @tc.name: TaskVolumeChange_002
505  * @tc.desc: Verify the TaskVolumeChange function.
506  * @tc.type: FUNC
507  * @tc.require: AR000H0E5F
508  */
509 HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_002, TestSize.Level1)
510 {
511     std::string args;
512     std::string devId = "devId";
513     ASSERT_NE(sinkDev_, nullptr);
514     sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
515     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskVolumeChange(args));
516 }
517 
518 /**
519  * @tc.name: TaskFocusChange_001
520  * @tc.desc: Verify the TaskFocusChange function.
521  * @tc.type: FUNC
522  * @tc.require: AR000H0E5F
523  */
524 HWTEST_F(DAudioSinkDevTest, TaskFocusChange_001, TestSize.Level1)
525 {
526     std::string args;
527     ASSERT_NE(sinkDev_, nullptr);
528     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskFocusChange(args));
529 }
530 
531 /**
532  * @tc.name: TaskFocusChange_002
533  * @tc.desc: Verify the TaskFocusChange function.
534  * @tc.type: FUNC
535  * @tc.require: AR000H0E5F
536  */
537 HWTEST_F(DAudioSinkDevTest, TaskFocusChange_002, TestSize.Level1)
538 {
539     std::string args;
540     std::string devId = "devId";
541     ASSERT_NE(sinkDev_, nullptr);
542     sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
543     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskFocusChange(args));
544 }
545 
546 /**
547  * @tc.name: TaskRenderStateChange_001
548  * @tc.desc: Verify the TaskRenderStateChange function.
549  * @tc.type: FUNC
550  * @tc.require: AR000H0E5F
551  */
552 HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_001, TestSize.Level1)
553 {
554     int32_t dhIdSpk = 1;
555     int32_t dhIdMic = 1 << 27 | 1 << 0;
556     std::string args = "{\"dhId\":\"123\"}";
557     std::string dhId = "123";
558     std::string devId = "devId";
559     std::string dhIdS = "1";
560     std::string dhIdM = "134217729";
561     int32_t result = 0;
562     ASSERT_NE(sinkDev_, nullptr);
563     sinkDev_->NotifySourceDev(AUDIO_START, dhId, result);
564     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhIdSpk, sinkDev_);
565     sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
566     auto micClient = std::make_shared<DMicClient>(devId, dhIdMic, sinkDev_);
567     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
568     sinkDev_->NotifySourceDev(AUDIO_START, dhId, result);
569     sinkDev_->NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, dhId, result);
570     sinkDev_->NotifySourceDev(NOTIFY_CLOSE_CTRL_RESULT, dhId, result);
571     sinkDev_->NotifySourceDev(AUDIO_START, devId, result);
572     sinkDev_->NotifySourceDev(AUDIO_START, dhIdS, result);
573     sinkDev_->NotifySourceDev(AUDIO_START, dhIdM, result);
574     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args));
575 }
576 
577 /**
578  * @tc.name: TaskRenderStateChange_002
579  * @tc.desc: Verify the TaskRenderStateChange function.
580  * @tc.type: FUNC
581  * @tc.require: AR000H0E5F
582  */
583 HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_002, TestSize.Level1)
584 {
585     std::string args;
586     std::string devId = "devId";
587     cJSON *j = cJSON_CreateObject();
588     CHECK_NULL_VOID(j);
589     AudioParam audioParam;
590     ASSERT_NE(sinkDev_, nullptr);
591     sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
592     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args));
593     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->from_json(j, audioParam));
594     cJSON_Delete(j);
595 }
596 
597 /**
598  * @tc.name: SendAudioEventToRemote_002
599  * @tc.desc: Verify the SendAudioEventToRemote function.
600  * @tc.type: FUNC
601  * @tc.require: AR000H0E5F
602  */
603 HWTEST_F(DAudioSinkDevTest, SendAudioEventToRemote_002, TestSize.Level1)
604 {
605     std::string devId = "devId";
606     int32_t dhId = 1;
607     AudioEvent event;
608     event.content = "{\"dhId\":\"1\"}";
609     ASSERT_NE(sinkDev_, nullptr);
610     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
611     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
612     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
613     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
614 }
615 
616 /**
617  * @tc.name: PauseDistributedHardware_001
618  * @tc.desc: Verify the PauseDistributedHardware function.
619  * @tc.type: FUNC
620  * @tc.require: AR000H0E5F
621  */
622 HWTEST_F(DAudioSinkDevTest, PauseDistributedHardware_001, TestSize.Level1)
623 {
624     std::string networkId = "networkId";
625     ASSERT_NE(sinkDev_, nullptr);
626     sinkDev_->PullUpPage();
627     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->PauseDistributedHardware(networkId));
628     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->ResumeDistributedHardware(networkId));
629     EXPECT_EQ(DH_SUCCESS, sinkDev_->StopDistributedHardware(networkId));
630 }
631 
632 /**
633  * @tc.name: JudgeDeviceStatus_001
634  * @tc.desc: Verify the JudgeDeviceStatus function.
635  * @tc.type: FUNC
636  * @tc.require: AR000H0E5F
637  */
638 HWTEST_F(DAudioSinkDevTest, JudgeDeviceStatus_001, TestSize.Level1)
639 {
640     ASSERT_NE(sinkDev_, nullptr);
641     sinkDev_->JudgeDeviceStatus();
642     sinkDev_->isSpkInUse_.store(true);
643     sinkDev_->JudgeDeviceStatus();
644     sinkDev_->isMicInUse_.store(true);
645     sinkDev_->JudgeDeviceStatus();
646     sinkDev_->isSpkInUse_.store(false);
647     sinkDev_->JudgeDeviceStatus();
648     std::string args = "one";
649     EXPECT_NE(DH_SUCCESS, sinkDev_->ConvertString2Int(args));
650 }
651 
652 /**
653  * @tc.name: SinkEventHandler_001
654  * @tc.desc: Verify the SinkEventHandler function.
655  * @tc.type: FUNC
656  * @tc.require: AR000H0E5F
657  */
658 HWTEST_F(DAudioSinkDevTest, SinkEventHandler_001, TestSize.Level1)
659 {
660     int32_t eventType = 2500;
661     std::string eventContent = "eventContent";
662     AudioEvent audioEvent(eventType, eventContent);
663     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
664     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
665     ASSERT_NE(sinkDev_, nullptr);
666     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
667     ASSERT_NE(sinkDev_->handler_, nullptr);
668     sinkDev_->handler_->ProcessEvent(msgEvent);
669     eventType = CTRL_OPENED;
670     std::string content = "content";
671     AudioEvent event(eventType, content);
672     auto Param = std::make_shared<AudioEvent>(event);
673     auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(event.type), Param, 0);
674     sinkDev_->handler_->ProcessEvent(msg);
675     sinkDev_->handler_->NotifyCtrlOpened(msg);
676     std::string networkId = "networkId";
677     std::string devId;
678     int32_t dhId = 134217729;
679     sinkDev_->micDhId_ = "134217729";
680     auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
681     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
682     EXPECT_EQ(DH_SUCCESS, sinkDev_->PauseDistributedHardware(networkId));
683 }
684 
685 /**
686  * @tc.name: SinkEventHandler_002
687  * @tc.desc: Verify the SinkEventHandler function.
688  * @tc.type: FUNC
689  * @tc.require: AR000H0E5F
690  */
691 HWTEST_F(DAudioSinkDevTest, SinkEventHandler_002, TestSize.Level1)
692 {
693     int32_t dhId = 1;
694     int32_t eventType = CTRL_CLOSED;
695     std::string eventContent = "{\"dhId\":\"1\"}";
696     std::string devId = "devId";
697     AudioEvent audioEvent(eventType, eventContent);
698     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
699     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
700     ASSERT_NE(sinkDev_, nullptr);
701     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
702     sinkDev_->spkClientMap_[dhId] = nullptr;
703     sinkDev_->micClientMap_[dhId] = nullptr;
704     ASSERT_NE(sinkDev_->handler_, nullptr);
705     sinkDev_->handler_->NotifyCtrlClosed(msgEvent);
706     auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
707     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
708     micClient->micTrans_ =nullptr;
709     sinkDev_->handler_->NotifyCtrlClosed(msgEvent);
710     std::string content = "content";
711     AudioEvent event(eventType, content);
712     auto Param = std::make_shared<AudioEvent>(event);
713     auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(event.type), Param, 0);
714     sinkDev_->handler_->NotifyCtrlClosed(msg);
715     std::string networkId = "networkId";
716     dhId = 134217729;
717     sinkDev_->micDhId_ = "134217729";
718     micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
719     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
720     EXPECT_EQ(DH_SUCCESS, sinkDev_->ResumeDistributedHardware(networkId));
721 }
722 
723 /**
724  * @tc.name: SinkEventHandler_003
725  * @tc.desc: Verify the SinkEventHandler function.
726  * @tc.type: FUNC
727  * @tc.require: AR000H0E5F
728  */
729 HWTEST_F(DAudioSinkDevTest, SinkEventHandler_003, TestSize.Level1)
730 {
731     int32_t eventType = OPEN_SPEAKER;
732     std::string eventContent = "{\"dhId\":\"dhId\",\"audioParam\":\"audioParam\"}";
733     std::string devId = "devId";
734     std::string networkId = "networkId";
735     AudioEvent audioEvent(eventType, devId);
736     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
737     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
738     ASSERT_NE(sinkDev_, nullptr);
739     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
740     sinkDev_->handler_->NotifyOpenSpeaker(msgEvent);
741     sinkDev_->handler_->NotifyOpenMic(msgEvent);
742     AudioEvent event(eventType, eventContent);
743     auto Param = std::make_shared<AudioEvent>(event);
744     auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(event.type), Param, 0);
745     sinkDev_->handler_->NotifyOpenSpeaker(msg);
746     EXPECT_EQ(DH_SUCCESS, sinkDev_->StopDistributedHardware(networkId));
747 }
748 
749 /**
750  * @tc.name: SinkEventHandler_004
751  * @tc.desc: Verify the SinkEventHandler function.
752  * @tc.type: FUNC
753  * @tc.require: AR000H0E5F
754  */
755 HWTEST_F(DAudioSinkDevTest, SinkEventHandler_004, TestSize.Level1)
756 {
757     int32_t eventType = OPEN_SPEAKER;
758     std::shared_ptr<AudioEvent> nullForFail = nullptr;
759     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(eventType), nullForFail, 0);
760     ASSERT_NE(sinkDev_, nullptr);
761     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
762     ASSERT_NE(sinkDev_->handler_, nullptr);
763     sinkDev_->handler_->NotifyCtrlOpened(msgEvent);
764     sinkDev_->handler_->NotifyCtrlClosed(msgEvent);
765     sinkDev_->handler_->NotifyOpenSpeaker(msgEvent);
766     sinkDev_->handler_->NotifyCloseSpeaker(msgEvent);
767     sinkDev_->handler_->NotifySpeakerOpened(msgEvent);
768     sinkDev_->handler_->NotifySpeakerClosed(msgEvent);
769     sinkDev_->handler_->NotifyOpenMic(msgEvent);
770     sinkDev_->handler_->NotifyCloseMic(msgEvent);
771     sinkDev_->handler_->NotifyMicOpened(msgEvent);
772     sinkDev_->handler_->NotifyMicClosed(msgEvent);
773     sinkDev_->handler_->NotifySetVolume(msgEvent);
774     sinkDev_->handler_->NotifyVolumeChange(msgEvent);
775     sinkDev_->handler_->NotifySetParam(msgEvent);
776     sinkDev_->handler_->NotifySetMute(msgEvent);
777     sinkDev_->handler_->NotifyFocusChange(msgEvent);
778     sinkDev_->handler_->NotifyRenderStateChange(msgEvent);
779     sinkDev_->handler_->NotifyPlayStatusChange(msgEvent);
780     std::string eventContent = "{\"dhId\":\"1\"}";
781     std::string paramResult;
782     AudioEvent audioEvent(eventType, eventContent);
783     sinkDev_->NotifyEvent(audioEvent);
784     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
785     auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
786     sinkDev_->handler_->NotifyCtrlOpened(msg);
787     sinkDev_->handler_->NotifyCtrlClosed(msg);
788     sinkDev_->handler_->NotifyOpenSpeaker(msg);
789     sinkDev_->handler_->NotifyCloseSpeaker(msg);
790     sinkDev_->handler_->NotifySpeakerOpened(msg);
791     sinkDev_->handler_->NotifySpeakerClosed(msg);
792     sinkDev_->handler_->NotifyOpenMic(msg);
793     sinkDev_->handler_->NotifyCloseMic(msg);
794     sinkDev_->handler_->NotifyMicOpened(msg);
795     sinkDev_->handler_->NotifyMicClosed(msg);
796     sinkDev_->handler_->NotifySetVolume(msg);
797     sinkDev_->handler_->NotifyVolumeChange(msg);
798     sinkDev_->handler_->NotifySetParam(msg);
799     sinkDev_->handler_->NotifySetMute(msg);
800     sinkDev_->handler_->NotifyFocusChange(msg);
801     sinkDev_->handler_->NotifyRenderStateChange(msg);
802     sinkDev_->handler_->NotifyPlayStatusChange(msg);
803     EXPECT_EQ(DH_SUCCESS, sinkDev_->handler_->GetEventParam(msg, paramResult));
804 }
805 
806 /**
807  * @tc.name: NotifyCtrlClosed_001
808  * @tc.desc: Verify the NotifyCtrlClosed function.
809  * @tc.type: FUNC
810  * @tc.require: AR000H0E5F
811  */
812 HWTEST_F(DAudioSinkDevTest, NotifyCtrlClosed_001, TestSize.Level1)
813 {
814     std::string eventContent1 = "ohos.dhardware.daudio.dspeaker";
815     std::string eventContent2 = "ohos.dhardware.daudio.dmic";
816     std::string eventContent3 = "ohos.dhardware.daudio.dspeaker.ohos.dhardware.daudio.dmic";
817     int32_t eventType = DISABLE_DEVICE;
818     AudioEvent audioEvent(eventType, eventContent1);
819     ASSERT_NE(sinkDev_, nullptr);
820     sinkDev_->NotifyEvent(audioEvent);
821     audioEvent.content = eventContent2;
822     sinkDev_->NotifyEvent(audioEvent);
823     audioEvent.content = eventContent3;
824     sinkDev_->NotifyEvent(audioEvent);
825     std::string eventContent = "{\"devId\":\"1\"}";
826     std::string paramResult;
827     audioEvent.type = OPEN_SPEAKER;
828     audioEvent.content = eventContent;
829     sinkDev_->NotifyEvent(audioEvent);
830     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
831     auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
832     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
833     ASSERT_NE(sinkDev_->handler_, nullptr);
834     sinkDev_->handler_->NotifyCtrlClosed(msg);
835     audioEvent.content = "{\"dhId\":\"134217729\"}";
836     eventParam = std::make_shared<AudioEvent>(audioEvent);
837     msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
838     sinkDev_->handler_->NotifyCtrlClosed(msg);
839     int32_t dhIdMic = 1 << 27 | 1 << 0;;
840     std::string devId = "devId";
841     auto micClient = std::make_shared<DMicClient>(devId, dhIdMic, sinkDev_);
842     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
843     EXPECT_EQ(DH_SUCCESS, sinkDev_->handler_->GetEventParam(msg, paramResult));
844 }
845 } // DistributedHardware
846 } // OHOS
847