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 16 #include <gtest/gtest.h> 17 18 #include "audio_service_log.h" 19 #include "audio_errors.h" 20 #include "audio_system_manager.h" 21 #include "audio_workgroup_callback_impl.h" 22 23 using namespace testing::ext; 24 25 namespace OHOS { 26 namespace AudioStandard { 27 28 const int32_t TEST_RET_NUM = 0; 29 const int32_t TEST_RET_MAX_VOLUME = 15; 30 const StreamUsage ILLEGAL_STREAM_USAGE = static_cast<StreamUsage>(static_cast<int32_t>(STREAM_USAGE_MAX)+999); 31 const int32_t TEST_RET_ERROR_NOT_SUPPORTED = ERR_NOT_SUPPORTED; 32 33 class AudioSystemManagerUnitTest : public testing::Test { 34 public: 35 static void SetUpTestCase(void); 36 static void TearDownTestCase(void); 37 void SetUp(); 38 void TearDown(); 39 }; 40 41 class AudioManagerAppVolumeChangeCallbackTest : public AudioManagerAppVolumeChangeCallback { 42 public: OnAppVolumeChangedForUid(int32_t appUid,const VolumeEvent & event)43 void OnAppVolumeChangedForUid(int32_t appUid, const VolumeEvent &event) override {} OnSelfAppVolumeChanged(const VolumeEvent & event)44 void OnSelfAppVolumeChanged(const VolumeEvent &event) override {} 45 }; 46 47 class DataTransferStateChangeCallbackTest : public AudioRendererDataTransferStateChangeCallback { 48 public: OnDataTransferStateChange(const AudioRendererDataTransferStateChangeInfo & info)49 void OnDataTransferStateChange(const AudioRendererDataTransferStateChangeInfo &info) override {} OnMuteStateChange(const int32_t & uid,const uint32_t & sessionId,const bool & isMuted)50 void OnMuteStateChange(const int32_t &uid, const uint32_t &sessionId, const bool &isMuted) override {} 51 }; 52 53 class SystemVolumeChangeCallbackTest : public SystemVolumeChangeCallback { 54 public: OnSystemVolumeChange(VolumeEvent volumeEvent)55 void OnSystemVolumeChange(VolumeEvent volumeEvent) override {} 56 }; 57 58 /** 59 * @tc.name : Test GetMaxVolume API 60 * @tc.type : FUNC 61 * @tc.number: GetMaxVolume_001 62 * @tc.desc : Test GetMaxVolume interface. 63 */ 64 HWTEST(AudioSystemManagerUnitTest, GetMaxVolume_001, TestSize.Level1) 65 { 66 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMaxVolume_001 start"); 67 int32_t result = AudioSystemManager::GetInstance()->GetMaxVolume(STREAM_ALL); 68 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMaxVolume_001 result1:%{public}d", result); 69 EXPECT_GT(TEST_RET_NUM, result); 70 result = AudioSystemManager::GetInstance()->GetMaxVolume(STREAM_ULTRASONIC); 71 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMaxVolume_001 result2:%{public}d", result); 72 EXPECT_GT(TEST_RET_NUM, result); 73 } 74 75 /** 76 * @tc.name : Test GetMinVolume API 77 * @tc.type : FUNC 78 * @tc.number: GetMinVolume_001 79 * @tc.desc : Test GetMinVolume interface. 80 */ 81 HWTEST(AudioSystemManagerUnitTest, GetMinVolume_001, TestSize.Level1) 82 { 83 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMinVolume_001 start"); 84 int32_t result = AudioSystemManager::GetInstance()->GetMinVolume(STREAM_ALL); 85 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMinVolume_001 result1:%{public}d", result); 86 EXPECT_EQ(result, -1); 87 result = AudioSystemManager::GetInstance()->GetMinVolume(STREAM_ULTRASONIC); 88 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMinVolume_001 result2:%{public}d", result); 89 EXPECT_EQ(result, -1); 90 } 91 92 /** 93 * @tc.name : Test GetDeviceMaxVolume API 94 * @tc.type : FUNC 95 * @tc.number: GetDeviceMaxVolume_001 96 * @tc.desc : Test GetDeviceMaxVolume interface. 97 */ 98 HWTEST(AudioSystemManagerUnitTest, GetDeviceMaxVolume_001, TestSize.Level1) 99 { 100 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMaxVolume_001 start"); 101 int32_t result = AudioSystemManager::GetInstance()->GetDeviceMaxVolume(STREAM_ALL, DEVICE_TYPE_NONE); 102 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMaxVolume_001 result1:%{public}d", result); 103 EXPECT_GT(TEST_RET_NUM, result); 104 result = AudioSystemManager::GetInstance()->GetDeviceMaxVolume(STREAM_ULTRASONIC, DEVICE_TYPE_NONE); 105 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMaxVolume_001 result2:%{public}d", result); 106 EXPECT_GT(TEST_RET_NUM, result); 107 result = AudioSystemManager::GetInstance()->GetDeviceMaxVolume(STREAM_MUSIC, DEVICE_TYPE_SPEAKER); 108 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMaxVolume_001 result3:%{public}d", result); 109 EXPECT_GT(TEST_RET_NUM, result); 110 result = AudioSystemManager::GetInstance()->GetDeviceMaxVolume(STREAM_MUSIC, DEVICE_TYPE_BLUETOOTH_A2DP); 111 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMaxVolume_001 result4:%{public}d", result); 112 EXPECT_GT(TEST_RET_NUM, result); 113 } 114 115 /** 116 * @tc.name : Test GetDeviceMaxVolume API 117 * @tc.type : FUNC 118 * @tc.number: GetDeviceMaxVolume_002 119 * @tc.desc : Test GetDeviceMaxVolume interface. 120 */ 121 HWTEST(AudioSystemManagerUnitTest, GetDeviceMaxVolume_002, TestSize.Level1) 122 { 123 int32_t result = AudioSystemManager::GetInstance()->GetDeviceMaxVolume(STREAM_ALL, DEVICE_TYPE_SPEAKER); 124 EXPECT_NE(result, ERR_PERMISSION_DENIED); 125 result = AudioSystemManager::GetInstance()->GetDeviceMaxVolume(STREAM_ULTRASONIC, DEVICE_TYPE_SPEAKER); 126 EXPECT_NE(result, ERR_PERMISSION_DENIED); 127 } 128 129 /** 130 * @tc.name : Test GetDeviceMinVolume API 131 * @tc.type : FUNC 132 * @tc.number: GetDeviceMinVolume_001 133 * @tc.desc : Test GetDeviceMinVolume interface. 134 */ 135 HWTEST(AudioSystemManagerUnitTest, GetDeviceMinVolume_001, TestSize.Level1) 136 { 137 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMinVolume_001 start"); 138 int32_t result = AudioSystemManager::GetInstance()->GetDeviceMinVolume(STREAM_ALL, DEVICE_TYPE_NONE); 139 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMinVolume_001 result1:%{public}d", result); 140 EXPECT_EQ(result, -1); 141 result = AudioSystemManager::GetInstance()->GetDeviceMinVolume(STREAM_ULTRASONIC, DEVICE_TYPE_NONE); 142 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMinVolume_001 result2:%{public}d", result); 143 EXPECT_EQ(result, -1); 144 result = AudioSystemManager::GetInstance()->GetDeviceMinVolume(STREAM_MUSIC, DEVICE_TYPE_SPEAKER); 145 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMinVolume_001 result3:%{public}d", result); 146 EXPECT_EQ(result, -1); 147 result = AudioSystemManager::GetInstance()->GetDeviceMinVolume(STREAM_MUSIC, DEVICE_TYPE_BLUETOOTH_A2DP); 148 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetDeviceMinVolume_001 result4:%{public}d", result); 149 EXPECT_EQ(result, -1); 150 } 151 152 /** 153 * @tc.name : Test GetDeviceMinVolume API 154 * @tc.type : FUNC 155 * @tc.number: GetDeviceMinVolume_002 156 * @tc.desc : Test GetDeviceMinVolume interface. 157 */ 158 HWTEST(AudioSystemManagerUnitTest, GetDeviceMinVolume_002, TestSize.Level1) 159 { 160 int32_t result = AudioSystemManager::GetInstance()->GetDeviceMinVolume(STREAM_ALL, DEVICE_TYPE_NONE); 161 EXPECT_NE(result, ERR_PERMISSION_DENIED); 162 result = AudioSystemManager::GetInstance()->GetDeviceMinVolume(STREAM_ULTRASONIC, DEVICE_TYPE_NONE); 163 EXPECT_NE(result, ERR_PERMISSION_DENIED); 164 } 165 166 /** 167 * @tc.name : Test IsStreamMute API 168 * @tc.type : FUNC 169 * @tc.number: IsStreamMute_001 170 * @tc.desc : Test IsStreamMute interface. 171 */ 172 HWTEST(AudioSystemManagerUnitTest, IsStreamMute_001, TestSize.Level1) 173 { 174 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMute_001 start"); 175 bool result = AudioSystemManager::GetInstance()->IsStreamMute(STREAM_MUSIC); 176 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMute_001 result1:%{public}d", result); 177 EXPECT_EQ(result, false); 178 179 result = AudioSystemManager::GetInstance()->IsStreamMute(STREAM_RING); 180 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMute_001 result2:%{public}d", result); 181 EXPECT_EQ(result, false); 182 183 result = AudioSystemManager::GetInstance()->IsStreamMute(STREAM_NOTIFICATION); 184 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMute_001 result3:%{public}d", result); 185 EXPECT_EQ(result, false); 186 } 187 188 /** 189 * @tc.name : Test IsStreamMute API 190 * @tc.type : FUNC 191 * @tc.number: IsStreamMute_002 192 * @tc.desc : Test IsStreamMute interface. 193 */ 194 HWTEST(AudioSystemManagerUnitTest, IsStreamMute_002, TestSize.Level1) 195 { 196 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMute_002 start"); 197 bool result = AudioSystemManager::GetInstance()->IsStreamMute(STREAM_ALL); 198 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMute_002 result1:%{public}d", result); 199 EXPECT_EQ(result, false); 200 } 201 202 /** 203 * @tc.name : Test IsStreamActive API 204 * @tc.type : FUNC 205 * @tc.number: IsStreamActive_002 206 * @tc.desc : Test IsStreamActive interface. 207 */ 208 HWTEST(AudioSystemManagerUnitTest, IsStreamActive_002, TestSize.Level1) 209 { 210 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamActive_002 start"); 211 bool result = AudioSystemManager::GetInstance()->IsStreamActive(STREAM_MUSIC); 212 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamActive_002 result1:%{public}d", result); 213 EXPECT_EQ(result, false); 214 215 result = AudioSystemManager::GetInstance()->IsStreamActive(STREAM_ULTRASONIC); 216 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamActive_002 result2:%{public}d", result); 217 EXPECT_EQ(result, false); 218 219 result = AudioSystemManager::GetInstance()->IsStreamActive(STREAM_ALL); 220 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamActive_002 result3:%{public}d", result); 221 EXPECT_EQ(result, false); 222 } 223 224 /** 225 * @tc.name : Test GetSelfBundleName API 226 * @tc.type : FUNC 227 * @tc.number: GetSelfBundleName_001 228 * @tc.desc : Test GetSelfBundleName interface. 229 */ 230 HWTEST(AudioSystemManagerUnitTest, GetSelfBundleName_001, TestSize.Level1) 231 { 232 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetSelfBundleName_001 start"); 233 std::string bundleName = AudioSystemManager::GetInstance()->GetSelfBundleName(); 234 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetSelfBundleName_001 bundleName:%{public}s", bundleName.c_str()); 235 EXPECT_EQ(bundleName, ""); 236 } 237 238 /** 239 * @tc.name : Test GetPinValueFromType API 240 * @tc.type : FUNC 241 * @tc.number: GetPinValueFromType_001 242 * @tc.desc : Test GetPinValueFromType interface. 243 */ 244 HWTEST(AudioSystemManagerUnitTest, GetPinValueFromType_001, TestSize.Level1) 245 { 246 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetPinValueFromType_001 start"); 247 AudioPin pinValue = AudioSystemManager::GetInstance()->GetPinValueFromType(DEVICE_TYPE_DP, INPUT_DEVICE); 248 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ->GetPinValueFromType_001() pinValue:%{public}d", pinValue); 249 EXPECT_NE(pinValue, AUDIO_PIN_NONE); 250 } 251 252 /** 253 * @tc.name : Test GetPinValueFromType API 254 * @tc.type : FUNC 255 * @tc.number: GetPinValueFromType_002 256 * @tc.desc : Test GetPinValueFromType interface. 257 */ 258 HWTEST(AudioSystemManagerUnitTest, GetPinValueFromType_002, TestSize.Level1) 259 { 260 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetPinValueFromType_002 start"); 261 AudioPin pinValue = AudioSystemManager::GetInstance()->GetPinValueFromType(DEVICE_TYPE_HDMI, OUTPUT_DEVICE); 262 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ->GetPinValueFromType_002() pinValue:%{public}d", pinValue); 263 EXPECT_NE(pinValue, AUDIO_PIN_NONE); 264 } 265 266 /** 267 * @tc.name : Test RegisterWakeupSourceCallback API 268 * @tc.type : FUNC 269 * @tc.number: RegisterWakeupSourceCallback_001 270 * @tc.desc : Test RegisterWakeupSourceCallback interface. 271 */ 272 HWTEST(AudioSystemManagerUnitTest, RegisterWakeupSourceCallback_001, TestSize.Level1) 273 { 274 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterWakeupSourceCallback_001 start"); 275 int32_t result = AudioSystemManager::GetInstance()->RegisterWakeupSourceCallback(); 276 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ->RegisterWakeupSourceCallback_001() result:%{public}d", result); 277 EXPECT_NE(result, ERROR); 278 } 279 280 /** 281 * @tc.name : Test ConfigDistributedRoutingRole API 282 * @tc.number : ConfigDistributedRoutingRoleTest_001 283 * @tc.desc : Test ConfigDistributedRoutingRole interface, when descriptor is nullptr. 284 */ 285 HWTEST(AudioSystemManagerUnitTest, ConfigDistributedRoutingRoleTest_001, TestSize.Level1) 286 { 287 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ConfigDistributedRoutingRoleTest_001 start"); 288 CastType castType = CAST_TYPE_ALL; 289 int32_t result = AudioSystemManager::GetInstance()->ConfigDistributedRoutingRole(nullptr, castType); 290 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ConfigDistributedRoutingRoleTest_001() result:%{public}d", result); 291 EXPECT_EQ(result, ERR_INVALID_PARAM); 292 } 293 294 #ifdef TEMP_DISABLE 295 /** 296 * @tc.name : Test ExcludeOutputDevices API 297 * @tc.number : ExcludeOutputDevicesTest_001 298 * @tc.desc : Test ExcludeOutputDevices interface, when audioDeviceDescriptors is valid. 299 */ 300 HWTEST(AudioSystemManagerUnitTest, ExcludeOutputDevicesTest_001, TestSize.Level1) 301 { 302 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ExcludeOutputDevicesTest_001 start"); 303 AudioDeviceUsage audioDevUsage = MEDIA_OUTPUT_DEVICES; 304 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors; 305 std::shared_ptr<AudioDeviceDescriptor> audioDevDesc = std::make_shared<AudioDeviceDescriptor>(); 306 audioDevDesc->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; 307 audioDevDesc->networkId_ = LOCAL_NETWORK_ID; 308 audioDevDesc->deviceRole_ = DeviceRole::OUTPUT_DEVICE; 309 audioDevDesc->macAddress_ = "00:00:00:00:00:00"; 310 audioDeviceDescriptors.push_back(audioDevDesc); 311 int32_t result = AudioSystemManager::GetInstance()->ExcludeOutputDevices(audioDevUsage, audioDeviceDescriptors); 312 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ExcludeOutputDevicesTest_001() result:%{public}d", result); 313 EXPECT_EQ(result, SUCCESS); 314 } 315 316 /** 317 * @tc.name : Test ExcludeOutputDevices API 318 * @tc.number : ExcludeOutputDevicesTest_002 319 * @tc.desc : Test ExcludeOutputDevices interface, when audioDeviceDescriptors is valid. 320 */ 321 HWTEST(AudioSystemManagerUnitTest, ExcludeOutputDevicesTest_002, TestSize.Level1) 322 { 323 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ExcludeOutputDevicesTest_002 start"); 324 AudioDeviceUsage audioDevUsage = CALL_OUTPUT_DEVICES; 325 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors; 326 std::shared_ptr<AudioDeviceDescriptor> audioDevDesc = std::make_shared<AudioDeviceDescriptor>(); 327 audioDevDesc->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO; 328 audioDevDesc->networkId_ = LOCAL_NETWORK_ID; 329 audioDevDesc->deviceRole_ = DeviceRole::OUTPUT_DEVICE; 330 audioDevDesc->macAddress_ = "00:00:00:00:00:00"; 331 audioDeviceDescriptors.push_back(audioDevDesc); 332 int32_t result = AudioSystemManager::GetInstance()->ExcludeOutputDevices(audioDevUsage, audioDeviceDescriptors); 333 AUDIO_INFO_LOG("AudioSystemManagerUnitTest ExcludeOutputDevicesTest_001() result:%{public}d", result); 334 EXPECT_EQ(result, SUCCESS); 335 } 336 337 /** 338 * @tc.name : Test UnexcludeOutputDevices API 339 * @tc.number : UnexcludeOutputDevicesTest_001 340 * @tc.desc : Test UnexcludeOutputDevices interface, when audioDeviceDescriptors is valid. 341 */ 342 HWTEST(AudioSystemManagerUnitTest, UnexcludeOutputDevicesTest_001, TestSize.Level1) 343 { 344 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnexcludeOutputDevicesTest_001 start"); 345 AudioDeviceUsage audioDevUsage = MEDIA_OUTPUT_DEVICES; 346 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors; 347 std::shared_ptr<AudioDeviceDescriptor> audioDevDesc = std::make_shared<AudioDeviceDescriptor>(); 348 audioDevDesc->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; 349 audioDevDesc->networkId_ = LOCAL_NETWORK_ID; 350 audioDevDesc->deviceRole_ = DeviceRole::OUTPUT_DEVICE; 351 audioDevDesc->macAddress_ = "00:00:00:00:00:00"; 352 audioDeviceDescriptors.push_back(audioDevDesc); 353 AudioSystemManager::GetInstance()->ExcludeOutputDevices(audioDevUsage, audioDeviceDescriptors); 354 int32_t result = AudioSystemManager::GetInstance()->UnexcludeOutputDevices(audioDevUsage, audioDeviceDescriptors); 355 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnexcludeOutputDevicesTest_001() result:%{public}d", result); 356 EXPECT_EQ(result, SUCCESS); 357 } 358 #endif 359 360 /** 361 * @tc.name : Test UnexcludeOutputDevices API 362 * @tc.number : UnexcludeOutputDevicesTest_002 363 * @tc.desc : Test UnexcludeOutputDevices interface, when audioDeviceDescriptors is empty. 364 */ 365 HWTEST(AudioSystemManagerUnitTest, UnexcludeOutputDevicesTest_002, TestSize.Level1) 366 { 367 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnexcludeOutputDevicesTest_002 start"); 368 AudioDeviceUsage audioDevUsage = CALL_OUTPUT_DEVICES; 369 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors; 370 std::shared_ptr<AudioDeviceDescriptor> audioDevDesc = std::make_shared<AudioDeviceDescriptor>(); 371 audioDevDesc->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO; 372 audioDevDesc->networkId_ = LOCAL_NETWORK_ID; 373 audioDevDesc->deviceRole_ = DeviceRole::OUTPUT_DEVICE; 374 audioDevDesc->macAddress_ = "00:00:00:00:00:00"; 375 audioDeviceDescriptors.push_back(audioDevDesc); 376 AudioSystemManager::GetInstance()->ExcludeOutputDevices(audioDevUsage, audioDeviceDescriptors); 377 int32_t result = AudioSystemManager::GetInstance()->UnexcludeOutputDevices(audioDevUsage); 378 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnexcludeOutputDevicesTest_002() result:%{public}d", result); 379 EXPECT_EQ(result, SUCCESS); 380 } 381 382 /** 383 * @tc.name : Test GetExcludedDevices API 384 * @tc.number : GetExcludedDevicesTest_001 385 * @tc.desc : Test GetExcludedDevices interface. 386 */ 387 HWTEST(AudioSystemManagerUnitTest, GetExcludedDevicesTest_001, TestSize.Level1) 388 { 389 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetExcludedDevicesTest_001 start"); 390 AudioDeviceUsage audioDevUsage = MEDIA_OUTPUT_DEVICES; 391 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors = 392 AudioSystemManager::GetInstance()->GetExcludedDevices(audioDevUsage); 393 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetExcludedDevicesTest_001() audioDeviceDescriptors.size:%{public}zu", 394 audioDeviceDescriptors.size()); 395 EXPECT_EQ(audioDeviceDescriptors.size(), 0); 396 } 397 398 /** 399 * @tc.name : Test GetExcludedDevices API 400 * @tc.number : GetExcludedDevicesTest_002 401 * @tc.desc : Test GetExcludedDevices interface. 402 */ 403 HWTEST(AudioSystemManagerUnitTest, GetExcludedDevicesTest_002, TestSize.Level1) 404 { 405 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetExcludedDevicesTest_002 start"); 406 AudioDeviceUsage audioDevUsage = CALL_OUTPUT_DEVICES; 407 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors = 408 AudioSystemManager::GetInstance()->GetExcludedDevices(audioDevUsage); 409 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetExcludedDevicesTest_002() audioDeviceDescriptors.size:%{public}zu", 410 audioDeviceDescriptors.size()); 411 EXPECT_EQ(audioDeviceDescriptors.size(), 0); 412 } 413 414 /** 415 * @tc.name : Test SetSelfAppVolume API 416 * @tc.number : SetAppVolume_001 417 * @tc.desc : Test SetSelfAppVolume interface 418 */ 419 HWTEST(AudioSystemManagerUnitTest, SetSelfAppVolume_001, TestSize.Level1) 420 { 421 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolume_001 start"); 422 int volume = 10; 423 int32_t result = AudioSystemManager::GetInstance()->SetSelfAppVolume(volume); 424 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolume_001 end result:%{public}d", result); 425 EXPECT_EQ(result, -1); 426 } 427 428 /** 429 * @tc.name : Test SetSelfAppVolume API 430 * @tc.number : SetAppVolume_002 431 * @tc.desc : Test SetSelfAppVolume interface 432 */ 433 HWTEST(AudioSystemManagerUnitTest, SetSelfAppVolume_002, TestSize.Level1) 434 { 435 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolume_002 start"); 436 int volume = 1000; 437 int32_t result = AudioSystemManager::GetInstance()->SetSelfAppVolume(volume); 438 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolume_002 end result:%{public}d", result); 439 EXPECT_NE(result, TEST_RET_NUM); 440 } 441 442 #ifdef TEMP_DISABLE 443 /** 444 * @tc.name : Test SetAppVolume API 445 * @tc.number : SetAppVolume_001 446 * @tc.desc : Test SetSelfAppVolume interface 447 */ 448 HWTEST(AudioSystemManagerUnitTest, SetAppVolume_001, TestSize.Level1) 449 { 450 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolume_001 start"); 451 int32_t appUid = 30003000; 452 int32_t volume = 10; 453 int32_t result = AudioSystemManager::GetInstance()->SetAppVolume(appUid, volume); 454 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolume_001 end result:%{public}d", result); 455 EXPECT_EQ(result, TEST_RET_NUM); 456 } 457 458 /** 459 * @tc.name : Test SetAppVolume API 460 * @tc.number : SetAppVolume_002 461 * @tc.desc : Test SetSelfAppVolume interface 462 */ 463 HWTEST(AudioSystemManagerUnitTest, SetAppVolume_002, TestSize.Level1) 464 { 465 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolume_002 start"); 466 int32_t appUid = 30003000; 467 int32_t volume = 1000; 468 int32_t result = AudioSystemManager::GetInstance()->SetAppVolume(appUid, volume); 469 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolume_002 end result:%{public}d", result); 470 EXPECT_NE(result, TEST_RET_NUM); 471 } 472 #endif 473 474 /** 475 * @tc.name : Test GetSelfAppVolume API 476 * @tc.number : GetSelfAppVolume_001 477 * @tc.desc : Test GetSelfAppVolume interface 478 */ 479 HWTEST(AudioSystemManagerUnitTest, GetSelfAppVolume_001, TestSize.Level1) 480 { 481 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetSelfAppVolume_001 start"); 482 int volume = 10; 483 int32_t result = AudioSystemManager::GetInstance()->SetSelfAppVolume(volume); 484 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolume end result:%{public}d", result); 485 EXPECT_EQ(result, -1); 486 result = AudioSystemManager::GetInstance()->GetSelfAppVolume(volume); 487 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetSelfAppVolume_001 end result:%{public}d", result); 488 EXPECT_EQ(result, -1); 489 } 490 491 #ifdef TEMP_DISABLE 492 /** 493 * @tc.name : Test GetAppVolume API 494 * @tc.number : GetAppVolume_001 495 * @tc.desc : Test GetAppVolume_001 interface 496 */ 497 HWTEST(AudioSystemManagerUnitTest, GetAppVolume_001, TestSize.Level1) 498 { 499 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetAppVolume_001 start"); 500 int32_t appUid = 30003000; 501 int volume = 10; 502 int result = AudioSystemManager::GetInstance()->SetAppVolume(appUid, volume); 503 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolume end result:%{public}d", result); 504 EXPECT_EQ(result, TEST_RET_NUM); 505 result = AudioSystemManager::GetInstance()->GetAppVolume(appUid, volume); 506 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetAppVolume_001 end result:%{public}d", result); 507 EXPECT_EQ(result, TEST_RET_NUM); 508 } 509 510 /** 511 * @tc.name : Test GetAppVolume API 512 * @tc.number : GetAppVolume_002 513 * @tc.desc : Test GetAppVolume_002 interface 514 */ 515 HWTEST(AudioSystemManagerUnitTest, GetAppVolume_002, TestSize.Level1) 516 { 517 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetAppVolume_002 start"); 518 int32_t appUid = 40004000; 519 int volume = 0; 520 int32_t result = AudioSystemManager::GetInstance()->GetAppVolume(appUid, volume); 521 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetAppVolume_002 end result:%{public}d", result); 522 EXPECT_EQ(result, TEST_RET_NUM); 523 } 524 525 /** 526 * @tc.name : Test SetAppVolumeMuted API 527 * @tc.number : SetAppVolumeMuted_001 528 * @tc.desc : Test SetAppVolumeMuted interface 529 */ 530 HWTEST(AudioSystemManagerUnitTest, SetAppVolumeMuted_001, TestSize.Level1) 531 { 532 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeMuted_001 start"); 533 int appUid = 30003000; 534 bool mute = true; 535 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeMuted(appUid, mute); 536 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeMuted_001 end result:%{public}d", result); 537 EXPECT_EQ(result, TEST_RET_NUM); 538 } 539 540 /** 541 * @tc.name : Test SetAppVolumeMuted API 542 * @tc.number : SetAppVolumeMuted_002 543 * @tc.desc : Test SetAppVolumeMuted interface 544 */ 545 HWTEST(AudioSystemManagerUnitTest, SetAppVolumeMuted_002, TestSize.Level1) 546 { 547 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeMuted_002 start"); 548 int appUid = 30003000; 549 bool mute = true; 550 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeMuted(appUid, mute); 551 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeMuted_002 end result:%{public}d", result); 552 EXPECT_EQ(result, TEST_RET_NUM); 553 mute = false; 554 result = AudioSystemManager::GetInstance()->SetAppVolumeMuted(appUid, mute); 555 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeMuted_002 end result2:%{public}d", result); 556 EXPECT_EQ(result, TEST_RET_NUM); 557 } 558 559 /** 560 * @tc.name : Test IsAppVolumeMuted API 561 * @tc.number : IsAppVolumeMuted_001 562 * @tc.desc : Test IsAppVolumeMuted interface 563 */ 564 HWTEST(AudioSystemManagerUnitTest, IsAppVolumeMuted_001, TestSize.Level1) 565 { 566 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsAppVolumeMuted_001 start"); 567 int32_t appUid = 30003000; 568 bool owned = true; 569 bool mute = true; 570 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeMuted(appUid, mute); 571 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeMuted end result:%{public}d", result); 572 EXPECT_EQ(result, TEST_RET_NUM); 573 result = AudioSystemManager::GetInstance()->IsAppVolumeMute(appUid, owned, mute); 574 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsAppVolumeMuted_001 end result:%{public}d", result); 575 576 result = AudioSystemManager::GetInstance()->IsAppVolumeMute(appUid + 1, owned, mute); 577 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsAppVolumeMuted_001 end result2:%{public}d", result); 578 EXPECT_EQ(mute, false); 579 } 580 581 /** 582 * @tc.name : Test IsAppVolumeMuted API 583 * @tc.number : IsAppVolumeMuted_002 584 * @tc.desc : Test IsAppVolumeMuted interface 585 */ 586 HWTEST(AudioSystemManagerUnitTest, IsAppVolumeMuted_002, TestSize.Level1) 587 { 588 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsAppVolumeMuted_002 start"); 589 int32_t appUid = 30003000; 590 bool owned = false; 591 bool mute = true; 592 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeMuted(appUid, mute); 593 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeMuted end result:%{public}d", result); 594 EXPECT_EQ(result, TEST_RET_NUM); 595 result = AudioSystemManager::GetInstance()->IsAppVolumeMute(appUid, owned, mute); 596 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsAppVolumeMuted_002 end result:%{public}d", result); 597 598 result = AudioSystemManager::GetInstance()->IsAppVolumeMute(appUid + 1, owned, mute); 599 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsAppVolumeMuted_002 end result2:%{public}d", result); 600 EXPECT_EQ(mute, false); 601 } 602 #endif 603 604 /** 605 * @tc.name : Test SetNearlinkDeviceVolume API 606 * @tc.number : SetNearlinkDeviceVolume_001 607 * @tc.desc : Test SetNearlinkDeviceVolume interface createAudioWorkgroup 608 */ 609 HWTEST(AudioSystemManagerUnitTest, SetNearlinkDeviceVolume_001, TestSize.Level1) 610 { 611 AudioSystemManager audioSystemManager; 612 std::string macAddress = "LocalDevice"; 613 AudioVolumeType volumeType = STREAM_MUSIC; 614 int32_t volume = 0; 615 bool updateUi = true; 616 617 int32_t result = audioSystemManager.SetNearlinkDeviceVolume(macAddress, volumeType, volume, updateUi); 618 EXPECT_NE(result, -2); 619 } 620 621 /** 622 * @tc.name : Test SetSelfAppVolumeCallback API 623 * @tc.number : SetSelfAppVolumeCallback_001 624 * @tc.desc : Test SetSelfAppVolumeCallback interface 625 */ 626 HWTEST(AudioSystemManagerUnitTest, SetSelfAppVolumeCallback_001, TestSize.Level1) 627 { 628 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback_001 start"); 629 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback = nullptr; 630 int32_t result = AudioSystemManager::GetInstance()->SetSelfAppVolumeCallback(callback); 631 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback end result:%{public}d", result); 632 EXPECT_NE(result, TEST_RET_NUM); 633 result = AudioSystemManager::GetInstance()->UnsetSelfAppVolumeCallback(callback); 634 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetAppVolumeCallback end result:%{public}d", result); 635 EXPECT_NE(result, TEST_RET_NUM); 636 } 637 638 /** 639 * @tc.name : Test SetSelfAppVolumeCallback API 640 * @tc.number : SetSelfAppVolumeCallback_002 641 * @tc.desc : Test SetSelfAppVolumeCallback interface 642 */ 643 HWTEST(AudioSystemManagerUnitTest, SetSelfAppVolumeCallback_002, TestSize.Level1) 644 { 645 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback_002 start"); 646 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback = 647 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 648 int32_t result = AudioSystemManager::GetInstance()->SetSelfAppVolumeCallback(callback); 649 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback1 end result:%{public}d", result); 650 EXPECT_NE(result, TEST_RET_NUM); 651 result = AudioSystemManager::GetInstance()->SetSelfAppVolumeCallback(callback); 652 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback2 end result:%{public}d", result); 653 EXPECT_NE(result, TEST_RET_NUM); 654 result = AudioSystemManager::GetInstance()->UnsetSelfAppVolumeCallback(callback); 655 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetSelfAppVolumeCallback end result:%{public}d", result); 656 EXPECT_NE(result, TEST_RET_NUM); 657 } 658 659 /** 660 * @tc.name : Test SetSelfAppVolumeCallback API 661 * @tc.number : SetSelfAppVolumeCallback_003 662 * @tc.desc : Test SetSelfAppVolumeCallback interface 663 */ 664 HWTEST(AudioSystemManagerUnitTest, SetSelfAppVolumeCallback_003, TestSize.Level1) 665 { 666 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback_003 start"); 667 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback1 = 668 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 669 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback2 = 670 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 671 int32_t result = AudioSystemManager::GetInstance()->SetSelfAppVolumeCallback(callback1); 672 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback1 end result:%{public}d", result); 673 EXPECT_NE(result, TEST_RET_NUM); 674 result = AudioSystemManager::GetInstance()->SetSelfAppVolumeCallback(callback2); 675 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback2 end result:%{public}d", result); 676 EXPECT_NE(result, TEST_RET_NUM); 677 result = AudioSystemManager::GetInstance()->UnsetSelfAppVolumeCallback(callback2); 678 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetSelfAppVolumeCallback end result:%{public}d", result); 679 EXPECT_NE(result, TEST_RET_NUM); 680 } 681 682 /** 683 * @tc.name : Test SetSelfAppVolumeCallback API 684 * @tc.number : SetSelfAppVolumeCallback_004 685 * @tc.desc : Test SetSelfAppVolumeCallback interface 686 */ 687 HWTEST(AudioSystemManagerUnitTest, SetSelfAppVolumeCallback_004, TestSize.Level1) 688 { 689 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback_004 start"); 690 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback = 691 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 692 int32_t result = AudioSystemManager::GetInstance()->SetSelfAppVolumeCallback(callback); 693 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback1 end result:%{public}d", result); 694 EXPECT_NE(result, TEST_RET_NUM); 695 result = AudioSystemManager::GetInstance()->UnsetSelfAppVolumeCallback(callback); 696 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetSelfAppVolumeCallback end result:%{public}d", result); 697 EXPECT_NE(result, TEST_RET_NUM); 698 } 699 700 /** 701 * @tc.name : Test SetSelfAppVolumeCallback API 702 * @tc.number : SetSelfAppVolumeCallback_005 703 * @tc.desc : Test SetSelfAppVolumeCallback interface 704 */ 705 HWTEST(AudioSystemManagerUnitTest, SetSelfAppVolumeCallback_005, TestSize.Level1) 706 { 707 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback_005 start"); 708 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback = 709 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 710 int32_t result = AudioSystemManager::GetInstance()->SetSelfAppVolumeCallback(callback); 711 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetSelfAppVolumeCallback1 end result:%{public}d", result); 712 EXPECT_NE(result, TEST_RET_NUM); 713 result = AudioSystemManager::GetInstance()->UnsetSelfAppVolumeCallback(nullptr); 714 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetSelfAppVolumeCallback end result:%{public}d", result); 715 EXPECT_NE(result, TEST_RET_NUM); 716 } 717 718 /** 719 * @tc.name : Test SetAppVolumeCallbackForUid API 720 * @tc.number : SetAppVolumeCallbackForUid_001 721 * @tc.desc : Test SetAppVolumeCallbackForUid interface 722 */ 723 HWTEST(AudioSystemManagerUnitTest, SetAppVolumeCallbackForUid_001, TestSize.Level1) 724 { 725 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_001 start"); 726 int32_t appUid = 30003000; 727 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback = nullptr; 728 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeCallbackForUid(appUid, callback); 729 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_001 end result:%{public}d", result); 730 EXPECT_NE(result, TEST_RET_NUM); 731 } 732 733 /** 734 * @tc.name : Test StartGroup API 735 * @tc.number : StartGroup_001 736 * @tc.desc : Test StartGroup interface when startTime > endTime. 737 */ 738 HWTEST(AudioSystemManagerUnitTest, StartGroup_001, TestSize.Level1) 739 { 740 AudioSystemManager manager; 741 bool needUpdatePrio = true; 742 int32_t testWorkgroupid = 1; 743 int32_t startTimeMs = 1000; 744 int32_t endTimeMs = 500; 745 std::unordered_map<int32_t, bool> threads = { 746 {101, true}, 747 {102, true} 748 }; 749 int32_t result = manager.StartGroup(testWorkgroupid, startTimeMs, endTimeMs, threads, needUpdatePrio); 750 EXPECT_EQ(result, AUDIO_ERR); 751 } 752 753 /** 754 * @tc.name : Test GetVolumeInUnitOfDb API 755 * @tc.number: GetVolumeInUnitOfDb_001 756 * @tc.tesc : Test GetVolumeInUnitOfDb interface 757 */ 758 HWTEST(AudioSystemManagerUnitTest, GetVolumeInUnitOfDb_001, TestSize.Level1) 759 { 760 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeInUnitOfDb_001 start"); 761 AudioSystemManager manager; 762 int32_t volLevel = 5; 763 float result = manager.GetVolumeInUnitOfDb(AudioVolumeType::STREAM_MUSIC, 764 volLevel, 765 DeviceType::DEVICE_TYPE_SPEAKER); 766 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeInUnitOfDb_001 result1:%{public}f", result); 767 EXPECT_GE(TEST_RET_NUM, result); 768 } 769 770 /** 771 * @tc.name : Test GetMaxVolumeByUsage API 772 * @tc.number: GetMaxVolumeByUsage_001 773 * @tc.tesc : Test GetMaxVolumeByUsage interface 774 */ 775 HWTEST(AudioSystemManagerUnitTest, GetMaxVolumeByUsage_001, TestSize.Level1) 776 { 777 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMaxVolumeByUsage_001 start"); 778 AudioSystemManager manager; 779 int32_t result = manager.GetMaxVolumeByUsage(StreamUsage::STREAM_USAGE_MUSIC); 780 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMaxVolumeByUsage_001 result1:%{public}d", result); 781 EXPECT_GE(TEST_RET_NUM, result); 782 EXPECT_LE(result, TEST_RET_MAX_VOLUME); 783 result = manager.GetMaxVolumeByUsage(StreamUsage::STREAM_USAGE_ULTRASONIC); 784 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMaxVolumeByUsage_001 result2:%{public}d", result); 785 EXPECT_GE(TEST_RET_NUM, result); 786 EXPECT_LE(result, TEST_RET_MAX_VOLUME); 787 result = manager.GetMaxVolumeByUsage(ILLEGAL_STREAM_USAGE); 788 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMaxVolumeByUsage_001 result3:%{public}d", result); 789 EXPECT_EQ(result, TEST_RET_ERROR_NOT_SUPPORTED); 790 } 791 792 /** 793 * @tc.name : Test GetMinVolumeByUsage API 794 * @tc.number: GetMinVolumeByUsage_001 795 * @tc.tesc : Test GetMinVolumeByUsage interface 796 */ 797 HWTEST(AudioSystemManagerUnitTest, GetMinVolumeByUsage_001, TestSize.Level1) 798 { 799 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMinVolumeByUsage_001 start"); 800 AudioSystemManager manager; 801 int32_t result = manager.GetMinVolumeByUsage(StreamUsage::STREAM_USAGE_MUSIC); 802 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMinVolumeByUsage_001 result1:%{public}d", result); 803 EXPECT_GE(TEST_RET_NUM, result); 804 EXPECT_LE(result, TEST_RET_MAX_VOLUME); 805 result = manager.GetMinVolumeByUsage(StreamUsage::STREAM_USAGE_ULTRASONIC); 806 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMinVolumeByUsage_001 result2:%{public}d", result); 807 EXPECT_GE(TEST_RET_NUM, result); 808 EXPECT_LE(result, TEST_RET_MAX_VOLUME); 809 result = manager.GetMinVolumeByUsage(ILLEGAL_STREAM_USAGE); 810 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetMinVolumeByUsage_001 result3:%{public}d", result); 811 EXPECT_EQ(result, TEST_RET_ERROR_NOT_SUPPORTED); 812 } 813 814 /** 815 * @tc.name : Test GetVolumeByUsage API 816 * @tc.number: GetVolumeByUsage_001 817 * @tc.tesc : Test GetVolumeByUsage interface 818 */ 819 HWTEST(AudioSystemManagerUnitTest, GetVolumeByUsage_001, TestSize.Level1) 820 { 821 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeByUsage_001 start"); 822 AudioSystemManager manager; 823 int32_t result = manager.GetVolumeByUsage(StreamUsage::STREAM_USAGE_MUSIC); 824 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeByUsage_001 result1:%{public}d", result); 825 EXPECT_GE(TEST_RET_NUM, result); 826 EXPECT_LE(result, TEST_RET_MAX_VOLUME); 827 result = manager.GetVolumeByUsage(StreamUsage::STREAM_USAGE_ULTRASONIC); 828 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeByUsage_001 result2:%{public}d", result); 829 EXPECT_GE(TEST_RET_NUM, result); 830 EXPECT_LE(result, TEST_RET_MAX_VOLUME); 831 result = manager.GetVolumeByUsage(ILLEGAL_STREAM_USAGE); 832 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeByUsage_001 result3:%{public}d", result); 833 EXPECT_EQ(result, TEST_RET_ERROR_NOT_SUPPORTED); 834 } 835 836 /** 837 * @tc.name : Test IsStreamMuteByUsage API 838 * @tc.number: IsStreamMuteByUsage_001 839 * @tc.tesc : Test IsStreamMuteByUsage interface 840 */ 841 HWTEST(AudioSystemManagerUnitTest, IsStreamMuteByUsage_001, TestSize.Level1) 842 { 843 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMuteByUsage_001 start"); 844 AudioSystemManager manager; 845 bool isMuted = false; 846 int32_t result = manager.IsStreamMuteByUsage(StreamUsage::STREAM_USAGE_MUSIC, isMuted); 847 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMuteByUsage_001 result1:%{public}d", result); 848 EXPECT_EQ(result, SUCCESS); 849 result = manager.IsStreamMuteByUsage(StreamUsage::STREAM_USAGE_ULTRASONIC, isMuted); 850 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMuteByUsage_001 result2:%{public}d", result); 851 EXPECT_EQ(result, SUCCESS); 852 result = manager.IsStreamMuteByUsage(ILLEGAL_STREAM_USAGE, isMuted); 853 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsStreamMuteByUsage_001 result3:%{public}d", result); 854 EXPECT_EQ(result, TEST_RET_ERROR_NOT_SUPPORTED); 855 } 856 857 /** 858 * @tc.name : Test GetVolumeInDbByStream API 859 * @tc.number: GetVolumeInDbByStream_001 860 * @tc.tesc : Test GetVolumeInDbByStream interface 861 */ 862 HWTEST(AudioSystemManagerUnitTest, GetVolumeInDbByStream_001, TestSize.Level1) 863 { 864 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeInDbByStream_001 start"); 865 AudioSystemManager manager; 866 int32_t volLevel = 5; 867 float result = manager.GetVolumeInDbByStream(StreamUsage::STREAM_USAGE_MUSIC, 868 volLevel, 869 DeviceType::DEVICE_TYPE_SPEAKER); 870 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeInDbByStream_001 result1:%{public}f", result); 871 EXPECT_GE(TEST_RET_NUM, result); 872 result = manager.GetVolumeInDbByStream(StreamUsage::STREAM_USAGE_ULTRASONIC, 873 volLevel, 874 DeviceType::DEVICE_TYPE_SPEAKER); 875 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeInDbByStream_001 result2:%{public}f", result); 876 EXPECT_GE(TEST_RET_NUM, result); 877 result = manager.GetVolumeInDbByStream(ILLEGAL_STREAM_USAGE, 878 volLevel, 879 DeviceType::DEVICE_TYPE_SPEAKER); 880 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolumeInDbByStream_001 result3:%{public}f", result); 881 EXPECT_EQ(result, TEST_RET_ERROR_NOT_SUPPORTED); 882 } 883 884 /** 885 * @tc.name : Test GetSupportedAudioVolumeTypes API 886 * @tc.number: GetSupportedAudioVolumeTypes_001 887 * @tc.tesc : Test GetSupportedAudioVolumeTypes interface 888 */ 889 HWTEST(AudioSystemManagerUnitTest, GetSupportedAudioVolumeTypes_001, TestSize.Level1) 890 { 891 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetSupportedAudioVolumeTypes_001 start"); 892 AudioSystemManager manager; 893 std::vector<AudioVolumeType> result = manager.GetSupportedAudioVolumeTypes(); 894 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetSupportedAudioVolumeTypes_001 result size1:%{public}zu", 895 result.size()); 896 EXPECT_GE(result.size(), TEST_RET_NUM); 897 } 898 899 /** 900 * @tc.name : Test GetAudioVolumeTypeByStreamUsage API 901 * @tc.number: GetAudioVolumeTypeByStreamUsage_001 902 * @tc.tesc : Test GetAudioVolumeTypeByStreamUsage interface 903 */ 904 HWTEST(AudioSystemManagerUnitTest, GetAudioVolumeTypeByStreamUsage_001, TestSize.Level1) 905 { 906 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetAudioVolumeTypeByStreamUsage_001 start"); 907 AudioSystemManager manager; 908 AudioVolumeType result = manager.GetAudioVolumeTypeByStreamUsage(StreamUsage::STREAM_USAGE_MUSIC); 909 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetAudioVolumeTypeByStreamUsage_001 result1:%{public}d", result); 910 EXPECT_GE(result, AudioVolumeType::STREAM_DEFAULT); 911 EXPECT_LE(result, AudioVolumeType::STREAM_ALL); 912 } 913 914 /** 915 * @tc.name : Test GetStreamUsagesByVolumeType API 916 * @tc.number: GetStreamUsagesByVolumeType_001 917 * @tc.tesc : Test GetStreamUsagesByVolumeType interface 918 */ 919 HWTEST(AudioSystemManagerUnitTest, GetStreamUsagesByVolumeType_001, TestSize.Level1) 920 { 921 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetStreamUsagesByVolumeType_001 start"); 922 AudioSystemManager manager; 923 std::vector<StreamUsage> result = manager.GetStreamUsagesByVolumeType(AudioVolumeType::STREAM_MUSIC); 924 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetStreamUsagesByVolumeType_001 result size1:%{public}zu", 925 result.size()); 926 EXPECT_GE(result.size(), TEST_RET_NUM); 927 } 928 929 /** 930 * @tc.name : Test RegisterSystemVolumeChnageCallback API 931 * @tc.number: RegisterSystemVolumeChnageCallback_001 932 * @tc.tesc : Test RegisterSystemVolumeChnageCallback interface 933 */ 934 HWTEST(AudioSystemManagerUnitTest, RegisterSystemVolumeChnageCallback_001, TestSize.Level1) 935 { 936 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterSystemVolumeChnageCallback_001 start"); 937 int32_t testClientId = 300300; 938 std::shared_ptr<SystemVolumeChangeCallback> callback = std::make_shared< 939 SystemVolumeChangeCallbackTest>(); 940 AudioSystemManager manager; 941 int32_t result = manager.RegisterSystemVolumeChangeCallback(testClientId, callback); 942 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterSystemVolumeChnageCallback_001 result1:%{public}d", result); 943 EXPECT_NE(result, SUCCESS); 944 result = manager.UnregisterSystemVolumeChangeCallback(testClientId, callback); 945 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterSystemVolumeChnageCallback_001 result2:%{public}d", result); 946 EXPECT_EQ(result, SUCCESS); 947 result = manager.RegisterSystemVolumeChangeCallback(testClientId, nullptr); 948 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterSystemVolumeChnageCallback_001 result3:%{public}d", result); 949 EXPECT_EQ(result, ERR_INVALID_PARAM); 950 } 951 952 #ifdef TEMP_DISABLE 953 /** 954 * @tc.name : Test SetAppVolumeCallbackForUid API 955 * @tc.number : SetAppVolumeCallbackForUid_002 956 * @tc.desc : Test SetAppVolumeCallbackForUid interface 957 */ 958 HWTEST(AudioSystemManagerUnitTest, SetAppVolumeCallbackForUid_002, TestSize.Level1) 959 { 960 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_002 start"); 961 int32_t appUid = 30003000; 962 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback = 963 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 964 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeCallbackForUid(appUid, callback); 965 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_002 end result:%{public}d", result); 966 EXPECT_EQ(result, TEST_RET_NUM); 967 result = AudioSystemManager::GetInstance()->SetAppVolumeCallbackForUid(appUid, callback); 968 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_002 end result2:%{public}d", result); 969 EXPECT_EQ(result, TEST_RET_NUM); 970 result = AudioSystemManager::GetInstance()->UnsetAppVolumeCallbackForUid(callback); 971 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetAppVolumeCallbackForUid end result:%{public}d", result); 972 EXPECT_EQ(result, TEST_RET_NUM); 973 } 974 975 /** 976 * @tc.name : Test SetAppVolumeCallbackForUid API 977 * @tc.number : SetAppVolumeCallbackForUid_003 978 * @tc.desc : Test SetAppVolumeCallbackForUid interface 979 */ 980 HWTEST(AudioSystemManagerUnitTest, SetAppVolumeCallbackForUid_003, TestSize.Level1) 981 { 982 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_003 start"); 983 int32_t appUid = 30003000; 984 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback1 = 985 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 986 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback2 = 987 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 988 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeCallbackForUid(appUid, callback1); 989 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_003 end result:%{public}d", result); 990 EXPECT_EQ(result, TEST_RET_NUM); 991 result = AudioSystemManager::GetInstance()->SetAppVolumeCallbackForUid(appUid, callback2); 992 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_003 end result2:%{public}d", result); 993 EXPECT_EQ(result, TEST_RET_NUM); 994 result = AudioSystemManager::GetInstance()->UnsetAppVolumeCallbackForUid(callback2); 995 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetAppVolumeCallbackForUid end result:%{public}d", result); 996 EXPECT_EQ(result, TEST_RET_NUM); 997 } 998 999 /** 1000 * @tc.name : Test SetAppVolumeCallbackForUid API 1001 * @tc.number : SetAppVolumeCallbackForUid_004 1002 * @tc.desc : Test SetAppVolumeCallbackForUid interface 1003 */ 1004 HWTEST(AudioSystemManagerUnitTest, SetAppVolumeCallbackForUid_004, TestSize.Level1) 1005 { 1006 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_004 start"); 1007 int32_t appUid = 30003000; 1008 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback = 1009 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 1010 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeCallbackForUid(appUid, callback); 1011 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_004 end result:%{public}d", result); 1012 EXPECT_EQ(result, TEST_RET_NUM); 1013 result = AudioSystemManager::GetInstance()->UnsetAppVolumeCallbackForUid(callback); 1014 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetAppVolumeCallbackForUid end result:%{public}d", result); 1015 EXPECT_EQ(result, TEST_RET_NUM); 1016 } 1017 1018 /** 1019 * @tc.name : Test SetAppVolumeCallbackForUid API 1020 * @tc.number : SetAppVolumeCallbackForUid_005 1021 * @tc.desc : Test SetAppVolumeCallbackForUid interface 1022 */ 1023 HWTEST(AudioSystemManagerUnitTest, SetAppVolumeCallbackForUid_005, TestSize.Level1) 1024 { 1025 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_005 start"); 1026 int32_t appUid = 30003000; 1027 std::shared_ptr<AudioManagerAppVolumeChangeCallback> callback = 1028 std::make_shared<AudioManagerAppVolumeChangeCallbackTest>(); 1029 int32_t result = AudioSystemManager::GetInstance()->SetAppVolumeCallbackForUid(appUid, callback); 1030 AUDIO_INFO_LOG("AudioSystemManagerUnitTest SetAppVolumeCallbackForUid_005 end result:%{public}d", result); 1031 EXPECT_EQ(result, TEST_RET_NUM); 1032 result = AudioSystemManager::GetInstance()->UnsetAppVolumeCallbackForUid(nullptr); 1033 AUDIO_INFO_LOG("AudioSystemManagerUnitTest UnsetAppVolumeCallbackForUid end result:%{public}d", result); 1034 EXPECT_EQ(result, TEST_RET_NUM); 1035 } 1036 1037 /** 1038 * @tc.name : Test RegisterRendererDataTransfer API 1039 * @tc.number : RegisterRendererDataTransfer_001 1040 * @tc.desc : Test RegisterRendererDataTransfer interface 1041 */ 1042 HWTEST(AudioSystemManagerUnitTest, RegisterRendererDataTransfer_001, TestSize.Level1) 1043 { 1044 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterRendererDataTransfer_001 start"); 1045 std::shared_ptr<AudioRendererDataTransferStateChangeCallback> callback = 1046 std::make_shared<DataTransferStateChangeCallbackTest>(); 1047 DataTransferMonitorParam param1; 1048 int32_t result = AudioSystemManager::GetInstance()->RegisterRendererDataTransferCallback(param1, callback); 1049 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterRendererDataTransfer_001 end result:%{public}d", result); 1050 EXPECT_EQ(result, SUCCESS); 1051 1052 DataTransferMonitorParam param2; 1053 result = AudioSystemManager::GetInstance()->RegisterRendererDataTransferCallback(param2, callback); 1054 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterRendererDataTransfer_001 end result:%{public}d", result); 1055 EXPECT_EQ(result, SUCCESS); 1056 1057 result = AudioSystemManager::GetInstance()->UnregisterRendererDataTransferCallback(callback); 1058 AUDIO_INFO_LOG("AudioSystemManagerUnitTest RegisterRendererDataTransfer_001 end result:%{public}d", result); 1059 EXPECT_EQ(result, SUCCESS); 1060 } 1061 #endif 1062 1063 /** 1064 * @tc.name : Test CreateGroup API 1065 * @tc.number : CreateGroup_001 1066 * @tc.desc : Test CreateGroup interface createAudioWorkgroup 1067 */ 1068 HWTEST(AudioSystemManagerUnitTest, CreateGroup_001, TestSize.Level1) 1069 { 1070 AudioSystemManager audioSystemManager; 1071 1072 int32_t result = audioSystemManager.CreateAudioWorkgroup(); 1073 EXPECT_EQ(0, result); 1074 } 1075 /** 1076 * @tc.name : Test GetVolumeInDbByStream API 1077 * @tc.number : GetVolumeInDbByStream 1078 * @tc.desc : Test GetVolumeInDbByStream interface createAudioWorkgroup 1079 */ 1080 HWTEST(AudioSystemManagerUnitTest, GetVolumeInDbByStream_002, TestSize.Level1) 1081 { 1082 StreamUsage streamUsage = STREAM_USAGE_MUSIC; 1083 int32_t volumeLevel = 50; 1084 DeviceType deviceType = DEVICE_TYPE_SPEAKER; 1085 1086 AudioSystemManager audioSystemManager; 1087 float result = audioSystemManager.GetVolumeInDbByStream(streamUsage, volumeLevel, deviceType); 1088 float errNotSupportedFloat = static_cast<float>(ERR_NOT_SUPPORTED); 1089 float errPermissionDeniedFloat = static_cast<float>(ERR_PERMISSION_DENIED); 1090 1091 EXPECT_TRUE(result != errNotSupportedFloat && result != errPermissionDeniedFloat); 1092 1093 streamUsage = static_cast<StreamUsage>(1000); 1094 result = audioSystemManager.GetVolumeInDbByStream(streamUsage, volumeLevel, deviceType); 1095 EXPECT_EQ(result, ERR_NOT_SUPPORTED); 1096 1097 streamUsage = STREAM_USAGE_SYSTEM; 1098 result = audioSystemManager.GetVolumeInDbByStream(streamUsage, volumeLevel, deviceType); 1099 EXPECT_TRUE(result != errNotSupportedFloat && result != errPermissionDeniedFloat); 1100 1101 streamUsage = STREAM_USAGE_DTMF; 1102 result = audioSystemManager.GetVolumeInDbByStream(streamUsage, volumeLevel, deviceType); 1103 EXPECT_TRUE(result != errNotSupportedFloat && result != errPermissionDeniedFloat); 1104 } 1105 /** 1106 * @tc.name : Test IsValidToStartGroup API 1107 * @tc.number : IsValidToStartGroup_001 1108 * @tc.desc : Test IsValidToStartGroup interface createAudioWorkgroup 1109 */ 1110 HWTEST(AudioSystemManagerUnitTest, IsValidToStartGroup_001, TestSize.Level1) 1111 { 1112 int workgroupId = 1; 1113 1114 AudioSystemManager audioSystemManager; 1115 bool result = audioSystemManager.IsValidToStartGroup(workgroupId); 1116 EXPECT_FALSE(result); 1117 1118 workgroupId = -1111; 1119 result = audioSystemManager.IsValidToStartGroup(workgroupId); 1120 EXPECT_FALSE(result); 1121 1122 workgroupId = 9999; 1123 result = audioSystemManager.IsValidToStartGroup(workgroupId); 1124 EXPECT_FALSE(result); 1125 } 1126 1127 /** 1128 * @tc.name : Test StopGroup API 1129 * @tc.number : StopGroupp_001 1130 * @tc.desc : Test StopGroup interface createAudioWorkgroup 1131 */ 1132 HWTEST(AudioSystemManagerUnitTest, StopGroup_001, TestSize.Level1) 1133 { 1134 int workgroupId = 1; 1135 1136 AudioSystemManager audioSystemManager; 1137 bool result = audioSystemManager.StopGroup(workgroupId); 1138 EXPECT_TRUE(result); 1139 1140 workgroupId = -111; 1141 result = audioSystemManager.StopGroup(workgroupId); 1142 EXPECT_TRUE(result); 1143 1144 workgroupId = 9999; 1145 result = audioSystemManager.StopGroup(workgroupId); 1146 EXPECT_TRUE(result); 1147 } 1148 1149 /** 1150 * @tc.name : Test GetVolumeByUsage API 1151 * @tc.number : GetVolumeByUsage001 1152 * @tc.desc : Test GetVolumeByUsage interface createAudioWorkgroup 1153 */ 1154 HWTEST(AudioSystemManagerUnitTest, GetVolumeByUsage_002, TestSize.Level1) 1155 { 1156 StreamUsage streamUsage = STREAM_USAGE_SYSTEM; 1157 1158 AudioSystemManager audioSystemManager; 1159 float result = audioSystemManager.GetVolumeByUsage(streamUsage); 1160 float errNotSupportedFloat = static_cast<float>(ERR_NOT_SUPPORTED); 1161 float errPermissionDeniedFloat = static_cast<float>(ERR_PERMISSION_DENIED); 1162 1163 EXPECT_TRUE(result != errNotSupportedFloat && result != errPermissionDeniedFloat); 1164 1165 streamUsage = static_cast<StreamUsage>(1000); 1166 result = audioSystemManager.GetVolumeByUsage(streamUsage); 1167 EXPECT_TRUE(result != -10); 1168 1169 streamUsage = STREAM_USAGE_MUSIC; 1170 result = audioSystemManager.GetVolumeByUsage(streamUsage); 1171 EXPECT_TRUE(result != -10); 1172 1173 streamUsage = STREAM_USAGE_DTMF; 1174 EXPECT_TRUE(result != errNotSupportedFloat && result != errPermissionDeniedFloat); 1175 } 1176 1177 /** 1178 * @tc.name : Test IsWhispering API 1179 * @tc.number : IsWhispering_001 1180 * @tc.desc : Test IsWhispering interface createAudioWorkgroup 1181 */ 1182 HWTEST(AudioSystemManagerUnitTest, IsWhispering_001, TestSize.Level1) 1183 { 1184 AudioSystemManager audioSystemManager; 1185 bool result = audioSystemManager.IsWhispering(); 1186 EXPECT_FALSE(result); 1187 } 1188 1189 /** 1190 * @tc.name : Test IsWhispering API 1191 * @tc.number : IsWhispering_001 1192 * @tc.desc : Test IsWhispering interface createAudioWorkgroup 1193 */ 1194 HWTEST(AudioSystemManagerUnitTest, SetVolumeWithDevice_001, TestSize.Level1) 1195 { 1196 DeviceType deviceType = DEVICE_TYPE_SPEAKER; 1197 AudioSystemManager audioSystemManager; 1198 EXPECT_NE(audioSystemManager.SetVolumeWithDevice(STREAM_MUSIC, 5, deviceType), 1); 1199 } 1200 1201 /** 1202 * @tc.name : Test WorkgroupPrioRecorder constructor 1203 * @tc.number : WorkgroupPrioRecorder_001 1204 * @tc.desc : Test WorkgroupPrioRecorder constructor 1205 */ 1206 HWTEST(AudioSystemManagerUnitTest, WorkgroupPrioRecorder_001, TestSize.Level1) 1207 { 1208 int32_t grpId = 1; 1209 AudioSystemManager::WorkgroupPrioRecorder recorder(grpId); 1210 EXPECT_EQ(recorder.grpId_, grpId); 1211 EXPECT_EQ(recorder.restoreByPermission_, false); 1212 } 1213 1214 /** 1215 * @tc.name : Test SetRestoreByPermission 1216 * @tc.number : SetRestoreByPermission_001 1217 * @tc.desc : Test SetRestoreByPermission when isByPermission true 1218 */ 1219 HWTEST(AudioSystemManagerUnitTest, SetRestoreByPermission_001, TestSize.Level1) 1220 { 1221 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1222 recorder.SetRestoreByPermission(true); 1223 EXPECT_TRUE(recorder.restoreByPermission_); 1224 } 1225 1226 /** 1227 * @tc.name : Test SetRestoreByPermission 1228 * @tc.number : SetRestoreByPermission_002 1229 * @tc.desc : Test SetRestoreByPermission when isByPermission false 1230 */ 1231 HWTEST(AudioSystemManagerUnitTest, SetRestoreByPermission_002, TestSize.Level1) 1232 { 1233 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1234 recorder.SetRestoreByPermission(false); 1235 EXPECT_FALSE(recorder.restoreByPermission_); 1236 } 1237 1238 /** 1239 * @tc.name : Test GetRestoreByPermission 1240 * @tc.number : GetRestoreByPermission_001 1241 * @tc.desc : Test SetRestoreByPermission when permission is set 1242 */ 1243 HWTEST(AudioSystemManagerUnitTest, GetRestoreByPermission_001, TestSize.Level1) 1244 { 1245 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1246 recorder.restoreByPermission_ = true; 1247 EXPECT_TRUE(recorder.GetRestoreByPermission()); 1248 } 1249 1250 /** 1251 * @tc.name : Test GetRestoreByPermission 1252 * @tc.number : GetRestoreByPermission_002 1253 * @tc.desc : Test SetRestoreByPermission when permission is not set 1254 */ 1255 HWTEST(AudioSystemManagerUnitTest, GetRestoreByPermission_002, TestSize.Level1) 1256 { 1257 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1258 recorder.restoreByPermission_ = false; 1259 EXPECT_FALSE(recorder.GetRestoreByPermission()); 1260 } 1261 1262 /** 1263 * @tc.name : Test RecordThreadPrio 1264 * @tc.number : RecordThreadPrio_001 1265 * @tc.desc : Test RecordThreadPrio inteface 1266 */ 1267 HWTEST(AudioSystemManagerUnitTest, RecordThreadPrio_001, TestSize.Level1) 1268 { 1269 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1270 int32_t tokenId = 1; 1271 1272 // Add the tokenId to the threads_ map 1273 recorder.threads_[tokenId] = 2; 1274 1275 // Call the method under test 1276 recorder.RecordThreadPrio(tokenId); 1277 1278 // Verify the result 1279 auto it = recorder.threads_.find(tokenId); 1280 ASSERT_TRUE(it != recorder.threads_.end()); 1281 EXPECT_EQ(it->second, 2); 1282 } 1283 1284 /** 1285 * @tc.name : Test RestoreGroupPrio 1286 * @tc.number : RestoreGroupPrio_001 1287 * @tc.desc : Test RestoreGroupPrio set permission 1288 */ 1289 HWTEST(AudioSystemManagerUnitTest, RestoreGroupPrio_001, TestSize.Level1) 1290 { 1291 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1292 int32_t result = recorder.RestoreGroupPrio(true); 1293 EXPECT_EQ(result, AUDIO_OK); 1294 EXPECT_TRUE(recorder.restoreByPermission_); 1295 } 1296 1297 /** 1298 * @tc.name : Test RestoreGroupPrio 1299 * @tc.number : RestoreGroupPrio_002 1300 * @tc.desc : Test RestoreGroupPrio not set permission 1301 */ 1302 HWTEST(AudioSystemManagerUnitTest, RestoreGroupPrio_002, TestSize.Level1) 1303 { 1304 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1305 int32_t result = recorder.RestoreGroupPrio(false); 1306 EXPECT_EQ(result, AUDIO_OK); 1307 EXPECT_TRUE(recorder.threads_.empty()); 1308 } 1309 1310 /** 1311 * @tc.name : Test RestoreThreadPrio 1312 * @tc.number : RestoreThreadPrio_001 1313 * @tc.desc : Test RestoreThreadPrio when tokenId not exist 1314 */ 1315 HWTEST(AudioSystemManagerUnitTest, RestoreThreadPrio_001, TestSize.Level1) 1316 { 1317 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1318 int32_t tokenId = 1; 1319 recorder.threads_[tokenId] = 1; 1320 int32_t result = recorder.RestoreThreadPrio(tokenId + 1); 1321 EXPECT_EQ(result, AUDIO_OK); 1322 } 1323 1324 /** 1325 * @tc.name : Test RestoreThreadPrio 1326 * @tc.number : RestoreThreadPrio_002 1327 * @tc.desc : Test RestoreThreadPrio when tokenId exist 1328 */ 1329 HWTEST(AudioSystemManagerUnitTest, RestoreThreadPrio_002, TestSize.Level1) 1330 { 1331 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1332 int32_t tokenId = 1; 1333 recorder.threads_[tokenId] = 1; 1334 int32_t result = recorder.RestoreThreadPrio(tokenId); 1335 EXPECT_EQ(result, AUDIO_OK); 1336 } 1337 1338 /** 1339 * @tc.name : Test RestoreThreadPrio 1340 * @tc.number : RestoreThreadPrio_003 1341 * @tc.desc : Test RestoreThreadPrio check tokenId 1342 */ 1343 HWTEST(AudioSystemManagerUnitTest, RestoreThreadPrio_003, TestSize.Level1) 1344 { 1345 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1346 int32_t tokenId = 1; 1347 recorder.threads_[tokenId] = 1; 1348 int32_t result = recorder.RestoreThreadPrio(tokenId); 1349 EXPECT_EQ(result, AUDIO_OK); 1350 EXPECT_EQ(recorder.threads_.find(tokenId), recorder.threads_.end()); 1351 } 1352 1353 /** 1354 * @tc.name : Test GetGrpId 1355 * @tc.number : GetGrpId_001 1356 * @tc.desc : Test GetGrpId when call 1357 */ 1358 HWTEST(AudioSystemManagerUnitTest, GetGrpId_001, TestSize.Level1) 1359 { 1360 AudioSystemManager::WorkgroupPrioRecorder recorder(1); 1361 recorder.grpId_ = 100; 1362 EXPECT_EQ(recorder.GetGrpId(), 100); 1363 } 1364 1365 /** 1366 * @tc.name : Test GetRecorderByGrpId 1367 * @tc.number : GetRecorderByGrpId_001 1368 * @tc.desc : Test GetRecorderByGrpId when grpId exist 1369 */ 1370 HWTEST(AudioSystemManagerUnitTest, GetRecorderByGrpId_001, TestSize.Level1) 1371 { 1372 AudioSystemManager manager; 1373 int32_t grpId = 1; 1374 auto recorder = std::make_shared<AudioSystemManager::WorkgroupPrioRecorder>(1); 1375 manager.workgroupPrioRecorderMap_[grpId] = recorder; 1376 auto result = manager.GetRecorderByGrpId(grpId); 1377 EXPECT_EQ(result, recorder); 1378 } 1379 1380 /** 1381 * @tc.name : Test GetRecorderByGrpId 1382 * @tc.number : GetRecorderByGrpId_002 1383 * @tc.desc : Test GetRecorderByGrpId when grpId not exist 1384 */ 1385 HWTEST(AudioSystemManagerUnitTest, GetRecorderByGrpId_002, TestSize.Level1) 1386 { 1387 AudioSystemManager manager; 1388 int32_t grpId = 1; 1389 auto result = manager.GetRecorderByGrpId(grpId); 1390 EXPECT_EQ(result, nullptr); 1391 } 1392 1393 /** 1394 * @tc.name : Test OnWorkgroupChange 1395 * @tc.number : OnWorkgroupChange_001 1396 * @tc.desc : Test OnWorkgroupChange when allowed is true 1397 */ 1398 HWTEST(AudioSystemManagerUnitTest, OnWorkgroupChange_001, TestSize.Level1) 1399 { 1400 AudioSystemManager manager; 1401 AudioWorkgroupChangeInfo info; 1402 info.pid = 1; 1403 info.groupId = 1; 1404 info.startAllowed = true; 1405 1406 manager.OnWorkgroupChange(info); 1407 1408 // Check if the permission is set correctly 1409 EXPECT_EQ(manager.startGroupPermissionMap_[info.pid][info.groupId], info.startAllowed); 1410 } 1411 1412 /** 1413 * @tc.name : Test OnWorkgroupChange 1414 * @tc.number : OnWorkgroupChange_002 1415 * @tc.desc : Test OnWorkgroupChange when allowed is false 1416 */ 1417 HWTEST(AudioSystemManagerUnitTest, OnWorkgroupChange_002, TestSize.Level1) 1418 { 1419 AudioSystemManager manager; 1420 AudioWorkgroupChangeInfo info; 1421 info.pid = 1; 1422 info.groupId = 1; 1423 info.startAllowed = false; 1424 1425 manager.OnWorkgroupChange(info); 1426 1427 // Check if the permission is set correctly 1428 EXPECT_EQ(manager.startGroupPermissionMap_[info.pid][info.groupId], info.startAllowed); 1429 } 1430 1431 /** 1432 * @tc.name : Test OnWorkgroupChange 1433 * @tc.number : OnWorkgroupChange_003 1434 * @tc.desc : Test OnWorkgroupChange when recorder is nullptr 1435 */ 1436 HWTEST(AudioSystemManagerUnitTest, OnWorkgroupChange_003, TestSize.Level1) 1437 { 1438 AudioSystemManager manager; 1439 AudioWorkgroupChangeInfo info; 1440 info.pid = 1; 1441 info.groupId = 1; 1442 info.startAllowed = false; 1443 1444 manager.OnWorkgroupChange(info); 1445 1446 // Check if the permission is set correctly 1447 EXPECT_EQ(manager.startGroupPermissionMap_[info.pid][info.groupId], info.startAllowed); 1448 // Check if the recorder is nullptr 1449 EXPECT_EQ(manager.GetRecorderByGrpId(info.groupId), nullptr); 1450 } 1451 1452 /** 1453 * @tc.name : Test GetMaxVolumeByUsage API 1454 * @tc.number : GetMaxVolumeByUsage_002 1455 * @tc.desc : Test GetMaxVolumeByUsage interface createAudioWorkgroup 1456 */ 1457 HWTEST(AudioSystemManagerUnitTest, GetMaxVolumeByUsage_002, TestSize.Level1) 1458 { 1459 StreamUsage streamUsage = STREAM_USAGE_ULTRASONIC; 1460 AudioSystemManager audioSystemManager; 1461 EXPECT_NE(audioSystemManager.GetMaxVolumeByUsage(streamUsage), SUCCESS); 1462 } 1463 1464 /** 1465 * @tc.name : Test GetMaxVolumeByUsage API 1466 * @tc.number : GetMaxVolumeByUsage_003 1467 * @tc.desc : Test GetMaxVolumeByUsage interface createAudioWorkgroup 1468 */ 1469 HWTEST(AudioSystemManagerUnitTest, GetMaxVolumeByUsage_003, TestSize.Level4) 1470 { 1471 StreamUsage streamUsage = static_cast<StreamUsage>(1000); 1472 AudioSystemManager audioSystemManager; 1473 EXPECT_EQ(audioSystemManager.GetMaxVolumeByUsage(streamUsage), ERR_NOT_SUPPORTED); 1474 } 1475 1476 /** 1477 * @tc.name : Test GetMaxVolumeByUsage API 1478 * @tc.number : GetMinVolumeByUsage_002 1479 * @tc.desc : Test GetMaxVolumeByUsage interface createAudioWorkgroup 1480 */ 1481 HWTEST(AudioSystemManagerUnitTest, GetMinVolumeByUsage_002, TestSize.Level1) 1482 { 1483 StreamUsage streamUsage = STREAM_USAGE_ULTRASONIC; 1484 AudioSystemManager audioSystemManager; 1485 EXPECT_NE(audioSystemManager.GetMinVolumeByUsage(streamUsage), ERR_NOT_SUPPORTED); 1486 } 1487 1488 /** 1489 * @tc.name : Test GetMaxVolumeByUsage API 1490 * @tc.number : GetMaxVolumeByUsage_003 1491 * @tc.desc : Test GetMaxVolumeByUsage interface createAudioWorkgroup 1492 */ 1493 HWTEST(AudioSystemManagerUnitTest, GetMinVolumeByUsage_003, TestSize.Level4) 1494 { 1495 StreamUsage streamUsage = static_cast<StreamUsage>(1000); 1496 AudioSystemManager audioSystemManager; 1497 EXPECT_EQ(audioSystemManager.GetMinVolumeByUsage(streamUsage), ERR_NOT_SUPPORTED); 1498 } 1499 1500 /** 1501 * @tc.name : Test IsStreamMuteByUsage API 1502 * @tc.number : IsStreamMuteByUsage_002 1503 * @tc.desc : Test IsStreamMuteByUsage interface createAudioWorkgroup 1504 */ 1505 HWTEST(AudioSystemManagerUnitTest, IsStreamMuteByUsage_002, TestSize.Level1) 1506 { 1507 StreamUsage streamUsage = STREAM_USAGE_ULTRASONIC; 1508 AudioSystemManager audioSystemManager; 1509 bool isMute = 0; 1510 EXPECT_NE(audioSystemManager.IsStreamMuteByUsage(streamUsage, isMute), ERR_NOT_SUPPORTED); 1511 } 1512 1513 /** 1514 * @tc.name : Test IsStreamMuteByUsage API 1515 * @tc.number : IsStreamMuteByUsage_003 1516 * @tc.desc : Test IsStreamMuteByUsage interface createAudioWorkgroup 1517 */ 1518 HWTEST(AudioSystemManagerUnitTest, IsStreamMuteByUsage_003, TestSize.Level4) 1519 { 1520 StreamUsage streamUsage = static_cast<StreamUsage>(1000); 1521 AudioSystemManager audioSystemManager; 1522 bool isMute = 0; 1523 EXPECT_EQ(audioSystemManager.IsStreamMuteByUsage(streamUsage, isMute), ERR_NOT_SUPPORTED); 1524 } 1525 1526 /** 1527 * @tc.name : Test GetStreamType API 1528 * @tc.number : GetStreamType_001 1529 * @tc.desc : Test GetStreamType interface 1530 */ 1531 HWTEST(AudioSystemManagerUnitTest, GetStreamType_001, TestSize.Level4) 1532 { 1533 AudioSystemManager audioSystemManager; 1534 ContentType contentType = CONTENT_TYPE_MUSIC; 1535 StreamUsage streamUsage = STREAM_USAGE_MUSIC; 1536 EXPECT_EQ(audioSystemManager.GetStreamType(contentType, streamUsage), STREAM_MUSIC); 1537 } 1538 1539 /** 1540 * @tc.name : Test GetStreamType API 1541 * @tc.number : GetStreamType_002 1542 * @tc.desc : Test GetStreamType interface 1543 */ 1544 HWTEST(AudioSystemManagerUnitTest, GetStreamType_002, TestSize.Level4) 1545 { 1546 AudioSystemManager audioSystemManager; 1547 ContentType contentType = CONTENT_TYPE_MUSIC; 1548 StreamUsage streamUsage = STREAM_USAGE_MEDIA; 1549 EXPECT_EQ(audioSystemManager.GetStreamType(contentType, streamUsage), STREAM_MUSIC); 1550 } 1551 1552 /** 1553 * @tc.name : Test GetStreamType API 1554 * @tc.number : GetStreamType_003 1555 * @tc.desc : Test GetStreamType interface 1556 */ 1557 HWTEST(AudioSystemManagerUnitTest, GetStreamType_003, TestSize.Level4) 1558 { 1559 AudioSystemManager audioSystemManager; 1560 ContentType contentType = CONTENT_TYPE_MUSIC; 1561 StreamUsage streamUsage = STREAM_USAGE_AUDIOBOOK; 1562 EXPECT_EQ(audioSystemManager.GetStreamType(contentType, streamUsage), STREAM_MUSIC); 1563 } 1564 1565 /** 1566 * @tc.name : Test GetAudioScene API 1567 * @tc.number : GetAudioScene_001 1568 * @tc.desc : Test GetAudioScene interface 1569 */ 1570 HWTEST(AudioSystemManagerUnitTest, GetAudioScene_001, TestSize.Level4) 1571 { 1572 AudioSystemManager audioSystemManager; 1573 AudioSystemManager::GetInstance()->SetAudioScene(AUDIO_SCENE_DEFAULT); 1574 int result = audioSystemManager.GetAudioScene(); 1575 EXPECT_EQ(result, AUDIO_SCENE_DEFAULT); 1576 } 1577 1578 /** 1579 * @tc.name : Test GetAudioScene API 1580 * @tc.number : GetAudioScene_002 1581 * @tc.desc : Test GetAudioScene interface 1582 */ 1583 HWTEST(AudioSystemManagerUnitTest, GetAudioScene_002, TestSize.Level4) 1584 { 1585 AudioSystemManager audioSystemManager; 1586 AudioSystemManager::GetInstance()->SetAudioScene(AUDIO_SCENE_VOICE_RINGING); 1587 int result = audioSystemManager.GetAudioScene(); 1588 EXPECT_NE(result, AUDIO_SCENE_INVALID); 1589 } 1590 1591 /** 1592 * @tc.name : Test IsDeviceActive API 1593 * @tc.number : IsDeviceActive_001 1594 * @tc.desc : Test IsDeviceActive interface 1595 */ 1596 HWTEST(AudioSystemManagerUnitTest, IsDeviceActive_001, TestSize.Level4) 1597 { 1598 AudioSystemManager audioSystemManager; 1599 int result = audioSystemManager.IsDeviceActive(DeviceType::DEVICE_TYPE_INVALID); 1600 EXPECT_EQ(result, true); 1601 } 1602 1603 /** 1604 * @tc.name : Test IsDeviceActive API 1605 * @tc.number : IsDeviceActive_002 1606 * @tc.desc : Test IsDeviceActive interface 1607 */ 1608 HWTEST(AudioSystemManagerUnitTest, IsDeviceActive_002, TestSize.Level4) 1609 { 1610 AudioSystemManager audioSystemManager; 1611 int result = audioSystemManager.IsDeviceActive(DeviceType::DEVICE_TYPE_MIC); 1612 EXPECT_EQ(result, true); 1613 } 1614 1615 /** 1616 * @tc.name : Test GetVolume API 1617 * @tc.number : GetVolume_001 1618 * @tc.desc : Test GetVolume interface 1619 */ 1620 HWTEST(AudioSystemManagerUnitTest, GetVolume_001, TestSize.Level4) 1621 { 1622 AudioSystemManager audioSystemManager; 1623 AudioVolumeType volumeType = STREAM_MUSIC; 1624 EXPECT_NE(audioSystemManager.GetVolume(volumeType), ERR_NOT_SUPPORTED); 1625 } 1626 1627 /** 1628 * @tc.name : Test GetVolume API 1629 * @tc.number : GetVolume_002 1630 * @tc.desc : Test GetVolume interface 1631 */ 1632 HWTEST(AudioSystemManagerUnitTest, GetVolume_002, TestSize.Level4) 1633 { 1634 AudioSystemManager audioSystemManager; 1635 AudioVolumeType volumeType = STREAM_ULTRASONIC; 1636 EXPECT_NE(audioSystemManager.GetVolume(volumeType), ERR_PERMISSION_DENIED); 1637 } 1638 1639 /** 1640 * @tc.name : Test IsDeviceActive API 1641 * @tc.number : IsDeviceActive_003 1642 * @tc.desc : Test IsDeviceActive interface 1643 */ 1644 HWTEST(AudioSystemManagerUnitTest, IsDeviceActive_003, TestSize.Level4) 1645 { 1646 AudioSystemManager audioSystemManager; 1647 int result = audioSystemManager.IsDeviceActive(DeviceType::DEVICE_TYPE_NONE); 1648 EXPECT_EQ(result, true); 1649 } 1650 1651 /** 1652 * @tc.name : Test GetVolume API 1653 * @tc.number : GetVolume_003 1654 * @tc.desc : Test GetVolume interface 1655 */ 1656 HWTEST(AudioSystemManagerUnitTest, GetVolume_003, TestSize.Level4) 1657 { 1658 AudioSystemManager audioSystemManager; 1659 AudioVolumeType volumeType = STREAM_ALL; 1660 EXPECT_NE(audioSystemManager.GetVolume(volumeType), ERR_PERMISSION_DENIED); 1661 } 1662 1663 /** 1664 * @tc.name : Test GetPinValueForPeripherals API 1665 * @tc.type : FUNC 1666 * @tc.number: GetPinValueForPeripherals_001 1667 * @tc.desc : Test GetPinValueForPeripherals interface. 1668 */ 1669 HWTEST(AudioSystemManagerUnitTest, GetPinValueForPeripherals_001, TestSize.Level4) 1670 { 1671 AudioPin pinValue = AudioSystemManager::GetInstance()->GetPinValueForPeripherals(DEVICE_TYPE_FILE_SINK, 1672 OUTPUT_DEVICE, DM_DEVICE_TYPE_UWB); 1673 EXPECT_EQ(pinValue, AUDIO_PIN_NONE); 1674 } 1675 1676 /** 1677 * @tc.name : Test GetPinValueForPeripherals API 1678 * @tc.type : FUNC 1679 * @tc.number: GetPinValueForPeripherals_002 1680 * @tc.desc : Test GetPinValueForPeripherals interface. 1681 */ 1682 HWTEST(AudioSystemManagerUnitTest, GetPinValueForPeripherals_002, TestSize.Level4) 1683 { 1684 AudioPin pinValue = AudioSystemManager::GetInstance()->GetPinValueForPeripherals(DEVICE_TYPE_ACCESSORY, 1685 OUTPUT_DEVICE, DM_DEVICE_TYPE_UWB); 1686 EXPECT_EQ(pinValue, AUDIO_PIN_NONE); 1687 } 1688 1689 /** 1690 * @tc.name : Test GetTypeValueFromPin API 1691 * @tc.type : FUNC 1692 * @tc.number: GetTypeValueFromPin_001 1693 * @tc.desc : Test GetTypeValueFromPin interface. 1694 */ 1695 HWTEST(AudioSystemManagerUnitTest, GetTypeValueFromPin_001, TestSize.Level4) 1696 { 1697 DeviceType deviceValue = AudioSystemManager::GetInstance()->GetTypeValueFromPin(AUDIO_PIN_OUT_HEADSET); 1698 EXPECT_EQ(deviceValue, DEVICE_TYPE_NONE); 1699 } 1700 1701 /** 1702 * @tc.name : Test GetTypeValueFromPin API 1703 * @tc.type : FUNC 1704 * @tc.number: GetTypeValueFromPin_002 1705 * @tc.desc : Test GetTypeValueFromPin interface. 1706 */ 1707 HWTEST(AudioSystemManagerUnitTest, GetTypeValueFromPin_002, TestSize.Level4) 1708 { 1709 DeviceType deviceValue = AudioSystemManager::GetInstance()->GetTypeValueFromPin(static_cast<AudioPin>(1000)); 1710 EXPECT_EQ(deviceValue, DEVICE_TYPE_NONE); 1711 } 1712 1713 /** 1714 * @tc.name : Test IsValidToStartGroup API 1715 * @tc.number : IsValidToStartGroup_002 1716 * @tc.desc : Test IsValidToStartGroup interface createAudioWorkgroup 1717 */ 1718 HWTEST(AudioSystemManagerUnitTest, IsValidToStartGroup_002, TestSize.Level4) 1719 { 1720 int workgroupId = 1; 1721 1722 AudioSystemManager audioSystemManager; 1723 audioSystemManager.hasSystemPermission_ = false; 1724 bool result = audioSystemManager.IsValidToStartGroup(workgroupId); 1725 EXPECT_FALSE(result); 1726 } 1727 1728 /** 1729 * @tc.name : Test OnWorkgroupChange API 1730 * @tc.number : OnWorkgroupChange_004 1731 * @tc.desc : Test OnWorkgroupChange interface 1732 */ 1733 HWTEST(AudioSystemManagerUnitTest, OnWorkgroupChange_004, TestSize.Level4) 1734 { 1735 AudioWorkgroupCallbackImpl audioWorkgroupCallbackImpl; 1736 AudioWorkgroupChangeInfoIpc info; 1737 audioWorkgroupCallbackImpl.workgroupCb_ = nullptr; 1738 EXPECT_EQ(audioWorkgroupCallbackImpl.OnWorkgroupChange(info), ERROR); 1739 } 1740 1741 /** 1742 * @tc.name : Test RemoveWorkgroupChangeCallback API 1743 * @tc.number : RemoveWorkgroupChangeCallback_001 1744 * @tc.desc : Test RemoveWorkgroupChangeCallback interface 1745 */ 1746 HWTEST(AudioSystemManagerUnitTest, RemoveWorkgroupChangeCallback_001, TestSize.Level4) 1747 { 1748 AudioWorkgroupCallbackImpl audioWorkgroupCallbackImpl; 1749 audioWorkgroupCallbackImpl.RemoveWorkgroupChangeCallback(); 1750 EXPECT_EQ(nullptr, audioWorkgroupCallbackImpl.workgroupCb_); 1751 } 1752 1753 } // namespace AudioStandard 1754 } // namespace OHOS 1755