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 "dmic_dev_test.h"
17
18 #include "audio_decode_transport.h"
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace DistributedHardware {
24 constexpr int32_t DH_ID = 1;
25 constexpr int32_t DH_ID_MIC = 134217728;
26 const std::string DEV_ID = "Test_Dev_Id";
27 const std::string CAP = "Test_Capability";
28
SetUpTestCase(void)29 void DMicDevTest::SetUpTestCase(void) {}
30
TearDownTestCase(void)31 void DMicDevTest::TearDownTestCase(void) {}
32
SetUp(void)33 void DMicDevTest::SetUp(void)
34 {
35 eventCb_ = std::make_shared<MockIAudioEventCallback>();
36 mic_ = std::make_shared<DMicDev>(DEV_ID, eventCb_);
37 }
38
TearDown(void)39 void DMicDevTest::TearDown(void)
40 {
41 eventCb_ = nullptr;
42 mic_ = nullptr;
43 }
44
45 /**
46 * @tc.name: InitReceiverEngine_001
47 * @tc.desc: Verify InitReceiverEngine function.
48 * @tc.type: FUNC
49 * @tc.require: AR000H0E5F
50 */
51 HWTEST_F(DMicDevTest, InitReceiverEngine_001, TestSize.Level1)
52 {
53 IAVEngineProvider *providerPtr = nullptr;
54 AVTransEvent event = { EventType::EVENT_START_SUCCESS, "", "" };
55 mic_->OnEngineTransEvent(event);
56 std::shared_ptr<AVTransMessage> message = nullptr;
57 mic_->OnEngineTransMessage(message);
58 size_t size = 4096;
59 auto audioData = std::make_shared<AudioData>(size);
60 mic_->OnEngineTransDataAvailable(audioData);
61 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, mic_->InitReceiverEngine(providerPtr));
62 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
63 EXPECT_EQ(DH_SUCCESS, mic_->InitReceiverEngine(providerPtr));
64 }
65
66 /**
67 * @tc.name: EnableDMic_001
68 * @tc.desc: Verify EnableDMic and EnableDevice function.
69 * @tc.type: FUNC
70 * @tc.require: AR000H0E5F
71 */
72 HWTEST_F(DMicDevTest, EnableDMic_001, TestSize.Level1)
73 {
74 EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->EnableDMic(DH_ID, CAP));
75 EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, mic_->EnableDevice(DH_ID, CAP));
76
77 mic_->enabledPorts_.insert(DH_ID_MIC);
78 EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, mic_->EnableDMic(DH_ID_MIC, CAP));
79 }
80
81 /**
82 * @tc.name: DisableDMic_001
83 * @tc.desc: Verify DisableDMic and DisableDevice function.
84 * @tc.type: FUNC
85 * @tc.require: AR000H0E5F
86 */
87 HWTEST_F(DMicDevTest, DisableDMic_001, TestSize.Level1)
88 {
89 mic_->enabledPorts_.insert(DH_ID);
90 EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, mic_->DisableDevice(DH_ID));
91
92 EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->DisableDMic(DH_ID));
93
94 mic_->curPort_ = DH_ID_MIC;
95 EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->DisableDMic(DH_ID_MIC));
96 EXPECT_FALSE(mic_->IsOpened());
97 }
98
99 /**
100 * @tc.name: OpenDevice_001
101 * @tc.desc: Verify OpenDevice function.
102 * @tc.type: FUNC
103 * @tc.require: AR000H0E5F
104 */
105 HWTEST_F(DMicDevTest, OpenDevice_001, TestSize.Level1)
106 {
107 EXPECT_EQ(DH_SUCCESS, mic_->OpenDevice(DEV_ID, DH_ID));
108
109 eventCb_ = nullptr;
110 EXPECT_EQ(ERR_DH_AUDIO_SA_MICCALLBACK_NULL, mic_->OpenDevice(DEV_ID, DH_ID));
111 }
112
113 /**
114 * @tc.name: CloseDevice_001
115 * @tc.desc: Verify CloseDevice function.
116 * @tc.type: FUNC
117 * @tc.require: AR000H0E5F
118 */
119 HWTEST_F(DMicDevTest, CloseDevice_001, TestSize.Level1)
120 {
121 EXPECT_EQ(DH_SUCCESS, mic_->CloseDevice(DEV_ID, DH_ID));
122
123 eventCb_ = nullptr;
124 EXPECT_EQ(ERR_DH_AUDIO_SA_MICCALLBACK_NULL, mic_->CloseDevice(DEV_ID, DH_ID));
125 }
126
127 /**
128 * @tc.name: SetParameters_001
129 * @tc.desc: Verify SetParameters and GetAudioParam function.
130 * @tc.type: FUNC
131 * @tc.require: AR000H0E5F
132 */
133 HWTEST_F(DMicDevTest, SetParameters_001, TestSize.Level1)
134 {
135 const AudioParamHDF param = {
136 .sampleRate = SAMPLE_RATE_8000,
137 .channelMask = STEREO,
138 .bitFormat = SAMPLE_U8,
139 .streamUsage = STREAM_USAGE_UNKNOWN,
140 .frameSize = 30,
141 .period = 0,
142 .ext = "Test",
143 };
144 EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(DEV_ID, DH_ID, param));
145 mic_->GetAudioParam();
146 }
147
148 /**
149 * @tc.name: NotifyEvent_001
150 * @tc.desc: Verify NotifyEvent function.
151 * @tc.type: FUNC
152 * @tc.require: AR000H0E5F
153 */
154 HWTEST_F(DMicDevTest, NotifyEvent_001, TestSize.Level1)
155 {
156 AudioEvent event = AudioEvent(OPEN_MIC, "OPEN_MIC");
157 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(DEV_ID, DH_ID, event));
158
159 event.type = EVENT_UNKNOWN;
160 EXPECT_EQ(DH_SUCCESS, mic_->NotifyEvent(DEV_ID, DH_ID, event));
161
162 eventCb_ = nullptr;
163 EXPECT_EQ(ERR_DH_AUDIO_SA_EVENT_CALLBACK_NULL, mic_->NotifyEvent(DEV_ID, DH_ID, event));
164 }
165
166 /**
167 * @tc.name: SetUp_001
168 * @tc.desc: Verify SetUp function.
169 * @tc.type: FUNC
170 * @tc.require: AR000H0E5F
171 */
172 HWTEST_F(DMicDevTest, SetUp_001, TestSize.Level1)
173 {
174 mic_->micTrans_ = nullptr;
175 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
176
177 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
178 EXPECT_EQ(DH_SUCCESS, mic_->SetUp());
179 }
180
181 /**
182 * @tc.name: Start_001
183 * @tc.desc: Verify Start and IsOpened function.
184 * @tc.type: FUNC
185 * @tc.require: AR000H0E5F
186 */
187 HWTEST_F(DMicDevTest, Start_001, TestSize.Level1)
188 {
189 mic_->micTrans_ = nullptr;
190 EXPECT_EQ(ERR_DH_AUDIO_SA_MIC_TRANS_NULL, mic_->Start());
191
192 mic_->micTrans_ = std::make_shared<AudioDecodeTransport>(DEV_ID);
193 EXPECT_NE(DH_SUCCESS, mic_->Start());
194 EXPECT_FALSE(mic_->IsOpened());
195
196 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
197 mic_->isTransReady_.store(true);
198 EXPECT_EQ(DH_SUCCESS, mic_->Start());
199 EXPECT_TRUE(mic_->IsOpened());
200 }
201
202 /**
203 * @tc.name: Start_002
204 * @tc.desc: Verify Start and IsOpened function.
205 * @tc.type: FUNC
206 * @tc.require: AR000H0E5F
207 */
208 HWTEST_F(DMicDevTest, Start_002, TestSize.Level1)
209 {
210 mic_->micTrans_ = nullptr;
211 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
212 EXPECT_NE(DH_SUCCESS, mic_->Start());
213
214 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
215 EXPECT_EQ(DH_SUCCESS, mic_->SetUp());
216 EXPECT_EQ(ERR_DH_AUDIO_SA_MIC_CHANNEL_WAIT_TIMEOUT, mic_->Start());
217 EXPECT_FALSE(mic_->IsOpened());
218
219 mic_->isTransReady_.store(true);
220 EXPECT_EQ(DH_SUCCESS, mic_->Start());
221 EXPECT_TRUE(mic_->IsOpened());
222 }
223
224 /**
225 * @tc.name: Stop_001
226 * @tc.desc: Verify Stop and IsOpened function.
227 * @tc.type: FUNC
228 * @tc.require: AR000H0E5F
229 */
230 HWTEST_F(DMicDevTest, Stop_001, TestSize.Level1)
231 {
232 mic_->micTrans_ = nullptr;
233 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
234
235 mic_->micTrans_ = std::make_shared<AudioDecodeTransport>(DEV_ID);
236 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
237
238 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
239 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
240 EXPECT_FALSE(mic_->IsOpened());
241 }
242
243 /**
244 * @tc.name: Stop_002
245 * @tc.desc: Verify Stop and IsOpened function.
246 * @tc.type: FUNC
247 * @tc.require: AR000H0E5F
248 */
249 HWTEST_F(DMicDevTest, Stop_002, TestSize.Level1)
250 {
251 mic_->micTrans_ = nullptr;
252 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SetUp());
253 EXPECT_NE(DH_SUCCESS, mic_->Start());
254 EXPECT_EQ(DH_SUCCESS, mic_->Stop());
255 EXPECT_FALSE(mic_->IsOpened());
256 }
257
258 /**
259 * @tc.name: Release_001
260 * @tc.desc: Verify Release function.
261 * @tc.type: FUNC
262 * @tc.require: AR000H0E5F
263 */
264 HWTEST_F(DMicDevTest, Release_001, TestSize.Level1)
265 {
266 mic_->micTrans_ = nullptr;
267 EXPECT_EQ(DH_SUCCESS, mic_->Release());
268
269 mic_->micTrans_ = std::make_shared<AudioDecodeTransport>(DEV_ID);
270 EXPECT_EQ(DH_SUCCESS, mic_->Release());
271
272 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
273 EXPECT_EQ(DH_SUCCESS, mic_->Release());
274 }
275
276
277 /**
278 * @tc.name: ReadStreamData_001
279 * @tc.desc: Verify ReadStreamData and WriteStreamData function.
280 * @tc.type: FUNC
281 * @tc.require: AR000H0E5F
282 */
283 HWTEST_F(DMicDevTest, ReadStreamData_001, TestSize.Level1)
284 {
285 mic_->curStatus_ = AudioStatus::STATUS_START;
286 const size_t capacity = 1;
287 auto writeData = std::make_shared<AudioData>(capacity);
288 EXPECT_EQ(DH_SUCCESS, mic_->WriteStreamData(DEV_ID, DH_ID, writeData));
289
290 std::shared_ptr<AudioData> readData = nullptr;
291 mic_->dataQueue_.push(writeData);
292 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(DEV_ID, DH_ID, readData));
293
294 std::shared_ptr<AudioData> readData1 = nullptr;
295 EXPECT_EQ(DH_SUCCESS, mic_->ReadStreamData(DEV_ID, DH_ID, readData1));
296 }
297
298 /**
299 * @tc.name: NotifyHdfAudioEvent_001
300 * @tc.desc: Verify NotifyHdfAudioEvent function.
301 * @tc.type: FUNC
302 * @tc.require: AR000H0E5F
303 */
304 HWTEST_F(DMicDevTest, NotifyHdfAudioEvent_001, TestSize.Level1)
305 {
306 AudioEvent event = AudioEvent(OPEN_MIC, "OPEN_MIC");
307 EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event));
308
309 event.type = MIC_OPENED;
310 mic_->curPort_ = DH_ID_MIC;
311 EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event));
312 }
313
314 /**
315 * @tc.name: OnStateChange_001
316 * @tc.desc: Verify OnStateChange function.
317 * @tc.type: FUNC
318 * @tc.require: AR000H0E5F
319 */
320 HWTEST_F(DMicDevTest, OnStateChange_001, TestSize.Level1)
321 {
322 AudioEventType event = DATA_OPENED;
323 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
324
325 event = DATA_CLOSED;
326 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
327
328 event = EVENT_UNKNOWN;
329 EXPECT_EQ(DH_SUCCESS, mic_->OnStateChange(event));
330
331 eventCb_ = nullptr;
332 EXPECT_EQ(ERR_DH_AUDIO_SA_MICCALLBACK_NULL, mic_->OnStateChange(event));
333 }
334
335 /**
336 * @tc.name: OnDecodeTransDataDone_001
337 * @tc.desc: Verify OnDecodeTransDataDone function.
338 * @tc.type: FUNC
339 * @tc.require: AR000H0E5F
340 */
341 HWTEST_F(DMicDevTest, OnDecodeTransDataDone_001, TestSize.Level1)
342 {
343 std::shared_ptr<AudioData> data = nullptr;
344 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->OnDecodeTransDataDone(data));
345
346 const size_t capacity = 1;
347 data = std::make_shared<AudioData>(capacity);
348 for (size_t i = 1; i <= mic_->DATA_QUEUE_MAX_SIZE + 1; i++) {
349 EXPECT_EQ(DH_SUCCESS, mic_->OnDecodeTransDataDone(data));
350 }
351 }
352
353 /**
354 * @tc.name: SendMessage_001
355 * @tc.desc: Verify SendMessage function.
356 * @tc.type: FUNC
357 * @tc.require: AR000H0E5F
358 */
359 HWTEST_F(DMicDevTest, SendMessage_001, TestSize.Level1)
360 {
361 std::string content = "content";
362 std::string dstDevId = "dstDevId";
363 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SendMessage(MIC_OPENED, content, dstDevId));
364 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, mic_->SendMessage(OPEN_MIC, content, dstDevId));
365 mic_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
366 EXPECT_EQ(DH_SUCCESS, mic_->SendMessage(OPEN_MIC, content, dstDevId));
367 }
368 } // namespace DistributedHardware
369 } // namespace OHOS
370