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