Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bb117a6b authored by Mikhail Naganov's avatar Mikhail Naganov Committed by Automerger Merge Worker
Browse files

audio VTS: Refactor test parameter generation for I/O streams am: 1e703f18 am: a4c937fe 

Original change: https://googleplex-android-review.googlesource.com/c/platform/hardware/interfaces/+/19340459



Change-Id: I6c5e6a560ef14ea202f8bc94c6a829c456395c8d
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 691b3317 a4c937fe

audio/core/all-versions/vts/functional/7.0/AudioPrimaryHidlHalTest.cpp

+7 −43
Original line number Diff line number Diff line
@@ -517,20 +517,10 @@ class PcmOnlyConfigOutputStreamTest : public OutputStreamTest { 
    }



    bool canQueryPresentationPosition() const {

        auto maybeSinkAddress =

                getCachedPolicyConfig().getSinkDeviceForMixPort(getDeviceName(), getMixPortName());

        // Returning 'true' when no sink is found so the test can fail later with a more clear

        // problem description.

        return !maybeSinkAddress.has_value() ||

               !xsd::isTelephonyDevice(maybeSinkAddress.value().deviceType);

        return !xsd::isTelephonyDevice(address.deviceType);

    }



    void createPatchIfNeeded() {

        auto maybeSinkAddress =

                getCachedPolicyConfig().getSinkDeviceForMixPort(getDeviceName(), getMixPortName());

        ASSERT_TRUE(maybeSinkAddress.has_value())

                << "No sink device found for mix port " << getMixPortName() << " (module "

                << getDeviceName() << ")";

        if (areAudioPatchesSupported()) {

            AudioPortConfig source;

            source.base.format.value(getConfig().base.format);
@@ -540,13 +530,13 @@ class PcmOnlyConfigOutputStreamTest : public OutputStreamTest { 
            source.ext.mix().ioHandle = helper.getIoHandle();

            source.ext.mix().useCase.stream({});

            AudioPortConfig sink;

            sink.ext.device(maybeSinkAddress.value());

            sink.ext.device(address);

            EXPECT_OK(getDevice()->createAudioPatch(hidl_vec<AudioPortConfig>{source},

                                                    hidl_vec<AudioPortConfig>{sink},

                                                    returnIn(res, mPatchHandle)));

            mHasPatch = res == Result::OK;

        } else {

            EXPECT_OK(stream->setDevices({maybeSinkAddress.value()}));

            EXPECT_OK(stream->setDevices({address}));

        }

    }
@@ -556,10 +546,6 @@ class PcmOnlyConfigOutputStreamTest : public OutputStreamTest { 
                EXPECT_OK(getDevice()->releaseAudioPatch(mPatchHandle));

                mHasPatch = false;

            }

        } else {

            if (stream) {

                EXPECT_OK(stream->setDevices({address}));

            }

        }

    }
@@ -691,24 +677,12 @@ class PcmOnlyConfigInputStreamTest : public InputStreamTest { 
        InputStreamTest::TearDown();

    }



    bool canQueryCapturePosition() const {

        auto maybeSourceAddress = getCachedPolicyConfig().getSourceDeviceForMixPort(

                getDeviceName(), getMixPortName());

        // Returning 'true' when no source is found so the test can fail later with a more clear

        // problem description.

        return !maybeSourceAddress.has_value() ||

               !xsd::isTelephonyDevice(maybeSourceAddress.value().deviceType);

    }

    bool canQueryCapturePosition() const { return !xsd::isTelephonyDevice(address.deviceType); }



    void createPatchIfNeeded() {

        auto maybeSourceAddress = getCachedPolicyConfig().getSourceDeviceForMixPort(

                getDeviceName(), getMixPortName());

        ASSERT_TRUE(maybeSourceAddress.has_value())

                << "No source device found for mix port " << getMixPortName() << " (module "

                << getDeviceName() << ")";

        if (areAudioPatchesSupported()) {

            AudioPortConfig source;

            source.ext.device(maybeSourceAddress.value());

            source.ext.device(address);

            AudioPortConfig sink;

            sink.base.format.value(getConfig().base.format);

            sink.base.sampleRateHz.value(getConfig().base.sampleRateHz);
@@ -721,7 +695,7 @@ class PcmOnlyConfigInputStreamTest : public InputStreamTest { 
                                                    returnIn(res, mPatchHandle)));

            mHasPatch = res == Result::OK;

        } else {

            EXPECT_OK(stream->setDevices({maybeSourceAddress.value()}));

            EXPECT_OK(stream->setDevices({address}));

        }

    }
@@ -731,10 +705,6 @@ class PcmOnlyConfigInputStreamTest : public InputStreamTest { 
                EXPECT_OK(getDevice()->releaseAudioPatch(mPatchHandle));

                mHasPatch = false;

            }

        } else {

            if (stream) {

                EXPECT_OK(stream->setDevices({address}));

            }

        }

    }
@@ -864,14 +834,8 @@ TEST_P(MicrophoneInfoInputStreamTest, GetActiveMicrophones) { 
    }

    ASSERT_OK(res);



    auto maybeSourceAddress =

            getCachedPolicyConfig().getSourceDeviceForMixPort(getDeviceName(), getMixPortName());

    ASSERT_TRUE(maybeSourceAddress.has_value())

            << "No source device found for mix port " << getMixPortName() << " (module "

            << getDeviceName() << ")";



    for (auto microphone : microphones) {

        if (microphone.deviceAddress == maybeSourceAddress.value()) {

        if (microphone.deviceAddress == address) {

            StreamReader reader(stream.get(), stream->getBufferSize());

            ASSERT_TRUE(reader.start());

            reader.pause();  // This ensures that at least one read has happened.

audio/core/all-versions/vts/functional/7.0/Generators.cpp

+39 −32
Original line number Diff line number Diff line
@@ -57,9 +57,6 @@ static std::vector<AudioConfig> combineAudioConfig(std::vector<xsd::AudioChannel 


static std::tuple<std::vector<AudioInOutFlag>, bool> generateOutFlags(

        const xsd::MixPorts::MixPort& mixPort) {

    static const std::vector<AudioInOutFlag> offloadFlags = {

            toString(xsd::AudioInOutFlag::AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD),

            toString(xsd::AudioInOutFlag::AUDIO_OUTPUT_FLAG_DIRECT)};

    std::vector<AudioInOutFlag> flags;

    bool isOffload = false;

    if (mixPort.hasFlags()) {
@@ -67,15 +64,11 @@ static std::tuple<std::vector<AudioInOutFlag>, bool> generateOutFlags( 
        isOffload = std::find(xsdFlags.begin(), xsdFlags.end(),

                              xsd::AudioInOutFlag::AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) !=

                    xsdFlags.end();

        if (!isOffload) {

        for (auto flag : xsdFlags) {

            if (flag != xsd::AudioInOutFlag::AUDIO_OUTPUT_FLAG_PRIMARY) {

                flags.push_back(toString(flag));

            }

        }

        } else {

            flags = offloadFlags;

        }

    }

    return {flags, isOffload};

}
@@ -100,11 +93,10 @@ std::vector<DeviceConfigParameter> generateOutputDeviceConfigParameters(bool one 
        if (!module || !module->getFirstMixPorts()) break;

        for (const auto& mixPort : module->getFirstMixPorts()->getMixPort()) {

            if (mixPort.getRole() != xsd::Role::source) continue;  // not an output profile

            if (getCachedPolicyConfig()

                        .getAttachedSinkDeviceForMixPort(moduleName, mixPort.getName())

                        .empty()) {

                continue;  // no attached device

            }

            const auto attachedDeviceAddress =

                    getCachedPolicyConfig().getDeviceAddressOfSinkDeviceAttachedToMixPort(

                            moduleName, mixPort.getName());

            if (!attachedDeviceAddress.has_value()) continue;

            auto [flags, isOffload] = generateOutFlags(mixPort);

            for (const auto& profile : mixPort.getProfile()) {

                if (!profile.hasFormat() || !profile.hasSamplingRates() ||
@@ -118,7 +110,8 @@ std::vector<DeviceConfigParameter> generateOutputDeviceConfigParameters(bool one 
                    if (isOffload) {

                        config.offloadInfo.info(generateOffloadInfo(config.base));

                    }

                    result.emplace_back(device, mixPort.getName(), config, flags);

                    result.emplace_back(device, mixPort.getName(), attachedDeviceAddress.value(),

                                        config, flags);

                    if (oneProfilePerDevice) break;

                }

                if (oneProfilePerDevice) break;
@@ -162,13 +155,16 @@ const std::vector<DeviceConfigParameter>& getOutputDeviceInvalidConfigParameters 
                            profile.getFormat(),

                            static_cast<uint32_t>(profile.getSamplingRates()[0]),

                            toString(profile.getChannelMasks()[0])};

                    DeviceAddress defaultDevice = {

                            toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_DEFAULT), {}};

                    {

                        AudioConfig config{.base = validBase};

                        config.base.channelMask = "random_string";

                        if (isOffload) {

                            config.offloadInfo.info(generateOffloadInfo(validBase));

                        }

                        result.emplace_back(device, mixPort.getName(), config, validFlags);

                        result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                            validFlags);

                    }

                    {

                        AudioConfig config{.base = validBase};
@@ -176,7 +172,8 @@ const std::vector<DeviceConfigParameter>& getOutputDeviceInvalidConfigParameters 
                        if (isOffload) {

                            config.offloadInfo.info(generateOffloadInfo(validBase));

                        }

                        result.emplace_back(device, mixPort.getName(), config, validFlags);

                        result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                            validFlags);

                    }

                    if (generateInvalidFlags) {

                        AudioConfig config{.base = validBase};
@@ -184,32 +181,37 @@ const std::vector<DeviceConfigParameter>& getOutputDeviceInvalidConfigParameters 
                            config.offloadInfo.info(generateOffloadInfo(validBase));

                        }

                        std::vector<AudioInOutFlag> flags = {"random_string", ""};

                        result.emplace_back(device, mixPort.getName(), config, flags);

                        result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                            flags);

                    }

                    if (isOffload) {

                        {

                            AudioConfig config{.base = validBase};

                            config.offloadInfo.info(generateOffloadInfo(validBase));

                            config.offloadInfo.info().base.channelMask = "random_string";

                            result.emplace_back(device, mixPort.getName(), config, validFlags);

                            result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                                validFlags);

                        }

                        {

                            AudioConfig config{.base = validBase};

                            config.offloadInfo.info(generateOffloadInfo(validBase));

                            config.offloadInfo.info().base.format = "random_string";

                            result.emplace_back(device, mixPort.getName(), config, validFlags);

                            result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                                validFlags);

                        }

                        {

                            AudioConfig config{.base = validBase};

                            config.offloadInfo.info(generateOffloadInfo(validBase));

                            config.offloadInfo.info().streamType = "random_string";

                            result.emplace_back(device, mixPort.getName(), config, validFlags);

                            result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                                validFlags);

                        }

                        {

                            AudioConfig config{.base = validBase};

                            config.offloadInfo.info(generateOffloadInfo(validBase));

                            config.offloadInfo.info().usage = "random_string";

                            result.emplace_back(device, mixPort.getName(), config, validFlags);

                            result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                                validFlags);

                        }

                        hasOffloadConfig = true;

                    } else {
@@ -233,11 +235,10 @@ std::vector<DeviceConfigParameter> generateInputDeviceConfigParameters(bool oneP 
        if (!module || !module->getFirstMixPorts()) break;

        for (const auto& mixPort : module->getFirstMixPorts()->getMixPort()) {

            if (mixPort.getRole() != xsd::Role::sink) continue;  // not an input profile

            if (getCachedPolicyConfig()

                        .getAttachedSourceDeviceForMixPort(moduleName, mixPort.getName())

                        .empty()) {

                continue;  // no attached device

            }

            const auto attachedDeviceAddress =

                    getCachedPolicyConfig().getDeviceAddressOfSourceDeviceAttachedToMixPort(

                            moduleName, mixPort.getName());

            if (!attachedDeviceAddress.has_value()) continue;

            std::vector<AudioInOutFlag> flags;

            if (mixPort.hasFlags()) {

                std::transform(mixPort.getFlags().begin(), mixPort.getFlags().end(),
@@ -250,7 +251,8 @@ std::vector<DeviceConfigParameter> generateInputDeviceConfigParameters(bool oneP 
                auto configs = combineAudioConfig(profile.getChannelMasks(),

                                                  profile.getSamplingRates(), profile.getFormat());

                for (const auto& config : configs) {

                    result.emplace_back(device, mixPort.getName(), config, flags);

                    result.emplace_back(device, mixPort.getName(), attachedDeviceAddress.value(),

                                        config, flags);

                    if (oneProfilePerDevice) break;

                }

                if (oneProfilePerDevice) break;
@@ -298,20 +300,25 @@ const std::vector<DeviceConfigParameter>& getInputDeviceInvalidConfigParameters( 
                            profile.getFormat(),

                            static_cast<uint32_t>(profile.getSamplingRates()[0]),

                            toString(profile.getChannelMasks()[0])};

                    DeviceAddress defaultDevice = {

                            toString(xsd::AudioDevice::AUDIO_DEVICE_IN_DEFAULT), {}};

                    {

                        AudioConfig config{.base = validBase};

                        config.base.channelMask = "random_string";

                        result.emplace_back(device, mixPort.getName(), config, validFlags);

                        result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                            validFlags);

                    }

                    {

                        AudioConfig config{.base = validBase};

                        config.base.format = "random_string";

                        result.emplace_back(device, mixPort.getName(), config, validFlags);

                        result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                            validFlags);

                    }

                    if (generateInvalidFlags) {

                        AudioConfig config{.base = validBase};

                        std::vector<AudioInOutFlag> flags = {"random_string", ""};

                        result.emplace_back(device, mixPort.getName(), config, flags);

                        result.emplace_back(device, mixPort.getName(), defaultDevice, config,

                                            flags);

                    }

                    hasConfig = true;

                    break;

audio/core/all-versions/vts/functional/7.0/PolicyConfig.h

+12 −2
Original line number Diff line number Diff line
@@ -61,6 +61,18 @@ class PolicyConfig { 
    const std::set<std::string>& getModulesWithDevicesNames() const {

        return mModulesWithDevicesNames;

    }

    std::optional<DeviceAddress> getDeviceAddressOfSinkDeviceAttachedToMixPort(

            const std::string& moduleName, const std::string& mixPortName) const {

        const auto attachedDevicePort = getAttachedSinkDeviceForMixPort(moduleName, mixPortName);

        if (attachedDevicePort.empty()) return {};

        return getDeviceAddressOfDevicePort(moduleName, attachedDevicePort);

    }

    std::optional<DeviceAddress> getDeviceAddressOfSourceDeviceAttachedToMixPort(

            const std::string& moduleName, const std::string& mixPortName) const {

        const auto attachedDevicePort = getAttachedSourceDeviceForMixPort(moduleName, mixPortName);

        if (attachedDevicePort.empty()) return {};

        return getDeviceAddressOfDevicePort(moduleName, attachedDevicePort);

    }

    std::string getAttachedSinkDeviceForMixPort(const std::string& moduleName,

                                                const std::string& mixPortName) const {

        return findAttachedDevice(getAttachedDevices(moduleName),
@@ -84,8 +96,6 @@ class PolicyConfig { 
    const std::vector<std::string>& getAttachedDevices(const std::string& moduleName) const;

    std::optional<DeviceAddress> getDeviceAddressOfDevicePort(

            const std::string& moduleName, const std::string& devicePortName) const;

    std::string getDevicePortTagNameFromType(const std::string& moduleName,

                                             const AudioDevice& deviceType) const;

    std::set<std::string> getSinkDevicesForMixPort(const std::string& moduleName,

                                                   const std::string& mixPortName) const;

    std::set<std::string> getSourceDevicesForMixPort(const std::string& moduleName,

audio/core/all-versions/vts/functional/AudioPrimaryHidlHalTest.h

+8 −9
Original line number Diff line number Diff line
@@ -617,7 +617,8 @@ static std::string DeviceConfigParameterToString( 
                    std::get<PARAM_FLAGS>(info.param)));

#elif MAJOR_VERSION >= 7

    const auto configPart =

            std::to_string(config.base.sampleRateHz) + "_" +

            ::testing::PrintToString(std::get<PARAM_ATTACHED_DEV_ADDR>(info.param).deviceType) +

            "_" + std::to_string(config.base.sampleRateHz) + "_" +

            // The channel masks and flags are vectors of strings, just need to sanitize them.

            SanitizeStringForGTestName(::testing::PrintToString(config.base.channelMask)) + "_" +

            SanitizeStringForGTestName(::testing::PrintToString(std::get<PARAM_FLAGS>(info.param)));
@@ -658,6 +659,9 @@ class AudioHidlTestWithDeviceConfigParameter 
                std::get<INDEX_OUTPUT>(std::get<PARAM_FLAGS>(GetParam())));

    }

#elif MAJOR_VERSION >= 7

    DeviceAddress getAttachedDeviceAddress() const {

        return std::get<PARAM_ATTACHED_DEV_ADDR>(GetParam());

    }

    hidl_vec<AudioInOutFlag> getInputFlags() const { return std::get<PARAM_FLAGS>(GetParam()); }

    hidl_vec<AudioInOutFlag> getOutputFlags() const { return std::get<PARAM_FLAGS>(GetParam()); }

#endif
@@ -1047,7 +1051,7 @@ class OutputStreamTest 
#if MAJOR_VERSION <= 6

        address.device = AudioDevice::OUT_DEFAULT;

#elif MAJOR_VERSION >= 7

        address.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_DEFAULT);

        address = getAttachedDeviceAddress();

#endif

        const AudioConfig& config = getConfig();

        auto flags = getOutputFlags();
@@ -1243,16 +1247,11 @@ class InputStreamTest 
#if MAJOR_VERSION <= 6

        address.device = AudioDevice::IN_DEFAULT;

#elif MAJOR_VERSION >= 7

        auto maybeSourceAddress = getCachedPolicyConfig().getSourceDeviceForMixPort(

                getDeviceName(), getMixPortName());

        address = getAttachedDeviceAddress();

        auto& metadata = initMetadata.tracks[0];

        if (maybeSourceAddress.has_value() &&

            !xsd::isTelephonyDevice(maybeSourceAddress.value().deviceType)) {

            address = maybeSourceAddress.value();

        if (!xsd::isTelephonyDevice(address.deviceType)) {

            metadata.source = toString(xsd::AudioSource::AUDIO_SOURCE_UNPROCESSED);

            metadata.channelMask = getConfig().base.channelMask;

        } else {

            address.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_IN_DEFAULT);

        }

#if MAJOR_VERSION == 7 && MINOR_VERSION >= 1

        auto flagsIt = std::find(flags.begin(), flags.end(),

audio/core/all-versions/vts/functional/AudioTestDefinitions.h

+2 −1
Original line number Diff line number Diff line
@@ -39,9 +39,10 @@ using DeviceConfigParameter = std::tuple< 
        std::variant<android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::AudioInputFlag,

                     android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::AudioOutputFlag>>;

#elif MAJOR_VERSION >= 7

enum { PARAM_DEVICE, PARAM_PORT_NAME, PARAM_CONFIG, PARAM_FLAGS };

enum { PARAM_DEVICE, PARAM_PORT_NAME, PARAM_ATTACHED_DEV_ADDR, PARAM_CONFIG, PARAM_FLAGS };

using DeviceConfigParameter =

        std::tuple<DeviceParameter, std::string,

                   android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::DeviceAddress,

                   android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::AudioConfig,

                   std::vector<android::hardware::audio::CORE_TYPES_CPP_VERSION::AudioInOutFlag>>;

#endif