1148 lines
56 KiB
C++
1148 lines
56 KiB
C++
/*
|
|
* 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 <array>
|
|
#include <string>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#define LOG_TAG "HidlUtils_Test"
|
|
#include <log/log.h>
|
|
|
|
#include <HidlUtils.h>
|
|
#include PATH(APM_XSD_ENUMS_H_FILENAME)
|
|
#include <system/audio.h>
|
|
#include <xsdc/XsdcSupport.h>
|
|
|
|
using namespace android;
|
|
using ::android::hardware::hidl_vec;
|
|
using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION;
|
|
using ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::implementation::HidlUtils;
|
|
namespace xsd {
|
|
using namespace ::android::audio::policy::configuration::CPP_VERSION;
|
|
}
|
|
|
|
static constexpr audio_channel_mask_t kInvalidHalChannelMask = AUDIO_CHANNEL_INVALID;
|
|
static constexpr audio_content_type_t kInvalidHalContentType =
|
|
static_cast<audio_content_type_t>(0xFFFFFFFFU);
|
|
static constexpr audio_devices_t kInvalidHalDevice = static_cast<audio_devices_t>(0xFFFFFFFFU);
|
|
static constexpr audio_format_t kInvalidHalFormat = AUDIO_FORMAT_INVALID;
|
|
static constexpr audio_gain_mode_t kInvalidHalGainMode =
|
|
static_cast<audio_gain_mode_t>(0xFFFFFFFFU);
|
|
// AUDIO_SOURCE_INVALID is framework-only.
|
|
static constexpr audio_source_t kInvalidHalSource = static_cast<audio_source_t>(-1);
|
|
// AUDIO_STREAM_DEFAULT is framework-only
|
|
static constexpr audio_stream_type_t kInvalidHalStreamType = static_cast<audio_stream_type_t>(-2);
|
|
static constexpr audio_usage_t kInvalidHalUsage = static_cast<audio_usage_t>(0xFFFFFFFFU);
|
|
static constexpr audio_encapsulation_type_t kInvalidEncapsulationType =
|
|
static_cast<audio_encapsulation_type_t>(0xFFFFFFFFU);
|
|
static constexpr audio_standard_t kInvalidAudioStandard =
|
|
static_cast<audio_standard_t>(0xFFFFFFFFU);
|
|
|
|
TEST(HidlUtils, ConvertInvalidChannelMask) {
|
|
AudioChannelMask invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioChannelMaskFromHal(kInvalidHalChannelMask,
|
|
false /*isInput*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioChannelMaskFromHal(kInvalidHalChannelMask,
|
|
true /*isInput*/, &invalid));
|
|
audio_channel_mask_t halInvalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioChannelMaskToHal("", &halInvalid));
|
|
// INVALID channel mask is not in XSD thus it's not allowed for transfer over HIDL.
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioChannelMaskToHal("AUDIO_CHANNEL_INVALID", &halInvalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioChannelMaskToHal("random string", &halInvalid));
|
|
}
|
|
|
|
// Might move these to the audio_policy_configuration_V7_0-enums library
|
|
// if there would be usages in the default wrapper code. In that case,
|
|
// it would be better to reimplement these methods using a proper switch statement
|
|
// over all known enum values.
|
|
static bool isInputChannelMask(xsd::AudioChannelMask channelMask) {
|
|
return toString(channelMask).find("_CHANNEL_IN_") != std::string::npos;
|
|
}
|
|
|
|
static bool isOutputChannelMask(xsd::AudioChannelMask channelMask) {
|
|
return toString(channelMask).find("_CHANNEL_OUT_") != std::string::npos;
|
|
}
|
|
|
|
static bool isIndexChannelMask(xsd::AudioChannelMask channelMask) {
|
|
return toString(channelMask).find("_CHANNEL_INDEX_") != std::string::npos;
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertChannelMask) {
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioChannelMask>{}) {
|
|
const AudioChannelMask channelMask = toString(enumVal);
|
|
audio_channel_mask_t halChannelMask, halChannelMaskBack;
|
|
AudioChannelMask channelMaskBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioChannelMaskToHal(channelMask, &halChannelMask))
|
|
<< "Conversion of \"" << channelMask << "\" failed";
|
|
EXPECT_EQ(enumVal != xsd::AudioChannelMask::AUDIO_CHANNEL_NONE,
|
|
audio_channel_mask_is_valid(halChannelMask))
|
|
<< "Validity of \"" << channelMask << "\" is not as expected";
|
|
if (bool isInput = isInputChannelMask(enumVal); isInput || isOutputChannelMask(enumVal)) {
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioChannelMaskFromHal(halChannelMask, isInput, &channelMaskBack))
|
|
<< "Conversion of " << (isInput ? "input" : "output") << " channel mask "
|
|
<< halChannelMask << " failed";
|
|
// Due to aliased values, the result of 'fromHal' might not be the same
|
|
// as 'channelMask', thus we need to compare the results of 'toHal' conversion instead.
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioChannelMaskToHal(channelMaskBack, &halChannelMaskBack))
|
|
<< "Conversion of \"" << channelMaskBack << "\" failed";
|
|
EXPECT_EQ(halChannelMask, halChannelMaskBack);
|
|
} else if (isIndexChannelMask(enumVal) ||
|
|
enumVal == xsd::AudioChannelMask::AUDIO_CHANNEL_NONE) {
|
|
// Conversions for indexed masks and "none" must not depend on the provided direction.
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioChannelMaskFromHal(halChannelMask, true /*isInput*/,
|
|
&channelMaskBack))
|
|
<< "Conversion of indexed / none channel mask " << halChannelMask
|
|
<< " failed (as input channel mask)";
|
|
EXPECT_EQ(channelMask, channelMaskBack);
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioChannelMaskFromHal(
|
|
halChannelMask, false /*isInput*/, &channelMaskBack))
|
|
<< "Conversion of indexed / none channel mask " << halChannelMask
|
|
<< " failed (as output channel mask)";
|
|
EXPECT_EQ(channelMask, channelMaskBack);
|
|
} else {
|
|
FAIL() << "Unrecognized channel mask \"" << channelMask << "\"";
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidChannelMasksFromHal) {
|
|
std::vector<std::string> validAndInvalidChannelMasks = {
|
|
toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO), "random string", ""};
|
|
hidl_vec<AudioChannelMask> validChannelMask;
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioChannelMasksFromHal(validAndInvalidChannelMasks, &validChannelMask));
|
|
EXPECT_EQ(1, validChannelMask.size());
|
|
EXPECT_EQ(validAndInvalidChannelMasks[0], validChannelMask[0]);
|
|
|
|
std::vector<std::string> invalidChannelMasks = {"random string", ""};
|
|
hidl_vec<AudioChannelMask> empty;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioChannelMasksFromHal(invalidChannelMasks, &empty));
|
|
EXPECT_EQ(0, empty.size());
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertChannelMasksFromHal) {
|
|
std::vector<std::string> allHalChannelMasks;
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioChannelMask>{}) {
|
|
allHalChannelMasks.push_back(toString(enumVal));
|
|
}
|
|
hidl_vec<AudioChannelMask> allChannelMasks;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioChannelMasksFromHal(allHalChannelMasks, &allChannelMasks));
|
|
EXPECT_EQ(allHalChannelMasks.size(), allChannelMasks.size());
|
|
for (size_t i = 0; i < allHalChannelMasks.size(); ++i) {
|
|
EXPECT_EQ(allHalChannelMasks[i], allChannelMasks[i]);
|
|
}
|
|
}
|
|
|
|
static AudioConfigBase generateValidConfigBase(bool isInput) {
|
|
AudioConfigBase configBase;
|
|
configBase.sampleRateHz = 44100;
|
|
configBase.format = toString(xsd::AudioFormat::AUDIO_FORMAT_PCM_16_BIT);
|
|
configBase.channelMask = isInput ? toString(xsd::AudioChannelMask::AUDIO_CHANNEL_IN_STEREO)
|
|
: toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO);
|
|
return configBase;
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidConfigBase) {
|
|
AudioConfigBase invalid;
|
|
audio_config_base_t halInvalidChannelMask = AUDIO_CONFIG_BASE_INITIALIZER;
|
|
halInvalidChannelMask.channel_mask = kInvalidHalChannelMask;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioConfigBaseFromHal(halInvalidChannelMask, false /*isInput*/,
|
|
&invalid));
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigBaseFromHal(halInvalidChannelMask, true /*isInput*/, &invalid));
|
|
audio_config_base_t halInvalidFormat = AUDIO_CONFIG_BASE_INITIALIZER;
|
|
halInvalidFormat.format = kInvalidHalFormat;
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigBaseFromHal(halInvalidFormat, false /*isInput*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigBaseFromHal(halInvalidFormat, true /*isInput*/, &invalid));
|
|
|
|
audio_config_base_t halInvalid;
|
|
AudioConfigBase invalidChannelMask = generateValidConfigBase(false /*isInput*/);
|
|
invalidChannelMask.channelMask = "random string";
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioConfigBaseToHal(invalidChannelMask, &halInvalid));
|
|
AudioConfigBase invalidFormat = generateValidConfigBase(false /*isInput*/);
|
|
invalidFormat.format = "random string";
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioConfigBaseToHal(invalidFormat, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertConfigBaseDefault) {
|
|
audio_config_base_t halBaseDefault = AUDIO_CONFIG_BASE_INITIALIZER;
|
|
AudioConfigBase baseDefaultOut, baseDefaultIn;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseFromHal(halBaseDefault, false /*isInput*/,
|
|
&baseDefaultOut));
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigBaseFromHal(halBaseDefault, true /*isInput*/, &baseDefaultIn));
|
|
EXPECT_EQ(baseDefaultOut, baseDefaultIn);
|
|
audio_config_base_t halBaseDefaultBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseToHal(baseDefaultOut, &halBaseDefaultBack));
|
|
EXPECT_EQ(halBaseDefault.sample_rate, halBaseDefaultBack.sample_rate);
|
|
EXPECT_EQ(halBaseDefault.channel_mask, halBaseDefaultBack.channel_mask);
|
|
EXPECT_EQ(halBaseDefault.format, halBaseDefaultBack.format);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertConfigBase) {
|
|
AudioConfigBase configBaseOut = generateValidConfigBase(false /*isInput*/);
|
|
audio_config_base_t halConfigBaseOut;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseToHal(configBaseOut, &halConfigBaseOut));
|
|
AudioConfigBase configBaseOutBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseFromHal(halConfigBaseOut, false /*isInput*/,
|
|
&configBaseOutBack));
|
|
EXPECT_EQ(configBaseOut, configBaseOutBack);
|
|
|
|
AudioConfigBase configBaseIn = generateValidConfigBase(true /*isInput*/);
|
|
audio_config_base_t halConfigBaseIn;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseToHal(configBaseIn, &halConfigBaseIn));
|
|
AudioConfigBase configBaseInBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseFromHal(halConfigBaseIn, true /*isInput*/,
|
|
&configBaseInBack));
|
|
EXPECT_EQ(configBaseIn, configBaseInBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidConfigBaseOptional) {
|
|
AudioConfigBaseOptional invalid;
|
|
audio_config_base_t halInvalidChannelMask = AUDIO_CONFIG_BASE_INITIALIZER;
|
|
halInvalidChannelMask.channel_mask = kInvalidHalChannelMask;
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halInvalidChannelMask, false /*isInput*/, false /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, true /*channelMaskSpecified*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halInvalidChannelMask, true /*isInput*/, false /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, true /*channelMaskSpecified*/, &invalid));
|
|
// Unspecified invalid values are ignored
|
|
AudioConfigBaseOptional unspecified;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halInvalidChannelMask, false /*isInput*/, false /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, false /*channelMaskSpecified*/, &unspecified));
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halInvalidChannelMask, true /*isInput*/, false /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, false /*channelMaskSpecified*/, &unspecified));
|
|
audio_config_base_t halInvalidFormat = AUDIO_CONFIG_BASE_INITIALIZER;
|
|
halInvalidFormat.format = kInvalidHalFormat;
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halInvalidFormat, false /*isInput*/, true /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, false /*channelMaskSpecified*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halInvalidFormat, true /*isInput*/, true /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, false /*channelMaskSpecified*/, &invalid));
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halInvalidFormat, false /*isInput*/, false /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, false /*channelMaskSpecified*/, &unspecified));
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halInvalidFormat, true /*isInput*/, false /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, false /*channelMaskSpecified*/, &unspecified));
|
|
|
|
audio_config_base_t halInvalid;
|
|
AudioConfigBaseOptional invalidChannelMask;
|
|
bool formatSpecified, sampleRateSpecified, channelMaskSpecified;
|
|
invalidChannelMask.channelMask.value("random string");
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioConfigBaseOptionalToHal(
|
|
invalidChannelMask, &halInvalid, &formatSpecified,
|
|
&sampleRateSpecified, &channelMaskSpecified));
|
|
AudioConfigBaseOptional invalidFormat;
|
|
invalidFormat.format.value("random string");
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigBaseOptionalToHal(invalidFormat, &halInvalid, &formatSpecified,
|
|
&sampleRateSpecified, &channelMaskSpecified));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertConfigBaseOptionalDefault) {
|
|
audio_config_base_t halBaseDefault = AUDIO_CONFIG_BASE_INITIALIZER;
|
|
AudioConfigBaseOptional baseDefaultUnspecOut, baseDefaultUnspecIn;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halBaseDefault, false /*isInput*/, false /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, false /*channelMaskSpecified*/,
|
|
&baseDefaultUnspecOut));
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halBaseDefault, true /*isInput*/, false /*formatSpecified*/,
|
|
false /*sampleRateSpecified*/, false /*channelMaskSpecified*/,
|
|
&baseDefaultUnspecIn));
|
|
EXPECT_EQ(baseDefaultUnspecOut, baseDefaultUnspecIn);
|
|
audio_config_base_t halBaseDefaultUnspecBack = AUDIO_CONFIG_BASE_INITIALIZER;
|
|
bool formatSpecified, sampleRateSpecified, channelMaskSpecified;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalToHal(
|
|
baseDefaultUnspecOut, &halBaseDefaultUnspecBack, &formatSpecified,
|
|
&sampleRateSpecified, &channelMaskSpecified));
|
|
EXPECT_FALSE(formatSpecified);
|
|
EXPECT_FALSE(sampleRateSpecified);
|
|
EXPECT_FALSE(channelMaskSpecified);
|
|
EXPECT_EQ(halBaseDefault.sample_rate, halBaseDefaultUnspecBack.sample_rate);
|
|
EXPECT_EQ(halBaseDefault.channel_mask, halBaseDefaultUnspecBack.channel_mask);
|
|
EXPECT_EQ(halBaseDefault.format, halBaseDefaultUnspecBack.format);
|
|
|
|
AudioConfigBaseOptional baseDefaultSpecOut, baseDefaultSpecIn;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halBaseDefault, false /*isInput*/, true /*formatSpecified*/,
|
|
true /*sampleRateSpecified*/, true /*channelMaskSpecified*/,
|
|
&baseDefaultSpecOut));
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halBaseDefault, true /*isInput*/, true /*formatSpecified*/,
|
|
true /*sampleRateSpecified*/, true /*channelMaskSpecified*/,
|
|
&baseDefaultSpecIn));
|
|
EXPECT_EQ(baseDefaultSpecOut, baseDefaultSpecIn);
|
|
audio_config_base_t halBaseDefaultSpecBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalToHal(
|
|
baseDefaultSpecOut, &halBaseDefaultSpecBack, &formatSpecified,
|
|
&sampleRateSpecified, &channelMaskSpecified));
|
|
EXPECT_TRUE(formatSpecified);
|
|
EXPECT_TRUE(sampleRateSpecified);
|
|
EXPECT_TRUE(channelMaskSpecified);
|
|
EXPECT_EQ(halBaseDefault.sample_rate, halBaseDefaultSpecBack.sample_rate);
|
|
EXPECT_EQ(halBaseDefault.channel_mask, halBaseDefaultSpecBack.channel_mask);
|
|
EXPECT_EQ(halBaseDefault.format, halBaseDefaultSpecBack.format);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertConfigBaseOptionalEmpty) {
|
|
AudioConfigBaseOptional empty;
|
|
bool formatSpecified, sampleRateSpecified, channelMaskSpecified;
|
|
audio_config_base_t halEmpty = AUDIO_CONFIG_BASE_INITIALIZER;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigBaseOptionalToHal(empty, &halEmpty, &formatSpecified,
|
|
&sampleRateSpecified, &channelMaskSpecified));
|
|
EXPECT_FALSE(formatSpecified);
|
|
EXPECT_FALSE(sampleRateSpecified);
|
|
EXPECT_FALSE(channelMaskSpecified);
|
|
AudioConfigBaseOptional emptyOutBack, emptyInBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halEmpty, false /*isInput*/, formatSpecified, sampleRateSpecified,
|
|
channelMaskSpecified, &emptyOutBack));
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halEmpty, true /*isInput*/, formatSpecified, sampleRateSpecified,
|
|
channelMaskSpecified, &emptyInBack));
|
|
EXPECT_EQ(emptyOutBack, emptyInBack);
|
|
EXPECT_EQ(empty, emptyOutBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertConfigBaseOptional) {
|
|
AudioConfigBase validBaseOut = generateValidConfigBase(false /*isInput*/);
|
|
AudioConfigBaseOptional configBaseOut;
|
|
configBaseOut.format.value(validBaseOut.format);
|
|
configBaseOut.sampleRateHz.value(validBaseOut.sampleRateHz);
|
|
configBaseOut.channelMask.value(validBaseOut.channelMask);
|
|
audio_config_base_t halConfigBaseOut;
|
|
bool formatSpecified, sampleRateSpecified, channelMaskSpecified;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalToHal(
|
|
configBaseOut, &halConfigBaseOut, &formatSpecified,
|
|
&sampleRateSpecified, &channelMaskSpecified));
|
|
EXPECT_TRUE(formatSpecified);
|
|
EXPECT_TRUE(sampleRateSpecified);
|
|
EXPECT_TRUE(channelMaskSpecified);
|
|
AudioConfigBaseOptional configBaseOutBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halConfigBaseOut, false /*isInput*/, formatSpecified,
|
|
sampleRateSpecified, channelMaskSpecified, &configBaseOutBack));
|
|
EXPECT_EQ(configBaseOut, configBaseOutBack);
|
|
|
|
AudioConfigBase validBaseIn = generateValidConfigBase(true /*isInput*/);
|
|
AudioConfigBaseOptional configBaseIn;
|
|
configBaseIn.format.value(validBaseIn.format);
|
|
configBaseIn.sampleRateHz.value(validBaseIn.sampleRateHz);
|
|
configBaseIn.channelMask.value(validBaseIn.channelMask);
|
|
audio_config_base_t halConfigBaseIn;
|
|
formatSpecified = false;
|
|
sampleRateSpecified = false;
|
|
channelMaskSpecified = false;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalToHal(
|
|
configBaseIn, &halConfigBaseIn, &formatSpecified,
|
|
&sampleRateSpecified, &channelMaskSpecified));
|
|
EXPECT_TRUE(formatSpecified);
|
|
EXPECT_TRUE(sampleRateSpecified);
|
|
EXPECT_TRUE(channelMaskSpecified);
|
|
AudioConfigBaseOptional configBaseInBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigBaseOptionalFromHal(
|
|
halConfigBaseIn, true /*isInput*/, formatSpecified,
|
|
sampleRateSpecified, channelMaskSpecified, &configBaseInBack));
|
|
EXPECT_EQ(configBaseIn, configBaseInBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidContentType) {
|
|
AudioContentType invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioContentTypeFromHal(kInvalidHalContentType, &invalid));
|
|
audio_content_type_t halInvalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioContentTypeToHal("", &halInvalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioContentTypeToHal("random string", &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertContentType) {
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioContentType>{}) {
|
|
const AudioContentType contentType = toString(enumVal);
|
|
audio_content_type_t halContentType;
|
|
AudioContentType contentTypeBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioContentTypeToHal(contentType, &halContentType))
|
|
<< "Conversion of \"" << contentType << "\" failed";
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioContentTypeFromHal(halContentType, &contentTypeBack))
|
|
<< "Conversion of content type " << halContentType << " failed";
|
|
EXPECT_EQ(contentType, contentTypeBack);
|
|
}
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidDeviceType) {
|
|
AudioDevice invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioDeviceTypeFromHal(kInvalidHalDevice, &invalid));
|
|
audio_devices_t halInvalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioDeviceTypeToHal("", &halInvalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioDeviceTypeToHal("random string", &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertDeviceType) {
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioDevice>{}) {
|
|
const AudioDevice deviceType = toString(enumVal);
|
|
audio_devices_t halDeviceType, halDeviceTypeBack;
|
|
AudioDevice deviceTypeBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioDeviceTypeToHal(deviceType, &halDeviceType))
|
|
<< "Conversion of \"" << deviceType << "\" failed";
|
|
if (enumVal != xsd::AudioDevice::AUDIO_DEVICE_NONE) {
|
|
EXPECT_TRUE(audio_is_input_device(halDeviceType) ||
|
|
audio_is_output_device(halDeviceType))
|
|
<< "Device \"" << deviceType << "\" is neither input, nor output device";
|
|
} else {
|
|
EXPECT_FALSE(audio_is_input_device(halDeviceType));
|
|
EXPECT_FALSE(audio_is_output_device(halDeviceType));
|
|
}
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioDeviceTypeFromHal(halDeviceType, &deviceTypeBack))
|
|
<< "Conversion of device type " << halDeviceType << " failed";
|
|
// Due to aliased values, the result of 'fromHal' might not be the same
|
|
// as 'deviceType', thus we need to compare the results of 'toHal' conversion instead.
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioDeviceTypeToHal(deviceTypeBack, &halDeviceTypeBack))
|
|
<< "Conversion of \"" << deviceTypeBack << "\" failed";
|
|
EXPECT_EQ(halDeviceType, halDeviceTypeBack);
|
|
}
|
|
}
|
|
|
|
// The enums module is too small to have unit tests on its own.
|
|
TEST(HidlUtils, VendorExtension) {
|
|
EXPECT_TRUE(xsd::isVendorExtension("VX_GOOGLE_VR_42"));
|
|
EXPECT_TRUE(xsd::isVendorExtension("VX_QCM_SPK"));
|
|
EXPECT_FALSE(xsd::isVendorExtension(""));
|
|
EXPECT_FALSE(xsd::isVendorExtension("random string"));
|
|
EXPECT_FALSE(xsd::isVendorExtension("VX_"));
|
|
EXPECT_FALSE(xsd::isVendorExtension("VX_X"));
|
|
EXPECT_FALSE(xsd::isVendorExtension("VX_X_"));
|
|
EXPECT_FALSE(xsd::isVendorExtension("VX_X_X"));
|
|
EXPECT_FALSE(xsd::isVendorExtension("VX_XX_X"));
|
|
EXPECT_FALSE(xsd::isVendorExtension("VX_GOOGLE_$$"));
|
|
EXPECT_FALSE(xsd::isVendorExtension("VX_$CM_SPK"));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidDeviceAddress) {
|
|
DeviceAddress invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::deviceAddressFromHal(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER,
|
|
nullptr, &invalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::deviceAddressFromHal(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER,
|
|
"", &invalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::deviceAddressFromHal(AUDIO_DEVICE_OUT_IP, nullptr, &invalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::deviceAddressFromHal(AUDIO_DEVICE_OUT_IP, "", &invalid));
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::deviceAddressFromHal(AUDIO_DEVICE_OUT_USB_HEADSET, nullptr, &invalid));
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::deviceAddressFromHal(AUDIO_DEVICE_OUT_USB_HEADSET, "", &invalid));
|
|
|
|
audio_devices_t halInvalid;
|
|
char halAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN] = {};
|
|
invalid = {};
|
|
invalid.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER);
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::deviceAddressToHal(invalid, &halInvalid, halAddress));
|
|
invalid.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_IP);
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::deviceAddressToHal(invalid, &halInvalid, halAddress));
|
|
invalid.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_USB_HEADSET);
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::deviceAddressToHal(invalid, &halInvalid, halAddress));
|
|
}
|
|
|
|
static void ConvertDeviceAddress(const DeviceAddress& device) {
|
|
audio_devices_t halDeviceType;
|
|
char halDeviceAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN] = {};
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::deviceAddressToHal(device, &halDeviceType, halDeviceAddress));
|
|
DeviceAddress deviceBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::deviceAddressFromHal(halDeviceType, halDeviceAddress, &deviceBack));
|
|
EXPECT_EQ(device, deviceBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertUniqueDeviceAddress) {
|
|
DeviceAddress speaker;
|
|
speaker.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_SPEAKER);
|
|
ConvertDeviceAddress(speaker);
|
|
|
|
DeviceAddress micWithAddress;
|
|
micWithAddress.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_IN_BUILTIN_MIC);
|
|
micWithAddress.address.id("bottom");
|
|
ConvertDeviceAddress(micWithAddress);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertA2dpDeviceAddress) {
|
|
DeviceAddress a2dpSpeaker;
|
|
a2dpSpeaker.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER);
|
|
a2dpSpeaker.address.mac(std::array<uint8_t, 6>{1, 2, 3, 4, 5, 6});
|
|
ConvertDeviceAddress(a2dpSpeaker);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertIpv4DeviceAddress) {
|
|
DeviceAddress ipv4;
|
|
ipv4.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_IP);
|
|
ipv4.address.ipv4(std::array<uint8_t, 4>{1, 2, 3, 4});
|
|
ConvertDeviceAddress(ipv4);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertUsbDeviceAddress) {
|
|
DeviceAddress usbHeadset;
|
|
usbHeadset.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_USB_HEADSET);
|
|
usbHeadset.address.alsa({1, 2});
|
|
ConvertDeviceAddress(usbHeadset);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertBusDeviceAddress) {
|
|
DeviceAddress bus;
|
|
bus.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_BUS);
|
|
bus.address.id("bus_device");
|
|
ConvertDeviceAddress(bus);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertRSubmixDeviceAddress) {
|
|
DeviceAddress rSubmix;
|
|
rSubmix.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_REMOTE_SUBMIX);
|
|
rSubmix.address.id(AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS);
|
|
ConvertDeviceAddress(rSubmix);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertVendorDeviceAddress) {
|
|
// The address part is not mandatory, both cases must work.
|
|
{
|
|
DeviceAddress vendor;
|
|
vendor.deviceType = "VX_GOOGLE_VR";
|
|
audio_devices_t halDeviceType;
|
|
char halDeviceAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN] = {};
|
|
// Ignore the result. Vendors will also add the extended device into
|
|
// the list of devices in audio-hal-enums.h. Without that, the conversion
|
|
// officially fails, but it still maps the device type to NONE.
|
|
(void)HidlUtils::deviceAddressToHal(vendor, &halDeviceType, halDeviceAddress);
|
|
EXPECT_EQ(AUDIO_DEVICE_NONE, halDeviceType);
|
|
EXPECT_EQ(0, strnlen(halDeviceAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN));
|
|
}
|
|
{
|
|
DeviceAddress vendor;
|
|
vendor.deviceType = "VX_GOOGLE_VR";
|
|
vendor.address.id("vr1");
|
|
audio_devices_t halDeviceType;
|
|
char halDeviceAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN] = {};
|
|
// Ignore the result. Vendors will also add the extended device into
|
|
// the list of devices in audio-hal-enums.h. Without that, the conversion
|
|
// officially fails, but it still maps the device type to NONE and converts
|
|
// the address.
|
|
(void)HidlUtils::deviceAddressToHal(vendor, &halDeviceType, halDeviceAddress);
|
|
EXPECT_EQ(AUDIO_DEVICE_NONE, halDeviceType);
|
|
EXPECT_EQ(0, strncmp("vr1", halDeviceAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN));
|
|
}
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidFormat) {
|
|
AudioFormat invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioFormatFromHal(kInvalidHalFormat, &invalid));
|
|
audio_format_t halInvalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioFormatToHal("", &halInvalid));
|
|
// INVALID format is not in XSD thus it's not allowed for transfer over HIDL.
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioFormatToHal("AUDIO_FORMAT_INVALID", &halInvalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioFormatToHal("random string", &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertFormat) {
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioFormat>{}) {
|
|
const AudioFormat format = toString(enumVal);
|
|
audio_format_t halFormat;
|
|
AudioFormat formatBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioFormatToHal(format, &halFormat))
|
|
<< "Conversion of \"" << format << "\" failed";
|
|
EXPECT_EQ(enumVal != xsd::AudioFormat::AUDIO_FORMAT_DEFAULT,
|
|
audio_is_valid_format(halFormat))
|
|
<< "Validity of \"" << format << "\" is not as expected";
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioFormatFromHal(halFormat, &formatBack))
|
|
<< "Conversion of format " << halFormat << " failed";
|
|
EXPECT_EQ(format, formatBack);
|
|
}
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidFormatsFromHal) {
|
|
std::vector<std::string> validAndInvalidFormats = {
|
|
toString(xsd::AudioFormat::AUDIO_FORMAT_PCM_16_BIT), "random string", ""};
|
|
hidl_vec<AudioFormat> validFormat;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioFormatsFromHal(validAndInvalidFormats, &validFormat));
|
|
EXPECT_EQ(1, validFormat.size());
|
|
EXPECT_EQ(validAndInvalidFormats[0], validFormat[0]);
|
|
|
|
std::vector<std::string> invalidFormats = {"random string", ""};
|
|
hidl_vec<AudioFormat> empty;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioFormatsFromHal(invalidFormats, &empty));
|
|
EXPECT_EQ(0, empty.size());
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertFormatsFromHal) {
|
|
std::vector<std::string> allHalFormats;
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioFormat>{}) {
|
|
allHalFormats.push_back(toString(enumVal));
|
|
}
|
|
hidl_vec<AudioFormat> allFormats;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioFormatsFromHal(allHalFormats, &allFormats));
|
|
EXPECT_EQ(allHalFormats.size(), allFormats.size());
|
|
for (size_t i = 0; i < allHalFormats.size(); ++i) {
|
|
EXPECT_EQ(allHalFormats[i], allFormats[i]);
|
|
}
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidGainModeMask) {
|
|
hidl_vec<AudioGainMode> invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioGainModeMaskFromHal(kInvalidHalGainMode, &invalid));
|
|
audio_gain_mode_t halInvalid;
|
|
invalid.resize(1);
|
|
invalid[0] = "random string";
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioGainModeMaskToHal(invalid, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertGainModeMask) {
|
|
hidl_vec<AudioGainMode> emptyGainModes;
|
|
audio_gain_mode_t halEmptyGainModes;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioGainModeMaskToHal(emptyGainModes, &halEmptyGainModes));
|
|
hidl_vec<AudioGainMode> emptyGainModesBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioGainModeMaskFromHal(halEmptyGainModes, &emptyGainModesBack));
|
|
EXPECT_EQ(emptyGainModes, emptyGainModesBack);
|
|
|
|
std::vector<std::string> allEnumValues;
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioGainMode>{}) {
|
|
allEnumValues.push_back(toString(enumVal));
|
|
}
|
|
hidl_vec<AudioGainMode> allGainModes;
|
|
allGainModes.resize(allEnumValues.size());
|
|
for (size_t i = 0; i < allEnumValues.size(); ++i) {
|
|
allGainModes[i] = allEnumValues[i];
|
|
}
|
|
audio_gain_mode_t halAllGainModes;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioGainModeMaskToHal(allGainModes, &halAllGainModes));
|
|
hidl_vec<AudioGainMode> allGainModesBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioGainModeMaskFromHal(halAllGainModes, &allGainModesBack));
|
|
EXPECT_EQ(allGainModes, allGainModesBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidSource) {
|
|
AudioSource invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioSourceFromHal(kInvalidHalSource, &invalid));
|
|
audio_source_t halInvalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioSourceToHal("", &halInvalid));
|
|
// INVALID source is not in XSD thus it's not allowed for transfer over HIDL.
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioSourceToHal("AUDIO_SOURCE_INVALID", &halInvalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioSourceToHal("random string", &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertSource) {
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioSource>{}) {
|
|
const AudioSource source = toString(enumVal);
|
|
audio_source_t halSource;
|
|
AudioSource sourceBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioSourceToHal(source, &halSource))
|
|
<< "Conversion of \"" << source << "\" failed";
|
|
EXPECT_EQ(enumVal != xsd::AudioSource::AUDIO_SOURCE_DEFAULT,
|
|
audio_is_valid_audio_source(halSource))
|
|
<< "Validity of \"" << source << "\" is not as expected";
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioSourceFromHal(halSource, &sourceBack))
|
|
<< "Conversion of source " << halSource << " failed";
|
|
EXPECT_EQ(source, sourceBack);
|
|
}
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidStreamType) {
|
|
AudioStreamType invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioStreamTypeFromHal(kInvalidHalStreamType, &invalid));
|
|
audio_stream_type_t halInvalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioStreamTypeToHal("random string", &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertDefaultStreamType) {
|
|
AudioStreamType streamDefault = "";
|
|
audio_stream_type_t halStreamDefault;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioStreamTypeToHal(streamDefault, &halStreamDefault));
|
|
AudioStreamType streamDefaultBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioStreamTypeFromHal(halStreamDefault, &streamDefaultBack));
|
|
EXPECT_EQ(streamDefault, streamDefaultBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertStreamType) {
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioStreamType>{}) {
|
|
const AudioStreamType streamType = toString(enumVal);
|
|
audio_stream_type_t halStreamType;
|
|
AudioStreamType streamTypeBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioStreamTypeToHal(streamType, &halStreamType))
|
|
<< "Conversion of \"" << streamType << "\" failed";
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioStreamTypeFromHal(halStreamType, &streamTypeBack))
|
|
<< "Conversion of stream type " << halStreamType << " failed";
|
|
EXPECT_EQ(streamType, streamTypeBack);
|
|
}
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidGain) {
|
|
AudioGain invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioGainFromHal({.mode = kInvalidHalGainMode},
|
|
false /*isInput*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioGainFromHal({.mode = kInvalidHalGainMode},
|
|
true /*isInput*/, &invalid));
|
|
struct audio_gain halInvalid;
|
|
invalid.mode.resize(1);
|
|
invalid.mode[0] = "random string";
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioGainToHal(invalid, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertGain) {
|
|
AudioGain gain = {};
|
|
gain.channelMask = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO);
|
|
struct audio_gain halGain;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioGainToHal(gain, &halGain));
|
|
AudioGain gainBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioGainFromHal(halGain, false /*isInput*/, &gainBack));
|
|
EXPECT_EQ(gain, gainBack);
|
|
struct audio_gain halGainBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioGainToHal(gainBack, &halGainBack));
|
|
EXPECT_TRUE(audio_gains_are_equal(&halGain, &halGainBack));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidGainConfig) {
|
|
AudioGainConfig invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioGainConfigFromHal({.mode = kInvalidHalGainMode},
|
|
false /*isInput*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioGainConfigFromHal({.mode = kInvalidHalGainMode},
|
|
true /*isInput*/, &invalid));
|
|
struct audio_gain_config halInvalid;
|
|
invalid.mode.resize(1);
|
|
invalid.mode[0] = "random string";
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioGainConfigToHal(invalid, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertGainConfig) {
|
|
AudioGainConfig gainConfig = {};
|
|
gainConfig.channelMask = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO);
|
|
struct audio_gain_config halGainConfig;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioGainConfigToHal(gainConfig, &halGainConfig));
|
|
AudioGainConfig gainConfigBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioGainConfigFromHal(halGainConfig, false /*isInput*/, &gainConfigBack));
|
|
EXPECT_EQ(gainConfig, gainConfigBack);
|
|
struct audio_gain_config halGainConfigBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioGainConfigToHal(gainConfigBack, &halGainConfigBack));
|
|
EXPECT_TRUE(audio_gain_config_are_equal(&halGainConfig, &halGainConfigBack));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidUsage) {
|
|
AudioUsage invalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioUsageFromHal(kInvalidHalUsage, &invalid));
|
|
audio_usage_t halInvalid;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioUsageToHal("", &halInvalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioUsageToHal("random string", &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertUsage) {
|
|
for (const auto enumVal : xsdc_enum_range<xsd::AudioUsage>{}) {
|
|
const AudioUsage usage = toString(enumVal);
|
|
audio_usage_t halUsage;
|
|
AudioUsage usageBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioUsageToHal(usage, &halUsage))
|
|
<< "Conversion of \"" << usage << "\" failed";
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioUsageFromHal(halUsage, &usageBack))
|
|
<< "Conversion of usage " << halUsage << " failed";
|
|
EXPECT_EQ(usage, usageBack);
|
|
}
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidOffloadInfo) {
|
|
AudioOffloadInfo invalid;
|
|
audio_offload_info_t halInvalid = AUDIO_INFO_INITIALIZER;
|
|
halInvalid.channel_mask = kInvalidHalChannelMask;
|
|
halInvalid.format = kInvalidHalFormat;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioOffloadInfoFromHal(halInvalid, &invalid));
|
|
invalid.base.channelMask = "random string";
|
|
invalid.base.format = "random string";
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioOffloadInfoToHal(invalid, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertOffloadInfo) {
|
|
AudioOffloadInfo offloadInfo = {};
|
|
offloadInfo.base = generateValidConfigBase(false /*isInput*/);
|
|
offloadInfo.streamType = toString(xsd::AudioStreamType::AUDIO_STREAM_MUSIC);
|
|
offloadInfo.bitRatePerSecond = 320;
|
|
offloadInfo.durationMicroseconds = -1;
|
|
offloadInfo.bitWidth = 16;
|
|
offloadInfo.bufferSize = 1024;
|
|
offloadInfo.usage = toString(xsd::AudioUsage::AUDIO_USAGE_MEDIA);
|
|
offloadInfo.encapsulationMode = AudioEncapsulationMode::ELEMENTARY_STREAM;
|
|
offloadInfo.contentId = 42;
|
|
offloadInfo.syncId = 13;
|
|
audio_offload_info_t halOffloadInfo;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioOffloadInfoToHal(offloadInfo, &halOffloadInfo));
|
|
AudioOffloadInfo offloadInfoBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioOffloadInfoFromHal(halOffloadInfo, &offloadInfoBack));
|
|
EXPECT_EQ(offloadInfo, offloadInfoBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidConfig) {
|
|
AudioConfig invalid;
|
|
audio_config_t halInvalidChannelMask = AUDIO_CONFIG_INITIALIZER;
|
|
halInvalidChannelMask.channel_mask = kInvalidHalChannelMask;
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigFromHal(halInvalidChannelMask, false /*isInput*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigFromHal(halInvalidChannelMask, true /*isInput*/, &invalid));
|
|
audio_config_t halInvalidFormat = AUDIO_CONFIG_INITIALIZER;
|
|
halInvalidFormat.format = kInvalidHalFormat;
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigFromHal(halInvalidFormat, false /*isInput*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioConfigFromHal(halInvalidFormat, true /*isInput*/, &invalid));
|
|
|
|
AudioConfig invalidChannelMask;
|
|
audio_config_t halInvalid;
|
|
invalidChannelMask.base.channelMask = "random string";
|
|
invalidChannelMask.base.format = toString(xsd::AudioFormat::AUDIO_FORMAT_DEFAULT);
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioConfigToHal(invalidChannelMask, &halInvalid));
|
|
AudioConfig invalidFormat;
|
|
invalidFormat.base.format = "random string";
|
|
invalidFormat.base.channelMask = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_NONE);
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioConfigToHal(invalidFormat, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertConfigDefault) {
|
|
audio_config_t halDefault = AUDIO_CONFIG_INITIALIZER;
|
|
AudioConfig defaultOut, defaultIn;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigFromHal(halDefault, false /*isInput*/, &defaultOut));
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigFromHal(halDefault, true /*isInput*/, &defaultIn));
|
|
EXPECT_EQ(defaultOut, defaultIn);
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigToHal(defaultOut, &halDefault));
|
|
|
|
// Note: empty channel mask and config are not valid values.
|
|
AudioConfig defaultCfg{};
|
|
defaultCfg.base.channelMask = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_NONE);
|
|
defaultCfg.base.format = toString(xsd::AudioFormat::AUDIO_FORMAT_DEFAULT);
|
|
audio_config_t halDefaultCfg;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigToHal(defaultCfg, &halDefaultCfg));
|
|
AudioConfig defaultCfgBackOut, defaultCfgBackIn;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigFromHal(halDefaultCfg, false /*isInput*/, &defaultCfgBackOut));
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigFromHal(halDefaultCfg, true /*isInput*/, &defaultCfgBackIn));
|
|
EXPECT_EQ(defaultCfgBackOut, defaultCfgBackIn);
|
|
EXPECT_EQ(defaultCfg, defaultCfgBackOut);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertConfig) {
|
|
AudioConfig configOut{};
|
|
configOut.base = generateValidConfigBase(false /*isInput*/);
|
|
audio_config_t halConfigOut;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigToHal(configOut, &halConfigOut));
|
|
AudioConfig configOutBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigFromHal(halConfigOut, false /*isInput*/, &configOutBack));
|
|
EXPECT_EQ(configOut, configOutBack);
|
|
|
|
AudioConfig configIn{};
|
|
configIn.base = generateValidConfigBase(true /*isInput*/);
|
|
audio_config_t halConfigIn;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigToHal(configIn, &halConfigIn));
|
|
AudioConfig configInBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioConfigFromHal(halConfigIn, true /*isInput*/, &configInBack));
|
|
EXPECT_EQ(configIn, configInBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertConfigWithOffloadInfo) {
|
|
AudioConfig config = {};
|
|
config.base = generateValidConfigBase(false /*isInput*/);
|
|
config.offloadInfo.info(
|
|
AudioOffloadInfo{.base = config.base,
|
|
.streamType = toString(xsd::AudioStreamType::AUDIO_STREAM_MUSIC),
|
|
.bitRatePerSecond = 320,
|
|
.durationMicroseconds = -1,
|
|
.bitWidth = 16,
|
|
.bufferSize = 1024,
|
|
.usage = toString(xsd::AudioUsage::AUDIO_USAGE_MEDIA),
|
|
.encapsulationMode = AudioEncapsulationMode::ELEMENTARY_STREAM,
|
|
.contentId = 42,
|
|
.syncId = 13});
|
|
audio_config_t halConfig;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigToHal(config, &halConfig));
|
|
AudioConfig configBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioConfigFromHal(halConfig, false /*isInput*/, &configBack));
|
|
EXPECT_EQ(config, configBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidAudioProfile) {
|
|
AudioProfile invalid;
|
|
struct audio_profile halInvalid = {};
|
|
halInvalid.format = kInvalidHalFormat;
|
|
halInvalid.num_sample_rates = 0;
|
|
halInvalid.num_channel_masks = 1;
|
|
halInvalid.channel_masks[0] = kInvalidHalChannelMask;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioProfileFromHal(halInvalid, false /*isInput*/, &invalid));
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioProfileFromHal(halInvalid, true /*isInput*/, &invalid));
|
|
invalid.format = "random string";
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioProfileToHal(invalid, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertAudioProfile) {
|
|
AudioProfile profile = {};
|
|
profile.format = toString(xsd::AudioFormat::AUDIO_FORMAT_PCM_16_BIT);
|
|
profile.sampleRates.resize(2);
|
|
profile.sampleRates[0] = 44100;
|
|
profile.sampleRates[1] = 48000;
|
|
profile.channelMasks.resize(2);
|
|
profile.channelMasks[0] = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_MONO);
|
|
profile.channelMasks[1] = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO);
|
|
struct audio_profile halProfile;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioProfileToHal(profile, &halProfile));
|
|
AudioProfile profileBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioProfileFromHal(halProfile, false /*isInput*/, &profileBack));
|
|
EXPECT_EQ(profile, profileBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidAudioPortConfig) {
|
|
AudioPortConfig invalid;
|
|
struct audio_port_config halInvalid = {};
|
|
halInvalid.type = AUDIO_PORT_TYPE_MIX;
|
|
halInvalid.role = AUDIO_PORT_ROLE_NONE; // note: this is valid.
|
|
halInvalid.config_mask = AUDIO_PORT_CONFIG_CHANNEL_MASK;
|
|
halInvalid.channel_mask = kInvalidHalChannelMask;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioPortConfigFromHal(halInvalid, &invalid));
|
|
invalid.base.channelMask.value("random string");
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioPortConfigToHal(invalid, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertAudioPortConfig) {
|
|
AudioPortConfig config = {};
|
|
config.id = 42;
|
|
config.base.sampleRateHz.value(44100);
|
|
config.base.channelMask.value(toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO));
|
|
config.base.format.value(toString(xsd::AudioFormat::AUDIO_FORMAT_PCM_16_BIT));
|
|
config.gain.config({});
|
|
config.gain.config().channelMask = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO);
|
|
config.ext.device({});
|
|
config.ext.device().deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_SPEAKER);
|
|
struct audio_port_config halConfig;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioPortConfigToHal(config, &halConfig));
|
|
AudioPortConfig configBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioPortConfigFromHal(halConfig, &configBack));
|
|
EXPECT_EQ(config, configBack);
|
|
struct audio_port_config halConfigBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioPortConfigToHal(configBack, &halConfigBack));
|
|
EXPECT_TRUE(audio_port_configs_are_equal(&halConfig, &halConfigBack));
|
|
}
|
|
|
|
static AudioProfile generateValidAudioProfile() {
|
|
AudioProfile profile;
|
|
profile.format = toString(xsd::AudioFormat::AUDIO_FORMAT_PCM_16_BIT);
|
|
profile.sampleRates.resize(2);
|
|
profile.sampleRates[0] = 44100;
|
|
profile.sampleRates[1] = 48000;
|
|
profile.channelMasks.resize(2);
|
|
profile.channelMasks[0] = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_MONO);
|
|
profile.channelMasks[1] = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO);
|
|
return profile;
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidAudioTransports) {
|
|
hidl_vec<AudioTransport> invalid;
|
|
struct audio_port_v7 halInvalid = {};
|
|
halInvalid.num_audio_profiles = 1;
|
|
halInvalid.audio_profiles[0].format = kInvalidHalFormat;
|
|
halInvalid.audio_profiles[0].encapsulation_type = kInvalidEncapsulationType;
|
|
halInvalid.num_extra_audio_descriptors = 1;
|
|
halInvalid.extra_audio_descriptors[0].standard = kInvalidAudioStandard;
|
|
halInvalid.extra_audio_descriptors[0].descriptor_length = EXTRA_AUDIO_DESCRIPTOR_SIZE + 1;
|
|
EXPECT_EQ(BAD_VALUE,
|
|
HidlUtils::audioTransportsFromHal(halInvalid, false /*isInput*/, &invalid));
|
|
invalid.resize(2);
|
|
AudioProfile invalidProfile;
|
|
invalidProfile.format = "random string";
|
|
invalid[0].audioCapability.profile(invalidProfile);
|
|
invalid[0].encapsulationType = "random string";
|
|
invalid[0].audioCapability.edid(hidl_vec<uint8_t>(EXTRA_AUDIO_DESCRIPTOR_SIZE + 1));
|
|
invalid[1].encapsulationType = "random string";
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioTransportsToHal(invalid, &halInvalid));
|
|
|
|
// The size of audio profile must not be greater than the maximum value.
|
|
invalid.resize(0);
|
|
invalid.resize(AUDIO_PORT_MAX_AUDIO_PROFILES + 1);
|
|
for (size_t i = 0; i < invalid.size(); ++i) {
|
|
invalid[i].audioCapability.profile(generateValidAudioProfile());
|
|
invalid[i].encapsulationType =
|
|
toString(xsd::AudioEncapsulationType::AUDIO_ENCAPSULATION_TYPE_NONE);
|
|
}
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioTransportsToHal(invalid, &halInvalid));
|
|
|
|
// The size of extra audio descriptors must not be greater than the maximum value.
|
|
invalid.resize(0);
|
|
invalid.resize(AUDIO_PORT_MAX_EXTRA_AUDIO_DESCRIPTORS + 1);
|
|
for (size_t i = 0; i < invalid.size(); ++i) {
|
|
invalid[i].audioCapability.edid({0x11, 0x06, 0x01});
|
|
invalid[i].encapsulationType =
|
|
toString(xsd::AudioEncapsulationType::AUDIO_ENCAPSULATION_TYPE_IEC61937);
|
|
}
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioTransportsToHal(invalid, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertAudioTransports) {
|
|
hidl_vec<AudioTransport> transports;
|
|
transports.resize(2);
|
|
transports[0].audioCapability.profile(generateValidAudioProfile());
|
|
hidl_vec<uint8_t> shortAudioDescriptor({0x11, 0x06, 0x01});
|
|
transports[0].encapsulationType =
|
|
toString(xsd::AudioEncapsulationType::AUDIO_ENCAPSULATION_TYPE_NONE);
|
|
transports[1].audioCapability.edid(std::move(shortAudioDescriptor));
|
|
transports[1].encapsulationType =
|
|
toString(xsd::AudioEncapsulationType::AUDIO_ENCAPSULATION_TYPE_IEC61937);
|
|
struct audio_port_v7 halPort;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioTransportsToHal(transports, &halPort));
|
|
hidl_vec<AudioTransport> transportsBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioTransportsFromHal(halPort, false /*isInput*/, &transportsBack));
|
|
EXPECT_EQ(transports, transportsBack);
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidAudioPort) {
|
|
AudioPort invalid;
|
|
struct audio_port_v7 halInvalid = {};
|
|
halInvalid.type = AUDIO_PORT_TYPE_MIX;
|
|
halInvalid.role = AUDIO_PORT_ROLE_NONE; // note: this is valid.
|
|
halInvalid.num_audio_profiles = 1;
|
|
halInvalid.audio_profiles[0].format = kInvalidHalFormat;
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioPortFromHal(halInvalid, &invalid));
|
|
invalid.transports.resize(1);
|
|
AudioProfile invalidProfile;
|
|
invalidProfile.format = "random string";
|
|
invalid.transports[0].audioCapability.profile(invalidProfile);
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioPortToHal(invalid, &halInvalid));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertAudioPort) {
|
|
AudioPort port = {};
|
|
port.id = 42;
|
|
port.name = "test";
|
|
port.transports.resize(2);
|
|
AudioProfile profile;
|
|
profile.format = toString(xsd::AudioFormat::AUDIO_FORMAT_PCM_16_BIT);
|
|
profile.sampleRates.resize(2);
|
|
profile.sampleRates[0] = 44100;
|
|
profile.sampleRates[1] = 48000;
|
|
profile.channelMasks.resize(2);
|
|
profile.channelMasks[0] = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_MONO);
|
|
profile.channelMasks[1] = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO);
|
|
port.transports[0].audioCapability.profile(profile);
|
|
port.transports[0].encapsulationType =
|
|
toString(xsd::AudioEncapsulationType::AUDIO_ENCAPSULATION_TYPE_NONE);
|
|
hidl_vec<uint8_t> shortAudioDescriptor({0x11, 0x06, 0x01});
|
|
port.transports[1].audioCapability.edid(std::move(shortAudioDescriptor));
|
|
port.transports[1].encapsulationType =
|
|
toString(xsd::AudioEncapsulationType::AUDIO_ENCAPSULATION_TYPE_IEC61937);
|
|
port.gains.resize(1);
|
|
port.gains[0].channelMask = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO);
|
|
port.ext.device({});
|
|
port.ext.device().deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_SPEAKER);
|
|
// active config left unspecified.
|
|
struct audio_port_v7 halPort;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioPortToHal(port, &halPort));
|
|
AudioPort portBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioPortFromHal(halPort, &portBack));
|
|
EXPECT_EQ(port, portBack);
|
|
struct audio_port_v7 halPortBack;
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioPortToHal(portBack, &halPortBack));
|
|
EXPECT_TRUE(audio_ports_v7_are_equal(&halPort, &halPortBack));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertInvalidAudioTags) {
|
|
char halTag[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE] = {};
|
|
|
|
hidl_vec<AudioTag> emptyTag = {{""}};
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioTagsToHal(emptyTag, halTag));
|
|
|
|
hidl_vec<AudioTag> longTag = {{std::string(AUDIO_ATTRIBUTES_TAGS_MAX_SIZE + 1, 'A')}};
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioTagsToHal(longTag, halTag));
|
|
|
|
hidl_vec<AudioTag> tagSeparator = {
|
|
{std::string(AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1, HidlUtils::sAudioTagSeparator)}};
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioTagsToHal(tagSeparator, halTag));
|
|
|
|
hidl_vec<AudioTag> notExtensions = {{"", "random string", "VX_", "VX_GOOGLE_$$"}};
|
|
EXPECT_EQ(BAD_VALUE, HidlUtils::audioTagsToHal(notExtensions, halTag));
|
|
}
|
|
|
|
TEST(HidlUtils, ConvertAudioTags) {
|
|
hidl_vec<AudioTag> emptyTags;
|
|
char halEmptyTags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE] = {};
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioTagsToHal(emptyTags, halEmptyTags));
|
|
hidl_vec<AudioTag> emptyTagsBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioTagsFromHal(HidlUtils::splitAudioTags(halEmptyTags), &emptyTagsBack));
|
|
EXPECT_EQ(emptyTags, emptyTagsBack);
|
|
|
|
hidl_vec<AudioTag> oneTag = {{"VX_GOOGLE_VR"}};
|
|
char halOneTag[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE] = {};
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioTagsToHal(oneTag, halOneTag));
|
|
hidl_vec<AudioTag> oneTagBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioTagsFromHal(HidlUtils::splitAudioTags(halOneTag), &oneTagBack));
|
|
EXPECT_EQ(oneTag, oneTagBack);
|
|
|
|
hidl_vec<AudioTag> twoTags = {{"VX_GOOGLE_VR_42", "VX_GOOGLE_1E100"}};
|
|
char halTwoTags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE] = {};
|
|
EXPECT_EQ(NO_ERROR, HidlUtils::audioTagsToHal(twoTags, halTwoTags));
|
|
hidl_vec<AudioTag> twoTagsBack;
|
|
EXPECT_EQ(NO_ERROR,
|
|
HidlUtils::audioTagsFromHal(HidlUtils::splitAudioTags(halTwoTags), &twoTagsBack));
|
|
EXPECT_EQ(twoTags, twoTagsBack);
|
|
}
|
|
|
|
template <typename T>
|
|
class FilterTest : public ::testing::Test {};
|
|
using FilterTestTypeParams = ::testing::Types<hidl_vec<AudioTag>, std::vector<std::string>>;
|
|
TYPED_TEST_SUITE(FilterTest, FilterTestTypeParams);
|
|
|
|
TYPED_TEST(FilterTest, FilterOutNonVendorTags) {
|
|
TypeParam emptyTags;
|
|
EXPECT_EQ(emptyTags, HidlUtils::filterOutNonVendorTags(emptyTags));
|
|
|
|
TypeParam allVendorTags = {{"VX_GOOGLE_VR_42", "VX_GOOGLE_1E100"}};
|
|
EXPECT_EQ(allVendorTags, HidlUtils::filterOutNonVendorTags(allVendorTags));
|
|
|
|
TypeParam oneVendorTag = {{"", "VX_GOOGLE_VR", "random_string"}};
|
|
TypeParam oneVendorTagOnly = HidlUtils::filterOutNonVendorTags(oneVendorTag);
|
|
EXPECT_EQ(1, oneVendorTagOnly.size());
|
|
EXPECT_EQ(oneVendorTag[1], oneVendorTagOnly[0]);
|
|
|
|
// The vendor extension isn't valid, however it must not be filtered out
|
|
// so the converter can detect the issue.
|
|
TypeParam oneMaybeVendorTag = {{"", "random string", "VX_GOOGLE_$$"}};
|
|
TypeParam oneMaybeVendorTagOnly = HidlUtils::filterOutNonVendorTags(oneMaybeVendorTag);
|
|
EXPECT_EQ(1, oneMaybeVendorTagOnly.size());
|
|
EXPECT_EQ(oneMaybeVendorTag[2], oneMaybeVendorTagOnly[0]);
|
|
|
|
TypeParam noVendorTags = {{"", "random string", "V_"}};
|
|
EXPECT_EQ(emptyTags, HidlUtils::filterOutNonVendorTags(noVendorTags));
|
|
}
|