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 CHECK_NULL_AND_FREE_VOID(jsonData, jobject);
162 std::string args(jsonData);
163 cJSON_free(jsonData);
164 cJSON_Delete(jobject);
165 ASSERT_NE(sinkDev_, nullptr);
166 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
167 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
168 sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
169 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
170 }
171
172 /**
173 * @tc.name: TaskCloseDSpeaker_001
174 * @tc.desc: Verify the TaskCloseDSpeaker function.
175 * @tc.type: FUNC
176 * @tc.require: AR000H0E5F
177 */
178 HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_001, TestSize.Level1)
179 {
180 std::string args = "{\"dhId\":\"1\"}";
181 ASSERT_NE(sinkDev_, nullptr);
182 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
183 }
184
185 /**
186 * @tc.name: TaskCloseDSpeaker_002
187 * @tc.desc: Verify the TaskCloseDSpeaker function.
188 * @tc.type: FUNC
189 * @tc.require: AR000H0E5F
190 */
191 HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1)
192 {
193 std::string args = "{\"dhId\":\"1\"}";
194 std::string devId = "devId";
195 int32_t dhId = 1;
196 ASSERT_NE(sinkDev_, nullptr);
197 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
198 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
199 sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
200 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
201 }
202
203 /**
204 * @tc.name: ParseDhidFromEvent_001
205 * @tc.desc: Verify the ParseDhidFromEvent function.
206 * @tc.type: FUNC
207 * @tc.require: AR000H0E5F
208 */
209 HWTEST_F(DAudioSinkDevTest, ParseDhidFromEvent_001, TestSize.Level1)
210 {
211 std::string args = "{\"devId\":\"1\"}";
212 ASSERT_NE(sinkDev_, nullptr);
213 EXPECT_NE(DH_SUCCESS, sinkDev_->ParseDhidFromEvent(args));
214 std::string dhIdArgs = "{\"dhId\": 1 }";
215 EXPECT_NE(DH_SUCCESS, sinkDev_->ParseDhidFromEvent(dhIdArgs));
216 }
217
218 /**
219 * @tc.name: ParseResultFromEvent_001
220 * @tc.desc: Verify the ParseResultFromEvent function.
221 * @tc.type: FUNC
222 * @tc.require: AR000H0E5F
223 */
224 HWTEST_F(DAudioSinkDevTest, ParseResultFromEvent_001, TestSize.Level1)
225 {
226 std::string args = "{\"result\":\"-40001\"}";
227 ASSERT_NE(sinkDev_, nullptr);
228 EXPECT_EQ(-1, sinkDev_->ParseResultFromEvent(args));
229 std::string dhIdArgs = "{\"result\": 1 }";
230 EXPECT_NE(DH_SUCCESS, sinkDev_->ParseResultFromEvent(dhIdArgs));
231
232 cJSON *jobject = cJSON_CreateObject();
233 CHECK_NULL_VOID(jobject);
234 cJSON_AddNumberToObject(jobject, KEY_RESULT, 0);
235 char *jsonData = cJSON_PrintUnformatted(jobject);
236 CHECK_NULL_AND_FREE_VOID(jsonData, jobject);
237 std::string args1(jsonData);
238 cJSON_free(jsonData);
239 cJSON_Delete(jobject);
240 EXPECT_EQ(DH_SUCCESS, sinkDev_->ParseResultFromEvent(args1));
241 }
242
243
244 /**
245 * @tc.name: TaskStartRender_001
246 * @tc.desc: Verify the TaskStartRender function.
247 * @tc.type: FUNC
248 * @tc.require: AR000H0E5F
249 */
250 HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1)
251 {
252 std::string devId = "devId";
253 int32_t dhId = 1;
254 std::string args = "{\"dhId\":\"1\"}";
255 ASSERT_NE(sinkDev_, nullptr);
256 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskStartRender(args));
257 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
258 sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
259 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskStartRender(args));
260 std::string devIdArgs = "{\"devId\":\"1\"}";
261 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskStartRender(devIdArgs));
262 }
263
264 /**
265 * @tc.name: TaskOpenDMic_001
266 * @tc.desc: Verify the TaskOpenDMic function.
267 * @tc.type: FUNC
268 * @tc.require: AR000H0E5F
269 */
270 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_001, TestSize.Level1)
271 {
272 std::string args;
273 ASSERT_NE(sinkDev_, nullptr);
274 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
275 }
276
277 /**
278 * @tc.name: TaskOpenDMic_002
279 * @tc.desc: Verify the TaskOpenDMic function.
280 * @tc.type: FUNC
281 * @tc.require: AR000H0E5F
282 */
283 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_002, TestSize.Level1)
284 {
285 ASSERT_NE(sinkDev_, nullptr);
286 sinkDev_->isDevLevelStatus_ = true;
287 std::string devId = "1";
288 int32_t dhId = 1;
289 cJSON *jobject = cJSON_CreateObject();
290 CHECK_NULL_VOID(jobject);
291 cJSON_AddStringToObject(jobject, KEY_DH_ID, "1");
292 cJSON_AddNumberToObject(jobject, KEY_SAMPLING_RATE, 0);
293 cJSON_AddNumberToObject(jobject, KEY_FORMAT, 0);
294 cJSON_AddNumberToObject(jobject, KEY_CHANNELS, 0);
295 cJSON_AddNumberToObject(jobject, KEY_CONTENT_TYPE, 0);
296 cJSON_AddNumberToObject(jobject, KEY_STREAM_USAGE, 0);
297 cJSON_AddNumberToObject(jobject, KEY_SOURCE_TYPE, 0);
298 char *jsonData = cJSON_PrintUnformatted(jobject);
299 CHECK_NULL_AND_FREE_VOID(jsonData, jobject);
300 std::string args(jsonData);
301 cJSON_free(jsonData);
302 cJSON_Delete(jobject);
303 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
304 auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
305 sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
306 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
307 }
308
309 /**
310 * @tc.name: TaskOpenDMic_003
311 * @tc.desc: Verify the TaskOpenDMic function.
312 * @tc.type: FUNC
313 * @tc.require: AR000H0E5F
314 */
315 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_003, TestSize.Level1)
316 {
317 std::string args;
318 ASSERT_NE(sinkDev_, nullptr);
319 sinkDev_->isDevLevelStatus_ = true;
320 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sinkDev_->TaskOpenDMic(args));
321 args = "{\"dhId\":\"1\"}";
322 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskOpenDMic(args));
323 args = "{\"KEY_DH_ID\":\"1\", \"KEY_AUDIO_PARAM\":\"param\"}}";
324 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
325 }
326
327 /**
328 * @tc.name: TaskCloseDMic_001
329 * @tc.desc: Verify the TaskCloseDMic function.
330 * @tc.type: FUNC
331 * @tc.require: AR000H0E5F
332 */
333 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_001, TestSize.Level1)
334 {
335 std::string args = "{\"dhId\":\"1\"}";
336 ASSERT_NE(sinkDev_, nullptr);
337 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
338 }
339
340 /**
341 * @tc.name: TaskCloseDMic_002
342 * @tc.desc: Verify the TaskCloseDMic function.
343 * @tc.type: FUNC
344 * @tc.require: AR000H0E5F
345 */
346 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_002, TestSize.Level1)
347 {
348 std::string args = "{\"dhId\":\"123\"}";
349 std::string devId;
350 int32_t dhId = 1 << 27 | 1 << 0;
351 auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
352 ASSERT_NE(sinkDev_, nullptr);
353 sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
354 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
355 std::string dhIdArgs = "{\"dhId\":1}";
356 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskCloseDMic(dhIdArgs));
357 }
358
359 /**
360 * @tc.name: TaskCloseDMic_003
361 * @tc.desc: Verify the TaskCloseDMic function.
362 * @tc.type: FUNC
363 * @tc.require: AR000H0E5F
364 */
365 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_003, TestSize.Level1)
366 {
367 std::string args = "{\"dhId\":\"-1\"}";
368 std::string devId;
369 int32_t dhId = 1;
370 ASSERT_NE(sinkDev_, nullptr);
371 sinkDev_->isPageStatus_ = true;
372 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskCloseDMic(args));
373 args = "{\"dhId\":\"1\"}";
374 auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
375 sinkDev_->micClientMap_.insert(std::make_pair(dhId, micClient));
376 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
377 }
378
379 /**
380 * @tc.name: TaskSetParameter_001
381 * @tc.desc: Verify the TaskSetParameter function.
382 * @tc.type: FUNC
383 * @tc.require: AR000H0E5F
384 */
385 HWTEST_F(DAudioSinkDevTest, TaskSetParameter_001, TestSize.Level1)
386 {
387 std::string args;
388 ASSERT_NE(sinkDev_, nullptr);
389 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
390 int32_t dhId = 1;
391 std::string devId = "devId";
392 args += "{\"dhId\":\"1\"}";
393 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskSetParameter(args));
394 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
395 sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
396 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
397 }
398
399 /**
400 * @tc.name: TaskSetParameter_002
401 * @tc.desc: Verify the TaskSetParameter function.
402 * @tc.type: FUNC
403 * @tc.require: AR000H0E5F
404 */
405 HWTEST_F(DAudioSinkDevTest, TaskSetParameter_002, TestSize.Level1)
406 {
407 std::string args;
408 std::string devId;
409 int32_t dhId = 1;
410 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
411 ASSERT_NE(sinkDev_, nullptr);
412 sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
413 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
414 }
415
416 /**
417 * @tc.name: TaskSetVolume_001
418 * @tc.desc: Verify the TaskSetVolume function.
419 * @tc.type: FUNC
420 * @tc.require: AR000H0E5F
421 */
422 HWTEST_F(DAudioSinkDevTest, TaskSetVolume_001, TestSize.Level1)
423 {
424 std::string args;
425 ASSERT_NE(sinkDev_, nullptr);
426 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
427 }
428
429 /**
430 * @tc.name: TaskSetVolume_002
431 * @tc.desc: Verify the TaskSetVolume function.
432 * @tc.type: FUNC
433 * @tc.require: AR000H0E5F
434 */
435 HWTEST_F(DAudioSinkDevTest, TaskSetVolume_002, TestSize.Level1)
436 {
437 std::string args = "{\"dhId\":\"1\"}";
438 std::string devId;
439 int32_t dhId = 1;
440 ASSERT_NE(sinkDev_, nullptr);
441 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
442 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
443 sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
444 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
445 std::string args1 = "dhId=1";
446 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args1));
447 }
448
449 /**
450 * @tc.name: TaskSetMute_001
451 * @tc.desc: Verify the TaskSetMute function.
452 * @tc.type: FUNC
453 * @tc.require: AR000H0E5F
454 */
455 HWTEST_F(DAudioSinkDevTest, TaskSetMute_001, TestSize.Level1)
456 {
457 std::string args;
458 ASSERT_NE(sinkDev_, nullptr);
459 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
460 }
461
462 /**
463 * @tc.name: TaskSetMute_002
464 * @tc.desc: Verify the TaskSetMute function.
465 * @tc.type: FUNC
466 * @tc.require: AR000H0E5F
467 */
468 HWTEST_F(DAudioSinkDevTest, TaskSetMute_002, TestSize.Level1)
469 {
470 std::string args = "{\"dhId\":\"1\", \"eventType\":\"setMute\"}";
471 std::string devId = "devId";
472 int32_t dhId = 1;
473 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
474 ASSERT_NE(sinkDev_, nullptr);
475 sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
476 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
477 std::string args1 = "dhId=1";
478 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args1));
479 }
480
481 /**
482 * @tc.name: TaskVolumeChange_001
483 * @tc.desc: Verify the TaskVolumeChange function.
484 * @tc.type: FUNC
485 * @tc.require: AR000H0E5F
486 */
487 HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_001, TestSize.Level1)
488 {
489 std::string args;
490 ASSERT_NE(sinkDev_, nullptr);
491 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskVolumeChange(args));
492 }
493
494 /**
495 * @tc.name: TaskVolumeChange_002
496 * @tc.desc: Verify the TaskVolumeChange function.
497 * @tc.type: FUNC
498 * @tc.require: AR000H0E5F
499 */
500 HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_002, TestSize.Level1)
501 {
502 std::string args;
503 std::string devId = "devId";
504 ASSERT_NE(sinkDev_, nullptr);
505 sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
506 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskVolumeChange(args));
507 }
508
509 /**
510 * @tc.name: TaskFocusChange_001
511 * @tc.desc: Verify the TaskFocusChange function.
512 * @tc.type: FUNC
513 * @tc.require: AR000H0E5F
514 */
515 HWTEST_F(DAudioSinkDevTest, TaskFocusChange_001, TestSize.Level1)
516 {
517 std::string args;
518 ASSERT_NE(sinkDev_, nullptr);
519 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskFocusChange(args));
520 }
521
522 /**
523 * @tc.name: TaskFocusChange_002
524 * @tc.desc: Verify the TaskFocusChange function.
525 * @tc.type: FUNC
526 * @tc.require: AR000H0E5F
527 */
528 HWTEST_F(DAudioSinkDevTest, TaskFocusChange_002, TestSize.Level1)
529 {
530 std::string args;
531 std::string devId = "devId";
532 ASSERT_NE(sinkDev_, nullptr);
533 sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
534 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskFocusChange(args));
535 }
536
537 /**
538 * @tc.name: TaskRenderStateChange_001
539 * @tc.desc: Verify the TaskRenderStateChange function.
540 * @tc.type: FUNC
541 * @tc.require: AR000H0E5F
542 */
543 HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_001, TestSize.Level1)
544 {
545 int32_t dhIdSpk = 1;
546 int32_t dhIdMic = 1 << 27 | 1 << 0;
547 std::string args = "{\"dhId\":\"123\"}";
548 std::string dhId = "123";
549 std::string devId = "devId";
550 std::string dhIdS = "1";
551 std::string dhIdM = "134217729";
552 int32_t result = 0;
553 ASSERT_NE(sinkDev_, nullptr);
554 sinkDev_->NotifySourceDev(AUDIO_START, dhId, result);
555 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhIdSpk, sinkDev_);
556 sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
557 auto micClient = std::make_shared<DMicClient>(devId, dhIdMic, sinkDev_);
558 sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
559 sinkDev_->NotifySourceDev(AUDIO_START, dhId, result);
560 sinkDev_->NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, dhId, result);
561 sinkDev_->NotifySourceDev(NOTIFY_CLOSE_CTRL_RESULT, dhId, result);
562 sinkDev_->NotifySourceDev(AUDIO_START, devId, result);
563 sinkDev_->NotifySourceDev(AUDIO_START, dhIdS, result);
564 sinkDev_->NotifySourceDev(AUDIO_START, dhIdM, result);
565 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args));
566 }
567
568 /**
569 * @tc.name: TaskRenderStateChange_002
570 * @tc.desc: Verify the TaskRenderStateChange function.
571 * @tc.type: FUNC
572 * @tc.require: AR000H0E5F
573 */
574 HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_002, TestSize.Level1)
575 {
576 std::string args;
577 std::string devId = "devId";
578 cJSON *j = cJSON_CreateObject();
579 CHECK_NULL_VOID(j);
580 AudioParam audioParam;
581 ASSERT_NE(sinkDev_, nullptr);
582 sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
583 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args));
584 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->from_json(j, audioParam));
585 cJSON_Delete(j);
586 }
587
588 /**
589 * @tc.name: SendAudioEventToRemote_002
590 * @tc.desc: Verify the SendAudioEventToRemote function.
591 * @tc.type: FUNC
592 * @tc.require: AR000H0E5F
593 */
594 HWTEST_F(DAudioSinkDevTest, SendAudioEventToRemote_002, TestSize.Level1)
595 {
596 std::string devId = "devId";
597 int32_t dhId = 1;
598 AudioEvent event;
599 event.content = "{\"dhId\":\"1\"}";
600 ASSERT_NE(sinkDev_, nullptr);
601 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
602 auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
603 sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
604 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
605 }
606
607 /**
608 * @tc.name: PauseDistributedHardware_001
609 * @tc.desc: Verify the PauseDistributedHardware function.
610 * @tc.type: FUNC
611 * @tc.require: AR000H0E5F
612 */
613 HWTEST_F(DAudioSinkDevTest, PauseDistributedHardware_001, TestSize.Level1)
614 {
615 std::string networkId = "networkId";
616 ASSERT_NE(sinkDev_, nullptr);
617 sinkDev_->PullUpPage();
618 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->PauseDistributedHardware(networkId));
619 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->ResumeDistributedHardware(networkId));
620 EXPECT_EQ(DH_SUCCESS, sinkDev_->StopDistributedHardware(networkId));
621 }
622
623 /**
624 * @tc.name: JudgeDeviceStatus_001
625 * @tc.desc: Verify the JudgeDeviceStatus function.
626 * @tc.type: FUNC
627 * @tc.require: AR000H0E5F
628 */
629 HWTEST_F(DAudioSinkDevTest, JudgeDeviceStatus_001, TestSize.Level1)
630 {
631 ASSERT_NE(sinkDev_, nullptr);
632 sinkDev_->JudgeDeviceStatus();
633 sinkDev_->isSpkInUse_.store(true);
634 sinkDev_->JudgeDeviceStatus();
635 sinkDev_->isMicInUse_.store(true);
636 sinkDev_->JudgeDeviceStatus();
637 sinkDev_->isSpkInUse_.store(false);
638 sinkDev_->JudgeDeviceStatus();
639 std::string args = "one";
640 EXPECT_NE(DH_SUCCESS, sinkDev_->ConvertString2Int(args));
641 }
642
643 /**
644 * @tc.name: SinkEventHandler_001
645 * @tc.desc: Verify the SinkEventHandler function.
646 * @tc.type: FUNC
647 * @tc.require: AR000H0E5F
648 */
649 HWTEST_F(DAudioSinkDevTest, SinkEventHandler_001, TestSize.Level1)
650 {
651 int32_t eventType = 2500;
652 std::string eventContent = "eventContent";
653 AudioEvent audioEvent(eventType, eventContent);
654 auto eventParam = std::make_shared<AudioEvent>(audioEvent);
655 auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
656 ASSERT_NE(sinkDev_, nullptr);
657 EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
658 ASSERT_NE(sinkDev_->handler_, nullptr);
659 sinkDev_->handler_->ProcessEvent(msgEvent);
660 eventType = CTRL_OPENED;
661 std::string content = "content";
662 AudioEvent event(eventType, content);
663 auto Param = std::make_shared<AudioEvent>(event);
664 auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(event.type), Param, 0);
665 sinkDev_->handler_->ProcessEvent(msg);
666 sinkDev_->handler_->NotifyCtrlOpened(msg);
667 std::string networkId = "networkId";
668 std::string devId;
669 int32_t dhId = 134217729;
670 sinkDev_->micDhId_ = "134217729";
671 auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
672 sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
673 EXPECT_EQ(DH_SUCCESS, sinkDev_->PauseDistributedHardware(networkId));
674 }
675
676 /**
677 * @tc.name: SinkEventHandler_002
678 * @tc.desc: Verify the SinkEventHandler function.
679 * @tc.type: FUNC
680 * @tc.require: AR000H0E5F
681 */
682 HWTEST_F(DAudioSinkDevTest, SinkEventHandler_002, TestSize.Level1)
683 {
684 int32_t dhId = 1;
685 int32_t eventType = CTRL_CLOSED;
686 std::string eventContent = "{\"dhId\":\"1\"}";
687 std::string devId = "devId";
688 AudioEvent audioEvent(eventType, eventContent);
689 auto eventParam = std::make_shared<AudioEvent>(audioEvent);
690 auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
691 ASSERT_NE(sinkDev_, nullptr);
692 EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
693 sinkDev_->spkClientMap_[dhId] = nullptr;
694 sinkDev_->micClientMap_[dhId] = nullptr;
695 ASSERT_NE(sinkDev_->handler_, nullptr);
696 sinkDev_->handler_->NotifyCtrlClosed(msgEvent);
697 auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
698 sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
699 micClient->micTrans_ =nullptr;
700 sinkDev_->handler_->NotifyCtrlClosed(msgEvent);
701 std::string content = "content";
702 AudioEvent event(eventType, content);
703 auto Param = std::make_shared<AudioEvent>(event);
704 auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(event.type), Param, 0);
705 sinkDev_->handler_->NotifyCtrlClosed(msg);
706 std::string networkId = "networkId";
707 dhId = 134217729;
708 sinkDev_->micDhId_ = "134217729";
709 micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
710 sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
711 EXPECT_EQ(DH_SUCCESS, sinkDev_->ResumeDistributedHardware(networkId));
712 }
713
714 /**
715 * @tc.name: SinkEventHandler_003
716 * @tc.desc: Verify the SinkEventHandler function.
717 * @tc.type: FUNC
718 * @tc.require: AR000H0E5F
719 */
720 HWTEST_F(DAudioSinkDevTest, SinkEventHandler_003, TestSize.Level1)
721 {
722 int32_t eventType = OPEN_SPEAKER;
723 std::string eventContent = "{\"dhId\":\"dhId\",\"audioParam\":\"audioParam\"}";
724 std::string devId = "devId";
725 std::string networkId = "networkId";
726 AudioEvent audioEvent(eventType, devId);
727 auto eventParam = std::make_shared<AudioEvent>(audioEvent);
728 auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
729 ASSERT_NE(sinkDev_, nullptr);
730 EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
731 sinkDev_->handler_->NotifyOpenSpeaker(msgEvent);
732 sinkDev_->handler_->NotifyOpenMic(msgEvent);
733 AudioEvent event(eventType, eventContent);
734 auto Param = std::make_shared<AudioEvent>(event);
735 auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(event.type), Param, 0);
736 sinkDev_->handler_->NotifyOpenSpeaker(msg);
737 EXPECT_EQ(DH_SUCCESS, sinkDev_->StopDistributedHardware(networkId));
738 }
739
740 /**
741 * @tc.name: SinkEventHandler_004
742 * @tc.desc: Verify the SinkEventHandler function.
743 * @tc.type: FUNC
744 * @tc.require: AR000H0E5F
745 */
746 HWTEST_F(DAudioSinkDevTest, SinkEventHandler_004, TestSize.Level1)
747 {
748 int32_t eventType = OPEN_SPEAKER;
749 std::shared_ptr<AudioEvent> nullForFail = nullptr;
750 auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(eventType), nullForFail, 0);
751 ASSERT_NE(sinkDev_, nullptr);
752 EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
753 ASSERT_NE(sinkDev_->handler_, nullptr);
754 sinkDev_->handler_->NotifyCtrlOpened(msgEvent);
755 sinkDev_->handler_->NotifyCtrlClosed(msgEvent);
756 sinkDev_->handler_->NotifyOpenSpeaker(msgEvent);
757 sinkDev_->handler_->NotifyCloseSpeaker(msgEvent);
758 sinkDev_->handler_->NotifySpeakerOpened(msgEvent);
759 sinkDev_->handler_->NotifySpeakerClosed(msgEvent);
760 sinkDev_->handler_->NotifyOpenMic(msgEvent);
761 sinkDev_->handler_->NotifyCloseMic(msgEvent);
762 sinkDev_->handler_->NotifyMicOpened(msgEvent);
763 sinkDev_->handler_->NotifyMicClosed(msgEvent);
764 sinkDev_->handler_->NotifySetVolume(msgEvent);
765 sinkDev_->handler_->NotifyVolumeChange(msgEvent);
766 sinkDev_->handler_->NotifySetParam(msgEvent);
767 sinkDev_->handler_->NotifySetMute(msgEvent);
768 sinkDev_->handler_->NotifyFocusChange(msgEvent);
769 sinkDev_->handler_->NotifyRenderStateChange(msgEvent);
770 sinkDev_->handler_->NotifyPlayStatusChange(msgEvent);
771 std::string eventContent = "{\"dhId\":\"1\"}";
772 std::string paramResult;
773 AudioEvent audioEvent(eventType, eventContent);
774 sinkDev_->NotifyEvent(audioEvent);
775 auto eventParam = std::make_shared<AudioEvent>(audioEvent);
776 auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
777 sinkDev_->handler_->NotifyCtrlOpened(msg);
778 sinkDev_->handler_->NotifyCtrlClosed(msg);
779 sinkDev_->handler_->NotifyOpenSpeaker(msg);
780 sinkDev_->handler_->NotifyCloseSpeaker(msg);
781 sinkDev_->handler_->NotifySpeakerOpened(msg);
782 sinkDev_->handler_->NotifySpeakerClosed(msg);
783 sinkDev_->handler_->NotifyOpenMic(msg);
784 sinkDev_->handler_->NotifyCloseMic(msg);
785 sinkDev_->handler_->NotifyMicOpened(msg);
786 sinkDev_->handler_->NotifyMicClosed(msg);
787 sinkDev_->handler_->NotifySetVolume(msg);
788 sinkDev_->handler_->NotifyVolumeChange(msg);
789 sinkDev_->handler_->NotifySetParam(msg);
790 sinkDev_->handler_->NotifySetMute(msg);
791 sinkDev_->handler_->NotifyFocusChange(msg);
792 sinkDev_->handler_->NotifyRenderStateChange(msg);
793 sinkDev_->handler_->NotifyPlayStatusChange(msg);
794 EXPECT_EQ(DH_SUCCESS, sinkDev_->handler_->GetEventParam(msg, paramResult));
795 }
796
797 /**
798 * @tc.name: NotifyCtrlClosed_001
799 * @tc.desc: Verify the NotifyCtrlClosed function.
800 * @tc.type: FUNC
801 * @tc.require: AR000H0E5F
802 */
803 HWTEST_F(DAudioSinkDevTest, NotifyCtrlClosed_001, TestSize.Level1)
804 {
805 std::string eventContent1 = "ohos.dhardware.daudio.dspeaker";
806 std::string eventContent2 = "ohos.dhardware.daudio.dmic";
807 std::string eventContent3 = "ohos.dhardware.daudio.dspeaker.ohos.dhardware.daudio.dmic";
808 int32_t eventType = DISABLE_DEVICE;
809 AudioEvent audioEvent(eventType, eventContent1);
810 ASSERT_NE(sinkDev_, nullptr);
811 sinkDev_->NotifyEvent(audioEvent);
812 audioEvent.content = eventContent2;
813 sinkDev_->NotifyEvent(audioEvent);
814 audioEvent.content = eventContent3;
815 sinkDev_->NotifyEvent(audioEvent);
816 std::string eventContent = "{\"devId\":\"1\"}";
817 std::string paramResult;
818 audioEvent.type = OPEN_SPEAKER;
819 audioEvent.content = eventContent;
820 sinkDev_->NotifyEvent(audioEvent);
821 auto eventParam = std::make_shared<AudioEvent>(audioEvent);
822 auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
823 EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
824 ASSERT_NE(sinkDev_->handler_, nullptr);
825 sinkDev_->handler_->NotifyCtrlClosed(msg);
826 audioEvent.content = "{\"dhId\":\"134217729\"}";
827 eventParam = std::make_shared<AudioEvent>(audioEvent);
828 msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
829 sinkDev_->handler_->NotifyCtrlClosed(msg);
830 int32_t dhIdMic = 1 << 27 | 1 << 0;;
831 std::string devId = "devId";
832 auto micClient = std::make_shared<DMicClient>(devId, dhIdMic, sinkDev_);
833 sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
834 EXPECT_EQ(DH_SUCCESS, sinkDev_->handler_->GetEventParam(msg, paramResult));
835 }
836 } // DistributedHardware
837 } // OHOS
838