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

Commit f8b4e79b authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Audio: Add VTS tests for invalid enum-strings, Part 2" am: 46f91823 am: e97fc6f6 

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

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I2c8063486c2a9cd482900b23b4dca5094affbf4f
parents 85316e7e e97fc6f6

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

+12 −54
Original line number Diff line number Diff line
@@ -116,75 +116,33 @@ const std::vector<DeviceConfigParameter>& getInputDeviceSingleConfigParameters() 
}

#endif  // MAJOR_VERSION <= 6



class SingleOutputConfigTest : public AudioHidlTestWithDeviceConfigParameter {};

TEST_P(SingleOutputConfigTest, CloseDeviceWithOpenedOutputStreams) {

class SingleConfigOutputStreamTest : public OutputStreamTest {};

TEST_P(SingleConfigOutputStreamTest, CloseDeviceWithOpenedOutputStreams) {

    doc::test("Verify that a device can't be closed if there are output streams opened");

#if MAJOR_VERSION <= 6

    DeviceAddress address{.device = AudioDevice::OUT_DEFAULT};

    SourceMetadata initMetadata = {{{AudioUsage::MEDIA, AudioContentType::MUSIC, 1 /* gain */}}};

#elif MAJOR_VERSION >= 7

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

    SourceMetadata initMetadata = {{{toString(xsd::AudioUsage::AUDIO_USAGE_MEDIA),

                                     toString(xsd::AudioContentType::AUDIO_CONTENT_TYPE_MUSIC),

                                     {} /* tags */,

                                     toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO),

                                     1 /* gain */}}};

#endif

    const AudioConfig& config = getConfig();

    auto flags = getOutputFlags();

    sp<IStreamOut> stream;

    StreamHelper<IStreamOut> helper(stream);

    AudioConfig suggestedConfig{};

    ASSERT_NO_FATAL_FAILURE(helper.open(

            [&](AudioIoHandle handle, AudioConfig config, auto cb) {

                return getDevice()->openOutputStream(handle, address, config, flags, initMetadata,

                                                     cb);

            },

            config, &res, &suggestedConfig));

    // Opening of the stream is done in SetUp.

    ASSERT_RESULT(Result::INVALID_STATE, getDevice()->close());

    ASSERT_NO_FATAL_FAILURE(helper.close(true /*clear*/, &res));

    ASSERT_OK(closeStream(true /*clear*/));

    ASSERT_OK(getDevice()->close());

    ASSERT_TRUE(resetDevice());

}

INSTANTIATE_TEST_CASE_P(SingleOutputConfig, SingleOutputConfigTest,

INSTANTIATE_TEST_CASE_P(SingleConfigOutputStream, SingleConfigOutputStreamTest,

                        ::testing::ValuesIn(getOutputDeviceSingleConfigParameters()),

                        &DeviceConfigParameterToString);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SingleOutputConfig);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SingleConfigOutputStream);



class SingleInputConfigTest : public AudioHidlTestWithDeviceConfigParameter {};

TEST_P(SingleInputConfigTest, CloseDeviceWithOpenedInputStreams) {

class SingleConfigInputStreamTest : public InputStreamTest {};

TEST_P(SingleConfigInputStreamTest, CloseDeviceWithOpenedInputStreams) {

    doc::test("Verify that a device can't be closed if there are input streams opened");

#if MAJOR_VERSION <= 6

    DeviceAddress address{.device = AudioDevice::IN_DEFAULT};

    SinkMetadata initMetadata = {{{.source = AudioSource::MIC, .gain = 1}}};

#elif MAJOR_VERSION >= 7

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

    SinkMetadata initMetadata = {

            {{.source = toString(xsd::AudioSource::AUDIO_SOURCE_MIC),

              .gain = 1,

              .tags = {},

              .channelMask = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_IN_MONO)}}};

#endif

    const AudioConfig& config = getConfig();

    auto flags = getInputFlags();

    sp<IStreamIn> stream;

    StreamHelper<IStreamIn> helper(stream);

    AudioConfig suggestedConfig{};

    ASSERT_NO_FATAL_FAILURE(helper.open(

            [&](AudioIoHandle handle, AudioConfig config, auto cb) {

                return getDevice()->openInputStream(handle, address, config, flags, initMetadata,

                                                    cb);

            },

            config, &res, &suggestedConfig));

    // Opening of the stream is done in SetUp.

    ASSERT_RESULT(Result::INVALID_STATE, getDevice()->close());

    ASSERT_NO_FATAL_FAILURE(helper.close(true /*clear*/, &res));

    ASSERT_OK(closeStream(true /*clear*/));

    ASSERT_OK(getDevice()->close());

    ASSERT_TRUE(resetDevice());

}

INSTANTIATE_TEST_CASE_P(SingleInputConfig, SingleInputConfigTest,

INSTANTIATE_TEST_CASE_P(SingleConfigInputStream, SingleConfigInputStreamTest,

                        ::testing::ValuesIn(getInputDeviceSingleConfigParameters()),

                        &DeviceConfigParameterToString);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SingleInputConfig);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SingleConfigInputStream);



TEST_P(AudioPatchHidlTest, UpdatePatchInvalidHandle) {

    doc::test("Verify that passing an invalid handle to updateAudioPatch is checked");

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

+48 −7
Original line number Diff line number Diff line
@@ -298,6 +298,19 @@ INSTANTIATE_TEST_CASE_P( 
        &DeviceConfigParameterToString);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(InputBufferSizeInvalidConfig);



static const DeviceAddress& getInvalidDeviceAddress() {

    static const DeviceAddress valid = {.deviceType = "random_string"};

    return valid;

}



TEST_P(AudioHidlDeviceTest, SetConnectedStateInvalidDeviceAddress) {

    doc::test("Check that invalid device address is rejected by IDevice::setConnectedState");

    EXPECT_RESULT(Result::INVALID_ARGUMENTS,

                  getDevice()->setConnectedState(getInvalidDeviceAddress(), true));

    EXPECT_RESULT(Result::INVALID_ARGUMENTS,

                  getDevice()->setConnectedState(getInvalidDeviceAddress(), false));

}



enum { PARAM_DEVICE_CONFIG, PARAM_ADDRESS, PARAM_METADATA };

enum { INDEX_SINK, INDEX_SOURCE };

using SinkOrSourceMetadata = std::variant<SinkMetadata, SourceMetadata>;
@@ -361,11 +374,6 @@ static const DeviceAddress& getValidOutputDeviceAddress() { 
    return valid;

}



static const DeviceAddress& getInvalidDeviceAddress() {

    static const DeviceAddress valid = {.deviceType = "random_string"};

    return valid;

}



static const RecordTrackMetadata& getValidRecordTrackMetadata() {

    static const RecordTrackMetadata valid = {

            .source = toString(xsd::AudioSource::AUDIO_SOURCE_DEFAULT), .gain = 1};
@@ -567,7 +575,40 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(OutputStreamInvalidConfig); 
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(OutputStreamInvalidAddress);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(OutputStreamInvalidMetadata);



TEST_P(OutputStreamTest, UpdateInvalidSourceMetadata) {

#define TEST_SINGLE_CONFIG_IO_STREAM(test_name, documentation, code) \

    TEST_P(SingleConfigInputStreamTest, test_name) {                 \

        doc::test(documentation);                                    \

        code;                                                        \

    }                                                                \

    TEST_P(SingleConfigOutputStreamTest, test_name) {                \

        doc::test(documentation);                                    \

        code;                                                        \

    }



static void testSetDevicesInvalidDeviceAddress(IStream* stream) {

    ASSERT_RESULT(Result::INVALID_ARGUMENTS, stream->setDevices({getInvalidDeviceAddress()}));

}

TEST_SINGLE_CONFIG_IO_STREAM(

        SetDevicesInvalidDeviceAddress,

        "Verify that invalid device address is rejected by IStream::setDevices",

        areAudioPatchesSupported() ? doc::partialTest("Audio patches are supported")

                                   : testSetDevicesInvalidDeviceAddress(stream.get()));



static void testSetAudioPropertiesInvalidArguments(IStream* stream, const AudioConfigBase& base) {

    AudioConfigBase invalidFormat = base;

    invalidFormat.format = "random_string";

    ASSERT_RESULT(invalidArgsOrNotSupported, stream->setAudioProperties(invalidFormat));



    AudioConfigBase invalidChannelMask = base;

    invalidChannelMask.channelMask = "random_string";

    ASSERT_RESULT(invalidArgsOrNotSupported, stream->setAudioProperties(invalidChannelMask));

}

TEST_SINGLE_CONFIG_IO_STREAM(

        SetAudioPropertiesInvalidArguments,

        "Verify that invalid arguments are rejected by IStream::setAudioProperties",

        testSetAudioPropertiesInvalidArguments(stream.get(), audioConfig.base));



TEST_P(SingleConfigOutputStreamTest, UpdateInvalidSourceMetadata) {

    doc::test("Verify that invalid metadata is rejected by IStreamOut::updateSourceMetadata");

    for (const auto& metadata : getInvalidSourceMetadatas()) {

        ASSERT_RESULT(invalidArgsOrNotSupported, stream->updateSourceMetadata(metadata))
@@ -575,7 +616,7 @@ TEST_P(OutputStreamTest, UpdateInvalidSourceMetadata) { 
    }

}



TEST_P(InputStreamTest, UpdateInvalidSinkMetadata) {

TEST_P(SingleConfigInputStreamTest, UpdateInvalidSinkMetadata) {

    doc::test("Verify that invalid metadata is rejected by IStreamIn::updateSinkMetadata");

    for (const auto& metadata : getInvalidSinkMetadatas()) {

        ASSERT_RESULT(invalidArgsOrNotSupported, stream->updateSinkMetadata(metadata))

audio/effect/all-versions/vts/functional/VtsHalAudioEffectTargetTest.cpp

+74 −0
Original line number Diff line number Diff line
@@ -14,6 +14,8 @@ 
 * limitations under the License.

 */



#include <vector>



#define LOG_TAG "AudioEffectHidlHalTest"

#include <android-base/logging.h>

#if MAJOR_VERSION <= 6
@@ -309,6 +311,47 @@ TEST_P(AudioEffectHidlTest, GetSetConfig) { 
    EXPECT_EQ(Result::OK, ret2);

}



#if MAJOR_VERSION >= 7

std::vector<EffectBufferConfig> generateInvalidConfigs(const EffectBufferConfig& src) {

    std::vector<EffectBufferConfig> result;

    EffectBufferConfig invalidFormat = src;

    invalidFormat.base.format = "random_string";

    result.push_back(std::move(invalidFormat));

    EffectBufferConfig invalidChannelMask = src;

    invalidChannelMask.base.channelMask = "random_string";

    result.push_back(std::move(invalidChannelMask));

    return result;

}



TEST_P(AudioEffectHidlTest, SetConfigInvalidArguments) {

    description("Verify that invalid arguments are rejected by SetConfig");

    Result retval = Result::NOT_INITIALIZED;

    EffectConfig currentConfig;

    Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) {

        retval = r;

        if (r == Result::OK) {

            currentConfig = conf;

        }

    });

    EXPECT_TRUE(ret.isOk());

    EXPECT_EQ(Result::OK, retval);

    for (const auto& invalidInputCfg : generateInvalidConfigs(currentConfig.inputCfg)) {

        EffectConfig invalidConfig = currentConfig;

        invalidConfig.inputCfg = invalidInputCfg;

        Return<Result> ret = effect->setConfig(invalidConfig, nullptr, nullptr);

        EXPECT_TRUE(ret.isOk());

        EXPECT_EQ(Result::INVALID_ARGUMENTS, ret);

    }

    for (const auto& invalidOutputCfg : generateInvalidConfigs(currentConfig.outputCfg)) {

        EffectConfig invalidConfig = currentConfig;

        invalidConfig.outputCfg = invalidOutputCfg;

        Return<Result> ret = effect->setConfig(invalidConfig, nullptr, nullptr);

        EXPECT_TRUE(ret.isOk());

        EXPECT_EQ(Result::INVALID_ARGUMENTS, ret);

    }

}

#endif



TEST_P(AudioEffectHidlTest, GetConfigReverse) {

    description("Verify that GetConfigReverse does not crash");

    Return<void> ret = effect->getConfigReverse([&](Result, const EffectConfig&) {});
@@ -413,6 +456,16 @@ TEST_P(AudioEffectHidlTest, DisableEnableDisable) { 
    EXPECT_EQ(Result::OK, ret);

}



#if MAJOR_VERSION >= 7

TEST_P(AudioEffectHidlTest, SetDeviceInvalidDeviceAddress) {

    description("Verify that invalid device address is rejected by SetDevice");

    DeviceAddress device{.deviceType = "random_string"};

    Return<Result> ret = effect->setDevice(device);

    EXPECT_TRUE(ret.isOk());

    EXPECT_EQ(Result::INVALID_ARGUMENTS, ret);

}

#endif



TEST_P(AudioEffectHidlTest, SetDevice) {

    description("Verify that SetDevice works for an output chain effect");

#if MAJOR_VERSION <= 6
@@ -468,6 +521,17 @@ TEST_P(AudioEffectHidlTest, SetConfigReverse) { 
    EXPECT_TRUE(ret.isOk());

}



#if MAJOR_VERSION >= 7

TEST_P(AudioEffectHidlTest, SetInputDeviceInvalidDeviceAddress) {

    description("Verify that invalid device address is rejected by SetInputDevice");

    DeviceAddress device{.deviceType = "random_string"};

    Return<Result> ret = effect->setInputDevice(device);

    EXPECT_TRUE(ret.isOk());

    EXPECT_TRUE(ret == Result::INVALID_ARGUMENTS || ret == Result::NOT_SUPPORTED)

            << ::testing::PrintToString(ret);

}

#endif



TEST_P(AudioEffectHidlTest, SetInputDevice) {

    description("Verify that SetInputDevice does not crash");

#if MAJOR_VERSION <= 6
@@ -479,6 +543,16 @@ TEST_P(AudioEffectHidlTest, SetInputDevice) { 
    EXPECT_TRUE(ret.isOk());

}



#if MAJOR_VERSION >= 7

TEST_P(AudioEffectHidlTest, SetInvalidAudioSource) {

    description("Verify that an invalid audio source is rejected by SetAudioSource");

    Return<Result> ret = effect->setAudioSource("random_string");

    ASSERT_TRUE(ret.isOk());

    EXPECT_TRUE(ret == Result::INVALID_ARGUMENTS || ret == Result::NOT_SUPPORTED)

            << ::testing::PrintToString(ret);

}

#endif



TEST_P(AudioEffectHidlTest, SetAudioSource) {

    description("Verify that SetAudioSource does not crash");

#if MAJOR_VERSION <= 6