1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <iostream>
17 #include <cstddef>
18 #include <cstdint>
19 #include <cstring>
20 #include "audio_info.h"
21 #include "audio_policy_server.h"
22 #include "audio_policy_service.h"
23 #include "audio_device_info.h"
24 #include "audio_utils.h"
25 #include "accesstoken_kit.h"
26 #include "nativetoken_kit.h"
27 #include "token_setproc.h"
28 #include "access_token.h"
29 #include "audio_channel_blend.h"
30 #include "volume_ramp.h"
31 #include "audio_speed.h"
32
33 #include "audio_policy_utils.h"
34 #include "audio_stream_descriptor.h"
35
36 namespace OHOS {
37 namespace AudioStandard {
38 using namespace std;
39
40 static const uint8_t* RAW_DATA = nullptr;
41 static size_t g_dataSize = 0;
42 static size_t g_pos;
43 const size_t THRESHOLD = 10;
44 const uint8_t TESTSIZE = 26;
45 const uint32_t RESIZENUM = 2;
46 const uint32_t IDNUM = 2;
47 const uint32_t NUM_2 = 2;
48 typedef void (*TestFuncs)();
49
50 vector<AudioFlag> AudioFlagVec = {
51 AUDIO_FLAG_NONE,
52 AUDIO_OUTPUT_FLAG_NORMAL,
53 AUDIO_OUTPUT_FLAG_DIRECT,
54 AUDIO_OUTPUT_FLAG_HD,
55 AUDIO_OUTPUT_FLAG_MULTICHANNEL,
56 AUDIO_OUTPUT_FLAG_LOWPOWER,
57 AUDIO_OUTPUT_FLAG_FAST,
58 AUDIO_OUTPUT_FLAG_VOIP,
59 AUDIO_OUTPUT_FLAG_VOIP_FAST,
60 AUDIO_OUTPUT_FLAG_HWDECODING,
61 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD,
62 AUDIO_INPUT_FLAG_NORMAL,
63 AUDIO_INPUT_FLAG_FAST,
64 AUDIO_INPUT_FLAG_VOIP,
65 AUDIO_INPUT_FLAG_VOIP_FAST,
66 AUDIO_INPUT_FLAG_WAKEUP,
67 AUDIO_FLAG_MAX,
68 };
69
70 template<class T>
GetData()71 T GetData()
72 {
73 T object {};
74 size_t objectSize = sizeof(object);
75 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
76 return object;
77 }
78 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
79 if (ret != EOK) {
80 return {};
81 }
82 g_pos += objectSize;
83 return object;
84 }
85
86 template<class T>
GetArrLength(T & arr)87 uint32_t GetArrLength(T& arr)
88 {
89 if (arr == nullptr) {
90 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
91 return 0;
92 }
93 return sizeof(arr) / sizeof(arr[0]);
94 }
95
RemoveAudioPipeInfoFuzzTest()96 void RemoveAudioPipeInfoFuzzTest()
97 {
98 auto audioPipeManager = AudioPipeManager::GetPipeManager();
99 std::shared_ptr<AudioPipeInfo> targetPipe = std::make_shared<AudioPipeInfo>();
100 targetPipe->adapterName_ = "test_adapter";
101 targetPipe->routeFlag_ = 1;
102
103 audioPipeManager->AddAudioPipeInfo(targetPipe);
104 audioPipeManager->RemoveAudioPipeInfo(targetPipe);
105 auto pipeList = audioPipeManager->GetPipeList();
106 }
107
RemoveAudioPipeInfoByIdFuzzTest()108 void RemoveAudioPipeInfoByIdFuzzTest()
109 {
110 auto audioPipeManager = AudioPipeManager::GetPipeManager();
111 std::shared_ptr<AudioPipeInfo> targetPipe = std::make_shared<AudioPipeInfo>();
112 targetPipe->id_ = GetData<uint32_t>();
113 targetPipe->adapterName_ = "test_adapter";
114
115 audioPipeManager->GetPipeList();
116 audioPipeManager->AddAudioPipeInfo(targetPipe);
117 audioPipeManager->RemoveAudioPipeInfo(targetPipe->id_);
118 audioPipeManager->GetPipeList();
119 }
120
UpdateAudioPipeInfoFuzzTest()121 void UpdateAudioPipeInfoFuzzTest()
122 {
123 auto audioPipeManager = AudioPipeManager::GetPipeManager();
124 audioPipeManager->curPipeList_.clear();
125 audioPipeManager->GetPipeList();
126
127 std::shared_ptr<AudioPipeInfo> existingPipe = std::make_shared<AudioPipeInfo>();
128 existingPipe->adapterName_ = "existing_adapter";
129 existingPipe->routeFlag_ = 1;
130 existingPipe->id_ = IDNUM;
131 audioPipeManager->AddAudioPipeInfo(existingPipe);
132
133 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
134 newPipe->adapterName_ = "existing_adapter";
135 newPipe->routeFlag_ = 1;
136 newPipe->id_ = GetData<uint32_t>();
137 audioPipeManager->UpdateAudioPipeInfo(newPipe);
138 audioPipeManager->GetPipeList();
139 }
140
IsSamePipeFuzzTest()141 void IsSamePipeFuzzTest()
142 {
143 auto audioPipeManager = AudioPipeManager::GetPipeManager();
144 std::shared_ptr<AudioPipeInfo> info = std::make_shared<AudioPipeInfo>();
145 info->adapterName_ = "test_adapter";
146 info->routeFlag_ = 1;
147 info->id_ = GetData<uint32_t>();
148
149 std::shared_ptr<AudioPipeInfo> cmpInfo = std::make_shared<AudioPipeInfo>();
150 cmpInfo->adapterName_ = "test_adapter";
151 cmpInfo->routeFlag_ = 1;
152 cmpInfo->id_ = GetData<uint32_t>();
153 audioPipeManager->IsSamePipe(info, cmpInfo);
154 }
155
GetUnusedPipeFuzzTest()156 void GetUnusedPipeFuzzTest()
157 {
158 auto audioPipeManager = AudioPipeManager::GetPipeManager();
159 audioPipeManager->curPipeList_.clear();
160
161 std::shared_ptr<AudioPipeInfo> pipe1 = std::make_shared<AudioPipeInfo>();
162 pipe1->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST;
163 pipe1->streamDescriptors_.clear();
164 audioPipeManager->AddAudioPipeInfo(pipe1);
165
166 audioPipeManager->GetUnusedPipe();
167 }
168
IsSpecialPipeFuzzTest()169 void IsSpecialPipeFuzzTest()
170 {
171 auto audioPipeManager = AudioPipeManager::GetPipeManager();
172 if (AudioFlagVec.size() == 0) {
173 return;
174 }
175 uint32_t routeFlagCount = GetData<uint32_t>() % AudioFlagVec.size();
176 uint32_t routeFlag = AudioFlagVec[routeFlagCount];
177 audioPipeManager->IsSpecialPipe(routeFlag);
178 }
179
IsNormalRecordPipeFuzzTest()180 void IsNormalRecordPipeFuzzTest()
181 {
182 auto audioPipeManager = AudioPipeManager::GetPipeManager();
183 if (AudioFlagVec.size() == 0 || audioPipeManager == nullptr) {
184 return;
185 }
186 shared_ptr<AudioPipeInfo> pipe = std::make_shared<AudioPipeInfo>();
187 pipe->adapterName_ = GetData<uint32_t>() % NUM_2 == 0 ? PRIMARY_CLASS : USB_CLASS;
188 uint32_t routeFlagCount = GetData<uint32_t>() % AudioFlagVec.size();
189 pipe->routeFlag_ == AudioFlagVec[routeFlagCount];
190 audioPipeManager->IsNormalRecordPipe(pipe);
191 }
192
GetStreamDescByIdFuzzTest()193 void GetStreamDescByIdFuzzTest()
194 {
195 auto audioPipeManager = AudioPipeManager::GetPipeManager();
196 if (audioPipeManager == nullptr) {
197 return;
198 }
199 audioPipeManager->curPipeList_.clear();
200
201 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
202 std::shared_ptr<AudioStreamDescriptor> desc = std::make_shared<AudioStreamDescriptor>();
203 desc->sessionId_ = GetData<uint32_t>();
204 pipeInfo->streamDescriptors_.push_back(desc);
205 audioPipeManager->AddAudioPipeInfo(pipeInfo);
206
207 uint32_t targetSessionId = GetData<uint32_t>();
208 audioPipeManager->GetStreamDescById(targetSessionId);
209 }
210
DumpFuzzTest()211 void DumpFuzzTest()
212 {
213 auto audioPipeManager = AudioPipeManager::GetPipeManager();
214 if (audioPipeManager == nullptr) {
215 return;
216 }
217 std::string dumpString = "";
218 audioPipeManager->Dump(dumpString);
219 }
220
IsModemCommunicationIdExistFuzzTest()221 void IsModemCommunicationIdExistFuzzTest()
222 {
223 auto audioPipeManager = AudioPipeManager::GetPipeManager();
224 if (audioPipeManager == nullptr) {
225 return;
226 }
227 uint32_t sessionId = GetData<uint32_t>();
228 audioPipeManager->IsModemCommunicationIdExist(sessionId);
229 }
230
GetModemCommunicationStreamDescByIdFuzzTest()231 void GetModemCommunicationStreamDescByIdFuzzTest()
232 {
233 auto audioPipeManager = AudioPipeManager::GetPipeManager();
234 if (audioPipeManager == nullptr) {
235 return;
236 }
237 uint32_t sessionId = GetData<uint32_t>();
238 audioPipeManager->modemCommunicationIdMap_.clear();
239 audioPipeManager->GetModemCommunicationStreamDescById(sessionId);
240 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
241 audioPipeManager->modemCommunicationIdMap_.clear();
242 audioPipeManager->AddModemCommunicationId(sessionId, streamDesc);
243 audioPipeManager->GetModemCommunicationStreamDescById(sessionId);
244 }
245
GetPipeinfoByNameAndFlagFuzzTest()246 void GetPipeinfoByNameAndFlagFuzzTest()
247 {
248 auto audioPipeManager = AudioPipeManager::GetPipeManager();
249 audioPipeManager->curPipeList_.clear();
250
251 std::shared_ptr<AudioPipeInfo> pipe1 = std::make_shared<AudioPipeInfo>();
252 pipe1->adapterName_ = "existing_adapter";
253 pipe1->routeFlag_ = 1;
254 audioPipeManager->AddAudioPipeInfo(pipe1);
255
256 std::string targetAdapterName = "existing_adapter";
257 uint32_t targetRouteFlag = 1;
258 audioPipeManager->GetPipeinfoByNameAndFlag(targetAdapterName, targetRouteFlag);
259 }
260
GetAdapterNameBySessionIdFuzzTest()261 void GetAdapterNameBySessionIdFuzzTest()
262 {
263 auto audioPipeManager = AudioPipeManager::GetPipeManager();
264 audioPipeManager->curPipeList_.clear();
265 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
266 pipeInfo->moduleInfo_.name = "TestAdapter";
267 std::shared_ptr<AudioStreamDescriptor> desc = std::make_shared<AudioStreamDescriptor>();
268 desc->sessionId_ = GetData<uint32_t>();
269 desc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
270 desc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
271 pipeInfo->streamDescriptors_.push_back(desc);
272 audioPipeManager->AddAudioPipeInfo(pipeInfo);
273 uint32_t targetSessionId = GetData<uint32_t>();
274
275 audioPipeManager->GetAdapterNameBySessionId(targetSessionId);
276 }
277
GetProcessDeviceInfoBySessionIdFuzzTest()278 void GetProcessDeviceInfoBySessionIdFuzzTest()
279 {
280 auto audioPipeManager = AudioPipeManager::GetPipeManager();
281 audioPipeManager->curPipeList_.clear();
282
283 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
284 std::shared_ptr<AudioStreamDescriptor> desc = std::make_shared<AudioStreamDescriptor>();
285 desc->sessionId_ = GetData<uint32_t>();
286 desc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
287 desc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
288 pipeInfo->streamDescriptors_.push_back(desc);
289 audioPipeManager->AddAudioPipeInfo(pipeInfo);
290
291 uint32_t targetSessionId = GetData<uint32_t>();
292 AudioStreamInfo info;
293 audioPipeManager->GetProcessDeviceInfoBySessionId(targetSessionId, info);
294 }
295
GetAllOutputStreamDescsFuzzTest()296 void GetAllOutputStreamDescsFuzzTest()
297 {
298 auto audioPipeManager = AudioPipeManager::GetPipeManager();
299 audioPipeManager->curPipeList_.clear();
300
301 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
302 pipeInfo->pipeRole_ = PIPE_ROLE_OUTPUT;
303 std::shared_ptr<AudioStreamDescriptor> desc1 = std::make_shared<AudioStreamDescriptor>();
304 std::shared_ptr<AudioStreamDescriptor> desc2 = std::make_shared<AudioStreamDescriptor>();
305 pipeInfo->streamDescriptors_.push_back(desc1);
306 pipeInfo->streamDescriptors_.push_back(desc2);
307
308 audioPipeManager->AddAudioPipeInfo(pipeInfo);
309 audioPipeManager->GetAllOutputStreamDescs();
310 }
311
GetAllInputStreamDescsFuzzTest()312 void GetAllInputStreamDescsFuzzTest()
313 {
314 auto audioPipeManager = AudioPipeManager::GetPipeManager();
315 audioPipeManager->curPipeList_.clear();
316
317 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
318 pipeInfo->pipeRole_ = PIPE_ROLE_INPUT;
319 std::shared_ptr<AudioStreamDescriptor> desc1 = std::make_shared<AudioStreamDescriptor>();
320 std::shared_ptr<AudioStreamDescriptor> desc2 = std::make_shared<AudioStreamDescriptor>();
321 pipeInfo->streamDescriptors_.push_back(desc1);
322 pipeInfo->streamDescriptors_.push_back(desc2);
323
324 audioPipeManager->AddAudioPipeInfo(pipeInfo);
325 audioPipeManager->GetAllInputStreamDescs();
326 }
327
GetStreamDescByIdInnerFuzzTest()328 void GetStreamDescByIdInnerFuzzTest()
329 {
330 auto audioPipeManager = AudioPipeManager::GetPipeManager();
331 audioPipeManager->curPipeList_.clear();
332
333 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
334 std::shared_ptr<AudioStreamDescriptor> desc = std::make_shared<AudioStreamDescriptor>();
335 desc->sessionId_ = GetData<uint32_t>();
336 pipeInfo->streamDescriptors_.push_back(desc);
337 audioPipeManager->AddAudioPipeInfo(pipeInfo);
338
339 uint32_t targetSessionId = GetData<uint32_t>();
340 audioPipeManager->GetStreamDescByIdInner(targetSessionId);
341 }
342
GetStreamCountFuzzTest()343 void GetStreamCountFuzzTest()
344 {
345 auto audioPipeManager = AudioPipeManager::GetPipeManager();
346 audioPipeManager->curPipeList_.clear();
347
348 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
349 pipeInfo->adapterName_ = "existing_adapter";
350 pipeInfo->routeFlag_ = 1;
351 pipeInfo->streamDescriptors_.resize(RESIZENUM);
352 audioPipeManager->AddAudioPipeInfo(pipeInfo);
353
354 std::string targetAdapterName = "existing_adapter";
355 uint32_t targetRouteFlag = 1;
356 audioPipeManager->GetStreamCount(targetAdapterName, targetRouteFlag);
357 }
358
GetPaIndexByIoHandleFuzzTest()359 void GetPaIndexByIoHandleFuzzTest()
360 {
361 auto audioPipeManager = AudioPipeManager::GetPipeManager();
362 audioPipeManager->curPipeList_.clear();
363
364 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
365 pipeInfo->id_ = GetData<uint32_t>();
366 pipeInfo->paIndex_ = GetData<uint32_t>();
367 audioPipeManager->AddAudioPipeInfo(pipeInfo);
368
369 AudioIOHandle targetId = GetData<uint32_t>();
370 audioPipeManager->GetPaIndexByIoHandle(targetId);
371 }
372
UpdateRendererPipeInfosFuzzTest()373 void UpdateRendererPipeInfosFuzzTest()
374 {
375 auto audioPipeManager = AudioPipeManager::GetPipeManager();
376 audioPipeManager->curPipeList_.clear();
377 std::shared_ptr<AudioPipeInfo> inputPipe = std::make_shared<AudioPipeInfo>();
378 inputPipe->pipeRole_ = PIPE_ROLE_INPUT;
379 audioPipeManager->AddAudioPipeInfo(inputPipe);
380
381 std::vector<std::shared_ptr<AudioPipeInfo>> pipeInfos;
382 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
383 newPipe->pipeRole_ = PIPE_ROLE_OUTPUT;
384 pipeInfos.push_back(newPipe);
385
386 audioPipeManager->UpdateRendererPipeInfos(pipeInfos);
387 audioPipeManager->GetPipeList();
388 }
389
UpdateCapturerPipeInfosFuzzTest()390 void UpdateCapturerPipeInfosFuzzTest()
391 {
392 auto audioPipeManager = AudioPipeManager::GetPipeManager();
393 audioPipeManager->curPipeList_.clear();
394 std::shared_ptr<AudioPipeInfo> outputPipe = std::make_shared<AudioPipeInfo>();
395 outputPipe->pipeRole_ = PIPE_ROLE_OUTPUT;
396 audioPipeManager->AddAudioPipeInfo(outputPipe);
397
398 std::vector<std::shared_ptr<AudioPipeInfo>> pipeInfos;
399 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
400 newPipe->pipeRole_ = PIPE_ROLE_INPUT;
401 pipeInfos.push_back(newPipe);
402 audioPipeManager->UpdateCapturerPipeInfos(pipeInfos);
403
404 audioPipeManager->GetPipeList();
405 }
406
PcmOffloadSessionCountFuzzTest()407 void PcmOffloadSessionCountFuzzTest()
408 {
409 auto audioPipeManager = AudioPipeManager::GetPipeManager();
410 audioPipeManager->curPipeList_.clear();
411 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
412 pipeInfo->routeFlag_ = AUDIO_OUTPUT_FLAG_LOWPOWER;
413 pipeInfo->streamDescriptors_.resize(RESIZENUM);
414 audioPipeManager->AddAudioPipeInfo(pipeInfo);
415
416 audioPipeManager->PcmOffloadSessionCount();
417 }
418
AddModemCommunicationIdFuzzTest()419 void AddModemCommunicationIdFuzzTest()
420 {
421 auto audioPipeManager = AudioPipeManager::GetPipeManager();
422 uint32_t sessionId = 99999;
423 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
424 audioPipeManager->modemCommunicationIdMap_.clear();
425 audioPipeManager->AddModemCommunicationId(sessionId, streamDesc);
426
427 audioPipeManager->GetModemCommunicationMap();
428 }
429
RemoveModemCommunicationIdFuzzTest()430 void RemoveModemCommunicationIdFuzzTest()
431 {
432 auto audioPipeManager = AudioPipeManager::GetPipeManager();
433 uint32_t sessionId = 12345;
434 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
435
436 audioPipeManager->modemCommunicationIdMap_[sessionId] = streamDesc;
437 audioPipeManager->RemoveModemCommunicationId(sessionId);
438 audioPipeManager->GetModemCommunicationMap();
439 }
440
GetNormalSourceInfoFuzzTest()441 void GetNormalSourceInfoFuzzTest()
442 {
443 auto audioPipeManager = AudioPipeManager::GetPipeManager();
444 audioPipeManager->curPipeList_.clear();
445
446 std::shared_ptr<AudioPipeInfo> bluetoothPipe = std::make_shared<AudioPipeInfo>();
447 bluetoothPipe->moduleInfo_.name = PRIMARY_MIC;
448 bluetoothPipe->routeFlag_ = AUDIO_INPUT_FLAG_NORMAL;
449 audioPipeManager->AddAudioPipeInfo(bluetoothPipe);
450
451 bool isEcFeatureEnable = true;
452 audioPipeManager->GetNormalSourceInfo(isEcFeatureEnable);
453 }
454
GetPipeByModuleAndFlagFuzzTest()455 void GetPipeByModuleAndFlagFuzzTest()
456 {
457 auto audioPipeManager = AudioPipeManager::GetPipeManager();
458 audioPipeManager->curPipeList_.clear();
459
460 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
461 pipeInfo->moduleInfo_.name = "EXISTING_MODULE";
462 pipeInfo->routeFlag_ = 1;
463 audioPipeManager->AddAudioPipeInfo(pipeInfo);
464
465 std::string targetModuleName = "NON_EXISTING_MODULE";
466 uint32_t targetRouteFlag = 1;
467 audioPipeManager->GetPipeByModuleAndFlag(targetModuleName, targetRouteFlag);
468 }
469
470 TestFuncs g_testFuncs[TESTSIZE] = {
471 RemoveAudioPipeInfoFuzzTest,
472 RemoveAudioPipeInfoByIdFuzzTest,
473 UpdateAudioPipeInfoFuzzTest,
474 IsSamePipeFuzzTest,
475 GetUnusedPipeFuzzTest,
476 IsSpecialPipeFuzzTest,
477 IsNormalRecordPipeFuzzTest,
478 GetStreamDescByIdFuzzTest,
479 DumpFuzzTest,
480 IsModemCommunicationIdExistFuzzTest,
481 GetModemCommunicationStreamDescByIdFuzzTest,
482 GetPipeinfoByNameAndFlagFuzzTest,
483 GetAdapterNameBySessionIdFuzzTest,
484 GetProcessDeviceInfoBySessionIdFuzzTest,
485 GetAllOutputStreamDescsFuzzTest,
486 GetAllInputStreamDescsFuzzTest,
487 GetStreamDescByIdInnerFuzzTest,
488 GetStreamCountFuzzTest,
489 GetPaIndexByIoHandleFuzzTest,
490 UpdateRendererPipeInfosFuzzTest,
491 UpdateCapturerPipeInfosFuzzTest,
492 PcmOffloadSessionCountFuzzTest,
493 AddModemCommunicationIdFuzzTest,
494 RemoveModemCommunicationIdFuzzTest,
495 GetNormalSourceInfoFuzzTest,
496 GetPipeByModuleAndFlagFuzzTest,
497 };
498
FuzzTest(const uint8_t * rawData,size_t size)499 bool FuzzTest(const uint8_t* rawData, size_t size)
500 {
501 if (rawData == nullptr) {
502 return false;
503 }
504
505 // initialize data
506 RAW_DATA = rawData;
507 g_dataSize = size;
508 g_pos = 0;
509
510 uint32_t code = GetData<uint32_t>();
511 uint32_t len = GetArrLength(g_testFuncs);
512 if (len > 0) {
513 g_testFuncs[code % len]();
514 } else {
515 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
516 }
517
518 return true;
519 }
520 } // namespace AudioStandard
521 } // namesapce OHOS
522
523 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)524 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
525 {
526 if (size < OHOS::AudioStandard::THRESHOLD) {
527 return 0;
528 }
529
530 OHOS::AudioStandard::FuzzTest(data, size);
531 return 0;
532 }
533