1 /*
2 * Copyright (c) 2025 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 "soundpool_unit_test.h"
17 #include "media_errors.h"
18
19 using namespace OHOS;
20 using namespace OHOS::Media;
21 using namespace testing::ext;
22 using namespace std;
23
24 static const std::string g_fileName[6] = {
25 {"/data/test/test_06.ogg"},
26 {"/data/test/test_02.mp3"},
27 {"/data/test/test_01.mp3"},
28 {"/data/test/test_05.ogg"},
29 {"/data/test/test_03.mp3"},
30 {"/data/test/test_04.mp3"},
31 };
32
33 namespace OHOS {
34 namespace Media {
35
36 /**
37 * @tc.name: soundpool_function_044
38 * @tc.desc: function test Load Url one more time use soundPoolParallel
39 * @tc.type: FUNC
40 * @tc.require:
41 */
42 HWTEST_F(SoundPoolUnitTest, soundpool_function_044, TestSize.Level2)
43 {
44 MEDIA_LOGI("soundpool_unit_test soundpool_function_044 before");
45 int maxStreams = 3;
46 create(maxStreams);
47 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
48 ASSERT_TRUE(cb != nullptr);
49 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
50 ASSERT_TRUE(ret == 0);
51 loadUrlParallel(g_fileName[loadNum_], loadNum_);
52 loadNum_++;
53 loadUrlParallel(g_fileName[loadNum_], loadNum_);
54 loadNum_++;
55 loadUrlParallel(g_fileName[1], loadNum_);
56 loadNum_++;
57 loadUrlParallel(g_fileName[1], loadNum_);
58 sleep(waitTime3);
59 ASSERT_TRUE(cb->WaitLoadedSoundNum(4));
60 cb->ResetHaveLoadedSoundNum();
61 MEDIA_LOGI("soundpool_unit_test soundpool_function_044 after");
62 }
63
64 /**
65 * @tc.name: soundpool_function_045
66 * @tc.desc: function test Load Url with invalid path use soundPoolParallel
67 * @tc.type: FUNC
68 * @tc.require:
69 */
70 HWTEST_F(SoundPoolUnitTest, soundpool_function_045, TestSize.Level2)
71 {
72 MEDIA_LOGI("soundpool_unit_test soundpool_function_045 before");
73 int maxStreams = 3;
74 create(maxStreams);
75 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
76 ASSERT_TRUE(cb != nullptr);
77 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
78 ASSERT_TRUE(ret == 0);
79 // test invalid path
80 std::string fileName = "/data/test/test_05.mp3";
81 fds_[loadNum_] = open(fileName.c_str(), O_RDWR);
82 std::string url = "fd://" + std::to_string(fds_[loadNum_]);
83 soundIDs_[loadNum_] = soundPoolParallel_->Load(url);
84 sleep(waitTime3);
85 if (fds_[loadNum_] == -1) {
86 cout << "Url open a invalid path: " << fileName.c_str() << endl;
87 }
88 EXPECT_EQ(soundIDs_[loadNum_], -1);
89 MEDIA_LOGI("soundpool_unit_test soundpool_function_045 after");
90 }
91
92 /**
93 * @tc.name: soundpool_function_046
94 * @tc.desc: function test Load Url when no callback use soundPoolParallel
95 * @tc.type: FUNC
96 * @tc.require:
97 */
98 HWTEST_F(SoundPoolUnitTest, soundpool_function_046, TestSize.Level2)
99 {
100 MEDIA_LOGI("soundpool_unit_test soundpool_function_046 before");
101 int maxStreams = 3;
102 create(maxStreams);
103 // test no callback to load
104 loadUrlParallel(g_fileName[loadNum_], loadNum_);
105 sleep(waitTime3);
106 MEDIA_LOGI("soundpool_unit_test soundpool_function_046 after");
107 }
108
109 /**
110 * @tc.name: soundpool_function_047
111 * @tc.desc: function test Load Url after play use soundPoolParallel
112 * @tc.type: FUNC
113 * @tc.require:
114 */
115 HWTEST_F(SoundPoolUnitTest, soundpool_function_047, TestSize.Level2)
116 {
117 MEDIA_LOGI("soundpool_unit_test soundpool_function_047 before");
118 int maxStreams = 3;
119 create(maxStreams);
120 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
121 ASSERT_TRUE(cb != nullptr);
122 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
123 ASSERT_TRUE(ret == 0);
124 loadUrlParallel(g_fileName[loadNum_], loadNum_);
125 sleep(waitTime3);
126 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
127 cb->ResetHaveLoadedSoundNum();
128 struct PlayParams playParameters;
129 if (soundIDs_[loadNum_] > 0) {
130 soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
131 sleep(waitTime1);
132 loadNum_++;
133 loadUrlParallel(g_fileName[loadNum_], loadNum_);
134 sleep(waitTime3);
135 } else {
136 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
137 }
138 cb->ResetHavePlayedSoundNum();
139 MEDIA_LOGI("soundpool_unit_test soundpool_function_047 after");
140 }
141
142 /**
143 * @tc.name: soundpool_function_048
144 * @tc.desc: function test Load Fd one more time use soundPoolParallel
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(SoundPoolUnitTest, soundpool_function_048, TestSize.Level2)
149 {
150 MEDIA_LOGI("soundpool_unit_test soundpool_function_048 before");
151 int maxStreams = 3;
152 create(maxStreams);
153 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
154 ASSERT_TRUE(cb != nullptr);
155 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
156 ASSERT_TRUE(ret == 0);
157 loadFdParallel(g_fileName[loadNum_], loadNum_);
158 loadNum_++;
159 loadFdParallel(g_fileName[loadNum_], loadNum_);
160 loadNum_++;
161 loadFdParallel(g_fileName[1], loadNum_);
162 loadNum_++;
163 loadFdParallel(g_fileName[1], loadNum_);
164 sleep(waitTime3);
165 ASSERT_TRUE(cb->WaitLoadedSoundNum(4));
166 cb->ResetHaveLoadedSoundNum();
167 MEDIA_LOGI("soundpool_unit_test soundpool_function_048 after");
168 }
169
170 /**
171 * @tc.name: soundpool_function_049
172 * @tc.desc: function test Load Fd with invalid path use soundPoolParallel
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(SoundPoolUnitTest, soundpool_function_049, TestSize.Level2)
177 {
178 MEDIA_LOGI("soundpool_unit_test soundpool_function_049 before");
179 int maxStreams = 3;
180 create(maxStreams);
181 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
182 ASSERT_TRUE(cb != nullptr);
183 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
184 ASSERT_TRUE(ret == 0);
185 std::string fileName = "/data/test/test_05.mp3";
186 fds_[loadNum_] = open(fileName.c_str(), O_RDONLY);
187 size_t filesize = soundPoolParallel_->GetFileSize(fileName);
188 EXPECT_EQ(filesize, 0);
189 soundIDs_[loadNum_] = soundPoolParallel_->Load(fds_[loadNum_], 0, filesize);
190 sleep(waitTime3);
191 if (fds_[loadNum_] == -1) {
192 cout << "Fd open a invalid path: " << fileName.c_str() << endl;
193 }
194 EXPECT_EQ(soundIDs_[loadNum_], -1);
195 MEDIA_LOGI("soundpool_unit_test soundpool_function_049 after");
196 }
197
198 /**
199 * @tc.name: soundpool_function_050
200 * @tc.desc: function test Load Fd when no callback use soundPoolParallel
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(SoundPoolUnitTest, soundpool_function_050, TestSize.Level2)
205 {
206 MEDIA_LOGI("soundpool_unit_test soundpool_function_050 before");
207 int maxStreams = 3;
208 create(maxStreams);
209 // test no callback to load
210 loadFdParallel(g_fileName[loadNum_], loadNum_);
211 sleep(waitTime3);
212 MEDIA_LOGI("soundpool_unit_test soundpool_function_050 after");
213 }
214
215 /**
216 * @tc.name: soundpool_function_051
217 * @tc.desc: function test Load Fd after paly use soundPoolParallel
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(SoundPoolUnitTest, soundpool_function_051, TestSize.Level2)
222 {
223 MEDIA_LOGI("soundpool_unit_test soundpool_function_051 before");
224 int maxStreams = 3;
225 create(maxStreams);
226 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
227 ASSERT_TRUE(cb != nullptr);
228 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
229 ASSERT_TRUE(ret == 0);
230 loadFdParallel(g_fileName[loadNum_], loadNum_);
231 sleep(waitTime3);
232 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
233 cb->ResetHaveLoadedSoundNum();
234 struct PlayParams playParameters;
235 if (soundIDs_[loadNum_] > 0) {
236 soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
237 sleep(waitTime1);
238 loadNum_++;
239 loadFdParallel(g_fileName[loadNum_], loadNum_);
240 sleep(waitTime3);
241 } else {
242 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
243 }
244 cb->ResetHavePlayedSoundNum();
245 MEDIA_LOGI("soundpool_unit_test soundpool_function_051 after");
246 }
247
248 /**
249 * @tc.name: soundpool_function_052
250 * @tc.desc: function test UnLoad use soundPoolParallel
251 * @tc.type: FUNC
252 * @tc.require:
253 */
254 HWTEST_F(SoundPoolUnitTest, soundpool_function_052, TestSize.Level2)
255 {
256 MEDIA_LOGI("soundpool_unit_test soundpool_function_052 before");
257 int maxStreams = 3;
258 create(maxStreams);
259 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
260 ASSERT_TRUE(cb != nullptr);
261 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
262 ASSERT_TRUE(ret == 0);
263 loadUrlParallel(g_fileName[loadNum_], loadNum_);
264 loadNum_++;
265 loadUrlParallel(g_fileName[loadNum_], loadNum_);
266 loadNum_++;
267 loadFdParallel(g_fileName[loadNum_], loadNum_);
268 loadNum_++;
269 loadFdParallel(g_fileName[loadNum_], loadNum_);
270 sleep(waitTime3);
271 ASSERT_TRUE(cb->WaitLoadedSoundNum(4));
272 cb->ResetHaveLoadedSoundNum();
273 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Unload(soundIDs_[0]));
274 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Unload(soundIDs_[1]));
275 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Unload(soundIDs_[2]));
276 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Unload(soundIDs_[3]));
277 MEDIA_LOGI("soundpool_unit_test soundpool_function_052 after");
278 }
279
280 /**
281 * @tc.name: soundpool_function_053
282 * @tc.desc: function test UnLoad with error path use soundPoolParallel
283 * @tc.type: FUNC
284 * @tc.require:
285 */
286 HWTEST_F(SoundPoolUnitTest, soundpool_function_053, TestSize.Level2)
287 {
288 MEDIA_LOGI("soundpool_unit_test soundpool_function_053 before");
289 int maxStreams = 3;
290 create(maxStreams);
291 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
292 ASSERT_TRUE(cb != nullptr);
293 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
294 ASSERT_TRUE(ret == 0);
295 std::string fileName = "/data/test/test_05.mp3";
296 fds_[loadNum_] = open(fileName.c_str(), O_RDWR);
297 std::string url = "fd://" + std::to_string(fds_[loadNum_]);
298 soundIDs_[loadNum_] = soundPoolParallel_->Load(url);
299 if (fds_[loadNum_] == -1) {
300 cout << "Url open a invalid path: " << fileName.c_str() << endl;
301 }
302 EXPECT_EQ(soundIDs_[loadNum_], -1);
303 loadNum_++;
304 fds_[loadNum_] = open(fileName.c_str(), O_RDONLY);
305 size_t filesize = soundPoolParallel_->GetFileSize(fileName);
306 EXPECT_EQ(filesize, 0);
307 soundIDs_[loadNum_] = soundPoolParallel_->Load(fds_[loadNum_], 0, filesize);
308 sleep(waitTime3);
309 if (fds_[loadNum_] == -1) {
310 cout << "Fd open a invalid path: " << fileName.c_str() << endl;
311 }
312 EXPECT_EQ(soundIDs_[loadNum_], -1);
313 // test UnLoad a invalid-path return soundId
314 int32_t unload = soundPoolParallel_->Unload(soundIDs_[0]);
315 EXPECT_EQ(MSERR_NO_MEMORY, unload);
316 unload = soundPoolParallel_->Unload(soundIDs_[1]);
317 EXPECT_EQ(MSERR_NO_MEMORY, unload);
318 MEDIA_LOGI("soundpool_unit_test soundpool_function_053 after");
319 }
320
321 /**
322 * @tc.name: soundpool_function_054
323 * @tc.desc: function test UnLoad with -1/5 use soundPoolParallel
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(SoundPoolUnitTest, soundpool_function_054, TestSize.Level2)
328 {
329 MEDIA_LOGI("soundpool_unit_test soundpool_function_054 before");
330 int maxStreams = 3;
331 create(maxStreams);
332 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
333 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
334 if (ret != 0) {
335 cout << "set callback failed" << endl;
336 }
337 // test unload -1
338 int32_t unload = soundPoolParallel_->Unload(-1);
339 EXPECT_EQ(MSERR_NO_MEMORY, unload);
340 // test unload 5
341 unload = soundPoolParallel_->Unload(5);
342 EXPECT_EQ(MSERR_NO_MEMORY, unload);
343 MEDIA_LOGI("soundpool_unit_test soundpool_function_054 after");
344 }
345
346 /**
347 * @tc.name: soundpool_function_055
348 * @tc.desc: function test Play with undefault playParameters use soundPoolParallel
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(SoundPoolUnitTest, soundpool_function_055, TestSize.Level2)
353 {
354 MEDIA_LOGI("soundpool_unit_test soundpool_function_055 before");
355 int maxStreams = 3;
356 create(maxStreams);
357 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
358 ASSERT_TRUE(cb != nullptr);
359 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
360 ASSERT_TRUE(ret == 0);
361
362 loadUrlParallel(g_fileName[loadNum_], loadNum_);
363 sleep(waitTime3);
364 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
365 cb->ResetHaveLoadedSoundNum();
366 struct PlayParams playParameters;
367 playParameters.loop = -1;
368 playParameters.rate = 1;
369 playParameters.leftVolume = 0.5;
370 playParameters.rightVolume = 0.3;
371 playParameters.priority = 1;
372 playParameters.parallelPlayFlag = true;
373 if (soundIDs_[loadNum_] > 0) {
374 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
375 EXPECT_GT(streamIDs_[playNum_], 0);
376 sleep(waitTime3);
377 }
378 cb->ResetHavePlayedSoundNum();
379 MEDIA_LOGI("soundpool_unit_test soundpool_function_055 after");
380 }
381
382 /**
383 * @tc.name: soundpool_function_056
384 * @tc.desc: function test Play with default playParameters use soundPoolParallel
385 * @tc.type: FUNC
386 * @tc.require:
387 */
388 HWTEST_F(SoundPoolUnitTest, soundpool_function_056, TestSize.Level2)
389 {
390 MEDIA_LOGI("soundpool_unit_test soundpool_function_056 before");
391 int maxStreams = 3;
392 create(maxStreams);
393 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
394 ASSERT_TRUE(cb != nullptr);
395 soundPoolParallel_->SetSoundPoolCallback(cb);
396 loadUrlParallel(g_fileName[loadNum_], loadNum_);
397 sleep(waitTime3);
398 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
399 cb->ResetHaveLoadedSoundNum();
400 struct PlayParams playParameters;
401 if (soundIDs_[loadNum_] > 0) {
402 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
403 EXPECT_GT(streamIDs_[playNum_], 0);
404 sleep(waitTime3);
405 playNum_++;
406 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
407 EXPECT_GT(streamIDs_[playNum_], 0);
408 sleep(waitTime3);
409 playNum_++;
410 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
411 EXPECT_GT(streamIDs_[playNum_], 0);
412 sleep(waitTime3);
413 playNum_++;
414 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
415 EXPECT_GT(streamIDs_[playNum_], 0);
416 sleep(waitTime3);
417 } else {
418 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
419 }
420 cb->ResetHavePlayedSoundNum();
421 MEDIA_LOGI("soundpool_unit_test soundpool_function_056 after");
422 }
423
424 /**
425 * @tc.name: soundpool_function_057
426 * @tc.desc: function test Play with error soundID use soundPoolParallel
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430 HWTEST_F(SoundPoolUnitTest, soundpool_function_057, TestSize.Level2)
431 {
432 MEDIA_LOGI("soundpool_unit_test soundpool_function_057 before");
433 int maxStreams = 3;
434 create(maxStreams);
435 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
436 ASSERT_TRUE(cb != nullptr);
437 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
438 ASSERT_TRUE(ret == 0);
439 struct PlayParams playParameters;
440 streamIDs_[playNum_] = soundPoolParallel_->Play(5, playParameters);
441 cout << "soundId 5 play, result: " << streamIDs_[playNum_] << endl;
442 EXPECT_EQ(streamIDs_[playNum_], -1);
443 sleep(waitTime1);
444 cb->ResetHavePlayedSoundNum();
445 MEDIA_LOGI("soundpool_unit_test soundpool_function_057 after");
446 }
447
448 /**
449 * @tc.name: soundpool_function_058
450 * @tc.desc: function test Play with not load number -1 use soundPoolParallel
451 * @tc.type: FUNC
452 * @tc.require:
453 */
454 HWTEST_F(SoundPoolUnitTest, soundpool_function_058, TestSize.Level2)
455 {
456 MEDIA_LOGI("soundpool_unit_test soundpool_function_058 before");
457 int maxStreams = 3;
458 create(maxStreams);
459 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
460 ASSERT_TRUE(cb != nullptr);
461 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
462 ASSERT_TRUE(ret == 0);
463 struct PlayParams playParameters;
464 streamIDs_[playNum_] = soundPoolParallel_->Play(-1, playParameters);
465 cout << "soundId -1 play, result: " << streamIDs_[playNum_] << endl;
466 EXPECT_EQ(streamIDs_[playNum_], -1);
467 sleep(waitTime1);
468 cb->ResetHavePlayedSoundNum();
469 MEDIA_LOGI("soundpool_unit_test soundpool_function_058 after");
470 }
471
472 /**
473 * @tc.name: soundpool_function_059
474 * @tc.desc: function test Play with different soundID use soundPoolParallel
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(SoundPoolUnitTest, soundpool_function_059, TestSize.Level2)
479 {
480 MEDIA_LOGI("soundpool_unit_test soundpool_function_059 before");
481 int maxStreams = 3;
482 create(maxStreams);
483 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
484 ASSERT_TRUE(cb != nullptr);
485 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
486 ASSERT_TRUE(ret == 0);
487 loadUrlParallel(g_fileName[loadNum_], loadNum_);
488 loadNum_++;
489 loadUrlParallel(g_fileName[loadNum_], loadNum_);
490 sleep(waitTime3);
491 ASSERT_TRUE(cb->WaitLoadedSoundNum(2));
492 cb->ResetHaveLoadedSoundNum();
493 struct PlayParams playParameters;
494 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
495 EXPECT_GT(streamIDs_[playNum_], 0);
496 sleep(waitTime1);
497 playNum_++;
498 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
499 EXPECT_GT(streamIDs_[playNum_], 0);
500 cb->ResetHavePlayedSoundNum();
501 MEDIA_LOGI("soundpool_unit_test soundpool_function_059 after");
502 }
503
504 /**
505 * @tc.name: soundpool_function_060
506 * @tc.desc: function test Stop with same streamId use soundPoolParallel
507 * @tc.type: FUNC
508 * @tc.require:
509 */
510 HWTEST_F(SoundPoolUnitTest, soundpool_function_060, TestSize.Level2)
511 {
512 MEDIA_LOGI("soundpool_unit_test soundpool_function_060 before");
513 int maxStreams = 3;
514 create(maxStreams);
515 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
516 ASSERT_TRUE(cb != nullptr);
517 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
518 ASSERT_TRUE(ret == 0);
519 loadUrlParallel(g_fileName[loadNum_], loadNum_);
520 sleep(waitTime3);
521 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
522 cb->ResetHaveLoadedSoundNum();
523 struct PlayParams playParameters;
524 if (soundIDs_[loadNum_] > 0) {
525 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
526 EXPECT_GT(streamIDs_[playNum_], 0);
527 sleep(waitTime1);
528 }
529 cb->ResetHavePlayedSoundNum();
530 if (streamIDs_[playNum_] > 0) {
531 int32_t stopResult = soundPoolParallel_->Stop(streamIDs_[playNum_]);
532 EXPECT_EQ(MSERR_OK, stopResult);
533 sleep(waitTime1);
534 int32_t stopResult1 = soundPoolParallel_->Stop(streamIDs_[playNum_]);
535 EXPECT_NE(MSERR_OK, stopResult1);
536 }
537 MEDIA_LOGI("soundpool_unit_test soundpool_function_060 after");
538 }
539
540 /**
541 * @tc.name: soundpool_function_061
542 * @tc.desc: function test Stop with different streamId use soundPoolParallel
543 * @tc.type: FUNC
544 * @tc.require:
545 */
546 HWTEST_F(SoundPoolUnitTest, soundpool_function_061, TestSize.Level2)
547 {
548 MEDIA_LOGI("soundpool_unit_test soundpool_function_061 before");
549 int maxStreams = 3;
550 create(maxStreams);
551 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
552 ASSERT_TRUE(cb != nullptr);
553 soundPoolParallel_->SetSoundPoolCallback(cb);
554 loadUrlParallel(g_fileName[loadNum_], loadNum_);
555 loadNum_++;
556 loadFdParallel(g_fileName[loadNum_], loadNum_);
557 sleep(waitTime3);
558 ASSERT_TRUE(cb->WaitLoadedSoundNum(2));
559 cb->ResetHaveLoadedSoundNum();
560 struct PlayParams playParameters;
561 if (soundIDs_[0] > 0) {
562 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
563 EXPECT_GT(streamIDs_[playNum_], 0);
564 sleep(waitTime1);
565 }
566 playNum_++;
567 if (soundIDs_[1] > 0) {
568 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
569 EXPECT_GT(streamIDs_[playNum_], 0);
570 sleep(waitTime1);
571 }
572 cb->ResetHavePlayedSoundNum();
573 if (streamIDs_[0] > 0) {
574 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Stop(streamIDs_[0]));
575 }
576 if (streamIDs_[1] > 0) {
577 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Stop(streamIDs_[1]));
578 }
579 MEDIA_LOGI("soundpool_unit_test soundpool_function_061 after");
580 }
581
582 /**
583 * @tc.name: soundpool_function_062
584 * @tc.desc: function test not Stop all streamId use soundPoolParallel
585 * @tc.type: FUNC
586 * @tc.require:
587 */
588 HWTEST_F(SoundPoolUnitTest, soundpool_function_062, TestSize.Level2)
589 {
590 MEDIA_LOGI("soundpool_unit_test soundpool_function_062 before");
591 int maxStreams = 3;
592 create(maxStreams);
593 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
594 ASSERT_TRUE(cb != nullptr);
595 soundPoolParallel_->SetSoundPoolCallback(cb);
596 loadUrlParallel(g_fileName[loadNum_], loadNum_);
597 loadNum_++;
598 loadFdParallel(g_fileName[loadNum_], loadNum_);
599 loadNum_++;
600 loadUrlParallel(g_fileName[loadNum_], loadNum_);
601 sleep(waitTime3);
602 ASSERT_TRUE(cb->WaitLoadedSoundNum(3));
603 cb->ResetHaveLoadedSoundNum();
604 struct PlayParams playParameters;
605 if (soundIDs_[0] > 0) {
606 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
607 EXPECT_GT(streamIDs_[playNum_], 0);
608 }
609 playNum_++;
610 if (soundIDs_[1] > 0) {
611 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
612 EXPECT_GT(streamIDs_[playNum_], 0);
613 sleep(waitTime1);
614 }
615 playNum_++;
616 if (soundIDs_[2] > 0) {
617 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[2], playParameters);
618 EXPECT_GT(streamIDs_[playNum_], 0);
619 sleep(waitTime1);
620 }
621 cb->ResetHavePlayedSoundNum();
622 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Stop(streamIDs_[0]));
623 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Stop(streamIDs_[2]));
624 MEDIA_LOGI("soundpool_unit_test soundpool_function_062 after");
625 }
626
627 /**
628 * @tc.name: soundpool_function_063
629 * @tc.desc: function test Stop with -1 use soundPoolParallel
630 * @tc.type: FUNC
631 * @tc.require:
632 */
633 HWTEST_F(SoundPoolUnitTest, soundpool_function_063, TestSize.Level2)
634 {
635 MEDIA_LOGI("soundpool_unit_test soundpool_function_063 before");
636 int maxStreams = 3;
637 create(maxStreams);
638 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
639 ASSERT_TRUE(cb != nullptr);
640 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
641 ASSERT_TRUE(ret == 0);
642 loadUrlParallel(g_fileName[loadNum_], loadNum_);
643 sleep(waitTime3);
644 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
645 cb->ResetHaveLoadedSoundNum();
646 int32_t stopResult = soundPoolParallel_->Stop(-1);
647 EXPECT_EQ(MSERR_INVALID_OPERATION, stopResult);
648 MEDIA_LOGI("soundpool_unit_test soundpool_function_063 after");
649 }
650
651 /**
652 * @tc.name: soundpool_function_064
653 * @tc.desc: function test SetLoop use soundPoolParallel
654 * @tc.type: FUNC
655 * @tc.require:
656 */
657 HWTEST_F(SoundPoolUnitTest, soundpool_function_064, TestSize.Level2)
658 {
659 MEDIA_LOGI("soundpool_unit_test soundpool_function_064 before");
660 int maxStreams = 3;
661 create(maxStreams);
662 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
663 ASSERT_TRUE(cb != nullptr);
664 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
665 ASSERT_TRUE(ret == 0);
666 loadUrlParallel(g_fileName[loadNum_], loadNum_);
667 sleep(waitTime3);
668 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
669 cb->ResetHaveLoadedSoundNum();
670 struct PlayParams playParameters;
671 playParameters.loop = 0;
672 int32_t loop = -1;
673 if (soundIDs_[loadNum_] > 0) {
674 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
675 EXPECT_GT(streamIDs_[playNum_], 0);
676 sleep(waitTime1);
677 int32_t setPool = soundPoolParallel_->SetLoop(streamIDs_[playNum_], loop);
678 EXPECT_EQ(MSERR_OK, setPool);
679 sleep(waitTime1);
680 } else {
681 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
682 }
683 cb->ResetHavePlayedSoundNum();
684 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Unload(soundIDs_[loadNum_]));
685 MEDIA_LOGI("soundpool_unit_test soundpool_function_064 after");
686 }
687
688 /**
689 * @tc.name: soundpool_function_065
690 * @tc.desc: function test SetLoop 3 use soundPoolParallel
691 * @tc.type: FUNC
692 * @tc.require:
693 */
694 HWTEST_F(SoundPoolUnitTest, soundpool_function_065, TestSize.Level2)
695 {
696 MEDIA_LOGI("soundpool_unit_test soundpool_function_065 before");
697 int maxStreams = 3;
698 create(maxStreams);
699 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
700 ASSERT_TRUE(cb != nullptr);
701 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
702 ASSERT_TRUE(ret == 0);
703 loadUrlParallel(g_fileName[loadNum_], loadNum_);
704 sleep(waitTime3);
705 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
706 cb->ResetHaveLoadedSoundNum();
707 struct PlayParams playParameters;
708 playParameters.loop = 0;
709 int32_t loop = 3;
710 if (soundIDs_[loadNum_] > 0) {
711 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
712 EXPECT_GT(streamIDs_[playNum_], 0);
713 sleep(waitTime1);
714 int32_t setPool = soundPoolParallel_->SetLoop(streamIDs_[playNum_], loop);
715 EXPECT_EQ(MSERR_OK, setPool);
716 sleep(waitTime1);
717 } else {
718 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
719 }
720 cb->ResetHavePlayedSoundNum();
721 MEDIA_LOGI("soundpool_unit_test soundpool_function_065 after");
722 }
723
724 /**
725 * @tc.name: soundpool_function_066
726 * @tc.desc: function test SetLoop -2 use soundPoolParallel
727 * @tc.type: FUNC
728 * @tc.require:
729 */
730 HWTEST_F(SoundPoolUnitTest, soundpool_function_066, TestSize.Level2)
731 {
732 MEDIA_LOGI("soundpool_unit_test soundpool_function_066 before");
733 int maxStreams = 3;
734 create(maxStreams);
735 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
736 ASSERT_TRUE(cb != nullptr);
737 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
738 ASSERT_TRUE(ret == 0);
739 loadUrlParallel(g_fileName[loadNum_], loadNum_);
740 sleep(waitTime3);
741 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
742 cb->ResetHaveLoadedSoundNum();
743 struct PlayParams playParameters;
744 playParameters.loop = 0;
745 int32_t loop = -2;
746 if (soundIDs_[loadNum_] > 0) {
747 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
748 EXPECT_GT(streamIDs_[playNum_], 0);
749 sleep(waitTime1);
750 int32_t setPool = soundPoolParallel_->SetLoop(streamIDs_[playNum_], loop);
751 EXPECT_EQ(MSERR_OK, setPool);
752 sleep(waitTime1);
753 } else {
754 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
755 }
756 cb->ResetHavePlayedSoundNum();
757 MEDIA_LOGI("soundpool_unit_test soundpool_function_066 after");
758 }
759
760 /**
761 * @tc.name: soundpool_function_067
762 * @tc.desc: function test SetLoop -1, streamID is -1 use soundPoolParallel
763 * @tc.type: FUNC
764 * @tc.require:
765 */
766 HWTEST_F(SoundPoolUnitTest, soundpool_function_067, TestSize.Level2)
767 {
768 MEDIA_LOGI("soundpool_unit_test soundpool_function_067 before");
769 int maxStreams = 3;
770 create(maxStreams);
771 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
772 ASSERT_TRUE(cb != nullptr);
773 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
774 ASSERT_TRUE(ret == 0);
775 loadUrlParallel(g_fileName[loadNum_], loadNum_);
776 sleep(waitTime3);
777 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
778 cb->ResetHaveLoadedSoundNum();
779 struct PlayParams playParameters;
780 playParameters.loop = 0;
781 int32_t loop = -1;
782 if (soundIDs_[loadNum_] > 0) {
783 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
784 EXPECT_GT(streamIDs_[playNum_], 0);
785 sleep(waitTime1);
786 int32_t setPool = soundPoolParallel_->SetLoop(-1, loop);
787 EXPECT_EQ(MSERR_INVALID_OPERATION, setPool);
788 sleep(waitTime1);
789 } else {
790 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
791 }
792 cb->ResetHavePlayedSoundNum();
793 MEDIA_LOGI("soundpool_unit_test soundpool_function_067 after");
794 }
795
796 /**
797 * @tc.name: soundpool_function_068
798 * @tc.desc: function test SetLoop 2 with different streamId use soundPoolParallel
799 * @tc.type: FUNC
800 * @tc.require:
801 */
802 HWTEST_F(SoundPoolUnitTest, soundpool_function_068, TestSize.Level2)
803 {
804 MEDIA_LOGI("soundpool_unit_test soundpool_function_068 before");
805 int maxStreams = 3;
806 create(maxStreams);
807 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
808 ASSERT_TRUE(cb != nullptr);
809 soundPoolParallel_->SetSoundPoolCallback(cb);
810 loadUrlParallel(g_fileName[loadNum_], loadNum_);
811 loadNum_++;
812 loadUrlParallel(g_fileName[loadNum_], loadNum_);
813 sleep(waitTime3);
814 ASSERT_TRUE(cb->WaitLoadedSoundNum(2));
815 cb->ResetHaveLoadedSoundNum();
816 struct PlayParams playParameters;
817 int32_t loop = 2;
818 if (soundIDs_[0] > 0) {
819 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
820 EXPECT_GT(streamIDs_[playNum_], 0);
821 sleep(waitTime1);
822 int32_t setPool = soundPoolParallel_->SetLoop(streamIDs_[playNum_], loop);
823 EXPECT_EQ(MSERR_OK, setPool);
824 sleep(waitTime3);
825 playNum_++;
826 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
827 EXPECT_GT(streamIDs_[playNum_], 0);
828 sleep(waitTime1);
829 int32_t setPool1 = soundPoolParallel_->SetLoop(streamIDs_[playNum_], loop);
830 EXPECT_EQ(MSERR_OK, setPool1);
831 sleep(waitTime3);
832 } else {
833 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
834 }
835 cb->ResetHavePlayedSoundNum();
836 MEDIA_LOGI("soundpool_unit_test soundpool_function_068 after");
837 }
838
839 /**
840 * @tc.name: soundpool_function_069
841 * @tc.desc: function test SetLoop different loop with different streamId use soundPoolParallel
842 * @tc.type: FUNC
843 * @tc.require:
844 */
845 HWTEST_F(SoundPoolUnitTest, soundpool_function_069, TestSize.Level2)
846 {
847 MEDIA_LOGI("soundpool_unit_test soundpool_function_069 before");
848 int maxStreams = 3;
849 create(maxStreams);
850 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
851 ASSERT_TRUE(cb != nullptr);
852 soundPoolParallel_->SetSoundPoolCallback(cb);
853 loadUrlParallel(g_fileName[loadNum_], loadNum_);
854 loadNum_++;
855 loadUrlParallel(g_fileName[loadNum_], loadNum_);
856 sleep(waitTime3);
857 ASSERT_TRUE(cb->WaitLoadedSoundNum(2));
858 cb->ResetHaveLoadedSoundNum();
859 struct PlayParams playParameters;
860 int32_t loop = 2;
861 if (soundIDs_[0] > 0) {
862 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
863 EXPECT_GT(streamIDs_[playNum_], 0);
864 sleep(waitTime1);
865 int32_t setPool = soundPoolParallel_->SetLoop(streamIDs_[playNum_], loop);
866 EXPECT_EQ(MSERR_OK, setPool);
867 sleep(waitTime3);
868 playNum_++;
869 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
870 EXPECT_GT(streamIDs_[playNum_], 0);
871 sleep(waitTime1);
872 int32_t setPool1 = soundPoolParallel_->SetLoop(streamIDs_[playNum_], -1);
873 EXPECT_EQ(MSERR_OK, setPool1);
874 sleep(waitTime3);
875 } else {
876 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
877 }
878 cb->ResetHavePlayedSoundNum();
879 MEDIA_LOGI("soundpool_unit_test soundpool_function_069 after");
880 }
881
882 /**
883 * @tc.name: soundpool_function_070
884 * @tc.desc: function test SetRate with different rate use soundPoolParallel
885 * @tc.type: FUNC
886 * @tc.require:
887 */
888 HWTEST_F(SoundPoolUnitTest, soundpool_function_070, TestSize.Level2)
889 {
890 MEDIA_LOGI("soundpool_unit_test soundpool_function_070 before");
891 int maxStreams = 3;
892 create(maxStreams);
893 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
894 ASSERT_TRUE(cb != nullptr);
895 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
896 ASSERT_TRUE(ret == 0);
897 loadUrlParallel(g_fileName[loadNum_], loadNum_);
898 sleep(waitTime3);
899 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
900 cb->ResetHaveLoadedSoundNum();
901 struct PlayParams playParameters;
902 playParameters.loop = -1;
903 if (soundIDs_[loadNum_] > 0) {
904 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
905 EXPECT_GT(streamIDs_[playNum_], 0);
906 sleep(waitTime1);
907 int32_t result = soundPoolParallel_->SetRate(streamIDs_[playNum_], AudioRendererRate::RENDER_RATE_DOUBLE);
908 EXPECT_EQ(MSERR_OK, result);
909 sleep(waitTime3);
910 int32_t result1 = soundPoolParallel_->SetRate(streamIDs_[playNum_], AudioRendererRate::RENDER_RATE_HALF);
911 EXPECT_EQ(MSERR_OK, result1);
912 sleep(waitTime3);
913 } else {
914 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
915 }
916
917 cb->ResetHavePlayedSoundNum();
918 MEDIA_LOGI("soundpool_unit_test soundpool_function_070 after");
919 }
920
921 /**
922 * @tc.name: soundpool_function_071
923 * @tc.desc: function test SetRate with different rate and streamID use soundPoolParallel
924 * @tc.type: FUNC
925 * @tc.require:
926 */
927 HWTEST_F(SoundPoolUnitTest, soundpool_function_071, TestSize.Level2)
928 {
929 MEDIA_LOGI("soundpool_unit_test soundpool_function_071 before");
930 int maxStreams = 3;
931 create(maxStreams);
932 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
933 ASSERT_TRUE(cb != nullptr);
934 soundPoolParallel_->SetSoundPoolCallback(cb);
935 loadUrlParallel(g_fileName[loadNum_], loadNum_);
936 loadNum_++;
937 loadUrlParallel(g_fileName[loadNum_], loadNum_);
938 sleep(waitTime3);
939 ASSERT_TRUE(cb->WaitLoadedSoundNum(2));
940 cb->ResetHaveLoadedSoundNum();
941 struct PlayParams playParameters;
942 if (soundIDs_[0] > 0) {
943 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
944 EXPECT_GT(streamIDs_[playNum_], 0);
945 sleep(waitTime1);
946 int32_t result = soundPoolParallel_->SetRate(streamIDs_[playNum_], AudioRendererRate::RENDER_RATE_DOUBLE);
947 EXPECT_EQ(MSERR_OK, result);
948 sleep(waitTime3);
949 }
950 playNum_++;
951 if (soundIDs_[1] > 0) {
952 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
953 EXPECT_GT(streamIDs_[playNum_], 0);
954 sleep(waitTime1);
955 int32_t result = soundPoolParallel_->SetRate(streamIDs_[playNum_], AudioRendererRate::RENDER_RATE_HALF);
956 EXPECT_EQ(MSERR_OK, result);
957 sleep(waitTime3);
958 }
959 cb->ResetHavePlayedSoundNum();
960 MEDIA_LOGI("soundpool_unit_test soundpool_function_071 after");
961 }
962
963 /**
964 * @tc.name: soundpool_function_072
965 * @tc.desc: function test SetRate with different streamID and same rate use soundPoolParallel
966 * @tc.type: FUNC
967 * @tc.require:
968 */
969 HWTEST_F(SoundPoolUnitTest, soundpool_function_072, TestSize.Level2)
970 {
971 MEDIA_LOGI("soundpool_unit_test soundpool_function_072 before");
972 int maxStreams = 3;
973 create(maxStreams);
974 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
975 ASSERT_TRUE(cb != nullptr);
976 soundPoolParallel_->SetSoundPoolCallback(cb);
977 loadUrlParallel(g_fileName[loadNum_], loadNum_);
978 loadNum_++;
979 loadUrlParallel(g_fileName[loadNum_], loadNum_);
980 sleep(waitTime3);
981 ASSERT_TRUE(cb->WaitLoadedSoundNum(2));
982 cb->ResetHaveLoadedSoundNum();
983 struct PlayParams playParameters;
984 playParameters.loop = -1;
985 if (soundIDs_[0] > 0) {
986 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
987 EXPECT_GT(streamIDs_[playNum_], 0);
988 sleep(waitTime1);
989 int32_t result = soundPoolParallel_->SetRate(streamIDs_[playNum_], AudioRendererRate::RENDER_RATE_DOUBLE);
990 EXPECT_EQ(MSERR_OK, result);
991 sleep(waitTime3);
992 }
993 playNum_++;
994 if (soundIDs_[1] > 0) {
995 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
996 EXPECT_GT(streamIDs_[playNum_], 0);
997 sleep(waitTime1);
998 int32_t result = soundPoolParallel_->SetRate(streamIDs_[playNum_], AudioRendererRate::RENDER_RATE_DOUBLE);
999 EXPECT_EQ(MSERR_OK, result);
1000 sleep(waitTime3);
1001 }
1002 cb->ResetHavePlayedSoundNum();
1003 MEDIA_LOGI("soundpool_unit_test soundpool_function_072 after");
1004 }
1005
1006 /**
1007 * @tc.name: soundpool_function_073
1008 * @tc.desc: function test SetVolume 0.5 use soundPoolParallel
1009 * @tc.type: FUNC
1010 * @tc.require:
1011 */
1012 HWTEST_F(SoundPoolUnitTest, soundpool_function_073, TestSize.Level2)
1013 {
1014 MEDIA_LOGI("soundpool_unit_test soundpool_function_073 before");
1015 int maxStreams = 3;
1016 create(maxStreams);
1017 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1018 ASSERT_TRUE(cb != nullptr);
1019 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1020 if (ret != 0) {
1021 cout << "set callback failed" << endl;
1022 }
1023 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1024 sleep(waitTime3);
1025 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
1026 cb->ResetHaveLoadedSoundNum();
1027 struct PlayParams playParameters;
1028 float leftVolume = 0.5;
1029 float rightVolume = 0.5;
1030 if (soundIDs_[loadNum_] > 0) {
1031 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1032 EXPECT_GT(streamIDs_[playNum_], 0);
1033 sleep(waitTime1);
1034 int32_t setVol = soundPoolParallel_->SetVolume(streamIDs_[playNum_], leftVolume, rightVolume);
1035 EXPECT_EQ(MSERR_OK, setVol);
1036 sleep(waitTime1);
1037 } else {
1038 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1039 }
1040 cb->ResetHavePlayedSoundNum();
1041 MEDIA_LOGI("soundpool_unit_test soundpool_function_073 after");
1042 }
1043
1044 /**
1045 * @tc.name: soundpool_function_074
1046 * @tc.desc: function test SetVolume deifferent leftVolume use soundPoolParallel
1047 * @tc.type: FUNC
1048 * @tc.require:
1049 */
1050 HWTEST_F(SoundPoolUnitTest, soundpool_function_074, TestSize.Level2)
1051 {
1052 MEDIA_LOGI("soundpool_unit_test soundpool_function_074 before");
1053 int maxStreams = 3;
1054 create(maxStreams);
1055 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1056 ASSERT_TRUE(cb != nullptr);
1057 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1058 ASSERT_TRUE(ret == 0);
1059 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1060 sleep(waitTime3);
1061 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
1062 cb->ResetHaveLoadedSoundNum();
1063 struct PlayParams playParameters;
1064 float leftVolume = 0.1;
1065 if (soundIDs_[loadNum_] > 0) {
1066 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1067 EXPECT_GT(streamIDs_[playNum_], 0);
1068 sleep(waitTime1);
1069 int32_t setVol = soundPoolParallel_->SetVolume(streamIDs_[playNum_], leftVolume, 0.0);
1070 EXPECT_EQ(MSERR_OK, setVol);
1071 sleep(waitTime3);
1072 int32_t setVol1 = soundPoolParallel_->SetVolume(streamIDs_[playNum_], 1.0, 0.0);
1073 EXPECT_EQ(MSERR_OK, setVol1);
1074 sleep(waitTime1);
1075 } else {
1076 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1077 }
1078 cb->ResetHavePlayedSoundNum();
1079 MEDIA_LOGI("soundpool_unit_test soundpool_function_074 after");
1080 }
1081
1082 /**
1083 * @tc.name: soundpool_function_075
1084 * @tc.desc: function test SetVolume leftVolume -1 use soundPoolParallel
1085 * @tc.type: FUNC
1086 * @tc.require:
1087 */
1088 HWTEST_F(SoundPoolUnitTest, soundpool_function_075, TestSize.Level2)
1089 {
1090 MEDIA_LOGI("soundpool_unit_test soundpool_function_075 before");
1091 int maxStreams = 3;
1092 create(maxStreams);
1093 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1094 ASSERT_TRUE(cb != nullptr);
1095 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1096 ASSERT_TRUE(ret == 0);
1097 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1098 sleep(waitTime3);
1099 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
1100 cb->ResetHaveLoadedSoundNum();
1101 struct PlayParams playParameters;
1102 float leftVolume = -1;
1103 if (soundIDs_[loadNum_] > 0) {
1104 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1105 EXPECT_GT(streamIDs_[playNum_], 0);
1106 sleep(waitTime1);
1107 int32_t setVol = soundPoolParallel_->SetVolume(streamIDs_[playNum_], leftVolume, 0.0);
1108 EXPECT_EQ(MSERR_OK, setVol);
1109 sleep(waitTime1);
1110 } else {
1111 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1112 }
1113 cb->ResetHavePlayedSoundNum();
1114 MEDIA_LOGI("soundpool_unit_test soundpool_function_075 after");
1115 }
1116
1117 /**
1118 * @tc.name: soundpool_function_076
1119 * @tc.desc: function test SetVolume rightVolume 2.0 use soundPoolParallel
1120 * @tc.type: FUNC
1121 * @tc.require:
1122 */
1123 HWTEST_F(SoundPoolUnitTest, soundpool_function_076, TestSize.Level2)
1124 {
1125 MEDIA_LOGI("soundpool_unit_test soundpool_function_076 before");
1126 int maxStreams = 3;
1127 create(maxStreams);
1128 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1129 ASSERT_TRUE(cb != nullptr);
1130 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1131 ASSERT_TRUE(ret == 0);
1132 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1133 sleep(waitTime3);
1134 ASSERT_TRUE(cb->WaitLoadedSoundNum(1));
1135 cb->ResetHaveLoadedSoundNum();
1136 struct PlayParams playParameters;
1137 float rightVolume = 2.0;
1138 if (soundIDs_[loadNum_] > 0) {
1139 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1140 EXPECT_GT(streamIDs_[playNum_], 0);
1141 sleep(waitTime1);
1142 int32_t setVol = soundPoolParallel_->SetVolume(streamIDs_[playNum_], 0.0, rightVolume);
1143 EXPECT_EQ(MSERR_OK, setVol);
1144 sleep(waitTime1);
1145 } else {
1146 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1147 }
1148 cb->ResetHavePlayedSoundNum();
1149 MEDIA_LOGI("soundpool_unit_test soundpool_function_076 after");
1150 }
1151
1152 /**
1153 * @tc.name: soundpool_function_077
1154 * @tc.desc: function test SetPriority 1 use soundPoolParallel
1155 * @tc.type: FUNC
1156 * @tc.require:
1157 */
1158 HWTEST_F(SoundPoolUnitTest, soundpool_function_077, TestSize.Level2)
1159 {
1160 MEDIA_LOGI("soundpool_unit_test soundpool_function_077 before");
1161 int maxStreams = 1;
1162 create(maxStreams);
1163 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1164 ASSERT_TRUE(cb != nullptr);
1165 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1166 ASSERT_TRUE(ret == 0);
1167 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1168 loadNum_++;
1169 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1170 sleep(waitTime3);
1171 ASSERT_TRUE(cb->WaitLoadedSoundNum(2));
1172 cb->ResetHaveLoadedSoundNum();
1173 struct PlayParams playParameters;
1174 playParameters.loop = -1;
1175 int32_t priority = 1;
1176 if (soundIDs_[0] > 0) {
1177 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1178 EXPECT_GT(streamIDs_[playNum_], 0);
1179 }
1180 playNum_++;
1181 if (soundIDs_[1] > 0) {
1182 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1183 EXPECT_GT(streamIDs_[playNum_], 0);
1184 int32_t setPriority = soundPoolParallel_->SetPriority(streamIDs_[playNum_], priority);
1185 EXPECT_EQ(MSERR_OK, setPriority);
1186 sleep(waitTime1);
1187 }
1188 cb->ResetHavePlayedSoundNum();
1189 MEDIA_LOGI("soundpool_unit_test soundpool_function_077 after");
1190 }
1191
1192
1193 /**
1194 * @tc.name: soundpool_function_078
1195 * @tc.desc: function test SetPriority use soundPoolParallel
1196 * @tc.type: FUNC
1197 * @tc.require:
1198 */
1199 HWTEST_F(SoundPoolUnitTest, soundpool_function_078, TestSize.Level2)
1200 {
1201 MEDIA_LOGI("soundpool_unit_test soundpool_function_078 before");
1202 int maxStreams = 1;
1203 create(maxStreams);
1204 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1205 ASSERT_TRUE(cb != nullptr);
1206 soundPoolParallel_->SetSoundPoolCallback(cb);
1207 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1208 loadNum_++;
1209 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1210 sleep(waitTime3);
1211 ASSERT_TRUE(cb->WaitLoadedSoundNum(2));
1212 cb->ResetHaveLoadedSoundNum();
1213 struct PlayParams playParameters;
1214 playParameters.priority = 1;
1215 playParameters.loop = -1;
1216 int32_t priority = -1;
1217 if (soundIDs_[0] > 0) {
1218 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1219 EXPECT_GT(streamIDs_[playNum_], 0);
1220 }
1221 int32_t setPriority = soundPoolParallel_->SetPriority(streamIDs_[0], priority);
1222 sleep(waitTime1);
1223 EXPECT_EQ(MSERR_OK, setPriority);
1224 playNum_++;
1225 if (soundIDs_[1] > 0) {
1226 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1227 EXPECT_GT(streamIDs_[1], 0);
1228 }
1229 cb->ResetHavePlayedSoundNum();
1230 MEDIA_LOGI("soundpool_unit_test soundpool_function_078 after");
1231 }
1232
1233 /**
1234 * @tc.name: soundpool_function_079
1235 * @tc.desc: function test Priority use soundPoolParallel
1236 * @tc.type: FUNC
1237 * @tc.require:
1238 */
1239 HWTEST_F(SoundPoolUnitTest, soundpool_function_079, TestSize.Level2)
1240 {
1241 MEDIA_LOGI("soundpool_unit_test soundpool_function_079 before");
1242 int maxStreams = 3;
1243 create(maxStreams);
1244 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1245 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1246 if (ret != 0) {
1247 cout << "set callback failed" << endl;
1248 }
1249 loadUrlParallel(g_fileName[1], loadNum_);
1250 loadNum_++;
1251 loadUrlParallel(g_fileName[1], loadNum_);
1252 loadNum_++;
1253 loadUrlParallel(g_fileName[1], loadNum_);
1254 loadNum_++;
1255 loadUrlParallel(g_fileName[0], loadNum_);
1256 sleep(waitTime3);
1257 struct PlayParams playParameters;
1258 playParameters.priority = 3;
1259 if (soundIDs_[0] > 0) {
1260 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1261 EXPECT_GT(streamIDs_[playNum_], 0);
1262 sleep(waitTime2);
1263 }
1264 playNum_++;
1265 if (soundIDs_[1] > 0) {
1266 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1267 EXPECT_GT(streamIDs_[playNum_], 0);
1268 sleep(waitTime2);
1269 }
1270 playNum_++;
1271 if (soundIDs_[2] > 0) {
1272 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[2], playParameters);
1273 EXPECT_GT(streamIDs_[playNum_], 0);
1274 sleep(waitTime2);
1275 }
1276 playNum_++;
1277 playParameters.priority = 5;
1278 if (soundIDs_[3] > 0) {
1279 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[3], playParameters);
1280 EXPECT_GT(streamIDs_[playNum_], 0);
1281 sleep(waitTime2);
1282 }
1283 sleep(waitTime10);
1284 cb->ResetHavePlayedSoundNum();
1285 MEDIA_LOGI("soundpool_unit_test soundpool_function_079 after");
1286 }
1287
1288 /**
1289 * @tc.name: soundpool_function_080
1290 * @tc.desc: function test Priority use soundPoolParallel
1291 * @tc.type: FUNC
1292 * @tc.require:
1293 */
1294 HWTEST_F(SoundPoolUnitTest, soundpool_function_080, TestSize.Level2)
1295 {
1296 MEDIA_LOGI("soundpool_unit_test soundpool_function_080 before");
1297 int maxStreams = 3;
1298 create(maxStreams);
1299 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1300 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1301 if (ret != 0) {
1302 cout << "set callback failed" << endl;
1303 }
1304 loadUrlParallel(g_fileName[1], loadNum_);
1305 loadNum_++;
1306 loadUrlParallel(g_fileName[1], loadNum_);
1307 loadNum_++;
1308 loadUrlParallel(g_fileName[1], loadNum_);
1309 loadNum_++;
1310 loadUrlParallel(g_fileName[0], loadNum_);
1311 sleep(waitTime3);
1312 struct PlayParams playParameters;
1313 playParameters.priority = 3;
1314 if (soundIDs_[0] > 0) {
1315 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1316 EXPECT_GT(streamIDs_[playNum_], 0);
1317 sleep(waitTime2);
1318 }
1319 playNum_++;
1320 if (soundIDs_[1] > 0) {
1321 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1322 EXPECT_GT(streamIDs_[playNum_], 0);
1323 sleep(waitTime2);
1324 }
1325 playNum_++;
1326 if (soundIDs_[2] > 0) {
1327 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[2], playParameters);
1328 EXPECT_GT(streamIDs_[playNum_], 0);
1329 sleep(waitTime2);
1330 }
1331 playNum_++;
1332 playParameters.priority = 1;
1333 if (soundIDs_[3] > 0) {
1334 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[3], playParameters);
1335 EXPECT_GT(streamIDs_[playNum_], 0);
1336 sleep(waitTime2);
1337 }
1338 sleep(waitTime10);
1339 cb->ResetHavePlayedSoundNum();
1340 MEDIA_LOGI("soundpool_unit_test soundpool_function_080 after");
1341 }
1342
1343
1344 /**
1345 * @tc.name: soundpool_function_081
1346 * @tc.desc: function test MaxStreams use soundPoolParallel
1347 * @tc.type: FUNC
1348 * @tc.require:
1349 */
1350 HWTEST_F(SoundPoolUnitTest, soundpool_function_081, TestSize.Level2)
1351 {
1352 MEDIA_LOGI("soundpool_unit_test soundpool_function_081 before");
1353
1354 int maxStreams = 3;
1355 create(maxStreams);
1356 maxStreams = -1;
1357 AudioStandard::AudioRendererInfo audioRenderInfo;
1358 audioRenderInfo.contentType = CONTENT_TYPE_MUSIC;
1359 audioRenderInfo.streamUsage = STREAM_USAGE_MUSIC;
1360 audioRenderInfo.rendererFlags = 0;
1361 EXPECT_FALSE(soundPoolParallel_->CreateParallelSoundPool(maxStreams, audioRenderInfo));
1362 maxStreams = 256;
1363 EXPECT_TRUE(soundPoolParallel_->CreateParallelSoundPool(maxStreams, audioRenderInfo));
1364
1365 MEDIA_LOGI("soundpool_unit_test soundpool_function_081 after");
1366 }
1367
1368 /**
1369 * @tc.name: soundpool_function_082
1370 * @tc.desc: function test CacheBuffer DoPlay fail use soundPoolParallel
1371 * @tc.type: FUNC
1372 * @tc.require:
1373 */
1374 HWTEST_F(SoundPoolUnitTest, soundpool_function_082, TestSize.Level2)
1375 {
1376 MEDIA_LOGI("soundpool_unit_test soundpool_function_082 before");
1377
1378 int maxStreams = 3;
1379 create(maxStreams);
1380 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1381 soundPoolParallel_->SetSoundPoolCallback(cb);
1382 loadUrlParallel(g_fileName[1], loadNum_);
1383 sleep(waitTime3);
1384 struct PlayParams playParameters;
1385 if (soundIDs_[0] > 0) {
1386 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1387 EXPECT_GT(streamIDs_[playNum_], 0);
1388 sleep(waitTime1);
1389 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1390 EXPECT_GT(streamIDs_[playNum_], 0);
1391 sleep(waitTime1);
1392 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1393 EXPECT_GT(streamIDs_[playNum_], 0);
1394 sleep(waitTime1);
1395 }
1396 cb->ResetHavePlayedSoundNum();
1397
1398 MEDIA_LOGI("soundpool_unit_test soundpool_function_082 after");
1399 }
1400
1401 /**
1402 * @tc.name: soundpool_function_083
1403 * @tc.desc: function test play Priority use soundPoolParallel
1404 * @tc.type: FUNC
1405 * @tc.require:
1406 */
1407 HWTEST_F(SoundPoolUnitTest, soundpool_function_083, TestSize.Level2)
1408 {
1409 MEDIA_LOGI("soundpool_unit_test soundpool_function_083 before");
1410
1411 int maxStreams = 4;
1412 create(maxStreams);
1413 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1414 soundPoolParallel_->SetSoundPoolCallback(cb);
1415 loadUrlParallel(g_fileName[2], loadNum_++);
1416 loadUrlParallel(g_fileName[1], loadNum_++);
1417 loadUrlParallel(g_fileName[4], loadNum_++);
1418 loadUrlParallel(g_fileName[5], loadNum_++);
1419 sleep(waitTime3);
1420 struct PlayParams playParameters;
1421 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1422 EXPECT_GT(streamIDs_[playNum_], 0);
1423 int32_t setPriority = soundPoolParallel_->SetPriority(streamIDs_[0], 1);
1424 EXPECT_EQ(MSERR_OK, setPriority);
1425 playNum_++;
1426 sleep(waitTime1);
1427
1428 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1429 EXPECT_GT(streamIDs_[playNum_], 0);
1430 setPriority = soundPoolParallel_->SetPriority(streamIDs_[1], 2);
1431 EXPECT_EQ(MSERR_OK, setPriority);
1432 playNum_++;
1433 sleep(waitTime1);
1434
1435 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[2], playParameters);
1436 EXPECT_GT(streamIDs_[playNum_], 0);
1437 setPriority = soundPoolParallel_->SetPriority(streamIDs_[2], 3);
1438 EXPECT_EQ(MSERR_OK, setPriority);
1439 playNum_++;
1440 sleep(waitTime1);
1441
1442 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[3], playParameters);
1443 EXPECT_GT(streamIDs_[playNum_], 0);
1444 setPriority = soundPoolParallel_->SetPriority(streamIDs_[3], 4);
1445 EXPECT_EQ(MSERR_OK, setPriority);
1446 playNum_++;
1447 sleep(waitTime10);
1448
1449 MEDIA_LOGI("soundpool_unit_test soundpool_function_083 after");
1450 }
1451
1452 /**
1453 * @tc.name: soundpool_function_084
1454 * @tc.desc: function test willplay Priority use soundPoolParallel
1455 * @tc.type: FUNC
1456 * @tc.require:
1457 */
1458 HWTEST_F(SoundPoolUnitTest, soundpool_function_084, TestSize.Level2)
1459 {
1460 MEDIA_LOGI("soundpool_unit_test soundpool_function_084 before");
1461
1462 int maxStreams = 1;
1463 create(maxStreams);
1464 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1465 soundPoolParallel_->SetSoundPoolCallback(cb);
1466 loadUrlParallel(g_fileName[2], loadNum_++);
1467 loadUrlParallel(g_fileName[1], loadNum_++);
1468 loadUrlParallel(g_fileName[4], loadNum_++);
1469 loadUrlParallel(g_fileName[5], loadNum_++);
1470 sleep(waitTime3);
1471 struct PlayParams playParameters;
1472 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1473 EXPECT_GT(streamIDs_[playNum_], 0);
1474 int32_t setPriority = soundPoolParallel_->SetPriority(streamIDs_[0], 1);
1475 EXPECT_EQ(MSERR_OK, setPriority);
1476 playNum_++;
1477 sleep(waitTime1);
1478
1479 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1480 EXPECT_GT(streamIDs_[playNum_], 0);
1481 setPriority = soundPoolParallel_->SetPriority(streamIDs_[1], 2);
1482 EXPECT_EQ(MSERR_OK, setPriority);
1483 playNum_++;
1484 sleep(waitTime1);
1485
1486 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[2], playParameters);
1487 EXPECT_GT(streamIDs_[playNum_], 0);
1488 setPriority = soundPoolParallel_->SetPriority(streamIDs_[2], 3);
1489 EXPECT_EQ(MSERR_OK, setPriority);
1490 playNum_++;
1491 sleep(waitTime1);
1492
1493 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[3], playParameters);
1494 EXPECT_GT(streamIDs_[playNum_], 0);
1495 setPriority = soundPoolParallel_->SetPriority(streamIDs_[3], 4);
1496 EXPECT_EQ(MSERR_OK, setPriority);
1497 playNum_++;
1498 sleep(waitTime30);
1499
1500 MEDIA_LOGI("soundpool_unit_test soundpool_function_084 after");
1501 }
1502
1503
1504 /**
1505 * @tc.name: soundpool_function_085
1506 * @tc.desc: function test playFinished with streamId use soundPoolParallel
1507 * @tc.type: FUNC
1508 * @tc.require:
1509 */
1510 HWTEST_F(SoundPoolUnitTest, soundpool_function_085, TestSize.Level2)
1511 {
1512 MEDIA_LOGI("soundpool_unit_test soundpool_function_085 before");
1513 int maxStreams = 3;
1514 create(maxStreams);
1515 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1516 soundPoolParallel_->SetSoundPoolCallback(cb);
1517 loadUrlParallel(g_fileName[4], loadNum_++);
1518 loadUrlParallel(g_fileName[5], loadNum_++);
1519 sleep(waitTime3);
1520 struct PlayParams playParameters;
1521 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1522 EXPECT_GT(streamIDs_[playNum_], 0);
1523 sleep(waitTime1);
1524 playNum_++;
1525 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1526 EXPECT_GT(streamIDs_[playNum_], 0);
1527 int32_t totalNum = playNum_ + 1;
1528 int32_t matchNum = 0;
1529 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Stop(streamIDs_[0]));
1530 EXPECT_EQ(MSERR_OK, soundPoolParallel_->Stop(streamIDs_[1]));
1531
1532 std::vector<int32_t> vector = cb->GetHavePlayedStreamID();
1533 EXPECT_EQ(totalNum, vector.size());
1534 for (int32_t i = 0; i < totalNum; ++i) {
1535 for (int32_t playStreamId : vector) {
1536 if (playStreamId == streamIDs_[i]) {
1537 matchNum++;
1538 }
1539 }
1540 }
1541 EXPECT_EQ(totalNum, matchNum);
1542
1543 cb->ResetHavePlayedStreamID();
1544 cb->ResetHavePlayedSoundNum();
1545 MEDIA_LOGI("soundpool_unit_test soundpool_function_085 after");
1546 }
1547
1548 /**
1549 * @tc.name: soundpool_function_086
1550 * @tc.desc: function test soundpool multi instance use soundPoolParallel
1551 * @tc.type: FUNC
1552 * @tc.require:
1553 */
1554 HWTEST_F(SoundPoolUnitTest, soundpool_function_086, TestSize.Level2)
1555 {
1556 MEDIA_LOGI("soundpool_unit_test soundpool_function_086 before");
1557 int maxStreams = 3;
1558 create(maxStreams);
1559 AudioStandard::AudioRendererInfo audioRenderInfo;
1560 audioRenderInfo.contentType = CONTENT_TYPE_MUSIC;
1561 audioRenderInfo.streamUsage = STREAM_USAGE_MUSIC;
1562 audioRenderInfo.rendererFlags = 0;
1563
1564 std::shared_ptr<SoundPoolParallelMock> soundPoolParallel1 = std::make_shared<SoundPoolParallelMock>();
1565 std::shared_ptr<SoundPoolParallelMock> soundPoolParallel2 = std::make_shared<SoundPoolParallelMock>();
1566 EXPECT_TRUE(soundPoolParallel1->CreateParallelSoundPool(maxStreams, audioRenderInfo));
1567 EXPECT_TRUE(soundPoolParallel2->CreateParallelSoundPool(maxStreams, audioRenderInfo));
1568 std::shared_ptr<SoundPoolCallbackTest> cb1 = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel1);
1569 soundPoolParallel1->SetSoundPoolCallback(cb1);
1570 std::shared_ptr<SoundPoolCallbackTest> cb2 = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel2);
1571 soundPoolParallel2->SetSoundPoolCallback(cb2);
1572
1573 functionTest086(soundPoolParallel1, soundPoolParallel2, cb1, cb2);
1574
1575 MEDIA_LOGI("soundpool_unit_test soundpool_function_086 after");
1576 }
1577
functionTest086(std::shared_ptr<SoundPoolParallelMock> soundPool1,std::shared_ptr<SoundPoolParallelMock> soundPool2,std::shared_ptr<SoundPoolCallbackTest> cb1,std::shared_ptr<SoundPoolCallbackTest> cb2)1578 void SoundPoolUnitTest::functionTest086(std::shared_ptr<SoundPoolParallelMock> soundPool1,
1579 std::shared_ptr<SoundPoolParallelMock> soundPool2, std::shared_ptr<SoundPoolCallbackTest> cb1,
1580 std::shared_ptr<SoundPoolCallbackTest> cb2)
1581 {
1582 int32_t soundNum = 2;
1583 int32_t num0 = 0;
1584 int32_t num1 = 1;
1585 int32_t num2 = 2;
1586 int32_t num3 = 3;
1587 fds_[num0] = open(g_fileName[num0].c_str(), O_RDWR);
1588 fds_[num1] = open(g_fileName[num1].c_str(), O_RDWR);
1589 std::string url0 = "fd://" + std::to_string(fds_[num0]);
1590 std::string url1 = "fd://" + std::to_string(fds_[num1]);
1591 soundIDs_[num0] = soundPool1->Load(url0);
1592 soundIDs_[num1] = soundPool1->Load(url1);
1593 EXPECT_GT(soundIDs_[num0], 0);
1594 EXPECT_GT(soundIDs_[num1], 0);
1595
1596 fds_[num2] = open(g_fileName[num2].c_str(), O_RDWR);
1597 fds_[num3] = open(g_fileName[num3].c_str(), O_RDWR);
1598 std::string url2 = "fd://" + std::to_string(fds_[num2]);
1599 std::string url3 = "fd://" + std::to_string(fds_[num3]);
1600 soundIDs_[num2] = soundPool2->Load(url2);
1601 soundIDs_[num3] = soundPool2->Load(url3);
1602 EXPECT_GT(soundIDs_[num2], 0);
1603 EXPECT_GT(soundIDs_[num3], 0);
1604 sleep(waitTime3);
1605
1606 struct PlayParams playParameters;
1607 streamIDs_[num0] = soundPool1->Play(soundIDs_[num0], playParameters);
1608 streamIDs_[num1] = soundPool1->Play(soundIDs_[num1], playParameters);
1609 EXPECT_GT(streamIDs_[num0], 0);
1610 EXPECT_GT(streamIDs_[num1], 0);
1611 streamIDs_[num2] = soundPool2->Play(soundIDs_[num2], playParameters);
1612 streamIDs_[num3] = soundPool2->Play(soundIDs_[num3], playParameters);
1613 EXPECT_GT(streamIDs_[num2], 0);
1614 EXPECT_GT(streamIDs_[num3], 0);
1615
1616 sleep(waitTime20);
1617
1618 ASSERT_TRUE(cb1->WaitLoadedSoundNum(soundNum));
1619 EXPECT_EQ(soundNum, cb1->GetHavePlayedSoundNum());
1620 ASSERT_TRUE(cb2->WaitLoadedSoundNum(soundNum));
1621 EXPECT_EQ(soundNum, cb2->GetHavePlayedSoundNum());
1622
1623 EXPECT_EQ(MSERR_OK, soundPool1->Unload(soundIDs_[num0]));
1624 EXPECT_EQ(MSERR_OK, soundPool1->Unload(soundIDs_[num1]));
1625 EXPECT_EQ(MSERR_OK, soundPool2->Unload(soundIDs_[num2]));
1626 EXPECT_EQ(MSERR_OK, soundPool2->Unload(soundIDs_[num3]));
1627
1628 EXPECT_EQ(MSERR_OK, soundPool1->Release());
1629 EXPECT_EQ(MSERR_OK, soundPool2->Release());
1630 }
1631
1632 /**
1633 * @tc.name: soundpool_function_087
1634 * @tc.desc: function test willplay Priority use soundPoolParallel
1635 * @tc.type: FUNC
1636 * @tc.require:
1637 */
1638 HWTEST_F(SoundPoolUnitTest, soundpool_function_087, TestSize.Level2)
1639 {
1640 MEDIA_LOGI("soundpool_unit_test soundpool_function_087 before");
1641
1642 int maxStreams = 1;
1643 create(maxStreams);
1644 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1645 soundPoolParallel_->SetSoundPoolCallback(cb);
1646 loadUrlParallel(g_fileName[2], loadNum_++);
1647 loadUrlParallel(g_fileName[1], loadNum_++);
1648 loadUrlParallel(g_fileName[4], loadNum_++);
1649 loadUrlParallel(g_fileName[5], loadNum_++);
1650 sleep(waitTime3);
1651 struct PlayParams playParameters;
1652 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1653 EXPECT_GT(streamIDs_[playNum_], 0);
1654 int32_t setPriority = soundPoolParallel_->SetPriority(streamIDs_[0], 1);
1655 EXPECT_EQ(MSERR_OK, setPriority);
1656 playNum_++;
1657 sleep(waitTime1);
1658
1659 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1660 EXPECT_GT(streamIDs_[playNum_], 0);
1661 setPriority = soundPoolParallel_->SetPriority(streamIDs_[1], 2);
1662 EXPECT_EQ(MSERR_OK, setPriority);
1663 playNum_++;
1664 sleep(waitTime1);
1665
1666 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[2], playParameters);
1667 EXPECT_GT(streamIDs_[playNum_], 0);
1668 setPriority = soundPoolParallel_->SetPriority(streamIDs_[2], 3);
1669 EXPECT_EQ(MSERR_OK, setPriority);
1670 playNum_++;
1671 sleep(waitTime1);
1672
1673 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[3], playParameters);
1674 EXPECT_GT(streamIDs_[playNum_], 0);
1675 setPriority = soundPoolParallel_->SetPriority(streamIDs_[3], 4);
1676 EXPECT_EQ(MSERR_OK, setPriority);
1677 playNum_++;
1678 sleep(waitTime20);
1679
1680 MEDIA_LOGI("soundpool_unit_test soundpool_function_087 after");
1681 }
1682
1683
1684 /**
1685 * @tc.name: soundpool_function_088
1686 * @tc.desc: function test willplay Priority use soundPoolParallel
1687 * @tc.type: FUNC
1688 * @tc.require:
1689 */
1690 HWTEST_F(SoundPoolUnitTest, soundpool_function_088, TestSize.Level2)
1691 {
1692 MEDIA_LOGI("soundpool_unit_test soundpool_function_088 before");
1693
1694 int maxStreams = 1;
1695 create(maxStreams);
1696 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1697 soundPoolParallel_->SetSoundPoolCallback(cb);
1698 loadUrlParallel(g_fileName[2], loadNum_++);
1699 loadUrlParallel(g_fileName[1], loadNum_++);
1700 loadUrlParallel(g_fileName[4], loadNum_++);
1701 loadUrlParallel(g_fileName[5], loadNum_++);
1702 sleep(waitTime3);
1703 struct PlayParams playParameters;
1704 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[0], playParameters);
1705 EXPECT_GT(streamIDs_[playNum_], 0);
1706 int32_t setPriority = soundPoolParallel_->SetPriority(streamIDs_[0], 1);
1707 EXPECT_EQ(MSERR_OK, setPriority);
1708 playNum_++;
1709 sleep(waitTime1);
1710
1711 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[1], playParameters);
1712 EXPECT_GT(streamIDs_[playNum_], 0);
1713 setPriority = soundPoolParallel_->SetPriority(streamIDs_[1], 2);
1714 EXPECT_EQ(MSERR_OK, setPriority);
1715 playNum_++;
1716 sleep(waitTime1);
1717
1718 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[2], playParameters);
1719 EXPECT_GT(streamIDs_[playNum_], 0);
1720 setPriority = soundPoolParallel_->SetPriority(streamIDs_[2], 3);
1721 EXPECT_EQ(MSERR_OK, setPriority);
1722 playNum_++;
1723 sleep(waitTime20);
1724
1725 MEDIA_LOGI("soundpool_unit_test soundpool_function_088 after");
1726 }
1727
1728 /**
1729 * @tc.name: soundpool_function_089
1730 * @tc.desc: function test SetVolume rightVolume 3.0 use soundPoolParallel
1731 * @tc.type: FUNC
1732 * @tc.require:
1733 */
1734 HWTEST_F(SoundPoolUnitTest, soundpool_function_089, TestSize.Level2)
1735 {
1736 MEDIA_LOGI("soundpool_unit_test soundpool_function_089 before");
1737 int maxStreams = 3;
1738 create(maxStreams);
1739 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1740 ASSERT_TRUE(cb != nullptr);
1741 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1742 ASSERT_TRUE(ret == 0);
1743 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1744 sleep(waitTime3);
1745 while (true) {
1746 if (cb->GetHaveLoadedSoundNum() == 1) {
1747 cout << "All sound loaded Url break. loaded sound num = " << cb->GetHaveLoadedSoundNum() << endl;
1748 cb->ResetHaveLoadedSoundNum();
1749 break;
1750 }
1751 }
1752 struct PlayParams playParameters;
1753 float rightVolume = 3.0;
1754 if (soundIDs_[loadNum_] > 0) {
1755 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1756 EXPECT_GT(streamIDs_[playNum_], 0);
1757 sleep(waitTime1);
1758 } else {
1759 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1760 }
1761 cb->ResetHavePlayedSoundNum();
1762 MEDIA_LOGI("soundpool_unit_test soundpool_function_089 after");
1763 }
1764
1765 /**
1766 * @tc.name: soundpool_function_090
1767 * @tc.desc: function test SetVolume leftVolume 3.0 use soundPoolParallel
1768 * @tc.type: FUNC
1769 * @tc.require:
1770 */
1771 HWTEST_F(SoundPoolUnitTest, soundpool_function_090, TestSize.Level2)
1772 {
1773 MEDIA_LOGI("soundpool_unit_test soundpool_function_090 before");
1774 int maxStreams = 3;
1775 create(maxStreams);
1776 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1777 ASSERT_TRUE(cb != nullptr);
1778 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1779 ASSERT_TRUE(ret == 0);
1780 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1781 sleep(waitTime3);
1782 while (true) {
1783 if (cb->GetHaveLoadedSoundNum() == 1) {
1784 cout << "All sound loaded Url break. loaded sound num = " << cb->GetHaveLoadedSoundNum() << endl;
1785 cb->ResetHaveLoadedSoundNum();
1786 break;
1787 }
1788 }
1789 struct PlayParams playParameters;
1790 float leftVolume = 3.0;
1791 if (soundIDs_[loadNum_] > 0) {
1792 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1793 EXPECT_GT(streamIDs_[playNum_], 0);
1794 sleep(waitTime1);
1795 int32_t setVol = soundPoolParallel_->SetVolume(streamIDs_[playNum_], leftVolume, 0.0);
1796 EXPECT_EQ(MSERR_OK, setVol);
1797 sleep(waitTime1);
1798 } else {
1799 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1800 }
1801 cb->ResetHavePlayedSoundNum();
1802 MEDIA_LOGI("soundpool_unit_test soundpool_function_090 after");
1803 }
1804
1805 /**
1806 * @tc.name: soundpool_function_091
1807 * @tc.desc: function test SetVolume 2.0 use soundPoolParallel
1808 * @tc.type: FUNC
1809 * @tc.require:
1810 */
1811 HWTEST_F(SoundPoolUnitTest, soundpool_function_091, TestSize.Level2)
1812 {
1813 MEDIA_LOGI("soundpool_unit_test soundpool_function_091 before");
1814 int maxStreams = 3;
1815 create(maxStreams);
1816 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1817 ASSERT_TRUE(cb != nullptr);
1818 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1819 ASSERT_TRUE(ret == 0);
1820 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1821 sleep(waitTime3);
1822 while (true) {
1823 if (cb->GetHaveLoadedSoundNum() == 1) {
1824 cout << "All sound loaded Url break. loaded sound num = " << cb->GetHaveLoadedSoundNum() << endl;
1825 cb->ResetHaveLoadedSoundNum();
1826 break;
1827 }
1828 }
1829 struct PlayParams playParameters;
1830 float leftVolume = 2.0;
1831 float rightVolume = 2.0;
1832 if (soundIDs_[loadNum_] > 0) {
1833 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1834 EXPECT_GT(streamIDs_[playNum_], 0);
1835 sleep(waitTime1);
1836 int32_t setVol = soundPoolParallel_->SetVolume(streamIDs_[playNum_], leftVolume, rightVolume);
1837 EXPECT_EQ(MSERR_OK, setVol);
1838 sleep(waitTime1);
1839 } else {
1840 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1841 }
1842 cb->ResetHavePlayedSoundNum();
1843 MEDIA_LOGI("soundpool_unit_test soundpool_function_091 after");
1844 }
1845
1846 /**
1847 * @tc.name: soundpool_function_092
1848 * @tc.desc: function test SetVolume 1.0, 2.0 use soundPoolParallel
1849 * @tc.type: FUNC
1850 * @tc.require:
1851 */
1852 HWTEST_F(SoundPoolUnitTest, soundpool_function_092, TestSize.Level2)
1853 {
1854 MEDIA_LOGI("soundpool_unit_test soundpool_function_092 before");
1855 int maxStreams = 3;
1856 create(maxStreams);
1857 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1858 ASSERT_TRUE(cb != nullptr);
1859 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1860 ASSERT_TRUE(ret == 0);
1861 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1862 sleep(waitTime3);
1863 while (true) {
1864 if (cb->GetHaveLoadedSoundNum() == 1) {
1865 cout << "All sound loaded Url break. loaded sound num = " << cb->GetHaveLoadedSoundNum() << endl;
1866 cb->ResetHaveLoadedSoundNum();
1867 break;
1868 }
1869 }
1870 struct PlayParams playParameters;
1871 float leftVolume = 1.0;
1872 float rightVolume = 2.0;
1873 if (soundIDs_[loadNum_] > 0) {
1874 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1875 EXPECT_GT(streamIDs_[playNum_], 0);
1876 sleep(waitTime1);
1877 int32_t setVol = soundPoolParallel_->SetVolume(streamIDs_[playNum_], leftVolume, rightVolume);
1878 EXPECT_EQ(MSERR_OK, setVol);
1879 sleep(waitTime1);
1880 } else {
1881 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1882 }
1883 cb->ResetHavePlayedSoundNum();
1884 MEDIA_LOGI("soundpool_unit_test soundpool_function_092 after");
1885 }
1886
1887 /**
1888 * @tc.name: soundpool_function_093
1889 * @tc.desc: function test SetVolume 2.0, 1.0 use soundPoolParallel
1890 * @tc.type: FUNC
1891 * @tc.require:
1892 */
1893 HWTEST_F(SoundPoolUnitTest, soundpool_function_093, TestSize.Level2)
1894 {
1895 MEDIA_LOGI("soundpool_unit_test soundpool_function_093 before");
1896 int maxStreams = 3;
1897 create(maxStreams);
1898 std::shared_ptr<SoundPoolCallbackTest> cb = std::make_shared<SoundPoolCallbackTest>(soundPoolParallel_);
1899 ASSERT_TRUE(cb != nullptr);
1900 int32_t ret = soundPoolParallel_->SetSoundPoolCallback(cb);
1901 ASSERT_TRUE(ret == 0);
1902 loadUrlParallel(g_fileName[loadNum_], loadNum_);
1903 sleep(waitTime3);
1904 while (true) {
1905 if (cb->GetHaveLoadedSoundNum() == 1) {
1906 cout << "All sound loaded Url break. loaded sound num = " << cb->GetHaveLoadedSoundNum() << endl;
1907 cb->ResetHaveLoadedSoundNum();
1908 break;
1909 }
1910 }
1911 struct PlayParams playParameters;
1912 float leftVolume = 2.0;
1913 float rightVolume = 1.0;
1914 if (soundIDs_[loadNum_] > 0) {
1915 streamIDs_[playNum_] = soundPoolParallel_->Play(soundIDs_[loadNum_], playParameters);
1916 EXPECT_GT(streamIDs_[playNum_], 0);
1917 sleep(waitTime1);
1918 int32_t setVol = soundPoolParallel_->SetVolume(streamIDs_[playNum_], leftVolume, rightVolume);
1919 EXPECT_EQ(MSERR_OK, setVol);
1920 sleep(waitTime1);
1921 } else {
1922 cout << "Get soundId failed, please try to get soundId: " << soundIDs_[loadNum_] << endl;
1923 }
1924 cb->ResetHavePlayedSoundNum();
1925 MEDIA_LOGI("soundpool_unit_test soundpool_function_093 after");
1926 }
1927 } // namespace Media
1928 } // namespace OHOS