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 "daudio_manager_callback_test.h"
17 #include "securec.h"
18 
19 using namespace testing::ext;
20 
21 namespace OHOS {
22 namespace DistributedHardware {
SetUpTestCase(void)23 void DAudioManagerCallbackTest::SetUpTestCase(void) {}
24 
TearDownTestCase(void)25 void DAudioManagerCallbackTest::TearDownTestCase(void) {}
26 
SetUp()27 void DAudioManagerCallbackTest::SetUp()
28 {
29     adpName_ = "hello";
30     hdiCallback_ = std::make_shared<MockIDAudioHdiCallback>();
31     manCallback_ = std::make_shared<DAudioManagerCallback>(hdiCallback_);
32 }
33 
TearDown()34 void DAudioManagerCallbackTest::TearDown() {}
35 
36 /**
37  * @tc.name: CreateStream_001
38  * @tc.desc: Verify the CreateStream function.
39  * @tc.type: FUNC
40  * @tc.require: AR000H0E6H
41  */
42 HWTEST_F(DAudioManagerCallbackTest, CreateStream_001, TestSize.Level1)
43 {
44     if (manCallback_ == nullptr) {
45         return;
46     }
47     manCallback_->callback_ = nullptr;
48     EXPECT_EQ(HDF_FAILURE, manCallback_->CreateStream(streamId_));
49 }
50 
51 /**
52  * @tc.name: CreateStream_002
53  * @tc.desc: Verify the CreateStream function.
54  * @tc.type: FUNC
55  * @tc.require: AR000H0E6H
56  */
57 HWTEST_F(DAudioManagerCallbackTest, CreateStream_002, TestSize.Level1)
58 {
59     if (manCallback_ == nullptr) {
60         return;
61     }
62     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
63     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
64     EXPECT_EQ(HDF_SUCCESS, manCallback_->DestroyStream(streamId_));
65 }
66 
67 /**
68  * @tc.name: DestroyStream_001
69  * @tc.desc: Verify the DestroyStream function.
70  * @tc.type: FUNC
71  * @tc.require: AR000H0E6H
72  */
73 HWTEST_F(DAudioManagerCallbackTest, DestroyStream_001, TestSize.Level1)
74 {
75     if (manCallback_ == nullptr) {
76         return;
77     }
78     manCallback_->callback_ = nullptr;
79     EXPECT_EQ(HDF_FAILURE, manCallback_->DestroyStream(streamId_));
80 }
81 
82 /**
83  * @tc.name: DestroyStream_002
84  * @tc.desc: Verify the DestroyStream function.
85  * @tc.type: FUNC
86  * @tc.require: AR000H0E6H
87  */
88 HWTEST_F(DAudioManagerCallbackTest, DestroyStream_002, TestSize.Level1)
89 {
90     if (manCallback_ == nullptr) {
91         return;
92     }
93     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
94     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
95     EXPECT_EQ(HDF_SUCCESS, manCallback_->DestroyStream(streamId_));
96 }
97 
98 /**
99  * @tc.name: SetParameters_001
100  * @tc.desc: Verify the SetParameters function.
101  * @tc.type: FUNC
102  * @tc.require: AR000H0E6H
103  */
104 HWTEST_F(DAudioManagerCallbackTest, SetParameters_001, TestSize.Level1)
105 {
106     if (manCallback_ == nullptr) {
107         return;
108     }
109     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
110     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
111     OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioParameter param;
112     manCallback_->callback_ = nullptr;
113     EXPECT_EQ(HDF_FAILURE, manCallback_->SetParameters(streamId_, param));
114     EXPECT_EQ(HDF_FAILURE, manCallback_->DestroyStream(streamId_));
115 }
116 
117 /**
118  * @tc.name: SetParameters_002
119  * @tc.desc: Verify the SetParameters function.
120  * @tc.type: FUNC
121  * @tc.require: AR000H0E6H
122  */
123 HWTEST_F(DAudioManagerCallbackTest, SetParameters_002, TestSize.Level1)
124 {
125     if (manCallback_ == nullptr) {
126         return;
127     }
128     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
129     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
130     OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioParameter param = {
131         .format = 0x1u,
132         .channelCount = 2,
133         .sampleRate = 48000,
134         .period = 0,
135         .frameSize = 0,
136         .streamUsage = 0,
137         .ext = "HDF_SUCCESS"
138     };
139     EXPECT_EQ(HDF_SUCCESS, manCallback_->SetParameters(streamId_, param));
140     param = {
141         .format = 1 << 1,
142         .channelCount = 2,
143         .sampleRate = 48000,
144         .period = 0,
145         .frameSize = 0,
146         .streamUsage = 1,
147         .ext = "HDF_SUCCESS"
148     };
149     EXPECT_EQ(HDF_SUCCESS, manCallback_->SetParameters(streamId_, param));
150     param = {
151         .format = 1 << 1 | 1 << 0,
152         .channelCount = 2,
153         .sampleRate = 48000,
154         .period = 0,
155         .frameSize = 0,
156         .streamUsage = 2,
157         .ext = "HDF_SUCCESS"
158     };
159     EXPECT_EQ(HDF_SUCCESS, manCallback_->SetParameters(streamId_, param));
160     param = {
161         .format = -1,
162         .channelCount = 2,
163         .sampleRate = 48000,
164         .period = 0,
165         .frameSize = 0,
166         .streamUsage = -1,
167         .ext = "HDF_SUCCESS"
168     };
169     EXPECT_NE(HDF_SUCCESS, manCallback_->SetParameters(streamId_, param));
170     EXPECT_EQ(HDF_SUCCESS, manCallback_->DestroyStream(streamId_));
171 }
172 
173 /**
174  * @tc.name: NotifyEvent_001
175  * @tc.desc: Verify the NotifyEvent function.
176  * @tc.type: FUNC
177  * @tc.require: AR000H0E6H
178  */
179 HWTEST_F(DAudioManagerCallbackTest, NotifyEvent_001, TestSize.Level1)
180 {
181     if (manCallback_ == nullptr) {
182         return;
183     }
184     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
185     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
186     manCallback_->callback_ = nullptr;
187     OHOS::HDI::DistributedAudio::Audioext::V2_0::DAudioEvent event;
188     EXPECT_EQ(HDF_FAILURE, manCallback_->NotifyEvent(streamId_, event));
189     EXPECT_EQ(HDF_FAILURE, manCallback_->DestroyStream(streamId_));
190 }
191 
192 /**
193  * @tc.name: NotifyEvent_002
194  * @tc.desc: Verify the NotifyEvent function.
195  * @tc.type: FUNC
196  * @tc.require: AR000H0E6H
197  */
198 HWTEST_F(DAudioManagerCallbackTest, NotifyEvent_002, TestSize.Level1)
199 {
200     if (manCallback_ == nullptr) {
201         return;
202     }
203     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
204     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
205     OHOS::HDI::DistributedAudio::Audioext::V2_0::DAudioEvent event;
206     event.type = AudioEventHDF::AUDIO_EVENT_VOLUME_SET;
207     event.content = "HDF_SUCCESS";
208     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
209     event.type = AudioEventHDF::AUDIO_EVENT_MUTE_SET;
210     event.content = "HDF_SUCCESS";
211     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
212     event.type = AudioEventHDF::AUDIO_EVENT_CHANGE_PLAY_STATUS;
213     event.content = "HDF_SUCCESS";
214     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
215     event.type = AudioEventHDF::AUDIO_EVENT_MMAP_START_SPK;
216     event.content = "HDF_SUCCESS";
217     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
218     event.type = AudioEventHDF::AUDIO_EVENT_MMAP_STOP_SPK;
219     event.content = "HDF_SUCCESS";
220     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
221     event.type = AudioEventHDF::AUDIO_EVENT_MMAP_START_MIC;
222     event.content = "HDF_SUCCESS";
223     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
224     event.type = AudioEventHDF::AUDIO_EVENT_MMAP_STOP_MIC;
225     event.content = "HDF_SUCCESS";
226     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
227     event.type = AudioEventHDF::AUDIO_EVENT_START;
228     event.content = "HDF_SUCCESS";
229     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
230     event.type = AudioEventHDF::AUDIO_EVENT_STOP;
231     event.content = "HDF_SUCCESS";
232     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
233     event.type = -1;
234     event.content = "HDF_SUCCESS";
235     EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(streamId_, event));
236     EXPECT_EQ(HDF_SUCCESS, manCallback_->DestroyStream(streamId_));
237 }
238 
239 /**
240  * @tc.name: WriteStreamData_001
241  * @tc.desc: Verify the WriteStreamData function.
242  * @tc.type: FUNC
243  * @tc.require: AR000H0E6H
244  */
245 HWTEST_F(DAudioManagerCallbackTest, WriteStreamData_001, TestSize.Level1)
246 {
247     if (manCallback_ == nullptr) {
248         return;
249     }
250     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
251     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
252     manCallback_->callback_ = nullptr;
253     OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioData data;
254     EXPECT_EQ(HDF_FAILURE, manCallback_->WriteStreamData(streamId_, data));
255     EXPECT_EQ(HDF_FAILURE, manCallback_->DestroyStream(streamId_));
256 }
257 
258 /**
259  * @tc.name: WriteStreamData_002
260  * @tc.desc: Verify the WriteStreamData function.
261  * @tc.type: FUNC
262  * @tc.require: AR000H0E6H
263  */
264 HWTEST_F(DAudioManagerCallbackTest, WriteStreamData_002, TestSize.Level1)
265 {
266     if (manCallback_ == nullptr) {
267         return;
268     }
269     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
270     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
271     OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioData data;
272     data.param.format = 16;
273     data.param.channelCount = 2;
274     data.param.sampleRate = 48000;
275     data.param.period = 2;
276     data.param.frameSize = 4096;
277     data.param.streamUsage = 1;
278     data.param.ext = "hello";
279     uint32_t dataSize = 4096;
280     std::shared_ptr<OHOS::DistributedHardware::AudioData> audioData = std::make_shared<AudioData>(dataSize);
281     data.data.assign(audioData->Data(), audioData->Data() + audioData->Capacity());
282     EXPECT_EQ(HDF_SUCCESS, manCallback_->WriteStreamData(streamId_, data));
283     audioData = std::make_shared<AudioData>(3000);
284     data.data.assign(audioData->Data(), audioData->Data() + audioData->Capacity());
285     EXPECT_EQ(HDF_SUCCESS, manCallback_->WriteStreamData(streamId_, data));
286     EXPECT_EQ(HDF_SUCCESS, manCallback_->DestroyStream(streamId_));
287 }
288 
289 /**
290  * @tc.name: ReadStreamData_001
291  * @tc.desc: Verify the ReadStreamData function.
292  * @tc.type: FUNC
293  * @tc.require: AR000H0E6H
294  */
295 HWTEST_F(DAudioManagerCallbackTest, ReadStreamData_001, TestSize.Level1)
296 {
297     if (manCallback_ == nullptr) {
298         return;
299     }
300     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
301     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
302     manCallback_->callback_ = nullptr;
303     OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioData data;
304     EXPECT_EQ(HDF_FAILURE, manCallback_->ReadStreamData(streamId_, data));
305     EXPECT_EQ(HDF_FAILURE, manCallback_->DestroyStream(streamId_));
306 }
307 
308 /**
309  * @tc.name: ReadStreamData_002
310  * @tc.desc: Verify the ReadStreamData function.
311  * @tc.type: FUNC
312  * @tc.require: AR000H0E6H
313  */
314 HWTEST_F(DAudioManagerCallbackTest, ReadStreamData_002, TestSize.Level1)
315 {
316     if (manCallback_ == nullptr) {
317         return;
318     }
319     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
320     EXPECT_EQ(HDF_SUCCESS, manCallback_->CreateStream(streamId_));
321     OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioData data;
322     data.param.format = 16;
323     data.param.channelCount = 2;
324     data.param.sampleRate = 48000;
325     data.param.period = 1;
326     data.param.frameSize = 1;
327     data.param.streamUsage = 1;
328     data.param.ext = "hello";
329     uint32_t dataSize = 4096;
330     std::shared_ptr<OHOS::DistributedHardware::AudioData> audioData = std::make_shared<AudioData>(dataSize);
331     data.data.assign(audioData->Data(), audioData->Data() + audioData->Capacity());
332     EXPECT_EQ(HDF_SUCCESS, manCallback_->ReadStreamData(streamId_, data));
333     EXPECT_EQ(HDF_SUCCESS, manCallback_->DestroyStream(streamId_));
334 }
335 
336 /**
337  * @tc.name: ReadMmapPosition_002
338  * @tc.desc: Verify the ReadMmapPosition function.
339  * @tc.type: FUNC
340  * @tc.require: AR000H0E6H
341  */
342 HWTEST_F(DAudioManagerCallbackTest, ReadMmapPosition_001, TestSize.Level1)
343 {
344     if (manCallback_ == nullptr) {
345         return;
346     }
347     int32_t streamId = 0;
348     uint64_t frames = 1;
349     OHOS::HDI::DistributedAudio::Audioext::V2_0::CurrentTime time;
350     EXPECT_EQ(HDF_SUCCESS, manCallback_->ReadMmapPosition(streamId, frames, time));
351     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
352     EXPECT_EQ(HDF_SUCCESS, manCallback_->ReadMmapPosition(streamId, frames, time));
353 }
354 
355 /**
356  * @tc.name: RefreshAshmemInfo_002
357  * @tc.desc: Verify the RefreshAshmemInfo function.
358  * @tc.type: FUNC
359  * @tc.require: AR000H0E6H
360  */
361 HWTEST_F(DAudioManagerCallbackTest, RefreshAshmemInfo_001, TestSize.Level1)
362 {
363     if (manCallback_ == nullptr) {
364         return;
365     }
366     int32_t streamId = 1;
367     int fd = 1;
368     int32_t ashmemLength = 240;
369     int32_t lengthPerTrans = 960;
370     EXPECT_EQ(HDF_SUCCESS, manCallback_->RefreshAshmemInfo(streamId, fd, ashmemLength, lengthPerTrans));
371     manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
372     EXPECT_EQ(HDF_SUCCESS, manCallback_->RefreshAshmemInfo(streamId, fd, ashmemLength, lengthPerTrans));
373 }
374 } // DistributedHardware
375 } // OHOS