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 "volume_tools.h" 21 22 using namespace testing::ext; 23 24 namespace OHOS { 25 namespace AudioStandard { 26 static const size_t MAX_FRAME_SIZE = 100000; 27 class VolumeToolsUnitTest : public testing::Test { 28 public: 29 static void SetUpTestCase(void); 30 static void TearDownTestCase(void); 31 void SetUp(); 32 void TearDown(); 33 }; 34 35 /** 36 * @tc.name : Test IsVolumeValid API 37 * @tc.type : FUNC 38 * @tc.number: IsVolumeValid_001 39 * @tc.desc : Test IsVolumeValid interface. 40 */ 41 HWTEST(VolumeToolsUnitTest, IsVolumeValid_001, TestSize.Level1) 42 { 43 std::shared_ptr<VolumeTools> volumeTools; 44 volumeTools = std::make_shared<VolumeTools>(); 45 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_001 start"); 46 ChannelVolumes channelVolumes = {STEREO, {1, 2}, {3, 4}}; 47 bool ret = volumeTools->IsVolumeValid(channelVolumes); 48 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_001 result:%{public}d", ret); 49 EXPECT_EQ(ret, true); 50 } 51 52 /** 53 * @tc.name : Test IsVolumeValid API 54 * @tc.type : FUNC 55 * @tc.number: IsVolumeValid_002 56 * @tc.desc : Test IsVolumeValid interface, when channelVolumes.channel is less than MONO(1). 57 */ 58 HWTEST(VolumeToolsUnitTest, IsVolumeValid_002, TestSize.Level1) 59 { 60 std::shared_ptr<VolumeTools> volumeTools; 61 volumeTools = std::make_shared<VolumeTools>(); 62 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_002 start"); 63 ChannelVolumes channelVolumes = {static_cast<AudioChannel>(0), {1, 2}, {3, 4}}; 64 bool ret = volumeTools->IsVolumeValid(channelVolumes); 65 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_001 result:%{public}d", ret); 66 EXPECT_EQ(ret, false); 67 } 68 69 /** 70 * @tc.name : Test IsVolumeValid API 71 * @tc.type : FUNC 72 * @tc.number: IsVolumeValid_003 73 * @tc.desc : Test IsVolumeValid interface, when channelVolumes.channel is bigger than CHANNEL_16(16). 74 */ 75 HWTEST(VolumeToolsUnitTest, IsVolumeValid_003, TestSize.Level1) 76 { 77 std::shared_ptr<VolumeTools> volumeTools; 78 volumeTools = std::make_shared<VolumeTools>(); 79 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_003 start"); 80 ChannelVolumes channelVolumes = {static_cast<AudioChannel>(20), {1, 2}, {3, 4}}; 81 bool ret = volumeTools->IsVolumeValid(channelVolumes); 82 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_001 result:%{public}d", ret); 83 EXPECT_EQ(ret, false); 84 } 85 86 /** 87 * @tc.name : Test IsVolumeValid API 88 * @tc.type : FUNC 89 * @tc.number: IsVolumeValid_004 90 * @tc.desc : Test IsVolumeValid interface. 91 */ 92 HWTEST(VolumeToolsUnitTest, IsVolumeValid_004, TestSize.Level1) 93 { 94 std::shared_ptr<VolumeTools> volumeTools; 95 volumeTools = std::make_shared<VolumeTools>(); 96 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_004 start"); 97 ChannelVolumes channelVolumes = {STEREO, {-1, 2}, {-1, 4}}; 98 bool ret = volumeTools->IsVolumeValid(channelVolumes); 99 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_004 result:%{public}d", ret); 100 EXPECT_EQ(ret, false); 101 } 102 103 /** 104 * @tc.name : Test IsVolumeValid API 105 * @tc.type : FUNC 106 * @tc.number: IsVolumeValid_005 107 * @tc.desc : Test IsVolumeValid interface. 108 */ 109 HWTEST(VolumeToolsUnitTest, IsVolumeValid_005, TestSize.Level1) 110 { 111 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 112 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_005 start"); 113 ChannelVolumes channelVolumes = {STEREO, {1, 65536}, {3, 65537}}; 114 bool ret = volumeTools->IsVolumeValid(channelVolumes); 115 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_005 result:%{public}d", ret); 116 EXPECT_EQ(ret, false); 117 } 118 119 /** 120 * @tc.name : Test Process API 121 * @tc.type : FUNC 122 * @tc.number: Process_001 123 * @tc.desc : Test Process interface. 124 */ 125 HWTEST(VolumeToolsUnitTest, Process_001, TestSize.Level1) 126 { 127 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 128 AUDIO_INFO_LOG("AudioSystemManagerUnitTest Process_001 start"); 129 ChannelVolumes channelVolumes = {STEREO, {1, 2}, {3, 4}}; 130 BufferDesc bufferDesc = {nullptr, 0, 0}; 131 int32_t ret = volumeTools->Process(bufferDesc, SAMPLE_U8, channelVolumes); 132 EXPECT_EQ(ERR_INVALID_PARAM, ret); 133 ret = volumeTools->Process(bufferDesc, SAMPLE_S16LE, channelVolumes); 134 EXPECT_EQ(ERR_INVALID_PARAM, ret); 135 ret = volumeTools->Process(bufferDesc, SAMPLE_S24LE, channelVolumes); 136 EXPECT_EQ(ERR_INVALID_PARAM, ret); 137 ret = volumeTools->Process(bufferDesc, SAMPLE_S32LE, channelVolumes); 138 EXPECT_EQ(ERR_INVALID_PARAM, ret); 139 ret = volumeTools->Process(bufferDesc, SAMPLE_F32LE, channelVolumes); 140 EXPECT_EQ(ERR_INVALID_PARAM, ret); 141 ret = volumeTools->Process(bufferDesc, INVALID_WIDTH, channelVolumes); 142 EXPECT_EQ(ERR_INVALID_PARAM, ret); 143 } 144 145 /** 146 * @tc.name : Test Process API 147 * @tc.type : FUNC 148 * @tc.number: Process_002 149 * @tc.desc : Test Process interface. 150 */ 151 HWTEST(VolumeToolsUnitTest, Process_002, TestSize.Level1) 152 { 153 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 154 size_t len = 10; 155 std::unique_ptr<float[]> buffer = std::make_unique<float[]>(len); 156 for (size_t i = 0; i < 10; ++i) { 157 buffer[i] = static_cast<float>(i); 158 } 159 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 0, 0}; 160 ChannelVolumes channelVols = {}; 161 channelVols.channel = MONO; 162 channelVols.volStart[0] = 0; 163 channelVols.volEnd[0] = 0; 164 int32_t ret = volumeTools->Process(bufferDesc, SAMPLE_F32LE, channelVols); 165 EXPECT_EQ(ret, ERR_INVALID_PARAM); 166 } 167 168 /** 169 * @tc.name : Test Process API 170 * @tc.type : FUNC 171 * @tc.number: Process_003 172 * @tc.desc : Test Process interface. 173 */ 174 HWTEST(VolumeToolsUnitTest, Process_003, TestSize.Level1) 175 { 176 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 177 AUDIO_INFO_LOG("AudioSystemManagerUnitTest Process_001 start"); 178 ChannelVolumes channelVolumes = {STEREO, {1, 2}, {3, 4}}; 179 BufferDesc bufferDesc = {nullptr, 0, 0}; 180 bufferDesc.dataLength = 0; 181 int32_t ret = volumeTools->Process(bufferDesc, SAMPLE_S16LE, channelVolumes); 182 EXPECT_EQ(ERR_INVALID_PARAM, ret); 183 } 184 185 /** 186 * @tc.name : Test Process API 187 * @tc.type : FUNC 188 * @tc.number: Process_004 189 * @tc.desc : Test Process interface. 190 */ 191 HWTEST(VolumeToolsUnitTest, Process_004, TestSize.Level1) 192 { 193 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 194 AUDIO_INFO_LOG("AudioSystemManagerUnitTest Process_001 start"); 195 ChannelVolumes channelVols = {}; 196 channelVols.channel = CHANNEL_UNKNOW; 197 channelVols.volStart[0] = 0; 198 channelVols.volEnd[0] = 0; 199 BufferDesc bufferDesc = {nullptr, 0, 0}; 200 int32_t ret = volumeTools->Process(bufferDesc, SAMPLE_S16LE, channelVols); 201 EXPECT_EQ(ERR_INVALID_PARAM, ret); 202 } 203 204 /** 205 * @tc.name : Test GetVolDb API 206 * @tc.type : FUNC 207 * @tc.number: GetVolDb_001 208 * @tc.desc : Test GetVolDb interface. 209 */ 210 HWTEST(VolumeToolsUnitTest, GetVolDb_001, TestSize.Level1) 211 { 212 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 213 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolDb_001 start"); 214 double ret = volumeTools->GetVolDb(SAMPLE_U8, 1); 215 EXPECT_NE(ret, 0); 216 ret = volumeTools->GetVolDb(SAMPLE_S16LE, 1); 217 EXPECT_NE(ret, 0); 218 ret = volumeTools->GetVolDb(SAMPLE_S24LE, 1); 219 EXPECT_NE(ret, 0); 220 ret = volumeTools->GetVolDb(SAMPLE_S32LE, 1); 221 EXPECT_NE(ret, 0); 222 ret = volumeTools->GetVolDb(SAMPLE_F32LE, 1); 223 EXPECT_NE(ret, 0); 224 ret = volumeTools->GetVolDb(INVALID_WIDTH, 1); 225 EXPECT_EQ(ret, 0); 226 } 227 228 /** 229 * @tc.name : Test CountVolumeLevel API 230 * @tc.type : FUNC 231 * @tc.number: CountVolumeLevel_001 232 * @tc.desc : Test CountVolumeLevel interface. 233 */ 234 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_001, TestSize.Level1) 235 { 236 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 237 AUDIO_INFO_LOG("AudioSystemManagerUnitTest CountVolumeLevel_001 start"); 238 BufferDesc bufferDesc = {nullptr, 0, 0}; 239 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, MONO); 240 EXPECT_EQ(ret.channel, MONO); 241 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S16LE, STEREO); 242 EXPECT_EQ(ret.channel, STEREO); 243 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S24LE, CHANNEL_3); 244 EXPECT_EQ(ret.channel, CHANNEL_3); 245 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S32LE, CHANNEL_4); 246 EXPECT_EQ(ret.channel, CHANNEL_4); 247 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_F32LE, CHANNEL_5); 248 EXPECT_EQ(ret.channel, CHANNEL_5); 249 ret = volumeTools->CountVolumeLevel(bufferDesc, INVALID_WIDTH, CHANNEL_6); 250 EXPECT_EQ(ret.channel, CHANNEL_6); 251 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, static_cast<AudioChannel>(CHANNEL_16 + 1)); 252 EXPECT_EQ(ret.channel, (CHANNEL_16 + 1)); 253 } 254 255 /** 256 * @tc.name : Test CountVolumeLevel API 257 * @tc.type : FUNC 258 * @tc.number: CountVolumeLevel_002 259 * @tc.desc : Test CountVolumeLevel interface. 260 */ 261 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_002, TestSize.Level1) 262 { 263 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 264 BufferDesc bufferDesc = {nullptr, 0, 0}; 265 size_t split = 0; 266 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, MONO, split); 267 EXPECT_EQ(ret.channel, MONO); 268 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S16LE, STEREO, split); 269 EXPECT_EQ(ret.channel, STEREO); 270 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S24LE, CHANNEL_3, split); 271 EXPECT_EQ(ret.channel, CHANNEL_3); 272 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S32LE, CHANNEL_4, split); 273 EXPECT_EQ(ret.channel, CHANNEL_4); 274 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_F32LE, CHANNEL_5, split); 275 EXPECT_EQ(ret.channel, CHANNEL_5); 276 ret = volumeTools->CountVolumeLevel(bufferDesc, INVALID_WIDTH, CHANNEL_6, split); 277 EXPECT_EQ(ret.channel, CHANNEL_6); 278 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, static_cast<AudioChannel>(CHANNEL_16 + 1), split); 279 EXPECT_EQ(ret.channel, (CHANNEL_16 + 1)); 280 } 281 282 /** 283 * @tc.name : Test CountVolumeLevel API 284 * @tc.type : FUNC 285 * @tc.number: CountVolumeLevel_003 286 * @tc.desc : Test CountVolumeLevel interface. 287 */ 288 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_003, TestSize.Level1) 289 { 290 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 291 size_t len = 10; 292 std::unique_ptr<int8_t[]> buffer = std::make_unique<int8_t[]>(len); 293 for (size_t i = 0; i < len; ++i) { 294 buffer[i] = static_cast<int8_t>(i); 295 } 296 size_t split = 1; 297 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 298 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, MONO, split); 299 EXPECT_EQ(ret.volStart[0], 0); 300 301 size_t size = volumeTools->GetByteSize(SAMPLE_U8); 302 size_t channel = MONO; 303 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 304 split = 11; 305 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, MONO, split); 306 EXPECT_EQ(ret.volStart[0], 0); 307 } 308 309 /** 310 * @tc.name : Test CountVolumeLevel API 311 * @tc.type : FUNC 312 * @tc.number: CountVolumeLevel_004 313 * @tc.desc : Test CountVolumeLevel interface. 314 */ 315 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_004, TestSize.Level1) 316 { 317 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 318 size_t len = 10; 319 std::unique_ptr<int16_t[]> buffer = std::make_unique<int16_t[]>(len); 320 for (size_t i = 0; i < 10; ++i) { 321 buffer[i] = static_cast<int16_t>(i); 322 } 323 324 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 325 size_t split = 1; 326 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S16LE, MONO, split); 327 EXPECT_EQ(ret.volStart[0], 0); 328 329 size_t size = volumeTools->GetByteSize(SAMPLE_S16LE); 330 size_t channel = MONO; 331 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 332 split = 11; 333 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S16LE, MONO, split); 334 EXPECT_EQ(ret.volStart[0], 0); 335 } 336 337 /** 338 * @tc.name : Test CountVolumeLevel API 339 * @tc.type : FUNC 340 * @tc.number: CountVolumeLevel_006 341 * @tc.desc : Test CountVolumeLevel interface. 342 */ 343 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_006, TestSize.Level1) 344 { 345 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 346 size_t len = 10; 347 std::unique_ptr<int8_t[]> buffer = std::make_unique<int8_t[]>(len * 3); 348 for (size_t i = 0; i < 30; ++i) { 349 buffer[i] = static_cast<int8_t>(i); 350 } 351 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 352 size_t split = 1; 353 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S24LE, MONO, split); 354 EXPECT_EQ(ret.volStart[0], 0); 355 356 size_t size = volumeTools->GetByteSize(SAMPLE_S24LE); 357 size_t channel = MONO; 358 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 359 split = 11; 360 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S24LE, MONO, split); 361 EXPECT_EQ(ret.volStart[0], 0); 362 } 363 364 /** 365 * @tc.name : Test CountVolumeLevel API 366 * @tc.type : FUNC 367 * @tc.number: CountVolumeLevel_007 368 * @tc.desc : Test CountVolumeLevel interface. 369 */ 370 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_007, TestSize.Level1) 371 { 372 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 373 size_t len = 10; 374 std::unique_ptr<int32_t[]> buffer = std::make_unique<int32_t[]>(len); 375 for (size_t i = 0; i < 10; ++i) { 376 buffer[i] = static_cast<int32_t>(i); 377 } 378 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 379 size_t split = 1; 380 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S32LE, MONO, split); 381 EXPECT_EQ(ret.volStart[0], 0); 382 383 size_t size = volumeTools->GetByteSize(SAMPLE_S32LE); 384 size_t channel = MONO; 385 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 386 split = 11; 387 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S32LE, MONO, split); 388 EXPECT_EQ(ret.volStart[0], 0); 389 } 390 391 /** 392 * @tc.name : Test CountVolumeLevel API 393 * @tc.type : FUNC 394 * @tc.number: CountVolumeLevel_008 395 * @tc.desc : Test CountVolumeLevel interface. 396 */ 397 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_008, TestSize.Level1) 398 { 399 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 400 size_t len = 10; 401 std::unique_ptr<float[]> buffer = std::make_unique<float[]>(len); 402 for (size_t i = 0; i < 10; ++i) { 403 buffer[i] = static_cast<float>(i); 404 } 405 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 406 size_t split = 1; 407 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_F32LE, MONO, split); 408 EXPECT_EQ(ret.volStart[0], 0); 409 410 size_t size = volumeTools->GetByteSize(SAMPLE_F32LE); 411 size_t channel = MONO; 412 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 413 split = 11; 414 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_F32LE, MONO, split); 415 EXPECT_EQ(ret.volStart[0], 0); 416 } 417 418 /** 419 * @tc.name : Test IsVolumeValid API 420 * @tc.type : FUNC 421 * @tc.number: IsVolumeValid_006 422 * @tc.desc : Test IsVolumeValid interface. 423 */ 424 HWTEST(VolumeToolsUnitTest, IsVolumeValid_006, TestSize.Level4) 425 { 426 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 427 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_006 start"); 428 ChannelVolumes channelVolumes = {STEREO, {1, 65536}, {3, 65537}}; 429 channelVolumes.channel = CHANNEL_UNKNOW; 430 bool ret = volumeTools->IsVolumeValid(channelVolumes); 431 AUDIO_INFO_LOG("AudioSystemManagerUnitTest IsVolumeValid_006 result:%{public}d", ret); 432 EXPECT_EQ(ret, false); 433 } 434 } // namespace AudioStandard 435 } // namespace OHOS