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 "hdf_remote_adapter_if.h"
18 #include "hdi_service_common.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS::Audio;
23
24 namespace {
25 class AudioIdlHdiCaptureAttrTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31 struct IAudioAdapter *adapter = nullptr;
32 struct IAudioCapture *capture = nullptr;
33 static TestAudioManager *manager;
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);
56 ASSERT_EQ(HDF_SUCCESS, ret);
57 }
58
TearDown(void)59 void AudioIdlHdiCaptureAttrTest::TearDown(void)
60 {
61 int32_t ret = ReleaseCaptureSource(manager, adapter, capture);
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 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
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_EQ(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 EXPECT_EQ(HDF_SUCCESS, ret);
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 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
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 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
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 EXPECT_EQ(HDF_SUCCESS, ret);
252 ret = audiopara.capture->GetExtraParams(audiopara.capture, keyValueListValue, listLenth);
253 EXPECT_EQ(HDF_SUCCESS, ret);
254 string strGetValue = keyValueListValue;
255 size_t indexAttr = strGetValue.find("attr-frame-count");
256 size_t indexFlag = strGetValue.rfind(";");
257 if (indexAttr != string::npos && indexFlag != string::npos) {
258 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
259 }
260 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
261 }
262
263 ret = ThreadRelease(audiopara);
264 EXPECT_EQ(HDF_SUCCESS, ret);
265 }
266 /**
267 * @tc.name AudioCaptureSetExtraParams_002
268 * @tc.desc Test CaptureSetExtraParams interface,return 0 if some parameters is set after playing
269 * @tc.type: FUNC
270 */
271 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_002, TestSize.Level1)
272 {
273 int32_t ret = -1;
274 char keyValueListOne[] = "attr-frame-count=4096;";
275 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
276 attr-sampling-rate=48000";
277 char keyValueListTwo[] = "attr-route=1;attr-frame-count=1024;";
278 char keyValueListTwoExp[] = "attr-route=1;attr-format=16;attr-channels=2;attr-frame-count=1024;\
279 attr-sampling-rate=48000";
280 char keyValueListThr[] = "attr-route=0;attr-channels=1;attr-frame-count=4096;";
281 char keyValueListThrExp[] = "attr-route=0;attr-format=16;attr-channels=1;attr-frame-count=4096;\
282 attr-sampling-rate=48000";
283 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
284 char keyValueListFourExp[] = "attr-route=0;attr-format=32;attr-channels=2;attr-frame-count=4096;\
285 attr-sampling-rate=48000";
286 char keyValueListValueOne[256] = {};
287 char keyValueListValueTwo[256] = {};
288 char keyValueListValueThr[256] = {};
289 char keyValueListValueFour[256] = {};
290 int32_t listLenth = 256;
291
292 ASSERT_NE(nullptr, capture);
293 ret = AudioCaptureStartAndOneFrame(capture);
294 ASSERT_EQ(HDF_SUCCESS, ret);
295 ret = capture->SetExtraParams(capture, keyValueListOne);
296 EXPECT_EQ(HDF_SUCCESS, ret);
297 ret = capture->GetExtraParams(capture, keyValueListValueOne, listLenth);
298 EXPECT_EQ(HDF_SUCCESS, ret);
299 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
300 ret = capture->SetExtraParams(capture, keyValueListTwo);
301 EXPECT_EQ(HDF_SUCCESS, ret);
302 ret = capture->GetExtraParams(capture, keyValueListValueTwo, listLenth);
303 EXPECT_EQ(HDF_SUCCESS, ret);
304 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
305 ret = capture->SetExtraParams(capture, keyValueListThr);
306 EXPECT_EQ(HDF_SUCCESS, ret);
307 ret = capture->GetExtraParams(capture, keyValueListValueThr, listLenth);
308 EXPECT_EQ(HDF_SUCCESS, ret);
309 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
310 ret = capture->SetExtraParams(capture, keyValueListFour);
311 EXPECT_EQ(HDF_SUCCESS, ret);
312 ret = capture->GetExtraParams(capture, keyValueListValueFour, listLenth);
313 EXPECT_EQ(HDF_SUCCESS, ret);
314 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
315
316 ret = capture->Stop(capture);
317 EXPECT_EQ(HDF_SUCCESS, ret);
318 }
319 /**
320 * @tc.name AudioCaptureSetExtraParams_003
321 * @tc.desc Test CaptureSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range
322 * @tc.type: FUNC
323 */
324 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_003, TestSize.Level1)
325 {
326 int32_t ret = -1;
327 char keyValueList[] = "attr-para=abc;";
328 ASSERT_NE(nullptr, capture);
329 ret = ret = capture->SetExtraParams(capture, keyValueList);
330 EXPECT_EQ(HDF_FAILURE, ret);
331 }
332 /**
333 * @tc.name AudioCaptureSetExtraParams_004
334 * @tc.desc Test CaptureSetExtraParams interface,return -1 if adding parameters to keyvaluelist
335 * @tc.type: FUNC
336 */
337 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_004, TestSize.Level1)
338 {
339 int32_t ret = -1;
340 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;\
341 attr-frame-count=82;attr-sampling-rate=48000;attr-para=abc";
342 ASSERT_NE(nullptr, capture);
343 ret = capture->SetExtraParams(capture, keyValueList);
344 EXPECT_EQ(HDF_FAILURE, ret);
345 }
346 /**
347 * @tc.name AudioCaptureSetExtraParams_005
348 * @tc.desc Test CaptureSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value
349 is different
350 * @tc.type: FUNC
351 */
352 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_005, TestSize.Level1)
353 {
354 int32_t ret = -1;
355 char keyValueList[] = "attr-route=1;attr-format=32;attr-frame-count=4096;";
356 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
357 attr-sampling-rate=48000";
358 char keyValueListValue[256] = {};
359 int32_t listLenth = 256;
360 ASSERT_NE(nullptr, capture);
361 ret = AudioCaptureStartAndOneFrame(capture);
362 ASSERT_EQ(HDF_SUCCESS, ret);
363
364 ASSERT_EQ(HDF_SUCCESS, ret);
365 ASSERT_NE(nullptr, capture);
366 ret = capture->SetExtraParams(capture, keyValueList);
367 EXPECT_EQ(HDF_SUCCESS, ret);
368 ret = capture->GetExtraParams(capture, keyValueListValue, listLenth);
369 EXPECT_EQ(HDF_SUCCESS, ret);
370 EXPECT_STREQ(keyValueListExp, keyValueListValue);
371 ret = capture->Stop(capture);
372 EXPECT_EQ(HDF_SUCCESS, ret);
373 }
374 /**
375 * @tc.name AudioCaptureSetExtraParams_006
376 * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the parameter in keyvaluelist as an abnormal value
377 * @tc.type: FUNC
378 */
379 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParams_006, TestSize.Level1)
380 {
381 int32_t ret = -1;
382 char attrSamplingRateError[] = "attr-sampling-rate=1234567;";
383 char attrChannelsError[] = "attr-channels=3;";
384 char attrFrameCountError[] = "attr-frame-count=111111111111111111111;";
385 char attrRouteError[] = "attr-route=5;";
386 char attrFormateError[] = "attr-formate=12;";
387 ASSERT_NE(nullptr, capture);
388 ret = capture->SetExtraParams(capture, attrSamplingRateError);
389 EXPECT_EQ(HDF_FAILURE, ret);
390 ret = capture->SetExtraParams(capture, attrChannelsError);
391 EXPECT_EQ(HDF_FAILURE, ret);
392 ret = capture->SetExtraParams(capture, attrFrameCountError);
393 EXPECT_EQ(HDF_FAILURE, ret);
394 ret = capture->SetExtraParams(capture, attrRouteError);
395 EXPECT_EQ(HDF_FAILURE, ret);
396 ret = capture->SetExtraParams(capture, attrFormateError);
397 EXPECT_EQ(HDF_FAILURE, ret);
398 }
399 /**
400 * @tc.name AudioCaptureSetExtraParamsNull_007
401 * @tc.desc Test CaptureSetExtraParams interface,return -3/-4 if set the parameter render is nullptr
402 * @tc.type: FUNC
403 */
404 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParamsNull_007, TestSize.Level1)
405 {
406 int32_t ret = -1;
407 struct IAudioCapture *captureNull = nullptr;
408 char keyValueList[] = "attr-format=2;";
409 ASSERT_NE(nullptr, capture);
410 ret = capture->SetExtraParams(captureNull, keyValueList);
411 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
412 }
413 /**
414 * @tc.name AudioCaptureSetExtraParamsNull_008
415 * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr
416 * @tc.type: FUNC
417 */
418 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetExtraParamsNull_008, TestSize.Level1)
419 {
420 int32_t ret = -1;
421 char keyValueListNull[] = "attr-format=;";
422 ASSERT_NE(nullptr, capture);
423 ret = capture->SetExtraParams(capture, keyValueListNull);
424 EXPECT_EQ(HDF_FAILURE, ret);
425 }
426 /**
427 * @tc.name AudioCaptureGetExtraParams_001
428 * @tc.desc Test CaptureGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
429 * @tc.type: FUNC
430 */
431 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetExtraParams_001, TestSize.Level1)
432 {
433 int32_t ret = -1;
434 uint64_t count = 0;
435 struct AudioSampleAttributes attrsValue = {};
436 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
437 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
438 attr-sampling-rate=48000";
439 char keyValueListValue[256] = {};
440 int32_t listLenth = 256;
441 int32_t formatExp = 3;
442 uint32_t channelCountExp = 2;
443 uint32_t sampleRateExp = 48000;
444 uint32_t frameCountExp = 4096;
445
446 ASSERT_NE(nullptr, capture);
447 ret = AudioCaptureStartAndOneFrame(capture);
448 ASSERT_EQ(HDF_SUCCESS, ret);
449 ret = capture->SetExtraParams(capture, keyValueList);
450 EXPECT_EQ(HDF_SUCCESS, ret);
451 ret = capture->GetExtraParams(capture, keyValueListValue, listLenth);
452 EXPECT_EQ(HDF_SUCCESS, ret);
453 EXPECT_STREQ(keyValueListExp, keyValueListValue);
454
455 ret = capture->GetSampleAttributes(capture, &attrsValue);
456 EXPECT_EQ(HDF_SUCCESS, ret);
457 EXPECT_EQ(formatExp, attrsValue.format);
458 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
459 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
460 ret = capture->GetFrameCount(capture, &count);
461 EXPECT_EQ(HDF_SUCCESS, ret);
462 EXPECT_EQ(count, frameCountExp);
463
464 ret = capture->Stop(capture);
465 EXPECT_EQ(HDF_SUCCESS, ret);
466 }
467 /**
468 * @tc.name AudioCaptureGetExtraParamsNull_002
469 * @tc.desc Test CaptureGetExtraParams interface,return -3/-4 if set the parameter render is nullptr
470 * @tc.type: FUNC
471 */
472 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetExtraParamsNull_002, TestSize.Level1)
473 {
474 int32_t ret = -1;
475 struct IAudioCapture *captureNull = nullptr;
476 char keyValueList[] = "attr-format=32;";
477 char keyValueListValue[256] = {};
478 int32_t listLenth = 256;
479
480 ASSERT_NE(nullptr, capture);
481 ret = capture->SetExtraParams(capture, keyValueList);
482 EXPECT_EQ(HDF_SUCCESS, ret);
483 ret = capture->GetExtraParams(captureNull, keyValueListValue, listLenth);
484 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
485 }
486 /**
487 * @tc.name AudioCaptureGetExtraParams_003
488 * @tc.desc Test CaptureGetExtraParams interface,return -1 if set listlength to be less than the actual length
489 * @tc.type: FUNC
490 */
491 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetExtraParams_003, TestSize.Level1)
492 {
493 int32_t ret = -1;
494 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;\
495 attr-frame-count=82;attr-sampling-rate=48000;";
496 char keyValueListValue[256] = {};
497 int32_t listLenth = 8;
498 ASSERT_NE(nullptr, capture);
499 ret = capture->SetExtraParams(capture, keyValueList);
500 EXPECT_EQ(HDF_SUCCESS, ret);
501 ret = capture->GetExtraParams(capture, keyValueListValue, listLenth);
502 EXPECT_EQ(HDF_FAILURE, ret);
503 }
504 /**
505 * @tc.name AudioCaptureGetExtraParams_004
506 * @tc.desc Test CaptureGetExtraParams interface,return 0 if set listlenth equal to the actual length
507 * @tc.type: FUNC
508 */
509 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetExtraParams_004, TestSize.Level1)
510 {
511 int32_t ret = -1;
512 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\
513 attr-sampling-rate=48000";
514 char keyValueListValue[256] = {};
515 int32_t listLenth = 107;
516
517 ASSERT_NE(nullptr, capture);
518 ret = AudioCaptureStartAndOneFrame(capture);
519 ASSERT_EQ(HDF_SUCCESS, ret);
520 ret = capture->SetExtraParams(capture, keyValueList);
521 EXPECT_EQ(HDF_SUCCESS, ret);
522 ret = capture->GetExtraParams(capture, keyValueListValue, listLenth);
523 EXPECT_EQ(HDF_SUCCESS, ret);
524 EXPECT_STREQ(keyValueList, keyValueListValue);
525
526 ret = capture->Stop(capture);
527 EXPECT_EQ(HDF_SUCCESS, ret);
528 }
529 /**
530 * @tc.name AudioCaptureSetSampleAttributesNull_007
531 * @tc.desc Test AudioCaptureSetSampleAttributes interface, return -3/-4 if the capture is nullptr.
532 * @tc.type: FUNC
533 */
534 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureSetSampleAttributesNull_007, TestSize.Level1)
535 {
536 int32_t ret;
537 struct AudioSampleAttributes attrs = {};
538 struct IAudioCapture *captureNull = nullptr;
539 ASSERT_NE(nullptr, capture);
540 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000);
541 ret = capture->SetSampleAttributes(captureNull, &attrs);
542 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
543 ret = capture->SetSampleAttributes(capture, nullptr);
544 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
545 }
546 /**
547 * @tc.name AudioCaptureGetSampleAttributesNull_002
548 * @tc.desc Test AudioCaptureGetSampleAttributes interface, return -3/-4 if the capture is nullptr.
549 * @tc.type: FUNC
550 */
551 HWTEST_F(AudioIdlHdiCaptureAttrTest, AudioCaptureGetSampleAttributesNull_002, TestSize.Level1)
552 {
553 int32_t ret;
554 struct AudioSampleAttributes attrs = {};
555 struct IAudioCapture *captureNull = nullptr;
556 ASSERT_NE(nullptr, capture);
557 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_48000);
558 ret = capture->GetSampleAttributes(captureNull, &attrs);
559 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
560 ret = capture->GetSampleAttributes(capture, nullptr);
561 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
562 }
563 }
564