1 /*
2 * Copyright (c) 2021 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 "audio_hdi_common.h"
17 #include <pthread.h>
18 #include "audio_hdicapture_reliability_test.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS::Audio;
23
24 namespace {
25 const int PTHREAD_SAMEADA_COUNT = 3;
26 const int PTHREAD_DIFFADA_COUNT = 3;
27 const uint32_t SAMPLERATEVALUE = 48000;
28 mutex g_testMutex;
29 struct PrepareAudioPara g_para[PTHREAD_DIFFADA_COUNT] = {
30 {
31 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
32 .path = AUDIO_CAPTURE_FILE.c_str()
33 }
34 };
35
36 class AudioHdiCaptureReliabilityTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 static TestAudioManager *manager;
43 static int32_t RelAudioCaptureSetMute(struct PrepareAudioPara& ptr);
44 static int32_t RelAudioCaptureGetMute(struct PrepareAudioPara& ptr);
45 static int32_t RelAudioCaptureSetVolume(struct PrepareAudioPara& ptr);
46 static int32_t RelAudioCaptureGetVolume(struct PrepareAudioPara& ptr);
47 static int32_t RelAudioCaptureProcedure(struct PrepareAudioPara& ptr);
48 static int32_t RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr);
49 static int32_t RelAudioCaptureSetGain(struct PrepareAudioPara& ptr);
50 static int32_t RelAudioCaptureGetGain(struct PrepareAudioPara& ptr);
51 static int32_t RelAudioCaptureGetGainThreshold(struct PrepareAudioPara& ptr);
52 static int32_t RelAudioCaptureGetFrameSize(struct PrepareAudioPara& ptr);
53 static int32_t RelAudioCaptureGetFrameCount(struct PrepareAudioPara& ptr);
54 static int32_t RelAudioCaptureGetCurrentChannelId(struct PrepareAudioPara& ptr);
55 static int32_t RelAudioCaptureSetSampleAttributes(struct PrepareAudioPara& ptr);
56 static int32_t RelAudioCaptureGetSampleAttributes(struct PrepareAudioPara& ptr);
57 static int32_t RelAudioCaptureSelectScene(struct PrepareAudioPara& ptr);
58 static int32_t RelAudioCaptureCheckSceneCapability(struct PrepareAudioPara& ptr);
59 AudioCapture *capture = nullptr;
60 AudioAdapter *adapter = nullptr;
61 };
62
63 using THREAD_FUNC = void *(*)(void *);
64 TestAudioManager *AudioHdiCaptureReliabilityTest::manager = nullptr;
65
SetUpTestCase(void)66 void AudioHdiCaptureReliabilityTest::SetUpTestCase(void)
67 {
68 manager = GetAudioManagerFuncs();
69 ASSERT_NE(nullptr, manager);
70 }
71
TearDownTestCase(void)72 void AudioHdiCaptureReliabilityTest::TearDownTestCase(void) {}
73
SetUp(void)74 void AudioHdiCaptureReliabilityTest::SetUp(void)
75 {
76 ASSERT_NE(nullptr, manager);
77 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
78 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
79 }
80
TearDown(void)81 void AudioHdiCaptureReliabilityTest::TearDown(void)
82 {
83 int32_t ret = ReleaseCaptureSource(manager, adapter, capture);
84 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
85 }
86
RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara & ptr)87 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr)
88 {
89 int32_t ret = -1;
90 struct AudioSampleAttributes attrs = {};
91 FILE *file = fopen(ptr.path, "wb+");
92 if (file == nullptr) {
93 return AUDIO_HAL_ERR_INTERNAL;
94 }
95 InitAttrs(attrs);
96
97 g_testMutex.lock();
98 ret = FrameStartCapture(ptr.capture, file, attrs);
99 g_testMutex.unlock();
100 (void)fclose(file);
101 return ret;
102 }
103
RelAudioCaptureSetMute(struct PrepareAudioPara & ptr)104 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetMute(struct PrepareAudioPara& ptr)
105 {
106 if (ptr.capture == nullptr) {
107 return AUDIO_HAL_ERR_INVALID_PARAM;
108 }
109 int32_t ret = -1;
110 g_testMutex.lock();
111 ret = ptr.capture->volume.SetMute(ptr.capture, ptr.character.setmute);
112 g_testMutex.unlock();
113 return ret;
114 }
115
RelAudioCaptureGetMute(struct PrepareAudioPara & ptr)116 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetMute(struct PrepareAudioPara& ptr)
117 {
118 if (ptr.capture == nullptr) {
119 return AUDIO_HAL_ERR_INVALID_PARAM;
120 }
121 int32_t ret = -1;
122 g_testMutex.lock();
123 ret = ptr.capture->volume.GetMute(ptr.capture, &(ptr.character.getmute));
124 g_testMutex.unlock();
125 return ret;
126 }
127
RelAudioCaptureSetVolume(struct PrepareAudioPara & ptr)128 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetVolume(struct PrepareAudioPara& ptr)
129 {
130 if (ptr.capture == nullptr) {
131 return AUDIO_HAL_ERR_INVALID_PARAM;
132 }
133 int32_t ret = -1;
134 g_testMutex.lock();
135 ret = ptr.capture->volume.SetVolume(ptr.capture, ptr.character.setvolume);
136 g_testMutex.unlock();
137 return ret;
138 }
139
RelAudioCaptureGetVolume(struct PrepareAudioPara & ptr)140 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetVolume(struct PrepareAudioPara& ptr)
141 {
142 if (ptr.capture == nullptr) {
143 return AUDIO_HAL_ERR_INVALID_PARAM;
144 }
145 int32_t ret = -1;
146 g_testMutex.lock();
147 ret = ptr.capture->volume.GetVolume(ptr.capture, &(ptr.character.getvolume));
148 g_testMutex.unlock();
149 return ret;
150 }
151
RelAudioCaptureGetGainThreshold(struct PrepareAudioPara & ptr)152 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGainThreshold(struct PrepareAudioPara& ptr)
153 {
154 if (ptr.capture == nullptr) {
155 return AUDIO_HAL_ERR_INVALID_PARAM;
156 }
157 int32_t ret = -1;
158 g_testMutex.lock();
159 ret = ptr.capture->volume.GetGainThreshold(ptr.capture, &(ptr.character.gainthresholdmin),
160 &(ptr.character.gainthresholdmax));
161 g_testMutex.unlock();
162 return ret;
163 }
164
RelAudioCaptureSetGain(struct PrepareAudioPara & ptr)165 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetGain(struct PrepareAudioPara& ptr)
166 {
167 if (ptr.capture == nullptr) {
168 return AUDIO_HAL_ERR_INVALID_PARAM;
169 }
170 int32_t ret = -1;
171 g_testMutex.lock();
172 ret = ptr.capture->volume.SetGain(ptr.capture, ptr.character.setgain);
173 g_testMutex.unlock();
174 return ret;
175 }
176
RelAudioCaptureGetGain(struct PrepareAudioPara & ptr)177 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGain(struct PrepareAudioPara& ptr)
178 {
179 if (ptr.capture == nullptr) {
180 return AUDIO_HAL_ERR_INVALID_PARAM;
181 }
182 int32_t ret = -1;
183 g_testMutex.lock();
184 ret = ptr.capture->volume.GetGain(ptr.capture, &(ptr.character.getgain));
185 g_testMutex.unlock();
186 return ret;
187 }
188
RelAudioCaptureGetFrameSize(struct PrepareAudioPara & ptr)189 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameSize(struct PrepareAudioPara& ptr)
190 {
191 if (ptr.capture == nullptr) {
192 return AUDIO_HAL_ERR_INVALID_PARAM;
193 }
194 int32_t ret = -1;
195 g_testMutex.lock();
196 ret = ptr.capture->attr.GetFrameSize(ptr.capture, &(ptr.character.getframesize));
197 g_testMutex.unlock();
198 return ret;
199 }
200
RelAudioCaptureGetFrameCount(struct PrepareAudioPara & ptr)201 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameCount(struct PrepareAudioPara& ptr)
202 {
203 if (ptr.capture == nullptr) {
204 return AUDIO_HAL_ERR_INVALID_PARAM;
205 }
206 int32_t ret = -1;
207 g_testMutex.lock();
208 ret = ptr.capture->attr.GetFrameCount(ptr.capture, &(ptr.character.getframecount));
209 g_testMutex.unlock();
210 return ret;
211 }
212
RelAudioCaptureGetCurrentChannelId(struct PrepareAudioPara & ptr)213 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetCurrentChannelId(struct PrepareAudioPara& ptr)
214 {
215 if (ptr.capture == nullptr) {
216 return AUDIO_HAL_ERR_INVALID_PARAM;
217 }
218 int32_t ret = -1;
219 g_testMutex.lock();
220 ret = ptr.capture->attr.GetCurrentChannelId(ptr.capture, &(ptr.character.getcurrentchannelId));
221 g_testMutex.unlock();
222 return ret;
223 }
224
RelAudioCaptureSetSampleAttributes(struct PrepareAudioPara & ptr)225 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetSampleAttributes(struct PrepareAudioPara& ptr)
226 {
227 if (ptr.capture == nullptr) {
228 return AUDIO_HAL_ERR_INVALID_PARAM;
229 }
230 int32_t ret = -1;
231 g_testMutex.lock();
232 ret = ptr.capture->attr.SetSampleAttributes(ptr.capture, &(ptr.attrs));
233 g_testMutex.unlock();
234 return ret;
235 }
236
RelAudioCaptureGetSampleAttributes(struct PrepareAudioPara & ptr)237 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetSampleAttributes(struct PrepareAudioPara& ptr)
238 {
239 if (ptr.capture == nullptr) {
240 return AUDIO_HAL_ERR_INVALID_PARAM;
241 }
242 int32_t ret = -1;
243 g_testMutex.lock();
244 ret = ptr.capture->attr.GetSampleAttributes(ptr.capture, &(ptr.attrsValue));
245 g_testMutex.unlock();
246 return ret;
247 }
248
RelAudioCaptureSelectScene(struct PrepareAudioPara & ptr)249 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSelectScene(struct PrepareAudioPara& ptr)
250 {
251 if (ptr.capture == nullptr) {
252 return AUDIO_HAL_ERR_INVALID_PARAM;
253 }
254 int32_t ret = -1;
255 g_testMutex.lock();
256 ret = ptr.capture->scene.SelectScene(ptr.capture, &(ptr.scenes));
257 g_testMutex.unlock();
258 return ret;
259 }
260
RelAudioCaptureCheckSceneCapability(struct PrepareAudioPara & ptr)261 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureCheckSceneCapability(struct PrepareAudioPara& ptr)
262 {
263 if (ptr.capture == nullptr) {
264 return AUDIO_HAL_ERR_INVALID_PARAM;
265 }
266 int32_t ret = -1;
267 g_testMutex.lock();
268 ret = ptr.capture->scene.CheckSceneCapability(ptr.capture, &ptr.scenes, &(ptr.character.supported));
269 g_testMutex.unlock();
270 return ret;
271 }
272
273 /**
274 * @tc.name AudioCaptureSetGainReliability_001
275 * @tc.desc test AudioCaptureSetGain interface Reliability pass through pthread_create fun and adapterName is same.
276 * @tc.type: RELI
277 */
278 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureSetGainReliability_001, TestSize.Level1)
279 {
280 int32_t ret = -1;
281 g_para[0].capture = capture;
282 ASSERT_NE(nullptr, g_para[0].capture);
283 pthread_t tids[PTHREAD_SAMEADA_COUNT];
284 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
285 g_para[0].character.setgain = 2;
286 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetGain, &g_para[0]);
287 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
288 }
289
290 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
291 void *result = nullptr;
292 pthread_join(tids[i], &result);
293 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
294 ret = g_para[0].capture->volume.GetGain(g_para[0].capture, &(g_para[0].character.getgain));
295 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
296 EXPECT_EQ(g_para[0].character.setgain, g_para[0].character.getgain);
297 }
298 }
299
300 /**
301 * @tc.name AudioCaptureGetGainReliability_001
302 * @tc.desc test AudioCaptureGetGain interface Reliability pass through pthread_create fun and adapterName is same.
303 * @tc.type: RELI
304 */
305 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureGetGainReliability_001, TestSize.Level1)
306 {
307 int32_t ret = -1;
308 g_para[0].capture = capture;
309 ASSERT_NE(nullptr, g_para[0].capture);
310
311 pthread_t tids[PTHREAD_SAMEADA_COUNT];
312 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
313 g_para[0].character.setgain = 8;
314 ret = g_para[0].capture->volume.SetGain(g_para[0].capture, g_para[0].character.setgain);
315 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
316 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGain, &g_para[0]);
317 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
318 }
319
320 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
321 void *result = nullptr;
322 pthread_join(tids[i], &result);
323 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
324 EXPECT_EQ(8, g_para[0].character.getgain);
325 }
326 }
327
328 /**
329 * @tc.name AudioCaptureGetGainThresholdReliability_001
330 * @tc.desc test GetGainThreshold interface Reliability pass through pthread_create fun and adapterName is same.
331 * @tc.type: RELI
332 */
333 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureGetGainThresholdReliability_001, TestSize.Level1)
334 {
335 int32_t ret = -1;
336 g_para[0].capture = capture;
337 ASSERT_NE(nullptr, g_para[0].capture);
338
339 pthread_t tids[PTHREAD_SAMEADA_COUNT];
340 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
341 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGainThreshold, &g_para[0]);
342 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
343 }
344
345 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
346 void *result = nullptr;
347 pthread_join(tids[i], &result);
348 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
349 EXPECT_EQ(0, g_para[0].character.gainthresholdmin);
350 EXPECT_EQ(15, g_para[0].character.gainthresholdmax);
351 }
352 }
353
354 /**
355 * @tc.name AudioCaptureGetFrameSizeReliability_001
356 * @tc.desc test AudioCaptureGetFrameSize interface Reliability pass through pthread_create fun and adapterName is same
357 * @tc.type: RELI
358 */
359 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureGetFrameSizeReliability_001, TestSize.Level1)
360 {
361 int32_t ret = -1;
362 uint64_t sizeValue = 4096;
363 g_para[0].capture = capture;
364 ASSERT_NE(nullptr, g_para[0].capture);
365
366 pthread_t tids[PTHREAD_SAMEADA_COUNT];
367 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
368 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameSize, &g_para[0]);
369 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
370 }
371
372 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
373 void *result = nullptr;
374 pthread_join(tids[i], &result);
375 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
376 EXPECT_EQ(sizeValue, g_para[0].character.getframesize);
377 }
378 }
379
380 /**
381 * @tc.name AudioCaptureGetFrameCountReliability_001
382 * @tc.desc test CaptureGetFrameCount interface Reliability pass through pthread_create fun and adapterName is same
383 * @tc.type: RELI
384 */
385 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureGetFrameCountReliability_001, TestSize.Level1)
386 {
387 int32_t ret = -1;
388 g_para[0].capture = capture;
389 ASSERT_NE(nullptr, g_para[0].capture);
390
391 ret = AudioCaptureStartAndOneFrame(g_para[0].capture);
392 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
393
394 pthread_t tids[PTHREAD_SAMEADA_COUNT];
395 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
396 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameCount, &g_para[0]);
397 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
398 }
399
400 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
401 void *result = nullptr;
402 pthread_join(tids[i], &result);
403 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
404 EXPECT_LT(INITIAL_VALUE, g_para[0].character.getframecount);
405 }
406 ret = g_para[0].capture->control.Stop(g_para[0].capture);
407 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
408 }
409
410 /**
411 * @tc.name AudioGetCurrentChannelIdReliability_001
412 * @tc.desc test AudioGetCurrentChannelId interface Reliability pass through pthread_create fun and adapterName is same
413 * @tc.type: RELI
414 */
415 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioGetCurrentChannelIdReliability_001, TestSize.Level1)
416 {
417 int32_t ret = -1;
418 uint32_t channelIdValue = 2;
419 ASSERT_NE(nullptr, capture);
420
421 pthread_t tids[PTHREAD_SAMEADA_COUNT];
422 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
423 g_para[i].character.getcurrentchannelId = 0;
424 g_para[i].capture = capture;
425 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCurrentChannelId, &g_para[i]);
426 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
427 }
428
429 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
430 void *result = nullptr;
431 pthread_join(tids[i], &result);
432 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
433 EXPECT_EQ(channelIdValue, g_para[i].character.getcurrentchannelId);
434 }
435 }
436 /**
437 * @tc.name AudioCaptureSetMute_001
438 * @tc.desc test AudioCaptureSetMute interface Reliability pass through pthread_create(adapterName is same)
439 * @tc.type: RELI
440 */
441 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureSetMute_001, TestSize.Level1)
442 {
443 int32_t ret = -1;
444 g_para[0].capture = capture;
445 ASSERT_NE(nullptr, g_para[0].capture);
446
447 pthread_t tids[PTHREAD_SAMEADA_COUNT];
448 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
449 ret = g_para[0].capture->volume.GetMute(g_para[0].capture, &(g_para[0].character.getmute));
450 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
451 if (g_para[0].character.getmute == false) {
452 g_para[0].character.setmute = true;
453 } else {
454 g_para[0].character.setmute = false;
455 }
456 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetMute, &g_para[0]);
457 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
458 void *result = nullptr;
459 pthread_join(tids[i], &result);
460 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
461
462 ret = g_para[0].capture->volume.GetMute(g_para[0].capture, &(g_para[0].character.getmute));
463 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
464 if (g_para[0].character.setmute == true) {
465 EXPECT_TRUE(g_para[0].character.getmute);
466 } else {
467 EXPECT_FALSE(g_para[0].character.getmute);
468 }
469 }
470 }
471
472 /**
473 * @tc.name AudioRelAudioCaptureGetMute_001
474 * @tc.desc test RelAudioCaptureGetMute interface Reliability pass through pthread_create(adapterName is same)
475 * @tc.type: RELI
476 */
477 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureGetMute_001, TestSize.Level1)
478 {
479 int32_t ret = -1;
480 g_para[0].capture = capture;
481 ASSERT_NE(nullptr, g_para[0].capture);
482
483 pthread_t tids[PTHREAD_SAMEADA_COUNT];
484 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
485 g_para[0].character.setmute = true;
486 ret = g_para[0].capture->volume.SetMute(g_para[0].capture, false);
487 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
488 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetMute, &g_para[0]);
489 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
490 }
491
492 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
493 void *result = nullptr;
494 pthread_join(tids[i], &result);
495 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
496 EXPECT_FALSE(g_para[0].character.getmute);
497 }
498 }
499
500 /**
501 * @tc.name AudiocaptureSetVolumeReliability_001
502 * @tc.desc test SetVolume interface Reliability pass through pthread_create fun and adapterName is same.
503 * @tc.type: RELI
504 */
505 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureSetVolumeReliability_001, TestSize.Level1)
506 {
507 int32_t ret = -1;
508 float volumeHighExpc = 0.70;
509 ASSERT_NE(nullptr, capture);
510
511 pthread_t tids[PTHREAD_SAMEADA_COUNT];
512 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
513 g_para[i].capture = capture;
514 g_para[i].character.setvolume = 0.7;
515 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetVolume, &g_para[i]);
516 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
517 }
518
519 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
520 void *result = nullptr;
521 pthread_join(tids[i], &result);
522 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
523 ret = g_para[0].capture->volume.GetVolume(g_para[i].capture, &(g_para[i].character.getvolume));
524 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
525 EXPECT_EQ(volumeHighExpc, g_para[i].character.getvolume);
526 }
527 }
528
529 /**
530 * @tc.name AudioCaptureGetVolumeReliability_001
531 * @tc.desc test GetVolume interface Reliability pass through pthread_create fun and adapterName is same.
532 * @tc.type: RELI
533 */
534 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureGetVolumeReliability_001, TestSize.Level1)
535 {
536 int32_t ret = -1;
537 float volumeHighExpc = 0.7;
538 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
539
540 g_para[0].capture = capture;
541 ASSERT_NE(nullptr, g_para[0].capture);
542 pthread_t tids[PTHREAD_SAMEADA_COUNT];
543 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
544 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
545 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
546 arrpara[i].character.setvolume = 0.7;
547 ret = arrpara[i].capture->volume.SetVolume(arrpara[i].capture, arrpara[i].character.setvolume);
548 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
549 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetVolume, &arrpara[i]);
550 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
551 }
552
553 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
554 void *result = nullptr;
555 pthread_join(tids[i], &result);
556 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
557 EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume);
558 }
559 }
560
561 /**
562 * @tc.name AudioCaptureSetSampleAttributesReliability_001
563 * @tc.desc test SetSampleAttributes interface Reliability pass through pthread_create fun and adapterName
564 is same.
565 * @tc.type: RELI
566 */
567 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureSetSampleAttributesReliability_001,
568 TestSize.Level1)
569 {
570 uint32_t count = 2;
571 g_para[0].capture = capture;
572 ASSERT_NE(nullptr, g_para[0].capture);
573 InitAttrs(g_para[0].attrs);
574 pthread_t tids[PTHREAD_SAMEADA_COUNT];
575 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
576
577 int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetSampleAttributes, &g_para[0]);
578 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
579
580 ret = g_para[0].capture->attr.GetSampleAttributes(g_para[0].capture, &(g_para[0].attrsValue));
581 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
582 EXPECT_EQ(AUDIO_IN_MEDIA, g_para[0].attrsValue.type);
583 EXPECT_FALSE(g_para[0].attrsValue.interleaved);
584 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, g_para[0].attrsValue.format);
585 EXPECT_EQ(SAMPLERATEVALUE, g_para[0].attrsValue.sampleRate);
586 EXPECT_EQ(count, g_para[0].attrsValue.channelCount);
587 }
588
589 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
590 void *result = nullptr;
591 pthread_join(tids[i], &result);
592 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
593 }
594 }
595
596 /**
597 * @tc.name AudioCaptureGetSampleAttributesReliability_001
598 * @tc.desc test AudioCaptureGetSampleAttributes interface Reliability pass through pthread_create fun and adapterName
599 is same.
600 * @tc.type: RELI
601 */
602 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureGetSampleAttributesReliability_001,
603 TestSize.Level1)
604 {
605 int32_t ret = -1;
606 uint32_t count = 2;
607 g_para[0].capture = capture;
608 ASSERT_NE(nullptr, g_para[0].capture);
609
610 InitAttrs(g_para[0].attrs);
611 pthread_t tids[PTHREAD_SAMEADA_COUNT];
612 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
613 ret = g_para[0].capture->attr.SetSampleAttributes(g_para[0].capture, &(g_para[0].attrs));
614 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
615
616 int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetSampleAttributes, &g_para[0]);
617 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
618
619 EXPECT_EQ(AUDIO_IN_MEDIA, g_para[0].attrsValue.type);
620 EXPECT_FALSE(g_para[0].attrsValue.interleaved);
621 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, g_para[0].attrsValue.format);
622 EXPECT_EQ(SAMPLERATEVALUE, g_para[0].attrsValue.sampleRate);
623 EXPECT_EQ(count, g_para[0].attrsValue.channelCount);
624 }
625
626 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
627 void *result = nullptr;
628 pthread_join(tids[i], &result);
629 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
630 }
631 }
632
633 /**
634 * @tc.name AudioCaptureSelectSceneReliability_001
635 * @tc.desc test AudioCaptureSelectScene interface Reliability pass through pthread_create fun and adapterName is same.
636 * @tc.type: RELI
637 */
638 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureSelectSceneReliability_001, TestSize.Level1)
639 {
640 int32_t ret = -1;
641 g_para[0].capture = capture;
642 ASSERT_NE(nullptr, g_para[0].capture);
643
644 pthread_t tids[PTHREAD_SAMEADA_COUNT];
645 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
646 g_para[0].scenes.scene.id = 0;
647 g_para[0].scenes.desc.pins = PIN_IN_MIC;
648 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSelectScene, &g_para[0]);
649 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
650 }
651
652 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
653 void *result = nullptr;
654 pthread_join(tids[i], &result);
655 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
656 }
657 }
658
659 /**
660 * @tc.name AudioCaptureCheckSceneCapabilityReliability_001
661 * @tc.desc test AudioCaptureCheckSceneCapability interface Reliability pass through pthread_create fun and adapterName
662 is same.
663 * @tc.type: RELI
664 */
665 HWTEST_F(AudioHdiCaptureReliabilityTest, AudioCaptureCheckSceneCapabilityReliability_001,
666 TestSize.Level1)
667 {
668 int32_t ret = -1;
669 g_para[0].capture = capture;
670 ASSERT_NE(nullptr, g_para[0].capture);
671
672 pthread_t tids[PTHREAD_SAMEADA_COUNT];
673 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
674 g_para[0].scenes.scene.id = 0;
675 g_para[0].scenes.desc.pins = PIN_IN_MIC;
676 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureCheckSceneCapability, &g_para[0]);
677 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
678 }
679
680 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
681 void *result = nullptr;
682 pthread_join(tids[i], &result);
683 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
684 }
685 }
686 }
687