Merge "Audio: Add VTS tests for invalid enum-strings, Part 2" (46f91823) · Commits · e / os / android_hardware_interfaces

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