Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:50:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "Audio: Add VTS tests for invalid enum-strings, Part 2"

Browse Source
This commit is contained in:
Treehugger Robot
2021-01-12 09:59:04 +00:00
committed by Gerrit Code Review
parent 112fab25fc 0dbf3982af
commit 46f91823cf
3 changed files with 134 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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");

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

@@ -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))

74
audio/effect/all-versions/vts/functional/VtsHalAudioEffectTargetTest.cpp
View File

@@ -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