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 <gtest/gtest.h>
17 #include "hdi_service_common.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 class AudioIdlHdiCaptureAttrTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 struct IAudioAdapter *adapter = nullptr;
31 struct IAudioCapture *capture = nullptr;
32 static TestAudioManager *manager;
33 uint32_t captureId_ = 0;
34 };
35
36 using THREAD_FUNC = void *(*)(void *);
37 TestAudioManager *AudioIdlHdiCaptureAttrTest::manager = nullptr;
38
SetUpTestCase(void)39 void AudioIdlHdiCaptureAttrTest::SetUpTestCase(void)
40 {
41 manager = IAudioManagerGet(IS_STUB);
42 ASSERT_NE(nullptr, manager);
43 }
44
TearDownTestCase(void)45 void AudioIdlHdiCaptureAttrTest::TearDownTestCase(void)
46 {
47 if (manager != nullptr) {
48 (void)IAudioManagerRelease(manager, IS_STUB);
49 }
50 }
51
SetUp(void)52 void AudioIdlHdiCaptureAttrTest::SetUp(void)
53 {
54 ASSERT_NE(nullptr, manager);
55 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture, &captureId_);
56 ASSERT_EQ(HDF_SUCCESS, ret);
57 }
58
TearDown(void)59 void AudioIdlHdiCaptureAttrTest::TearDown(void)
60 {
61 int32_t ret = ReleaseCaptureSource(manager, adapter, capture, captureId_);
62 ASSERT_EQ(HDF_SUCCESS, ret);
63 }
64
65 /**
66 * @tc.name AudioCaptureGetFrameSize_001
67 * @tc.desc test AudioCaptureGetFrameSize interface, return 0 is call successfully.
68 * @tc.type: FUNC
69 */
70 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetFrameSize_001, TestSize.Level1)
71 {
72 int32_t ret = -1;
73 uint64_t size = 0;
74 ASSERT_NE(nullptr, capture);
75 ret = capture->GetFrameSize(capture, &size);
76 EXPECT_EQ(HDF_SUCCESS, ret);
77 EXPECT_GT(size, INITIAL_VALUE);
78 }
79 /**
80 * @tc.name AudioCaptureGetFrameSizeNull_002
81 * @tc.desc test AudioCaptureGetFrameSize interface, return -3/-4 if the parameter handle is nullptr.
82 * @tc.type: FUNC
83 */
84 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetFrameSizeNull_002, TestSize.Level1)
85 {
86 int32_t ret = -1;
87 uint64_t size = 0;
88 struct IAudioCapture *captureNull = nullptr;
89 ASSERT_NE(nullptr, capture);
90 ret = capture->GetFrameSize(captureNull, &size);
91 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
92 }
93 /**
94 * @tc.name AudioCaptureGetFrameSizeNull_003
95 * @tc.desc test AudioCaptureGetFrameSize interface, return -3 if the parameter size is nullptr.
96 * @tc.type: FUNC
97 */
98 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetFrameSizeNull_003, TestSize.Level1)
99 {
100 int32_t ret = -1;
101 uint64_t *sizeNull = nullptr;
102 ASSERT_NE(nullptr, capture);
103 ret = capture->GetFrameSize(capture, sizeNull);
104 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
105 }
106 /**
107 * @tc.name AudioCaptureGetFrameCount_001
108 * @tc.desc test AudioCaptureGetFrameCount interface, return 0 if the FrameCount is called after creating the object.
109 * @tc.type: FUNC
110 */
111 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetFrameCount_001, TestSize.Level1)
112 {
113 int32_t ret = -1;
114 uint64_t count = 0;
115 ASSERT_NE(nullptr, capture);
116 ret = capture->GetFrameCount(capture, &count);
117 EXPECT_EQ(HDF_SUCCESS, ret);
118 EXPECT_GE(count, INITIAL_VALUE);
119 }
120 /**
121 * @tc.name AudioCaptureGetFrameCount_001
122 * @tc.desc test AudioCaptureGetFrameCount interface, return 0 if the GetFrameCount is called after started.
123 * @tc.type: FUNC
124 */
125 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetFrameCount_002, TestSize.Level1)
126 {
127 int32_t ret = -1;
128 uint64_t count = 0;
129 ASSERT_NE(nullptr, capture);
130 ret = AudioCaptureStartAndOneFrame(capture);
131 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_FAILURE);
132 ret = capture->GetFrameCount(capture, &count);
133 EXPECT_EQ(HDF_SUCCESS, ret);
134 EXPECT_GT(count, INITIAL_VALUE);
135 capture->Stop(capture);
136 }
137 /**
138 * @tc.name AudioCaptureGetFrameCountNull_003
139 * @tc.desc test AudioCaptureGetFrameCount interface, return -3/-4 if the parameter handle is nullptr.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetFrameCountNull_003, TestSize.Level1)
143 {
144 int32_t ret = -1;
145 uint64_t count = 0;
146 struct IAudioCapture *captureNull = nullptr;
147 ASSERT_NE(nullptr, capture);
148 ret = capture->GetFrameCount(captureNull, &count);
149 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
150 }
151
152 /**
153 * @tc.name AudioCaptureGetFrameCountNull_004
154 * @tc.desc test AudioCaptureGetFrameCount interface, return -3 if the parameter handle is nullptr.
155 * @tc.type: FUNC
156 */
157 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetFrameCountNull_004, TestSize.Level1)
158 {
159 int32_t ret = -1;
160 uint64_t *countNull = nullptr;
161 ASSERT_NE(nullptr, capture);
162 ret = capture->GetFrameCount(capture, countNull);
163 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
164 }
165 /**
166 * @tc.name AudioRenderGetCurrentChannelId_001
167 * @tc.desc Test GetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully
168 * @tc.type: FUNC
169 */
170 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetCurrentChannelId_001, TestSize.Level1)
171 {
172 int32_t ret = -1;
173 uint32_t channelId = 0;
174 uint32_t channelIdValue = CHANNELCOUNT;
175 ASSERT_NE(nullptr, capture);
176 ret = capture->GetCurrentChannelId(capture, &channelId);
177 EXPECT_EQ(HDF_SUCCESS, ret);
178 EXPECT_EQ(channelIdValue, channelId);
179 }
180 /**
181 * @tc.name AudioCaptureGetCurrentChannelId_003
182 * @tc.desc Test GetCurrentChannelId interface, return 0 if CurrentChannelId is obtained after started
183 * @tc.type: FUNC
184 */
185 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetCurrentChannelId_003, TestSize.Level1)
186 {
187 int32_t ret = -1;
188 uint32_t channelId = 0;
189 uint32_t channelIdExp = 2;
190 ASSERT_NE(nullptr, capture);
191 ret = AudioCaptureStartAndOneFrame(capture);
192 EXPECT_EQ(HDF_SUCCESS, ret);
193
194 ret = capture->GetCurrentChannelId(capture, &channelId);
195 EXPECT_EQ(HDF_SUCCESS, ret);
196 EXPECT_EQ(channelIdExp, channelId);
197 capture->Stop(capture);
198 }
199 /**
200 * @tc.name AudioCaptureGetCurrentChannelIdNull_004
201 * @tc.desc Test GetCurrentChannelId interface,return -3/-4 if set the parameter capture is nullptr
202 * @tc.type: FUNC
203 */
204 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetCurrentChannelIdNull_004, TestSize.Level1)
205 {
206 int32_t ret = -1;
207 uint32_t channelId = 0;
208 struct IAudioCapture *captureNull = nullptr;
209 ASSERT_NE(nullptr, capture);
210 ret = capture->GetCurrentChannelId(captureNull, &channelId);
211 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
212 }
213 /**
214 * @tc.name AudioCaptureGetCurrentChannelIdNull_005
215 * @tc.desc Test CaptureGetCurrentChannelId interface, return -3 if setting the parameter channelId is nullptr
216 * @tc.type: FUNC
217 */
218 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetCurrentChannelIdNull_005, TestSize.Level1)
219 {
220 int32_t ret = -1;
221 uint32_t *channelIdNull = nullptr;
222 ASSERT_NE(nullptr, capture);
223 ret = capture->GetCurrentChannelId(capture, channelIdNull);
224 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
225 }
226 /**
227 * @tc.name AudioCaptureSetExtraParams_001
228 * @tc.desc Test CaptureSetExtraParams interface,return 0 if the ExtraParams is set during playback
229 * @tc.type: FUNC
230 */
231 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_001, TestSize.Level1)
232 {
233 int32_t ret = -1;
234 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
235 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
236 size_t index = 1;
237 char keyValueListValue[256] = {};
238 int32_t listLenth = 256;
239 uint64_t FILESIZE = 1024;
240 ASSERT_NE(nullptr, capture);
241 struct PrepareAudioPara audiopara = {
242 .capture = capture, .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
243 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
244 };
245
246 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
247 ASSERT_EQ(HDF_SUCCESS, ret);
248 sleep(1);
249 if (audiopara.capture != nullptr) {
250 ret = audiopara.capture->SetExtraParams(audiopara.capture, keyValueList);
251 if (ret == HDF_SUCCESS) {
252 EXPECT_EQ(HDF_SUCCESS, ret);
253 ret = audiopara.capture->GetExtraParams(audiopara.capture, keyValueListValue, listLenth);
254 EXPECT_EQ(HDF_SUCCESS, ret);
255 string strGetValue = keyValueListValue;
256 size_t indexAttr = strGetValue.find("attr-frame-count");
257 size_t indexFlag = strGetValue.rfind(";");
258 if (indexAttr != string::npos && indexFlag != string::npos) {
259 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
260 }
261 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
262 }
263 }
264
265 ret = ThreadRelease(audiopara);
266 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
267 }
268 /**
269 * @tc.name AudioCaptureSetExtraParams_002
270 * @tc.desc Test CaptureSetExtraParams interface,return 0 if some parameters is set after playing
271 * @tc.type: FUNC
272 */
273 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_002, TestSize.Level1)
274 {
275 int32_t ret = -1;
276 char keyValueListOne[] = "attr-frame-count=4096;";
277 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
278 attr-sampling-rate=48000";
279 char keyValueListTwo[] = "attr-route=1;attr-frame-count=1024;";
280 char keyValueListTwoExp[] = "attr-route=1;attr-format=16;attr-channels=2;attr-frame-count=1024;\
281 attr-sampling-rate=48000";
282 char keyValueListThr[] = "attr-route=0;attr-channels=1;attr-frame-count=4096;";
283 char keyValueListThrExp[] = "attr-route=0;attr-format=16;attr-channels=1;attr-frame-count=4096;\
284 attr-sampling-rate=48000";
285 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
286 char keyValueListFourExp[] = "attr-route=0;attr-format=32;attr-channels=2;attr-frame-count=4096;\
287 attr-sampling-rate=48000";
288 char keyValueListValueOne[256] = {};
289 char keyValueListValueTwo[256] = {};
290 char keyValueListValueThr[256] = {};
291 char keyValueListValueFour[256] = {};
292 int32_t listLenth = 256;
293
294 ASSERT_NE(nullptr, capture);
295 ret = AudioCaptureStartAndOneFrame(capture);
296 ASSERT_EQ(HDF_SUCCESS, ret);
297 ret = capture->SetExtraParams(capture, keyValueListOne);
298 if (ret == HDF_SUCCESS) {
299 ret = capture->GetExtraParams(capture, keyValueListValueOne, listLenth);
300 EXPECT_EQ(HDF_SUCCESS, ret);
301 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
302 }
303
304 ret = capture->SetExtraParams(capture, keyValueListTwo);
305 if (ret == HDF_SUCCESS) {
306 ret = capture->GetExtraParams(capture, keyValueListValueTwo, listLenth);
307 EXPECT_EQ(HDF_SUCCESS, ret);
308 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
309 }
310
311 ret = capture->SetExtraParams(capture, keyValueListThr);
312 if (ret == HDF_SUCCESS) {
313 ret = capture->GetExtraParams(capture, keyValueListValueThr, listLenth);
314 EXPECT_EQ(HDF_SUCCESS, ret);
315 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
316 }
317
318 ret = capture->SetExtraParams(capture, keyValueListFour);
319 if (ret == HDF_SUCCESS) {
320 ret = capture->GetExtraParams(capture, keyValueListValueFour, listLenth);
321 EXPECT_EQ(HDF_SUCCESS, ret);
322 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
323 }
324
325 ret = capture->Stop(capture);
326 EXPECT_EQ(HDF_SUCCESS, ret);
327 }
328 /**
329 * @tc.name AudioCaptureSetExtraParams_003
330 * @tc.desc Test CaptureSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range
331 * @tc.type: FUNC
332 */
333 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_003, TestSize.Level1)
334 {
335 int32_t ret = -1;
336 char keyValueList[] = "attr-para=abc;";
337 ASSERT_NE(nullptr, capture);
338 ret = ret = capture->SetExtraParams(capture, keyValueList);
339 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
340 }
341 /**
342 * @tc.name AudioCaptureSetExtraParams_004
343 * @tc.desc Test CaptureSetExtraParams interface,return -1 if adding parameters to keyvaluelist
344 * @tc.type: FUNC
345 */
346 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_004, TestSize.Level1)
347 {
348 int32_t ret = -1;
349 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;\
350 attr-frame-count=82;attr-sampling-rate=48000;attr-para=abc";
351 ASSERT_NE(nullptr, capture);
352 ret = capture->SetExtraParams(capture, keyValueList);
353 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
354 }
355 /**
356 * @tc.name AudioCaptureSetExtraParams_005
357 * @tc.desc Test CaptureSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value
358 is different
359 * @tc.type: FUNC
360 */
361 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_005, TestSize.Level1)
362 {
363 int32_t ret = -1;
364 char keyValueList[] = "attr-route=1;attr-format=32;attr-frame-count=4096;";
365 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
366 attr-sampling-rate=48000";
367 char keyValueListValue[256] = {};
368 int32_t listLenth = 256;
369 ASSERT_NE(nullptr, capture);
370 ret = AudioCaptureStartAndOneFrame(capture);
371 ASSERT_EQ(HDF_SUCCESS, ret);
372
373 ASSERT_EQ(HDF_SUCCESS, ret);
374 ASSERT_NE(nullptr, capture);
375 ret = capture->SetExtraParams(capture, keyValueList);
376 if (ret == HDF_SUCCESS) {
377 ret = capture->GetExtraParams(capture, keyValueListValue, listLenth);
378 EXPECT_EQ(HDF_SUCCESS, ret);
379 EXPECT_STREQ(keyValueListExp, keyValueListValue);
380 }
381
382 ret = capture->Stop(capture);
383 EXPECT_EQ(HDF_SUCCESS, ret);
384 }
385 /**
386 * @tc.name AudioCaptureSetExtraParams_006
387 * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the parameter in keyvaluelist as an abnormal value
388 * @tc.type: FUNC
389 */
390 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_006, TestSize.Level1)
391 {
392 int32_t ret = -1;
393 char attrSamplingRateError[] = "attr-sampling-rate=1234567;";
394 char attrChannelsError[] = "attr-channels=3;";
395 char attrFrameCountError[] = "attr-frame-count=111111111111111111111;";
396 char attrRouteError[] = "attr-route=5;";
397 char attrFormateError[] = "attr-formate=12;";
398 ASSERT_NE(nullptr, capture);
399 ret = capture->SetExtraParams(capture, attrSamplingRateError);
400 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
401 ret = capture->SetExtraParams(capture, attrChannelsError);
402 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
403 ret = capture->SetExtraParams(capture, attrFrameCountError);
404 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
405 ret = capture->SetExtraParams(capture, attrRouteError);
406 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
407 ret = capture->SetExtraParams(capture, attrFormateError);
408 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
409 }
410 /**
411 * @tc.name AudioCaptureSetExtraParamsNull_007
412 * @tc.desc Test CaptureSetExtraParams interface,return -3/-4 if set the parameter render is nullptr
413 * @tc.type: FUNC
414 */
415 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParamsNull_007, TestSize.Level1)
416 {
417 int32_t ret = -1;
418 struct IAudioCapture *captureNull = nullptr;
419 char keyValueList[] = "attr-format=2;";
420 ASSERT_NE(nullptr, capture);
421 ret = capture->SetExtraParams(captureNull, keyValueList);
422 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
423 }
424 /**
425 * @tc.name AudioCaptureSetExtraParamsNull_008
426 * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr
427 * @tc.type: FUNC
428 */
429 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParamsNull_008, TestSize.Level1)
430 {
431 int32_t ret = -1;
432 char keyValueListNull[] = "attr-format=;";
433 ASSERT_NE(nullptr, capture);
434 ret = capture->SetExtraParams(capture, keyValueListNull);
435 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
436 }
437 /**
438 * @tc.name AudioCaptureGetExtraParams_001
439 * @tc.desc Test CaptureGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
440 * @tc.type: FUNC
441 */
442 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetExtraParams_001, TestSize.Level1)
443 {
444 int32_t ret = -1;
445 uint64_t count = 0;
446 struct AudioSampleAttributes attrsValue = {};
447 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
448 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
449 attr-sampling-rate=48000";
450 char keyValueListValue[256] = {};
451 int32_t listLenth = 256;
452 int32_t formatExp = 3;
453 uint32_t channelCountExp = 2;
454 uint32_t sampleRateExp = 48000;
455 uint32_t frameCountExp = 4096;
456
457 ASSERT_NE(nullptr, capture);
458 ret = AudioCaptureStartAndOneFrame(capture);
459 ASSERT_EQ(HDF_SUCCESS, ret);
460 ret = capture->SetExtraParams(capture, keyValueList);
461 if (ret == HDF_SUCCESS) {
462 ret = capture->GetExtraParams(capture, keyValueListValue, listLenth);
463 EXPECT_EQ(HDF_SUCCESS, ret);
464 EXPECT_STREQ(keyValueListExp, keyValueListValue);
465
466 ret = capture->GetSampleAttributes(capture, &attrsValue);
467 EXPECT_EQ(HDF_SUCCESS, ret);
468 EXPECT_EQ(formatExp, attrsValue.format);
469 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
470 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
471 ret = capture->GetFrameCount(capture, &count);
472 EXPECT_EQ(HDF_SUCCESS, ret);
473 EXPECT_EQ(count, frameCountExp);
474 }
475
476 ret = capture->Stop(capture);
477 EXPECT_EQ(HDF_SUCCESS, ret);
478 }
479 /**
480 * @tc.name AudioCaptureGetExtraParamsNull_002
481 * @tc.desc Test CaptureGetExtraParams interface,return -3/-4 if set the parameter render is nullptr
482 * @tc.type: FUNC
483 */
484 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetExtraParamsNull_002, TestSize.Level1)
485 {
486 int32_t ret = -1;
487 struct IAudioCapture *captureNull = nullptr;
488 char keyValueList[] = "attr-format=32;";
489 char keyValueListValue[256] = {};
490 int32_t listLenth = 256;
491
492 ASSERT_NE(nullptr, capture);
493 ret = capture->SetExtraParams(capture, keyValueList);
494 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
495 ret = capture->GetExtraParams(captureNull, keyValueListValue, listLenth);
496 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
497 }
498 /**
499 * @tc.name AudioCaptureGetExtraParams_003
500 * @tc.desc Test CaptureGetExtraParams interface,return -1 if set listlength to be less than the actual length
501 * @tc.type: FUNC
502 */
503 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetExtraParams_003, TestSize.Level1)
504 {
505 int32_t ret = -1;
506 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;\
507 attr-frame-count=82;attr-sampling-rate=48000;";
508 char keyValueListValue[256] = {};
509 int32_t listLenth = 8;
510 ASSERT_NE(nullptr, capture);
511 ret = capture->SetExtraParams(capture, keyValueList);
512 if (ret == HDF_SUCCESS) {
513 ret = capture->GetExtraParams(capture, keyValueListValue, listLenth);
514 EXPECT_EQ(HDF_FAILURE, ret);
515 }
516 }
517 /**
518 * @tc.name AudioCaptureGetExtraParams_004
519 * @tc.desc Test CaptureGetExtraParams interface,return 0 if set listlenth equal to the actual length
520 * @tc.type: FUNC
521 */
522 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetExtraParams_004, TestSize.Level1)
523 {
524 int32_t ret = -1;
525 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\
526 attr-sampling-rate=48000";
527 char keyValueListValue[256] = {};
528 int32_t listLenth = 107;
529
530 ASSERT_NE(nullptr, capture);
531 ret = AudioCaptureStartAndOneFrame(capture);
532 ASSERT_EQ(HDF_SUCCESS, ret);
533 ret = capture->SetExtraParams(capture, keyValueList);
534 if (ret == HDF_SUCCESS) {
535 ret = capture->GetExtraParams(capture, keyValueListValue, listLenth);
536 EXPECT_EQ(HDF_SUCCESS, ret);
537 EXPECT_STREQ(keyValueList, keyValueListValue);
538 }
539
540 ret = capture->Stop(capture);
541 EXPECT_EQ(HDF_SUCCESS, ret);
542 }
543 /**
544 * @tc.name AudioCaptureSetSampleAttributesNull_007
545 * @tc.desc Test AudioCaptureSetSampleAttributes interface, return -3/-4 if the capture is nullptr.
546 * @tc.type: FUNC
547 */
548 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetSampleAttributesNull_007, TestSize.Level1)
549 {
550 int32_t ret;
551 struct AudioSampleAttributes attrs = {};
552 struct IAudioCapture *captureNull = nullptr;
553 ASSERT_NE(nullptr, capture);
554 InitAttrsUpdate(attrs, AUDIO_FORMAT_TYPE_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000);
555 ret = capture->SetSampleAttributes(captureNull, &attrs);
556 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
557 ret = capture->SetSampleAttributes(capture, nullptr);
558 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
559 }
560 /**
561 * @tc.name AudioCaptureGetSampleAttributesNull_002
562 * @tc.desc Test AudioCaptureGetSampleAttributes interface, return -3/-4 if the capture is nullptr.
563 * @tc.type: FUNC
564 */
565 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetSampleAttributesNull_002, TestSize.Level1)
566 {
567 int32_t ret;
568 struct AudioSampleAttributes attrs = {};
569 struct IAudioCapture *captureNull = nullptr;
570 ASSERT_NE(nullptr, capture);
571 InitAttrsUpdate(attrs, AUDIO_FORMAT_TYPE_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_48000);
572 ret = capture->GetSampleAttributes(captureNull, &attrs);
573 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
574 ret = capture->GetSampleAttributes(capture, nullptr);
575 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
576 }
577 }
578