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 "dspeaker_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 int32_t DH_ID_SPK = 134217728;
24 const std::string DEV_ID = "Test_Dev_Id";
25 const std::string CAP = "Test_Capability";
26
SetUpTestCase(void)27 void DSpeakerDevTest::SetUpTestCase(void) {}
28
TearDownTestCase(void)29 void DSpeakerDevTest::TearDownTestCase(void) {}
30
SetUp(void)31 void DSpeakerDevTest::SetUp(void)
32 {
33 eventCb_ = std::make_shared<MockIAudioEventCallback>();
34 spk_ = std::make_shared<DSpeakerDev>(DEV_ID, eventCb_);
35 }
36
TearDown(void)37 void DSpeakerDevTest::TearDown(void)
38 {
39 eventCb_ = nullptr;
40 spk_ = nullptr;
41 }
42
43 /**
44 * @tc.name: InitSenderEngine_001
45 * @tc.desc: Verify InitSenderEngine function.
46 * @tc.type: FUNC
47 * @tc.require: AR000H0E5F
48 */
49 HWTEST_F(DSpeakerDevTest, InitSenderEngine_001, TestSize.Level1)
50 {
51 IAVEngineProvider *providerPtr = nullptr;
52 AVTransEvent event = { EventType::EVENT_START_SUCCESS, "", "" };
53 spk_->OnEngineTransEvent(event);
54 event.type = EventType::EVENT_STOP_SUCCESS;
55 spk_->OnEngineTransEvent(event);
56 event.type = EventType::EVENT_CHANNEL_CLOSED;
57 spk_->OnEngineTransEvent(event);
58 event.type = EventType::EVENT_START_FAIL;
59 spk_->OnEngineTransEvent(event);
60 std::shared_ptr<AVTransMessage> message = nullptr;
61 spk_->OnEngineTransMessage(message);
62 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->InitSenderEngine(providerPtr));
63 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
64 EXPECT_EQ(DH_SUCCESS, spk_->InitSenderEngine(providerPtr));
65 }
66
67 /**
68 * @tc.name: InitReceiverEngine_001
69 * @tc.desc: Verify InitReceiverEngine function.
70 * @tc.type: FUNC
71 * @tc.require: AR000H0E5F
72 */
73 HWTEST_F(DSpeakerDevTest, InitReceiverEngine_001, TestSize.Level1)
74 {
75 IAVEngineProvider *providerPtr = nullptr;
76 EXPECT_EQ(DH_SUCCESS, spk_->InitReceiverEngine(providerPtr));;
77 }
78
79 /**
80 * @tc.name: EnableDSpeaker_001
81 * @tc.desc: Verify EnableDSpeaker and EnableDevice function.
82 * @tc.type: FUNC
83 * @tc.require: AR000H0E5F
84 */
85 HWTEST_F(DSpeakerDevTest, EnableDSpeaker_001, TestSize.Level1)
86 {
87 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->EnableDevice(DH_ID, CAP));
88 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->EnableDevice(DH_ID, CAP));
89
90 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->EnableDevice(DH_ID_SPK, CAP));
91 }
92
93 /**
94 * @tc.name: DisableDSpeaker_001
95 * @tc.desc: Verify DisableDSpeaker and DisableDevice function.
96 * @tc.type: FUNC
97 * @tc.require: AR000H0E5F
98 */
99 HWTEST_F(DSpeakerDevTest, DisableDSpeaker_001, TestSize.Level1)
100 {
101 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->DisableDevice(DH_ID));
102
103 spk_->curPort_ = DH_ID_SPK;
104 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->DisableDevice(DH_ID_SPK));
105 EXPECT_FALSE(spk_->IsOpened());
106 }
107
108 /**
109 * @tc.name: CreateStream_001
110 * @tc.desc: Verify CreateStream function.
111 * @tc.type: FUNC
112 * @tc.require: AR000H0E5F
113 */
114 HWTEST_F(DSpeakerDevTest, CreateStream_001, TestSize.Level1)
115 {
116 EXPECT_EQ(DH_SUCCESS, spk_->CreateStream(streamId_));
117
118 eventCb_ = nullptr;
119 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->CreateStream(streamId_));
120 }
121
122 /**
123 * @tc.name: DestroyStream_001
124 * @tc.desc: Verify DestroyStream function.
125 * @tc.type: FUNC
126 * @tc.require: AR000H0E5F
127 */
128 HWTEST_F(DSpeakerDevTest, DestroyStream_001, TestSize.Level1)
129 {
130 EXPECT_EQ(DH_SUCCESS, spk_->DestroyStream(streamId_));
131
132 eventCb_ = nullptr;
133 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->DestroyStream(streamId_));
134 }
135
136 /**
137 * @tc.name: SetParameters_001
138 * @tc.desc: Verify SetParameters and GetAudioParam function.
139 * @tc.type: FUNC
140 * @tc.require: AR000H0E5F
141 */
142 HWTEST_F(DSpeakerDevTest, SetParameters_001, TestSize.Level1)
143 {
144 const AudioParamHDF param = {
145 .sampleRate = SAMPLE_RATE_8000,
146 .channelMask = STEREO,
147 .bitFormat = SAMPLE_U8,
148 .streamUsage = STREAM_USAGE_UNKNOWN,
149 .frameSize = 30,
150 .period = 0,
151 .ext = "Test",
152 };
153 EXPECT_EQ(DH_SUCCESS, spk_->SetParameters(streamId_, param));
154 spk_->GetAudioParam();
155 }
156
157 /**
158 * @tc.name: NotifyEvent_001
159 * @tc.desc: Verify NotifyEvent function.
160 * @tc.type: FUNC
161 * @tc.require: AR000H0E5F
162 */
163 HWTEST_F(DSpeakerDevTest, NotifyEvent_001, TestSize.Level1)
164 {
165 AudioEvent event = AudioEvent(OPEN_SPEAKER, "OPEN_SPEAKER");
166 EXPECT_EQ(DH_SUCCESS, spk_->NotifyEvent(streamId_, event));
167
168 event.type = EVENT_UNKNOWN;
169 EXPECT_EQ(DH_SUCCESS, spk_->NotifyEvent(streamId_, event));
170
171 eventCb_ = nullptr;
172 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->NotifyEvent(streamId_, event));
173 }
174
175 /**
176 * @tc.name: SetUp_001
177 * @tc.desc: Verify SetUp function.
178 * @tc.type: FUNC
179 * @tc.require: AR000H0E5F
180 */
181 HWTEST_F(DSpeakerDevTest, SetUp_001, TestSize.Level1)
182 {
183 spk_->speakerTrans_ = nullptr;
184 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->SetUp());
185
186 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
187 EXPECT_EQ(DH_SUCCESS, spk_->SetUp());
188 }
189
190 /**
191 * @tc.name: Start_001
192 * @tc.desc: Verify Start and IsOpened function.
193 * @tc.type: FUNC
194 * @tc.require: AR000H0E5F
195 */
196 HWTEST_F(DSpeakerDevTest, Start_001, TestSize.Level1)
197 {
198 spk_->speakerTrans_ = nullptr;
199 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->Start());
200
201 spk_->speakerTrans_ = std::make_shared<AVTransSenderTransport>(DEV_ID, spk_);
202 EXPECT_NE(DH_SUCCESS, spk_->Start());
203 EXPECT_FALSE(spk_->IsOpened());
204 }
205
206 /**
207 * @tc.name: Start_002
208 * @tc.desc: Verify Start and IsOpened function.
209 * @tc.type: FUNC
210 * @tc.require: AR000H0E5F
211 */
212 HWTEST_F(DSpeakerDevTest, Start_002, TestSize.Level1)
213 {
214 spk_->speakerTrans_ = nullptr;
215 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->SetUp());
216 EXPECT_NE(DH_SUCCESS, spk_->Start());
217 EXPECT_FALSE(spk_->IsOpened());
218 }
219
220 /**
221 * @tc.name: Start_003
222 * @tc.desc: Verify Start and IsOpened function.
223 * @tc.type: FUNC
224 * @tc.require: AR000H0E5F
225 */
226 HWTEST_F(DSpeakerDevTest, Start_003, TestSize.Level1)
227 {
228 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
229 EXPECT_EQ(DH_SUCCESS, spk_->SetUp());
230 EXPECT_EQ(ERR_DH_AUDIO_SA_WAIT_TIMEOUT, spk_->Start());
231
232 spk_->isTransReady_.store(true);
233 EXPECT_EQ(DH_SUCCESS, spk_->Start());
234 EXPECT_TRUE(spk_->IsOpened());
235 }
236
237 /**
238 * @tc.name: Stop_001
239 * @tc.desc: Verify Stop and IsOpened function.
240 * @tc.type: FUNC
241 * @tc.require: AR000H0E5F
242 */
243 HWTEST_F(DSpeakerDevTest, Stop_001, TestSize.Level1)
244 {
245 spk_->speakerTrans_ = nullptr;
246 EXPECT_EQ(DH_SUCCESS, spk_->Stop());
247 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->SetUp());
248 EXPECT_EQ(DH_SUCCESS, spk_->Stop());
249
250 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
251 EXPECT_EQ(DH_SUCCESS, spk_->Stop());
252 EXPECT_FALSE(spk_->IsOpened());
253 }
254
255 /**
256 * @tc.name: Stop_002
257 * @tc.desc: Verify Stop and IsOpened function.
258 * @tc.type: FUNC
259 * @tc.require: AR000H0E5F
260 */
261 HWTEST_F(DSpeakerDevTest, Stop_002, TestSize.Level1)
262 {
263 spk_->speakerTrans_ = nullptr;
264 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->SetUp());
265 EXPECT_NE(DH_SUCCESS, spk_->Start());
266 EXPECT_EQ(DH_SUCCESS, spk_->Stop());
267 EXPECT_FALSE(spk_->IsOpened());
268 }
269
270 /**
271 * @tc.name: Pause_001
272 * @tc.desc: Verify Pause function.
273 * @tc.type: FUNC
274 * @tc.require: AR000H0E5F
275 */
276 HWTEST_F(DSpeakerDevTest, Pause_001, TestSize.Level1)
277 {
278 spk_->speakerTrans_ = nullptr;
279 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->Pause());
280
281 spk_->speakerTrans_ = std::make_shared<AVTransSenderTransport>(DEV_ID, spk_);
282 EXPECT_NE(DH_SUCCESS, spk_->Pause());
283
284 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
285 EXPECT_EQ(DH_SUCCESS, spk_->Pause());
286 }
287
288 /**
289 * @tc.name: Restart_001
290 * @tc.desc: Verify Restart function.
291 * @tc.type: FUNC
292 * @tc.require: AR000H0E5F
293 */
294 HWTEST_F(DSpeakerDevTest, Restart_001, TestSize.Level1)
295 {
296 spk_->speakerTrans_ = nullptr;
297 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->Restart());
298
299 const AudioParamHDF param = {
300 .sampleRate = SAMPLE_RATE_8000,
301 .channelMask = STEREO,
302 .bitFormat = SAMPLE_U8,
303 .streamUsage = STREAM_USAGE_UNKNOWN,
304 .frameSize = 30,
305 .period = 0,
306 .ext = "Test",
307 };
308 EXPECT_EQ(DH_SUCCESS, spk_->SetParameters(streamId_, param));
309 spk_->speakerTrans_ = std::make_shared<AVTransSenderTransport>(DEV_ID, spk_);
310 EXPECT_NE(DH_SUCCESS, spk_->Restart());
311
312 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
313 EXPECT_EQ(DH_SUCCESS, spk_->Restart());
314 }
315
316 /**
317 * @tc.name: Release_001
318 * @tc.desc: Verify Release function.
319 * @tc.type: FUNC
320 * @tc.require: AR000H0E5F
321 */
322 HWTEST_F(DSpeakerDevTest, Release_001, TestSize.Level1)
323 {
324 spk_->speakerTrans_ = nullptr;
325 EXPECT_EQ(DH_SUCCESS, spk_->Release());
326
327 spk_->speakerTrans_ = std::make_shared<AVTransSenderTransport>(DEV_ID, spk_);
328 EXPECT_EQ(DH_SUCCESS, spk_->Release());
329
330 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
331 EXPECT_EQ(DH_SUCCESS, spk_->Release());
332
333 int32_t fd = 1;
334 int32_t ashmemLength = 10;
335 int32_t streamId = 1;
336 int32_t lengthPerTrans = 10;
337 EXPECT_EQ(DH_SUCCESS, spk_->RefreshAshmemInfo(streamId, fd, ashmemLength, lengthPerTrans));
338 spk_->param_.renderOpts.renderFlags = MMAP_MODE;
339 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->RefreshAshmemInfo(streamId, fd, ashmemLength, lengthPerTrans));
340 }
341
342 /**
343 * @tc.name: WriteStreamData_001
344 * @tc.desc: Verify WriteStreamData and ReadStreamData function.
345 * @tc.type: FUNC
346 * @tc.require: AR000H0E5F
347 */
348 HWTEST_F(DSpeakerDevTest, WriteStreamData_001, TestSize.Level1)
349 {
350 const size_t capacity = 1;
351 auto writeData = std::make_shared<AudioData>(capacity);
352 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->WriteStreamData(streamId_, writeData));
353
354 std::shared_ptr<AudioData> readData = nullptr;
355 EXPECT_EQ(DH_SUCCESS, spk_->ReadStreamData(streamId_, readData));
356
357 std::shared_ptr<AudioData> data = nullptr;
358 EXPECT_EQ(DH_SUCCESS, spk_->OnDecodeTransDataDone(data));
359 }
360
361 /**
362 * @tc.name: WriteStreamData_002
363 * @tc.desc: Verify WriteStreamData function.
364 * @tc.type: FUNC
365 * @tc.require: AR000H0E5F
366 */
367 HWTEST_F(DSpeakerDevTest, WriteStreamData_002, TestSize.Level1)
368 {
369 const size_t capacity = 1;
370 auto writeData = std::make_shared<AudioData>(capacity);
371 spk_->speakerTrans_ = std::make_shared<AVTransSenderTransport>(DEV_ID, spk_);
372 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->WriteStreamData(streamId_, writeData));
373
374 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
375 EXPECT_EQ(DH_SUCCESS, spk_->WriteStreamData(streamId_, writeData));
376 }
377
378 /**
379 * @tc.name: NotifyHdfAudioEvent_001
380 * @tc.desc: Verify NotifyHdfAudioEvent function.
381 * @tc.type: FUNC
382 * @tc.require: AR000H0E5F
383 */
384 HWTEST_F(DSpeakerDevTest, ReadMmapPosition_001, TestSize.Level1)
385 {
386 int32_t streamId = 0;
387 uint64_t frames = 0;
388 CurrentTimeHDF time;
389 EXPECT_EQ(DH_SUCCESS, spk_->ReadMmapPosition(streamId, frames, time));
390 }
391
392 /**
393 * @tc.name: MmapStart_001
394 * @tc.desc: Verify MmapStart function.
395 * @tc.type: FUNC
396 * @tc.require: AR000H0E5F
397 */
398 HWTEST_F(DSpeakerDevTest, MmapStart_001, TestSize.Level1)
399 {
400 spk_->ashmem_ = nullptr;
401 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->MmapStart());
402 }
403
404 /**
405 * @tc.name: NotifyHdfAudioEvent_001
406 * @tc.desc: Verify NotifyHdfAudioEvent function.
407 * @tc.type: FUNC
408 * @tc.require: AR000H0E5F
409 */
410 HWTEST_F(DSpeakerDevTest, NotifyHdfAudioEvent_001, TestSize.Level1)
411 {
412 AudioEvent event = AudioEvent(OPEN_SPEAKER, "OPEN_SPEAKER");
413 int32_t dhId = 0;
414 EXPECT_EQ(DH_SUCCESS, spk_->NotifyHdfAudioEvent(event, dhId));
415
416 event.type = SPEAKER_OPENED;
417 dhId = DH_ID_SPK;
418 EXPECT_EQ(DH_SUCCESS, spk_->NotifyHdfAudioEvent(event, dhId));
419 }
420
421 /**
422 * @tc.name: OnStateChange_001
423 * @tc.desc: Verify OnStateChange function.
424 * @tc.type: FUNC
425 * @tc.require: AR000H0E5F
426 */
427 HWTEST_F(DSpeakerDevTest, OnStateChange_001, TestSize.Level1)
428 {
429 AudioEventType event = DATA_OPENED;
430 EXPECT_EQ(DH_SUCCESS, spk_->OnStateChange(event));
431
432 event = DATA_CLOSED;
433 EXPECT_EQ(DH_SUCCESS, spk_->OnStateChange(event));
434
435 event = EVENT_UNKNOWN;
436 EXPECT_EQ(DH_SUCCESS, spk_->OnStateChange(event));
437
438 eventCb_ = nullptr;
439 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->OnStateChange(event));
440 }
441
442 /**
443 * @tc.name: SendMessage_001
444 * @tc.desc: Verify SendMessage function.
445 * @tc.type: FUNC
446 * @tc.require: AR000H0E5F
447 */
448 HWTEST_F(DSpeakerDevTest, SendMessage_001, TestSize.Level1)
449 {
450 std::string content = "content";
451 std::string dstDevId = "dstDevId";
452 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->SendMessage(MIC_OPENED, content, dstDevId));
453 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, spk_->SendMessage(OPEN_SPEAKER, content, dstDevId));
454 spk_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
455 EXPECT_EQ(DH_SUCCESS, spk_->SendMessage(OPEN_SPEAKER, content, dstDevId));
456 }
457 } // namespace DistributedHardware
458 } // namespace OHOS
459