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