stack/test/fuzzers/a2dp/codec/a2dpCodecConfigFuzzFunctions.h

/*
 * Copyright 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef BT_STACK_FUZZ_A2DP_CODECCONFIG_FUNCTIONS_H_
#define BT_STACK_FUZZ_A2DP_CODECCONFIG_FUNCTIONS_H_

#include <fuzzer/FuzzedDataProvider.h>
#include <vector>
#include "a2dp_codec_api.h"
#include "fuzzers/a2dp/codec/a2dpCodecHelperFunctions.h"
#include "fuzzers/a2dp/codec/a2dpCodecInfoFuzzFunctions.h"
#include "fuzzers/common/commonFuzzHelpers.h"

#include "fuzzers/a2dp/codec/a2dpCodecConfigFuzzHelpers.h"

/* This is a vector of lambda functions the fuzzer will pull from.
 *  This is done so new functions can be added to the fuzzer easily
 *  without requiring modifications to the main fuzzer file. This also
 *  allows multiple fuzzers to include this file, if functionality is needed.
 */
std::vector<std::function<void(FuzzedDataProvider*)>>
    a2dp_codec_config_operations = {
        // createCodec
        [](FuzzedDataProvider* fdp) -> void {
          // Generate our arguments
          btav_a2dp_codec_index_t codec_index = getArbitraryBtavCodecIndex(fdp);
          btav_a2dp_codec_priority_t codec_priority =
              getArbitraryBtavCodecPriority(fdp);
          // Create our new codec
          std::shared_ptr<A2dpCodecConfig> codec_config(
              A2dpCodecConfig::createCodec(codec_index, codec_priority));
          // Push it to our vector
          if (codec_config) {
            a2dp_codec_config_vect.push_back(codec_config);
          }
        },

        // A2dpCodecConfig Destructor
        [](FuzzedDataProvider* fdp) -> void {
          if (a2dp_codec_config_vect.empty()) {
            return;
          }
          // Get random vector index
          size_t index = fdp->ConsumeIntegralInRange<size_t>(
              0, a2dp_codec_config_vect.size() - 1);
          // Remove from vector
          a2dp_codec_config_vect.erase(a2dp_codec_config_vect.begin() + index);
        },

        // codecIndex
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->codecIndex();
        },

        // name
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->name();
        },

        // codecPriority
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->codecPriority();
        },

        // getCodecSpecificConfig
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          tBT_A2DP_OFFLOAD a2dp_offload = generateArbitrarytA2dpOffload(fdp);
          codec_config->getCodecSpecificConfig(&a2dp_offload);
        },

        // getTrackBitRate
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->getTrackBitRate();
        },

        // copyOutOtaCodecConfig
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          uint8_t* codec_info =
              getArbitraryVectorElement(fdp, a2dp_codec_info_vect, true);
          codec_config->copyOutOtaCodecConfig(codec_info);
        },

        // getCodecConfig
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->getCodecConfig();
        },

        // getCodecCapability
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->getCodecCapability();
        },

        // getCodecLocalCapability
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->getCodecLocalCapability();
        },

        // getCodecSelectableCapability
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->getCodecSelectableCapability();
        },

        // getCodecUserConfig
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->getCodecUserConfig();
        },

        // getCodecAudioConfig
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->getCodecAudioConfig();
        },

        // getAudioBitsPerSample
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          codec_config->getAudioBitsPerSample();
        },

        // getAudioBitsPerSample
        [](FuzzedDataProvider* fdp) -> void {
          std::shared_ptr<A2dpCodecConfig> codec_config(
              getArbitraryVectorElement(fdp, a2dp_codec_config_vect, false));
          if (codec_config == nullptr) {
            return;
          }

          const btav_a2dp_codec_config_t btav_codec_config =
              getArbitraryBtavCodecConfig(fdp);
          codec_config->isCodecConfigEmpty(btav_codec_config);
        },

        // Dependency calling: CodecInfo
        [](FuzzedDataProvider* fdp) -> void {
          callArbitraryCodecInfoFunction(fdp, a2dp_codec_info_operations);
        }};

#endif  // BT_STACK_FUZZ_A2DP_CODECCONFIG_FUNCTIONS_H_