| /* |
| * Copyright (C) 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. |
| */ |
| |
| #include <gtest/gtest.h> |
| |
| #define LOG_TAG "TypeConverter_Test" |
| #include <log/log.h> |
| |
| #include <android_audio_policy_configuration_V7_0.h> |
| #include <media/TypeConverter.h> |
| #include <system/audio.h> |
| #include <xsdc/XsdcSupport.h> |
| |
| using namespace android; |
| namespace xsd { |
| using namespace android::audio::policy::configuration::V7_0; |
| } |
| |
| TEST(TypeConverter, ParseChannelMasks) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioChannelMask>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_channel_mask_t channelMask = channelMaskFromString(stringVal); |
| EXPECT_EQ(enumVal != xsd::AudioChannelMask::AUDIO_CHANNEL_NONE, |
| audio_channel_mask_is_valid(channelMask)) |
| << "Validity of \"" << stringVal << "\" is not as expected"; |
| } |
| } |
| |
| TEST(TypeConverter, ParseInputOutputIndexChannelMask) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioChannelMask>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_channel_mask_t channelMask, channelMaskBack; |
| std::string stringValBack; |
| if (stringVal.find("_CHANNEL_IN_") != std::string::npos) { |
| EXPECT_TRUE(InputChannelConverter::fromString(stringVal, channelMask)) |
| << "Conversion of \"" << stringVal << "\" failed (as input channel mask)"; |
| EXPECT_TRUE(InputChannelConverter::toString(channelMask, stringValBack)) |
| << "Conversion of input channel mask " << channelMask << " failed"; |
| // Due to aliased values, the result of 'toString' might not be the same |
| // as 'stringVal', thus we need to compare the results of parsing instead. |
| EXPECT_TRUE(InputChannelConverter::fromString(stringValBack, channelMaskBack)) |
| << "Conversion of \"" << stringValBack << "\" failed (as input channel mask)"; |
| EXPECT_EQ(channelMask, channelMaskBack); |
| } else if (stringVal.find("_CHANNEL_OUT_") != std::string::npos) { |
| EXPECT_TRUE(OutputChannelConverter::fromString(stringVal, channelMask)) |
| << "Conversion of \"" << stringVal << "\" failed (as output channel mask)"; |
| EXPECT_TRUE(OutputChannelConverter::toString(channelMask, stringValBack)) |
| << "Conversion of output channel mask " << channelMask << " failed"; |
| EXPECT_TRUE(OutputChannelConverter::fromString(stringValBack, channelMaskBack)) |
| << "Conversion of \"" << stringValBack << "\" failed (as output channel mask)"; |
| EXPECT_EQ(channelMask, channelMaskBack); |
| } else if (stringVal.find("_CHANNEL_INDEX_") != std::string::npos) { |
| EXPECT_TRUE(ChannelIndexConverter::fromString(stringVal, channelMask)) |
| << "Conversion of \"" << stringVal << "\" failed (as indexed channel mask)"; |
| EXPECT_TRUE(ChannelIndexConverter::toString(channelMask, stringValBack)) |
| << "Conversion of indexed channel mask " << channelMask << " failed"; |
| EXPECT_EQ(stringVal, stringValBack); |
| } else if (stringVal == toString(xsd::AudioChannelMask::AUDIO_CHANNEL_NONE)) { |
| EXPECT_FALSE(InputChannelConverter::fromString(stringVal, channelMask)) |
| << "Conversion of \"" << stringVal << "\" succeeded (as input channel mask)"; |
| EXPECT_FALSE(OutputChannelConverter::fromString(stringVal, channelMask)) |
| << "Conversion of \"" << stringVal << "\" succeeded (as output channel mask)"; |
| EXPECT_FALSE(ChannelIndexConverter::fromString(stringVal, channelMask)) |
| << "Conversion of \"" << stringVal << "\" succeeded (as index channel mask)"; |
| // None of Converters could parse this because 'NONE' isn't a 'valid' channel mask. |
| channelMask = AUDIO_CHANNEL_NONE; |
| // However they all must succeed in converting it back. |
| EXPECT_TRUE(InputChannelConverter::toString(channelMask, stringValBack)) |
| << "Conversion of input channel mask " << channelMask << " failed"; |
| EXPECT_EQ(stringVal, stringValBack); |
| EXPECT_TRUE(OutputChannelConverter::toString(channelMask, stringValBack)) |
| << "Conversion of output channel mask " << channelMask << " failed"; |
| EXPECT_EQ(stringVal, stringValBack); |
| EXPECT_TRUE(ChannelIndexConverter::toString(channelMask, stringValBack)) |
| << "Conversion of indexed channel mask " << channelMask << " failed"; |
| EXPECT_EQ(stringVal, stringValBack); |
| } else { |
| FAIL() << "Unrecognized channel mask \"" << stringVal << "\""; |
| } |
| } |
| } |
| |
| TEST(TypeConverter, ParseContentTypes) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioContentType>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_content_type_t contentType; |
| EXPECT_TRUE(AudioContentTypeConverter::fromString(stringVal, contentType)) |
| << "Conversion of \"" << stringVal << "\" failed"; |
| EXPECT_EQ(stringVal, toString(contentType)); |
| } |
| } |
| |
| TEST(TypeConverter, ParseDevices) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioDevice>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_devices_t device, deviceBack; |
| std::string stringValBack; |
| EXPECT_TRUE(DeviceConverter::fromString(stringVal, device)) |
| << "Conversion of \"" << stringVal << "\" failed"; |
| if (enumVal != xsd::AudioDevice::AUDIO_DEVICE_NONE) { |
| EXPECT_TRUE(audio_is_input_device(device) || audio_is_output_device(device)) |
| << "Device \"" << stringVal << "\" is neither input, nor output device"; |
| } else { |
| EXPECT_FALSE(audio_is_input_device(device)); |
| EXPECT_FALSE(audio_is_output_device(device)); |
| } |
| // Due to aliased values, the result of 'toString' might not be the same |
| // as 'stringVal', thus we need to compare the results of parsing instead. |
| stringValBack = toString(device); |
| EXPECT_TRUE(DeviceConverter::fromString(stringValBack, deviceBack)) |
| << "Conversion of \"" << stringValBack << "\" failed"; |
| EXPECT_EQ(device, deviceBack); |
| } |
| } |
| |
| TEST(TypeConverter, ParseInOutDevices) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioDevice>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_devices_t device, deviceBack; |
| std::string stringValBack; |
| if (stringVal.find("_DEVICE_IN_") != std::string::npos) { |
| EXPECT_TRUE(InputDeviceConverter::fromString(stringVal, device)) |
| << "Conversion of \"" << stringVal << "\" failed (as input device)"; |
| // Due to aliased values, the result of 'toString' might not be the same |
| // as 'stringVal', thus we need to compare the results of parsing instead. |
| stringValBack = toString(device); |
| EXPECT_TRUE(InputDeviceConverter::fromString(stringValBack, deviceBack)) |
| << "Conversion of \"" << stringValBack << "\" failed"; |
| EXPECT_EQ(device, deviceBack); |
| } else if (stringVal.find("_DEVICE_OUT_") != std::string::npos) { |
| EXPECT_TRUE(OutputDeviceConverter::fromString(stringVal, device)) |
| << "Conversion of \"" << stringVal << "\" failed (as output device)"; |
| stringValBack = toString(device); |
| EXPECT_TRUE(OutputDeviceConverter::fromString(stringValBack, deviceBack)) |
| << "Conversion of \"" << stringValBack << "\" failed"; |
| EXPECT_EQ(device, deviceBack); |
| } else if (stringVal == toString(xsd::AudioDevice::AUDIO_DEVICE_NONE)) { |
| EXPECT_FALSE(InputDeviceConverter::fromString(stringVal, device)) |
| << "Conversion of \"" << stringVal << "\" succeeded (as input device)"; |
| EXPECT_FALSE(OutputDeviceConverter::fromString(stringVal, device)) |
| << "Conversion of \"" << stringVal << "\" succeeded (as output device)"; |
| EXPECT_EQ(stringVal, toString(device)); |
| } else { |
| FAIL() << "Unrecognized audio device \"" << stringVal << "\""; |
| } |
| } |
| } |
| |
| TEST(TypeConverter, ParseInOutFlags) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioInOutFlag>{}) { |
| const std::string stringVal = toString(enumVal); |
| if (stringVal.find("_INPUT_FLAG_") != std::string::npos) { |
| audio_input_flags_t flag; |
| EXPECT_TRUE(InputFlagConverter::fromString(stringVal, flag)) |
| << "Conversion of \"" << stringVal << "\" failed (as input flag)"; |
| EXPECT_EQ(stringVal, toString(flag)); |
| } else { |
| audio_output_flags_t flag; |
| EXPECT_TRUE(OutputFlagConverter::fromString(stringVal, flag)) |
| << "Conversion of \"" << stringVal << "\" failed (as output flag)"; |
| EXPECT_EQ(stringVal, toString(flag)); |
| } |
| } |
| } |
| |
| TEST(TypeConverter, ParseFormats) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioFormat>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_format_t format; |
| EXPECT_TRUE(FormatConverter::fromString(stringVal, format)) |
| << "Conversion of \"" << stringVal << "\" failed"; |
| EXPECT_EQ(enumVal != xsd::AudioFormat::AUDIO_FORMAT_DEFAULT, |
| audio_is_valid_format(format)) |
| << "Validity of \"" << stringVal << "\" is not as expected"; |
| EXPECT_EQ(stringVal, toString(format)); |
| } |
| } |
| |
| TEST(TypeConverter, ParseGainModes) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioGainMode>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_gain_mode_t gainMode; |
| EXPECT_TRUE(GainModeConverter::fromString(stringVal, gainMode)) |
| << "Conversion of \"" << stringVal << "\" failed"; |
| EXPECT_EQ(stringVal, toString(gainMode)); |
| } |
| } |
| |
| TEST(TypeConverter, ParseSources) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioSource>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_source_t source; |
| EXPECT_TRUE(SourceTypeConverter::fromString(stringVal, source)) |
| << "Conversion of \"" << stringVal << "\" failed"; |
| EXPECT_EQ(source != AUDIO_SOURCE_DEFAULT, audio_is_valid_audio_source(source)) |
| << "Validity of \"" << stringVal << "\" is not as expected"; |
| EXPECT_EQ(stringVal, toString(source)); |
| } |
| } |
| |
| TEST(TypeConverter, ParseStreamTypes) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioStreamType>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_stream_type_t streamType; |
| EXPECT_TRUE(StreamTypeConverter::fromString(stringVal, streamType)) |
| << "Conversion of \"" << stringVal << "\" failed"; |
| EXPECT_EQ(stringVal, toString(streamType)); |
| } |
| } |
| |
| TEST(TypeConverter, ParseUsages) { |
| for (const auto enumVal : xsdc_enum_range<xsd::AudioUsage>{}) { |
| const std::string stringVal = toString(enumVal); |
| audio_usage_t usage; |
| EXPECT_TRUE(UsageTypeConverter::fromString(stringVal, usage)) |
| << "Conversion of \"" << stringVal << "\" failed"; |
| EXPECT_EQ(stringVal, toString(usage)); |
| } |
| } |
