1 /*
2 * Copyright (c) 2022-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 <thread>
17 #include <chrono>
18
19 #include "audio_adapter_interface_impl_test.h"
20 #include "daudio_constants.h"
21
22 using namespace testing::ext;
23 using namespace OHOS::DistributedHardware;
24 namespace OHOS {
25 namespace HDI {
26 namespace DistributedAudio {
27 namespace Audio {
28 namespace V1_0 {
29 static constexpr int32_t DEFAULT_CAPTURE_ID = 1 << 27 | 1 << 0;
30
SetUpTestCase(void)31 void AudioAdapterInterfaceImpTest::SetUpTestCase(void) {}
32
TearDownTestCase(void)33 void AudioAdapterInterfaceImpTest::TearDownTestCase(void) {}
34
SetUp(void)35 void AudioAdapterInterfaceImpTest::SetUp(void) {}
36
TearDown(void)37 void AudioAdapterInterfaceImpTest::TearDown(void)
38 {
39 AdapterTest_ = nullptr;
40 }
41
42 /**
43 * @tc.name: InitAllPorts_001
44 * @tc.desc: Verify the InitAllPorts function.
45 * @tc.type: FUNC
46 * @tc.require: AR000H0E6H
47 */
48 HWTEST_F(AudioAdapterInterfaceImpTest, InitAllPorts_001, TestSize.Level1)
49 {
50 AudioAdapterDescriptor adaDesc;
51 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
52
53 sptr<IDAudioCallback> speakerCallback = nullptr;
54 int32_t dhId = 1;
55 AdapterTest_->SetSpeakerCallback(dhId, speakerCallback);
56 AdapterTest_->extCallbackMap_.erase(dhId);
57 speakerCallback = sptr<IDAudioCallback>(new MockIDAudioCallback());
58 AdapterTest_->SetSpeakerCallback(dhId, speakerCallback);
59
60 dhId = DEFAULT_CAPTURE_ID;
61 sptr<IDAudioCallback> micCallback = nullptr;
62 AdapterTest_->SetMicCallback(dhId, micCallback);
63 AdapterTest_->extCallbackMap_.erase(dhId);
64 micCallback = sptr<IDAudioCallback>(new MockIDAudioCallback());
65 AdapterTest_->SetMicCallback(dhId, micCallback);
66
67 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->InitAllPorts());
68 }
69
70 /**
71 * @tc.name: CreateRender_001
72 * @tc.desc: Verify the CreateRender function.
73 * @tc.type: FUNC
74 * @tc.require: AR000H0E6H
75 */
76 HWTEST_F(AudioAdapterInterfaceImpTest, CreateRender_001, TestSize.Level1)
77 {
78 AudioAdapterDescriptor adaDesc;
79 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
80
81 AudioDeviceDescriptor devDesc;
82 AudioSampleAttributes attrs;
83 sptr<IAudioRender> render = nullptr;
84 uint32_t renderId = 0;
85 int32_t dhId = 1;
86 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockIDAudioCallback());
87 EXPECT_NE(HDF_SUCCESS, AdapterTest_->CreateRender(devDesc, attrs, render, renderId));
88 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyRender(renderId));
89
90 AdapterTest_->mapAudioDevice_.insert(std::make_pair(PIN_OUT_DAUDIO_DEFAULT, "hello"));
91 devDesc.pins = PIN_OUT_DAUDIO_DEFAULT;
92 EXPECT_NE(HDF_SUCCESS, AdapterTest_->CreateRender(devDesc, attrs, render, renderId));
93 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyRender(renderId));
94 }
95
96 /**
97 * @tc.name: DestroyRender_001
98 * @tc.desc: Verify the DestroyRender function.
99 * @tc.type: FUNC
100 * @tc.require: AR000H0E6H
101 */
102 HWTEST_F(AudioAdapterInterfaceImpTest, DestroyRender_001, TestSize.Level1)
103 {
104 AudioAdapterDescriptor adaDesc;
105 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
106
107 AudioDeviceDescriptor devDesc;
108 AudioSampleAttributes attrs;
109 std::string adpterName = "adbcef";
110 int32_t dhId = 1;
111 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
112 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockRevertIDAudioCallback());
113
114 devDesc.pins = PIN_OUT_DAUDIO_DEFAULT;
115 uint32_t renderId = 0;
116 AdapterTest_->renderDevs_[renderId] = std::make_pair(dhId,
117 new AudioRenderInterfaceImpl(adpterName, devDesc, attrs, callback, renderId));
118 AdapterTest_->spkPinInUse_ = 0;
119
120 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyRender(renderId));
121 renderId = 10;
122 EXPECT_EQ(HDF_FAILURE, AdapterTest_->DestroyRender(renderId));
123 renderId = 1;
124 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyRender(renderId));
125 }
126
127 /**
128 * @tc.name: CreateCapture_001
129 * @tc.desc: Verify the CreateCapture function.
130 * @tc.type: FUNC
131 * @tc.require: AR000H0E6H
132 */
133 HWTEST_F(AudioAdapterInterfaceImpTest, CreateCapture_001, TestSize.Level1)
134 {
135 AudioAdapterDescriptor adaDesc;
136 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
137
138 AudioDeviceDescriptor devDesc;
139 AudioSampleAttributes attrs;
140 sptr<IAudioCapture> capture = nullptr;
141 uint32_t capId = 0;
142 int32_t dhId = DEFAULT_CAPTURE_ID;
143 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockIDAudioCallback());
144 EXPECT_NE(HDF_SUCCESS, AdapterTest_->CreateCapture(devDesc, attrs, capture, capId));
145 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyCapture(capId));
146
147 AdapterTest_->mapAudioDevice_.insert(std::make_pair(PIN_OUT_DAUDIO_DEFAULT, "hello"));
148 devDesc.pins = PIN_OUT_DAUDIO_DEFAULT;
149 EXPECT_NE(HDF_SUCCESS, AdapterTest_->CreateCapture(devDesc, attrs, capture, capId));
150 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyCapture(capId));
151 }
152
153 /**
154 * @tc.name: CreateRender_001
155 * @tc.desc: Verify the DestroyCapture function.
156 * @tc.type: FUNC
157 * @tc.require: AR000H0E6H
158 */
159 HWTEST_F(AudioAdapterInterfaceImpTest, DestroyCapture_001, TestSize.Level1)
160 {
161 AudioAdapterDescriptor adaDesc;
162 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
163
164 AudioDeviceDescriptor devDesc;
165 AudioSampleAttributes attrs;
166 std::string adpterName = "adbcef";
167 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
168 int32_t dhId = DEFAULT_CAPTURE_ID;
169 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockRevertIDAudioCallback());
170
171 devDesc.pins = PIN_OUT_DAUDIO_DEFAULT;
172 uint32_t capId = 0;
173 AdapterTest_->captureDevs_[capId] = std::make_pair(dhId,
174 new AudioCaptureInterfaceImpl(adpterName, devDesc, attrs, callback));
175
176 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyCapture(capId));
177 capId = 10;
178 EXPECT_EQ(HDF_FAILURE, AdapterTest_->DestroyCapture(capId));
179 capId = 1;
180 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyCapture(capId));
181 }
182
183 /**
184 * @tc.name: GetPortCapability_001
185 * @tc.desc: Verify the GetPortCapability function.
186 * @tc.type: FUNC
187 * @tc.require: AR000H0E6H
188 */
189 HWTEST_F(AudioAdapterInterfaceImpTest, GetPortCapability_001, TestSize.Level1)
190 {
191 AudioAdapterDescriptor adaDesc;
192 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
193
194 AudioPort port;
195 AudioPortCapability capability;
196 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetPortCapability(port, capability));
197 }
198
199 /**
200 * @tc.name: SetPassthroughMode_001
201 * @tc.desc: Verify the SetPassthroughMode function.
202 * @tc.type: FUNC
203 * @tc.require: AR000H0E6H
204 */
205 HWTEST_F(AudioAdapterInterfaceImpTest, SetPassthroughMode_001, TestSize.Level1)
206 {
207 AudioAdapterDescriptor adaDesc;
208 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
209
210 AudioPort port;
211 AudioPortPassthroughMode mode = AudioPortPassthroughMode::PORT_PASSTHROUGH_LPCM;
212 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetPassthroughMode(port, mode));
213 }
214
215 /**
216 * @tc.name: GetPassthroughMode_001
217 * @tc.desc: Verify the GetPassthroughMode function.
218 * @tc.type: FUNC
219 * @tc.require: AR000H0E6H
220 */
221 HWTEST_F(AudioAdapterInterfaceImpTest, GetPassthroughMode_001, TestSize.Level1)
222 {
223 AudioAdapterDescriptor adaDesc;
224 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
225
226 AudioPort port;
227 AudioPortPassthroughMode mode = AudioPortPassthroughMode::PORT_PASSTHROUGH_LPCM;
228 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetPassthroughMode(port, mode));
229 }
230
231 /**
232 * @tc.name: GetDeviceStatus_001
233 * @tc.desc: Verify the GetDeviceStatus function.
234 * @tc.type: FUNC
235 * @tc.require: AR000H0E6H
236 */
237 HWTEST_F(AudioAdapterInterfaceImpTest, GetDeviceStatus_001, TestSize.Level1)
238 {
239 AudioAdapterDescriptor adaDesc;
240 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
241
242 AudioDeviceStatus sta;
243
244 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetDeviceStatus(sta));
245 }
246
247 /**
248 * @tc.name: SetMicMute_001
249 * @tc.desc: Verify the SetMicMute function.
250 * @tc.type: FUNC
251 * @tc.require: AR000H0E6H
252 */
253 HWTEST_F(AudioAdapterInterfaceImpTest, SetMicMute_001, TestSize.Level1)
254 {
255 AudioAdapterDescriptor adaDesc;
256 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
257
258 bool muteTmp = true;
259 bool muteGetted;
260 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetMicMute(muteTmp));
261 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetMicMute(muteGetted));
262 }
263
264 /**
265 * @tc.name: SetVoiceVolume_001
266 * @tc.desc: Verify the SetVoiceVolume function.
267 * @tc.type: FUNC
268 * @tc.require: AR000H0E6H
269 */
270 HWTEST_F(AudioAdapterInterfaceImpTest, SetVoiceVolume_001, TestSize.Level1)
271 {
272 AudioAdapterDescriptor adaDesc;
273 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
274
275 float vol = 1.0f;
276 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetVoiceVolume(vol));
277 }
278
279 /**
280 * @tc.name: UpdateAudioRoute_001
281 * @tc.desc: Verify the UpdateAudioRoute function.
282 * @tc.type: FUNC
283 * @tc.require: AR000H0E6H
284 */
285 HWTEST_F(AudioAdapterInterfaceImpTest, UpdateAudioRoute_001, TestSize.Level1)
286 {
287 AudioAdapterDescriptor adaDesc;
288 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
289
290 AudioRoute route;
291 int32_t handle = 0;
292 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->UpdateAudioRoute(route, handle));
293 }
294
295 /**
296 * @tc.name: ReleaseAudioRoute_001
297 * @tc.desc: Verify the ReleaseAudioRoute function.
298 * @tc.type: FUNC
299 * @tc.require: AR000H0E6H
300 */
301 HWTEST_F(AudioAdapterInterfaceImpTest, ReleaseAudioRoute_001, TestSize.Level1)
302 {
303 AudioAdapterDescriptor adaDesc;
304 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
305
306 int32_t handle = 0;
307 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->ReleaseAudioRoute(handle));
308 }
309
310 /**
311 * @tc.name: SetExtraParams_001
312 * @tc.desc: Verify the SetExtraParams function.
313 * @tc.type: FUNC
314 * @tc.require: AR000H0E6H
315 */
316 HWTEST_F(AudioAdapterInterfaceImpTest, SetExtraParams_001, TestSize.Level1)
317 {
318 AudioAdapterDescriptor adaDesc;
319 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
320
321 AudioExtParamKey key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_NONE;
322 std::string condition = "{\"dhId\":\"1\"}";
323 std::string value = "world";
324 EXPECT_EQ(HDF_ERR_INVALID_PARAM, AdapterTest_->SetExtraParams(key, condition, value));
325 key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_VOLUME;
326 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetExtraParams(key, condition, value));
327 key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_LOWPOWER;
328 EXPECT_NE(HDF_SUCCESS, AdapterTest_->SetExtraParams(key, condition, value));
329 }
330
331 /**
332 * @tc.name: GetExtraParams_001
333 * @tc.desc: Verify the GetExtraParams function.
334 * @tc.type: FUNC
335 * @tc.require: AR000H0E6H
336 */
337 HWTEST_F(AudioAdapterInterfaceImpTest, GetExtraParams_001, TestSize.Level1)
338 {
339 AudioAdapterDescriptor adaDesc;
340 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
341
342 AudioExtParamKey key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_NONE;
343 std::string condition = "hello";
344 std::string value = "world";
345 EXPECT_EQ(HDF_ERR_INVALID_PARAM, AdapterTest_->GetExtraParams(key, condition, value));
346 }
347
348 /**
349 * @tc.name: GetExtraParams_002
350 * @tc.desc: Verify the GetExtraParams function.
351 * @tc.type: FUNC
352 * @tc.require: AR000H0E6H
353 */
354 HWTEST_F(AudioAdapterInterfaceImpTest, GetExtraParams_002, TestSize.Level1)
355 {
356 AudioAdapterDescriptor adaDesc;
357 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
358
359 AudioExtParamKey key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_VOLUME;
360 std::string condition = "hello";
361 std::string value = "1";
362 EXPECT_NE(HDF_SUCCESS, AdapterTest_->GetExtraParams(key, condition, value));
363 }
364
365 /**
366 * @tc.name: GetExtraParams_003
367 * @tc.desc: Verify the GetExtraParams function.
368 * @tc.type: FUNC
369 * @tc.require: AR000H0E6H
370 */
371 HWTEST_F(AudioAdapterInterfaceImpTest, GetExtraParams_003, TestSize.Level1)
372 {
373 AudioAdapterDescriptor adaDesc;
374 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
375
376 AudioExtParamKey key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_VOLUME;
377 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
378 std::string value = "1";
379 EXPECT_EQ(HDF_FAILURE, AdapterTest_->GetExtraParams(key, condition, value));
380 }
381
382 /**
383 * @tc.name: GetExtraParams_004
384 * @tc.desc: Verify the GetExtraParams function.
385 * @tc.type: FUNC
386 * @tc.require: AR000H0E6H
387 */
388 HWTEST_F(AudioAdapterInterfaceImpTest, GetExtraParams_004, TestSize.Level1)
389 {
390 AudioAdapterDescriptor adaDesc;
391 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
392
393 AudioExtParamKey key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_STATUS;
394 std::string condition = "hello";
395 std::string value = "world";
396 EXPECT_EQ(HDF_ERR_INVALID_PARAM, AdapterTest_->GetExtraParams(key, condition, value));
397 }
398
399 /**
400 * @tc.name: RegExtraParamObserver_001
401 * @tc.desc: Verify the RegExtraParamObserver function.
402 * @tc.type: FUNC
403 * @tc.require: AR000H0E6H
404 */
405 HWTEST_F(AudioAdapterInterfaceImpTest, RegExtraParamObserver_001, TestSize.Level1)
406 {
407 AudioAdapterDescriptor adaDesc;
408 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
409
410 sptr<IAudioCallback> cbObj = nullptr;
411 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->RegExtraParamObserver(cbObj, 0));
412 }
413
414 /**
415 * @tc.name: RegExtraParamObserver_002
416 * @tc.desc: Verify the RegExtraParamObserver function.
417 * @tc.type: FUNC
418 * @tc.require: AR000H0E6H
419 */
420 HWTEST_F(AudioAdapterInterfaceImpTest, RegExtraParamObserver_002, TestSize.Level1)
421 {
422 AudioAdapterDescriptor adaDesc;
423 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
424
425 AdapterTest_->paramCallback_ = sptr<IAudioCallback>(new MockIAudioParamCallback());
426 sptr<IAudioCallback> cbObj = sptr<IAudioCallback>(new MockIAudioParamCallback());
427 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->RegExtraParamObserver(cbObj, 0));
428 }
429
430 /**
431 * @tc.name: GetAdapterDesc_002
432 * @tc.desc: Verify the GetAdapterDesc function.
433 * @tc.type: FUNC
434 * @tc.require: AR000H0E6H
435 */
436 HWTEST_F(AudioAdapterInterfaceImpTest, GetAdapterDesc_002, TestSize.Level1)
437 {
438 AudioAdapterDescriptor adaDesc;
439 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
440
441 AdapterTest_->mapAudioDevice_.insert(std::make_pair(64, "hello"));
442 AudioPort port;
443 port.dir = PORT_OUT_IN;
444 port.portId = 64;
445 port.portName = "";
446 AdapterTest_->GetAdapterDesc();
447 EXPECT_EQ(PORT_OUT_IN, AdapterTest_->adpDescriptor_.ports[0].dir);
448 }
449
450 /**
451 * @tc.name: GetDeviceCapabilitys_001
452 * @tc.desc: Verify the GetDeviceCapabilitys function.
453 * @tc.type: FUNC
454 * @tc.require: AR000H0E6H
455 */
456 HWTEST_F(AudioAdapterInterfaceImpTest, GetDeviceCapabilitys_001, TestSize.Level1)
457 {
458 AudioAdapterDescriptor adaDesc;
459 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
460
461 uint32_t devId = 88;
462 std::string caps = "worldcup";
463 AdapterTest_->AddAudioDevice(devId, caps);
464
465 EXPECT_EQ(caps, AdapterTest_->GetDeviceCapabilitys(devId));
466 }
467
468 /**
469 * @tc.name: GetDeviceCapabilitys_002
470 * @tc.desc: Verify the GetDeviceCapabilitys function.
471 * @tc.type: FUNC
472 * @tc.require: AR000H0E6H
473 */
474 HWTEST_F(AudioAdapterInterfaceImpTest, GetDeviceCapabilitys_002, TestSize.Level1)
475 {
476 AudioAdapterDescriptor adaDesc;
477 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
478
479 uint32_t devId = 88;
480 std::string caps = "worldcup";
481 AdapterTest_->RemoveAudioDevice(devId);
482
483 EXPECT_EQ("", AdapterTest_->GetDeviceCapabilitys(devId));
484 }
485
486 /**
487 * @tc.name: AdapterLoad_001
488 * @tc.desc: Verify the AdapterLoad function.
489 * @tc.type: FUNC
490 * @tc.require: AR000H0E6H
491 */
492 HWTEST_F(AudioAdapterInterfaceImpTest, AdapterLoad_001, TestSize.Level1)
493 {
494 AudioAdapterDescriptor adaDesc;
495 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
496
497 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->AdapterLoad());
498 }
499
500 /**
501 * @tc.name: AdapterUnload_001
502 * @tc.desc: Verify the AdapterUnload function.
503 * @tc.type: FUNC
504 * @tc.require: AR000H0E6H
505 */
506 HWTEST_F(AudioAdapterInterfaceImpTest, AdapterUnload_001, TestSize.Level1)
507 {
508 AudioAdapterDescriptor adaDesc;
509 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
510
511 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->AdapterUnload());
512
513 std::string adpterName = "adbcef";
514 AudioDeviceDescriptor descSpk;
515 AudioSampleAttributes attrsSpk;
516 int32_t dhId = 1;
517 sptr<IDAudioCallback> callbackSpk = sptr<IDAudioCallback>(new MockIDAudioCallback());
518 AdapterTest_->SetSpeakerCallback(dhId, callbackSpk);
519 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
520 new AudioRenderInterfaceImpl(adpterName, descSpk, attrsSpk, callbackSpk, 0));
521 EXPECT_EQ(HDF_ERR_DEVICE_BUSY, AdapterTest_->AdapterUnload());
522
523 AudioDeviceDescriptor devDescMic;
524 AudioSampleAttributes attrsMic;
525 dhId = DEFAULT_CAPTURE_ID;
526 sptr<IDAudioCallback> callbackMic = sptr<IDAudioCallback>(new MockIDAudioCallback());
527 AdapterTest_->SetMicCallback(dhId, callbackMic);
528 AdapterTest_->captureDevs_[0] = std::make_pair(dhId,
529 new AudioCaptureInterfaceImpl(adpterName, devDescMic, attrsMic, callbackMic));
530 EXPECT_EQ(HDF_ERR_DEVICE_BUSY, AdapterTest_->AdapterUnload());
531
532 AdapterTest_->renderDevs_[0].first = 0;
533 AdapterTest_->renderDevs_[0].second = nullptr;
534 EXPECT_EQ(HDF_ERR_DEVICE_BUSY, AdapterTest_->AdapterUnload());
535
536 AdapterTest_->captureDevs_[0].first = 0;
537 AdapterTest_->captureDevs_[0].second = nullptr;
538 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->AdapterUnload());
539 }
540
541 /**
542 * @tc.name: Notify_001
543 * @tc.desc: Verify the Notify function.
544 * @tc.type: FUNC
545 * @tc.require: AR000H0E6H
546 */
547 HWTEST_F(AudioAdapterInterfaceImpTest, Notify_001, TestSize.Level1)
548 {
549 AudioAdapterDescriptor adaDesc;
550 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
551
552 DAudioEvent event;
553 event.type = 3;
554 event.content = "VOLUME_LEVEL";
555 uint32_t devId = 64;
556 uint32_t streamId = 0;
557 EXPECT_NE(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
558 }
559
560 /**
561 * @tc.name: Notify_002
562 * @tc.desc: Verify the Notify function.
563 * @tc.type: FUNC
564 * @tc.require: AR000H0E6H
565 */
566 HWTEST_F(AudioAdapterInterfaceImpTest, Notify_002, TestSize.Level1)
567 {
568 AudioAdapterDescriptor adaDesc;
569 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
570
571 DAudioEvent event;
572 event.type = 10;
573 event.content = "FOCUS_CHANGE";
574 uint32_t devId = 64;
575 uint32_t streamId = 0;
576 EXPECT_NE(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
577 event.type = 11;
578 event.content = "RENDER_STATE_CHANG";
579 EXPECT_NE(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
580 event.type = 7;
581 event.content = "CLOSE_MIC_RESULT";
582 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
583 event.type = 9;
584 event.content = "MIC_CLOSED_STATE";
585 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
586 }
587
588 /**
589 * @tc.name: Notify_003
590 * @tc.desc: Verify the Notify function.
591 * @tc.type: FUNC
592 * @tc.require: AR000H0E6H
593 */
594 HWTEST_F(AudioAdapterInterfaceImpTest, Notify_003, TestSize.Level1)
595 {
596 AudioAdapterDescriptor adaDesc;
597 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
598
599 DAudioEvent event;
600 event.type = 4;
601 event.content = "OPEN_SPK_RESULT";
602 uint32_t devId = 64;
603 uint32_t streamId = 0;
604 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
605 event.type = 5;
606 event.content = "CLOSE_SPK_RESULT";
607 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
608 event.type = 6;
609 event.content = "OPEN_MIC_RESULT";
610 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
611 event.type = 8;
612 event.content = "SPK_CLOSED";
613 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->Notify(devId, streamId, event));
614 }
615
616 /**
617 * @tc.name: AddAudioDevice_001
618 * @tc.desc: Verify the AddAudioDevice function.
619 * @tc.type: FUNC
620 * @tc.require: AR000H0E6H
621 */
622 HWTEST_F(AudioAdapterInterfaceImpTest, AddAudioDevice_001, TestSize.Level1)
623 {
624 AudioAdapterDescriptor adaDesc;
625 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
626
627 uint32_t devId = 64;
628 std::string caps;
629 AdapterTest_->mapAudioDevice_.insert(std::make_pair(64, "hello"));
630 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->AddAudioDevice(devId, caps));
631 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->RemoveAudioDevice(devId));
632 }
633
634 /**
635 * @tc.name: AddAudioDevice_002
636 * @tc.desc: Verify the AddAudioDevice function.
637 * @tc.type: FUNC
638 * @tc.require: AR000H0E6H
639 */
640 HWTEST_F(AudioAdapterInterfaceImpTest, AddAudioDevice_002, TestSize.Level1)
641 {
642 AudioAdapterDescriptor adaDesc;
643 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
644
645 uint32_t devId = 64;
646 std::string caps = "hello";
647 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->AddAudioDevice(devId, caps));
648 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->RemoveAudioDevice(devId));
649 }
650
651 /**
652 * @tc.name: RemoveAudioDevice_001
653 * @tc.desc: Verify the RemoveAudioDevice function.
654 * @tc.type: FUNC
655 * @tc.require: AR000H0E6H
656 */
657 HWTEST_F(AudioAdapterInterfaceImpTest, RemoveAudioDevice_001, TestSize.Level1)
658 {
659 AudioAdapterDescriptor adaDesc;
660 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
661
662 uint32_t devId = 64;
663 std::string caps;
664 AdapterTest_->mapAudioDevice_.insert(std::make_pair(64, "hello"));
665 AdapterTest_->spkPinInUse_ = 64;
666 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->RemoveAudioDevice(devId));
667 AdapterTest_->mapAudioDevice_.insert(std::make_pair(64, "hello"));
668 AdapterTest_->spkPinInUse_ = 0;
669 AdapterTest_->micPinInUse_ = 64;
670 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->RemoveAudioDevice(devId));
671 }
672
673 /**
674 * @tc.name: OpenRenderDevice_001
675 * @tc.desc: Verify the OpenRenderDevice function.
676 * @tc.type: FUNC
677 * @tc.require: AR000H0E6H
678 */
679 HWTEST_F(AudioAdapterInterfaceImpTest, OpenRenderDevice_001, TestSize.Level1)
680 {
681 AudioAdapterDescriptor adaDesc;
682 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
683
684 AudioDeviceDescriptor devDesc;
685 AudioSampleAttributes attrs;
686 int32_t dhId = 1;
687 uint32_t renderId = 0;
688 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockIDAudioCallback());
689 EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs,
690 AdapterTest_->extCallbackMap_[dhId], dhId, renderId));
691 AdapterTest_->spkStatus_[renderId] = true;
692 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs,
693 AdapterTest_->extCallbackMap_[dhId], dhId, renderId));
694 }
695 /**
696 * @tc.name: OpenRenderDevice_002
697 * @tc.desc: Verify the OpenRenderDevice function.
698 * @tc.type: FUNC
699 * @tc.require: AR000H0E6H
700 */
701 HWTEST_F(AudioAdapterInterfaceImpTest, OpenRenderDevice_002, TestSize.Level1)
702 {
703 AudioAdapterDescriptor adaDesc;
704 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
705
706 AudioDeviceDescriptor devDesc;
707 AudioSampleAttributes attrs;
708 int32_t dhId = 1;
709 uint32_t renderId = 0;
710 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockRevertIDAudioCallback());
711 AdapterTest_->spkStatus_[renderId] = false;
712 EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs,
713 AdapterTest_->extCallbackMap_[dhId], dhId, renderId));
714 }
715
716 /**
717 * @tc.name: CloseRenderDevice_001
718 * @tc.desc: Verify the CloseRenderDevice function.
719 * @tc.type: FUNC
720 * @tc.require: AR000H0E6H
721 */
722 HWTEST_F(AudioAdapterInterfaceImpTest, CloseRenderDevice_001, TestSize.Level1)
723 {
724 AudioAdapterDescriptor adaDesc;
725 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
726
727 AudioDeviceDescriptor devDesc;
728 int32_t dhId = 1;
729 sptr<IDAudioCallback> callback(nullptr);
730 AdapterTest_->spkPinInUse_ = 0;
731 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc, callback, dhId));
732 AdapterTest_->spkPinInUse_ = 1;
733 callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
734 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc, callback, dhId));
735 callback = sptr<IDAudioCallback>(new MockRevertIDAudioCallback());
736 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc, callback, dhId));
737 }
738
739 /**
740 * @tc.name: OpenCaptureDevice_001
741 * @tc.desc: Verify the OpenCaptureDevice function.
742 * @tc.type: FUNC
743 * @tc.require: AR000H0E6H
744 */
745 HWTEST_F(AudioAdapterInterfaceImpTest, OpenCaptureDevice_001, TestSize.Level1)
746 {
747 AudioAdapterDescriptor adaDesc;
748 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
749
750 AudioDeviceDescriptor devDesc;
751 AudioSampleAttributes attrs;
752 int32_t dhId = DEFAULT_CAPTURE_ID;
753 sptr<IDAudioCallback> callback(new MockIDAudioCallback());
754 EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenCaptureDevice(devDesc, attrs, callback, dhId));
755 AdapterTest_->isMicOpened_ = true;
756 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->OpenCaptureDevice(devDesc, attrs, callback, dhId));
757 }
758
759 /**
760 * @tc.name: CloseCaptureDevice_001
761 * @tc.desc: Verify the CloseCaptureDevice function.
762 * @tc.type: FUNC
763 * @tc.require: AR000H0E6H
764 */
765 HWTEST_F(AudioAdapterInterfaceImpTest, CloseCaptureDevice_001, TestSize.Level1)
766 {
767 AudioAdapterDescriptor adaDesc;
768 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
769
770 AudioDeviceDescriptor devDesc;
771 int32_t dhId = DEFAULT_CAPTURE_ID;
772 sptr<IDAudioCallback> callback(new MockIDAudioCallback());
773 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseCaptureDevice(devDesc, callback, dhId));
774 AdapterTest_->micPinInUse_ = 1;
775 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseCaptureDevice(devDesc, callback, dhId));
776 }
777
778 /**
779 * @tc.name: GetVolumeGroup_001
780 * @tc.desc: Verify the GetVolumeGroup function.
781 * @tc.type: FUNC
782 * @tc.require: AR000H0E6H
783 */
784 HWTEST_F(AudioAdapterInterfaceImpTest, GetVolumeGroup_001, TestSize.Level1)
785 {
786 AudioAdapterDescriptor adaDesc;
787 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
788
789 uint32_t devId = 88;
790 int32_t dhId = DEFAULT_CAPTURE_ID;
791 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockIDAudioCallback());
792 EXPECT_EQ(0, AdapterTest_->GetVolumeGroup(devId));
793 }
794
795 /**
796 * @tc.name: GetInterruptGroup_001
797 * @tc.desc: Verify the GetInterruptGroup function.
798 * @tc.type: FUNC
799 * @tc.require: AR000H0E6H
800 */
801 HWTEST_F(AudioAdapterInterfaceImpTest, GetInterruptGroup_001, TestSize.Level1)
802 {
803 AudioAdapterDescriptor adaDesc;
804 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
805
806 uint32_t devId = 88;
807 int32_t dhId = 1;
808
809 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockIDAudioCallback());
810 EXPECT_EQ(0, AdapterTest_->GetInterruptGroup(devId));
811 }
812
813 /**
814 * @tc.name: SetAudioVolume_001
815 * @tc.desc: Verify the SetAudioVolume function.
816 * @tc.type: FUNC
817 * @tc.require: AR000H0E6H
818 */
819 HWTEST_F(AudioAdapterInterfaceImpTest, SetAudioVolume_001, TestSize.Level1)
820 {
821 AudioAdapterDescriptor adaDesc;
822 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
823
824 std::string condition = "EVENT_TYPE=4;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
825 std::string param = "1";
826 int32_t dhId = 1;
827 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param));
828 AdapterTest_->extCallbackMap_[dhId] = sptr<IDAudioCallback>(new MockIDAudioCallback());
829 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param));
830 std::string adpterName = "adbcef";
831 AudioDeviceDescriptor desc;
832 AudioSampleAttributes attrs;
833 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
834
835 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
836 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
837 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param));
838 param = "0";
839 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param));
840 param = "-66";
841 EXPECT_NE(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param));
842 condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
843 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param));
844 }
845
846 /**
847 * @tc.name: GetAudioVolume_001
848 * @tc.desc: Verify the GetAudioVolume function.
849 * @tc.type: FUNC
850 * @tc.require: AR000H0E6H
851 */
852 HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_001, TestSize.Level1)
853 {
854 AudioAdapterDescriptor adaDesc;
855 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
856
857 std::string adpterName = "adbcef";
858 AudioDeviceDescriptor desc;
859 AudioSampleAttributes attrs;
860 int32_t dhId = 1;
861 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
862
863 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
864 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
865
866 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
867 std::string param = "1";
868 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetAudioVolume(condition, param));
869 }
870
871 /**
872 * @tc.name: GetAudioVolume_002
873 * @tc.desc: Verify the GetAudioVolume function.
874 * @tc.type: FUNC
875 * @tc.require: AR000H0E6H
876 */
877 HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_002, TestSize.Level1)
878 {
879 AudioAdapterDescriptor adaDesc;
880 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
881
882 std::string adpterName = "adbcef";
883 AudioDeviceDescriptor desc;
884 AudioSampleAttributes attrs;
885 int32_t dhId = 1;
886 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
887
888 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
889 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
890
891 std::string condition = "EVENT_TYPE=3;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
892 std::string param = "1";
893 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetAudioVolume(condition, param));
894 }
895
896 /**
897 * @tc.name: GetAudioVolume_003
898 * @tc.desc: Verify the GetAudioVolume function.
899 * @tc.type: FUNC
900 * @tc.require: AR000H0E6H
901 */
902 HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_003, TestSize.Level1)
903 {
904 AudioAdapterDescriptor adaDesc;
905 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
906
907 std::string adpterName = "adbcef";
908 AudioDeviceDescriptor desc;
909 AudioSampleAttributes attrs;
910 int32_t dhId = 1;
911 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
912
913 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
914 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
915
916 std::string condition = "EVENT_TYPE=2;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
917 std::string param = "1";
918 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetAudioVolume(condition, param));
919 }
920
921 /**
922 * @tc.name: GetAudioVolume_004
923 * @tc.desc: Verify the GetAudioVolume function.
924 * @tc.type: FUNC
925 * @tc.require: AR000H0E6H
926 */
927 HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_004, TestSize.Level1)
928 {
929 AudioAdapterDescriptor adaDesc;
930 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
931
932 std::string adpterName = "adbcef";
933 AudioDeviceDescriptor desc;
934 AudioSampleAttributes attrs;
935 int32_t dhId = 1;
936 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
937
938 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
939 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
940
941 std::string condition = "EVENT_TYPE=4;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
942 std::string param = "1";
943 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetAudioVolume(condition, param));
944 }
945
946
947 /**
948 * @tc.name: GetAudioVolume_005
949 * @tc.desc: Verify the GetAudioVolume function.
950 * @tc.type: FUNC
951 * @tc.require: AR000H0E6H
952 */
953 HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_005, TestSize.Level1)
954 {
955 AudioAdapterDescriptor adaDesc;
956 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
957
958 std::string adpterName = "adbcef";
959 AudioDeviceDescriptor desc;
960 AudioSampleAttributes attrs;
961 int32_t dhId = 0;
962 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
963
964 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
965 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
966
967 std::string condition = "EVENT_TYPE=66;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
968 std::string param = "1";
969 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->GetAudioVolume(condition, param));
970 EXPECT_EQ("0", param);
971 }
972
973 /**
974 * @tc.name: GetAudioVolume_006
975 * @tc.desc: Verify the GetAudioVolume function.
976 * @tc.type: FUNC
977 * @tc.require: AR000H0E6H
978 */
979 HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_006, TestSize.Level1)
980 {
981 AudioAdapterDescriptor adaDesc;
982 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
983
984 AdapterTest_->renderDevs_[0] = std::make_pair(1, nullptr);
985
986 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
987 std::string param = "1";
988 EXPECT_NE(HDF_SUCCESS, AdapterTest_->GetAudioVolume(condition, param));
989 EXPECT_EQ("1", param);
990 }
991
992 /**
993 * @tc.name: getEventTypeFromCondition_001
994 * @tc.desc: Verify the getEventTypeFromCondition function.
995 * @tc.type: FUNC
996 * @tc.require: AR000H0E6H
997 */
998 HWTEST_F(AudioAdapterInterfaceImpTest, getEventTypeFromCondition_001, TestSize.Level1)
999 {
1000 AudioAdapterDescriptor adaDesc;
1001 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1002
1003 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
1004 auto actualValue = AdapterTest_->getEventTypeFromCondition(condition);
1005 EXPECT_EQ(1, actualValue);
1006 }
1007
1008 /**
1009 * @tc.name: getEventTypeFromCondition_002
1010 * @tc.desc: Verify the getEventTypeFromCondition function.
1011 * @tc.type: FUNC
1012 * @tc.require: AR000H0E6H
1013 */
1014 HWTEST_F(AudioAdapterInterfaceImpTest, getEventTypeFromCondition_002, TestSize.Level1)
1015 {
1016 AudioAdapterDescriptor adaDesc;
1017 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1018
1019 std::string condition = "EVENT_TYPE=12;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;";
1020 auto actualValue = AdapterTest_->getEventTypeFromCondition(condition);
1021 EXPECT_EQ(12, actualValue);
1022 }
1023
1024 /**
1025 * @tc.name: ParseDhIdFromJson_001
1026 * @tc.desc: Verify the ParseDhIdFromJson function.
1027 * @tc.type: FUNC
1028 * @tc.require: AR000H0E6H
1029 */
1030 HWTEST_F(AudioAdapterInterfaceImpTest, ParseDhIdFromJson_001, TestSize.Level1)
1031 {
1032 AudioAdapterDescriptor adaDesc;
1033 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1034
1035 std::string jsonArgs = "";
1036 EXPECT_EQ(-1, AdapterTest_->ParseDhIdFromJson(jsonArgs));
1037 }
1038
1039 /**
1040 * @tc.name: ConvertString2Int_001
1041 * @tc.desc: Verify the ConvertString2Int function.
1042 * @tc.type: FUNC
1043 * @tc.require: AR000H0E6H
1044 */
1045 HWTEST_F(AudioAdapterInterfaceImpTest, ConvertString2Int_001, TestSize.Level1)
1046 {
1047 AudioAdapterDescriptor adaDesc;
1048 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1049
1050 std::string valueStr = "";
1051 int value = 0;
1052
1053 for (int i = 1; i < 10; i++) {
1054 valueStr += std::to_string(i);
1055 value = value * 10 + i;
1056 EXPECT_EQ(value, AdapterTest_->ConvertString2Int(valueStr));
1057 }
1058 valueStr = "1ab";
1059 value = -1;
1060 EXPECT_EQ(value, AdapterTest_->ConvertString2Int(valueStr));
1061 }
1062
1063 /**
1064 * @tc.name: GetRenderImpl_001
1065 * @tc.desc: Verify the GetRenderImpl function.
1066 * @tc.type: FUNC
1067 * @tc.require: AR000H0E6H
1068 */
1069 HWTEST_F(AudioAdapterInterfaceImpTest, GetRenderImpl_001, TestSize.Level1)
1070 {
1071 AudioAdapterDescriptor adaDesc;
1072 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1073
1074 std::string content = "";
1075 EXPECT_EQ(nullptr, AdapterTest_->GetRenderImpl(content));
1076
1077 content = "{\"dhId\":\"1\"}";
1078 AudioDeviceDescriptor desc;
1079 AudioSampleAttributes attrs;
1080 const int dhId = 1;
1081 const std::string adpName = "abc";
1082 auto audioRender = sptr<AudioRenderInterfaceImplBase>(new AudioRenderInterfaceImpl(adpName,
1083 desc, attrs, nullptr, 0));
1084 AdapterTest_->renderDevs_[0] = std::make_pair(dhId, audioRender);
1085 EXPECT_NE(nullptr, AdapterTest_->GetRenderImpl(content));
1086 }
1087
1088 /**
1089 * @tc.name: HandleVolumeChangeEvent_001
1090 * @tc.desc: Verify the HandleVolumeChangeEvent function.
1091 * @tc.type: FUNC
1092 * @tc.require: AR000H0E6H
1093 */
1094 HWTEST_F(AudioAdapterInterfaceImpTest, HandleVolumeChangeEvent_001, TestSize.Level1)
1095 {
1096 AudioAdapterDescriptor adaDesc;
1097 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1098
1099 DAudioEvent event = {HDF_AUDIO_EVENT_VOLUME_CHANGE,
1100 "VOLUME_CHANAGE;AUDIO_STREAM_TYPE=1;VOLUME_LEVEL=1;IS_UPDATEUI=1;VOLUME_GROUP_ID=1;"};
1101 std::string adpterName = "adbcef";
1102 AudioDeviceDescriptor desc;
1103 AudioSampleAttributes attrs;
1104 int32_t dhId = 1;
1105 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
1106
1107 AdapterTest_->renderDevs_[0] = std::make_pair(dhId, nullptr);
1108 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event));
1109
1110 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
1111 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
1112 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event));
1113 AdapterTest_->paramCallback_ = sptr<IAudioCallback>(new MockIAudioParamCallback());
1114 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event));
1115 }
1116
1117 /**
1118 * @tc.name: HandleVolumeChangeEvent_002
1119 * @tc.desc: Verify the HandleVolumeChangeEvent function.
1120 * @tc.type: FUNC
1121 * @tc.require: AR000H0E6H
1122 */
1123 HWTEST_F(AudioAdapterInterfaceImpTest, HandleVolumeChangeEvent_002, TestSize.Level1)
1124 {
1125 AudioAdapterDescriptor adaDesc;
1126 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1127
1128 DAudioEvent event = {HDF_AUDIO_EVENT_VOLUME_CHANGE, "V"};
1129 std::string adpterName = "adbcef";
1130 AudioDeviceDescriptor desc;
1131 AudioSampleAttributes attrs;
1132 int32_t dhId = 1;
1133 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
1134
1135 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
1136 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
1137 EXPECT_EQ(ERR_DH_AUDIO_HDF_NULLPTR, AdapterTest_->HandleVolumeChangeEvent(event));
1138 }
1139
1140 /**
1141 * @tc.name: HandleVolumeChangeEvent_003
1142 * @tc.desc: Verify the HandleVolumeChangeEvent function.
1143 * @tc.type: FUNC
1144 * @tc.require: AR000H0E6H
1145 */
1146 HWTEST_F(AudioAdapterInterfaceImpTest, HandleVolumeChangeEvent_003, TestSize.Level1)
1147 {
1148 AudioAdapterDescriptor adaDesc;
1149 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1150
1151 DAudioEvent event = {HDF_AUDIO_EVENT_VOLUME_CHANGE, "V"};
1152 std::string adpterName = "adbcef";
1153 AudioDeviceDescriptor desc;
1154 AudioSampleAttributes attrs;
1155 int32_t dhId = 1;
1156 sptr<IDAudioCallback> callback = sptr<IDAudioCallback>(new MockIDAudioCallback());
1157
1158 AdapterTest_->renderDevs_[0] = std::make_pair(dhId,
1159 new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback, 0));
1160 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event));
1161 }
1162
1163 /**
1164 * @tc.name: HandleFocusChangeEvent_001
1165 * @tc.desc: Verify the HandleFocusChangeEvent function.
1166 * @tc.type: FUNC
1167 * @tc.require: AR000H0E6H
1168 */
1169 HWTEST_F(AudioAdapterInterfaceImpTest, HandleFocusChangeEvent_001, TestSize.Level1)
1170 {
1171 AudioAdapterDescriptor adaDesc;
1172 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1173
1174 DAudioEvent event = {HDF_AUDIO_EVENT_FOCUS_CHANGE,
1175 "INTERRUPT_EVENT;EVENT_TYPE=1;VOLUME_LEVEL=1;FORCE_TYPE=1;HINT_TYPE=1;"};
1176
1177 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleFocusChangeEvent(event));
1178 AdapterTest_->paramCallback_ = sptr<IAudioCallback>(new MockIAudioParamCallback());
1179 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleFocusChangeEvent(event));
1180 }
1181
1182 /**
1183 * @tc.name: HandleFocusChangeEvent_002
1184 * @tc.desc: Verify the HandleFocusChangeEvent function.
1185 * @tc.type: FUNC
1186 * @tc.require: AR000H0E6H
1187 */
1188 HWTEST_F(AudioAdapterInterfaceImpTest, HandleFocusChangeEvent_002, TestSize.Level1)
1189 {
1190 AudioAdapterDescriptor adaDesc;
1191 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1192
1193 DAudioEvent event = {HDF_AUDIO_EVENT_FOCUS_CHANGE,
1194 "INTERRUPT_EVENT;EVENT_TYPE=1;VOLUME_LEVEL=1;FORCE_TYPE=1;HINT_TYPE=1;"};
1195
1196 AdapterTest_->paramCallback_ = sptr<IAudioCallback>(new MockRevertIAudioParamCallback());
1197 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleFocusChangeEvent(event));
1198 }
1199
1200 /**
1201 * @tc.name: HandleRenderStateChangeEvent_001
1202 * @tc.desc: Verify the HandleRenderStateChangeEvent function.
1203 * @tc.type: FUNC
1204 * @tc.require: AR000H0E6H
1205 */
1206 HWTEST_F(AudioAdapterInterfaceImpTest, HandleRenderStateChangeEvent_001, TestSize.Level1)
1207 {
1208 AudioAdapterDescriptor adaDesc;
1209 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1210
1211 DAudioEvent event = {HDF_AUDIO_EVENT_RENDER_STATE_CHANGE,
1212 "RENDER_STATE_CHANGE_EVENT;STATE=0;"};
1213
1214 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleRenderStateChangeEvent(event));
1215 AdapterTest_->paramCallback_ = sptr<IAudioCallback>(new MockIAudioParamCallback());
1216 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleRenderStateChangeEvent(event));
1217 }
1218
1219 /**
1220 * @tc.name: HandleRenderStateChangeEvent_002
1221 * @tc.desc: Verify the HandleRenderStateChangeEvent function.
1222 * @tc.type: FUNC
1223 * @tc.require: AR000H0E6H
1224 */
1225 HWTEST_F(AudioAdapterInterfaceImpTest, HandleRenderStateChangeEvent_002, TestSize.Level1)
1226 {
1227 AudioAdapterDescriptor adaDesc;
1228 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1229
1230 DAudioEvent event = {HDF_AUDIO_EVENT_RENDER_STATE_CHANGE,
1231 "RENDER_STATE_CHANGE_EVENT;STATE=0;"};
1232
1233 AdapterTest_->paramCallback_ = sptr<IAudioCallback>(new MockRevertIAudioParamCallback());
1234 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleRenderStateChangeEvent(event));
1235 }
1236
1237 /**
1238 * @tc.name: HandleSANotifyEvent_001
1239 * @tc.desc: Verify the HandleSANotifyEvent function.
1240 * @tc.type: FUNC
1241 * @tc.require: AR000H0E6H
1242 */
1243 HWTEST_F(AudioAdapterInterfaceImpTest, HandleSANotifyEvent_001, TestSize.Level1)
1244 {
1245 AudioAdapterDescriptor adaDesc;
1246 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1247
1248 DAudioEvent event = {HDF_AUDIO_EVENT_OPEN_SPK_RESULT, "RENDER_STATE_CHANGE_EVENT"};
1249 uint32_t streamId = 0;
1250 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event));
1251 }
1252
1253 /**
1254 * @tc.name: HandleSANotifyEvent_002
1255 * @tc.desc: Verify the HandleSANotifyEvent function.
1256 * @tc.type: FUNC
1257 * @tc.require: AR000H0E6H
1258 */
1259 HWTEST_F(AudioAdapterInterfaceImpTest, HandleSANotifyEvent_002, TestSize.Level1)
1260 {
1261 AudioAdapterDescriptor adaDesc;
1262 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1263
1264 DAudioEvent event = {HDF_AUDIO_EVENT_OPEN_SPK_RESULT, HDF_EVENT_RESULT_SUCCESS};
1265 uint32_t streamId = 0;
1266 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event));
1267 }
1268
1269 /**
1270 * @tc.name: HandleSANotifyEvent_003
1271 * @tc.desc: Verify the HandleSANotifyEvent function.
1272 * @tc.type: FUNC
1273 * @tc.require: AR000H0E6H
1274 */
1275 HWTEST_F(AudioAdapterInterfaceImpTest, HandleSANotifyEvent_003, TestSize.Level1)
1276 {
1277 AudioAdapterDescriptor adaDesc;
1278 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1279
1280 DAudioEvent event = {HDF_AUDIO_EVENT_CLOSE_SPK_RESULT,
1281 HDF_EVENT_RESULT_SUCCESS};
1282 uint32_t streamId = 0;
1283 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event));
1284 DAudioEvent event1 = {HDF_AUDIO_EVENT_CLOSE_SPK_RESULT, "RENDER_STATE_CHANGE"};
1285 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event1));
1286 }
1287
1288 /**
1289 * @tc.name: HandleSANotifyEvent_004
1290 * @tc.desc: Verify the HandleSANotifyEvent function.
1291 * @tc.type: FUNC
1292 * @tc.require: AR000H0E6H
1293 */
1294 HWTEST_F(AudioAdapterInterfaceImpTest, HandleSANotifyEvent_004, TestSize.Level1)
1295 {
1296 AudioAdapterDescriptor adaDesc;
1297 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1298
1299 DAudioEvent event = {HDF_AUDIO_EVENT_OPEN_MIC_RESULT,
1300 HDF_EVENT_RESULT_SUCCESS};
1301 uint32_t streamId = 0;
1302 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event));
1303 DAudioEvent event1 = {HDF_AUDIO_EVENT_OPEN_MIC_RESULT, "RENDER_STATE_CHANGE"};
1304 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event1));
1305 }
1306
1307 /**
1308 * @tc.name: HandleSANotifyEvent_005
1309 * @tc.desc: Verify the HandleSANotifyEvent function.
1310 * @tc.type: FUNC
1311 * @tc.require: AR000H0E6H
1312 */
1313 HWTEST_F(AudioAdapterInterfaceImpTest, HandleSANotifyEvent_005, TestSize.Level1)
1314 {
1315 AudioAdapterDescriptor adaDesc;
1316 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1317
1318 DAudioEvent event = {HDF_AUDIO_EVENT_CLOSE_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS};
1319 uint32_t streamId = 0;
1320 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event));
1321 DAudioEvent event1 = {HDF_AUDIO_EVENT_CLOSE_MIC_RESULT, "RENDER_STATE_CHANGE"};
1322 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event1));
1323 }
1324
1325 /**
1326 * @tc.name: HandleSANotifyEvent_006
1327 * @tc.desc: Verify the HandleSANotifyEvent function.
1328 * @tc.type: FUNC
1329 * @tc.require: AR000H0E6H
1330 */
1331 HWTEST_F(AudioAdapterInterfaceImpTest, HandleSANotifyEvent_006, TestSize.Level1)
1332 {
1333 AudioAdapterDescriptor adaDesc;
1334 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1335
1336 using namespace DistributedHardware;
1337 DAudioEvent event = {-1, "ddd"};
1338 uint32_t streamId = 0;
1339 EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleSANotifyEvent(streamId, event));
1340 }
1341
1342 /**
1343 * @tc.name: WaitForSANotify_001
1344 * @tc.desc: Verify the WaitForSANotify function.
1345 * @tc.type: FUNC
1346 * @tc.require: AR000H0E6H
1347 */
1348 HWTEST_F(AudioAdapterInterfaceImpTest, WaitForSANotify_001, TestSize.Level1)
1349 {
1350 AudioAdapterDescriptor adaDesc;
1351 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1352
1353 int flag = 1;
1354 uint32_t streamId = 0;
__anonf10a75500102() 1355 std::thread th([&]() {
1356 while (flag) {
1357 std::this_thread::sleep_for(std::chrono::seconds(2));
1358 AdapterTest_->spkNotifyFlag_ = true;
1359 AdapterTest_->spkWaitCond_.notify_one();
1360 }});
1361 AudioDeviceEvent event = EVENT_OPEN_SPK;
1362 AdapterTest_->spkStatus_[streamId] = true;
1363 EXPECT_EQ(DH_SUCCESS, AdapterTest_->WaitForSANotify(streamId, event));
1364 AudioDeviceEvent event1 = EVENT_CLOSE_SPK ;
1365 AdapterTest_->spkStatus_[streamId] = false;
1366 EXPECT_EQ(DH_SUCCESS, AdapterTest_->WaitForSANotify(streamId, event1));
1367 flag = 0;
1368 if (th.joinable()) {
1369 th.join();
1370 }
1371 }
1372
1373 /**
1374 * @tc.name: WaitForSANotify_002
1375 * @tc.desc: Verify the WaitForSANotify function.
1376 * @tc.type: FUNC
1377 * @tc.require: AR000H0E6H
1378 */
1379 HWTEST_F(AudioAdapterInterfaceImpTest, WaitForSANotify_002, TestSize.Level1)
1380 {
1381 AudioAdapterDescriptor adaDesc;
1382 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1383
1384 int flag = 1;
__anonf10a75500202() 1385 std::thread th([&]() {
1386 while (flag) {
1387 std::this_thread::sleep_for(std::chrono::seconds(2));
1388 AdapterTest_->spkNotifyFlag_ = true;
1389 AdapterTest_->spkWaitCond_.notify_one();
1390 }});
1391 AudioDeviceEvent event = EVENT_OPEN_SPK;
1392 uint32_t streamId = 0;
1393 AdapterTest_->spkStatus_[streamId] = true;
1394 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->WaitForSANotify(streamId, event));
1395 flag = 0;
1396 if (th.joinable()) {
1397 th.join();
1398 }
1399 }
1400
1401 /**
1402 * @tc.name: WaitForSANotify_003
1403 * @tc.desc: Verify the WaitForSANotify function.
1404 * @tc.type: FUNC
1405 * @tc.require: AR000H0E6H
1406 */
1407 HWTEST_F(AudioAdapterInterfaceImpTest, WaitForSANotify_003, TestSize.Level1)
1408 {
1409 AudioAdapterDescriptor adaDesc;
1410 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1411
1412 int flag = 1;
1413 uint32_t captureId = 0;
__anonf10a75500302() 1414 std::thread th([&]() {
1415 while (flag) {
1416 std::this_thread::sleep_for(std::chrono::seconds(2));
1417 AdapterTest_->micNotifyFlag_ = true;
1418 AdapterTest_->micWaitCond_.notify_one();
1419 }});
1420 AudioDeviceEvent event = EVENT_OPEN_MIC;
1421 AdapterTest_->isMicOpened_ = true;
1422 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->WaitForSANotify(captureId, event));
1423
1424 AudioDeviceEvent event1 = EVENT_CLOSE_MIC;
1425 AdapterTest_->isMicOpened_ = false;
1426 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->WaitForSANotify(captureId, event1));
1427 flag = 0;
1428 if (th.joinable()) {
1429 th.join();
1430 }
1431 }
1432
1433 /**
1434 * @tc.name: WaitForSANotify_004
1435 * @tc.desc: Verify the WaitForSANotify function.
1436 * @tc.type: FUNC
1437 * @tc.require: AR000H0E6H
1438 */
1439 HWTEST_F(AudioAdapterInterfaceImpTest, WaitForSANotify_004, TestSize.Level1)
1440 {
1441 AudioAdapterDescriptor adaDesc;
1442 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1443
1444 int flag = 1;
1445 uint32_t captureId = 0;
__anonf10a75500402() 1446 std::thread th([&]() {
1447 while (flag) {
1448 std::this_thread::sleep_for(std::chrono::seconds(2));
1449 AdapterTest_->micNotifyFlag_ = true;
1450 AdapterTest_->micWaitCond_.notify_one();
1451 }});
1452 AudioDeviceEvent event = EVENT_OPEN_MIC;
1453 AdapterTest_->isMicOpened_ = true;;
1454 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->WaitForSANotify(captureId, event));
1455 flag = 0;
1456 if (th.joinable()) {
1457 th.join();
1458 }
1459 }
1460
1461 /**
1462 * @tc.name: WaitForSANotify_005
1463 * @tc.desc: Verify the WaitForSANotify function.
1464 * @tc.type: FUNC
1465 * @tc.require: AR000H0E6H
1466 */
1467 HWTEST_F(AudioAdapterInterfaceImpTest, WaitForSANotify_005, TestSize.Level1)
1468 {
1469 AudioAdapterDescriptor adaDesc;
1470 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1471
1472 AudioDeviceEvent event = EVENT_DEV_CLOSED;
1473 uint32_t captureId = 0;
1474 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->WaitForSANotify(captureId, event));
1475 }
1476
1477 /**
1478 * @tc.name: HandleDeviceClosed_001
1479 * @tc.desc: Verify the HandleDeviceClosed function.
1480 * @tc.type: FUNC
1481 * @tc.require: AR000H0E6H
1482 */
1483 HWTEST_F(AudioAdapterInterfaceImpTest, HandleDeviceClosed_001, TestSize.Level1)
1484 {
1485 AudioAdapterDescriptor adaDesc;
1486 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1487
1488 DAudioEvent event = {HDF_AUDIO_EVENT_SPK_CLOSED, "gtest"};
1489 uint32_t streamId = 0;
1490
1491 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleDeviceClosed(streamId, event));
1492 AdapterTest_->paramCallback_ = sptr<IAudioCallback>(new MockIAudioParamCallback());
1493 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleDeviceClosed(streamId, event));
1494 }
1495
1496 /**
1497 * @tc.name: HandleDeviceClosed_002
1498 * @tc.desc: Verify the HandleDeviceClosed function.
1499 * @tc.type: FUNC
1500 * @tc.require: AR000H0E6H
1501 */
1502 HWTEST_F(AudioAdapterInterfaceImpTest, HandleDeviceClosed_002, TestSize.Level1)
1503 {
1504 AudioAdapterDescriptor adaDesc;
1505 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1506
1507 DAudioEvent event = {HDF_AUDIO_EVENT_SPK_CLOSED, "gtest"};
1508 DAudioEvent event1 = {HDF_AUDIO_EVENT_MIC_CLOSED, "gmock"};
1509 uint32_t streamId = 0;
1510 AdapterTest_->paramCallback_ = nullptr;
1511 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleDeviceClosed(streamId, event));
1512
1513 AdapterTest_->spkStatus_[streamId] = true;
1514 AdapterTest_->isMicOpened_ = true;
1515 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleDeviceClosed(streamId, event));
1516 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleDeviceClosed(streamId, event1));
1517 }
1518
1519 /**
1520 * @tc.name: HandleDeviceClosed_001
1521 * @tc.desc: Verify the HandleDeviceClosed function.
1522 * @tc.type: FUNC
1523 * @tc.require: AR000H0E6H
1524 */
1525 HWTEST_F(AudioAdapterInterfaceImpTest, HandleDeviceClosed_003, TestSize.Level1)
1526 {
1527 AudioAdapterDescriptor adaDesc;
1528 AdapterTest_ = std::make_shared<AudioAdapterInterfaceImpl>(adaDesc);
1529
1530 DAudioEvent event = {HDF_AUDIO_EVENT_SPK_CLOSED, "gtest"};
1531 uint32_t streamId = 0;
1532
1533 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleDeviceClosed(streamId, event));
1534 AdapterTest_->paramCallback_ = sptr<IAudioCallback>(new MockRevertIAudioParamCallback());
1535 EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleDeviceClosed(streamId, event));
1536 }
1537 } // V1_0
1538 } // Audio
1539 } // Distributedaudio
1540 } // HDI
1541 } // OHOS