1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "dmic_dev_test.h"
17
18 using namespace testing::ext;
19
20 namespace OHOS {
21 namespace DistributedHardware {
22 constexpr int32_t DH_ID = 1;
23 constexpr size_t NOTIFY_WAIT_FRAMES = 5;
24 constexpr int32_t DH_ID_MIC = 134217728;
25 const std::string DEV_ID = "Test_Dev_Id";
26 const std::string CAP = "Test_Capability";
27
SetUpTestCase(void)28 void DMicDevTest::SetUpTestCase(void) {}
29
TearDownTestCase(void)30 void DMicDevTest::TearDownTestCase(void) {}
31
SetUp(void)32 void DMicDevTest::SetUp(void)
33 {
34 eventCb_ = std::make_shared<MockIAudioEventCallback>();
35 mic_ = std::make_shared<DMicDev>(DEV_ID, eventCb_);
36 }
37
TearDown(void)38 void DMicDevTest::TearDown(void)
39 {
40 eventCb_ = nullptr;
41 mic_ = nullptr;
42 }
43
44 /**
45 * @tc.name: InitReceiverEngine_001
46 * @tc.desc: Verify InitReceiverEngine function.
47 * @tc.type: FUNC
48 * @tc.require: AR000H0E5F
49 */
50 HWTEST_F(DMicDevTest, InitReceiverEngine_001, TestSize.Level1)
51 {
52 IAVEngineProvider *providerPtr = nullptr;
53 AVTransEvent event = { EventType::EVENT_START_SUCCESS, "", "" };
54 mic_->OnEngineTransEvent(event);
55 event.type = EventType::EVENT_STOP_SUCCESS;
56 mic_->OnEngineTransEvent(event);
57 event.type = EventType::EVENT_START_FAIL;
58 mic_->OnEngineTransEvent(event);
59 event.type = EventType::EVENT_CHANNEL_CLOSED;
60 mic_->OnEngineTransEvent(event);
61 event.type = EventType::EVENT_START_SUCCESS;
62 mic_->OnEngineTransEvent(event);
63
64 std::shared_ptr<AVTransMessage> message = nullptr;
65 mic_->OnEngineTransMessage(message);
66 size_t size = 4096;
67 auto audioData = std::make_shared<AudioData>(size);
68 mic_->OnEngineTransDataAvailable(audioData);
69 mic_->SendToProcess(audioData);
70 mic_->echoCannelOn_ = true;
71 mic_->OnEngineTransDataAvailable(audioData);
72 mic_->SendToProcess(audioData);
73 mic_->echoCannelOn_ = false;
74 mic_->SendToProcess(audioData);
75 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->InitReceiverEngine(providerPtr));
76 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
77 EXPECT_EQ(DH_SUCCESS, mic_->InitReceiverEngine(providerPtr));
78 }
79
80 /**
81 * @tc.name: EnableDMic_001
82 * @tc.desc: Verify EnableDMic and EnableDevice function.
83 * @tc.type: FUNC
84 * @tc.require: AR000H0E5F
85 */
86 HWTEST_F(DMicDevTest, EnableDMic_001, TestSize.Level1)
87 {
88 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->EnableDevice(DH_ID, CAP));
89 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->EnableDevice(DH_ID, CAP));
90
91 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->EnableDevice(DH_ID_MIC, CAP));
92 }
93
94 /**
95 * @tc.name: DisableDMic_001
96 * @tc.desc: Verify DisableDMic and DisableDevice function.
97 * @tc.type: FUNC
98 * @tc.require: AR000H0E5F
99 */
100 HWTEST_F(DMicDevTest, DisableDMic_001, TestSize.Level1)
101 {
102 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->DisableDevice(DH_ID));
103
104 mic_->curPort_ = DH_ID_MIC;
105 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->DisableDevice(DH_ID_MIC));
106 EXPECT_FALSE(mic_->IsOpened());
107 }
108
109 /**
110 * @tc.name: CreateStream_001
111 * @tc.desc: Verify CreateStream function.
112 * @tc.type: FUNC
113 * @tc.require: AR000H0E5F
114 */
115 HWTEST_F(DMicDevTest, CreateStream_001, TestSize.Level1)
116 {
117 EXPECT_EQ(DH_SUCCESS, mic_->CreateStream(streamId_));
118
119 eventCb_ = nullptr;
120 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->CreateStream(streamId_));
121 }
122
123 /**
124 * @tc.name: DestroyStream_001
125 * @tc.desc: Verify DestroyStream function.
126 * @tc.type: FUNC
127 * @tc.require: AR000H0E5F
128 */
129 HWTEST_F(DMicDevTest, DestroyStream_001, TestSize.Level1)
130 {
131 EXPECT_EQ(DH_SUCCESS, mic_->DestroyStream(streamId_));
132
133 eventCb_ = nullptr;
134 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->DestroyStream(streamId_));
135 }
136
137 /**
138 * @tc.name: SetParameters_001
139 * @tc.desc: Verify SetParameters and GetAudioParam function.
140 * @tc.type: FUNC
141 * @tc.require: AR000H0E5F
142 */
143 HWTEST_F(DMicDevTest, SetParameters_001, TestSize.Level1)
144 {
145 AudioParamHDF param = {
146 .sampleRate = SAMPLE_RATE_8000,
147 .channelMask = STEREO,
148 .bitFormat = SAMPLE_U8,
149 .streamUsage = STREAM_USAGE_UNKNOWN,
150 .frameSize = 30,
151 .period = 0,
152 .ext = "Test",
153 };
154 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
155 mic_->GetAudioParam();
156 param.streamUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
157 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
158
159 param.capturerFlags = MMAP_MODE;
160 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, mic_->SetParameters(streamId_, param));
161 param.period = 5;
162 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
163 param.period = 20;
164 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
165 mic_->GetCodecCaps(AAC);
166 mic_->GetCodecCaps(OPUS);
167 param.streamUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
168 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
169 }
170
171 /**
172 * @tc.name: NotifyEvent_001
173 * @tc.desc: Verify NotifyEvent function.
174 * @tc.type: FUNC
175 * @tc.require: AR000H0E5F
176 */
177 HWTEST_F(DMicDevTest, NotifyEvent_001, TestSize.Level1)
178 {
179 AudioEvent event = AudioEvent(OPEN_MIC, "OPEN_MIC");
180 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
181
182 event.type = EVENT_UNKNOWN;
183 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
184
185 mic_->isTransReady_ = false;
186 event.type = AUDIO_START;
187 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
188
189 event.type = AUDIO_STOP;
190 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
191
192 mic_->isTransReady_ = true;
193 for (int32_t i = 0; i < NOTIFY_WAIT_FRAMES; i++) {
194 size_t size = 4096;
195 auto audioData = std::make_shared<AudioData>(size);
196 mic_->dataQueue_.push(audioData);
197 }
198 event.type = AUDIO_START;
199 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
200
201 eventCb_ = nullptr;
202 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->NotifyEvent(streamId_, event));
203 }
204
205 /**
206 * @tc.name: SetUp_001
207 * @tc.desc: Verify SetUp function.
208 * @tc.type: FUNC
209 * @tc.require: AR000H0E5F
210 */
211 HWTEST_F(DMicDevTest, SetUp_001, TestSize.Level1)
212 {
213 mic_->micTrans_ = nullptr;
214 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
215
216 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
217 EXPECT_EQ(DH_SUCCESS, mic_->SetUp());
218
219 mic_->micTrans_ = std::make_shared<MockIAudioDataTransportInner>();
220 EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->SetUp());
221 }
222
223 /**
224 * @tc.name: Start_001
225 * @tc.desc: Verify Start and IsOpened function.
226 * @tc.type: FUNC
227 * @tc.require: AR000H0E5F
228 */
229 HWTEST_F(DMicDevTest, Start_001, TestSize.Level1)
230 {
231 mic_->micTrans_ = nullptr;
232 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->Start());
233
234 mic_->micTrans_ = std::make_shared<AVTransReceiverTransport>(DEV_ID, mic_);
235 EXPECT_NE(DH_SUCCESS, mic_->Start());
236 EXPECT_FALSE(mic_->IsOpened());
237
238 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
239 EXPECT_EQ(DH_SUCCESS, mic_->SetUp());
240 mic_->isTransReady_.store(true);
241 EXPECT_EQ(DH_SUCCESS, mic_->Start());
242 mic_->isOpened_.store(true);
243 EXPECT_TRUE(mic_->IsOpened());
244 }
245
246 /**
247 * @tc.name: Start_002
248 * @tc.desc: Verify Start and IsOpened function.
249 * @tc.type: FUNC
250 * @tc.require: AR000H0E5F
251 */
252 HWTEST_F(DMicDevTest, Start_002, TestSize.Level1)
253 {
254 mic_->micTrans_ = nullptr;
255 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
256 EXPECT_NE(DH_SUCCESS, mic_->Start());
257
258 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
259 EXPECT_EQ(DH_SUCCESS, mic_->SetUp());
260 EXPECT_EQ(ERR_DH_AUDIO_SA_WAIT_TIMEOUT, mic_->Start());
261 EXPECT_FALSE(mic_->IsOpened());
262
263 mic_->isTransReady_.store(true);
264 EXPECT_EQ(DH_SUCCESS, mic_->Start());
265 mic_->isOpened_.store(true);
266 EXPECT_TRUE(mic_->IsOpened());
267 }
268
269 /**
270 * @tc.name: Stop_001
271 * @tc.desc: Verify Stop and IsOpened function.
272 * @tc.type: FUNC
273 * @tc.require: AR000H0E5F
274 */
275 HWTEST_F(DMicDevTest, Stop_001, TestSize.Level1)
276 {
277 mic_->micTrans_ = nullptr;
278 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
279
280 mic_->micTrans_ = std::make_shared<AVTransReceiverTransport>(DEV_ID, mic_);
281 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
282
283 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
284 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
285 EXPECT_FALSE(mic_->IsOpened());
286 }
287
288 /**
289 * @tc.name: Stop_002
290 * @tc.desc: Verify Stop and IsOpened function.
291 * @tc.type: FUNC
292 * @tc.require: AR000H0E5F
293 */
294 HWTEST_F(DMicDevTest, Stop_002, TestSize.Level1)
295 {
296 mic_->micTrans_ = nullptr;
297 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
298 EXPECT_NE(DH_SUCCESS, mic_->Start());
299 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
300 EXPECT_FALSE(mic_->IsOpened());
301 }
302
303 /**
304 * @tc.name: Release_001
305 * @tc.desc: Verify Release function.
306 * @tc.type: FUNC
307 * @tc.require: AR000H0E5F
308 */
309 HWTEST_F(DMicDevTest, Release_001, TestSize.Level1)
310 {
311 mic_->micTrans_ = nullptr;
312 EXPECT_EQ(DH_SUCCESS, mic_->Release());
313
314 mic_->micTrans_ = std::make_shared<AVTransReceiverTransport>(DEV_ID, mic_);
315 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->Release());
316
317 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
318 EXPECT_EQ(DH_SUCCESS, mic_->Release());
319
320 int32_t fd = 10;
321 int32_t ashmemLength = 10;
322 int32_t streamId = 1;
323 int32_t lengthPerTrans = 10;
324 EXPECT_EQ(DH_SUCCESS, mic_->RefreshAshmemInfo(streamId, fd, ashmemLength, lengthPerTrans));
325 }
326
327
328 /**
329 * @tc.name: ReadStreamData_001
330 * @tc.desc: Verify ReadStreamData and WriteStreamData function.
331 * @tc.type: FUNC
332 * @tc.require: AR000H0E5F
333 */
334 HWTEST_F(DMicDevTest, ReadStreamData_001, TestSize.Level1)
335 {
336 mic_->curStatus_ = AudioStatus::STATUS_START;
337 mic_->paramHDF_.period = 10;
338 const size_t capacity = 1;
339 auto writeData = std::make_shared<AudioData>(capacity);
340 EXPECT_EQ(DH_SUCCESS, mic_->WriteStreamData(streamId_, writeData));
341
342 std::shared_ptr<AudioData> readData = nullptr;
343 mic_->dataQueue_.push(writeData);
344 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(streamId_, readData));
345 for (size_t i = 0; i < 11; ++i) {
346 auto data = std::make_shared<AudioData>(DEFAULT_AUDIO_DATA_SIZE);
347 mic_->dataQueue_.push(data);
348 }
349 mic_->isEnqueueRunning_ = true;
350 mic_->FillJitterQueue();
351 mic_->paramHDF_.period = 0;
352 mic_->FillJitterQueue();
353 mic_->paramHDF_.period = 10;
354 mic_->FillJitterQueue();
355 std::shared_ptr<AudioData> readData1 = nullptr;
356 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(streamId_, readData1));
357
358 mic_->curStatus_ = AudioStatus::STATUS_STOP;
359 EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->ReadStreamData(streamId_, readData1));
360
361 mic_->curStatus_ = AudioStatus::STATUS_START;
362 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(streamId_, readData1));
363
364 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(streamId_, readData1));
365 }
366
367 /**
368 * @tc.name: NotifyHdfAudioEvent_001
369 * @tc.desc: Verify NotifyHdfAudioEvent function.
370 * @tc.type: FUNC
371 * @tc.require: AR000H0E5F
372 */
373 HWTEST_F(DMicDevTest, NotifyHdfAudioEvent_001, TestSize.Level1)
374 {
375 AudioEvent event = AudioEvent(OPEN_MIC, "OPEN_MIC");
376 int32_t dhId = 0;
377 EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event, dhId));
378
379 event.type = MIC_OPENED;
380 dhId = DH_ID_MIC;
381 EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event, dhId));
382 }
383
384 /**
385 * @tc.name: OnStateChange_001
386 * @tc.desc: Verify OnStateChange function.
387 * @tc.type: FUNC
388 * @tc.require: AR000H0E5F
389 */
390 HWTEST_F(DMicDevTest, OnStateChange_001, TestSize.Level1)
391 {
392 AudioEventType event = DATA_OPENED;
393 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
394
395 event = DATA_CLOSED;
396 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
397
398 event = EVENT_UNKNOWN;
399 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
400
401 eventCb_ = nullptr;
402 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->OnStateChange(event));
403 }
404
405 /**
406 * @tc.name: OnDecodeTransDataDone_001
407 * @tc.desc: Verify OnDecodeTransDataDone function.
408 * @tc.type: FUNC
409 * @tc.require: AR000H0E5F
410 */
411 HWTEST_F(DMicDevTest, OnDecodeTransDataDone_001, TestSize.Level1)
412 {
413 std::shared_ptr<AudioData> data = nullptr;
414 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->OnDecodeTransDataDone(data));
415
416 const size_t capacity = 1;
417 data = std::make_shared<AudioData>(capacity);
418 for (size_t i = 1; i <= mic_->DATA_QUEUE_MAX_SIZE + 1; i++) {
419 EXPECT_EQ(DH_SUCCESS, mic_->OnDecodeTransDataDone(data));
420 }
421 }
422
423 /**
424 * @tc.name: SendMessage_001
425 * @tc.desc: Verify SendMessage function.
426 * @tc.type: FUNC
427 * @tc.require: AR000H0E5F
428 */
429 HWTEST_F(DMicDevTest, SendMessage_001, TestSize.Level1)
430 {
431 std::string content = "content";
432 std::string dstDevId = "dstDevId";
433 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SendMessage(MIC_OPENED, content, dstDevId));
434 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SendMessage(OPEN_MIC, content, dstDevId));
435 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
436 mic_->InitCtrlTrans();
437 EXPECT_EQ(DH_SUCCESS, mic_->SendMessage(OPEN_MIC, content, dstDevId));
438 AVTransEvent event = { EventType::EVENT_START_SUCCESS, "", "" };
439 mic_->OnCtrlTransEvent(event);
440 event.type = EventType::EVENT_STOP_SUCCESS;
441 mic_->OnCtrlTransEvent(event);
442 event.type = EventType::EVENT_START_FAIL;
443 mic_->OnCtrlTransEvent(event);
444 event.type = EventType::EVENT_CHANNEL_CLOSED;
445 mic_->OnCtrlTransEvent(event);
446 event.type = EventType::EVENT_START_SUCCESS;
447 mic_->OnCtrlTransEvent(event);
448 mic_->micTrans_ = nullptr;
449 EXPECT_NE(DH_SUCCESS, mic_->InitCtrlTrans());
450 }
451
452 /**
453 * @tc.name: AddToVec001
454 * @tc.desc: Verify AddToVec function.
455 * @tc.type: FUNC
456 * @tc.require: AR000H0E5F
457 */
458 HWTEST_F(DMicDevTest, AddToVec001, TestSize.Level1)
459 {
460 std::vector<AudioCodecType> container;
461 mic_->AddToVec(container, AudioCodecType::AUDIO_CODEC_AAC);
462 EXPECT_EQ(1, container.size());
463 }
464
465 /**
466 * @tc.name: GetCodecCaps001
467 * @tc.desc: Verify GetCodecCaps function.
468 * @tc.type: FUNC
469 * @tc.require: AR000H0E5F
470 */
471 HWTEST_F(DMicDevTest, GetCodecCaps001, TestSize.Level1)
472 {
473 std::vector<AudioCodecType> container = mic_->codec_;
474 mic_->codec_.clear();
475 mic_->GetCodecCaps(AAC);
476 auto num = mic_->codec_.size();
477 EXPECT_EQ(1, num);
478 mic_->GetCodecCaps(OPUS);
479 num = mic_->codec_.size();
480 mic_->codec_ = container;
481 EXPECT_EQ(2, num);
482 }
483
484 /**
485 * @tc.name: IsMimeSupported001
486 * @tc.desc: Verify IsMimeSupported function.
487 * @tc.type: FUNC
488 * @tc.require: AR000H0E5F
489 */
490 HWTEST_F(DMicDevTest, IsMimeSupported001, TestSize.Level1)
491 {
492 std::vector<AudioCodecType> container = mic_->codec_;
493 mic_->codec_.clear();
494 mic_->GetCodecCaps(AAC);
495 bool ret = mic_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN);
496 EXPECT_EQ(ret, true);
497 ret = mic_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS);
498 mic_->codec_ = container;
499 EXPECT_EQ(ret, false);
500 }
501
502 /**
503 * @tc.name: ReadMmapPosition001
504 * @tc.desc: Verify ReadMmapPosition function.
505 * @tc.type: FUNC
506 * @tc.require: AR000H0E5F
507 */
508 HWTEST_F(DMicDevTest, ReadMmapPosition001, TestSize.Level1)
509 {
510 int32_t streamId = 0;
511 uint64_t frames = 0;
512 CurrentTimeHDF time;
513 EXPECT_EQ(DH_SUCCESS, mic_->ReadMmapPosition(streamId, frames, time));
514 }
515
516 /**
517 * @tc.name: MmapStart_001
518 * @tc.desc: Verify MmapStart function.
519 * @tc.type: FUNC
520 * @tc.require: AR000H0E5F
521 */
522 HWTEST_F(DMicDevTest, MmapStart_001, TestSize.Level1)
523 {
524 mic_->ashmem_ = nullptr;
525 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->MmapStart());
526 }
527
528 } // namespace DistributedHardware
529 } // namespace OHOS
530