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 GetVolDb API 170 * @tc.type : FUNC 171 * @tc.number: GetVolDb_001 172 * @tc.desc : Test GetVolDb interface. 173 */ 174 HWTEST(VolumeToolsUnitTest, GetVolDb_001, TestSize.Level1) 175 { 176 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 177 AUDIO_INFO_LOG("AudioSystemManagerUnitTest GetVolDb_001 start"); 178 double ret = volumeTools->GetVolDb(SAMPLE_U8, 1); 179 EXPECT_NE(ret, 0); 180 ret = volumeTools->GetVolDb(SAMPLE_S16LE, 1); 181 EXPECT_NE(ret, 0); 182 ret = volumeTools->GetVolDb(SAMPLE_S24LE, 1); 183 EXPECT_NE(ret, 0); 184 ret = volumeTools->GetVolDb(SAMPLE_S32LE, 1); 185 EXPECT_NE(ret, 0); 186 ret = volumeTools->GetVolDb(SAMPLE_F32LE, 1); 187 EXPECT_NE(ret, 0); 188 ret = volumeTools->GetVolDb(INVALID_WIDTH, 1); 189 EXPECT_EQ(ret, 0); 190 } 191 192 /** 193 * @tc.name : Test CountVolumeLevel API 194 * @tc.type : FUNC 195 * @tc.number: CountVolumeLevel_001 196 * @tc.desc : Test CountVolumeLevel interface. 197 */ 198 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_001, TestSize.Level1) 199 { 200 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 201 AUDIO_INFO_LOG("AudioSystemManagerUnitTest CountVolumeLevel_001 start"); 202 BufferDesc bufferDesc = {nullptr, 0, 0}; 203 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, MONO); 204 EXPECT_EQ(ret.channel, MONO); 205 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S16LE, STEREO); 206 EXPECT_EQ(ret.channel, STEREO); 207 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S24LE, CHANNEL_3); 208 EXPECT_EQ(ret.channel, CHANNEL_3); 209 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S32LE, CHANNEL_4); 210 EXPECT_EQ(ret.channel, CHANNEL_4); 211 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_F32LE, CHANNEL_5); 212 EXPECT_EQ(ret.channel, CHANNEL_5); 213 ret = volumeTools->CountVolumeLevel(bufferDesc, INVALID_WIDTH, CHANNEL_6); 214 EXPECT_EQ(ret.channel, CHANNEL_6); 215 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, static_cast<AudioChannel>(CHANNEL_16 + 1)); 216 EXPECT_EQ(ret.channel, (CHANNEL_16 + 1)); 217 } 218 219 /** 220 * @tc.name : Test CountVolumeLevel API 221 * @tc.type : FUNC 222 * @tc.number: CountVolumeLevel_002 223 * @tc.desc : Test CountVolumeLevel interface. 224 */ 225 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_002, TestSize.Level1) 226 { 227 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 228 BufferDesc bufferDesc = {nullptr, 0, 0}; 229 size_t split = 0; 230 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, MONO, split); 231 EXPECT_EQ(ret.channel, MONO); 232 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S16LE, STEREO, split); 233 EXPECT_EQ(ret.channel, STEREO); 234 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S24LE, CHANNEL_3, split); 235 EXPECT_EQ(ret.channel, CHANNEL_3); 236 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S32LE, CHANNEL_4, split); 237 EXPECT_EQ(ret.channel, CHANNEL_4); 238 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_F32LE, CHANNEL_5, split); 239 EXPECT_EQ(ret.channel, CHANNEL_5); 240 ret = volumeTools->CountVolumeLevel(bufferDesc, INVALID_WIDTH, CHANNEL_6, split); 241 EXPECT_EQ(ret.channel, CHANNEL_6); 242 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, static_cast<AudioChannel>(CHANNEL_16 + 1), split); 243 EXPECT_EQ(ret.channel, (CHANNEL_16 + 1)); 244 } 245 246 /** 247 * @tc.name : Test CountVolumeLevel API 248 * @tc.type : FUNC 249 * @tc.number: CountVolumeLevel_003 250 * @tc.desc : Test CountVolumeLevel interface. 251 */ 252 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_003, TestSize.Level1) 253 { 254 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 255 size_t len = 10; 256 std::unique_ptr<int8_t[]> buffer = std::make_unique<int8_t[]>(len); 257 for (size_t i = 0; i < len; ++i) { 258 buffer[i] = static_cast<int8_t>(i); 259 } 260 size_t split = 1; 261 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 262 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, MONO, split); 263 EXPECT_EQ(ret.volStart[0], 0); 264 265 size_t size = volumeTools->GetByteSize(SAMPLE_U8); 266 size_t channel = MONO; 267 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 268 split = 11; 269 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_U8, MONO, split); 270 EXPECT_EQ(ret.volStart[0], 0); 271 } 272 273 /** 274 * @tc.name : Test CountVolumeLevel API 275 * @tc.type : FUNC 276 * @tc.number: CountVolumeLevel_004 277 * @tc.desc : Test CountVolumeLevel interface. 278 */ 279 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_004, TestSize.Level1) 280 { 281 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 282 size_t len = 10; 283 std::unique_ptr<int16_t[]> buffer = std::make_unique<int16_t[]>(len); 284 for (size_t i = 0; i < 10; ++i) { 285 buffer[i] = static_cast<int16_t>(i); 286 } 287 288 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 289 size_t split = 1; 290 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S16LE, MONO, split); 291 EXPECT_EQ(ret.volStart[0], 0); 292 293 size_t size = volumeTools->GetByteSize(SAMPLE_S16LE); 294 size_t channel = MONO; 295 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 296 split = 11; 297 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S16LE, MONO, split); 298 EXPECT_EQ(ret.volStart[0], 0); 299 } 300 301 /** 302 * @tc.name : Test CountVolumeLevel API 303 * @tc.type : FUNC 304 * @tc.number: CountVolumeLevel_006 305 * @tc.desc : Test CountVolumeLevel interface. 306 */ 307 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_006, TestSize.Level1) 308 { 309 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 310 size_t len = 10; 311 std::unique_ptr<int8_t[]> buffer = std::make_unique<int8_t[]>(len * 3); 312 for (size_t i = 0; i < 30; ++i) { 313 buffer[i] = static_cast<int8_t>(i); 314 } 315 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 316 size_t split = 1; 317 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S24LE, MONO, split); 318 EXPECT_EQ(ret.volStart[0], 0); 319 320 size_t size = volumeTools->GetByteSize(SAMPLE_S24LE); 321 size_t channel = MONO; 322 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 323 split = 11; 324 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S24LE, MONO, split); 325 EXPECT_EQ(ret.volStart[0], 0); 326 } 327 328 /** 329 * @tc.name : Test CountVolumeLevel API 330 * @tc.type : FUNC 331 * @tc.number: CountVolumeLevel_007 332 * @tc.desc : Test CountVolumeLevel interface. 333 */ 334 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_007, TestSize.Level1) 335 { 336 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 337 size_t len = 10; 338 std::unique_ptr<int32_t[]> buffer = std::make_unique<int32_t[]>(len); 339 for (size_t i = 0; i < 10; ++i) { 340 buffer[i] = static_cast<int32_t>(i); 341 } 342 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 343 size_t split = 1; 344 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S32LE, MONO, split); 345 EXPECT_EQ(ret.volStart[0], 0); 346 347 size_t size = volumeTools->GetByteSize(SAMPLE_S32LE); 348 size_t channel = MONO; 349 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 350 split = 11; 351 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_S32LE, MONO, split); 352 EXPECT_EQ(ret.volStart[0], 0); 353 } 354 355 /** 356 * @tc.name : Test CountVolumeLevel API 357 * @tc.type : FUNC 358 * @tc.number: CountVolumeLevel_008 359 * @tc.desc : Test CountVolumeLevel interface. 360 */ 361 HWTEST(VolumeToolsUnitTest, CountVolumeLevel_008, TestSize.Level1) 362 { 363 std::shared_ptr<VolumeTools> volumeTools = std::make_shared<VolumeTools>(); 364 size_t len = 10; 365 std::unique_ptr<float[]> buffer = std::make_unique<float[]>(len); 366 for (size_t i = 0; i < 10; ++i) { 367 buffer[i] = static_cast<float>(i); 368 } 369 BufferDesc bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), 10 * MAX_FRAME_SIZE, 10 * MAX_FRAME_SIZE}; 370 size_t split = 1; 371 ChannelVolumes ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_F32LE, MONO, split); 372 EXPECT_EQ(ret.volStart[0], 0); 373 374 size_t size = volumeTools->GetByteSize(SAMPLE_F32LE); 375 size_t channel = MONO; 376 bufferDesc = {reinterpret_cast<uint8_t *>(buffer.get()), len * size * channel, len * size * channel}; 377 split = 11; 378 ret = volumeTools->CountVolumeLevel(bufferDesc, SAMPLE_F32LE, MONO, split); 379 EXPECT_EQ(ret.volStart[0], 0); 380 } 381 } // namespace AudioStandard 382 } // namespace OHOS