1 /* 2 * Copyright (c) 2024 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 #include <gtest/gtest.h> 16 17 #include "audio_service_log.h" 18 #include "audio_errors.h" 19 #include "audio_server.h" 20 #include "audio_service.h" 21 #include "system_ability_definition.h" 22 #include "audio_service_types.h" 23 24 using namespace testing::ext; 25 26 namespace OHOS { 27 namespace AudioStandard { 28 29 class AudioServerUnitTest : public testing::Test { 30 public: 31 static void SetUpTestCase(void); 32 static void TearDownTestCase(void); 33 void SetUp(); 34 void TearDown(); 35 }; 36 37 #ifdef TEMP_DISABLE 38 /** 39 * @tc.name : Test CreatePlaybackCapturerManager API 40 * @tc.type : FUNC 41 * @tc.number: CreatePlaybackCapturerManager_001 42 * @tc.desc : Test CreatePlaybackCapturerManager interface using empty case. 43 */ 44 HWTEST(AudioServerUnitTest, CreatePlaybackCapturerManager_001, TestSize.Level1) 45 { 46 AUDIO_INFO_LOG("AudioServerUnitTest CreatePlaybackCapturerManager_001 start"); 47 int32_t systemAbilityId = 100; 48 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 49 bool ret = false; 50 audioServer->CreatePlaybackCapturerManager(ret); 51 EXPECT_EQ(true, ret); 52 } 53 #endif 54 55 /** 56 * @tc.name : Test SetIORoutes API 57 * @tc.type : FUNC 58 * @tc.number: SetIORoutes_001 59 * @tc.desc : Test SetIORoutes interface using empty case, when type is DEVICE_TYPE_USB_ARM_HEADSET, 60 deviceType is DEVICE_TYPE_USB_ARM_HEADSET. 61 */ 62 HWTEST(AudioServerUnitTest, SetIORoutes_001, TestSize.Level1) 63 { 64 AUDIO_INFO_LOG("AudioServerUnitTest SetIORoutes_001 start"); 65 int32_t systemAbilityId = 100; 66 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 67 DeviceType type = DEVICE_TYPE_USB_ARM_HEADSET; 68 DeviceFlag flag = ALL_DEVICES_FLAG; 69 std::vector<DeviceType> deviceTypes; 70 DeviceType deviceType = DEVICE_TYPE_USB_ARM_HEADSET; 71 deviceTypes.push_back(deviceType); 72 BluetoothOffloadState a2dpOffloadFlag = A2DP_OFFLOAD; 73 bool ret = audioServer->SetIORoutes(type, flag, deviceTypes, a2dpOffloadFlag); 74 EXPECT_EQ(false, ret); 75 } 76 77 /** 78 * @tc.name : Test OnAddSystemAbility API 79 * @tc.type : FUNC 80 * @tc.number: OnAddSystemAbility_001 81 * @tc.desc : Test OnAddSystemAbility interface using empty case. 82 */ 83 HWTEST(AudioServerUnitTest, OnAddSystemAbility_001, TestSize.Level1) 84 { 85 AUDIO_INFO_LOG("AudioServerUnitTest OnAddSystemAbility_001 start"); 86 int32_t systemAbilityId = 100; 87 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 88 const std::string deviceId = ""; 89 audioServer->OnAddSystemAbility(LAST_SYS_ABILITY_ID, deviceId); 90 } 91 92 /** 93 * @tc.name : Test InitMaxRendererStreamCntPerUid API 94 * @tc.type : FUNC 95 * @tc.number: InitMaxRendererStreamCntPerUid_001 96 * @tc.desc : Test InitMaxRendererStreamCntPerUid interface using empty case. 97 */ 98 HWTEST(AudioServerUnitTest, InitMaxRendererStreamCntPerUid_001, TestSize.Level1) 99 { 100 AUDIO_INFO_LOG("AudioServerUnitTest InitMaxRendererStreamCntPerUid_001 start"); 101 int32_t systemAbilityId = 100; 102 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 103 ASSERT_TRUE(audioServer != nullptr); 104 audioServer->InitMaxRendererStreamCntPerUid(); 105 } 106 107 /** 108 * @tc.name : Test WriteServiceStartupError API 109 * @tc.type : FUNC 110 * @tc.number: WriteServiceStartupError_001 111 * @tc.desc : Test WriteServiceStartupError interface using empty case. 112 */ 113 HWTEST(AudioServerUnitTest, WriteServiceStartupError_001, TestSize.Level1) 114 { 115 AUDIO_INFO_LOG("AudioServerUnitTest WriteServiceStartupError_001 start"); 116 int32_t systemAbilityId = 100; 117 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 118 ASSERT_TRUE(audioServer != nullptr); 119 audioServer->WriteServiceStartupError(); 120 } 121 122 /** 123 * @tc.name : Test CheckMaxRendererInstances API 124 * @tc.type : FUNC 125 * @tc.number: CheckMaxRendererInstances_001 126 * @tc.desc : Test CheckMaxRendererInstances interface using empty case. 127 */ 128 HWTEST(AudioServerUnitTest, CheckMaxRendererInstances_001, TestSize.Level1) 129 { 130 AUDIO_INFO_LOG("AudioServerUnitTest CheckMaxRendererInstances_001 start"); 131 int32_t systemAbilityId = 100; 132 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 133 ASSERT_TRUE(audioServer != nullptr); 134 int32_t ret = audioServer->CheckMaxRendererInstances(); 135 EXPECT_EQ(ret, SUCCESS); 136 } 137 138 /** 139 * @tc.name : Test CheckMaxRendererInstances API 140 * @tc.type : FUNC 141 * @tc.number: CheckMaxRendererInstances_002 142 * @tc.desc : Test CheckMaxRendererInstances interface using empty case. 143 */ 144 HWTEST(AudioServerUnitTest, CheckMaxRendererInstances_002, TestSize.Level1) 145 { 146 AUDIO_INFO_LOG("AudioServerUnitTest CheckMaxRendererInstances_002 start"); 147 int32_t systemAbilityId = 100; 148 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 149 ASSERT_TRUE(audioServer != nullptr); 150 AudioService::GetInstance()->currentRendererStreamCnt_ = 128; 151 int32_t ret = audioServer->CheckMaxRendererInstances(); 152 EXPECT_EQ(ret, ERR_EXCEED_MAX_STREAM_CNT); 153 } 154 155 /** 156 * @tc.name : Test CheckAndWaitAudioPolicyReady API 157 * @tc.type : FUNC 158 * @tc.number: CheckAndWaitAudioPolicyReady_001 159 * @tc.desc : Test CheckAndWaitAudioPolicyReady interface using empty case. 160 */ 161 HWTEST(AudioServerUnitTest, CheckAndWaitAudioPolicyReady_001, TestSize.Level1) 162 { 163 AUDIO_INFO_LOG("AudioServerUnitTest CheckAndWaitAudioPolicyReady_001 start"); 164 int32_t systemAbilityId = 100; 165 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 166 ASSERT_TRUE(audioServer != nullptr); 167 int32_t ret = audioServer->CheckAndWaitAudioPolicyReady(); 168 EXPECT_EQ(ret, SUCCESS); 169 } 170 171 /** 172 * @tc.name : Test CheckAndWaitAudioPolicyReady API 173 * @tc.type : FUNC 174 * @tc.number: CheckAndWaitAudioPolicyReady_002 175 * @tc.desc : Test CheckAndWaitAudioPolicyReady interface using empty case. 176 */ 177 HWTEST(AudioServerUnitTest, CheckAndWaitAudioPolicyReady_002, TestSize.Level1) 178 { 179 AUDIO_INFO_LOG("AudioServerUnitTest CheckAndWaitAudioPolicyReady_002 start"); 180 int32_t systemAbilityId = 100; 181 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 182 ASSERT_TRUE(audioServer != nullptr); 183 audioServer->waitCreateStreamInServerCount_ = 6; 184 int32_t ret = audioServer->CheckAndWaitAudioPolicyReady(); 185 EXPECT_EQ(ret, ERR_RETRY_IN_CLIENT); 186 } 187 188 /** 189 * @tc.name : Test CheckAndWaitAudioPolicyReady API 190 * @tc.type : FUNC 191 * @tc.number: CheckAndWaitAudioPolicyReady_003 192 * @tc.desc : Test CheckAndWaitAudioPolicyReady interface using empty case. 193 */ 194 HWTEST(AudioServerUnitTest, CheckAndWaitAudioPolicyReady_003, TestSize.Level1) 195 { 196 AUDIO_INFO_LOG("AudioServerUnitTest CheckAndWaitAudioPolicyReady_003 start"); 197 int32_t systemAbilityId = 100; 198 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 199 ASSERT_TRUE(audioServer != nullptr); 200 audioServer->isAudioPolicyReady_ = true; 201 int32_t ret = audioServer->CheckAndWaitAudioPolicyReady(); 202 EXPECT_EQ(ret, SUCCESS); 203 } 204 205 /** 206 * @tc.name : Test RegisterAudioCapturerSourceCallback API 207 * @tc.type : FUNC 208 * @tc.number: RegisterAudioCapturerSourceCallback_001 209 * @tc.desc : Test RegisterAudioCapturerSourceCallback interface using empty case. 210 */ 211 HWTEST(AudioServerUnitTest, RegisterAudioCapturerSourceCallback_001, TestSize.Level1) 212 { 213 AUDIO_INFO_LOG("AudioServerUnitTest RegisterAudioCapturerSourceCallback_001 start"); 214 int32_t systemAbilityId = 100; 215 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 216 ASSERT_TRUE(audioServer != nullptr); 217 audioServer->RegisterAudioCapturerSourceCallback(); 218 } 219 220 /** 221 * @tc.name : Test RegisterAudioRendererSinkCallback API 222 * @tc.type : FUNC 223 * @tc.number: RegisterAudioRendererSinkCallback_001 224 * @tc.desc : Test RegisterAudioRendererSinkCallback interface using empty case. 225 */ 226 HWTEST(AudioServerUnitTest, RegisterAudioRendererSinkCallback_001, TestSize.Level1) 227 { 228 AUDIO_INFO_LOG("AudioServerUnitTest RegisterAudioRendererSinkCallback_001 start"); 229 int32_t systemAbilityId = 100; 230 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 231 ASSERT_TRUE(audioServer != nullptr); 232 audioServer->RegisterAudioRendererSinkCallback(); 233 } 234 235 /** 236 * @tc.name : Test RegisterDataTransferStateChangeCallback API 237 * @tc.type : FUNC 238 * @tc.number: RegisterDataTransferStateChangeCallback_001 239 * @tc.desc : Test RegisterDataTransferStateChangeCallback interface using empty case. 240 */ 241 HWTEST(AudioServerUnitTest, RegisterDataTransferStateChangeCallback_001, TestSize.Level1) 242 { 243 AUDIO_INFO_LOG("AudioServerUnitTest RegisterDataTransferStateChangeCallback_001 start"); 244 int32_t systemAbilityId = 100; 245 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 246 ASSERT_TRUE(audioServer != nullptr); 247 audioServer->RegisterDataTransferStateChangeCallback(); 248 } 249 250 /** 251 * @tc.name : Test OnRenderSinkStateChange API 252 * @tc.type : FUNC 253 * @tc.number: OnRenderSinkStateChange_001 254 * @tc.desc : Test OnRenderSinkStateChange interface using empty case. 255 */ 256 HWTEST(AudioServerUnitTest, OnRenderSinkStateChange_001, TestSize.Level1) 257 { 258 AUDIO_INFO_LOG("AudioServerUnitTest OnRenderSinkStateChange_001 start"); 259 int32_t systemAbilityId = 100; 260 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 261 ASSERT_TRUE(audioServer != nullptr); 262 uint32_t sinkId = 1; 263 bool started = true; 264 audioServer->OnRenderSinkStateChange(sinkId, started); 265 } 266 267 /** 268 * @tc.name : Test CheckHibernateState API 269 * @tc.type : FUNC 270 * @tc.number: CheckHibernateState_001 271 * @tc.desc : Test CheckHibernateState interface using empty case. 272 */ 273 HWTEST(AudioServerUnitTest, CheckHibernateState_001, TestSize.Level1) 274 { 275 AUDIO_INFO_LOG("AudioServerUnitTest CheckHibernateState_001 start"); 276 int32_t systemAbilityId = 100; 277 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 278 ASSERT_TRUE(audioServer != nullptr); 279 bool hibernate = true; 280 audioServer->CheckHibernateState(hibernate); 281 } 282 283 #ifdef TEMP_DISABLE 284 /** 285 * @tc.name : Test CreateIpcOfflineStream API 286 * @tc.type : FUNC 287 * @tc.number: CreateIpcOfflineStream_001 288 * @tc.desc : Test CreateIpcOfflineStream interface using empty case. 289 */ 290 HWTEST(AudioServerUnitTest, CreateIpcOfflineStream_001, TestSize.Level1) 291 { 292 AUDIO_INFO_LOG("AudioServerUnitTest CreateIpcOfflineStream_001 start"); 293 int32_t systemAbilityId = 100; 294 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 295 ASSERT_TRUE(audioServer != nullptr); 296 int32_t errorCode = 0; 297 sptr<IRemoteObject> obj = nullptr; 298 audioServer->CreateIpcOfflineStream(errorCode, obj); 299 EXPECT_NE(obj, nullptr); 300 } 301 302 /** 303 * @tc.name : Test GetOfflineAudioEffectChains API 304 * @tc.type : FUNC 305 * @tc.number: GetOfflineAudioEffectChains_001 306 * @tc.desc : Test GetOfflineAudioEffectChains interface using empty case. 307 */ 308 HWTEST(AudioServerUnitTest, GetOfflineAudioEffectChains_001, TestSize.Level1) 309 { 310 AUDIO_INFO_LOG("AudioServerUnitTest GetOfflineAudioEffectChains_001 start"); 311 int32_t systemAbilityId = 100; 312 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 313 ASSERT_TRUE(audioServer != nullptr); 314 std::vector<std::string> effectChains = {}; 315 int32_t ret = audioServer->GetOfflineAudioEffectChains(effectChains); 316 EXPECT_EQ(ret, SUCCESS); 317 } 318 319 /** 320 * @tc.name : Test GenerateSessionId API 321 * @tc.type : FUNC 322 * @tc.number: GenerateSessionId_001 323 * @tc.desc : Test GenerateSessionId interface using empty case. 324 */ 325 HWTEST(AudioServerUnitTest, GenerateSessionId_001, TestSize.Level1) 326 { 327 AUDIO_INFO_LOG("AudioServerUnitTest GenerateSessionId_001 start"); 328 int32_t systemAbilityId = 100; 329 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 330 ASSERT_TRUE(audioServer != nullptr); 331 uint32_t sessionId = 1; 332 int32_t ret = audioServer->GenerateSessionId(sessionId); 333 EXPECT_EQ(ret, ERROR); 334 } 335 #endif 336 337 /** 338 * @tc.name : Test GetAllSinkInputs API 339 * @tc.type : FUNC 340 * @tc.number: GetAllSinkInputs_001 341 * @tc.desc : Test GetAllSinkInputs interface using empty case. 342 */ 343 HWTEST(AudioServerUnitTest, GetAllSinkInputs_001, TestSize.Level1) 344 { 345 AUDIO_INFO_LOG("AudioServerUnitTest GetAllSinkInputs_001 start"); 346 int32_t systemAbilityId = 100; 347 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 348 ASSERT_TRUE(audioServer != nullptr); 349 std::vector<SinkInput> sinkInputs = {}; 350 audioServer->GetAllSinkInputs(sinkInputs); 351 } 352 353 /** 354 * @tc.name : Test NotifyAudioPolicyReady API 355 * @tc.type : FUNC 356 * @tc.number: NotifyAudioPolicyReady_001 357 * @tc.desc : Test NotifyAudioPolicyReady interface using empty case. 358 */ 359 HWTEST(AudioServerUnitTest, NotifyAudioPolicyReady_001, TestSize.Level1) 360 { 361 AUDIO_INFO_LOG("AudioServerUnitTest NotifyAudioPolicyReady_001 start"); 362 int32_t systemAbilityId = 100; 363 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 364 ASSERT_TRUE(audioServer != nullptr); 365 audioServer->NotifyAudioPolicyReady(); 366 } 367 368 /** 369 * @tc.name : Test CheckCaptureLimit API 370 * @tc.type : FUNC 371 * @tc.number: CheckCaptureLimit_001 372 * @tc.desc : Test CheckCaptureLimit interface using empty case. 373 */ 374 #ifdef HAS_FEATURE_INNERCAPTURER 375 HWTEST(AudioServerUnitTest, CheckCaptureLimit_001, TestSize.Level1) 376 { 377 AUDIO_INFO_LOG("AudioServerUnitTest CheckCaptureLimit_001 start"); 378 int32_t systemAbilityId = 100; 379 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 380 ASSERT_TRUE(audioServer != nullptr); 381 AudioPlaybackCaptureConfig config; 382 int32_t innerCapId = 0; 383 int32_t ret = audioServer->CheckCaptureLimit(config, innerCapId); 384 EXPECT_EQ(ret, SUCCESS); 385 } 386 387 #ifdef TEMP_DISABLE 388 /** 389 * @tc.name : Test SetInnerCapLimit API 390 * @tc.type : FUNC 391 * @tc.number: SetInnerCapLimit_001 392 * @tc.desc : Test SetInnerCapLimit interface using empty case. 393 */ 394 HWTEST(AudioServerUnitTest, SetInnerCapLimit_001, TestSize.Level1) 395 { 396 AUDIO_INFO_LOG("AudioServerUnitTest SetInnerCapLimit_001 start"); 397 int32_t systemAbilityId = 100; 398 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 399 ASSERT_TRUE(audioServer != nullptr); 400 int32_t innerCapId = 0; 401 int32_t ret = audioServer->SetInnerCapLimit(innerCapId); 402 EXPECT_EQ(ret, SUCCESS); 403 } 404 #endif 405 406 /** 407 * @tc.name : Test ReleaseCaptureLimit API 408 * @tc.type : FUNC 409 * @tc.number: ReleaseCaptureLimit_001 410 * @tc.desc : Test ReleaseCaptureLimit interface using empty case. 411 */ 412 HWTEST(AudioServerUnitTest, ReleaseCaptureLimit_001, TestSize.Level1) 413 { 414 AUDIO_INFO_LOG("AudioServerUnitTest ReleaseCaptureLimit_001 start"); 415 int32_t systemAbilityId = 100; 416 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 417 ASSERT_TRUE(audioServer != nullptr); 418 int32_t innerCapId = 0; 419 int32_t ret = audioServer->ReleaseCaptureLimit(innerCapId); 420 EXPECT_EQ(ret, SUCCESS); 421 } 422 #endif 423 424 /** 425 * @tc.name : Test LoadHdiAdapter API 426 * @tc.type : FUNC 427 * @tc.number: LoadHdiAdapter_001 428 * @tc.desc : Test LoadHdiAdapter interface using empty case. 429 */ 430 HWTEST(AudioServerUnitTest, LoadHdiAdapter_001, TestSize.Level1) 431 { 432 AUDIO_INFO_LOG("AudioServerUnitTest LoadHdiAdapter_001 start"); 433 int32_t systemAbilityId = 100; 434 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 435 ASSERT_TRUE(audioServer != nullptr); 436 uint32_t devMgrType = 0; 437 std::string adapterName = "test"; 438 int32_t ret = audioServer->LoadHdiAdapter(devMgrType, adapterName); 439 EXPECT_NE(ret, SUCCESS); 440 } 441 442 /** 443 * @tc.name : Test UnloadHdiAdapter API 444 * @tc.type : FUNC 445 * @tc.number: UnloadHdiAdapter_001 446 * @tc.desc : Test UnloadHdiAdapter interface using empty case. 447 */ 448 HWTEST(AudioServerUnitTest, UnloadHdiAdapter_001, TestSize.Level1) 449 { 450 AUDIO_INFO_LOG("AudioServerUnitTest UnloadHdiAdapter_001 start"); 451 int32_t systemAbilityId = 100; 452 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 453 ASSERT_TRUE(audioServer != nullptr); 454 uint32_t devMgrType = 0; 455 const std::string adapterName = "test"; 456 bool force = false; 457 audioServer->UnloadHdiAdapter(devMgrType, adapterName, force); 458 } 459 460 /** 461 * @tc.name : Test ParseAudioParameter API 462 * @tc.type : FUNC 463 * @tc.number: ParseAudioParameter_001 464 * @tc.desc : Test ParseAudioParameter interface. 465 */ 466 HWTEST(AudioServerUnitTest, ParseAudioParameter_001, TestSize.Level1) 467 { 468 AUDIO_INFO_LOG("AudioServerUnitTest ParseAudioParameter_001 start"); 469 int32_t systemAbilityId = 100; 470 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 471 ASSERT_TRUE(audioServer != nullptr); 472 EXPECT_FALSE(audioServer->isAudioParameterParsed_.load()); 473 audioServer->ParseAudioParameter(); 474 EXPECT_TRUE(audioServer->isAudioParameterParsed_.load()); 475 } 476 477 /** 478 * @tc.name : Test ParseAudioParameter API 479 * @tc.type : FUNC 480 * @tc.number: ParseAudioParameter_002 481 * @tc.desc : Test ParseAudioParameter interface. 482 */ 483 HWTEST(AudioServerUnitTest, ParseAudioParameter_002, TestSize.Level1) 484 { 485 AUDIO_INFO_LOG("AudioServerUnitTest ParseAudioParameter_002 start"); 486 int32_t systemAbilityId = 3001; 487 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 488 ASSERT_TRUE(audioServer != nullptr); 489 EXPECT_FALSE(audioServer->isAudioParameterParsed_.load()); 490 audioServer->ParseAudioParameter(); 491 EXPECT_TRUE(audioServer->isAudioParameterParsed_.load()); 492 } 493 494 /** 495 * @tc.name : Test CacheExtraParameters API 496 * @tc.type : FUNC 497 * @tc.number: CacheExtraParameters_001 498 * @tc.desc : Test CacheExtraParameters interface. 499 */ 500 HWTEST(AudioServerUnitTest, CacheExtraParameters_001, TestSize.Level1) 501 { 502 AUDIO_INFO_LOG("AudioServerUnitTest CacheExtraParameters_001 start"); 503 int32_t systemAbilityId = 100; 504 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(systemAbilityId, true); 505 ASSERT_TRUE(audioServer != nullptr); 506 const std::string key = "key-test"; 507 const std::vector<StringPair> kvpairs = { 508 {"key1", "value1"}, 509 {"key2", "value2"} 510 }; 511 EXPECT_FALSE(audioServer->isAudioParameterParsed_.load()); 512 EXPECT_TRUE(audioServer->audioExtraParameterCacheVector_.empty()); 513 audioServer->ParseAudioParameter(); 514 EXPECT_TRUE(audioServer->audioExtraParameterCacheVector_.empty()); 515 } 516 517 } // namespace AudioStandard 518 } //