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<TonePlayer> toneplayer = TonePlayer::Create(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 } // namespace AudioStandard
195 } // namespace OHOS