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 "gmock/gmock.h" 18 #include "audio_errors.h" 19 #include "pulse_audio_service_adapter_impl.h" 20 21 using namespace testing::ext; 22 using namespace testing; 23 using namespace std; 24 namespace OHOS { 25 namespace AudioStandard { 26 27 class PulseAudioServiceAdapterImplUnitTest : public testing::Test { 28 public: 29 static void SetUpTestCase(void); 30 static void TearDownTestCase(void); 31 void SetUp(); 32 void TearDown(); 33 }; 34 35 class AudioServiceAdapterCallbackTest : public AudioServiceAdapterCallback { 36 public: OnAudioStreamRemoved(const uint64_t sessionID)37 void OnAudioStreamRemoved(const uint64_t sessionID) override { return; } OnSetVolumeDbCb()38 void OnSetVolumeDbCb() override { return; } 39 }; 40 41 /** 42 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 43 * @tc.number: PulseAudioServiceAdapterImplUnitTest_001 44 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 45 */ 46 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_001, TestSize.Level1) 47 { 48 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 49 std::make_unique<AudioServiceAdapterCallbackTest>(); 50 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 51 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 52 53 pa_mainloop* mainloop = pa_mainloop_new(); 54 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 55 56 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 57 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 58 59 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 60 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 61 62 auto ret = pulseAudioServiceAdapterImpl->ConnectToPulseAudio(); 63 EXPECT_EQ(ret, true); 64 } 65 66 /** 67 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 68 * @tc.number: PulseAudioServiceAdapterImplUnitTest_002 69 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 70 */ 71 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_002, TestSize.Level1) 72 { 73 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 74 std::make_unique<AudioServiceAdapterCallbackTest>(); 75 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 76 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 77 78 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 79 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 80 81 pulseAudioServiceAdapterImpl->mContext = nullptr; 82 83 int32_t audioHandleIndex = 0; 84 auto ret = pulseAudioServiceAdapterImpl->CloseAudioPort(audioHandleIndex); 85 EXPECT_EQ(ret, ERROR); 86 } 87 88 /** 89 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 90 * @tc.number: PulseAudioServiceAdapterImplUnitTest_003 91 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 92 */ 93 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_003, TestSize.Level1) 94 { 95 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 96 std::make_unique<AudioServiceAdapterCallbackTest>(); 97 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 98 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 99 100 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 101 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 102 103 pa_mainloop* mainloop = pa_mainloop_new(); 104 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 105 106 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 107 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 108 109 int32_t audioHandleIndex = 5; 110 auto ret = pulseAudioServiceAdapterImpl->CloseAudioPort(audioHandleIndex); 111 EXPECT_EQ(ret, ERROR); 112 } 113 114 /** 115 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 116 * @tc.number: PulseAudioServiceAdapterImplUnitTest_004 117 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 118 */ 119 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_004, TestSize.Level1) 120 { 121 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 122 std::make_unique<AudioServiceAdapterCallbackTest>(); 123 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 124 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 125 126 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 127 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 128 129 pa_mainloop* mainloop = pa_mainloop_new(); 130 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 131 132 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 133 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 134 135 int32_t audioHandleIndex = 5; 136 auto ret = pulseAudioServiceAdapterImpl->CloseAudioPort(audioHandleIndex); 137 EXPECT_EQ(ret, ERROR); 138 } 139 140 /** 141 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 142 * @tc.number: PulseAudioServiceAdapterImplUnitTest_005 143 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 144 */ 145 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_005, TestSize.Level1) 146 { 147 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 148 std::make_unique<AudioServiceAdapterCallbackTest>(); 149 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 150 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 151 152 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 153 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 154 155 pulseAudioServiceAdapterImpl->mContext = nullptr; 156 157 string audioPortName = "abc"; 158 bool isSuspend = false; 159 auto ret = pulseAudioServiceAdapterImpl->SuspendAudioDevice(audioPortName, isSuspend); 160 EXPECT_EQ(ret, ERROR); 161 } 162 163 /** 164 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 165 * @tc.number: PulseAudioServiceAdapterImplUnitTest_006 166 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 167 */ 168 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_006, TestSize.Level1) 169 { 170 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 171 std::make_unique<AudioServiceAdapterCallbackTest>(); 172 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 173 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 174 175 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 176 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 177 178 pa_mainloop* mainloop = pa_mainloop_new(); 179 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 180 181 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 182 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 183 184 string sinkName = "abc"; 185 bool isMute = false; 186 bool isSync = true; 187 auto ret = pulseAudioServiceAdapterImpl->SetSinkMute(sinkName, isMute, isSync); 188 EXPECT_EQ(ret, false); 189 } 190 191 /** 192 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 193 * @tc.number: PulseAudioServiceAdapterImplUnitTest_007 194 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 195 */ 196 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_007, TestSize.Level1) 197 { 198 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 199 std::make_unique<AudioServiceAdapterCallbackTest>(); 200 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 201 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 202 203 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 204 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 205 206 pa_mainloop* mainloop = pa_mainloop_new(); 207 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 208 209 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 210 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 211 212 string sinkName = "abc"; 213 bool isMute = false; 214 bool isSync = false; 215 auto ret = pulseAudioServiceAdapterImpl->SetSinkMute(sinkName, isMute, isSync); 216 EXPECT_EQ(ret, false); 217 } 218 219 /** 220 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 221 * @tc.number: PulseAudioServiceAdapterImplUnitTest_008 222 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 223 */ 224 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_008, TestSize.Level1) 225 { 226 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 227 std::make_unique<AudioServiceAdapterCallbackTest>(); 228 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 229 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 230 231 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 232 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 233 234 pulseAudioServiceAdapterImpl->mContext = nullptr; 235 236 string name = "abc"; 237 auto ret = pulseAudioServiceAdapterImpl->SetDefaultSink(name); 238 EXPECT_EQ(ret, ERROR); 239 } 240 241 /** 242 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 243 * @tc.number: PulseAudioServiceAdapterImplUnitTest_009 244 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 245 */ 246 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_009, TestSize.Level1) 247 { 248 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 249 std::make_unique<AudioServiceAdapterCallbackTest>(); 250 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 251 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 252 253 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 254 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 255 256 pa_mainloop* mainloop = pa_mainloop_new(); 257 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 258 259 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 260 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 261 262 string name = "abc"; 263 auto ret = pulseAudioServiceAdapterImpl->SetDefaultSink(name); 264 EXPECT_EQ(ret, ERR_OPERATION_FAILED); 265 } 266 267 /** 268 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 269 * @tc.number: PulseAudioServiceAdapterImplUnitTest_010 270 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 271 */ 272 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_010, TestSize.Level1) 273 { 274 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 275 std::make_unique<AudioServiceAdapterCallbackTest>(); 276 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 277 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 278 279 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 280 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 281 282 pulseAudioServiceAdapterImpl->mContext = nullptr; 283 284 string name = "abc"; 285 auto ret = pulseAudioServiceAdapterImpl->SetDefaultSource(name); 286 EXPECT_EQ(ret, ERROR); 287 } 288 289 /** 290 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 291 * @tc.number: PulseAudioServiceAdapterImplUnitTest_011 292 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 293 */ 294 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_011, TestSize.Level1) 295 { 296 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 297 std::make_unique<AudioServiceAdapterCallbackTest>(); 298 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 299 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 300 301 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 302 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 303 304 pa_mainloop* mainloop = pa_mainloop_new(); 305 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 306 307 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 308 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 309 310 string name = "abc"; 311 auto ret = pulseAudioServiceAdapterImpl->SetDefaultSource(name); 312 EXPECT_EQ(ret, ERR_OPERATION_FAILED); 313 } 314 315 /** 316 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 317 * @tc.number: PulseAudioServiceAdapterImplUnitTest_012 318 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 319 */ 320 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_012, TestSize.Level1) 321 { 322 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 323 std::make_unique<AudioServiceAdapterCallbackTest>(); 324 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 325 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 326 327 pa_mainloop* mainloop = pa_mainloop_new(); 328 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 329 pa_context *c = pa_context_new(mainloop_api, "MyAudioApp"); 330 pa_sink_info *i = nullptr; 331 int eol = -1; 332 PulseAudioServiceAdapterImpl::UserData *userdata = new PulseAudioServiceAdapterImpl::UserData(); 333 userdata->thiz = new PulseAudioServiceAdapterImpl(audioServiceAdapterCallback); 334 userdata->thiz->mMainLoop = pa_threaded_mainloop_new(); 335 336 pulseAudioServiceAdapterImpl->PaGetSinksCb(c, i, eol, userdata); 337 eol = 1; 338 pulseAudioServiceAdapterImpl->PaGetSinksCb(c, i, eol, userdata); 339 ASSERT_NE(userdata->thiz->mMainLoop, nullptr); 340 } 341 342 /** 343 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 344 * @tc.number: PulseAudioServiceAdapterImplUnitTest_013 345 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 346 */ 347 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_013, TestSize.Level1) 348 { 349 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 350 std::make_unique<AudioServiceAdapterCallbackTest>(); 351 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 352 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 353 354 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 355 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 356 357 pa_mainloop* mainloop = pa_mainloop_new(); 358 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 359 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 360 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 361 362 auto ret = pulseAudioServiceAdapterImpl->GetAllSinks(); 363 EXPECT_EQ(ret.size(), 0); 364 } 365 366 /** 367 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 368 * @tc.number: PulseAudioServiceAdapterImplUnitTest_014 369 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 370 */ 371 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_014, TestSize.Level1) 372 { 373 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 374 std::make_unique<AudioServiceAdapterCallbackTest>(); 375 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 376 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 377 378 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 379 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 380 381 pa_mainloop* mainloop = pa_mainloop_new(); 382 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 383 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 384 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 385 386 uint32_t sinkInputId = 0; 387 uint32_t sinkIndex = 0; 388 std::string sinkName = ""; 389 auto ret = pulseAudioServiceAdapterImpl->MoveSinkInputByIndexOrName(sinkInputId, sinkIndex, sinkName); 390 EXPECT_EQ(ret, ERROR); 391 392 sinkName = "abc"; 393 ret = pulseAudioServiceAdapterImpl->MoveSinkInputByIndexOrName(sinkInputId, sinkIndex, sinkName); 394 EXPECT_EQ(ret, ERROR); 395 } 396 397 /** 398 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 399 * @tc.number: PulseAudioServiceAdapterImplUnitTest_015 400 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 401 */ 402 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_015, TestSize.Level1) 403 { 404 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 405 std::make_unique<AudioServiceAdapterCallbackTest>(); 406 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 407 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 408 409 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 410 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 411 412 pulseAudioServiceAdapterImpl->mContext = nullptr; 413 414 uint32_t sourceOutputId = 0; 415 uint32_t sourceIndex = 0; 416 std::string sourceName = ""; 417 auto ret = pulseAudioServiceAdapterImpl->MoveSourceOutputByIndexOrName(sourceOutputId, sourceIndex, sourceName); 418 EXPECT_EQ(ret, ERROR); 419 420 pa_mainloop* mainloop = pa_mainloop_new(); 421 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 422 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 423 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 424 425 sourceName = ""; 426 ret = pulseAudioServiceAdapterImpl->MoveSourceOutputByIndexOrName(sourceOutputId, sourceIndex, sourceName); 427 EXPECT_EQ(ret, ERROR); 428 429 sourceName = "abc"; 430 ret = pulseAudioServiceAdapterImpl->MoveSourceOutputByIndexOrName(sourceOutputId, sourceIndex, sourceName); 431 EXPECT_EQ(ret, ERROR); 432 } 433 434 /** 435 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 436 * @tc.number: PulseAudioServiceAdapterImplUnitTest_016 437 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 438 */ 439 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_016, TestSize.Level1) 440 { 441 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 442 std::make_unique<AudioServiceAdapterCallbackTest>(); 443 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 444 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 445 446 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 447 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 448 449 pa_mainloop* mainloop = pa_mainloop_new(); 450 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 451 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 452 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 453 454 auto ret = pulseAudioServiceAdapterImpl->GetAllSinkInputs(); 455 EXPECT_EQ(ret.size(), 0); 456 auto ret2 = pulseAudioServiceAdapterImpl->GetAllSourceOutputs(); 457 EXPECT_EQ(ret2.size(), 0); 458 } 459 460 /** 461 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 462 * @tc.number: PulseAudioServiceAdapterImplUnitTest_017 463 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 464 */ 465 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_017, TestSize.Level1) 466 { 467 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 468 std::make_unique<AudioServiceAdapterCallbackTest>(); 469 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 470 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 471 472 pulseAudioServiceAdapterImpl->mContext = nullptr; 473 pulseAudioServiceAdapterImpl->mMainLoop = nullptr; 474 pulseAudioServiceAdapterImpl->Disconnect(); 475 476 pulseAudioServiceAdapterImpl->mMainLoop = pa_threaded_mainloop_new(); 477 ASSERT_NE(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 478 479 pa_mainloop* mainloop = pa_mainloop_new(); 480 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 481 pulseAudioServiceAdapterImpl->mContext = pa_context_new(mainloop_api, "MyAudioApp"); 482 ASSERT_NE(pulseAudioServiceAdapterImpl->mContext, nullptr); 483 484 pulseAudioServiceAdapterImpl->Disconnect(); 485 ASSERT_EQ(pulseAudioServiceAdapterImpl->mMainLoop, nullptr); 486 ASSERT_EQ(pulseAudioServiceAdapterImpl->mContext, nullptr); 487 } 488 489 /** 490 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 491 * @tc.number: PulseAudioServiceAdapterImplUnitTest_018 492 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 493 */ 494 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_018, TestSize.Level1) 495 { 496 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 497 std::make_unique<AudioServiceAdapterCallbackTest>(); 498 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 499 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 500 501 string streamType = "voice_call"; 502 auto ret = pulseAudioServiceAdapterImpl->GetIdByStreamType(streamType); 503 EXPECT_EQ(ret, STREAM_VOICE_CALL); 504 505 streamType = "abc"; 506 ret = pulseAudioServiceAdapterImpl->GetIdByStreamType(streamType); 507 EXPECT_EQ(ret, STREAM_MUSIC); 508 } 509 510 /** 511 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 512 * @tc.number: PulseAudioServiceAdapterImplUnitTest_019 513 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 514 */ 515 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_019, TestSize.Level1) 516 { 517 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 518 std::make_unique<AudioServiceAdapterCallbackTest>(); 519 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 520 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 521 522 pa_mainloop* mainloop = pa_mainloop_new(); 523 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 524 pa_context *c = pa_context_new(mainloop_api, "MyAudioApp"); 525 526 PulseAudioServiceAdapterImpl::UserData *userdata = new PulseAudioServiceAdapterImpl::UserData(); 527 userdata->thiz = new PulseAudioServiceAdapterImpl(audioServiceAdapterCallback); 528 userdata->thiz->mMainLoop = pa_threaded_mainloop_new(); 529 530 uint32_t idx = PA_INVALID_INDEX; 531 pulseAudioServiceAdapterImpl->PaModuleLoadCb(c, idx, userdata); 532 EXPECT_EQ(userdata->idx, PA_INVALID_INDEX); 533 } 534 535 /** 536 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 537 * @tc.number: PulseAudioServiceAdapterImplUnitTest_020 538 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 539 */ 540 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_020, TestSize.Level1) 541 { 542 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 543 std::make_unique<AudioServiceAdapterCallbackTest>(); 544 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 545 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 546 547 pa_mainloop* mainloop = pa_mainloop_new(); 548 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 549 pa_context *c = pa_context_new(mainloop_api, "MyAudioApp"); 550 pa_source_output_info *i = nullptr; 551 int eol = -1; 552 PulseAudioServiceAdapterImpl::UserData *userdata = new PulseAudioServiceAdapterImpl::UserData(); 553 userdata->thiz = new PulseAudioServiceAdapterImpl(audioServiceAdapterCallback); 554 userdata->thiz->mMainLoop = pa_threaded_mainloop_new(); 555 556 pulseAudioServiceAdapterImpl->PaGetSourceOutputNoSignalCb(c, i, eol, userdata); 557 ASSERT_NE(userdata, nullptr); 558 559 eol = 1; 560 userdata = new PulseAudioServiceAdapterImpl::UserData(); 561 userdata->thiz = new PulseAudioServiceAdapterImpl(audioServiceAdapterCallback); 562 userdata->thiz->mMainLoop = pa_threaded_mainloop_new(); 563 pulseAudioServiceAdapterImpl->PaGetSourceOutputNoSignalCb(c, i, eol, userdata); 564 ASSERT_NE(userdata, nullptr); 565 } 566 567 /** 568 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 569 * @tc.number: PulseAudioServiceAdapterImplUnitTest_021 570 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 571 */ 572 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_021, TestSize.Level1) 573 { 574 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 575 std::make_unique<AudioServiceAdapterCallbackTest>(); 576 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 577 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 578 579 pa_mainloop* mainloop = pa_mainloop_new(); 580 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 581 pa_context *c = pa_context_new(mainloop_api, "MyAudioApp"); 582 pa_sink_input_info *i = nullptr; 583 int eol = -1; 584 PulseAudioServiceAdapterImpl::UserData *userdata = new PulseAudioServiceAdapterImpl::UserData(); 585 userdata->thiz = new PulseAudioServiceAdapterImpl(audioServiceAdapterCallback); 586 userdata->thiz->mMainLoop = pa_threaded_mainloop_new(); 587 588 pulseAudioServiceAdapterImpl->PaGetAllSinkInputsCb(c, i, eol, userdata); 589 ASSERT_NE(userdata, nullptr); 590 591 eol = 1; 592 pulseAudioServiceAdapterImpl->PaGetAllSinkInputsCb(c, i, eol, userdata); 593 ASSERT_NE(userdata, nullptr); 594 } 595 596 /** 597 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 598 * @tc.number: PulseAudioServiceAdapterImplUnitTest_022 599 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 600 */ 601 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_022, TestSize.Level1) 602 { 603 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 604 std::make_unique<AudioServiceAdapterCallbackTest>(); 605 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 606 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 607 608 pa_mainloop* mainloop = pa_mainloop_new(); 609 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 610 pa_context *c = pa_context_new(mainloop_api, "MyAudioApp"); 611 pa_subscription_event_type_t t = 612 static_cast<pa_subscription_event_type_t>(PA_SUBSCRIPTION_EVENT_CHANGE | PA_SUBSCRIPTION_EVENT_SINK); 613 uint32_t idx = 0; 614 PulseAudioServiceAdapterImpl::UserData *userdata = new PulseAudioServiceAdapterImpl::UserData(); 615 userdata->thiz = new PulseAudioServiceAdapterImpl(audioServiceAdapterCallback); 616 userdata->thiz->mMainLoop = pa_threaded_mainloop_new(); 617 618 EXPECT_NE(t & PA_SUBSCRIPTION_EVENT_TYPE_MASK, PA_SUBSCRIPTION_EVENT_NEW); 619 EXPECT_NE(t & PA_SUBSCRIPTION_EVENT_TYPE_MASK, PA_SUBSCRIPTION_EVENT_REMOVE); 620 pulseAudioServiceAdapterImpl->ProcessSourceOutputEvent(c, t, idx, userdata); 621 ASSERT_NE(userdata, nullptr); 622 623 t = static_cast<pa_subscription_event_type_t>(PA_SUBSCRIPTION_EVENT_NEW | PA_SUBSCRIPTION_EVENT_SINK); 624 EXPECT_EQ(t & PA_SUBSCRIPTION_EVENT_TYPE_MASK, PA_SUBSCRIPTION_EVENT_NEW); 625 pulseAudioServiceAdapterImpl->ProcessSourceOutputEvent(c, t, idx, userdata); 626 ASSERT_NE(userdata, nullptr); 627 628 userdata = new PulseAudioServiceAdapterImpl::UserData(); 629 userdata->thiz = new PulseAudioServiceAdapterImpl(audioServiceAdapterCallback); 630 userdata->thiz->mMainLoop = pa_threaded_mainloop_new(); 631 632 t = static_cast<pa_subscription_event_type_t>(PA_SUBSCRIPTION_EVENT_REMOVE | PA_SUBSCRIPTION_EVENT_SINK); 633 EXPECT_EQ(t & PA_SUBSCRIPTION_EVENT_TYPE_MASK, PA_SUBSCRIPTION_EVENT_REMOVE); 634 pulseAudioServiceAdapterImpl->ProcessSourceOutputEvent(c, t, idx, userdata); 635 ASSERT_NE(userdata, nullptr); 636 } 637 638 /** 639 * @tc.name : Test PulseAudioServiceAdapterImplUnitTest API 640 * @tc.number: PulseAudioServiceAdapterImplUnitTest_023 641 * @tc.desc : Test PulseAudioServiceAdapterImplUnitTest interface. 642 */ 643 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_023, TestSize.Level1) 644 { 645 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 646 std::make_unique<AudioServiceAdapterCallbackTest>(); 647 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 648 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 649 650 pa_mainloop* mainloop = pa_mainloop_new(); 651 pa_mainloop_api* mainloop_api = pa_mainloop_get_api(mainloop); 652 pa_context *c = pa_context_new(mainloop_api, "MyAudioApp"); 653 pa_subscription_event_type_t t = 654 static_cast<pa_subscription_event_type_t>(PA_SUBSCRIPTION_EVENT_NEW | PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT); 655 uint32_t idx = 0; 656 PulseAudioServiceAdapterImpl::UserData *userdata = new PulseAudioServiceAdapterImpl::UserData(); 657 userdata->thiz = new PulseAudioServiceAdapterImpl(audioServiceAdapterCallback); 658 userdata->thiz->mMainLoop = pa_threaded_mainloop_new(); 659 660 EXPECT_EQ(t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT); 661 pulseAudioServiceAdapterImpl->PaSubscribeCb(c, t, idx, userdata); 662 663 t = static_cast<pa_subscription_event_type_t>(PA_SUBSCRIPTION_EVENT_NEW | PA_SUBSCRIPTION_EVENT_MODULE); 664 pulseAudioServiceAdapterImpl->PaSubscribeCb(c, t, idx, userdata); 665 666 t = static_cast<pa_subscription_event_type_t>(PA_SUBSCRIPTION_EVENT_REMOVE | PA_SUBSCRIPTION_EVENT_SINK_INPUT); 667 pulseAudioServiceAdapterImpl->PaSubscribeCb(c, t, idx, userdata); 668 ASSERT_NE(userdata, nullptr); 669 } 670 671 /** 672 * @tc.name : Test PulseAudioServiceAdapterImpl API 673 * @tc.number: PulseAudioServiceAdapterImplUnitTest_024 674 * @tc.desc : Test SetThreadPriority interface. 675 */ 676 HWTEST(PulseAudioServiceAdapterImplUnitTest, PulseAudioServiceAdapterImplUnitTest_024, TestSize.Level3) 677 { 678 std::unique_ptr<AudioServiceAdapterCallback> audioServiceAdapterCallback = 679 std::make_unique<AudioServiceAdapterCallbackTest>(); 680 auto pulseAudioServiceAdapterImpl = std::make_shared<PulseAudioServiceAdapterImpl>(audioServiceAdapterCallback); 681 ASSERT_NE(pulseAudioServiceAdapterImpl, nullptr); 682 683 // start test 684 bool res = pulseAudioServiceAdapterImpl->SetThreadPriority(); 685 EXPECT_EQ(res, true); 686 res = pulseAudioServiceAdapterImpl->SetThreadPriority(); 687 EXPECT_EQ(res, true); 688 } 689 690 } // namespace AudioStandard 691 } // namespace OHOS