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_unittest.h"
17 #include "media_errors.h"
18 #include "soundpool_manager_multi.h"
19
20 using namespace OHOS;
21 using namespace OHOS::Media;
22 using namespace testing;
23 using namespace testing::ext;
24 using namespace std;
25
26 namespace OHOS {
27 namespace Media {
28 static const int32_t ID_TEST = 0;
29 static const int32_t NUM_TEST = 1;
30 static const int32_t MSERR_INVALID = -1;
31 static const int32_t SOUNDPOOL_INSTANCE_MAX_NUM = 128;
SetUpTestCase(void)32 void SoundPoolUnittest::SetUpTestCase(void)
33 {}
34
TearDownTestCase(void)35 void SoundPoolUnittest::TearDownTestCase(void)
36 {}
37
SetUp(void)38 void SoundPoolUnittest::SetUp(void)
39 {
40 soundPool_ = std::make_shared<SoundPool>();
41 }
42
TearDown(void)43 void SoundPoolUnittest::TearDown(void)
44 {
45 soundPool_ = nullptr;
46 }
47
48 /**
49 * @tc.name : Test CheckInitParam
50 * @tc.number: CheckInitParam_001
51 * @tc.desc : Test Return false
52 */
53 HWTEST_F(SoundPoolUnittest, CheckInitParam_001, TestSize.Level0)
54 {
55 ASSERT_NE(soundPool_, nullptr);
56 int maxStreams = NUM_TEST;
57 AudioStandard::AudioRendererInfo audioRenderInfo;
58 audioRenderInfo.rendererFlags = -1;
59 auto ret = SoundPool::CheckInitParam(maxStreams, audioRenderInfo);
60 EXPECT_EQ(ret, false);
61 }
62
63 /**
64 * @tc.name : Test CheckInitParam
65 * @tc.number: CheckInitParam_002
66 * @tc.desc : Test Return false
67 */
68 HWTEST_F(SoundPoolUnittest, CheckInitParam_002, TestSize.Level1)
69 {
70 ASSERT_NE(soundPool_, nullptr);
71 int maxStreams = NUM_TEST;
72 AudioStandard::AudioRendererInfo audioRenderInfo;
73 audioRenderInfo.rendererFlags = 1024;
74 auto ret = SoundPool::CheckInitParam(maxStreams, audioRenderInfo);
75 EXPECT_EQ(ret, false);
76 }
77
78 /**
79 * @tc.name : Test CheckInitParam
80 * @tc.number: CheckInitParam_003
81 * @tc.desc : Test Return false
82 */
83 HWTEST_F(SoundPoolUnittest, CheckInitParam_003, TestSize.Level1)
84 {
85 ASSERT_NE(soundPool_, nullptr);
86 int maxStreams = NUM_TEST;
87 AudioStandard::AudioRendererInfo audioRenderInfo;
88 audioRenderInfo.rendererFlags = 1025;
89 auto ret = SoundPool::CheckInitParam(maxStreams, audioRenderInfo);
90 EXPECT_EQ(ret, false);
91 }
92
93 /**
94 * @tc.name : Test Play
95 * @tc.number: Play_001
96 * @tc.desc : Test return -1
97 */
98 HWTEST_F(SoundPoolUnittest, Play_001, TestSize.Level0)
99 {
100 ASSERT_NE(soundPool_, nullptr);
101 std::shared_ptr<SoundParser> testPtr = std::make_shared<SoundParser>(1, "testurl");
102 soundPool_->soundIDManager_ = std::make_shared<SoundIDManager>();
103 int32_t soundID = ID_TEST;
104 PlayParams playParameters;
105 auto ret = soundPool_->Play(soundID, playParameters);
106 EXPECT_EQ(ret, MSERR_INVALID);
107 }
108
109 /**
110 * @tc.name : Test SetPriority
111 * @tc.number: SetPriority_001
112 * @tc.desc : Test return MSERR_INVALID_OPERATION
113 */
114 HWTEST_F(SoundPoolUnittest, SetPriority_001, TestSize.Level0)
115 {
116 ASSERT_NE(soundPool_, nullptr);
117 int32_t streamID = ID_TEST;
118 int32_t priority = NUM_TEST;
119 soundPool_->parallelStreamFlag_ = true;
120 int32_t maxStreams = NUM_TEST;
121 AudioStandard::AudioRendererInfo audioRenderInfo;
122 soundPool_->parallelStreamManager_ = std::make_shared<ParallelStreamManager>(maxStreams, audioRenderInfo);
123 auto ret = soundPool_->SetPriority(streamID, priority);
124 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
125 }
126
127 /**
128 * @tc.name : Test SetRate
129 * @tc.number: SetRate_001
130 * @tc.desc : Test return MSERR_INVALID_OPERATION
131 */
132 HWTEST_F(SoundPoolUnittest, SetRate_001, TestSize.Level0)
133 {
134 ASSERT_NE(soundPool_, nullptr);
135 int32_t streamID = ID_TEST;
136 soundPool_->parallelStreamFlag_ = true;
137 int32_t maxStreams = NUM_TEST;
138 AudioStandard::AudioRendererInfo audioRenderInfo;
139 AudioStandard::AudioRendererRate renderRate = AudioStandard::AudioRendererRate::RENDER_RATE_NORMAL;
140 soundPool_->parallelStreamManager_ = std::make_shared<ParallelStreamManager>(maxStreams, audioRenderInfo);
141 auto ret = soundPool_->SetRate(streamID, renderRate);
142 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
143 }
144
145 /**
146 * @tc.name : Test ReleaseInner
147 * @tc.number: ReleaseInner_001
148 * @tc.desc : Test return MSERR_OK
149 */
150 HWTEST_F(SoundPoolUnittest, ReleaseInner_001, TestSize.Level0)
151 {
152 ASSERT_NE(soundPool_, nullptr);
153 soundPool_->apiVersion_ = NUM_TEST;
154 soundPool_->parallelStreamFlag_ = false;
155 auto ret = soundPool_->ReleaseInner();
156 EXPECT_EQ(ret, MSERR_OK);
157 }
158
159 /**
160 * @tc.name : Test SetSoundPoolFrameWriteCallback
161 * @tc.number: SetSoundPoolFrameWriteCallback_001
162 * @tc.desc : Test return MSERR_OK
163 */
164 HWTEST_F(SoundPoolUnittest, SetSoundPoolFrameWriteCallback_001, TestSize.Level0)
165 {
166 ASSERT_NE(soundPool_, nullptr);
167 AudioStandard::AudioRendererInfo audioRenderInfo;
168 std::shared_ptr<ISoundPoolFrameWriteCallback> frameWriteCallback;
169 soundPool_->parallelStreamManager_ = std::make_shared<ParallelStreamManager>(1, audioRenderInfo);
170 auto ret = soundPool_->SetSoundPoolFrameWriteCallback(frameWriteCallback);
171 EXPECT_EQ(ret, MSERR_OK);
172 }
173
174 /**
175 * @tc.name : Test GetSoundPoolInstance
176 * @tc.number: GetSoundPoolInstance_001
177 * @tc.desc : Test return MSERR_INVALID_OPERATION
178 */
179 HWTEST_F(SoundPoolUnittest, GetSoundPoolInstance_001, TestSize.Level0)
180 {
181 auto soundPoolManagerMulti = std::make_shared<SoundPoolManagerMulti>();
182 ASSERT_NE(soundPoolManagerMulti, nullptr);
183 std::shared_ptr<SoundPool> soundPool;
184 for (int i = 0; i < (SOUNDPOOL_INSTANCE_MAX_NUM + 1); ++i)
185 {
186 soundPoolManagerMulti->soundPools_.push_back(soundPool);
187 }
188 auto ret = soundPoolManagerMulti->GetSoundPoolInstance(soundPool);
189 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
190 }
191
192 /**
193 * @tc.name : Test CheckRendererFlagsValid
194 * @tc.number: CheckRendererFlagsValid_001
195 * @tc.desc : Test CheckRendererFlagsValid returns true when rendererFlags is 0
196 */
197 HWTEST_F(SoundPoolUnittest, CheckRendererFlagsValid_001, TestSize.Level0)
198 {
199 ASSERT_NE(soundPool_, nullptr);
200 AudioStandard::AudioRendererInfo audioRenderInfo;
201 audioRenderInfo.rendererFlags = 0;
202 auto ret = soundPool_->CheckRendererFlagsValid(audioRenderInfo);
203 EXPECT_EQ(ret, true);
204 }
205
206 /**
207 * @tc.name : Test CheckRendererFlagsValid
208 * @tc.number: CheckRendererFlagsValid_002
209 * @tc.desc : Test CheckRendererFlagsValid returns true when rendererFlags is 1
210 */
211 HWTEST_F(SoundPoolUnittest, CheckRendererFlagsValid_002, TestSize.Level0)
212 {
213 ASSERT_NE(soundPool_, nullptr);
214 AudioStandard::AudioRendererInfo audioRenderInfo;
215 audioRenderInfo.rendererFlags = 1;
216 auto ret = soundPool_->CheckRendererFlagsValid(audioRenderInfo);
217 EXPECT_EQ(ret, true);
218 }
219
220 /**
221 * @tc.name : Test CheckRendererFlagsValid
222 * @tc.number: CheckRendererFlagsValid_003
223 * @tc.desc : Test CheckRendererFlagsValid returns false when rendererFlags is AUDIO_FLAG_VKB_NORMAL
224 but the isBundleNameValid flag is false
225 */
226 HWTEST_F(SoundPoolUnittest, CheckRendererFlagsValid_003, TestSize.Level0)
227 {
228 ASSERT_NE(soundPool_, nullptr);
229 AudioStandard::AudioRendererInfo audioRenderInfo;
230 audioRenderInfo.rendererFlags = AudioStandard::AUDIO_FLAG_VKB_NORMAL;
231 auto ret = soundPool_->CheckRendererFlagsValid(audioRenderInfo);
232 EXPECT_EQ(ret, false);
233 }
234
235 /**
236 * @tc.name : Test CheckRendererFlagsValid
237 * @tc.number: CheckRendererFlagsValid_004
238 * @tc.desc : Test CheckRendererFlagsValid returns false when rendererFlags is AUDIO_FLAG_VKB_FAST
239 but the isBundleNameValid flag is false
240 */
241 HWTEST_F(SoundPoolUnittest, CheckRendererFlagsValid_004, TestSize.Level0)
242 {
243 ASSERT_NE(soundPool_, nullptr);
244 AudioStandard::AudioRendererInfo audioRenderInfo;
245 audioRenderInfo.rendererFlags = AudioStandard::AUDIO_FLAG_VKB_FAST;
246 auto ret = soundPool_->CheckRendererFlagsValid(audioRenderInfo);
247 EXPECT_EQ(ret, false);
248 }
249
250 /**
251 * @tc.name : Test CheckRendererFlagsValid
252 * @tc.number: CheckRendererFlagsValid_005
253 * @tc.desc : Test CheckRendererFlagsValid returns true when rendererFlags is AUDIO_FLAG_VKB_FAST
254 */
255 HWTEST_F(SoundPoolUnittest, CheckRendererFlagsValid_005, TestSize.Level0)
256 {
257 ASSERT_NE(soundPool_, nullptr);
258 AudioStandard::AudioRendererInfo audioRenderInfo;
259 audioRenderInfo.rendererFlags = -100;
260 auto ret = soundPool_->CheckRendererFlagsValid(audioRenderInfo);
261 EXPECT_EQ(ret, false);
262 }
263 } // namespace Media
264 } // namespace OHOS
265