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 "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 std::shared_ptr<AVTransMessage> message = nullptr;
56 mic_->OnEngineTransMessage(message);
57 size_t size = 4096;
58 auto audioData = std::make_shared<AudioData>(size);
59 mic_->OnEngineTransDataAvailable(audioData);
60 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->InitReceiverEngine(providerPtr));
61 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
62 EXPECT_EQ(DH_SUCCESS, mic_->InitReceiverEngine(providerPtr));
63
64 event = { EventType::EVENT_STOP_SUCCESS, "", "" };
65 mic_->OnEngineTransEvent(event);
66
67 mic_->echoCannelOn_ = true;
68 mic_->OnEngineTransDataAvailable(audioData);
69 }
70
71 /**
72 * @tc.name: EnableDMic_001
73 * @tc.desc: Verify EnableDMic and EnableDevice function.
74 * @tc.type: FUNC
75 * @tc.require: AR000H0E5F
76 */
77 HWTEST_F(DMicDevTest, EnableDMic_001, TestSize.Level1)
78 {
79 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->EnableDevice(DH_ID, CAP));
80 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->EnableDevice(DH_ID, CAP));
81
82 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->EnableDevice(DH_ID_MIC, CAP));
83 }
84
85 /**
86 * @tc.name: DisableDMic_001
87 * @tc.desc: Verify DisableDMic and DisableDevice function.
88 * @tc.type: FUNC
89 * @tc.require: AR000H0E5F
90 */
91 HWTEST_F(DMicDevTest, DisableDMic_001, TestSize.Level1)
92 {
93 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->DisableDevice(DH_ID));
94
95 mic_->curPort_ = DH_ID_MIC;
96 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->DisableDevice(DH_ID_MIC));
97 EXPECT_FALSE(mic_->IsOpened());
98 }
99
100 /**
101 * @tc.name: CreateStream_001
102 * @tc.desc: Verify CreateStream function.
103 * @tc.type: FUNC
104 * @tc.require: AR000H0E5F
105 */
106 HWTEST_F(DMicDevTest, CreateStream_001, TestSize.Level1)
107 {
108 EXPECT_EQ(DH_SUCCESS, mic_->CreateStream(streamId_));
109
110 eventCb_ = nullptr;
111 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->CreateStream(streamId_));
112 }
113
114 /**
115 * @tc.name: DestroyStream_001
116 * @tc.desc: Verify DestroyStream function.
117 * @tc.type: FUNC
118 * @tc.require: AR000H0E5F
119 */
120 HWTEST_F(DMicDevTest, DestroyStream_001, TestSize.Level1)
121 {
122 EXPECT_EQ(DH_SUCCESS, mic_->DestroyStream(streamId_));
123
124 eventCb_ = nullptr;
125 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->DestroyStream(streamId_));
126 }
127
128 /**
129 * @tc.name: SetParameters_001
130 * @tc.desc: Verify SetParameters and GetAudioParam function.
131 * @tc.type: FUNC
132 * @tc.require: AR000H0E5F
133 */
134 HWTEST_F(DMicDevTest, SetParameters_001, TestSize.Level1)
135 {
136 AudioParamHDF param = {
137 .sampleRate = SAMPLE_RATE_8000,
138 .channelMask = STEREO,
139 .bitFormat = SAMPLE_U8,
140 .streamUsage = STREAM_USAGE_UNKNOWN,
141 .frameSize = 30,
142 .period = 0,
143 .ext = "Test",
144 };
145 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
146 mic_->GetAudioParam();
147 param.streamUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
148 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
149
150 param.capturerFlags = MMAP_MODE;
151 EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, mic_->SetParameters(streamId_, param));
152 param.period = 5;
153 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
154 param.period = 20;
155 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
156 }
157
158 /**
159 * @tc.name: NotifyEvent_001
160 * @tc.desc: Verify NotifyEvent function.
161 * @tc.type: FUNC
162 * @tc.require: AR000H0E5F
163 */
164 HWTEST_F(DMicDevTest, NotifyEvent_001, TestSize.Level1)
165 {
166 AudioEvent event = AudioEvent(OPEN_MIC, "OPEN_MIC");
167 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
168
169 event.type = EVENT_UNKNOWN;
170 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
171
172 mic_->isTransReady_ = false;
173 event.type = AUDIO_START;
174 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
175
176 event.type = AUDIO_STOP;
177 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
178
179 mic_->isTransReady_ = true;
180 for (int32_t i = 0; i < NOTIFY_WAIT_FRAMES; i++) {
181 size_t size = 4096;
182 auto audioData = std::make_shared<AudioData>(size);
183 mic_->dataQueue_.push(audioData);
184 }
185 event.type = AUDIO_START;
186 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(streamId_, event));
187
188 eventCb_ = nullptr;
189 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->NotifyEvent(streamId_, event));
190 }
191
192 /**
193 * @tc.name: SetUp_001
194 * @tc.desc: Verify SetUp function.
195 * @tc.type: FUNC
196 * @tc.require: AR000H0E5F
197 */
198 HWTEST_F(DMicDevTest, SetUp_001, TestSize.Level1)
199 {
200 mic_->micTrans_ = nullptr;
201 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
202
203 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
204 EXPECT_EQ(DH_SUCCESS, mic_->SetUp());
205
206 mic_->micTrans_ = std::make_shared<MockIAudioDataTransportInner>();
207 EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->SetUp());
208 }
209
210 /**
211 * @tc.name: Start_001
212 * @tc.desc: Verify Start and IsOpened function.
213 * @tc.type: FUNC
214 * @tc.require: AR000H0E5F
215 */
216 HWTEST_F(DMicDevTest, Start_001, TestSize.Level1)
217 {
218 mic_->micTrans_ = nullptr;
219 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->Start());
220
221 mic_->micTrans_ = std::make_shared<AVTransReceiverTransport>(DEV_ID, mic_);
222 EXPECT_NE(DH_SUCCESS, mic_->Start());
223 EXPECT_FALSE(mic_->IsOpened());
224
225 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
226 EXPECT_EQ(DH_SUCCESS, mic_->SetUp());
227 mic_->isTransReady_.store(true);
228 EXPECT_EQ(DH_SUCCESS, mic_->Start());
229 mic_->isOpened_.store(true);
230 EXPECT_TRUE(mic_->IsOpened());
231 }
232
233 /**
234 * @tc.name: Start_002
235 * @tc.desc: Verify Start and IsOpened function.
236 * @tc.type: FUNC
237 * @tc.require: AR000H0E5F
238 */
239 HWTEST_F(DMicDevTest, Start_002, TestSize.Level1)
240 {
241 mic_->micTrans_ = nullptr;
242 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
243 EXPECT_NE(DH_SUCCESS, mic_->Start());
244
245 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
246 EXPECT_EQ(DH_SUCCESS, mic_->SetUp());
247 EXPECT_EQ(ERR_DH_AUDIO_SA_WAIT_TIMEOUT, mic_->Start());
248 EXPECT_FALSE(mic_->IsOpened());
249
250 mic_->isTransReady_.store(true);
251 EXPECT_EQ(DH_SUCCESS, mic_->Start());
252 mic_->isOpened_.store(true);
253 EXPECT_TRUE(mic_->IsOpened());
254 }
255
256 /**
257 * @tc.name: Stop_001
258 * @tc.desc: Verify Stop and IsOpened function.
259 * @tc.type: FUNC
260 * @tc.require: AR000H0E5F
261 */
262 HWTEST_F(DMicDevTest, Stop_001, TestSize.Level1)
263 {
264 mic_->micTrans_ = nullptr;
265 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
266
267 mic_->micTrans_ = std::make_shared<AVTransReceiverTransport>(DEV_ID, mic_);
268 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
269
270 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
271 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
272 EXPECT_FALSE(mic_->IsOpened());
273 }
274
275 /**
276 * @tc.name: Stop_002
277 * @tc.desc: Verify Stop and IsOpened function.
278 * @tc.type: FUNC
279 * @tc.require: AR000H0E5F
280 */
281 HWTEST_F(DMicDevTest, Stop_002, TestSize.Level1)
282 {
283 mic_->micTrans_ = nullptr;
284 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
285 EXPECT_NE(DH_SUCCESS, mic_->Start());
286 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
287 EXPECT_FALSE(mic_->IsOpened());
288 }
289
290 /**
291 * @tc.name: Release_001
292 * @tc.desc: Verify Release function.
293 * @tc.type: FUNC
294 * @tc.require: AR000H0E5F
295 */
296 HWTEST_F(DMicDevTest, Release_001, TestSize.Level1)
297 {
298 mic_->micTrans_ = nullptr;
299 EXPECT_EQ(DH_SUCCESS, mic_->Release());
300
301 mic_->micTrans_ = std::make_shared<AVTransReceiverTransport>(DEV_ID, mic_);
302 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->Release());
303
304 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
305 EXPECT_EQ(DH_SUCCESS, mic_->Release());
306 }
307
308
309 /**
310 * @tc.name: ReadStreamData_001
311 * @tc.desc: Verify ReadStreamData and WriteStreamData function.
312 * @tc.type: FUNC
313 * @tc.require: AR000H0E5F
314 */
315 HWTEST_F(DMicDevTest, ReadStreamData_001, TestSize.Level1)
316 {
317 mic_->curStatus_ = AudioStatus::STATUS_START;
318 mic_->paramHDF_.period = 10;
319 const size_t capacity = 1;
320 auto writeData = std::make_shared<AudioData>(capacity);
321 EXPECT_EQ(DH_SUCCESS, mic_->WriteStreamData(streamId_, writeData));
322
323 std::shared_ptr<AudioData> readData = nullptr;
324 mic_->dataQueue_.push(writeData);
325 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(streamId_, readData));
326 for (size_t i = 0; i < 11; ++i) {
327 auto data = std::make_shared<AudioData>(DEFAULT_AUDIO_DATA_SIZE);
328 mic_->dataQueue_.push(data);
329 }
330 mic_->isEnqueueRunning_ = true;
331 mic_->FillJitterQueue();
332
333 std::shared_ptr<AudioData> readData1 = nullptr;
334 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(streamId_, readData1));
335
336 mic_->curStatus_ = AudioStatus::STATUS_STOP;
337 EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->ReadStreamData(streamId_, readData1));
338
339 mic_->curStatus_ = AudioStatus::STATUS_START;
340 mic_->insertFrameCnt_ = 1;
341 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(streamId_, readData1));
342
343 mic_->insertFrameCnt_ = 11;
344 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(streamId_, readData1));
345 }
346
347 /**
348 * @tc.name: NotifyHdfAudioEvent_001
349 * @tc.desc: Verify NotifyHdfAudioEvent function.
350 * @tc.type: FUNC
351 * @tc.require: AR000H0E5F
352 */
353 HWTEST_F(DMicDevTest, NotifyHdfAudioEvent_001, TestSize.Level1)
354 {
355 AudioEvent event = AudioEvent(OPEN_MIC, "OPEN_MIC");
356 int32_t dhId = 0;
357 EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event, dhId));
358
359 event.type = MIC_OPENED;
360 dhId = DH_ID_MIC;
361 EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event, dhId));
362 }
363
364 /**
365 * @tc.name: OnStateChange_001
366 * @tc.desc: Verify OnStateChange function.
367 * @tc.type: FUNC
368 * @tc.require: AR000H0E5F
369 */
370 HWTEST_F(DMicDevTest, OnStateChange_001, TestSize.Level1)
371 {
372 AudioEventType event = DATA_OPENED;
373 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
374
375 event = DATA_CLOSED;
376 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
377
378 event = EVENT_UNKNOWN;
379 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
380
381 eventCb_ = nullptr;
382 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->OnStateChange(event));
383 }
384
385 /**
386 * @tc.name: OnDecodeTransDataDone_001
387 * @tc.desc: Verify OnDecodeTransDataDone function.
388 * @tc.type: FUNC
389 * @tc.require: AR000H0E5F
390 */
391 HWTEST_F(DMicDevTest, OnDecodeTransDataDone_001, TestSize.Level1)
392 {
393 std::shared_ptr<AudioData> data = nullptr;
394 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->OnDecodeTransDataDone(data));
395
396 const size_t capacity = 1;
397 data = std::make_shared<AudioData>(capacity);
398 for (size_t i = 1; i <= mic_->DATA_QUEUE_MAX_SIZE + 1; i++) {
399 EXPECT_EQ(DH_SUCCESS, mic_->OnDecodeTransDataDone(data));
400 }
401 }
402
403 /**
404 * @tc.name: SendMessage_001
405 * @tc.desc: Verify SendMessage function.
406 * @tc.type: FUNC
407 * @tc.require: AR000H0E5F
408 */
409 HWTEST_F(DMicDevTest, SendMessage_001, TestSize.Level1)
410 {
411 std::string content = "content";
412 std::string dstDevId = "dstDevId";
413 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SendMessage(MIC_OPENED, content, dstDevId));
414 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SendMessage(OPEN_MIC, content, dstDevId));
415 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
416 EXPECT_EQ(DH_SUCCESS, mic_->SendMessage(OPEN_MIC, content, dstDevId));
417 }
418 } // namespace DistributedHardware
419 } // namespace OHOS
420