1 /*
2 * Copyright (c) 2024-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 "audio_log.h"
17 #include "sle_audio_device_manager.h"
18
19 using namespace std;
20
21 namespace OHOS {
22 namespace AudioStandard {
23
24 static const uint8_t* RAW_DATA = nullptr;
25 static size_t g_dataSize = 0;
26 static size_t g_pos;
27 const size_t THRESHOLD = 10;
28 typedef void (*TestPtr)();
29
30 const vector<StreamUsage> g_testAudioStreamUsages = {
31 STREAM_USAGE_INVALID,
32 STREAM_USAGE_UNKNOWN,
33 STREAM_USAGE_MEDIA,
34 STREAM_USAGE_MUSIC,
35 STREAM_USAGE_VOICE_COMMUNICATION,
36 STREAM_USAGE_VOICE_ASSISTANT,
37 STREAM_USAGE_ALARM,
38 STREAM_USAGE_VOICE_MESSAGE,
39 STREAM_USAGE_NOTIFICATION_RINGTONE,
40 STREAM_USAGE_RINGTONE,
41 STREAM_USAGE_NOTIFICATION,
42 STREAM_USAGE_ACCESSIBILITY,
43 STREAM_USAGE_SYSTEM,
44 STREAM_USAGE_MOVIE,
45 STREAM_USAGE_GAME,
46 STREAM_USAGE_AUDIOBOOK,
47 STREAM_USAGE_NAVIGATION,
48 STREAM_USAGE_DTMF,
49 STREAM_USAGE_ENFORCED_TONE,
50 STREAM_USAGE_ULTRASONIC,
51 STREAM_USAGE_VIDEO_COMMUNICATION,
52 STREAM_USAGE_RANGING,
53 STREAM_USAGE_VOICE_MODEM_COMMUNICATION,
54 STREAM_USAGE_VOICE_RINGTONE,
55 STREAM_USAGE_VOICE_CALL_ASSISTANT,
56 STREAM_USAGE_MAX,
57 };
58
59 const vector<SourceType> g_testSourceTypes = {
60 SOURCE_TYPE_INVALID,
61 SOURCE_TYPE_MIC,
62 SOURCE_TYPE_VOICE_RECOGNITION,
63 SOURCE_TYPE_PLAYBACK_CAPTURE,
64 SOURCE_TYPE_WAKEUP,
65 SOURCE_TYPE_VOICE_CALL,
66 SOURCE_TYPE_VOICE_COMMUNICATION,
67 SOURCE_TYPE_ULTRASONIC,
68 SOURCE_TYPE_VIRTUAL_CAPTURE,
69 SOURCE_TYPE_VOICE_MESSAGE,
70 SOURCE_TYPE_REMOTE_CAST,
71 SOURCE_TYPE_VOICE_TRANSCRIPTION,
72 SOURCE_TYPE_CAMCORDER,
73 SOURCE_TYPE_UNPROCESSED,
74 SOURCE_TYPE_EC,
75 SOURCE_TYPE_MIC_REF,
76 SOURCE_TYPE_LIVE,
77 SOURCE_TYPE_MAX,
78 };
79
80 const vector<AudioStreamType> g_testAudioStreamTypes = {
81 STREAM_DEFAULT,
82 STREAM_VOICE_CALL,
83 STREAM_MUSIC,
84 STREAM_RING,
85 STREAM_MEDIA,
86 STREAM_VOICE_ASSISTANT,
87 STREAM_SYSTEM,
88 STREAM_ALARM,
89 STREAM_NOTIFICATION,
90 STREAM_BLUETOOTH_SCO,
91 STREAM_ENFORCED_AUDIBLE,
92 STREAM_DTMF,
93 STREAM_TTS,
94 STREAM_ACCESSIBILITY,
95 STREAM_RECORDING,
96 STREAM_MOVIE,
97 STREAM_GAME,
98 STREAM_SPEECH,
99 STREAM_SYSTEM_ENFORCED,
100 STREAM_ULTRASONIC,
101 STREAM_WAKEUP,
102 STREAM_VOICE_MESSAGE,
103 STREAM_NAVIGATION,
104 STREAM_INTERNAL_FORCE_STOP,
105 STREAM_SOURCE_VOICE_CALL,
106 STREAM_VOICE_COMMUNICATION,
107 STREAM_VOICE_RING,
108 STREAM_VOICE_CALL_ASSISTANT,
109 STREAM_CAMCORDER,
110 STREAM_APP,
111 STREAM_TYPE_MAX,
112 STREAM_ALL,
113 };
114
115 const vector<SleAudioStreamType> g_testSleAudioStreamTypes = {
116 SLE_AUDIO_STREAM_NONE,
117 SLE_AUDIO_STREAM_UNDEFINED,
118 SLE_AUDIO_STREAM_MUSIC,
119 SLE_AUDIO_STREAM_VOICE_CALL,
120 SLE_AUDIO_STREAM_VOICE_ASSISTANT,
121 SLE_AUDIO_STREAM_RING,
122 SLE_AUDIO_STREAM_VOIP,
123 SLE_AUDIO_STREAM_GAME,
124 SLE_AUDIO_STREAM_RECORD,
125 SLE_AUDIO_STREAM_ALERT,
126 SLE_AUDIO_STREAM_VIDEO,
127 SLE_AUDIO_STREAM_GUID,
128 };
129
130 const vector<DeviceType> g_testDeviceTypes = {
131 DEVICE_TYPE_NONE,
132 DEVICE_TYPE_INVALID,
133 DEVICE_TYPE_EARPIECE,
134 DEVICE_TYPE_SPEAKER,
135 DEVICE_TYPE_WIRED_HEADSET,
136 DEVICE_TYPE_WIRED_HEADPHONES,
137 DEVICE_TYPE_BLUETOOTH_SCO,
138 DEVICE_TYPE_BLUETOOTH_A2DP,
139 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
140 DEVICE_TYPE_MIC,
141 DEVICE_TYPE_WAKEUP,
142 DEVICE_TYPE_USB_HEADSET,
143 DEVICE_TYPE_DP,
144 DEVICE_TYPE_REMOTE_CAST,
145 DEVICE_TYPE_USB_DEVICE,
146 DEVICE_TYPE_ACCESSORY,
147 DEVICE_TYPE_REMOTE_DAUDIO,
148 DEVICE_TYPE_HDMI,
149 DEVICE_TYPE_LINE_DIGITAL,
150 DEVICE_TYPE_NEARLINK,
151 DEVICE_TYPE_NEARLINK_IN,
152 DEVICE_TYPE_FILE_SINK,
153 DEVICE_TYPE_FILE_SOURCE,
154 DEVICE_TYPE_EXTERN_CABLE,
155 DEVICE_TYPE_DEFAULT,
156 DEVICE_TYPE_USB_ARM_HEADSET,
157 DEVICE_TYPE_MAX
158 };
159
160 class IStandardSleAudioOperationCallbackFuzzTest : public IRemoteStub<IStandardSleAudioOperationCallback> {
161 public:
IStandardSleAudioOperationCallbackFuzzTest()162 IStandardSleAudioOperationCallbackFuzzTest() {}
~IStandardSleAudioOperationCallbackFuzzTest()163 virtual ~IStandardSleAudioOperationCallbackFuzzTest() {}
164
GetSleAudioDeviceList(std::vector<AudioDeviceDescriptor> & devices)165 void GetSleAudioDeviceList(std::vector<AudioDeviceDescriptor> &devices) override {}
GetSleVirtualAudioDeviceList(std::vector<AudioDeviceDescriptor> & devices)166 void GetSleVirtualAudioDeviceList(std::vector<AudioDeviceDescriptor> &devices) override {}
IsInBandRingOpen(const std::string & device)167 bool IsInBandRingOpen(const std::string &device) override
168 {
169 return false;
170 }
GetSupportStreamType(const std::string & device)171 uint32_t GetSupportStreamType(const std::string &device) override
172 {
173 return 0;
174 }
SetActiveSinkDevice(const std::string & device,uint32_t streamType)175 int32_t SetActiveSinkDevice(const std::string &device, uint32_t streamType) override
176 {
177 return 0;
178 }
StartPlaying(const std::string & device,uint32_t streamType)179 int32_t StartPlaying(const std::string &device, uint32_t streamType) override
180 {
181 return 0;
182 }
StopPlaying(const std::string & device,uint32_t streamType)183 int32_t StopPlaying(const std::string &device, uint32_t streamType) override
184 {
185 return 0;
186 }
ConnectAllowedProfiles(const std::string & remoteAddr)187 int32_t ConnectAllowedProfiles(const std::string &remoteAddr) override
188 {
189 return 0;
190 }
SetDeviceAbsVolume(const std::string & remoteAddr,uint32_t volume,uint32_t streamType)191 int32_t SetDeviceAbsVolume(const std::string &remoteAddr, uint32_t volume, uint32_t streamType) override
192 {
193 return 0;
194 }
SendUserSelection(const std::string & device,uint32_t streamType)195 int32_t SendUserSelection(const std::string &device, uint32_t streamType) override
196 {
197 return 0;
198 }
199
GetRenderPosition(const std::string & device,uint32_t & delayValue)200 int32_t GetRenderPosition(const std::string &device, uint32_t &delayValue) override
201 {
202 delayValue = 0;
203 return 0;
204 }
205 };
206
207 template<class T>
GetArrLength(T & arr)208 uint32_t GetArrLength(T& arr)
209 {
210 if (arr == nullptr) {
211 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
212 return 0;
213 }
214 return sizeof(arr) / sizeof(arr[0]);
215 }
216
217 template<class T>
GetData()218 T GetData()
219 {
220 T object {};
221 size_t objectSize = sizeof(object);
222 if (g_dataSize < g_pos) {
223 return object;
224 }
225 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
226 return object;
227 }
228 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
229 if (ret != EOK) {
230 return {};
231 }
232 g_pos += objectSize;
233 return object;
234 }
235
SleAudioDeviceManagerGetSleAudioDeviceListFuzzTest()236 void SleAudioDeviceManagerGetSleAudioDeviceListFuzzTest()
237 {
238 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
239 if (manager.callback_ == nullptr) {
240 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
241 manager.SetSleAudioOperationCallback(callback);
242 }
243 std::vector<AudioDeviceDescriptor> devices;
244 manager.GetSleAudioDeviceList(devices);
245 }
246
SleAudioDeviceManagerGetSleVirtualAudioDeviceListFuzzTest()247 void SleAudioDeviceManagerGetSleVirtualAudioDeviceListFuzzTest()
248 {
249 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
250 if (manager.callback_ == nullptr) {
251 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
252 manager.SetSleAudioOperationCallback(callback);
253 }
254 std::vector<AudioDeviceDescriptor> devices;
255 manager.GetSleVirtualAudioDeviceList(devices);
256 }
257
SleAudioDeviceManagerIsInBandRingOpenFuzzTest()258 void SleAudioDeviceManagerIsInBandRingOpenFuzzTest()
259 {
260 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
261 if (manager.callback_ == nullptr) {
262 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
263 manager.SetSleAudioOperationCallback(callback);
264 }
265 std::string device;
266 manager.IsInBandRingOpen(device);
267 }
268
SleAudioDeviceManagerGetSupportStreamTypeFuzzTest()269 void SleAudioDeviceManagerGetSupportStreamTypeFuzzTest()
270 {
271 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
272 if (manager.callback_ == nullptr) {
273 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
274 manager.SetSleAudioOperationCallback(callback);
275 }
276 std::string device;
277 manager.GetSupportStreamType(device);
278 }
279
SleAudioDeviceManagerSetActiveDeviceFuzzTest()280 void SleAudioDeviceManagerSetActiveDeviceFuzzTest()
281 {
282 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
283 if (manager.callback_ == nullptr) {
284 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
285 manager.SetSleAudioOperationCallback(callback);
286 }
287 AudioDeviceDescriptor deviceDesc;
288 if (g_testAudioStreamUsages.size() == 0 || g_testSourceTypes.size() == 0) {
289 return;
290 }
291 StreamUsage streamUsage = g_testAudioStreamUsages[GetData<uint32_t>() % g_testAudioStreamUsages.size()];
292 manager.SetActiveDevice(deviceDesc, streamUsage);
293 AudioDeviceDescriptor deviceDescBySource;
294 SourceType sourceType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
295 manager.SetActiveDevice(deviceDescBySource, sourceType);
296 }
297
SleAudioDeviceManagerStartPlayingFuzzTest()298 void SleAudioDeviceManagerStartPlayingFuzzTest()
299 {
300 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
301 if (manager.callback_ == nullptr) {
302 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
303 manager.SetSleAudioOperationCallback(callback);
304 }
305 AudioDeviceDescriptor deviceDesc;
306 if (g_testAudioStreamUsages.size() == 0 || g_testSourceTypes.size() == 0) {
307 return;
308 }
309 StreamUsage streamUsage = g_testAudioStreamUsages[GetData<uint32_t>() % g_testAudioStreamUsages.size()];
310 manager.StartPlaying(deviceDesc, streamUsage);
311 AudioDeviceDescriptor deviceDescBySource;
312 SourceType sourceType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
313 manager.StartPlaying(deviceDescBySource, sourceType);
314 }
315
SleAudioDeviceManagerStopPlayingFuzzTest()316 void SleAudioDeviceManagerStopPlayingFuzzTest()
317 {
318 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
319 if (manager.callback_ == nullptr) {
320 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
321 manager.SetSleAudioOperationCallback(callback);
322 }
323 AudioDeviceDescriptor deviceDesc;
324 if (g_testAudioStreamUsages.size() == 0 || g_testSourceTypes.size() == 0) {
325 return;
326 }
327 StreamUsage streamUsage = g_testAudioStreamUsages[GetData<uint32_t>() % g_testAudioStreamUsages.size()];
328 manager.StopPlaying(deviceDesc, streamUsage);
329 AudioDeviceDescriptor deviceDescBySource;
330 SourceType sourceType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
331 manager.StopPlaying(deviceDescBySource, sourceType);
332 }
333
SleAudioDeviceManagerConnectAllowedProfilesFuzzTest()334 void SleAudioDeviceManagerConnectAllowedProfilesFuzzTest()
335 {
336 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
337 if (manager.callback_ == nullptr) {
338 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
339 manager.SetSleAudioOperationCallback(callback);
340 }
341 std::string remoteAddr;
342 manager.ConnectAllowedProfiles(remoteAddr);
343 }
344
SleAudioDeviceManagerSetDeviceAbsVolumeFuzzTest()345 void SleAudioDeviceManagerSetDeviceAbsVolumeFuzzTest()
346 {
347 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
348 if (manager.callback_ == nullptr) {
349 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
350 manager.SetSleAudioOperationCallback(callback);
351 }
352 std::string device;
353 if (g_testAudioStreamTypes.size() == 0) {
354 return;
355 }
356 AudioStreamType streamType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
357 int32_t volume = GetData<int32_t>();
358 manager.SetDeviceAbsVolume(device, streamType, volume);
359 }
360
SleAudioDeviceManagerSendUserSelectionFuzzTest()361 void SleAudioDeviceManagerSendUserSelectionFuzzTest()
362 {
363 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
364 if (manager.callback_ == nullptr) {
365 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
366 manager.SetSleAudioOperationCallback(callback);
367 }
368 AudioDeviceDescriptor deviceDesc;
369 if (g_testAudioStreamUsages.size() == 0 || g_testSourceTypes.size() == 0) {
370 return;
371 }
372 StreamUsage streamUsage = g_testAudioStreamUsages[GetData<uint32_t>() % g_testAudioStreamUsages.size()];
373 manager.SendUserSelection(deviceDesc, streamUsage);
374 AudioDeviceDescriptor deviceDescBySource;
375 SourceType sourceType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
376 manager.SendUserSelection(deviceDescBySource, sourceType);
377 }
378
SleAudioDeviceManagerGetStreamUsagesBySleStreamTypeFuzzTest()379 void SleAudioDeviceManagerGetStreamUsagesBySleStreamTypeFuzzTest()
380 {
381 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
382 if (manager.callback_ == nullptr) {
383 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
384 manager.SetSleAudioOperationCallback(callback);
385 }
386
387 if (g_testSleAudioStreamTypes.size() == 0) {
388 return;
389 }
390 uint32_t streamType = static_cast<uint32_t>(
391 g_testSleAudioStreamTypes[GetData<uint32_t>() % g_testSleAudioStreamTypes.size()]);
392 manager.GetStreamUsagesBySleStreamType(streamType);
393 }
394
SleAudioDeviceManagerGetSourceTypesBySleStreamTypeFuzzTest()395 void SleAudioDeviceManagerGetSourceTypesBySleStreamTypeFuzzTest()
396 {
397 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
398 if (manager.callback_ == nullptr) {
399 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
400 manager.SetSleAudioOperationCallback(callback);
401 }
402
403 if (g_testSleAudioStreamTypes.size() == 0) {
404 return;
405 }
406 uint32_t streamType = static_cast<uint32_t>(
407 g_testSleAudioStreamTypes[GetData<uint32_t>() % g_testSleAudioStreamTypes.size()]);
408 manager.GetSourceTypesBySleStreamType(streamType);
409 }
410
SleAudioDeviceManagerAddNearlinkDeviceFuzzTest()411 void SleAudioDeviceManagerAddNearlinkDeviceFuzzTest()
412 {
413 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
414 if (manager.callback_ == nullptr) {
415 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
416 manager.SetSleAudioOperationCallback(callback);
417 }
418
419 AudioDeviceDescriptor deviceDesc;
420 if (g_testDeviceTypes.size() == 0) {
421 return;
422 }
423 deviceDesc.deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
424 manager.AddNearlinkDevice(deviceDesc);
425 manager.RemoveNearlinkDevice(deviceDesc);
426 }
427
SleAudioDeviceManagerUpdateSleStreamTypeCountFuzzTest()428 void SleAudioDeviceManagerUpdateSleStreamTypeCountFuzzTest()
429 {
430 static const vector<AudioStreamStatus> testAudioStreamStatuses = {
431 STREAM_STATUS_NEW,
432 STREAM_STATUS_STARTED,
433 STREAM_STATUS_PAUSED,
434 STREAM_STATUS_STOPPED,
435 STREAM_STATUS_RELEASED,
436 };
437 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
438 if (manager.callback_ == nullptr) {
439 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
440 manager.SetSleAudioOperationCallback(callback);
441 }
442 std::shared_ptr<AudioStreamDescriptor> streamDesc = make_shared<AudioStreamDescriptor>();
443 bool isRemoved = GetData<bool>();
444 std::shared_ptr<AudioDeviceDescriptor> deviceDesc = make_shared<AudioDeviceDescriptor>();
445 if (g_testDeviceTypes.size() == 0 || testAudioStreamStatuses.size() == 0) {
446 return;
447 }
448 bool isDeviceType = GetData<bool>();
449 if (isDeviceType) {
450 deviceDesc->deviceType_ = DEVICE_TYPE_NEARLINK;
451 streamDesc->audioMode_ = AUDIO_MODE_RECORD;
452 } else {
453 deviceDesc->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
454 streamDesc->audioMode_ = AUDIO_MODE_PLAYBACK;
455 }
456 streamDesc->newDeviceDescs_.push_back(deviceDesc);
457 streamDesc->oldDeviceDescs_.push_back(deviceDesc);
458 streamDesc->streamStatus_ = testAudioStreamStatuses[GetData<uint32_t>() % testAudioStreamStatuses.size()];
459
460 manager.UpdateSleStreamTypeCount(streamDesc, isRemoved);
461 }
462
SleAudioDeviceManagerSetNearlinkDeviceMuteFuzzTest()463 void SleAudioDeviceManagerSetNearlinkDeviceMuteFuzzTest()
464 {
465 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
466 if (manager.callback_ == nullptr) {
467 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
468 manager.SetSleAudioOperationCallback(callback);
469 }
470
471 if (g_testAudioStreamTypes.size() == 0) {
472 return;
473 }
474 SleVolumeConfigInfo configInfo;
475 std::pair<SleVolumeConfigInfo, SleVolumeConfigInfo> pairConfigInfo = make_pair(configInfo, configInfo);
476 std::string device = "test_device";
477 manager.deviceVolumeConfigInfo_.insert(make_pair(device, pairConfigInfo));
478 AudioStreamType streamType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
479 bool isMute = GetData<bool>();
480 manager.SetNearlinkDeviceMute(device, streamType, isMute);
481 }
482
SleAudioDeviceManagerSetNearlinkDeviceVolumeLevelFuzzTest()483 void SleAudioDeviceManagerSetNearlinkDeviceVolumeLevelFuzzTest()
484 {
485 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
486 if (manager.callback_ == nullptr) {
487 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
488 manager.SetSleAudioOperationCallback(callback);
489 }
490
491 SleVolumeConfigInfo configInfo;
492 std::pair<SleVolumeConfigInfo, SleVolumeConfigInfo> pairConfigInfo = make_pair(configInfo, configInfo);
493 std::string device = "test_device";
494 manager.deviceVolumeConfigInfo_.insert(make_pair(device, pairConfigInfo));
495 if (g_testAudioStreamTypes.size() == 0) {
496 return;
497 }
498 AudioStreamType streamType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
499 int32_t volumeLevel = GetData<int32_t>();
500 manager.SetNearlinkDeviceVolumeLevel(device, streamType, volumeLevel);
501 }
502
SleAudioDeviceManagerGetVolumeLevelByVolumeTypeFuzzTest()503 void SleAudioDeviceManagerGetVolumeLevelByVolumeTypeFuzzTest()
504 {
505 SleAudioDeviceManager &manager = SleAudioDeviceManager::GetInstance();
506 if (manager.callback_ == nullptr) {
507 sptr<IStandardSleAudioOperationCallback> callback = new IStandardSleAudioOperationCallbackFuzzTest();
508 manager.SetSleAudioOperationCallback(callback);
509 }
510
511 SleVolumeConfigInfo configInfo;
512 std::pair<SleVolumeConfigInfo, SleVolumeConfigInfo> pairConfigInfo = make_pair(configInfo, configInfo);
513 std::string device = "test_mac_address";
514 manager.deviceVolumeConfigInfo_.insert(make_pair(device, pairConfigInfo));
515 if (g_testAudioStreamTypes.size() == 0) {
516 return;
517 }
518 AudioVolumeType volumeType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
519 AudioDeviceDescriptor deviceDesc;
520 deviceDesc.macAddress_ = "test_mac_address";
521 manager.GetVolumeLevelByVolumeType(volumeType, deviceDesc);
522 }
523
524 TestPtr g_testPtrs[] = {
525 SleAudioDeviceManagerGetSleAudioDeviceListFuzzTest,
526 SleAudioDeviceManagerGetSleVirtualAudioDeviceListFuzzTest,
527 SleAudioDeviceManagerIsInBandRingOpenFuzzTest,
528 SleAudioDeviceManagerGetSupportStreamTypeFuzzTest,
529 SleAudioDeviceManagerSetActiveDeviceFuzzTest,
530 SleAudioDeviceManagerStartPlayingFuzzTest,
531 SleAudioDeviceManagerStopPlayingFuzzTest,
532 SleAudioDeviceManagerConnectAllowedProfilesFuzzTest,
533 SleAudioDeviceManagerSetDeviceAbsVolumeFuzzTest,
534 SleAudioDeviceManagerSendUserSelectionFuzzTest,
535 SleAudioDeviceManagerGetStreamUsagesBySleStreamTypeFuzzTest,
536 SleAudioDeviceManagerGetSourceTypesBySleStreamTypeFuzzTest,
537 SleAudioDeviceManagerAddNearlinkDeviceFuzzTest,
538 SleAudioDeviceManagerUpdateSleStreamTypeCountFuzzTest,
539 SleAudioDeviceManagerSetNearlinkDeviceMuteFuzzTest,
540 SleAudioDeviceManagerSetNearlinkDeviceVolumeLevelFuzzTest,
541 SleAudioDeviceManagerGetVolumeLevelByVolumeTypeFuzzTest,
542 };
543
FuzzTest(const uint8_t * rawData,size_t size)544 void FuzzTest(const uint8_t* rawData, size_t size)
545 {
546 if (rawData == nullptr) {
547 return;
548 }
549
550 RAW_DATA = rawData;
551 g_dataSize = size;
552 g_pos = 0;
553
554 uint32_t code = GetData<uint32_t>();
555 uint32_t len = GetArrLength(g_testPtrs);
556 if (len > 0) {
557 g_testPtrs[code % len]();
558 } else {
559 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
560 }
561 return;
562 }
563
564 } // namespace AudioStandard
565 } // namesapce OHOS
566
567 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)568 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
569 {
570 if (size < OHOS::AudioStandard::THRESHOLD) {
571 return 0;
572 }
573 OHOS::AudioStandard::FuzzTest(data, size);
574 return 0;
575 }