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 "audio_loopback_unit_test.h"
17 #include "audio_loopback_private.h"
18 #include "audio_errors.h"
19 #include "accesstoken_kit.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22
23 using namespace testing::ext;
24 using namespace testing;
25 namespace OHOS {
26 namespace AudioStandard {
27 bool g_hasPermission = false;
28
GetPermission()29 void GetPermission()
30 {
31 if (!g_hasPermission) {
32 uint64_t tokenId;
33 constexpr int perNum = 10;
34 const char *perms[perNum] = {
35 "ohos.permission.MICROPHONE",
36 "ohos.permission.MANAGE_INTELLIGENT_VOICE",
37 "ohos.permission.MANAGE_AUDIO_CONFIG",
38 "ohos.permission.MICROPHONE_CONTROL",
39 "ohos.permission.MODIFY_AUDIO_SETTINGS",
40 "ohos.permission.ACCESS_NOTIFICATION_POLICY",
41 "ohos.permission.USE_BLUETOOTH",
42 "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO",
43 "ohos.permission.RECORD_VOICE_CALL",
44 "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS",
45 };
46
47 NativeTokenInfoParams infoInstance = {
48 .dcapsNum = 0,
49 .permsNum = 10,
50 .aclsNum = 0,
51 .dcaps = nullptr,
52 .perms = perms,
53 .acls = nullptr,
54 .processName = "audio_loopback_unit_test",
55 .aplStr = "system_basic",
56 };
57 tokenId = GetAccessTokenId(&infoInstance);
58 SetSelfTokenID(tokenId);
59 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
60 g_hasPermission = true;
61 }
62 }
63
SetUpTestCase(void)64 void AudioLoopbackUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)65 void AudioLoopbackUnitTest::TearDownTestCase(void) {}
66
SetUp(void)67 void AudioLoopbackUnitTest::SetUp(void)
68 {
69 GetPermission();
70 }
71
TearDown(void)72 void AudioLoopbackUnitTest::TearDown(void) {}
73
74 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_001, TestSize.Level0)
75 {
76 #ifdef TEMP_DISABLED
77 auto audioLoopback = AudioLoopback::CreateAudioLoopback(LOOPBACK_HARDWARE, AppInfo());
78 EXPECT_NE(audioLoopback, nullptr);
79 #endif
80 }
81
82 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_002, TestSize.Level0)
83 {
84 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
85 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
86 EXPECT_EQ(audioLoopback->Enable(true), false);
87 EXPECT_EQ(audioLoopback->Enable(false), false);
88 EXPECT_EQ(audioLoopback->Enable(false), false);
89 }
90
91 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_003, TestSize.Level1)
92 {
93 #ifdef TEMP_DISABLED
94 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
95 audioLoopback->CreateAudioLoopback();
96 EXPECT_EQ(audioLoopback->capturerState_, CAPTURER_RUNNING);
97 auto audioLoopback2 = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
98 audioLoopback2->CreateAudioLoopback();
99 EXPECT_NE(audioLoopback2->capturerState_, CAPTURER_RUNNING);
100 audioLoopback->DestroyAudioLoopback();
101 audioLoopback2->DestroyAudioLoopback();
102 #endif
103 }
104
105 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_004, TestSize.Level1)
106 {
107 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
108 audioLoopback->isRendererUsb_ = true;
109 audioLoopback->UpdateStatus();
110 EXPECT_EQ(audioLoopback->GetStatus(), LOOPBACK_UNAVAILABLE_DEVICE);
111 audioLoopback->DestroyAudioLoopback();
112 }
113
114 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_005, TestSize.Level1)
115 {
116 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
117 audioLoopback->isCapturerUsb_ = true;
118 audioLoopback->UpdateStatus();
119 EXPECT_EQ(audioLoopback->GetStatus(), LOOPBACK_UNAVAILABLE_DEVICE);
120 audioLoopback->DestroyAudioLoopback();
121 }
122
123 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_006, TestSize.Level1)
124 {
125 #ifdef TEMP_DISABLED
126 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
127 audioLoopback->isRendererUsb_ = true;
128 audioLoopback->isCapturerUsb_ = true;
129 audioLoopback->CreateAudioLoopback();
130 audioLoopback->currentState_ = LOOPBACK_STATE_PREPARED;
131 audioLoopback->UpdateStatus();
132 EXPECT_EQ(audioLoopback->capturerState_, CAPTURER_RUNNING);
133 EXPECT_EQ(audioLoopback->GetStatus(), LOOPBACK_AVAILABLE_RUNNING);
134 audioLoopback->isRendererUsb_ = false;
135 audioLoopback->UpdateStatus();
136 EXPECT_EQ(audioLoopback->GetStatus(), LOOPBACK_UNAVAILABLE_DEVICE);
137 audioLoopback->DestroyAudioLoopback();
138 #endif
139 }
140
141 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_007, TestSize.Level1)
142 {
143 #ifdef TEMP_DISABLED
144 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
145 audioLoopback->CreateAudioLoopback();
146 EXPECT_EQ(audioLoopback->capturerState_, CAPTURER_RUNNING);
147 ASSERT_NE(audioLoopback->audioCapturer_, nullptr);
148 audioLoopback->audioCapturer_->Release();
149 audioLoopback->audioCapturer_ = nullptr;
150 audioLoopback->DestroyAudioLoopback();
151 #endif
152 }
153
154 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_008, TestSize.Level1)
155 {
156 #ifdef TEMP_DISABLED
157 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
158 audioLoopback->CreateAudioLoopback();
159 EXPECT_EQ(audioLoopback->capturerState_, CAPTURER_RUNNING);
160 ASSERT_NE(audioLoopback->audioRenderer_, nullptr);
161 audioLoopback->audioRenderer_->Release();
162 audioLoopback->audioRenderer_ = nullptr;
163 audioLoopback->DestroyAudioLoopback();
164 #endif
165 }
166
167 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_009, TestSize.Level1)
168 {
169 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
170 audioLoopback->rendererOptions_.rendererInfo.contentType = ContentType::CONTENT_TYPE_ULTRASONIC;
171 audioLoopback->rendererOptions_.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_SYSTEM;
172 audioLoopback->CreateAudioLoopback();
173 EXPECT_EQ(audioLoopback->audioRenderer_, nullptr);
174 audioLoopback->DestroyAudioLoopback();
175 }
176
177 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_010, TestSize.Level1)
178 {
179 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
180 audioLoopback->rendererOptions_.rendererInfo.rendererFlags = 0;
181 audioLoopback->CreateAudioLoopback();
182 EXPECT_EQ(audioLoopback->rendererFastStatus_, FASTSTATUS_NORMAL);
183 audioLoopback->DestroyAudioLoopback();
184 }
185
186 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_011, TestSize.Level1)
187 {
188 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
189 audioLoopback->capturerOptions_.capturerInfo.sourceType = SOURCE_TYPE_INVALID;
190 audioLoopback->CreateAudioLoopback();
191 EXPECT_EQ(audioLoopback->audioCapturer_, nullptr);
192 audioLoopback->DestroyAudioLoopback();
193 }
194
195 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_012, TestSize.Level1)
196 {
197 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
198 audioLoopback->capturerOptions_.capturerInfo.capturerFlags = 0;
199 audioLoopback->CreateAudioLoopback();
200 EXPECT_EQ(audioLoopback->capturerFastStatus_, FASTSTATUS_NORMAL);
201 audioLoopback->DestroyAudioLoopback();
202 }
203
204 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_013, TestSize.Level1)
205 {
206 AppInfo appInfo = AppInfo();
207 appInfo.appPid = -1;
208 appInfo.appUid = 1;
209 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, appInfo);
210 EXPECT_NE(audioLoopback, nullptr);
211 }
212
213 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetVolume_001, TestSize.Level1)
214 {
215 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
216 int32_t ret = audioLoopback->SetVolume(1);
217 EXPECT_EQ(ret, SUCCESS);
218 EXPECT_EQ(audioLoopback->karaokeParams_["Karaoke_volume"], "100");
219 }
220
221 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetVolume_002, TestSize.Level1)
222 {
223 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
224 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
225 int32_t ret = audioLoopback->SetVolume(1);
226 EXPECT_EQ(ret, SUCCESS);
227 EXPECT_EQ(audioLoopback->karaokeParams_["Karaoke_volume"], "100");
228 }
229
230 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetVolume_003, TestSize.Level1)
231 {
232 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
233 int32_t ret = audioLoopback->SetVolume(10);
234 EXPECT_EQ(ret, ERR_INVALID_PARAM);
235 }
236
237 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetVolume_004, TestSize.Level1)
238 {
239 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
240 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
241 int32_t ret = audioLoopback->SetVolume(-1);
242 EXPECT_EQ(ret, ERR_INVALID_PARAM);
243 }
244
245 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_GetStatus_001, TestSize.Level1)
246 {
247 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
248 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
249 EXPECT_EQ(audioLoopback->GetStatus(), LOOPBACK_AVAILABLE_RUNNING);
250 }
251
252 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_UpdateStatus_001, TestSize.Level1)
253 {
254 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
255 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
256 audioLoopback->isRendererUsb_ = true;
257 audioLoopback->isCapturerUsb_ = true;
258 audioLoopback->UpdateStatus();
259 EXPECT_EQ(audioLoopback->currentState_, LOOPBACK_STATE_DESTROYED);
260 }
261
262 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_UpdateStatus_002, TestSize.Level1)
263 {
264 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
265 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
266 audioLoopback->rendererState_ = RENDERER_RUNNING;
267 audioLoopback->isRendererUsb_ = true;
268 audioLoopback->rendererFastStatus_ = FASTSTATUS_FAST;
269
270 audioLoopback->capturerState_ = CAPTURER_RUNNING;
271 audioLoopback->isCapturerUsb_ = true;
272 audioLoopback->capturerFastStatus_ = FASTSTATUS_FAST;
273 audioLoopback->UpdateStatus();
274 EXPECT_EQ(audioLoopback->currentState_, LOOPBACK_STATE_RUNNING);
275 }
276
277 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_UpdateStatus_003, TestSize.Level1)
278 {
279 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
280 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
281 audioLoopback->UpdateStatus();
282 EXPECT_EQ(audioLoopback->currentState_, LOOPBACK_STATE_DESTROYED);
283 }
284
285 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetReverbPreset_001, TestSize.Level1)
286 {
287 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
288 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
289 bool ret = audioLoopback->SetReverbPreset(REVERB_PRESET_THEATRE);
290 EXPECT_EQ(ret, true);
291 }
292
293 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetReverbPreset_002, TestSize.Level1)
294 {
295 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
296 bool ret = audioLoopback->SetReverbPreset(REVERB_PRESET_THEATRE);
297 EXPECT_EQ(ret, true);
298 }
299
300 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetEqualizerPreset_001, TestSize.Level1)
301 {
302 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
303 audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
304 bool ret = audioLoopback->SetEqualizerPreset(EQUALIZER_PRESET_FLAT);
305 EXPECT_EQ(ret, true);
306 }
307
308 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetEqualizerPreset_002, TestSize.Level1)
309 {
310 auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
311 bool ret = audioLoopback->SetEqualizerPreset(EQUALIZER_PRESET_FLAT);
312 EXPECT_EQ(ret, true);
313 }
314 } // namespace AudioStandard
315 } // namespace OHOS
316