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