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 "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: OpenDevice_001
38 * @tc.desc: Verify the OpenDevice function.
39 * @tc.type: FUNC
40 * @tc.require: AR000H0E6H
41 */
42 HWTEST_F(DAudioManagerCallbackTest, OpenDevice_001, TestSize.Level1)
43 {
44 manCallback_->callback_ = nullptr;
45 EXPECT_EQ(HDF_FAILURE, manCallback_->OpenDevice(adpName_, devId_));
46 }
47
48 /**
49 * @tc.name: OpenDevice_002
50 * @tc.desc: Verify the OpenDevice function.
51 * @tc.type: FUNC
52 * @tc.require: AR000H0E6H
53 */
54 HWTEST_F(DAudioManagerCallbackTest, OpenDevice_002, TestSize.Level1)
55 {
56 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
57 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
58 EXPECT_EQ(HDF_SUCCESS, manCallback_->CloseDevice(adpName_, devId_));
59 }
60
61 /**
62 * @tc.name: CloseDevice_001
63 * @tc.desc: Verify the CloseDevice function.
64 * @tc.type: FUNC
65 * @tc.require: AR000H0E6H
66 */
67 HWTEST_F(DAudioManagerCallbackTest, CloseDevice_001, TestSize.Level1)
68 {
69 manCallback_->callback_ = nullptr;
70 EXPECT_EQ(HDF_FAILURE, manCallback_->CloseDevice(adpName_, devId_));
71 }
72
73 /**
74 * @tc.name: CloseDevice_002
75 * @tc.desc: Verify the CloseDevice function.
76 * @tc.type: FUNC
77 * @tc.require: AR000H0E6H
78 */
79 HWTEST_F(DAudioManagerCallbackTest, CloseDevice_002, TestSize.Level1)
80 {
81 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
82 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
83 EXPECT_EQ(HDF_SUCCESS, manCallback_->CloseDevice(adpName_, devId_));
84 }
85
86 /**
87 * @tc.name: SetParameters_001
88 * @tc.desc: Verify the SetParameters function.
89 * @tc.type: FUNC
90 * @tc.require: AR000H0E6H
91 */
92 HWTEST_F(DAudioManagerCallbackTest, SetParameters_001, TestSize.Level1)
93 {
94 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
95 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
96 OHOS::HDI::DistributedAudio::Audioext::V1_0::AudioParameter param;
97 manCallback_->callback_ = nullptr;
98 EXPECT_EQ(HDF_FAILURE, manCallback_->SetParameters(adpName_, devId_, param));
99 EXPECT_EQ(HDF_FAILURE, manCallback_->CloseDevice(adpName_, devId_));
100 }
101
102 /**
103 * @tc.name: SetParameters_002
104 * @tc.desc: Verify the SetParameters function.
105 * @tc.type: FUNC
106 * @tc.require: AR000H0E6H
107 */
108 HWTEST_F(DAudioManagerCallbackTest, SetParameters_002, TestSize.Level1)
109 {
110 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
111 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
112 OHOS::HDI::DistributedAudio::Audioext::V1_0::AudioParameter param = {
113 .format = 0x1u,
114 .channelCount = 2,
115 .sampleRate = 48000,
116 .period = 0,
117 .frameSize = 0,
118 .streamUsage = 0,
119 .ext = "HDF_SUCCESS"
120 };
121 EXPECT_EQ(HDF_SUCCESS, manCallback_->SetParameters(adpName_, devId_, param));
122 param = {
123 .format = 1 << 1,
124 .channelCount = 2,
125 .sampleRate = 48000,
126 .period = 0,
127 .frameSize = 0,
128 .streamUsage = 1,
129 .ext = "HDF_SUCCESS"
130 };
131 EXPECT_EQ(HDF_SUCCESS, manCallback_->SetParameters(adpName_, devId_, param));
132 param = {
133 .format = 1 << 1 | 1 << 0,
134 .channelCount = 2,
135 .sampleRate = 48000,
136 .period = 0,
137 .frameSize = 0,
138 .streamUsage = 2,
139 .ext = "HDF_SUCCESS"
140 };
141 EXPECT_EQ(HDF_SUCCESS, manCallback_->SetParameters(adpName_, devId_, param));
142 param = {
143 .format = -1,
144 .channelCount = 2,
145 .sampleRate = 48000,
146 .period = 0,
147 .frameSize = 0,
148 .streamUsage = -1,
149 .ext = "HDF_SUCCESS"
150 };
151 EXPECT_NE(HDF_SUCCESS, manCallback_->SetParameters(adpName_, devId_, param));
152 EXPECT_EQ(HDF_SUCCESS, manCallback_->CloseDevice(adpName_, devId_));
153 }
154
155 /**
156 * @tc.name: NotifyEvent_001
157 * @tc.desc: Verify the NotifyEvent function.
158 * @tc.type: FUNC
159 * @tc.require: AR000H0E6H
160 */
161 HWTEST_F(DAudioManagerCallbackTest, NotifyEvent_001, TestSize.Level1)
162 {
163 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
164 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
165 manCallback_->callback_ = nullptr;
166 OHOS::HDI::DistributedAudio::Audioext::V1_0::DAudioEvent event;
167 EXPECT_EQ(HDF_FAILURE, manCallback_->NotifyEvent(adpName_, devId_, event));
168 EXPECT_EQ(HDF_FAILURE, manCallback_->CloseDevice(adpName_, devId_));
169 }
170
171 /**
172 * @tc.name: NotifyEvent_002
173 * @tc.desc: Verify the NotifyEvent function.
174 * @tc.type: FUNC
175 * @tc.require: AR000H0E6H
176 */
177 HWTEST_F(DAudioManagerCallbackTest, NotifyEvent_002, TestSize.Level1)
178 {
179 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
180 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
181 OHOS::HDI::DistributedAudio::Audioext::V1_0::DAudioEvent event;
182 event.type = AudioEventHDF::AUDIO_EVENT_VOLUME_SET;
183 event.content = "HDF_SUCCESS";
184 EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(adpName_, devId_, event));
185 event.type = AudioEventHDF::AUDIO_EVENT_MUTE_SET;
186 event.content = "HDF_SUCCESS";
187 EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(adpName_, devId_, event));
188 event.type = AudioEventHDF::AUDIO_EVENT_CHANGE_PLAY_STATUS;
189 event.content = "HDF_SUCCESS";
190 EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(adpName_, devId_, event));
191 event.type = -1;
192 event.content = "HDF_SUCCESS";
193 EXPECT_EQ(HDF_SUCCESS, manCallback_->NotifyEvent(adpName_, devId_, event));
194 EXPECT_EQ(HDF_SUCCESS, manCallback_->CloseDevice(adpName_, devId_));
195 }
196
197 /**
198 * @tc.name: WriteStreamData_001
199 * @tc.desc: Verify the WriteStreamData function.
200 * @tc.type: FUNC
201 * @tc.require: AR000H0E6H
202 */
203 HWTEST_F(DAudioManagerCallbackTest, WriteStreamData_001, TestSize.Level1)
204 {
205 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
206 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
207 manCallback_->callback_ = nullptr;
208 OHOS::HDI::DistributedAudio::Audioext::V1_0::AudioData data;
209 EXPECT_EQ(HDF_FAILURE, manCallback_->WriteStreamData(adpName_, devId_, data));
210 EXPECT_EQ(HDF_FAILURE, manCallback_->CloseDevice(adpName_, devId_));
211 }
212
213 /**
214 * @tc.name: WriteStreamData_002
215 * @tc.desc: Verify the WriteStreamData function.
216 * @tc.type: FUNC
217 * @tc.require: AR000H0E6H
218 */
219 HWTEST_F(DAudioManagerCallbackTest, WriteStreamData_002, TestSize.Level1)
220 {
221 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
222 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
223 OHOS::HDI::DistributedAudio::Audioext::V1_0::AudioData data;
224 data.param.format = 16;
225 data.param.channelCount = 2;
226 data.param.sampleRate = 48000;
227 data.param.period = 2;
228 data.param.frameSize = 4096;
229 data.param.streamUsage = 1;
230 data.param.ext = "hello";
231 uint32_t dataSize = 4096;
232 std::shared_ptr<OHOS::DistributedHardware::AudioData> audioData = std::make_shared<AudioData>(dataSize);
233 data.data.assign(audioData->Data(), audioData->Data() + audioData->Capacity());
234 EXPECT_EQ(HDF_SUCCESS, manCallback_->WriteStreamData(adpName_, devId_, data));
235 audioData = std::make_shared<AudioData>(3000);
236 data.data.assign(audioData->Data(), audioData->Data() + audioData->Capacity());
237 EXPECT_EQ(HDF_SUCCESS, manCallback_->WriteStreamData(adpName_, devId_, data));
238 EXPECT_EQ(HDF_SUCCESS, manCallback_->CloseDevice(adpName_, devId_));
239 }
240
241 /**
242 * @tc.name: ReadStreamData_001
243 * @tc.desc: Verify the ReadStreamData function.
244 * @tc.type: FUNC
245 * @tc.require: AR000H0E6H
246 */
247 HWTEST_F(DAudioManagerCallbackTest, ReadStreamData_001, TestSize.Level1)
248 {
249 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
250 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
251 manCallback_->callback_ = nullptr;
252 OHOS::HDI::DistributedAudio::Audioext::V1_0::AudioData data;
253 EXPECT_EQ(HDF_FAILURE, manCallback_->ReadStreamData(adpName_, devId_, data));
254 EXPECT_EQ(HDF_FAILURE, manCallback_->CloseDevice(adpName_, devId_));
255 }
256
257 /**
258 * @tc.name: ReadStreamData_002
259 * @tc.desc: Verify the ReadStreamData function.
260 * @tc.type: FUNC
261 * @tc.require: AR000H0E6H
262 */
263 HWTEST_F(DAudioManagerCallbackTest, ReadStreamData_002, TestSize.Level1)
264 {
265 manCallback_->callback_ = std::make_shared<MockIDAudioHdiCallback>();
266 EXPECT_EQ(HDF_SUCCESS, manCallback_->OpenDevice(adpName_, devId_));
267 OHOS::HDI::DistributedAudio::Audioext::V1_0::AudioData data;
268 data.param.format = 16;
269 data.param.channelCount = 2;
270 data.param.sampleRate = 48000;
271 data.param.period = 1;
272 data.param.frameSize = 1;
273 data.param.streamUsage = 1;
274 data.param.ext = "hello";
275 uint32_t dataSize = 4096;
276 std::shared_ptr<OHOS::DistributedHardware::AudioData> audioData = std::make_shared<AudioData>(dataSize);
277 data.data.assign(audioData->Data(), audioData->Data() + audioData->Capacity());
278 EXPECT_EQ(HDF_SUCCESS, manCallback_->ReadStreamData(adpName_, devId_, data));
279 EXPECT_EQ(HDF_SUCCESS, manCallback_->CloseDevice(adpName_, devId_));
280 }
281 } // DistributedHardware
282 } // OHOS