1 /*
2 * Copyright (c) 2023 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
19 using namespace testing::ext;
20 namespace OHOS {
21 namespace AudioStandard {
22 constexpr uint32_t SLEEP_TIME = 30000;
23 static size_t g_reqBufLen = 0;
24 class AudioToneplayerUnitTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 };
31
SetUpTestCase(void)32 void AudioToneplayerUnitTest::SetUpTestCase(void)
33 {
34 // input testsuit setup step，setup invoked before all testcases
35 }
36
TearDownTestCase(void)37 void AudioToneplayerUnitTest::TearDownTestCase(void)
38 {
39 // input testsuit teardown step，teardown invoked after all testcases
40 }
41
SetUp(void)42 void AudioToneplayerUnitTest::SetUp(void)
43 {
44 // input testcase setup step，setup invoked before each testcases
45 }
46
TearDown(void)47 void AudioToneplayerUnitTest::TearDown(void)
48 {
49 // input testcase teardown step，teardown invoked after each testcases
50 }
51
52 class AudioRendererCallbackTest : public AudioRendererCallback {
53 public:
OnInterrupt(const InterruptEvent & interruptEvent)54 void OnInterrupt(const InterruptEvent &interruptEvent) override {}
OnStateChange(const RendererState state,const StateChangeCmdType cmdType)55 void OnStateChange(const RendererState state, const StateChangeCmdType cmdType) override {}
56 };
57
58 class AudioToneplayerCallbackTest : public AudioRendererCallback {
59 public:
60 void OnWriteData(size_t length);
61 };
62
OnWriteData(size_t length)63 void AudioToneplayerCallbackTest::OnWriteData(size_t length)
64 {
65 g_reqBufLen = length;
66 }
67
68 /**
69 * @tc.name : Test Create API
70 * @tc.type : FUNC
71 * @tc.number: Create_001
72 * @tc.desc : Test Create interface.
73 */
74 HWTEST(AudioToneplayerUnitTest, Create_001, TestSize.Level1)
75 {
76 std::shared_ptr<TonePlayer> toneplayer = nullptr;
77 AudioRendererInfo rendererInfo = {};
78 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
79 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
80 rendererInfo.rendererFlags = 0;
81 toneplayer = TonePlayer::Create(rendererInfo);
82 ASSERT_NE(nullptr, toneplayer);
83
84 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
85 toneplayer = TonePlayer::Create(rendererInfo);
86 ASSERT_NE(nullptr, toneplayer);
87
88 toneplayer->Release();
89 }
90
91 /**
92 * @tc.name : Test toneplayer loading API
93 * @tc.type : FUNC
94 * @tc.number: Toneplayer_001
95 * @tc.desc : Test create->LoadTone->StartTone->StopTone->Release interface.
96 */
97 HWTEST(AudioToneplayerUnitTest, Toneplayer_001, TestSize.Level1)
98 {
99 AudioRendererInfo rendererInfo = {};
100 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
101 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
102 rendererInfo.rendererFlags = 0;
103 std::shared_ptr<TonePlayer> toneplayer = TonePlayer::Create(rendererInfo);
104 ASSERT_NE(nullptr, toneplayer);
105
106 bool ret = toneplayer->LoadTone(TONE_TYPE_DIAL_1);
107 EXPECT_EQ(true, ret);
108
109 bool startRet = toneplayer->StartTone();
110 EXPECT_EQ(true, startRet);
111
112 usleep(SLEEP_TIME); // 30ms sleep time
113 bool stopRet = toneplayer->StopTone();
114 EXPECT_EQ(true, stopRet);
115
116 bool releaseRet = toneplayer->Release();
117 EXPECT_EQ(true, releaseRet);
118 }
119
120 /**
121 * @tc.name : Test toneplayer loading API
122 * @tc.type : FUNC
123 * @tc.number: Toneplayer_002
124 * @tc.desc : Test create->StartTone->StopTone->Release interface.
125 */
126 HWTEST(AudioToneplayerUnitTest, Toneplayer_002, TestSize.Level1)
127 {
128 AudioRendererInfo rendererInfo = {};
129 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
130 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
131 rendererInfo.rendererFlags = 0;
132 std::shared_ptr<TonePlayer> toneplayer = TonePlayer::Create(rendererInfo);
133 ASSERT_NE(nullptr, toneplayer);
134
135 bool ret = toneplayer->LoadTone(TONE_TYPE_DIAL_2);
136 EXPECT_EQ(true, ret);
137
138 usleep(SLEEP_TIME); // 30ms sleep time
139 bool stopRet = toneplayer->StopTone();
140 EXPECT_EQ(false, stopRet);
141
142 bool releaseRet = toneplayer->Release();
143 EXPECT_EQ(true, releaseRet);
144 }
145
146 /**
147 * @tc.name : Test toneplayer loading API
148 * @tc.type : FUNC
149 * @tc.number: Toneplayer_003
150 * @tc.desc : Test create->StartTone->Release interface.
151 */
152 HWTEST(AudioToneplayerUnitTest, Toneplayer_003, TestSize.Level1)
153 {
154 AudioRendererInfo rendererInfo = {};
155 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
156 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
157 rendererInfo.rendererFlags = 0;
158 std::shared_ptr<TonePlayer> toneplayer = TonePlayer::Create(rendererInfo);
159 ASSERT_NE(nullptr, toneplayer);
160
161 bool startRet = toneplayer->StartTone();
162 EXPECT_EQ(false, startRet);
163
164 bool releaseRet = toneplayer->Release();
165 EXPECT_EQ(true, releaseRet);
166 }
167
168 /**
169 * @tc.name : Test toneplayer loading API
170 * @tc.type : FUNC
171 * @tc.number: Toneplayer_004
172 * @tc.desc : Test create->LoadTone->StartTone->Release interface.
173 */
174 HWTEST(AudioToneplayerUnitTest, Toneplayer_004, TestSize.Level1)
175 {
176 AudioRendererInfo rendererInfo = {};
177 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
178 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
179 rendererInfo.rendererFlags = 0;
180 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
181 ASSERT_NE(nullptr, toneplayer);
182
183 bool ret = toneplayer->LoadTone(TONE_TYPE_DIAL_6);
184 EXPECT_EQ(true, ret);
185
186 bool startRet = toneplayer->StartTone();
187 EXPECT_EQ(true, startRet);
188
189 usleep(SLEEP_TIME); // 30ms sleep time
190
191 bool releaseRet = toneplayer->Release();
192 EXPECT_EQ(true, releaseRet);
193 }
194
195 /**
196 * @tc.name : Test toneplayer loading API
197 * @tc.type : FUNC
198 * @tc.number: Toneplayer_005
199 * @tc.desc : Test create->LoadTone->StartTone->Release interface.
200 */
201 HWTEST(AudioToneplayerUnitTest, Toneplayer_005, TestSize.Level1)
202 {
203 AudioRendererInfo rendererInfo = {};
204 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
205 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
206 rendererInfo.rendererFlags = 0;
207 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
208 ASSERT_NE(nullptr, toneplayer);
209
210 bool ret = toneplayer->LoadTone(TONE_TYPE_DIAL_6);
211 EXPECT_EQ(true, ret);
212
213 bool startRet = toneplayer->StartTone();
214 EXPECT_EQ(true, startRet);
215
216 bool stopRet = toneplayer->StopTone();
217 EXPECT_EQ(true, stopRet);
218
219 bool checkRet = toneplayer->CheckToneStopped();
220 EXPECT_EQ(true, checkRet);
221
222 bool releaseRet = toneplayer->Release();
223 EXPECT_EQ(true, releaseRet);
224 }
225
226 /**
227 * @tc.name : Test toneplayer loading API
228 * @tc.type : FUNC
229 * @tc.number: Toneplayer_006
230 * @tc.desc : Test create->StartTone->StopTone->LoadTone->LoadTone->Release interface.
231 */
232 HWTEST(AudioToneplayerUnitTest, Toneplayer_006, TestSize.Level1)
233 {
234 AudioRendererInfo rendererInfo = {};
235 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
236 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
237 rendererInfo.rendererFlags = 0;
238 std::shared_ptr<TonePlayer> toneplayer = TonePlayer::Create(rendererInfo);
239 ASSERT_NE(nullptr, toneplayer);
240
241 bool ret = toneplayer->StartTone();
242 EXPECT_EQ(false, ret);
243
244 ret = toneplayer->StopTone();
245 EXPECT_EQ(false, ret);
246
247 ret = toneplayer->LoadTone(NUM_TONES);
248 ret = toneplayer->LoadTone(NUM_TONES);
249 EXPECT_EQ(false, ret);
250
251 bool releaseRet = toneplayer->Release();
252 EXPECT_EQ(true, releaseRet);
253 }
254
255 /**
256 * @tc.name : Test toneplayer loading API
257 * @tc.type : FUNC
258 * @tc.number: Toneplayer_StartTone_001
259 * @tc.desc : Test StartTone interface.
260 */
261 HWTEST(AudioToneplayerUnitTest, Toneplayer_StartTone_001, TestSize.Level1)
262 {
263 AudioRendererInfo rendererInfo = {};
264 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
265 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
266 rendererInfo.rendererFlags = 0;
267 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
268 ASSERT_NE(nullptr, toneplayer);
269
270 toneplayer->isRendererInited_ = true;
271 bool ret = toneplayer->StartTone();
272 ret = toneplayer->StopTone();
273
274 bool releaseRet = toneplayer->Release();
275 EXPECT_EQ(true, releaseRet);
276 }
277
278 /**
279 * @tc.name : Test toneplayer loading API
280 * @tc.type : FUNC
281 * @tc.number: Toneplayer_StartTone_002
282 * @tc.desc : Test StartTone interface.
283 */
284 HWTEST(AudioToneplayerUnitTest, Toneplayer_StartTone_002, TestSize.Level1)
285 {
286 AudioRendererInfo rendererInfo = {};
287 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
288 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
289 rendererInfo.rendererFlags = 0;
290 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
291 ASSERT_NE(nullptr, toneplayer);
292
293 toneplayer->isRendererInited_ = true;
294 toneplayer->audioRenderer_ = nullptr;
295 toneplayer->StartTone();
296 toneplayer->StopTone();
297
298 bool releaseRet = toneplayer->Release();
299 EXPECT_EQ(true, releaseRet);
300 }
301
302 /**
303 * @tc.name : Test toneplayer loading API
304 * @tc.type : FUNC
305 * @tc.number: Toneplayer_StartTone_003
306 * @tc.desc : Test StartTone interface.
307 */
308 HWTEST(AudioToneplayerUnitTest, Toneplayer_StartTone_003, TestSize.Level1)
309 {
310 AudioRendererInfo rendererInfo = {};
311 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
312 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
313 rendererInfo.rendererFlags = 0;
314 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
315 ASSERT_NE(nullptr, toneplayer);
316
317 toneplayer->isRendererInited_ = false;
318 toneplayer->StartTone();
319 toneplayer->StopTone();
320
321 bool releaseRet = toneplayer->Release();
322 EXPECT_EQ(true, releaseRet);
323 }
324
325 /**
326 * @tc.name : Test toneplayer loading API
327 * @tc.type : FUNC
328 * @tc.number: Toneplayer_StartTone_004
329 * @tc.desc : Test StartTone interface.
330 */
331 HWTEST(AudioToneplayerUnitTest, Toneplayer_StartTone_004, TestSize.Level1)
332 {
333 AudioRendererInfo rendererInfo = {};
334 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
335 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
336 rendererInfo.rendererFlags = 0;
337 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
338 ASSERT_NE(nullptr, toneplayer);
339
340 toneplayer->isRendererInited_ = false;
341 toneplayer->audioRenderer_ = nullptr;
342 toneplayer->StartTone();
343 toneplayer->StopTone();
344
345 bool releaseRet = toneplayer->Release();
346 EXPECT_EQ(true, releaseRet);
347 }
348
349 /**
350 * @tc.name : Test Create API
351 * @tc.type : FUNC
352 * @tc.number: Create_002
353 * @tc.desc : Test Create interface.
354 */
355 HWTEST(AudioToneplayerUnitTest, Create_002, TestSize.Level1)
356 {
357 std::string cachePath = "/data/local/tmp";
358 std::shared_ptr<TonePlayer> toneplayer = nullptr;
359 AudioRendererInfo rendererInfo = {};
360 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
361 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
362 rendererInfo.rendererFlags = 0;
363 toneplayer = TonePlayer::Create(cachePath, rendererInfo);
364 ASSERT_NE(nullptr, toneplayer);
365
366 toneplayer->Release();
367 }
368
369 /**
370 * @tc.name : Test GetCurrentSegmentUpdated API
371 * @tc.type : FUNC
372 * @tc.number: GetCurrentSegmentUpdated_001
373 * @tc.desc : Test GetCurrentSegmentUpdated interface.
374 */
375 HWTEST(AudioToneplayerUnitTest, GetCurrentSegmentUpdated_001, TestSize.Level1)
376 {
377 AudioRendererInfo rendererInfo = {};
378 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
379 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
380 rendererInfo.rendererFlags = 0;
381 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
382 ASSERT_NE(nullptr, toneplayer);
383
384 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
385 EXPECT_NE(nullptr, toneplayer->toneInfo_);
386
387 toneplayer->currSegment_ = 0;
388 toneplayer->toneInfo_->segments[0].loopCnt = 0;
389 toneplayer->GetCurrentSegmentUpdated();
390 EXPECT_EQ(1, toneplayer->currSegment_);
391
392 toneplayer->loopCounter_ = 0;
393 toneplayer->currSegment_ = 0;
394 toneplayer->toneInfo_->segments[0].loopCnt = 1;
395 toneplayer->GetCurrentSegmentUpdated();
396 EXPECT_EQ(1, toneplayer->loopCounter_);
397
398 toneplayer->loopCounter_ = 2;
399 toneplayer->currSegment_ = 0;
400 toneplayer->toneInfo_->segments[0].loopCnt = 1;
401 toneplayer->GetCurrentSegmentUpdated();
402 EXPECT_EQ(0, toneplayer->loopCounter_);
403 }
404
405 /**
406 * @tc.name : Test CheckToneContinuity API
407 * @tc.type : FUNC
408 * @tc.number: CheckToneContinuity_001
409 * @tc.desc : Test CheckToneContinuity interface.
410 */
411 HWTEST(AudioToneplayerUnitTest, CheckToneContinuity_001, TestSize.Level1)
412 {
413 bool ret = false;
414 AudioRendererInfo rendererInfo = {};
415 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
416 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
417 rendererInfo.rendererFlags = 0;
418 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
419 ASSERT_NE(nullptr, toneplayer);
420
421 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
422 EXPECT_NE(nullptr, toneplayer->toneInfo_);
423
424 toneplayer->currSegment_ = 0;
425 toneplayer->toneInfo_->segments[0].duration = 1;
426 ret = toneplayer->CheckToneContinuity();
427 EXPECT_EQ(true, ret);
428
429 toneplayer->currSegment_ = 0;
430 toneplayer->toneInfo_->segments[0].duration = 0;
431 toneplayer->currCount_ = 0;
432 toneplayer->toneInfo_->repeatCnt = 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_ = 1;
439 toneplayer->toneInfo_->repeatCnt = 0;
440 ret = toneplayer->CheckToneContinuity();
441 EXPECT_EQ(false, ret);
442 }
443
444 /**
445 * @tc.name : Test OnInterrupt API
446 * @tc.type : FUNC
447 * @tc.number: OnInterrupt_001
448 * @tc.desc : Test OnInterrupt interface.
449 */
450 HWTEST(AudioToneplayerUnitTest, OnInterrupt_001, TestSize.Level1)
451 {
452 AudioRendererInfo rendererInfo = {};
453 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
454 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
455 rendererInfo.rendererFlags = 0;
456 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
457 ASSERT_NE(nullptr, toneplayer);
458
459 InterruptEvent interruptEvent;
460 interruptEvent.eventType = InterruptType::INTERRUPT_TYPE_END;
461 toneplayer->OnInterrupt(interruptEvent);
462 EXPECT_EQ(ToneType::NUM_TONES, toneplayer->toneType_);
463 }
464
465 /**
466 * @tc.name : Test ContinueToneplay API
467 * @tc.type : FUNC
468 * @tc.number: ContinueToneplay_001
469 * @tc.desc : Test ContinueToneplay interface.
470 */
471 HWTEST(AudioToneplayerUnitTest, ContinueToneplay_001, TestSize.Level1)
472 {
473 bool ret = false;
474 AudioRendererInfo rendererInfo = {};
475 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
476 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
477 rendererInfo.rendererFlags = 0;
478 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
479 ASSERT_NE(nullptr, toneplayer);
480 uint32_t reqSample = 4;
481 int8_t buff[8] = {0};
482 int8_t *audioBuffer = buff;
483
484 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_STOPPED;
485 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
486 EXPECT_EQ(ret, false);
487
488 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
489 EXPECT_NE(nullptr, toneplayer->toneInfo_);
490 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
491 toneplayer->totalSample_ = 2;
492 toneplayer->nextSegSample_ = 1;
493 toneplayer->currSegment_ = 0;
494 toneplayer->toneInfo_->segments[0].duration = 1;
495 ret = toneplayer->CheckToneContinuity();
496 EXPECT_EQ(true, ret);
497 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
498 EXPECT_EQ(ret, true);
499
500 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
501 toneplayer->currSegment_ = 0;
502 toneplayer->toneInfo_->segments[0].duration = 0;
503 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
504 EXPECT_EQ(ret, true);
505 }
506
507 /**
508 * @tc.name : Test ContinueToneplay API
509 * @tc.type : FUNC
510 * @tc.number: ContinueToneplay_002
511 * @tc.desc : Test ContinueToneplay interface.
512 */
513 HWTEST(AudioToneplayerUnitTest, ContinueToneplay_002, TestSize.Level1)
514 {
515 bool ret = false;
516 AudioRendererInfo rendererInfo = {};
517 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
518 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
519 rendererInfo.rendererFlags = 0;
520 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
521 ASSERT_NE(nullptr, toneplayer);
522 uint32_t reqSample = 4;
523 int8_t buff[8] = {0};
524 int8_t *audioBuffer = buff;
525
526 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
527 EXPECT_NE(nullptr, toneplayer->toneInfo_);
528 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
529 toneplayer->totalSample_ = 0;
530 toneplayer->nextSegSample_ = 1;
531 toneplayer->currSegment_ = 0;
532 toneplayer->toneInfo_->segments[0].duration = 0;
533 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
534 EXPECT_EQ(ret, true);
535 }
536
537 /**
538 * @tc.name : Test ContinueToneplay API
539 * @tc.type : FUNC
540 * @tc.number: ContinueToneplay_003
541 * @tc.desc : Test ContinueToneplay interface.
542 */
543 HWTEST(AudioToneplayerUnitTest, ContinueToneplay_003, TestSize.Level1)
544 {
545 bool ret = false;
546 AudioRendererInfo rendererInfo = {};
547 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
548 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
549 rendererInfo.rendererFlags = 0;
550 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
551 ASSERT_NE(nullptr, toneplayer);
552 uint32_t reqSample = 4;
553 int8_t buff[8] = {0};
554 int8_t *audioBuffer = buff;
555
556 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
557 EXPECT_NE(nullptr, toneplayer->toneInfo_);
558 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
559 toneplayer->totalSample_ = 0;
560 toneplayer->nextSegSample_ = 1;
561 toneplayer->currSegment_ = 0;
562 toneplayer->toneInfo_->segments[0].duration = 1;
563 ret = toneplayer->ContinueToneplay(reqSample, audioBuffer);
564 EXPECT_EQ(ret, true);
565 }
566
567 /**
568 * @tc.name : Test CheckToneStopped API
569 * @tc.type : FUNC
570 * @tc.number: CheckToneStopped_001
571 * @tc.desc : Test CheckToneStopped interface.
572 */
573 HWTEST(AudioToneplayerUnitTest, CheckToneStopped_001, TestSize.Level1)
574 {
575 AudioRendererInfo rendererInfo = {};
576 rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
577 rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF;
578 rendererInfo.rendererFlags = 0;
579 std::shared_ptr<TonePlayerImpl> toneplayer = std::make_shared<TonePlayerImpl>("", rendererInfo);
580 ASSERT_NE(nullptr, toneplayer);
581
582 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_STOPPED;
583 bool ret = toneplayer->CheckToneStopped();
584 EXPECT_EQ(true, ret);
585
586 toneplayer->LoadTone(TONE_TYPE_DIAL_6);
587 EXPECT_NE(nullptr, toneplayer->toneInfo_);
588 toneplayer->currSegment_ = 0;
589 toneplayer->toneInfo_->segments[0].duration = 0;
590 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
591 ret = toneplayer->CheckToneStopped();
592 EXPECT_EQ(true, ret);
593
594 toneplayer->currSegment_ = 0;
595 toneplayer->toneInfo_->segments[0].duration = 1;
596 toneplayer->totalSample_ = 3;
597 toneplayer->maxSample_ = 2;
598 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_RUNNING;
599 ret = toneplayer->CheckToneStopped();
600 EXPECT_EQ(true, ret);
601
602 toneplayer->currSegment_ = 0;
603 toneplayer->toneInfo_->segments[0].duration = 1;
604 toneplayer->totalSample_ = 1;
605 toneplayer->maxSample_ = 2;
606 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_STOPPING;
607 ret = toneplayer->CheckToneStopped();
608 EXPECT_EQ(true, ret);
609
610 toneplayer->currSegment_ = 0;
611 toneplayer->toneInfo_->segments[0].duration = 1;
612 toneplayer->totalSample_ = 1;
613 toneplayer->maxSample_ = 2;
614 toneplayer->toneState_ = TonePlayerImpl::ToneState::TONE_IDLE;
615 ret = toneplayer->CheckToneStopped();
616 EXPECT_EQ(false, ret);
617 }
618 } // namespace AudioStandard
619 } // namespace OHOS
620