1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17 #include "hpae_capturer_stream_impl.h"
18 #include "audio_errors.h"
19 #include "hpae_adapter_manager.h"
20 #include "audio_system_manager.h"
21
22 using namespace testing::ext;
23 namespace OHOS {
24 namespace AudioStandard {
25 const int32_t CAPTURER_FLAG = 10;
26 static std::shared_ptr<HpaeAdapterManager> adapterManager;
27
28 class HpaeCapturerStreamUnitTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 std::shared_ptr<HpaeCapturerStreamImpl> CreateHpaeCapturerStreamImpl();
35 };
36
SetUpTestCase(void)37 void HpaeCapturerStreamUnitTest::SetUpTestCase(void)
38 {
39 // input testsuit setup step，setup invoked before all testcases
40 }
41
TearDownTestCase(void)42 void HpaeCapturerStreamUnitTest::TearDownTestCase(void)
43 {
44 // input testsuit teardown step，teardown invoked after all testcases
45 }
46
SetUp(void)47 void HpaeCapturerStreamUnitTest::SetUp(void)
48 {
49 // input testcase setup step，setup invoked before each testcases
50 }
51
TearDown(void)52 void HpaeCapturerStreamUnitTest::TearDown(void)
53 {
54 // input testcase teardown step，teardown invoked after each testcases
55 }
56
GetInnerCapConfig()57 static AudioProcessConfig GetInnerCapConfig()
58 {
59 AudioProcessConfig config;
60 config.appInfo.appUid = CAPTURER_FLAG;
61 config.appInfo.appPid = CAPTURER_FLAG;
62 config.streamInfo.format = SAMPLE_S32LE;
63 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
64 config.streamInfo.channels = STEREO;
65 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
66 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
67 config.streamType = AudioStreamType::STREAM_MUSIC;
68 config.deviceType = DEVICE_TYPE_USB_HEADSET;
69 config.capturerInfo.sourceType = SOURCE_TYPE_WAKEUP;
70 config.innerCapId = 1;
71 config.originalSessionId = 123456; // 123456: session id
72 return config;
73 }
74
CreateHpaeCapturerStreamImpl()75 std::shared_ptr<HpaeCapturerStreamImpl> HpaeCapturerStreamUnitTest::CreateHpaeCapturerStreamImpl()
76 {
77 adapterManager = std::make_shared<HpaeAdapterManager>(DUP_PLAYBACK);
78 AudioProcessConfig processConfig = GetInnerCapConfig();
79 std::string deviceName = "";
80 std::shared_ptr<ICapturerStream> capturerStream = adapterManager->CreateCapturerStream(processConfig, deviceName);
81 std::shared_ptr<HpaeCapturerStreamImpl> capturerStreamImpl =
82 std::static_pointer_cast<HpaeCapturerStreamImpl>(capturerStream);
83 return capturerStreamImpl;
84 }
85
86 /**
87 * @tc.name : Test HpaeCapturerStreamImpl API
88 * @tc.type : FUNC
89 * @tc.number: HpaeCapturerStream_001
90 * @tc.desc : Test HpaeCapturerStreamImpl interface.
91 */
92 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_001, TestSize.Level1)
93 {
94 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
95 uint64_t framesReadRet = 0;
96 capturerStreamImplRet->byteSizePerFrame_ = 0;
97 auto ret = capturerStreamImplRet->GetStreamFramesRead(framesReadRet);
98 EXPECT_EQ(ret, SUCCESS);
99
100 capturerStreamImplRet->byteSizePerFrame_ = 1;
101 ret = capturerStreamImplRet->GetStreamFramesRead(framesReadRet);
102 EXPECT_EQ(ret, SUCCESS);
103 }
104
105 /**
106 * @tc.name : Test HpaeCapturerStreamImpl API
107 * @tc.type : FUNC
108 * @tc.number: HpaeCapturerStream_002
109 * @tc.desc : Test HpaeCapturerStreamImpl interface.
110 */
111 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_002, TestSize.Level1)
112 {
113 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
114 uint64_t timestampRet = 0;
115 auto ret = capturerStreamImplRet->GetCurrentTimeStamp(timestampRet);
116 EXPECT_EQ(ret, SUCCESS);
117 }
118
119 /**
120 * @tc.name : Test HpaeCapturerStreamImpl API
121 * @tc.type : FUNC
122 * @tc.number: HpaeCapturerStream_003
123 * @tc.desc : Test HpaeCapturerStreamImpl interface.
124 */
125 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_003, TestSize.Level1)
126 {
127 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
128 uint64_t latencyRet;
129 bool isStandbyRet = false;
130
131 auto ret = capturerStreamImplRet->GetLatency(latencyRet);
132 EXPECT_EQ(ret, SUCCESS);
133
134 ret = capturerStreamImplRet->Flush();
135 EXPECT_EQ(ret, SUCCESS);
136
137 ret = capturerStreamImplRet->Stop();
138 EXPECT_EQ(ret, SUCCESS);
139
140 ret = capturerStreamImplRet->Start();
141 EXPECT_EQ(ret, SUCCESS);
142
143 ret = capturerStreamImplRet->Pause(isStandbyRet);
144 EXPECT_EQ(ret, SUCCESS);
145 }
146
147 /**
148 * @tc.name : Test HpaeCapturerStreamImpl API
149 * @tc.type : FUNC
150 * @tc.number: HpaeCapturerStream_004
151 * @tc.desc : Test HpaeCapturerStreamImpl interface.
152 */
153 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_004, TestSize.Level1)
154 {
155 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
156 bool isStandbyRet = false;
157
158 auto ret = capturerStreamImplRet->Start();
159 EXPECT_EQ(ret, SUCCESS);
160
161 ret = capturerStreamImplRet->Pause(isStandbyRet);
162 EXPECT_EQ(ret, SUCCESS);
163
164 ret = capturerStreamImplRet->Flush();
165 EXPECT_EQ(ret, SUCCESS);
166
167 ret = capturerStreamImplRet->Stop();
168 EXPECT_EQ(ret, SUCCESS);
169 }
170
171 /**
172 * @tc.name : Test HpaeCapturerStreamImpl API
173 * @tc.type : FUNC
174 * @tc.number: HpaeCapturerStream_005
175 * @tc.desc : Test HpaeCapturerStreamImpl interface.
176 */
177 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_005, TestSize.Level1)
178 {
179 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
180 capturerStreamImplRet->state_ = RUNNING;
181
182 auto ret = capturerStreamImplRet->Release();
183 EXPECT_EQ(ret, SUCCESS);
184 }
185
186 /**
187 * @tc.name : Test HpaeCapturerStreamImpl API
188 * @tc.type : FUNC
189 * @tc.number: HpaeCapturerStream_006
190 * @tc.desc : Test HpaeCapturerStreamImpl interface.
191 */
192 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_006, TestSize.Level1)
193 {
194 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
195 capturerStreamImplRet->statusCallback_ = std::weak_ptr<IStatusCallback>();
196 capturerStreamImplRet->state_ = STOPPED;
197
198 auto ret = capturerStreamImplRet->Release();
199 EXPECT_EQ(ret, SUCCESS);
200 }
201
202 /**
203 * @tc.name : Test HpaeCapturerStreamImpl API
204 * @tc.type : FUNC
205 * @tc.number: HpaeCapturerStream_007
206 * @tc.desc : Test HpaeCapturerStreamImpl interface.
207 */
208 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_007, TestSize.Level1)
209 {
210 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
211 std::string deviceName = "";
212 auto ret = capturerStreamImplRet->InitParams(deviceName);
213 EXPECT_EQ(ret, SUCCESS);
214 }
215
216 /**
217 * @tc.name : Test HpaeCapturerStreamImpl API
218 * @tc.type : FUNC
219 * @tc.number: HpaeCapturerStream_008
220 * @tc.desc : Test HpaeCapturerStreamImpl interface.
221 */
222 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_008, TestSize.Level1)
223 {
224 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
225 int32_t ret = capturerStreamImplRet->Start();
226 EXPECT_EQ(ret, SUCCESS);
227 }
228
229 /**
230 * @tc.name : Test HpaeCapturerStreamImpl API
231 * @tc.type : FUNC
232 * @tc.number: HpaeCapturerStream_009
233 * @tc.desc : Test HpaeCapturerStreamImpl interface.
234 */
235 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_009, TestSize.Level1)
236 {
237 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
238 bool isStandbyRet = false;
239 auto ret = capturerStreamImplRet->Start();
240 EXPECT_EQ(ret, SUCCESS);
241 ret = capturerStreamImplRet->Pause(isStandbyRet);
242 EXPECT_EQ(ret, SUCCESS);
243 }
244
245 /**
246 * @tc.name : Test HpaeCapturerStreamImpl API
247 * @tc.type : FUNC
248 * @tc.number: HpaeCapturerStream_010
249 * @tc.desc : Test HpaeCapturerStreamImpl interface.
250 */
251 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_010, TestSize.Level1)
252 {
253 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
254 bool isStandbyRet = false;
255 auto ret = capturerStreamImplRet->Start();
256 EXPECT_EQ(ret, SUCCESS);
257
258 ret = capturerStreamImplRet->Pause(isStandbyRet);
259 EXPECT_EQ(ret, SUCCESS);
260
261 ret = capturerStreamImplRet->Flush();
262 EXPECT_EQ(ret, SUCCESS);
263 }
264
265 /**
266 * @tc.name : Test HpaeCapturerStreamImpl API
267 * @tc.type : FUNC
268 * @tc.number: HpaeCapturerStream_011
269 * @tc.desc : Test HpaeCapturerStreamImpl interface.
270 */
271 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_011, TestSize.Level1)
272 {
273 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
274 bool isStandbyRet = false;
275
276 auto ret = capturerStreamImplRet->Start();
277 EXPECT_EQ(ret, SUCCESS);
278
279 ret = capturerStreamImplRet->Pause(isStandbyRet);
280 EXPECT_EQ(ret, SUCCESS);
281
282 ret = capturerStreamImplRet->Flush();
283 EXPECT_EQ(ret, SUCCESS);
284
285 ret = capturerStreamImplRet->Stop();
286 EXPECT_EQ(ret, SUCCESS);
287 }
288
289 /**
290 * @tc.name : Test HpaeCapturerStreamImpl API
291 * @tc.type : FUNC
292 * @tc.number: HpaeCapturerStream_012
293 * @tc.desc : Test HpaeCapturerStreamImpl interface.
294 */
295 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_012, TestSize.Level1)
296 {
297 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
298 capturerStreamImplRet->state_ = RUNNING;
299 auto ret = capturerStreamImplRet->Release();
300 EXPECT_EQ(ret, SUCCESS);
301 }
302
303 /**
304 * @tc.name : Test HpaeCapturerStreamImpl API
305 * @tc.type : FUNC
306 * @tc.number: HpaeCapturerStream_013
307 * @tc.desc : Test HpaeCapturerStreamImpl interface.
308 */
309 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_013, TestSize.Level1)
310 {
311 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
312 capturerStreamImplRet->capturerServerDumpFile_ = fopen("/data/data/.pulse_dir/capturer_impl.pcm", "wb+");
313 size_t length = 1;
314 capturerStreamImplRet->DequeueBuffer(length);
315 EXPECT_EQ(capturerStreamImplRet != nullptr, true);
316 }
317
318 /**
319 * @tc.name : Test HpaeCapturerStreamImpl API
320 * @tc.type : FUNC
321 * @tc.number: HpaeCapturerStream_014
322 * @tc.desc : Test HpaeCapturerStreamImpl interface.
323 */
324 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_014, TestSize.Level1)
325 {
326 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
327 AudioCallBackCapturerStreamInfo info;
328 info.timestamp = 123456789;
329 info.latency = 100;
330 info.framesRead = 44100;
331 info.outputData = nullptr;
332 info.requestDataLen = 44100 * sizeof(int16_t);
333
334 auto ret = capturerStreamImplRet->OnStreamData(info);
335 EXPECT_EQ(ret, SUCCESS);
336
337 capturerStreamImplRet->readCallback_.reset();
338 ret = capturerStreamImplRet->OnStreamData(info);
339 EXPECT_EQ(ret, SUCCESS);
340 }
341
342 /**
343 * @tc.name : Test HpaeCapturerStreamImpl API
344 * @tc.type : FUNC
345 * @tc.number: HpaeCapturerStream_016
346 * @tc.desc : Test HpaeCapturerStreamImpl interface.
347 */
348 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_016, TestSize.Level2)
349 {
350 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
351
352 auto ret = capturerStreamImplRet->DropBuffer();
353 EXPECT_EQ(ret, SUCCESS);
354 }
355
356 /**
357 * @tc.name : Test HpaeCapturerStreamImpl API
358 * @tc.type : FUNC
359 * @tc.number: HpaeCapturerStream_017
360 * @tc.desc : Test HpaeCapturerStreamImpl interface.
361 */
362 HWTEST_F(HpaeCapturerStreamUnitTest, HpaeCapturerStream_017, TestSize.Level2)
363 {
364 auto capturerStreamImplRet = CreateHpaeCapturerStreamImpl();
365 size_t minBufferSize = 10;
366 int32_t abortTimes = 0;
367
368 capturerStreamImplRet->AbortCallback(abortTimes);
369 auto ret = capturerStreamImplRet->GetMinimumBufferSize(minBufferSize);
370 EXPECT_EQ(ret, SUCCESS);
371 }
372 }
373 }