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 "audio_errors.h"
18 #include "audio_session.h"
19 #include "audio_session_service.h"
20 #include "audio_session_unit_test.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AudioStandard {
26
SetUpTestCase(void)27 void AudioSessionUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)28 void AudioSessionUnitTest::TearDownTestCase(void) {}
SetUp(void)29 void AudioSessionUnitTest::SetUp(void) {}
TearDown(void)30 void AudioSessionUnitTest::TearDown(void) {}
31
32 /**
33 * @tc.name : Test AudioSession.
34 * @tc.number: AudioSessionUnitTest_001.
35 * @tc.desc : Test AddAudioInterrpt.
36 */
37 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_001, TestSize.Level1)
38 {
39 int32_t callerPid = 1;
40 AudioSessionStrategy strategy;
41 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
42 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
43
44 AudioInterrupt audioInterrupt;
45 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
46 auto ret = audioSession->AddAudioInterrpt(interruptPair);
47 EXPECT_EQ(ret, SUCCESS);
48 }
49
50 /**
51 * @tc.name : Test AudioSession.
52 * @tc.number: AudioSessionUnitTest_002.
53 * @tc.desc : Test RemoveAudioInterrpt.
54 */
55 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_002, TestSize.Level1)
56 {
57 int32_t callerPid = 1;
58 AudioSessionStrategy strategy;
59 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
60 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
61
62 AudioInterrupt audioInterrupt;
63 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
64 auto ret = audioSession->RemoveAudioInterrpt(interruptPair);
65 EXPECT_EQ(ret, SUCCESS);
66 }
67
68 /**
69 * @tc.name : Test AudioSession.
70 * @tc.number: AudioSessionUnitTest_003.
71 * @tc.desc : Test RemoveAudioInterrpt.
72 */
73 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_003, TestSize.Level1)
74 {
75 int32_t callerPid = 1;
76 AudioSessionStrategy strategy;
77 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
78 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
79
80 AudioInterrupt audioInterrupt;
81 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
82 audioSession->interruptMap_[audioInterrupt.streamId] = interruptPair;
83 auto ret = audioSession->RemoveAudioInterrpt(interruptPair);
84 EXPECT_EQ(ret, SUCCESS);
85 }
86
87 /**
88 * @tc.name : Test AudioSession.
89 * @tc.number: AudioSessionUnitTest_004.
90 * @tc.desc : Test RemoveAudioInterrpt.
91 */
92 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_004, TestSize.Level1)
93 {
94 int32_t callerPid = 1;
95 AudioSessionStrategy strategy;
96 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
97 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
98
99 AudioInterrupt audioInterrupt;
100 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
101 audioSession->interruptMap_[audioInterrupt.streamId] = interruptPair;
102 auto ret = audioSession->RemoveAudioInterrpt(interruptPair);
103 EXPECT_EQ(ret, SUCCESS);
104 }
105
106 /**
107 * @tc.name : Test AudioSession.
108 * @tc.number: AudioSessionUnitTest_005.
109 * @tc.desc : Test RemoveAudioInterrpt.
110 */
111 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_005, TestSize.Level1)
112 {
113 int32_t callerPid = 1;
114 AudioSessionStrategy strategy;
115 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
116 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
117
118 uint32_t i = 1;
119 AudioInterrupt audioInterrupt;
120 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
121 audioSession->interruptMap_[audioInterrupt.streamId] = interruptPair;
122 audioSession->interruptMap_[i] = interruptPair;
123 auto ret = audioSession->RemoveAudioInterrpt(interruptPair);
124 EXPECT_EQ(ret, SUCCESS);
125 }
126
127 /**
128 * @tc.name : Test AudioSession.
129 * @tc.number: AudioSessionUnitTest_006.
130 * @tc.desc : Test RemoveAudioInterrpt.
131 */
132 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_006, TestSize.Level1)
133 {
134 int32_t callerPid = 1;
135 AudioSessionStrategy strategy;
136 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
137 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
138
139 uint32_t i = 1;
140 AudioInterrupt audioInterrupt;
141 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
142 audioSession->interruptMap_[audioInterrupt.streamId] = interruptPair;
143 audioSession->interruptMap_[i] = interruptPair;
144 auto ret = audioSession->RemoveAudioInterrpt(interruptPair);
145 EXPECT_EQ(ret, SUCCESS);
146 }
147
148 /**
149 * @tc.name : Test AudioSession.
150 * @tc.number: AudioSessionUnitTest_007.
151 * @tc.desc : Test RemoveAudioInterrptByStreamId.
152 */
153 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_007, TestSize.Level1)
154 {
155 int32_t callerPid = 1;
156 AudioSessionStrategy strategy;
157 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
158 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
159
160 uint32_t streamId = 10;
161 AudioInterrupt audioInterrupt;
162 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
163 audioSession->interruptMap_[streamId] = interruptPair;
164 auto ret = audioSession->RemoveAudioInterrptByStreamId(streamId);
165 EXPECT_EQ(ret, SUCCESS);
166 }
167
168 /**
169 * @tc.name : Test AudioSession.
170 * @tc.number: AudioSessionUnitTest_008.
171 * @tc.desc : Test RemoveAudioInterrptByStreamId.
172 */
173 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_008, TestSize.Level1)
174 {
175 int32_t callerPid = 1;
176 AudioSessionStrategy strategy;
177 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
178 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
179
180 uint32_t streamId = 10;
181 AudioInterrupt audioInterrupt;
182 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
183 audioSession->interruptMap_[streamId] = interruptPair;
184 auto ret = audioSession->RemoveAudioInterrptByStreamId(streamId);
185 EXPECT_EQ(ret, SUCCESS);
186 }
187
188 /**
189 * @tc.name : Test AudioSession.
190 * @tc.number: AudioSessionUnitTest_009.
191 * @tc.desc : Test RemoveAudioInterrptByStreamId.
192 */
193 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_009, TestSize.Level1)
194 {
195 int32_t callerPid = 1;
196 AudioSessionStrategy strategy;
197 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
198 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
199
200 uint32_t streamId0 = 1;
201 uint32_t streamId = 10;
202 AudioInterrupt audioInterrupt;
203 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
204 audioSession->interruptMap_[streamId] = interruptPair;
205 audioSession->interruptMap_[streamId0] = interruptPair;
206 auto ret = audioSession->RemoveAudioInterrptByStreamId(streamId);
207 EXPECT_EQ(ret, SUCCESS);
208 }
209
210 /**
211 * @tc.name : Test AudioSession.
212 * @tc.number: AudioSessionUnitTest_010.
213 * @tc.desc : Test RemoveAudioInterrptByStreamId.
214 */
215 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_010, TestSize.Level1)
216 {
217 int32_t callerPid = 1;
218 AudioSessionStrategy strategy;
219 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
220 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
221
222 uint32_t streamId0 = 1;
223 uint32_t streamId = 10;
224 AudioInterrupt audioInterrupt;
225 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
226 audioSession->interruptMap_[streamId] = interruptPair;
227 audioSession->interruptMap_[streamId0] = interruptPair;
228 auto ret = audioSession->RemoveAudioInterrptByStreamId(streamId);
229 EXPECT_EQ(ret, SUCCESS);
230 }
231
232 /**
233 * @tc.name : Test AudioSession.
234 * @tc.number: AudioSessionUnitTest_011.
235 * @tc.desc : Test IsAudioRendererEmpty.
236 */
237 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_011, TestSize.Level1)
238 {
239 int32_t callerPid = 1;
240 AudioSessionStrategy strategy;
241 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
242 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
243
244 uint32_t streamId = 1;
245 AudioInterrupt audioInterrupt;
246 audioInterrupt.audioFocusType.streamType = STREAM_DEFAULT;
247 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
248 audioSession->interruptMap_[streamId] = interruptPair;
249 auto ret = audioSession->IsAudioRendererEmpty();
250 EXPECT_TRUE(ret);
251 }
252
253 /**
254 * @tc.name : Test AudioSession.
255 * @tc.number: AudioSessionUnitTest_012.
256 * @tc.desc : Test IsAudioRendererEmpty.
257 */
258 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_012, TestSize.Level1)
259 {
260 int32_t callerPid = 1;
261 AudioSessionStrategy strategy;
262 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
263 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
264
265 uint32_t streamId = 1;
266 AudioInterrupt audioInterrupt;
267 audioInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
268 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
269 audioSession->interruptMap_[streamId] = interruptPair;
270 auto ret = audioSession->IsAudioRendererEmpty();
271 EXPECT_FALSE(ret);
272 }
273 } // namespace AudioStandard
274 } // namespace OHOS
275