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 <gtest/gtest.h>
17 #include "tone_player_impl.h"
18 #include "audio_renderer_private.h"
19 #include "audio_errors.h"
20 #include "parameter.h"
21
22 using namespace testing::ext;
23 namespace OHOS {
24 namespace AudioStandard {
25 constexpr uint32_t SLEEP_TIME = 30000;
26 static size_t g_reqBufLen = 0;
27 class AudioToneplayerUnitTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 };
34
SetUpTestCase(void)35 void AudioToneplayerUnitTest::SetUpTestCase(void)
36 {
37 // input testsuit setup step，setup invoked before all testcases
38 }
39
TearDownTestCase(void)40 void AudioToneplayerUnitTest::TearDownTestCase(void)
41 {
42 // input testsuit teardown step，teardown invoked after all testcases
43 }
44
SetUp(void)45 void AudioToneplayerUnitTest::SetUp(void)
46 {
47 // input testcase setup step，setup invoked before each testcases
48 }
49
TearDown(void)50 void AudioToneplayerUnitTest::TearDown(void)
51 {
52 // input testcase teardown step，teardown invoked after each testcases
53 }
54
55 class AudioRendererCallbackTest : public AudioRendererCallback {
56 public:
OnInterrupt(const InterruptEvent & interruptEvent)57 void OnInterrupt(const InterruptEvent &interruptEvent) override {}
OnStateChange(const RendererState state,const StateChangeCmdType cmdType)58 void OnStateChange(const RendererState state, const StateChangeCmdType cmdType) override {}
59 };
60
61 class AudioToneplayerCallbackTest : public AudioRendererCallback {
62 public:
63 void OnWriteData(size_t length);
64 };
65
OnWriteData(size_t length)66 void AudioToneplayerCallbackTest::OnWriteData(size_t length)
67 {
68 g_reqBufLen = length;
69 }
70
71 /**
72 * @tc.name : Test Create API
73 * @tc.type : FUNC
74 * @tc.number: Create_001
75 * @tc.desc : Test Create interface.
76 */
77 HWTEST(AudioToneplayerUnitTest, Create_001, TestSize.Level1)
78 {
79 std::shared_ptr<TonePlayer> toneplayer = nullptr;
80 AudioRendererInfo rendererInfo = {};
81 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
82 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
83 rendererInfo.rendererFlags = 0;
84 toneplayer = TonePlayer::Create(rendererInfo);
85 ASSERT_NE(nullptr, toneplayer);
86
87 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
88 toneplayer = TonePlayer::Create(rendererInfo);
89 ASSERT_NE(nullptr, toneplayer);
90
91 toneplayer->Release();
92 }
93
94 /**
95 * @tc.name : Test toneplayer loading API
96 * @tc.type : FUNC
97 * @tc.number: Toneplayer_001
98 * @tc.desc : Test create->LoadTone->StartTone->StopTone->Release interface.
99 */
100 HWTEST(AudioToneplayerUnitTest, Toneplayer_001, TestSize.Level1)
101 {
102 AudioRendererInfo rendererInfo = {};
103 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
104 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
105 rendererInfo.rendererFlags = 0;
106 std::shared_ptr<TonePlayer> toneplayer = TonePlayer::Create(rendererInfo);
107 ASSERT_NE(nullptr, toneplayer);
108
109 bool ret = toneplayer->LoadTone(TONE_TYPE_DIAL_1);
110 EXPECT_EQ(true, ret);
111
112 bool startRet = toneplayer->StartTone();
113 EXPECT_EQ(true, startRet);
114
115 usleep(SLEEP_TIME); // 30ms sleep time
116 bool stopRet = toneplayer->StopTone();
117 EXPECT_EQ(true, stopRet);
118
119 bool releaseRet = toneplayer->Release();
120 EXPECT_EQ(true, releaseRet);
121 }
122
123 #ifdef TEMP_DISABLE
124 /**
125 * @tc.name : Test toneplayer loading API
126 * @tc.type : FUNC
127 * @tc.number: Toneplayer_002
128 * @tc.desc : Test create->StartTone->StopTone->Release interface.
129 */
130 HWTEST(AudioToneplayerUnitTest, Toneplayer_002, TestSize.Level1)
131 {
132 AudioRendererInfo rendererInfo = {};
133 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
134 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
135 rendererInfo.rendererFlags = 0;
136 std::shared_ptr<TonePlayer> toneplayer = TonePlayer::Create(rendererInfo);
137 ASSERT_NE(nullptr, toneplayer);
138
139 bool ret = toneplayer->LoadTone(TONE_TYPE_DIAL_2);
140 EXPECT_EQ(true, ret);
141
142 usleep(SLEEP_TIME); // 30ms sleep time
143 bool stopRet = toneplayer->StopTone();
144 EXPECT_EQ(false, stopRet);
145
146 bool releaseRet = toneplayer->Release();
147 EXPECT_EQ(true, releaseRet);
148 }
149 #endif
150
151 /**
152 * @tc.name : Test toneplayer loading API
153 * @tc.type : FUNC
154 * @tc.number: Toneplayer_003
155 * @tc.desc : Test create->StartTone->Release interface.
156 */
157 HWTEST(AudioToneplayerUnitTest, Toneplayer_003, TestSize.Level1)
158 {
159 AudioRendererInfo rendererInfo = {};
160 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
161 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
162 rendererInfo.rendererFlags = 0;
163 std::shared_ptr<TonePlayer> toneplayer = TonePlayer::Create(rendererInfo);
164 ASSERT_NE(nullptr, toneplayer);
165
166 bool startRet = toneplayer->StartTone();
167 EXPECT_EQ(false, startRet);
168
169 bool releaseRet = toneplayer->Release();
170 EXPECT_EQ(true, releaseRet);
171 }
172
173 /**
174 * @tc.name : Test toneplayer loading API
175 * @tc.type : FUNC
176 * @tc.number: Toneplayer_004
177 * @tc.desc : Test create->LoadTone->StartTone->Release interface.
178 */
179 HWTEST(AudioToneplayerUnitTest, Toneplayer_004, TestSize.Level1)
180 {
181 AudioRendererInfo rendererInfo = {};
182 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
183 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
184 rendererInfo.rendererFlags = 0;
185 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
186 ASSERT_NE(nullptr, toneplayer);
187
188 bool ret = toneplayer->LoadTone(TONE_TYPE_DIAL_6);
189 EXPECT_EQ(true, ret);
190
191 bool startRet = toneplayer->StartTone();
192 EXPECT_EQ(true, startRet);
193
194 usleep(SLEEP_TIME); // 30ms sleep time
195
196 bool releaseRet = toneplayer->Release();
197 EXPECT_EQ(true, releaseRet);
198 }
199
200 /**
201 * @tc.name : Test toneplayer loading API
202 * @tc.type : FUNC
203 * @tc.number: Toneplayer_005
204 * @tc.desc : Test create->LoadTone->StartTone->Release interface.
205 */
206 HWTEST(AudioToneplayerUnitTest, Toneplayer_005, TestSize.Level1)
207 {
208 AudioRendererInfo rendererInfo = {};
209 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
210 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
211 rendererInfo.rendererFlags = 0;
212 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
213 ASSERT_NE(nullptr, toneplayer);
214
215 bool ret = toneplayer->LoadTone(TONE_TYPE_DIAL_6);
216 EXPECT_EQ(true, ret);
217
218 bool startRet = toneplayer->StartTone();
219 EXPECT_EQ(true, startRet);
220
221 bool stopRet = toneplayer->StopTone();
222 EXPECT_EQ(true, stopRet);
223
224 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_STOPPED;
225 bool checkRet = toneplayer->CheckToneStopped();
226 EXPECT_EQ(true, checkRet);
227
228 bool releaseRet = toneplayer->Release();
229 EXPECT_EQ(true, releaseRet);
230 }
231
232 /**
233 * @tc.name : Test toneplayer loading API
234 * @tc.type : FUNC
235 * @tc.number: Toneplayer_006
236 * @tc.desc : Test create->StartTone->StopTone->LoadTone->LoadTone->Release interface.
237 */
238 HWTEST(AudioToneplayerUnitTest, Toneplayer_006, TestSize.Level1)
239 {
240 AudioRendererInfo rendererInfo = {};
241 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
242 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
243 rendererInfo.rendererFlags = 0;
244 std::shared_ptr<TonePlayer> toneplayer = TonePlayer::Create(rendererInfo);
245 ASSERT_NE(nullptr, toneplayer);
246
247 bool ret = toneplayer->StartTone();
248 EXPECT_EQ(false, ret);
249
250 ret = toneplayer->StopTone();
251 EXPECT_EQ(false, ret);
252
253 ret = toneplayer->LoadTone(NUM_TONES);
254 ret = toneplayer->LoadTone(NUM_TONES);
255 EXPECT_EQ(false, ret);
256
257 bool releaseRet = toneplayer->Release();
258 EXPECT_EQ(true, releaseRet);
259 }
260
261 /**
262 * @tc.name : Test toneplayer loading API
263 * @tc.type : FUNC
264 * @tc.number: Toneplayer_StartTone_001
265 * @tc.desc : Test StartTone interface.
266 */
267 HWTEST(AudioToneplayerUnitTest, Toneplayer_StartTone_001, TestSize.Level1)
268 {
269 AudioRendererInfo rendererInfo = {};
270 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
271 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
272 rendererInfo.rendererFlags = 0;
273 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
274 ASSERT_NE(nullptr, toneplayer);
275
276 toneplayer->isRendererInited_ = true;
277 bool ret = toneplayer->StartTone();
278 ret = toneplayer->StopTone();
279
280 bool releaseRet = toneplayer->Release();
281 EXPECT_EQ(true, releaseRet);
282 }
283
284 /**
285 * @tc.name : Test toneplayer loading API
286 * @tc.type : FUNC
287 * @tc.number: Toneplayer_StartTone_002
288 * @tc.desc : Test StartTone interface.
289 */
290 HWTEST(AudioToneplayerUnitTest, Toneplayer_StartTone_002, TestSize.Level1)
291 {
292 AudioRendererInfo rendererInfo = {};
293 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
294 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
295 rendererInfo.rendererFlags = 0;
296 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
297 ASSERT_NE(nullptr, toneplayer);
298
299 toneplayer->isRendererInited_ = true;
300 toneplayer->audioRenderer_ = nullptr;
301 toneplayer->StartTone();
302 toneplayer->StopTone();
303
304 bool releaseRet = toneplayer->Release();
305 EXPECT_EQ(true, releaseRet);
306 }
307
308 /**
309 * @tc.name : Test toneplayer loading API
310 * @tc.type : FUNC
311 * @tc.number: Toneplayer_StartTone_003
312 * @tc.desc : Test StartTone interface.
313 */
314 HWTEST(AudioToneplayerUnitTest, Toneplayer_StartTone_003, TestSize.Level1)
315 {
316 AudioRendererInfo rendererInfo = {};
317 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
318 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
319 rendererInfo.rendererFlags = 0;
320 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
321 ASSERT_NE(nullptr, toneplayer);
322
323 toneplayer->isRendererInited_ = false;
324 toneplayer->StartTone();
325 toneplayer->StopTone();
326
327 bool releaseRet = toneplayer->Release();
328 EXPECT_EQ(true, releaseRet);
329 }
330
331 /**
332 * @tc.name : Test toneplayer loading API
333 * @tc.type : FUNC
334 * @tc.number: Toneplayer_StartTone_004
335 * @tc.desc : Test StartTone interface.
336 */
337 HWTEST(AudioToneplayerUnitTest, Toneplayer_StartTone_004, TestSize.Level1)
338 {
339 AudioRendererInfo rendererInfo = {};
340 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
341 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
342 rendererInfo.rendererFlags = 0;
343 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
344 ASSERT_NE(nullptr, toneplayer);
345
346 toneplayer->isRendererInited_ = false;
347 toneplayer->audioRenderer_ = nullptr;
348 toneplayer->StartTone();
349 toneplayer->StopTone();
350
351 bool releaseRet = toneplayer->Release();
352 EXPECT_EQ(true, releaseRet);
353 }
354
355 /**
356 * @tc.name : Test Create API
357 * @tc.type : FUNC
358 * @tc.number: Create_002
359 * @tc.desc : Test Create interface.
360 */
361 HWTEST(AudioToneplayerUnitTest, Create_002, TestSize.Level1)
362 {
363 std::string cachePath = "/data/local/tmp";
364 std::shared_ptr<TonePlayer> toneplayer = nullptr;
365 AudioRendererInfo rendererInfo = {};
366 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
367 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
368 rendererInfo.rendererFlags = 0;
369 toneplayer = TonePlayer::Create(cachePath, rendererInfo);
370 ASSERT_NE(nullptr, toneplayer);
371
372 toneplayer->Release();
373 }
374
375 #ifdef TEMP_DISABLE
376 /**
377 * @tc.name : Test GetCurrentSegmentUpdated API
378 * @tc.type : FUNC
379 * @tc.number: GetCurrentSegmentUpdated_001
380 * @tc.desc : Test GetCurrentSegmentUpdated interface.
381 */
382 HWTEST(AudioToneplayerUnitTest, GetCurrentSegmentUpdated_001, TestSize.Level1)
383 {
384 AudioRendererInfo rendererInfo = {};
385 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
386 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
387 rendererInfo.rendererFlags = 0;
388 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
389 ASSERT_NE(nullptr, toneplayer);
390
391 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
392 EXPECT_NE(nullptr, toneplayer->toneInfo_);
393
394 toneplayer->currSegment_ = 0;
395 toneplayer->toneInfo_->segments[0].loopCnt = 0;
396 toneplayer->GetCurrentSegmentUpdated();
397 EXPECT_EQ(1, toneplayer->currSegment_);
398
399 toneplayer->loopCounter_ = 0;
400 toneplayer->currSegment_ = 0;
401 toneplayer->toneInfo_->segments[0].loopCnt = 1;
402 toneplayer->GetCurrentSegmentUpdated();
403 EXPECT_EQ(1, toneplayer->loopCounter_);
404
405 toneplayer->loopCounter_ = 2;
406 toneplayer->currSegment_ = 0;
407 toneplayer->toneInfo_->segments[0].loopCnt = 1;
408 toneplayer->GetCurrentSegmentUpdated();
409 EXPECT_EQ(0, toneplayer->loopCounter_);
410 }
411
412 /**
413 * @tc.name : Test CheckToneContinuity API
414 * @tc.type : FUNC
415 * @tc.number: CheckToneContinuity_001
416 * @tc.desc : Test CheckToneContinuity interface.
417 */
418 HWTEST(AudioToneplayerUnitTest, CheckToneContinuity_001, TestSize.Level1)
419 {
420 bool ret = false;
421 AudioRendererInfo rendererInfo = {};
422 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
423 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
424 rendererInfo.rendererFlags = 0;
425 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
426 ASSERT_NE(nullptr, toneplayer);
427
428 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
429 EXPECT_NE(nullptr, toneplayer->toneInfo_);
430
431 toneplayer->currSegment_ = 0;
432 toneplayer->toneInfo_->segments[0].duration = 1;
433 ret = toneplayer->CheckToneContinuity();
434 EXPECT_EQ(true, ret);
435
436 toneplayer->currSegment_ = 0;
437 toneplayer->toneInfo_->segments[0].duration = 0;
438 toneplayer->currCount_ = 0;
439 toneplayer->toneInfo_->repeatCnt = 1;
440 ret = toneplayer->CheckToneContinuity();
441 EXPECT_EQ(true, ret);
442
443 toneplayer->currSegment_ = 0;
444 toneplayer->toneInfo_->segments[0].duration = 0;
445 toneplayer->currCount_ = 1;
446 toneplayer->toneInfo_->repeatCnt = 0;
447 ret = toneplayer->CheckToneContinuity();
448 EXPECT_EQ(false, ret);
449 }
450 #endif
451
452 /**
453 * @tc.name : Test OnInterrupt API
454 * @tc.type : FUNC
455 * @tc.number: OnInterrupt_001
456 * @tc.desc : Test OnInterrupt interface.
457 */
458 HWTEST(AudioToneplayerUnitTest, OnInterrupt_001, TestSize.Level1)
459 {
460 AudioRendererInfo rendererInfo = {};
461 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
462 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
463 rendererInfo.rendererFlags = 0;
464 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
465 ASSERT_NE(nullptr, toneplayer);
466
467 InterruptEvent interruptEvent;
468 interruptEvent.eventType = InterruptType::INTERRUPT_TYPE_END;
469 toneplayer->OnInterrupt(interruptEvent);
470 EXPECT_EQ(ToneType::NUM_TONES, toneplayer->toneType_);
471 }
472
473 #ifdef TEMP_DISABLE
474 /**
475 * @tc.name : Test ContinueToneplay API
476 * @tc.type : FUNC
477 * @tc.number: ContinueToneplay_001
478 * @tc.desc : Test ContinueToneplay interface.
479 */
480 HWTEST(AudioToneplayerUnitTest, ContinueToneplay_001, TestSize.Level1)
481 {
482 bool ret = false;
483 AudioRendererInfo rendererInfo = {};
484 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
485 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
486 rendererInfo.rendererFlags = 0;
487 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
488 ASSERT_NE(nullptr, toneplayer);
489 uint32_t reqSample = 4;
490 int8_t buff[8] = {0};
491 int8_t *audioBuffer = buff;
492
493 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_STOPPED;
494 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
495 EXPECT_EQ(ret, false);
496
497 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
498 EXPECT_NE(nullptr, toneplayer->toneInfo_);
499 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
500 toneplayer->totalSample_ = 2;
501 toneplayer->nextSegSample_ = 1;
502 toneplayer->currSegment_ = 0;
503 toneplayer->toneInfo_->segments[0].duration = 1;
504 ret = toneplayer->CheckToneContinuity();
505 EXPECT_EQ(true, ret);
506 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
507 EXPECT_EQ(ret, true);
508
509 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
510 toneplayer->currSegment_ = 0;
511 toneplayer->toneInfo_->segments[0].duration = 0;
512 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
513 EXPECT_EQ(ret, true);
514 }
515
516 /**
517 * @tc.name : Test ContinueToneplay API
518 * @tc.type : FUNC
519 * @tc.number: ContinueToneplay_002
520 * @tc.desc : Test ContinueToneplay interface.
521 */
522 HWTEST(AudioToneplayerUnitTest, ContinueToneplay_002, TestSize.Level1)
523 {
524 bool ret = false;
525 AudioRendererInfo rendererInfo = {};
526 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
527 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
528 rendererInfo.rendererFlags = 0;
529 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
530 ASSERT_NE(nullptr, toneplayer);
531 uint32_t reqSample = 4;
532 int8_t buff[8] = {0};
533 int8_t *audioBuffer = buff;
534
535 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
536 EXPECT_NE(nullptr, toneplayer->toneInfo_);
537 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
538 toneplayer->totalSample_ = 0;
539 toneplayer->nextSegSample_ = 1;
540 toneplayer->currSegment_ = 0;
541 toneplayer->toneInfo_->segments[0].duration = 0;
542 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
543 EXPECT_EQ(ret, true);
544 }
545
546 /**
547 * @tc.name : Test ContinueToneplay API
548 * @tc.type : FUNC
549 * @tc.number: ContinueToneplay_003
550 * @tc.desc : Test ContinueToneplay interface.
551 */
552 HWTEST(AudioToneplayerUnitTest, ContinueToneplay_003, TestSize.Level1)
553 {
554 bool ret = false;
555 AudioRendererInfo rendererInfo = {};
556 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
557 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
558 rendererInfo.rendererFlags = 0;
559 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
560 ASSERT_NE(nullptr, toneplayer);
561 uint32_t reqSample = 4;
562 int8_t buff[8] = {0};
563 int8_t *audioBuffer = buff;
564
565 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
566 EXPECT_NE(nullptr, toneplayer->toneInfo_);
567 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
568 toneplayer->totalSample_ = 0;
569 toneplayer->nextSegSample_ = 1;
570 toneplayer->currSegment_ = 0;
571 toneplayer->toneInfo_->segments[0].duration = 1;
572 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
573 EXPECT_EQ(ret, true);
574 }
575
576 /**
577 * @tc.name : Test CheckToneStopped API
578 * @tc.type : FUNC
579 * @tc.number: CheckToneStopped_001
580 * @tc.desc : Test CheckToneStopped interface.
581 */
582 HWTEST(AudioToneplayerUnitTest, CheckToneStopped_001, TestSize.Level1)
583 {
584 AudioRendererInfo rendererInfo = {};
585 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
586 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
587 rendererInfo.rendererFlags = 0;
588 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
589 ASSERT_NE(nullptr, toneplayer);
590
591 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_STOPPED;
592 bool ret = toneplayer->CheckToneStopped();
593 EXPECT_EQ(true, ret);
594
595 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
596 EXPECT_NE(nullptr, toneplayer->toneInfo_);
597 toneplayer->currSegment_ = 0;
598 toneplayer->toneInfo_->segments[0].duration = 0;
599 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
600 ret = toneplayer->CheckToneStopped();
601 EXPECT_EQ(true, ret);
602
603 toneplayer->currSegment_ = 0;
604 toneplayer->toneInfo_->segments[0].duration = 1;
605 toneplayer->totalSample_ = 3;
606 toneplayer->maxSample_ = 2;
607 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
608 ret = toneplayer->CheckToneStopped();
609 EXPECT_EQ(true, ret);
610
611 toneplayer->currSegment_ = 0;
612 toneplayer->toneInfo_->segments[0].duration = 1;
613 toneplayer->totalSample_ = 1;
614 toneplayer->maxSample_ = 2;
615 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_STOPPING;
616 ret = toneplayer->CheckToneStopped();
617 EXPECT_EQ(true, ret);
618
619 toneplayer->currSegment_ = 0;
620 toneplayer->toneInfo_->segments[0].duration = 1;
621 toneplayer->totalSample_ = 1;
622 toneplayer->maxSample_ = 2;
623 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_IDLE;
624 ret = toneplayer->CheckToneStopped();
625 EXPECT_EQ(false, ret);
626 }
627 #endif
628
629 /**
630 * @tc.name : Test TonePlayerImpl API
631 * @tc.type : FUNC
632 * @tc.number: TonePlayerImpl_001
633 * @tc.desc : Test TonePlayerImpl interface.
634 */
635 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_001, TestSize.Level1)
636 {
637 AudioRendererInfo rendererInfo = {};
638 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
639 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
640 rendererInfo.rendererFlags = 0;
641 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
642 EXPECT_NE(nullptr, toneplayer);
643
644 toneplayer->initialToneInfo_ = nullptr;
645 auto ret = toneplayer->InitToneWaveInfo();
646 EXPECT_EQ(ret, false);
647 }
648
649 /**
650 * @tc.name : Test TonePlayerImpl API
651 * @tc.type : FUNC
652 * @tc.number: TonePlayerImpl_002
653 * @tc.desc : Test TonePlayerImpl interface.
654 */
655 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_002, TestSize.Level1)
656 {
657 AudioRendererInfo rendererInfo = {};
658 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
659 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
660 rendererInfo.rendererFlags = 0;
661 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
662 EXPECT_NE(nullptr, toneplayer);
663
664 toneplayer->toneState_ = TonePlayerImpl::TONE_INIT;
665 toneplayer->isRendererInited_ = false;
666 auto ret = toneplayer->StartTone();
667 EXPECT_EQ(ret, false);
668 }
669
670 /**
671 * @tc.name : Test TonePlayerImpl API
672 * @tc.type : FUNC
673 * @tc.number: TonePlayerImpl_003
674 * @tc.desc : Test TonePlayerImpl interface.
675 */
676 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_003, TestSize.Level1)
677 {
678 AudioRendererInfo rendererInfo = {};
679 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
680 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
681 rendererInfo.rendererFlags = 0;
682 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
683 EXPECT_NE(nullptr, toneplayer);
684
685 toneplayer->toneState_ = TonePlayerImpl::TONE_INIT;
686 toneplayer->isRendererInited_ = true;
687 toneplayer->audioRenderer_ = nullptr;
688
689 auto ret = toneplayer->StartTone();
690 EXPECT_EQ(ret, false);
691 }
692
693 /**
694 * @tc.name : Test TonePlayerImpl API
695 * @tc.type : FUNC
696 * @tc.number: TonePlayerImpl_004
697 * @tc.desc : Test TonePlayerImpl interface.
698 */
699 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_004, TestSize.Level1)
700 {
701 AudioRendererInfo rendererInfo = {};
702 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
703 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
704 rendererInfo.rendererFlags = 0;
705 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
706 EXPECT_NE(toneplayer, nullptr);
707
708 toneplayer->toneState_ = TonePlayerImpl::TONE_INIT;
709 toneplayer->isRendererInited_ = true;
710 toneplayer->currSegment_ = 0;
711
712 toneplayer->InitAudioRenderer();
713 EXPECT_NE(toneplayer->audioRenderer_, nullptr);
714
715 auto ret = toneplayer->StartTone();
716 EXPECT_EQ(ret, true);
717 }
718
719 /**
720 * @tc.name : Test TonePlayerImpl API
721 * @tc.type : FUNC
722 * @tc.number: TonePlayerImpl_005
723 * @tc.desc : Test TonePlayerImpl interface.
724 */
725 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_005, TestSize.Level1)
726 {
727 AudioRendererInfo rendererInfo = {};
728 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
729 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
730 rendererInfo.rendererFlags = 0;
731 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
732 EXPECT_NE(toneplayer, nullptr);
733
734 toneplayer->toneState_ = TonePlayerImpl::TONE_INIT;
735 toneplayer->audioRenderer_ = nullptr;
736
737 size_t length = 0;
738
739 toneplayer->OnWriteData(length);
740 EXPECT_NE(toneplayer, nullptr);
741 }
742
743 /**
744 * @tc.name : Test TonePlayerImpl API
745 * @tc.type : FUNC
746 * @tc.number: TonePlayerImpl_006
747 * @tc.desc : Test TonePlayerImpl interface.
748 */
749 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_006, TestSize.Level1)
750 {
751 AudioRendererInfo rendererInfo = {};
752 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
753 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
754 rendererInfo.rendererFlags = 0;
755 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
756 EXPECT_NE(toneplayer, nullptr);
757 toneplayer->isRendererInited_ = true;
758 toneplayer->currSegment_ = 0;
759 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
760 EXPECT_NE(toneplayer->toneInfo_, nullptr);
761
762 toneplayer->toneState_ = TonePlayerImpl::TONE_INIT;
763 toneplayer->InitAudioRenderer();
764 EXPECT_NE(toneplayer->audioRenderer_, nullptr);
765 size_t length = 0;
766
767 toneplayer->OnWriteData(length);
768 EXPECT_NE(toneplayer, nullptr);
769 }
770
771 /**
772 * @tc.name : Test TonePlayerImpl API
773 * @tc.type : FUNC
774 * @tc.number: TonePlayerImpl_007
775 * @tc.desc : Test ~TonePlayerImpl interface. audioRenderer_ != nullptr
776 */
777 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_007, TestSize.Level4)
778 {
779 AudioRendererInfo rendererInfo = {};
780 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
781 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
782 rendererInfo.rendererFlags = 0;
783
784 {
785 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
786 EXPECT_NE(toneplayer, nullptr);
787 toneplayer->isRendererInited_ = true;
788 toneplayer->currSegment_ = 0;
789
790 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
791 EXPECT_NE(toneplayer->toneInfo_, nullptr);
792
793 toneplayer->toneState_ = TonePlayerImpl::TONE_INIT;
794 toneplayer->InitAudioRenderer();
795 EXPECT_NE(toneplayer->audioRenderer_, nullptr);
796 }
797 }
798
799 /**
800 * @tc.name : Test TonePlayerImpl API
801 * @tc.type : FUNC
802 * @tc.number: TonePlayerImpl_008
803 * @tc.desc : Test GetCurrentSegmentUpdated interface.
804 */
805 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_008, TestSize.Level4)
806 {
807 AudioRendererInfo rendererInfo = {};
808 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
809 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
810 rendererInfo.rendererFlags = 0;
811
812 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
813 EXPECT_NE(toneplayer, nullptr);
814
815 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
816 EXPECT_NE(toneplayer->toneInfo_, nullptr);
817
818 toneplayer->currSegment_ = 0;
819 toneplayer->loopCounter_ = 0;
820 toneplayer->toneInfo_->segments[0].loopCnt = 1;
821 toneplayer->toneInfo_->segments[0].loopIndx = 1;
822
823 toneplayer->GetCurrentSegmentUpdated();
824 EXPECT_EQ(toneplayer->currSegment_, 1);
825 EXPECT_EQ(toneplayer->loopCounter_, 1);
826 }
827
828 /**
829 * @tc.name : Test TonePlayerImpl API
830 * @tc.type : FUNC
831 * @tc.number: TonePlayerImpl_009
832 * @tc.desc : Test GetCurrentSegmentUpdated interface.
833 */
834 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_009, TestSize.Level4)
835 {
836 AudioRendererInfo rendererInfo = {};
837 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
838 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
839 rendererInfo.rendererFlags = 0;
840
841 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
842 EXPECT_NE(toneplayer, nullptr);
843
844 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
845 EXPECT_NE(toneplayer->toneInfo_, nullptr);
846
847 toneplayer->currSegment_ = 1;
848 toneplayer->loopCounter_ = 1;
849 toneplayer->toneInfo_->segments[1].loopCnt = 3;
850 toneplayer->toneInfo_->segments[1].loopIndx = 3;
851
852 toneplayer->GetCurrentSegmentUpdated();
853 EXPECT_EQ(toneplayer->currSegment_, 3);
854 EXPECT_EQ(toneplayer->loopCounter_, 2);
855 }
856
857 /**
858 * @tc.name : Test TonePlayerImpl API
859 * @tc.type : FUNC
860 * @tc.number: TonePlayerImpl_010
861 * @tc.desc : Test GetCurrentSegmentUpdated interface.
862 */
863 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_010, TestSize.Level4)
864 {
865 AudioRendererInfo rendererInfo = {};
866 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
867 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
868 rendererInfo.rendererFlags = 0;
869
870 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
871 EXPECT_NE(toneplayer, nullptr);
872
873 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
874 EXPECT_NE(toneplayer->toneInfo_, nullptr);
875
876 toneplayer->currSegment_ = 0;
877 toneplayer->loopCounter_ = 3;
878 toneplayer->toneInfo_->segments[0].loopCnt = 1;
879 toneplayer->toneInfo_->segments[0].loopIndx = 1;
880
881 toneplayer->GetCurrentSegmentUpdated();
882 EXPECT_EQ(toneplayer->currSegment_, 1);
883 EXPECT_EQ(toneplayer->loopCounter_, 0);
884 }
885
886 /**
887 * @tc.name : Test TonePlayerImpl API
888 * @tc.type : FUNC
889 * @tc.number: TonePlayerImpl_011
890 * @tc.desc : Test GetCurrentSegmentUpdated interface.
891 */
892 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_011, TestSize.Level4)
893 {
894 AudioRendererInfo rendererInfo = {};
895 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
896 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
897 rendererInfo.rendererFlags = 0;
898
899 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
900 EXPECT_NE(toneplayer, nullptr);
901
902 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
903 EXPECT_NE(toneplayer->toneInfo_, nullptr);
904
905 toneplayer->currSegment_ = 1;
906 toneplayer->loopCounter_ = 1;
907 toneplayer->toneInfo_->segments[1].loopCnt = 1;
908 toneplayer->toneInfo_->segments[1].loopIndx = 1;
909
910 toneplayer->GetCurrentSegmentUpdated();
911 EXPECT_EQ(toneplayer->currSegment_, 2);
912 EXPECT_EQ(toneplayer->loopCounter_, 0);
913 }
914
915 /**
916 * @tc.name : Test TonePlayerImpl API
917 * @tc.type : FUNC
918 * @tc.number: TonePlayerImpl_012
919 * @tc.desc : Test CheckToneContinuity interface.
920 */
921 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_012, TestSize.Level4)
922 {
923 AudioRendererInfo rendererInfo = {};
924 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
925 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
926 rendererInfo.rendererFlags = 0;
927
928 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
929 EXPECT_NE(toneplayer, nullptr);
930
931 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
932 EXPECT_NE(toneplayer->toneInfo_, nullptr);
933
934 toneplayer->currSegment_ = 1;
935 toneplayer->loopCounter_ = 1;
936 toneplayer->toneInfo_->segments[1].loopCnt = 1;
937 toneplayer->toneInfo_->segments[1].loopIndx = 1;
938 toneplayer->toneInfo_->segments[2].duration = 1;
939
940 bool ret = toneplayer->CheckToneContinuity();
941 EXPECT_EQ(ret, true);
942 EXPECT_EQ(toneplayer->currSegment_, 2);
943 EXPECT_EQ(toneplayer->loopCounter_, 0);
944 }
945
946 /**
947 * @tc.name : Test TonePlayerImpl API
948 * @tc.type : FUNC
949 * @tc.number: TonePlayerImpl_013
950 * @tc.desc : Test ContinueToneplay interface.
951 */
952 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_013, TestSize.Level4)
953 {
954 AudioRendererInfo rendererInfo = {};
955 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
956 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
957 rendererInfo.rendererFlags = 0;
958
959 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
960 EXPECT_NE(toneplayer, nullptr);
961
962 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
963 EXPECT_NE(toneplayer->toneInfo_, nullptr);
964
965 toneplayer->toneState_ = TonePlayerImpl::TONE_STOPPED;
966 uint32_t reqSample = 0;
967 const size_t bufferSize = 1024;
968 int8_t* audioBuffer = new int8_t[bufferSize];
969
970 bool ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
971 EXPECT_EQ(ret, false);
972
973 delete[] audioBuffer;
974 }
975
976 /**
977 * @tc.name : Test TonePlayerImpl API
978 * @tc.type : FUNC
979 * @tc.number: TonePlayerImpl_014
980 * @tc.desc : Test ContinueToneplay interface.
981 */
982 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_014, TestSize.Level4)
983 {
984 AudioRendererInfo rendererInfo = {};
985 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
986 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
987 rendererInfo.rendererFlags = 0;
988
989 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
990 EXPECT_NE(toneplayer, nullptr);
991
992 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
993 EXPECT_NE(toneplayer->toneInfo_, nullptr);
994
995 toneplayer->toneState_ = TonePlayerImpl::TONE_RUNNING;
996 toneplayer->totalSample_ = 8000;
997 toneplayer->nextSegSample_ = 8000;
998 toneplayer->currSegment_ = 1;
999 toneplayer->sampleCount_ = 1;
1000 toneplayer->needFadeOut_ = false;
1001 toneplayer->toneInfo_->segments[1].duration = 1;
1002
1003 uint32_t reqSample = 0;
1004 const size_t bufferSize = 1024;
1005 int8_t* audioBuffer = new int8_t[bufferSize];
1006
1007 bool ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
1008 EXPECT_EQ(ret, true);
1009 EXPECT_EQ(toneplayer->needFadeOut_, true);
1010
1011 delete[] audioBuffer;
1012 }
1013
1014 /**
1015 * @tc.name : Test TonePlayerImpl API
1016 * @tc.type : FUNC
1017 * @tc.number: TonePlayerImpl_015
1018 * @tc.desc : Test ContinueToneplay interface.
1019 */
1020 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_015, TestSize.Level4)
1021 {
1022 AudioRendererInfo rendererInfo = {};
1023 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1024 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1025 rendererInfo.rendererFlags = 0;
1026
1027 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1028 EXPECT_NE(toneplayer, nullptr);
1029
1030 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1031 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1032
1033 toneplayer->toneState_ = TonePlayerImpl::TONE_RUNNING;
1034 toneplayer->totalSample_ = 8000;
1035 toneplayer->nextSegSample_ = 8000;
1036 toneplayer->currSegment_ = 0;
1037 toneplayer->sampleCount_ = 1;
1038 toneplayer->needFadeOut_ = false;
1039 toneplayer->toneInfo_->segments[0].duration = 0;
1040
1041 uint32_t reqSample = 0;
1042 const size_t bufferSize = 1024;
1043 int8_t* audioBuffer = new int8_t[bufferSize];
1044
1045 bool ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
1046 EXPECT_EQ(ret, true);
1047 EXPECT_EQ(toneplayer->needFadeOut_, true);
1048
1049 delete[] audioBuffer;
1050 }
1051
1052 /**
1053 * @tc.name : Test TonePlayerImpl API
1054 * @tc.type : FUNC
1055 * @tc.number: TonePlayerImpl_016
1056 * @tc.desc : Test ContinueToneplay interface.
1057 */
1058 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_016, TestSize.Level4)
1059 {
1060 AudioRendererInfo rendererInfo = {};
1061 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1062 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1063 rendererInfo.rendererFlags = 0;
1064
1065 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1066 EXPECT_NE(toneplayer, nullptr);
1067
1068 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1069 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1070
1071 toneplayer->toneState_ = TonePlayerImpl::TONE_RUNNING;
1072 toneplayer->totalSample_ = 8000;
1073 toneplayer->nextSegSample_ = 8000;
1074 toneplayer->currSegment_ = 1;
1075 toneplayer->sampleCount_ = 1;
1076 toneplayer->needFadeOut_ = false;
1077 toneplayer->toneInfo_->segments[1].duration = 0;
1078
1079 uint32_t reqSample = 0;
1080 const size_t bufferSize = 1024;
1081 int8_t* audioBuffer = new int8_t[bufferSize];
1082
1083 bool ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
1084 EXPECT_EQ(ret, true);
1085 EXPECT_EQ(toneplayer->needFadeOut_, true);
1086
1087 delete[] audioBuffer;
1088 }
1089
1090 /**
1091 * @tc.name : Test TonePlayerImpl API
1092 * @tc.type : FUNC
1093 * @tc.number: TonePlayerImpl_017
1094 * @tc.desc : Test ContinueToneplay interface.
1095 */
1096 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_017, TestSize.Level4)
1097 {
1098 AudioRendererInfo rendererInfo = {};
1099 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1100 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1101 rendererInfo.rendererFlags = 0;
1102
1103 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1104 EXPECT_NE(toneplayer, nullptr);
1105
1106 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1107 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1108
1109 toneplayer->toneState_ = TonePlayerImpl::TONE_RUNNING;
1110 toneplayer->totalSample_ = 16000;
1111 toneplayer->nextSegSample_ = 8000;
1112 toneplayer->currSegment_ = 0;
1113 toneplayer->currCount_ = 1;
1114 toneplayer->sampleCount_ = 1;
1115 toneplayer->toneInfo_->repeatCnt = 2;
1116 toneplayer->toneInfo_->repeatSegment = 0;
1117 toneplayer->toneInfo_->segments[1].duration = 0;
1118 toneplayer->toneInfo_->segments[0].duration = 1;
1119
1120 uint32_t reqSample = 0;
1121 const size_t bufferSize = 1024;
1122 int8_t* audioBuffer = new int8_t[bufferSize];
1123
1124 bool ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
1125 EXPECT_EQ(ret, true);
1126 EXPECT_EQ(toneplayer->sampleCount_, 0);
1127
1128 delete[] audioBuffer;
1129 }
1130
1131 /**
1132 * @tc.name : Test TonePlayerImpl API
1133 * @tc.type : FUNC
1134 * @tc.number: TonePlayerImpl_018
1135 * @tc.desc : Test ContinueToneplay interface.
1136 */
1137 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_018, TestSize.Level4)
1138 {
1139 AudioRendererInfo rendererInfo = {};
1140 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1141 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1142 rendererInfo.rendererFlags = 0;
1143
1144 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1145 EXPECT_NE(toneplayer, nullptr);
1146
1147 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1148 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1149
1150 toneplayer->toneState_ = TonePlayerImpl::TONE_RUNNING;
1151 toneplayer->totalSample_ = 16000;
1152 toneplayer->nextSegSample_ = 8000;
1153 toneplayer->currSegment_ = 0;
1154 toneplayer->currCount_ = 1;
1155 toneplayer->sampleCount_ = 1;
1156 toneplayer->toneInfo_->repeatCnt = 2;
1157 toneplayer->toneInfo_->repeatSegment = 2;
1158 toneplayer->toneInfo_->segments[1].duration = 0;
1159 toneplayer->toneInfo_->segments[2].duration = 1;
1160
1161 uint32_t reqSample = 0;
1162 const size_t bufferSize = 1024;
1163 int8_t* audioBuffer = new int8_t[bufferSize];
1164
1165 bool ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
1166 EXPECT_EQ(ret, true);
1167 EXPECT_EQ(toneplayer->sampleCount_, 0);
1168
1169 delete[] audioBuffer;
1170 }
1171
1172 /**
1173 * @tc.name : Test TonePlayerImpl API
1174 * @tc.type : FUNC
1175 * @tc.number: TonePlayerImpl_019
1176 * @tc.desc : Test GetCountryCode interface.
1177 */
1178 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_019, TestSize.Level4)
1179 {
1180 AudioRendererInfo rendererInfo = {};
1181 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1182 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1183 rendererInfo.rendererFlags = 0;
1184
1185 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1186 EXPECT_NE(toneplayer, nullptr);
1187
1188 SetParameter("debug.toneplayer.country", "TEST");
1189
1190
1191 std::string ret = toneplayer->GetCountryCode();
1192 EXPECT_EQ(ret, "test");
1193 }
1194
1195 /**
1196 * @tc.name : Test TonePlayerImpl API
1197 * @tc.type : FUNC
1198 * @tc.number: TonePlayerImpl_020
1199 * @tc.desc : Test CheckToneStarted interface.
1200 */
1201 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_020, TestSize.Level4)
1202 {
1203 AudioRendererInfo rendererInfo = {};
1204 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1205 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1206 rendererInfo.rendererFlags = 0;
1207
1208 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1209 EXPECT_NE(toneplayer, nullptr);
1210
1211 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1212 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1213
1214 toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING;
1215 toneplayer->currSegment_ = 0;
1216 toneplayer->sampleCount_ = 1;
1217 toneplayer->toneInfo_->segments[0].duration = 1;
1218
1219 uint32_t reqSample = 0;
1220 const size_t bufferSize = 1024;
1221 int8_t* audioBuffer = new int8_t[bufferSize];
1222
1223 bool ret = toneplayer->CheckToneStarted(reqSample, audioBuffer);
1224 EXPECT_EQ(ret, true);
1225 EXPECT_EQ(toneplayer->toneState_, TonePlayerImpl::TONE_RUNNING);
1226 EXPECT_EQ(toneplayer->sampleCount_, 0);
1227
1228 delete[] audioBuffer;
1229 }
1230
1231 /**
1232 * @tc.name : Test TonePlayerImpl API
1233 * @tc.type : FUNC
1234 * @tc.number: TonePlayerImpl_021
1235 * @tc.desc : Test CheckToneStarted interface.
1236 */
1237 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_021, TestSize.Level4)
1238 {
1239 AudioRendererInfo rendererInfo = {};
1240 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1241 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1242 rendererInfo.rendererFlags = 0;
1243
1244 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1245 EXPECT_NE(toneplayer, nullptr);
1246
1247 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1248 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1249
1250 toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING;
1251 toneplayer->currSegment_ = 1;
1252 toneplayer->sampleCount_ = 1;
1253 toneplayer->toneInfo_->segments[0].duration = 0;
1254
1255 uint32_t reqSample = 0;
1256 const size_t bufferSize = 1024;
1257 int8_t* audioBuffer = new int8_t[bufferSize];
1258
1259 bool ret = toneplayer->CheckToneStarted(reqSample, audioBuffer);
1260 EXPECT_EQ(ret, true);
1261 EXPECT_EQ(toneplayer->toneState_, TonePlayerImpl::TONE_RUNNING);
1262 EXPECT_EQ(toneplayer->sampleCount_, 1);
1263
1264 delete[] audioBuffer;
1265 }
1266
1267 /**
1268 * @tc.name : Test TonePlayerImpl API
1269 * @tc.type : FUNC
1270 * @tc.number: TonePlayerImpl_022
1271 * @tc.desc : Test CheckToneStopped interface.
1272 */
1273 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_022, TestSize.Level4)
1274 {
1275 AudioRendererInfo rendererInfo = {};
1276 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1277 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1278 rendererInfo.rendererFlags = 0;
1279
1280 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1281 EXPECT_NE(toneplayer, nullptr);
1282
1283 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1284 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1285
1286 toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING;
1287 toneplayer->currSegment_ = 0;
1288 toneplayer->totalSample_ = 8000;
1289 toneplayer->maxSample_ = 8000;
1290 toneplayer->toneInfo_->segments[0].duration = 1;
1291
1292 bool ret = toneplayer->CheckToneStopped();
1293 EXPECT_EQ(ret, false);
1294 }
1295
1296 /**
1297 * @tc.name : Test TonePlayerImpl API
1298 * @tc.type : FUNC
1299 * @tc.number: TonePlayerImpl_023
1300 * @tc.desc : Test CheckToneStopped interface.
1301 */
1302 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_023, TestSize.Level4)
1303 {
1304 AudioRendererInfo rendererInfo = {};
1305 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1306 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1307 rendererInfo.rendererFlags = 0;
1308
1309 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1310 EXPECT_NE(toneplayer, nullptr);
1311
1312 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1313 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1314
1315 toneplayer->toneState_ = TonePlayerImpl::TONE_STOPPING;
1316 toneplayer->currSegment_ = 0;
1317 toneplayer->totalSample_ = 8000;
1318 toneplayer->maxSample_ = 8000;
1319 toneplayer->toneInfo_->segments[1].duration = 1;
1320
1321 bool ret = toneplayer->CheckToneStopped();
1322 EXPECT_EQ(ret, true);
1323 }
1324
1325 /**
1326 * @tc.name : Test TonePlayerImpl API
1327 * @tc.type : FUNC
1328 * @tc.number: TonePlayerImpl_024
1329 * @tc.desc : Test AudioToneSequenceGen interface.
1330 */
1331 HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_024, TestSize.Level4)
1332 {
1333 AudioRendererInfo rendererInfo = {};
1334 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1335 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
1336 rendererInfo.rendererFlags = 0;
1337
1338 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
1339 EXPECT_NE(toneplayer, nullptr);
1340
1341 toneplayer->toneState_ = TonePlayerImpl::TONE_INIT;
1342
1343 toneplayer->toneInfo_ = std::make_shared<ToneInfo>();
1344 EXPECT_NE(toneplayer->toneInfo_, nullptr);
1345 toneplayer->currSegment_ = 1;
1346 toneplayer->totalSample_ = 8000;
1347 toneplayer->maxSample_ = 8000;
1348 toneplayer->toneInfo_->segments[1].duration = 1;
1349 toneplayer->processSize_ = 100;
1350
1351 BufferDesc bufDesc;
1352 const size_t bufferSize = sizeof(int16_t);
1353 bufDesc.buffer = new uint8_t[bufferSize];
1354
1355 bool ret = toneplayer->AudioToneSequenceGen(bufDesc);
1356 EXPECT_EQ(ret, true);
1357 }
1358
1359 } // namespace AudioStandard
1360 } // namespace OHOS
1361