mirror of
https://github.com/Evolution-X/hardware_interfaces
synced 2026-02-01 11:36:00 +00:00
Merge changes from topic "fix-b-141847510-parametrize-device-and-factory"
* changes: audio: Parametrize core VTS tests audio: Parametrize effect VTS tests for V6.0 audio: Extract utility functions
This commit is contained in:
TreeHugger Robot
committed by
Android (Google) Code Review
Android (Google) Code Review
commit
d03b87971f
@@ -114,6 +114,27 @@ inline ::testing::AssertionResult assertOk(const char* expr, const Return<Result
|
||||
#define ASSERT_RESULT(expected, ret) ASSERT_PRED_FORMAT2(detail::assertResult, expected, ret)
|
||||
#define EXPECT_RESULT(expected, ret) EXPECT_PRED_FORMAT2(detail::assertResult, expected, ret)
|
||||
|
||||
/** Unpack the provided result.
|
||||
* If the result is not OK, register a failure and return the default initializer value. */
|
||||
template <class R>
|
||||
static R extract(const Return<R>& ret) {
|
||||
if (!ret.isOk()) {
|
||||
EXPECT_IS_OK(ret);
|
||||
return R{};
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
template <class Result, class Value>
|
||||
static void expectValueOrFailure(Result res, Value expectedValue, Value actualValue,
|
||||
Result expectedFailure) {
|
||||
if (res == Result::OK) {
|
||||
ASSERT_EQ(expectedValue, actualValue);
|
||||
} else {
|
||||
ASSERT_EQ(expectedFailure, res) << "Unexpected result " << toString(res);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace utility
|
||||
} // namespace test
|
||||
} // namespace common
|
||||
|
||||
@@ -20,9 +20,6 @@
|
||||
#include <functional>
|
||||
#include <list>
|
||||
|
||||
#include <VtsHalHidlTargetTestEnvBase.h>
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
namespace audio {
|
||||
@@ -34,18 +31,20 @@ namespace utility {
|
||||
* Avoid destroying static objects after main return.
|
||||
* Post main return destruction leads to incorrect gtest timing measurements as
|
||||
* well as harder debuging if anything goes wrong during destruction. */
|
||||
class Environment : public ::testing::VtsHalHidlTargetTestEnvBase {
|
||||
public:
|
||||
class EnvironmentTearDown {
|
||||
public:
|
||||
using TearDownFunc = std::function<void()>;
|
||||
void registerTearDown(TearDownFunc&& tearDown) { tearDowns.push_front(std::move(tearDown)); }
|
||||
|
||||
private:
|
||||
void HidlTearDown() override {
|
||||
protected:
|
||||
void executeAllTearDowns() {
|
||||
// Call the tear downs in reverse order of insertion
|
||||
for (auto& tearDown : tearDowns) {
|
||||
tearDown();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
std::list<TearDownFunc> tearDowns;
|
||||
};
|
||||
|
||||
|
||||
@@ -60,19 +60,20 @@ TEST_IO_STREAM(SetConnectedState,
|
||||
"deconnection",
|
||||
testConnectedState(stream.get()))
|
||||
|
||||
TEST_IO_STREAM(GetHwAvSync, "Get hardware sync can not fail", ASSERT_IS_OK(device->getHwAvSync()));
|
||||
TEST_IO_STREAM(GetHwAvSync, "Get hardware sync can not fail",
|
||||
ASSERT_IS_OK(getDevice()->getHwAvSync()));
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, setMode) {
|
||||
TEST_P(AudioPrimaryHidlTest, setMode) {
|
||||
doc::test("Make sure setMode always succeeds if mode is valid and fails otherwise");
|
||||
// Test Invalid values
|
||||
for (AudioMode mode : {AudioMode::INVALID, AudioMode::CURRENT, AudioMode::CNT}) {
|
||||
SCOPED_TRACE("mode=" + toString(mode));
|
||||
ASSERT_RESULT(Result::INVALID_ARGUMENTS, device->setMode(mode));
|
||||
ASSERT_RESULT(Result::INVALID_ARGUMENTS, getDevice()->setMode(mode));
|
||||
}
|
||||
// Test valid values
|
||||
for (AudioMode mode : {AudioMode::IN_CALL, AudioMode::IN_COMMUNICATION, AudioMode::RINGTONE,
|
||||
AudioMode::NORMAL /* Make sure to leave the test in normal mode */}) {
|
||||
SCOPED_TRACE("mode=" + toString(mode));
|
||||
ASSERT_OK(device->setMode(mode));
|
||||
ASSERT_OK(getDevice()->setMode(mode));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
* Copyright (C) 2019 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.
|
||||
*/
|
||||
|
||||
#ifndef ANDROID_HARDWARE_AUDIO_CORE_2_0_ENVIRONMENT_TEARDOWN_H
|
||||
#define ANDROID_HARDWARE_AUDIO_CORE_2_0_ENVIRONMENT_TEARDOWN_H
|
||||
|
||||
#include <VtsHalHidlTargetTestEnvBase.h>
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "utility/EnvironmentTearDown.h"
|
||||
|
||||
class Environment : public ::android::hardware::audio::common::test::utility::EnvironmentTearDown,
|
||||
public ::testing::VtsHalHidlTargetTestEnvBase {
|
||||
private:
|
||||
void HidlTearDown() override {
|
||||
executeAllTearDowns();
|
||||
VtsHalHidlTargetTestEnvBase::HidlTearDown();
|
||||
}
|
||||
};
|
||||
|
||||
#endif // ANDROID_HARDWARE_AUDIO_CORE_2_0_ENVIRONMENT_TEARDOWN_H
|
||||
@@ -16,25 +16,14 @@
|
||||
|
||||
#include "AudioPrimaryHidlHalTest.h"
|
||||
|
||||
static void waitForDeviceDestruction() {
|
||||
// FIXME: there is no way to know when the remote IDevice is being destroyed
|
||||
// Binder does not support testing if an object is alive, thus
|
||||
// wait for 100ms to let the binder destruction propagates and
|
||||
// the remote device has the time to be destroyed.
|
||||
// flushCommand makes sure all local command are sent, thus should reduce
|
||||
// the latency between local and remote destruction.
|
||||
IPCThreadState::self()->flushCommands();
|
||||
usleep(100 * 1000);
|
||||
}
|
||||
|
||||
TEST_F(AudioHidlTest, OpenPrimaryDeviceUsingGetDevice) {
|
||||
TEST_P(AudioHidlTest, OpenPrimaryDeviceUsingGetDevice) {
|
||||
doc::test("Calling openDevice(\"primary\") should return the primary device.");
|
||||
struct WaitExecutor {
|
||||
~WaitExecutor() { waitForDeviceDestruction(); }
|
||||
~WaitExecutor() { DeviceManager::waitForInstanceDestruction(); }
|
||||
} waitExecutor; // Make sure we wait for the device destruction on exiting from the test.
|
||||
Result result;
|
||||
sp<IDevice> baseDevice;
|
||||
ASSERT_OK(devicesFactory->openDevice("primary", returnIn(result, baseDevice)));
|
||||
ASSERT_OK(getDevicesFactory()->openDevice("primary", returnIn(result, baseDevice)));
|
||||
if (result != Result::OK && isPrimaryDeviceOptional()) {
|
||||
GTEST_SKIP() << "No primary device on this factory"; // returns
|
||||
}
|
||||
@@ -50,10 +39,10 @@ TEST_F(AudioHidlTest, OpenPrimaryDeviceUsingGetDevice) {
|
||||
/////////////////////////// get(Active)Microphones ///////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, GetMicrophonesTest) {
|
||||
TEST_P(AudioPrimaryHidlTest, GetMicrophonesTest) {
|
||||
doc::test("Make sure getMicrophones always succeeds");
|
||||
hidl_vec<MicrophoneInfo> microphones;
|
||||
ASSERT_OK(device->getMicrophones(returnIn(res, microphones)));
|
||||
ASSERT_OK(getDevice()->getMicrophones(returnIn(res, microphones)));
|
||||
ASSERT_OK(res);
|
||||
if (microphones.size() > 0) {
|
||||
// When there is microphone on the phone, try to open an input stream
|
||||
@@ -75,15 +64,15 @@ TEST_F(AudioPrimaryHidlTest, GetMicrophonesTest) {
|
||||
}
|
||||
sp<IStreamIn> stream;
|
||||
AudioConfig suggestedConfig{};
|
||||
ASSERT_OK(device->openInputStream(ioHandle, microphone.deviceAddress, config, flags,
|
||||
initMetadata,
|
||||
returnIn(res, stream, suggestedConfig)));
|
||||
ASSERT_OK(getDevice()->openInputStream(ioHandle, microphone.deviceAddress, config,
|
||||
flags, initMetadata,
|
||||
returnIn(res, stream, suggestedConfig)));
|
||||
if (res != Result::OK) {
|
||||
ASSERT_TRUE(stream == nullptr);
|
||||
AudioConfig suggestedConfigRetry{};
|
||||
ASSERT_OK(device->openInputStream(ioHandle, microphone.deviceAddress,
|
||||
suggestedConfig, flags, initMetadata,
|
||||
returnIn(res, stream, suggestedConfigRetry)));
|
||||
ASSERT_OK(getDevice()->openInputStream(
|
||||
ioHandle, microphone.deviceAddress, suggestedConfig, flags, initMetadata,
|
||||
returnIn(res, stream, suggestedConfigRetry)));
|
||||
}
|
||||
ASSERT_OK(res);
|
||||
hidl_vec<MicrophoneInfo> activeMicrophones;
|
||||
@@ -131,7 +120,7 @@ TEST_F(AudioPrimaryHidlTest, GetMicrophonesTest) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, SetConnectedState) {
|
||||
TEST_P(AudioPrimaryHidlTest, SetConnectedState) {
|
||||
doc::test("Check that the HAL can be notified of device connection and deconnection");
|
||||
using AD = AudioDevice;
|
||||
for (auto deviceType : {AD::OUT_HDMI, AD::OUT_WIRED_HEADPHONE, AD::IN_USB_HEADSET}) {
|
||||
@@ -140,7 +129,7 @@ TEST_F(AudioPrimaryHidlTest, SetConnectedState) {
|
||||
SCOPED_TRACE("state=" + ::testing::PrintToString(state));
|
||||
DeviceAddress address = {};
|
||||
address.device = deviceType;
|
||||
auto ret = device->setConnectedState(address, state);
|
||||
auto ret = getDevice()->setConnectedState(address, state);
|
||||
ASSERT_TRUE(ret.isOk());
|
||||
if (ret == Result::NOT_SUPPORTED) {
|
||||
doc::partialTest("setConnectedState is not supported");
|
||||
@@ -153,9 +142,7 @@ TEST_F(AudioPrimaryHidlTest, SetConnectedState) {
|
||||
// Because there is no way of knowing if the devices were connected before
|
||||
// calling setConnectedState, there is no way to restore the HAL to its
|
||||
// initial state. To workaround this, destroy the HAL at the end of this test.
|
||||
device.clear();
|
||||
waitForDeviceDestruction();
|
||||
ASSERT_NO_FATAL_FAILURE(initPrimaryDevice());
|
||||
ASSERT_TRUE(DeviceManager::getInstance().resetPrimary(getFactoryName()));
|
||||
}
|
||||
|
||||
static void testGetDevices(IStream* stream, AudioDevice expectedDevice) {
|
||||
@@ -199,7 +186,7 @@ static void checkGetHwAVSync(IDevice* device) {
|
||||
}
|
||||
ASSERT_OK(res);
|
||||
}
|
||||
TEST_IO_STREAM(GetHwAvSync, "Get hardware sync can not fail", checkGetHwAVSync(device.get()));
|
||||
TEST_IO_STREAM(GetHwAvSync, "Get hardware sync can not fail", checkGetHwAVSync(getDevice().get()));
|
||||
|
||||
TEST_P(InputStreamTest, updateSinkMetadata) {
|
||||
doc::test("The HAL should not crash on metadata change");
|
||||
@@ -259,58 +246,58 @@ TEST_P(OutputStreamTest, updateSourceMetadata) {
|
||||
ASSERT_OK(stream->updateSourceMetadata(initMetadata));
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, setMode) {
|
||||
TEST_P(AudioPrimaryHidlTest, setMode) {
|
||||
doc::test("Make sure setMode always succeeds if mode is valid and fails otherwise");
|
||||
// Test Invalid values
|
||||
for (int mode : {-2, -1, int(AudioMode::IN_COMMUNICATION) + 1}) {
|
||||
ASSERT_RESULT(Result::INVALID_ARGUMENTS, device->setMode(AudioMode(mode)))
|
||||
<< "mode=" << mode;
|
||||
ASSERT_RESULT(Result::INVALID_ARGUMENTS, getDevice()->setMode(AudioMode(mode)))
|
||||
<< "mode=" << mode;
|
||||
}
|
||||
// Test valid values
|
||||
for (AudioMode mode : {AudioMode::IN_CALL, AudioMode::IN_COMMUNICATION, AudioMode::RINGTONE,
|
||||
AudioMode::NORMAL /* Make sure to leave the test in normal mode */}) {
|
||||
ASSERT_OK(device->setMode(mode)) << "mode=" << toString(mode);
|
||||
ASSERT_OK(getDevice()->setMode(mode)) << "mode=" << toString(mode);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, setBtHfpSampleRate) {
|
||||
TEST_P(AudioPrimaryHidlTest, setBtHfpSampleRate) {
|
||||
doc::test(
|
||||
"Make sure setBtHfpSampleRate either succeeds or "
|
||||
"indicates that it is not supported at all, or that the provided value is invalid");
|
||||
for (auto samplingRate : {8000, 16000, 22050, 24000}) {
|
||||
ASSERT_RESULT(okOrNotSupportedOrInvalidArgs, device->setBtHfpSampleRate(samplingRate));
|
||||
ASSERT_RESULT(okOrNotSupportedOrInvalidArgs, getDevice()->setBtHfpSampleRate(samplingRate));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, setBtHfpVolume) {
|
||||
TEST_P(AudioPrimaryHidlTest, setBtHfpVolume) {
|
||||
doc::test(
|
||||
"Make sure setBtHfpVolume is either not supported or "
|
||||
"only succeed if volume is in [0,1]");
|
||||
auto ret = device->setBtHfpVolume(0.0);
|
||||
auto ret = getDevice()->setBtHfpVolume(0.0);
|
||||
ASSERT_TRUE(ret.isOk());
|
||||
if (ret == Result::NOT_SUPPORTED) {
|
||||
doc::partialTest("setBtHfpVolume is not supported");
|
||||
return;
|
||||
}
|
||||
testUnitaryGain([](float volume) { return device->setBtHfpVolume(volume); });
|
||||
testUnitaryGain([this](float volume) { return getDevice()->setBtHfpVolume(volume); });
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, setBtScoHeadsetDebugName) {
|
||||
TEST_P(AudioPrimaryHidlTest, setBtScoHeadsetDebugName) {
|
||||
doc::test(
|
||||
"Make sure setBtScoHeadsetDebugName either succeeds or "
|
||||
"indicates that it is not supported");
|
||||
ASSERT_RESULT(okOrNotSupported, device->setBtScoHeadsetDebugName("test"));
|
||||
ASSERT_RESULT(okOrNotSupported, getDevice()->setBtScoHeadsetDebugName("test"));
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, updateRotation) {
|
||||
TEST_P(AudioPrimaryHidlTest, updateRotation) {
|
||||
doc::test("Check that the hal can receive the current rotation");
|
||||
for (Rotation rotation : {Rotation::DEG_0, Rotation::DEG_90, Rotation::DEG_180,
|
||||
Rotation::DEG_270, Rotation::DEG_0}) {
|
||||
ASSERT_RESULT(okOrNotSupported, device->updateRotation(rotation));
|
||||
ASSERT_RESULT(okOrNotSupported, getDevice()->updateRotation(rotation));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(BoolAccessorPrimaryHidlTest, setGetBtHfpEnabled) {
|
||||
TEST_P(BoolAccessorPrimaryHidlTest, setGetBtHfpEnabled) {
|
||||
doc::test("Query and set the BT HFP state");
|
||||
testAccessors<OPTIONAL>("BtHfpEnabled", Initial{false, OPTIONAL}, {true},
|
||||
&IPrimaryDevice::setBtHfpEnabled, &IPrimaryDevice::getBtHfpEnabled);
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
/*
|
||||
* Copyright (C) 2019 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.
|
||||
*/
|
||||
|
||||
#ifndef ANDROID_HARDWARE_AUDIO_CORE_6_0_ENVIRONMENT_TEARDOWN_H
|
||||
#define ANDROID_HARDWARE_AUDIO_CORE_6_0_ENVIRONMENT_TEARDOWN_H
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "utility/EnvironmentTearDown.h"
|
||||
|
||||
class Environment : public ::android::hardware::audio::common::test::utility::EnvironmentTearDown,
|
||||
public ::testing::Environment {
|
||||
public:
|
||||
void init(int* /*argc*/, char** /*argv*/) {} // emulate VtsHalHidlTargetTestEnvBase
|
||||
private:
|
||||
void TearDown() override { executeAllTearDowns(); }
|
||||
};
|
||||
|
||||
// FIXME: Will be removed while making getDeviceParameters to use the config
|
||||
static constexpr const char* kDefaultServiceName = "default";
|
||||
|
||||
#endif // ANDROID_HARDWARE_AUDIO_CORE_6_0_ENVIRONMENT_TEARDOWN_H
|
||||
@@ -23,6 +23,7 @@
|
||||
#include <initializer_list>
|
||||
#include <limits>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
@@ -31,7 +32,9 @@
|
||||
|
||||
#include <hwbinder/IPCThreadState.h>
|
||||
|
||||
#if MAJOR_VERSION <= 5
|
||||
#include <VtsHalHidlTargetTestBase.h>
|
||||
#endif
|
||||
|
||||
#include <android-base/logging.h>
|
||||
|
||||
@@ -44,16 +47,25 @@
|
||||
#include <Serializer.h>
|
||||
#include <fmq/EventFlag.h>
|
||||
#include <fmq/MessageQueue.h>
|
||||
#if MAJOR_VERSION >= 6
|
||||
#include <hidl/GtestPrinter.h>
|
||||
#include <hidl/ServiceManagement.h>
|
||||
#endif
|
||||
|
||||
#include <common/all-versions/VersionUtils.h>
|
||||
|
||||
#include "utility/AssertOk.h"
|
||||
#include "utility/Documentation.h"
|
||||
#include "utility/EnvironmentTearDown.h"
|
||||
#include "utility/PrettyPrintAudioTypes.h"
|
||||
#include "utility/ReturnIn.h"
|
||||
#include "utility/ValidateXml.h"
|
||||
|
||||
#if MAJOR_VERSION <= 5
|
||||
#include "2.0/EnvironmentTearDown.h"
|
||||
#elif MAJOR_VERSION >= 6
|
||||
#include "6.0/EnvironmentTearDown.h"
|
||||
#endif
|
||||
|
||||
/** Provide version specific functions that are used in the generic tests */
|
||||
#if MAJOR_VERSION == 2
|
||||
#include "2.0/AudioPrimaryHidlHalUtils.h"
|
||||
@@ -105,14 +117,23 @@ static auto invalidStateOrNotSupported = {Result::INVALID_STATE, Result::NOT_SUP
|
||||
|
||||
class AudioHidlTestEnvironment : public ::Environment {
|
||||
public:
|
||||
virtual void registerTestServices() override { registerTestService<IDevicesFactory>(); }
|
||||
#if MAJOR_VERSION <= 5
|
||||
void registerTestServices() override { registerTestService<IDevicesFactory>(); }
|
||||
#endif
|
||||
};
|
||||
|
||||
// Instance to register global tearDown
|
||||
static AudioHidlTestEnvironment* environment;
|
||||
|
||||
#define AUDIO_PRIMARY_HIDL_HAL_TEST
|
||||
#include "DeviceManager.h"
|
||||
|
||||
#if MAJOR_VERSION <= 5
|
||||
class HidlTest : public ::testing::VtsHalHidlTargetTestBase {
|
||||
protected:
|
||||
#elif MAJOR_VERSION >= 6
|
||||
class HidlTest : public ::testing::Test {
|
||||
#endif
|
||||
protected:
|
||||
// Convenient member to store results
|
||||
Result res;
|
||||
};
|
||||
@@ -201,6 +222,21 @@ class AudioPolicyConfigTest : public HidlTest {
|
||||
ASSERT_TRUE(mPrimaryConfig) << "Could not find primary module in configuration file: "
|
||||
<< policyConfig.getFilePath();
|
||||
}
|
||||
|
||||
protected:
|
||||
sp<IDevicesFactory> getDevicesFactory(const std::string& factoryName) const {
|
||||
return DevicesFactoryManager::getInstance().get(factoryName);
|
||||
}
|
||||
|
||||
sp<IPrimaryDevice> getPrimaryDevice(const std::string& factoryName) const {
|
||||
return DeviceManager::getInstance().getPrimary(factoryName);
|
||||
}
|
||||
|
||||
bool isPrimaryDeviceOptional(const std::string& factoryName) const {
|
||||
// It's OK not to have "primary" device on non-default audio HAL service.
|
||||
return factoryName != kDefaultServiceName;
|
||||
}
|
||||
|
||||
sp<const HwModule> mPrimaryConfig = nullptr;
|
||||
};
|
||||
|
||||
@@ -208,42 +244,86 @@ TEST_F(AudioPolicyConfigTest, LoadAudioPolicyXMLConfiguration) {
|
||||
doc::test("Test parsing audio_policy_configuration.xml (called in SetUp)");
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//////////////////// Test parameter types and definitions ////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
enum { PARAM_FACTORY_NAME, PARAM_DEVICE_NAME };
|
||||
using DeviceParameter = std::tuple<std::string, std::string>;
|
||||
|
||||
static inline std::string DeviceParameterToString(
|
||||
const ::testing::TestParamInfo<DeviceParameter>& info) {
|
||||
#if MAJOR_VERSION <= 5
|
||||
return std::get<PARAM_DEVICE_NAME>(info.param);
|
||||
#elif MAJOR_VERSION >= 6
|
||||
const auto factoryName =
|
||||
::android::hardware::PrintInstanceNameToString(::testing::TestParamInfo<std::string>{
|
||||
std::get<PARAM_FACTORY_NAME>(info.param), info.index});
|
||||
const auto& deviceName = std::get<PARAM_DEVICE_NAME>(info.param);
|
||||
return !deviceName.empty() ? factoryName + "_" + deviceName : factoryName;
|
||||
#endif
|
||||
}
|
||||
|
||||
#if MAJOR_VERSION <= 5
|
||||
// For V2..5 the factory is looked up using the instance name passed
|
||||
// in the environment, only one factory is returned. This is because the VTS
|
||||
// framework will call the test for each instance. Only the primary device of
|
||||
// the factory specified in the environment is tested.
|
||||
const std::vector<DeviceParameter>& getDeviceParameters() {
|
||||
static std::vector<DeviceParameter> parameters = {
|
||||
{environment->getServiceName<IDevicesFactory>(), DeviceManager::kPrimaryDevice}};
|
||||
return parameters;
|
||||
}
|
||||
#elif MAJOR_VERSION >= 6
|
||||
// FIXME: Will be replaced with code that analyzes the audio policy config file.
|
||||
const std::vector<DeviceParameter>& getDeviceParameters() {
|
||||
static std::vector<DeviceParameter> parameters = [] {
|
||||
const auto instances =
|
||||
::android::hardware::getAllHalInstanceNames(IDevicesFactory::descriptor);
|
||||
std::vector<DeviceParameter> result;
|
||||
result.reserve(instances.size());
|
||||
for (const auto& instance : instances) {
|
||||
result.emplace_back(instance, DeviceManager::kPrimaryDevice);
|
||||
}
|
||||
return result;
|
||||
}();
|
||||
return parameters;
|
||||
}
|
||||
#endif
|
||||
|
||||
class AudioHidlTestWithDeviceParameter : public AudioPolicyConfigTest,
|
||||
public ::testing::WithParamInterface<DeviceParameter> {
|
||||
protected:
|
||||
const std::string& getFactoryName() const { return std::get<PARAM_FACTORY_NAME>(GetParam()); }
|
||||
bool isPrimaryDeviceOptional() const {
|
||||
return AudioPolicyConfigTest::isPrimaryDeviceOptional(getFactoryName());
|
||||
}
|
||||
sp<IDevicesFactory> getDevicesFactory() const {
|
||||
return AudioPolicyConfigTest::getDevicesFactory(getFactoryName());
|
||||
}
|
||||
sp<IPrimaryDevice> getPrimaryDevice() const {
|
||||
return AudioPolicyConfigTest::getPrimaryDevice(getFactoryName());
|
||||
}
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////// getService audio_devices_factory //////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Test all audio devices
|
||||
class AudioHidlTest : public AudioPolicyConfigTest {
|
||||
public:
|
||||
static void SetUpTestSuite() {
|
||||
devicesFactory = ::testing::VtsHalHidlTargetTestBase::getService<IDevicesFactory>(
|
||||
environment->getServiceName<IDevicesFactory>());
|
||||
}
|
||||
|
||||
static void TearDownTestSuite() { devicesFactory.clear(); }
|
||||
|
||||
void SetUp() override {
|
||||
ASSERT_NO_FATAL_FAILURE(AudioPolicyConfigTest::SetUp()); // setup base
|
||||
// Failures during SetUpTestSuite do not cause test termination.
|
||||
ASSERT_TRUE(devicesFactory != nullptr);
|
||||
}
|
||||
|
||||
protected:
|
||||
// Cache the devicesFactory retrieval to speed up each test by ~0.5s
|
||||
static sp<IDevicesFactory> devicesFactory;
|
||||
|
||||
static bool isPrimaryDeviceOptional() {
|
||||
// It's OK not to have "primary" device on non-default audio HAL service.
|
||||
return environment->getServiceName<IDevicesFactory>() != kDefaultServiceName;
|
||||
class AudioHidlTest : public AudioHidlTestWithDeviceParameter {
|
||||
public:
|
||||
void SetUp() override {
|
||||
ASSERT_NO_FATAL_FAILURE(AudioHidlTestWithDeviceParameter::SetUp()); // setup base
|
||||
ASSERT_TRUE(getDevicesFactory() != nullptr);
|
||||
}
|
||||
};
|
||||
sp<IDevicesFactory> AudioHidlTest::devicesFactory;
|
||||
|
||||
TEST_F(AudioHidlTest, GetAudioDevicesFactoryService) {
|
||||
TEST_P(AudioHidlTest, GetAudioDevicesFactoryService) {
|
||||
doc::test("Test the getService");
|
||||
}
|
||||
|
||||
TEST_F(AudioHidlTest, OpenDeviceInvalidParameter) {
|
||||
TEST_P(AudioHidlTest, OpenDeviceInvalidParameter) {
|
||||
doc::test("Test passing an invalid parameter to openDevice");
|
||||
Result result;
|
||||
sp<IDevice> device;
|
||||
@@ -252,11 +332,14 @@ TEST_F(AudioHidlTest, OpenDeviceInvalidParameter) {
|
||||
#elif MAJOR_VERSION >= 4
|
||||
auto invalidDevice = "Non existing device";
|
||||
#endif
|
||||
ASSERT_OK(devicesFactory->openDevice(invalidDevice, returnIn(result, device)));
|
||||
ASSERT_OK(getDevicesFactory()->openDevice(invalidDevice, returnIn(result, device)));
|
||||
ASSERT_EQ(Result::INVALID_ARGUMENTS, result);
|
||||
ASSERT_TRUE(device == nullptr);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AudioHidl, AudioHidlTest, ::testing::ValuesIn(getDeviceParameters()),
|
||||
&DeviceParameterToString);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
/////////////////////////////// openDevice primary ///////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
@@ -264,57 +347,30 @@ TEST_F(AudioHidlTest, OpenDeviceInvalidParameter) {
|
||||
// Test the primary device
|
||||
class AudioPrimaryHidlTest : public AudioHidlTest {
|
||||
public:
|
||||
static void SetUpTestSuite() {
|
||||
ASSERT_NO_FATAL_FAILURE(AudioHidlTest::SetUpTestSuite());
|
||||
ASSERT_NO_FATAL_FAILURE(initPrimaryDevice());
|
||||
}
|
||||
|
||||
static void TearDownTestSuite() {
|
||||
device.clear();
|
||||
AudioHidlTest::TearDownTestSuite();
|
||||
}
|
||||
|
||||
void SetUp() override {
|
||||
ASSERT_NO_FATAL_FAILURE(AudioHidlTest::SetUp()); // setup base
|
||||
if (device == nullptr && isPrimaryDeviceOptional()) {
|
||||
if (getDevice() == nullptr && isPrimaryDeviceOptional()) {
|
||||
GTEST_SKIP() << "No primary device on this factory";
|
||||
}
|
||||
ASSERT_TRUE(device != nullptr);
|
||||
ASSERT_TRUE(getDevice() != nullptr);
|
||||
}
|
||||
|
||||
protected:
|
||||
// Cache the device opening to speed up each test by ~0.5s
|
||||
static sp<IPrimaryDevice> device;
|
||||
|
||||
static void initPrimaryDevice() {
|
||||
// Failures during test suite set up do not cause test termination.
|
||||
ASSERT_TRUE(devicesFactory != nullptr);
|
||||
Result result;
|
||||
#if MAJOR_VERSION == 2
|
||||
sp<IDevice> baseDevice;
|
||||
ASSERT_OK(devicesFactory->openDevice(IDevicesFactory::Device::PRIMARY,
|
||||
returnIn(result, baseDevice)));
|
||||
ASSERT_OK(result);
|
||||
ASSERT_TRUE(baseDevice != nullptr);
|
||||
|
||||
device = IPrimaryDevice::castFrom(baseDevice);
|
||||
#elif MAJOR_VERSION >= 4
|
||||
ASSERT_OK(devicesFactory->openPrimaryDevice(returnIn(result, device)));
|
||||
ASSERT_OK(result);
|
||||
#endif
|
||||
}
|
||||
sp<IPrimaryDevice> getDevice() const { return getPrimaryDevice(); }
|
||||
};
|
||||
sp<IPrimaryDevice> AudioPrimaryHidlTest::device;
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, OpenPrimaryDevice) {
|
||||
TEST_P(AudioPrimaryHidlTest, OpenPrimaryDevice) {
|
||||
doc::test("Test the openDevice (called during setup)");
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, Init) {
|
||||
TEST_P(AudioPrimaryHidlTest, Init) {
|
||||
doc::test("Test that the audio primary hal initialized correctly");
|
||||
ASSERT_OK(device->initCheck());
|
||||
ASSERT_OK(getDevice()->initCheck());
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AudioPrimaryHidl, AudioPrimaryHidlTest,
|
||||
::testing::ValuesIn(getDeviceParameters()), &DeviceParameterToString);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////// {set,get}{Master,Mic}{Mute,Volume} /////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
@@ -339,7 +395,7 @@ class AccessorPrimaryHidlTest : public AudioPrimaryHidlTest {
|
||||
optionality == OPTIONAL ? Result::NOT_SUPPORTED : Result::OK};
|
||||
|
||||
Property initialValue = expectedInitial.value;
|
||||
ASSERT_OK((device.get()->*getter)(returnIn(res, initialValue)));
|
||||
ASSERT_OK((getDevice().get()->*getter)(returnIn(res, initialValue)));
|
||||
ASSERT_RESULT(expectedResults, res);
|
||||
if (res == Result::OK && expectedInitial.check == REQUIRED) {
|
||||
EXPECT_EQ(expectedInitial.value, initialValue);
|
||||
@@ -350,7 +406,7 @@ class AccessorPrimaryHidlTest : public AudioPrimaryHidlTest {
|
||||
for (Property setValue : valuesToTest) {
|
||||
SCOPED_TRACE("Test " + propertyName + " getter and setter for " +
|
||||
testing::PrintToString(setValue));
|
||||
auto ret = (device.get()->*setter)(setValue);
|
||||
auto ret = (getDevice().get()->*setter)(setValue);
|
||||
ASSERT_RESULT(expectedResults, ret);
|
||||
if (ret == Result::NOT_SUPPORTED) {
|
||||
doc::partialTest(propertyName + " setter is not supported");
|
||||
@@ -358,7 +414,7 @@ class AccessorPrimaryHidlTest : public AudioPrimaryHidlTest {
|
||||
}
|
||||
Property getValue;
|
||||
// Make sure the getter returns the same value just set
|
||||
ASSERT_OK((device.get()->*getter)(returnIn(res, getValue)));
|
||||
ASSERT_OK((getDevice().get()->*getter)(returnIn(res, getValue)));
|
||||
ASSERT_RESULT(expectedResults, res);
|
||||
if (res == Result::NOT_SUPPORTED) {
|
||||
doc::partialTest(propertyName + " getter is not supported");
|
||||
@@ -370,31 +426,34 @@ class AccessorPrimaryHidlTest : public AudioPrimaryHidlTest {
|
||||
for (Property invalidValue : invalidValues) {
|
||||
SCOPED_TRACE("Try to set " + propertyName + " with the invalid value " +
|
||||
testing::PrintToString(invalidValue));
|
||||
EXPECT_RESULT(invalidArgsOrNotSupported, (device.get()->*setter)(invalidValue));
|
||||
EXPECT_RESULT(invalidArgsOrNotSupported, (getDevice().get()->*setter)(invalidValue));
|
||||
}
|
||||
|
||||
// Restore initial value
|
||||
EXPECT_RESULT(expectedResults, (device.get()->*setter)(initialValue));
|
||||
EXPECT_RESULT(expectedResults, (getDevice().get()->*setter)(initialValue));
|
||||
}
|
||||
};
|
||||
|
||||
using BoolAccessorPrimaryHidlTest = AccessorPrimaryHidlTest<bool>;
|
||||
|
||||
TEST_F(BoolAccessorPrimaryHidlTest, MicMuteTest) {
|
||||
TEST_P(BoolAccessorPrimaryHidlTest, MicMuteTest) {
|
||||
doc::test("Check that the mic can be muted and unmuted");
|
||||
testAccessors("mic mute", Initial{false}, {true}, &IDevice::setMicMute, &IDevice::getMicMute);
|
||||
// TODO: check that the mic is really muted (all sample are 0)
|
||||
}
|
||||
|
||||
TEST_F(BoolAccessorPrimaryHidlTest, MasterMuteTest) {
|
||||
TEST_P(BoolAccessorPrimaryHidlTest, MasterMuteTest) {
|
||||
doc::test("If master mute is supported, try to mute and unmute the master output");
|
||||
testAccessors<OPTIONAL>("master mute", Initial{false}, {true}, &IDevice::setMasterMute,
|
||||
&IDevice::getMasterMute);
|
||||
// TODO: check that the master volume is really muted
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BoolAccessorPrimaryHidl, BoolAccessorPrimaryHidlTest,
|
||||
::testing::ValuesIn(getDeviceParameters()), &DeviceParameterToString);
|
||||
|
||||
using FloatAccessorPrimaryHidlTest = AccessorPrimaryHidlTest<float>;
|
||||
TEST_F(FloatAccessorPrimaryHidlTest, MasterVolumeTest) {
|
||||
TEST_P(FloatAccessorPrimaryHidlTest, MasterVolumeTest) {
|
||||
doc::test("Test the master volume if supported");
|
||||
testAccessors<OPTIONAL>(
|
||||
"master volume", Initial{1}, {0, 0.5}, &IDevice::setMasterVolume, &IDevice::getMasterVolume,
|
||||
@@ -402,20 +461,19 @@ TEST_F(FloatAccessorPrimaryHidlTest, MasterVolumeTest) {
|
||||
// TODO: check that the master volume is really changed
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FloatAccessorPrimaryHidl, FloatAccessorPrimaryHidlTest,
|
||||
::testing::ValuesIn(getDeviceParameters()), &DeviceParameterToString);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//////////////////////////////// AudioPatches ////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class AudioPatchPrimaryHidlTest : public AudioPrimaryHidlTest {
|
||||
protected:
|
||||
bool areAudioPatchesSupported() {
|
||||
auto result = device->supportsAudioPatches();
|
||||
EXPECT_IS_OK(result);
|
||||
return result;
|
||||
}
|
||||
bool areAudioPatchesSupported() { return extract(getDevice()->supportsAudioPatches()); }
|
||||
};
|
||||
|
||||
TEST_F(AudioPatchPrimaryHidlTest, AudioPatches) {
|
||||
TEST_P(AudioPatchPrimaryHidlTest, AudioPatches) {
|
||||
doc::test("Test if audio patches are supported");
|
||||
if (!areAudioPatchesSupported()) {
|
||||
doc::partialTest("Audio patches are not supported");
|
||||
@@ -424,6 +482,9 @@ TEST_F(AudioPatchPrimaryHidlTest, AudioPatches) {
|
||||
// TODO: test audio patches
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AudioPatchPrimaryHidl, AudioPatchPrimaryHidlTest,
|
||||
::testing::ValuesIn(getDeviceParameters()), &DeviceParameterToString);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//////////////// Required and recommended audio format support ///////////////
|
||||
// From:
|
||||
@@ -433,8 +494,7 @@ TEST_F(AudioPatchPrimaryHidlTest, AudioPatches) {
|
||||
/////////// TODO: move to the beginning of the file for easier update ////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class AudioConfigPrimaryTest : public AudioPatchPrimaryHidlTest {
|
||||
public:
|
||||
struct ConfigHelper {
|
||||
// for retro compatibility only test the primary device IN_BUILTIN_MIC
|
||||
// FIXME: in the next audio HAL version, test all available devices
|
||||
static bool primaryHasMic() {
|
||||
@@ -506,21 +566,51 @@ class AudioConfigPrimaryTest : public AudioPatchPrimaryHidlTest {
|
||||
}
|
||||
};
|
||||
|
||||
// Nesting a tuple in another tuple allows to use GTest Combine function to generate
|
||||
// all combinations of devices and configs.
|
||||
enum { PARAM_DEVICE, PARAM_CONFIG };
|
||||
using DeviceConfigParameter = std::tuple<DeviceParameter, AudioConfig>;
|
||||
|
||||
/** Generate a test name based on an audio config.
|
||||
*
|
||||
* As the only parameter changing are channel mask and sample rate,
|
||||
* only print those ones in the test name.
|
||||
*/
|
||||
static string generateTestName(const testing::TestParamInfo<AudioConfig>& info) {
|
||||
const AudioConfig& config = info.param;
|
||||
return to_string(info.index) + "__" + to_string(config.sampleRateHz) + "_" +
|
||||
static string DeviceConfigParameterToString(
|
||||
const testing::TestParamInfo<DeviceConfigParameter>& info) {
|
||||
const AudioConfig& config = std::get<PARAM_CONFIG>(info.param);
|
||||
const auto deviceName = DeviceParameterToString(::testing::TestParamInfo<DeviceParameter>{
|
||||
std::get<PARAM_DEVICE>(info.param), info.index});
|
||||
return (deviceName.empty() ? "" : deviceName + "_") + to_string(info.index) + "__" +
|
||||
to_string(config.sampleRateHz) + "_" +
|
||||
// "MONO" is more clear than "FRONT_LEFT"
|
||||
((config.channelMask == mkEnumBitfield(AudioChannelMask::OUT_MONO) ||
|
||||
config.channelMask == mkEnumBitfield(AudioChannelMask::IN_MONO))
|
||||
? "MONO"
|
||||
: ::testing::PrintToString(config.channelMask));
|
||||
? "MONO"
|
||||
: ::testing::PrintToString(config.channelMask));
|
||||
}
|
||||
|
||||
class AudioHidlTestWithDeviceConfigParameter
|
||||
: public AudioPolicyConfigTest,
|
||||
public ::testing::WithParamInterface<DeviceConfigParameter> {
|
||||
protected:
|
||||
const std::string& getFactoryName() const {
|
||||
return std::get<PARAM_FACTORY_NAME>(std::get<PARAM_DEVICE>(GetParam()));
|
||||
}
|
||||
bool isPrimaryDeviceOptional() const {
|
||||
return AudioPolicyConfigTest::isPrimaryDeviceOptional(getFactoryName());
|
||||
}
|
||||
sp<IDevicesFactory> getDevicesFactory() const {
|
||||
return AudioPolicyConfigTest::getDevicesFactory(getFactoryName());
|
||||
}
|
||||
sp<IPrimaryDevice> getPrimaryDevice() const {
|
||||
return AudioPolicyConfigTest::getPrimaryDevice(getFactoryName());
|
||||
}
|
||||
const AudioConfig& getConfig() const { return std::get<PARAM_CONFIG>(GetParam()); }
|
||||
// FIXME: Split out tests that don't require primary device
|
||||
sp<IPrimaryDevice> getDevice() const { return getPrimaryDevice(); }
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////// getInputBufferSize /////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
@@ -529,12 +619,21 @@ static string generateTestName(const testing::TestParamInfo<AudioConfig>& info)
|
||||
// android.hardware.microphone
|
||||
// how to get this value ? is it a property ???
|
||||
|
||||
class AudioCaptureConfigPrimaryTest : public AudioConfigPrimaryTest,
|
||||
public ::testing::WithParamInterface<AudioConfig> {
|
||||
protected:
|
||||
class AudioCaptureConfigPrimaryTest : public AudioHidlTestWithDeviceConfigParameter {
|
||||
public:
|
||||
void SetUp() override {
|
||||
ASSERT_NO_FATAL_FAILURE(AudioHidlTestWithDeviceConfigParameter::SetUp()); // setup base
|
||||
ASSERT_TRUE(getDevicesFactory() != nullptr);
|
||||
if (getDevice() == nullptr && isPrimaryDeviceOptional()) {
|
||||
GTEST_SKIP() << "No primary device on this factory";
|
||||
}
|
||||
ASSERT_TRUE(getDevice() != nullptr);
|
||||
}
|
||||
|
||||
protected:
|
||||
void inputBufferSizeTest(const AudioConfig& audioConfig, bool supportRequired) {
|
||||
uint64_t bufferSize;
|
||||
ASSERT_OK(device->getInputBufferSize(audioConfig, returnIn(res, bufferSize)));
|
||||
ASSERT_OK(getDevice()->getInputBufferSize(audioConfig, returnIn(res, bufferSize)));
|
||||
|
||||
switch (res) {
|
||||
case Result::INVALID_ARGUMENTS:
|
||||
@@ -558,16 +657,19 @@ TEST_P(RequiredInputBufferSizeTest, RequiredInputBufferSizeTest) {
|
||||
doc::test(
|
||||
"Input buffer size must be retrievable for a format with required "
|
||||
"support.");
|
||||
inputBufferSizeTest(GetParam(), true);
|
||||
inputBufferSizeTest(getConfig(), true);
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
RequiredInputBufferSize, RequiredInputBufferSizeTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getRequiredSupportCaptureAudioConfig()),
|
||||
&generateTestName);
|
||||
RequiredInputBufferSize, RequiredInputBufferSizeTest,
|
||||
::testing::Combine(
|
||||
::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getRequiredSupportCaptureAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SupportedInputBufferSize, RequiredInputBufferSizeTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getSupportedCaptureAudioConfig()),
|
||||
&generateTestName);
|
||||
SupportedInputBufferSize, RequiredInputBufferSizeTest,
|
||||
::testing::Combine(::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getSupportedCaptureAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
|
||||
// Test that the recommended capture config are supported or lead to a
|
||||
// INVALID_ARGUMENTS return
|
||||
@@ -576,21 +678,23 @@ TEST_P(OptionalInputBufferSizeTest, OptionalInputBufferSizeTest) {
|
||||
doc::test(
|
||||
"Input buffer size should be retrievable for a format with recommended "
|
||||
"support.");
|
||||
inputBufferSizeTest(GetParam(), false);
|
||||
inputBufferSizeTest(getConfig(), false);
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
RecommendedCaptureAudioConfigSupport, OptionalInputBufferSizeTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getRecommendedSupportCaptureAudioConfig()),
|
||||
&generateTestName);
|
||||
RecommendedCaptureAudioConfigSupport, OptionalInputBufferSizeTest,
|
||||
::testing::Combine(
|
||||
::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getRecommendedSupportCaptureAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
/////////////////////////////// setScreenState ///////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, setScreenState) {
|
||||
TEST_P(AudioPrimaryHidlTest, setScreenState) {
|
||||
doc::test("Check that the hal can receive the screen state");
|
||||
for (bool turnedOn : {false, true, true, false, false}) {
|
||||
ASSERT_RESULT(okOrNotSupported, device->setScreenState(turnedOn));
|
||||
ASSERT_RESULT(okOrNotSupported, getDevice()->setScreenState(turnedOn));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -598,15 +702,15 @@ TEST_F(AudioPrimaryHidlTest, setScreenState) {
|
||||
//////////////////////////// {get,set}Parameters /////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, getParameters) {
|
||||
TEST_P(AudioPrimaryHidlTest, getParameters) {
|
||||
doc::test("Check that the hal can set and get parameters");
|
||||
hidl_vec<ParameterValue> context;
|
||||
hidl_vec<hidl_string> keys;
|
||||
hidl_vec<ParameterValue> values;
|
||||
ASSERT_OK(Parameters::get(device, keys, returnIn(res, values)));
|
||||
ASSERT_OK(Parameters::set(device, values));
|
||||
ASSERT_OK(Parameters::get(getDevice(), keys, returnIn(res, values)));
|
||||
ASSERT_OK(Parameters::set(getDevice(), values));
|
||||
values.resize(0);
|
||||
ASSERT_OK(Parameters::set(device, values));
|
||||
ASSERT_OK(Parameters::set(getDevice(), values));
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
@@ -647,14 +751,14 @@ static void testDebugDump(DebugDump debugDump) {
|
||||
EXPECT_EQ(0, close(fds[1])) << errno;
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, DebugDump) {
|
||||
TEST_P(AudioPrimaryHidlTest, DebugDump) {
|
||||
doc::test("Check that the hal can dump its state without error");
|
||||
testDebugDump([](const auto& handle) { return dump(device, handle); });
|
||||
testDebugDump([this](const auto& handle) { return dump(getDevice(), handle); });
|
||||
}
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, DebugDumpInvalidArguments) {
|
||||
TEST_P(AudioPrimaryHidlTest, DebugDumpInvalidArguments) {
|
||||
doc::test("Check that the hal dump doesn't crash on invalid arguments");
|
||||
ASSERT_OK(dump(device, hidl_handle()));
|
||||
ASSERT_OK(dump(getDevice(), hidl_handle()));
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
@@ -662,9 +766,17 @@ TEST_F(AudioPrimaryHidlTest, DebugDumpInvalidArguments) {
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
template <class Stream>
|
||||
class OpenStreamTest : public AudioConfigPrimaryTest,
|
||||
public ::testing::WithParamInterface<AudioConfig> {
|
||||
protected:
|
||||
class OpenStreamTest : public AudioHidlTestWithDeviceConfigParameter {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
ASSERT_NO_FATAL_FAILURE(AudioHidlTestWithDeviceConfigParameter::SetUp()); // setup base
|
||||
ASSERT_TRUE(getDevicesFactory() != nullptr);
|
||||
if (getDevice() == nullptr && isPrimaryDeviceOptional()) {
|
||||
GTEST_SKIP() << "No primary device on this factory";
|
||||
}
|
||||
ASSERT_TRUE(getDevice() != nullptr);
|
||||
}
|
||||
|
||||
template <class Open>
|
||||
void testOpen(Open openStream, const AudioConfig& config) {
|
||||
// FIXME: Open a stream without an IOHandle
|
||||
@@ -705,7 +817,7 @@ class OpenStreamTest : public AudioConfigPrimaryTest,
|
||||
return res;
|
||||
}
|
||||
|
||||
void waitForStreamDestruction() {
|
||||
static void waitForStreamDestruction() {
|
||||
// FIXME: there is no way to know when the remote IStream is being destroyed
|
||||
// Binder does not support testing if an object is alive, thus
|
||||
// wait for 100ms to let the binder destruction propagates and
|
||||
@@ -716,12 +828,14 @@ class OpenStreamTest : public AudioConfigPrimaryTest,
|
||||
usleep(100 * 1000);
|
||||
}
|
||||
|
||||
private:
|
||||
bool areAudioPatchesSupported() { return extract(getDevice()->supportsAudioPatches()); }
|
||||
|
||||
private:
|
||||
void TearDown() override {
|
||||
if (open) {
|
||||
ASSERT_OK(closeStream());
|
||||
}
|
||||
AudioConfigPrimaryTest::TearDown();
|
||||
AudioPolicyConfigTest::TearDown();
|
||||
}
|
||||
|
||||
protected:
|
||||
@@ -738,18 +852,19 @@ class OutputStreamTest : public OpenStreamTest<IStreamOut> {
|
||||
ASSERT_NO_FATAL_FAILURE(OpenStreamTest::SetUp()); // setup base
|
||||
if (IsSkipped()) return; // do not attempt to use 'device'
|
||||
address.device = AudioDevice::OUT_DEFAULT;
|
||||
const AudioConfig& config = GetParam();
|
||||
const AudioConfig& config = getConfig();
|
||||
// TODO: test all flag combination
|
||||
auto flags = mkEnumBitfield(AudioOutputFlag::NONE);
|
||||
testOpen(
|
||||
[&](AudioIoHandle handle, AudioConfig config, auto cb) {
|
||||
[&](AudioIoHandle handle, AudioConfig config, auto cb) {
|
||||
#if MAJOR_VERSION == 2
|
||||
return device->openOutputStream(handle, address, config, flags, cb);
|
||||
return getDevice()->openOutputStream(handle, address, config, flags, cb);
|
||||
#elif MAJOR_VERSION >= 4
|
||||
return device->openOutputStream(handle, address, config, flags, initMetadata, cb);
|
||||
return getDevice()->openOutputStream(handle, address, config, flags,
|
||||
initMetadata, cb);
|
||||
#endif
|
||||
},
|
||||
config);
|
||||
},
|
||||
config);
|
||||
}
|
||||
#if MAJOR_VERSION >= 4
|
||||
|
||||
@@ -767,18 +882,23 @@ TEST_P(OutputStreamTest, OpenOutputStreamTest) {
|
||||
// Open done in SetUp
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
RequiredOutputStreamConfigSupport, OutputStreamTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getRequiredSupportPlaybackAudioConfig()),
|
||||
&generateTestName);
|
||||
RequiredOutputStreamConfigSupport, OutputStreamTest,
|
||||
::testing::Combine(
|
||||
::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getRequiredSupportPlaybackAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SupportedOutputStreamConfig, OutputStreamTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getSupportedPlaybackAudioConfig()),
|
||||
&generateTestName);
|
||||
SupportedOutputStreamConfig, OutputStreamTest,
|
||||
::testing::Combine(::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getSupportedPlaybackAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
RecommendedOutputStreamConfigSupport, OutputStreamTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getRecommendedSupportPlaybackAudioConfig()),
|
||||
&generateTestName);
|
||||
RecommendedOutputStreamConfigSupport, OutputStreamTest,
|
||||
::testing::Combine(
|
||||
::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getRecommendedSupportPlaybackAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
|
||||
////////////////////////////// openInputStream //////////////////////////////
|
||||
|
||||
@@ -787,14 +907,15 @@ class InputStreamTest : public OpenStreamTest<IStreamIn> {
|
||||
ASSERT_NO_FATAL_FAILURE(OpenStreamTest::SetUp()); // setup base
|
||||
if (IsSkipped()) return; // do not attempt to use 'device'
|
||||
address.device = AudioDevice::IN_DEFAULT;
|
||||
const AudioConfig& config = GetParam();
|
||||
const AudioConfig& config = getConfig();
|
||||
// TODO: test all supported flags and source
|
||||
auto flags = mkEnumBitfield(AudioInputFlag::NONE);
|
||||
testOpen(
|
||||
[&](AudioIoHandle handle, AudioConfig config, auto cb) {
|
||||
return device->openInputStream(handle, address, config, flags, initMetadata, cb);
|
||||
},
|
||||
config);
|
||||
[&](AudioIoHandle handle, AudioConfig config, auto cb) {
|
||||
return getDevice()->openInputStream(handle, address, config, flags,
|
||||
initMetadata, cb);
|
||||
},
|
||||
config);
|
||||
}
|
||||
|
||||
protected:
|
||||
@@ -812,34 +933,28 @@ TEST_P(InputStreamTest, OpenInputStreamTest) {
|
||||
// Open done in setup
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
RequiredInputStreamConfigSupport, InputStreamTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getRequiredSupportCaptureAudioConfig()),
|
||||
&generateTestName);
|
||||
RequiredInputStreamConfigSupport, InputStreamTest,
|
||||
::testing::Combine(
|
||||
::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getRequiredSupportCaptureAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SupportedInputStreamConfig, InputStreamTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getSupportedCaptureAudioConfig()),
|
||||
&generateTestName);
|
||||
SupportedInputStreamConfig, InputStreamTest,
|
||||
::testing::Combine(::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getSupportedCaptureAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
RecommendedInputStreamConfigSupport, InputStreamTest,
|
||||
::testing::ValuesIn(AudioConfigPrimaryTest::getRecommendedSupportCaptureAudioConfig()),
|
||||
&generateTestName);
|
||||
RecommendedInputStreamConfigSupport, InputStreamTest,
|
||||
::testing::Combine(
|
||||
::testing::ValuesIn(getDeviceParameters()),
|
||||
::testing::ValuesIn(ConfigHelper::getRecommendedSupportCaptureAudioConfig())),
|
||||
&DeviceConfigParameterToString);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////// IStream getters ///////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/** Unpack the provided result.
|
||||
* If the result is not OK, register a failure and return an undefined value. */
|
||||
template <class R>
|
||||
static R extract(Return<R> ret) {
|
||||
if (!ret.isOk()) {
|
||||
EXPECT_IS_OK(ret);
|
||||
return R{};
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Could not find a way to write a test for two parametrized class fixure
|
||||
* thus use this macro do duplicate tests for Input and Output stream */
|
||||
#define TEST_IO_STREAM(test_name, documentation, code) \
|
||||
@@ -1189,11 +1304,7 @@ TEST_P(OutputStreamTest, PrepareForWritingCheckOverflow) {
|
||||
struct Capability {
|
||||
Capability(IStreamOut* stream) {
|
||||
EXPECT_OK(stream->supportsPauseAndResume(returnIn(pause, resume)));
|
||||
auto ret = stream->supportsDrain();
|
||||
EXPECT_IS_OK(ret);
|
||||
if (ret.isOk()) {
|
||||
drain = ret;
|
||||
}
|
||||
drain = extract(stream->supportsDrain());
|
||||
}
|
||||
bool pause = false;
|
||||
bool resume = false;
|
||||
@@ -1205,19 +1316,6 @@ TEST_P(OutputStreamTest, SupportsPauseAndResumeAndDrain) {
|
||||
Capability(stream.get());
|
||||
}
|
||||
|
||||
template <class Value>
|
||||
static void checkInvalidStateOr0(Result res, Value value) {
|
||||
switch (res) {
|
||||
case Result::INVALID_STATE:
|
||||
break;
|
||||
case Result::OK:
|
||||
ASSERT_EQ(0U, value);
|
||||
break;
|
||||
default:
|
||||
FAIL() << "Unexpected result " << toString(res);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_P(OutputStreamTest, GetRenderPosition) {
|
||||
doc::test("A new stream render position should be 0 or INVALID_STATE");
|
||||
uint32_t dspFrames;
|
||||
@@ -1226,7 +1324,7 @@ TEST_P(OutputStreamTest, GetRenderPosition) {
|
||||
doc::partialTest("getRenderPosition is not supported");
|
||||
return;
|
||||
}
|
||||
checkInvalidStateOr0(res, dspFrames);
|
||||
expectValueOrFailure(res, 0U, dspFrames, Result::INVALID_STATE);
|
||||
}
|
||||
|
||||
TEST_P(OutputStreamTest, GetNextWriteTimestamp) {
|
||||
@@ -1237,7 +1335,7 @@ TEST_P(OutputStreamTest, GetNextWriteTimestamp) {
|
||||
doc::partialTest("getNextWriteTimestamp is not supported");
|
||||
return;
|
||||
}
|
||||
checkInvalidStateOr0(res, timestampUs);
|
||||
expectValueOrFailure(res, uint64_t{0}, timestampUs, Result::INVALID_STATE);
|
||||
}
|
||||
|
||||
/** Stub implementation of out stream callback. */
|
||||
@@ -1364,19 +1462,19 @@ TEST_P(OutputStreamTest, GetPresentationPositionStop) {
|
||||
/////////////////////////////// PrimaryDevice ////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
TEST_F(AudioPrimaryHidlTest, setVoiceVolume) {
|
||||
TEST_P(AudioPrimaryHidlTest, setVoiceVolume) {
|
||||
doc::test("Make sure setVoiceVolume only succeed if volume is in [0,1]");
|
||||
testUnitaryGain([](float volume) { return device->setVoiceVolume(volume); });
|
||||
testUnitaryGain([this](float volume) { return getDevice()->setVoiceVolume(volume); });
|
||||
}
|
||||
|
||||
TEST_F(BoolAccessorPrimaryHidlTest, BtScoNrecEnabled) {
|
||||
TEST_P(BoolAccessorPrimaryHidlTest, BtScoNrecEnabled) {
|
||||
doc::test("Query and set the BT SCO NR&EC state");
|
||||
testAccessors<OPTIONAL>("BtScoNrecEnabled", Initial{false, OPTIONAL}, {true},
|
||||
&IPrimaryDevice::setBtScoNrecEnabled,
|
||||
&IPrimaryDevice::getBtScoNrecEnabled);
|
||||
}
|
||||
|
||||
TEST_F(BoolAccessorPrimaryHidlTest, setGetBtScoWidebandEnabled) {
|
||||
TEST_P(BoolAccessorPrimaryHidlTest, setGetBtScoWidebandEnabled) {
|
||||
doc::test("Query and set the SCO whideband state");
|
||||
testAccessors<OPTIONAL>("BtScoWideband", Initial{false, OPTIONAL}, {true},
|
||||
&IPrimaryDevice::setBtScoWidebandEnabled,
|
||||
@@ -1384,15 +1482,17 @@ TEST_F(BoolAccessorPrimaryHidlTest, setGetBtScoWidebandEnabled) {
|
||||
}
|
||||
|
||||
using TtyModeAccessorPrimaryHidlTest = AccessorPrimaryHidlTest<IPrimaryDevice::TtyMode>;
|
||||
TEST_F(TtyModeAccessorPrimaryHidlTest, setGetTtyMode) {
|
||||
TEST_P(TtyModeAccessorPrimaryHidlTest, setGetTtyMode) {
|
||||
doc::test("Query and set the TTY mode state");
|
||||
testAccessors<OPTIONAL>(
|
||||
"TTY mode", Initial{IPrimaryDevice::TtyMode::OFF},
|
||||
{IPrimaryDevice::TtyMode::HCO, IPrimaryDevice::TtyMode::VCO, IPrimaryDevice::TtyMode::FULL},
|
||||
&IPrimaryDevice::setTtyMode, &IPrimaryDevice::getTtyMode);
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(TtyModeAccessorPrimaryHidl, TtyModeAccessorPrimaryHidlTest,
|
||||
::testing::ValuesIn(getDeviceParameters()), &DeviceParameterToString);
|
||||
|
||||
TEST_F(BoolAccessorPrimaryHidlTest, setGetHac) {
|
||||
TEST_P(BoolAccessorPrimaryHidlTest, setGetHac) {
|
||||
doc::test("Query and set the HAC state");
|
||||
testAccessors<OPTIONAL>("HAC", Initial{false}, {true}, &IPrimaryDevice::setHacEnabled,
|
||||
&IPrimaryDevice::getHacEnabled);
|
||||
@@ -1404,9 +1504,13 @@ TEST_F(BoolAccessorPrimaryHidlTest, setGetHac) {
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
environment = new AudioHidlTestEnvironment;
|
||||
// For V2..5 it's critical to initialize environment before GTest.
|
||||
// The environment parses the service name from the command line,
|
||||
// then it can be used in GTest parameter generators which are
|
||||
// initialized during the call to InitGoogleTest.
|
||||
environment->init(&argc, argv);
|
||||
::testing::AddGlobalTestEnvironment(environment);
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
environment->init(&argc, argv);
|
||||
int status = RUN_ALL_TESTS();
|
||||
return status;
|
||||
}
|
||||
|
||||
143
audio/core/all-versions/vts/functional/DeviceManager.h
Normal file
143
audio/core/all-versions/vts/functional/DeviceManager.h
Normal file
@@ -0,0 +1,143 @@
|
||||
/*
|
||||
* Copyright (C) 2019 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.
|
||||
*/
|
||||
|
||||
// Code in this file uses 'environment'
|
||||
#ifndef AUDIO_PRIMARY_HIDL_HAL_TEST
|
||||
#error Must be included from AudioPrimaryHidlTest.h
|
||||
#endif
|
||||
|
||||
template <class Derived, class Key, class Interface>
|
||||
class InterfaceManager {
|
||||
public:
|
||||
sp<Interface> get(const Key& name) {
|
||||
auto existing = instances.find(name);
|
||||
if (existing != instances.end()) return existing->second;
|
||||
auto [inserted, _] = instances.emplace(name, Derived::createInterfaceInstance(name));
|
||||
if (inserted->second) {
|
||||
environment->registerTearDown([name]() { (void)Derived::getInstance().reset(name); });
|
||||
}
|
||||
return inserted->second;
|
||||
}
|
||||
|
||||
// The test must check that reset was successful. Reset failure means that the test code
|
||||
// is holding a strong reference to the device.
|
||||
bool reset(const Key& name) __attribute__((warn_unused_result)) {
|
||||
auto iter = instances.find(name);
|
||||
if (iter == instances.end()) return true;
|
||||
::android::wp<Interface> weak = iter->second;
|
||||
instances.erase(iter);
|
||||
if (weak.promote() != nullptr) return false;
|
||||
waitForInstanceDestruction();
|
||||
return true;
|
||||
}
|
||||
|
||||
static void waitForInstanceDestruction() {
|
||||
// FIXME: there is no way to know when the remote IDevice is being destroyed
|
||||
// Binder does not support testing if an object is alive, thus
|
||||
// wait for 100ms to let the binder destruction propagates and
|
||||
// the remote device has the time to be destroyed.
|
||||
// flushCommand makes sure all local command are sent, thus should reduce
|
||||
// the latency between local and remote destruction.
|
||||
IPCThreadState::self()->flushCommands();
|
||||
usleep(100 * 1000);
|
||||
}
|
||||
|
||||
protected:
|
||||
std::map<Key, sp<Interface>> instances;
|
||||
};
|
||||
|
||||
class DevicesFactoryManager
|
||||
: public InterfaceManager<DevicesFactoryManager, std::string, IDevicesFactory> {
|
||||
public:
|
||||
static DevicesFactoryManager& getInstance() {
|
||||
static DevicesFactoryManager instance;
|
||||
return instance;
|
||||
}
|
||||
static sp<IDevicesFactory> createInterfaceInstance(const std::string& name) {
|
||||
#if MAJOR_VERSION <= 5
|
||||
return ::testing::VtsHalHidlTargetTestBase::getService<IDevicesFactory>(name);
|
||||
#elif MAJOR_VERSION >= 6
|
||||
return IDevicesFactory::getService(name);
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
using FactoryAndDevice = std::tuple<std::string, std::string>;
|
||||
class DeviceManager : public InterfaceManager<DeviceManager, FactoryAndDevice, IDevice> {
|
||||
public:
|
||||
static DeviceManager& getInstance() {
|
||||
static DeviceManager instance;
|
||||
return instance;
|
||||
}
|
||||
static sp<IDevice> createInterfaceInstance(const FactoryAndDevice& factoryAndDevice) {
|
||||
auto [factoryName, name] = factoryAndDevice;
|
||||
sp<IDevicesFactory> factory = DevicesFactoryManager::getInstance().get(factoryName);
|
||||
return name == kPrimaryDevice ? openPrimaryDevice(factory) : openDevice(factory, name);
|
||||
}
|
||||
using InterfaceManager::reset;
|
||||
|
||||
static constexpr const char* kPrimaryDevice = "primary";
|
||||
|
||||
sp<IDevice> get(const std::string& factoryName, const std::string& name) {
|
||||
return InterfaceManager::get(std::make_tuple(factoryName, name));
|
||||
}
|
||||
sp<IPrimaryDevice> getPrimary(const std::string& factoryName) {
|
||||
sp<IDevice> device = get(factoryName, kPrimaryDevice);
|
||||
return device != nullptr ? IPrimaryDevice::castFrom(device) : nullptr;
|
||||
}
|
||||
bool reset(const std::string& factoryName, const std::string& name)
|
||||
__attribute__((warn_unused_result)) {
|
||||
return InterfaceManager::reset(std::make_tuple(factoryName, name));
|
||||
}
|
||||
bool resetPrimary(const std::string& factoryName) __attribute__((warn_unused_result)) {
|
||||
return reset(factoryName, kPrimaryDevice);
|
||||
}
|
||||
|
||||
private:
|
||||
static sp<IDevice> openDevice(const sp<IDevicesFactory>& factory, const std::string& name) {
|
||||
if (factory == nullptr) return nullptr;
|
||||
sp<IDevice> device;
|
||||
#if MAJOR_VERSION >= 4
|
||||
Result result;
|
||||
auto ret = factory->openDevice(name, returnIn(result, device));
|
||||
if (!ret.isOk() || result != Result::OK || device == nullptr) {
|
||||
ALOGW("Device %s can not be opened, transaction: %s, result %d, device %p",
|
||||
name.c_str(), ret.description().c_str(), result, device.get());
|
||||
return nullptr;
|
||||
}
|
||||
#else
|
||||
(void)name;
|
||||
#endif
|
||||
return device;
|
||||
}
|
||||
|
||||
static sp<IDevice> openPrimaryDevice(const sp<IDevicesFactory>& factory) {
|
||||
if (factory == nullptr) return nullptr;
|
||||
Result result;
|
||||
sp<IDevice> device;
|
||||
#if MAJOR_VERSION == 2
|
||||
auto ret = factory->openDevice(IDevicesFactory::Device::PRIMARY, returnIn(result, device));
|
||||
#elif MAJOR_VERSION >= 4
|
||||
auto ret = factory->openPrimaryDevice(returnIn(result, device));
|
||||
#endif
|
||||
if (!ret.isOk() || result != Result::OK || device == nullptr) {
|
||||
ALOGW("Primary device can not be opened, transaction: %s, result %d, device %p",
|
||||
ret.description().c_str(), result, device.get());
|
||||
return nullptr;
|
||||
}
|
||||
return device;
|
||||
}
|
||||
};
|
||||
@@ -28,8 +28,14 @@
|
||||
|
||||
#include <common/all-versions/VersionUtils.h>
|
||||
|
||||
#if MAJOR_VERSION <= 5
|
||||
#include <VtsHalHidlTargetTestBase.h>
|
||||
#include <VtsHalHidlTargetTestEnvBase.h>
|
||||
#elif MAJOR_VERSION >= 6
|
||||
#include <gtest/gtest.h>
|
||||
#include <hidl/GtestPrinter.h>
|
||||
#include <hidl/ServiceManagement.h>
|
||||
#endif
|
||||
|
||||
using ::android::sp;
|
||||
using ::android::hardware::hidl_handle;
|
||||
@@ -49,6 +55,11 @@ using namespace ::android::hardware::audio::effect::CPP_VERSION;
|
||||
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
|
||||
#endif
|
||||
|
||||
#if MAJOR_VERSION <= 5
|
||||
// For HAL versions 2..5 Vts Environment and Test base classes are used.
|
||||
// The tests are non-parametrized.
|
||||
#define EFFECT_TEST TEST_F
|
||||
|
||||
// Test environment for Audio Effects Factory HIDL HAL.
|
||||
class AudioEffectsFactoryHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
|
||||
public:
|
||||
@@ -71,6 +82,18 @@ class AudioEffectsFactoryHidlTest : public ::testing::VtsHalHidlTargetTestBase {
|
||||
ASSERT_NE(effectsFactory, nullptr);
|
||||
}
|
||||
|
||||
#elif MAJOR_VERSION >= 6
|
||||
// For HAL version 6 and above, standard GTest Environment and Test base classes are used.
|
||||
// The tests are parametrized by the IEffectsFactory instance name.
|
||||
#define EFFECT_TEST TEST_P
|
||||
|
||||
class AudioEffectsFactoryHidlTest : public ::testing::TestWithParam<std::string> {
|
||||
public:
|
||||
void SetUp() override {
|
||||
effectsFactory = IEffectsFactory::getService(GetParam());
|
||||
ASSERT_NE(effectsFactory, nullptr);
|
||||
}
|
||||
#endif // The rest of the AudioEffectsFactoryHidlTest class definition is the same.
|
||||
void TearDown() override { effectsFactory.clear(); }
|
||||
|
||||
protected:
|
||||
@@ -81,7 +104,7 @@ class AudioEffectsFactoryHidlTest : public ::testing::VtsHalHidlTargetTestBase {
|
||||
sp<IEffectsFactory> effectsFactory;
|
||||
};
|
||||
|
||||
TEST_F(AudioEffectsFactoryHidlTest, EnumerateEffects) {
|
||||
EFFECT_TEST(AudioEffectsFactoryHidlTest, EnumerateEffects) {
|
||||
description("Verify that EnumerateEffects returns at least one effect");
|
||||
Result retval = Result::NOT_INITIALIZED;
|
||||
size_t effectCount = 0;
|
||||
@@ -95,7 +118,7 @@ TEST_F(AudioEffectsFactoryHidlTest, EnumerateEffects) {
|
||||
EXPECT_GT(effectCount, 0u);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectsFactoryHidlTest, CreateEffect) {
|
||||
EFFECT_TEST(AudioEffectsFactoryHidlTest, CreateEffect) {
|
||||
description("Verify that an effect can be created via CreateEffect");
|
||||
bool gotEffect = false;
|
||||
Uuid effectUuid;
|
||||
@@ -123,7 +146,7 @@ TEST_F(AudioEffectsFactoryHidlTest, CreateEffect) {
|
||||
EXPECT_NE(nullptr, effect.get());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectsFactoryHidlTest, GetDescriptor) {
|
||||
EFFECT_TEST(AudioEffectsFactoryHidlTest, GetDescriptor) {
|
||||
description(
|
||||
"Verify that effects factory can provide an effect descriptor via "
|
||||
"GetDescriptor");
|
||||
@@ -146,7 +169,7 @@ TEST_F(AudioEffectsFactoryHidlTest, GetDescriptor) {
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectsFactoryHidlTest, DebugDumpInvalidArgument) {
|
||||
EFFECT_TEST(AudioEffectsFactoryHidlTest, DebugDumpInvalidArgument) {
|
||||
description("Verify that debugDump doesn't crash on invalid arguments");
|
||||
#if MAJOR_VERSION == 2
|
||||
Return<void> ret = effectsFactory->debugDump(hidl_handle());
|
||||
@@ -168,10 +191,17 @@ static const Uuid LOUDNESS_ENHANCER_EFFECT_TYPE = {
|
||||
std::array<uint8_t, 6>{{0x11, 0x26, 0x0e, 0xb6, 0x3c, 0xf1}}};
|
||||
|
||||
// The main test class for Audio Effect HIDL HAL.
|
||||
#if MAJOR_VERSION <= 5
|
||||
class AudioEffectHidlTest : public ::testing::VtsHalHidlTargetTestBase {
|
||||
public:
|
||||
void SetUp() override {
|
||||
effectsFactory = ::testing::VtsHalHidlTargetTestBase::getService<IEffectsFactory>();
|
||||
#elif MAJOR_VERSION >= 6
|
||||
class AudioEffectHidlTest : public ::testing::TestWithParam<std::string> {
|
||||
public:
|
||||
void SetUp() override {
|
||||
effectsFactory = IEffectsFactory::getService(GetParam());
|
||||
#endif
|
||||
ASSERT_NE(nullptr, effectsFactory.get());
|
||||
|
||||
findAndCreateEffect(getEffectType());
|
||||
@@ -250,14 +280,14 @@ void AudioEffectHidlTest::getChannelCount(uint32_t* channelCount) {
|
||||
static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels));
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, Close) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, Close) {
|
||||
description("Verify that an effect can be closed");
|
||||
Return<Result> ret = effect->close();
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
EXPECT_EQ(Result::OK, ret);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, GetDescriptor) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, GetDescriptor) {
|
||||
description("Verify that an effect can return its own descriptor via GetDescriptor");
|
||||
Result retval = Result::NOT_INITIALIZED;
|
||||
Uuid actualType;
|
||||
@@ -272,7 +302,7 @@ TEST_F(AudioEffectHidlTest, GetDescriptor) {
|
||||
EXPECT_EQ(getEffectType(), actualType);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, GetSetConfig) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, GetSetConfig) {
|
||||
description(
|
||||
"Verify that it is possible to manipulate effect config via Get / "
|
||||
"SetConfig");
|
||||
@@ -291,26 +321,26 @@ TEST_F(AudioEffectHidlTest, GetSetConfig) {
|
||||
EXPECT_EQ(Result::OK, ret2);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, GetConfigReverse) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, GetConfigReverse) {
|
||||
description("Verify that GetConfigReverse does not crash");
|
||||
Return<void> ret = effect->getConfigReverse([&](Result, const EffectConfig&) {});
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, GetSupportedAuxChannelsConfigs) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, GetSupportedAuxChannelsConfigs) {
|
||||
description("Verify that GetSupportedAuxChannelsConfigs does not crash");
|
||||
Return<void> ret = effect->getSupportedAuxChannelsConfigs(
|
||||
0, [&](Result, const hidl_vec<EffectAuxChannelsConfig>&) {});
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, GetAuxChannelsConfig) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, GetAuxChannelsConfig) {
|
||||
description("Verify that GetAuxChannelsConfig does not crash");
|
||||
Return<void> ret = effect->getAuxChannelsConfig([&](Result, const EffectAuxChannelsConfig&) {});
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetAuxChannelsConfig) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetAuxChannelsConfig) {
|
||||
description("Verify that SetAuxChannelsConfig does not crash");
|
||||
Return<Result> ret = effect->setAuxChannelsConfig(EffectAuxChannelsConfig());
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
@@ -349,7 +379,7 @@ inline bool operator==(const EffectConfig& lhs, const EffectConfig& rhs) {
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
||||
TEST_F(AudioEffectHidlTest, Reset) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, Reset) {
|
||||
description("Verify that Reset preserves effect configuration");
|
||||
Result retval = Result::NOT_INITIALIZED;
|
||||
EffectConfig originalConfig;
|
||||
@@ -374,7 +404,7 @@ TEST_F(AudioEffectHidlTest, Reset) {
|
||||
EXPECT_EQ(originalConfig, configAfterReset);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, DisableEnableDisable) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, DisableEnableDisable) {
|
||||
description("Verify Disable -> Enable -> Disable sequence for an effect");
|
||||
Return<Result> ret = effect->disable();
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
@@ -387,14 +417,14 @@ TEST_F(AudioEffectHidlTest, DisableEnableDisable) {
|
||||
EXPECT_EQ(Result::OK, ret);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetDevice) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetDevice) {
|
||||
description("Verify that SetDevice works for an output chain effect");
|
||||
Return<Result> ret = effect->setDevice(mkEnumBitfield(AudioDevice::OUT_SPEAKER));
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
EXPECT_EQ(Result::OK, ret);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetAndGetVolume) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetAndGetVolume) {
|
||||
description("Verify that SetAndGetVolume method works for an effect");
|
||||
uint32_t channelCount;
|
||||
getChannelCount(&channelCount);
|
||||
@@ -410,7 +440,7 @@ TEST_F(AudioEffectHidlTest, SetAndGetVolume) {
|
||||
EXPECT_EQ(Result::OK, retval);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, VolumeChangeNotification) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, VolumeChangeNotification) {
|
||||
description("Verify that effect accepts VolumeChangeNotification");
|
||||
uint32_t channelCount;
|
||||
getChannelCount(&channelCount);
|
||||
@@ -424,32 +454,32 @@ TEST_F(AudioEffectHidlTest, VolumeChangeNotification) {
|
||||
EXPECT_EQ(Result::OK, ret);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetAudioMode) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetAudioMode) {
|
||||
description("Verify that SetAudioMode works for an effect");
|
||||
Return<Result> ret = effect->setAudioMode(AudioMode::NORMAL);
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
EXPECT_EQ(Result::OK, ret);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetConfigReverse) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetConfigReverse) {
|
||||
description("Verify that SetConfigReverse does not crash");
|
||||
Return<Result> ret = effect->setConfigReverse(EffectConfig(), nullptr, nullptr);
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetInputDevice) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetInputDevice) {
|
||||
description("Verify that SetInputDevice does not crash");
|
||||
Return<Result> ret = effect->setInputDevice(mkEnumBitfield(AudioDevice::IN_BUILTIN_MIC));
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetAudioSource) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetAudioSource) {
|
||||
description("Verify that SetAudioSource does not crash");
|
||||
Return<Result> ret = effect->setAudioSource(AudioSource::MIC);
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, Offload) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, Offload) {
|
||||
description("Verify that calling Offload method does not crash");
|
||||
EffectOffloadParameter offloadParam;
|
||||
offloadParam.isOffload = false;
|
||||
@@ -458,7 +488,7 @@ TEST_F(AudioEffectHidlTest, Offload) {
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, PrepareForProcessing) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, PrepareForProcessing) {
|
||||
description("Verify that PrepareForProcessing method works for an effect");
|
||||
Result retval = Result::NOT_INITIALIZED;
|
||||
Return<void> ret = effect->prepareForProcessing(
|
||||
@@ -467,7 +497,7 @@ TEST_F(AudioEffectHidlTest, PrepareForProcessing) {
|
||||
EXPECT_EQ(Result::OK, retval);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetProcessBuffers) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetProcessBuffers) {
|
||||
description("Verify that SetProcessBuffers works for an effect");
|
||||
sp<IAllocator> ashmem = IAllocator::getService("ashmem");
|
||||
ASSERT_NE(nullptr, ashmem.get());
|
||||
@@ -486,41 +516,41 @@ TEST_F(AudioEffectHidlTest, SetProcessBuffers) {
|
||||
EXPECT_EQ(Result::OK, ret2);
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, Command) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, Command) {
|
||||
description("Verify that Command does not crash");
|
||||
Return<void> ret =
|
||||
effect->command(0, hidl_vec<uint8_t>(), 0, [&](int32_t, const hidl_vec<uint8_t>&) {});
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetParameter) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetParameter) {
|
||||
description("Verify that SetParameter does not crash");
|
||||
Return<Result> ret = effect->setParameter(hidl_vec<uint8_t>(), hidl_vec<uint8_t>());
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, GetParameter) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, GetParameter) {
|
||||
description("Verify that GetParameter does not crash");
|
||||
Return<void> ret =
|
||||
effect->getParameter(hidl_vec<uint8_t>(), 0, [&](Result, const hidl_vec<uint8_t>&) {});
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, GetSupportedConfigsForFeature) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, GetSupportedConfigsForFeature) {
|
||||
description("Verify that GetSupportedConfigsForFeature does not crash");
|
||||
Return<void> ret = effect->getSupportedConfigsForFeature(
|
||||
0, 0, 0, [&](Result, uint32_t, const hidl_vec<uint8_t>&) {});
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, GetCurrentConfigForFeature) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, GetCurrentConfigForFeature) {
|
||||
description("Verify that GetCurrentConfigForFeature does not crash");
|
||||
Return<void> ret =
|
||||
effect->getCurrentConfigForFeature(0, 0, [&](Result, const hidl_vec<uint8_t>&) {});
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
}
|
||||
|
||||
TEST_F(AudioEffectHidlTest, SetCurrentConfigForFeature) {
|
||||
EFFECT_TEST(AudioEffectHidlTest, SetCurrentConfigForFeature) {
|
||||
description("Verify that SetCurrentConfigForFeature does not crash");
|
||||
Return<Result> ret = effect->setCurrentConfigForFeature(0, hidl_vec<uint8_t>());
|
||||
EXPECT_TRUE(ret.isOk());
|
||||
@@ -606,21 +636,21 @@ void EqualizerAudioEffectHidlTest::getPresetCount(size_t* count) {
|
||||
ASSERT_EQ(Result::OK, retval);
|
||||
}
|
||||
|
||||
TEST_F(EqualizerAudioEffectHidlTest, GetNumBands) {
|
||||
EFFECT_TEST(EqualizerAudioEffectHidlTest, GetNumBands) {
|
||||
description("Verify that Equalizer effect reports at least one band");
|
||||
uint16_t numBands = 0;
|
||||
getNumBands(&numBands);
|
||||
EXPECT_GT(numBands, 0);
|
||||
}
|
||||
|
||||
TEST_F(EqualizerAudioEffectHidlTest, GetLevelRange) {
|
||||
EFFECT_TEST(EqualizerAudioEffectHidlTest, GetLevelRange) {
|
||||
description("Verify that Equalizer effect reports adequate band level range");
|
||||
int16_t minLevel = 0x7fff, maxLevel = 0;
|
||||
getLevelRange(&minLevel, &maxLevel);
|
||||
EXPECT_GT(maxLevel, minLevel);
|
||||
}
|
||||
|
||||
TEST_F(EqualizerAudioEffectHidlTest, GetSetBandLevel) {
|
||||
EFFECT_TEST(EqualizerAudioEffectHidlTest, GetSetBandLevel) {
|
||||
description("Verify that manipulating band levels works for Equalizer effect");
|
||||
uint16_t numBands = 0;
|
||||
getNumBands(&numBands);
|
||||
@@ -649,7 +679,7 @@ TEST_F(EqualizerAudioEffectHidlTest, GetSetBandLevel) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(EqualizerAudioEffectHidlTest, GetBandCenterFrequencyAndRange) {
|
||||
EFFECT_TEST(EqualizerAudioEffectHidlTest, GetBandCenterFrequencyAndRange) {
|
||||
description("Verify that Equalizer effect reports adequate band frequency range");
|
||||
uint16_t numBands = 0;
|
||||
getNumBands(&numBands);
|
||||
@@ -664,7 +694,7 @@ TEST_F(EqualizerAudioEffectHidlTest, GetBandCenterFrequencyAndRange) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(EqualizerAudioEffectHidlTest, GetBandForFrequency) {
|
||||
EFFECT_TEST(EqualizerAudioEffectHidlTest, GetBandForFrequency) {
|
||||
description("Verify that Equalizer effect supports GetBandForFrequency correctly");
|
||||
uint16_t numBands = 0;
|
||||
getNumBands(&numBands);
|
||||
@@ -693,14 +723,14 @@ TEST_F(EqualizerAudioEffectHidlTest, GetBandForFrequency) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(EqualizerAudioEffectHidlTest, GetPresetNames) {
|
||||
EFFECT_TEST(EqualizerAudioEffectHidlTest, GetPresetNames) {
|
||||
description("Verify that Equalizer effect reports at least one preset");
|
||||
size_t presetCount;
|
||||
getPresetCount(&presetCount);
|
||||
EXPECT_GT(presetCount, 0u);
|
||||
}
|
||||
|
||||
TEST_F(EqualizerAudioEffectHidlTest, GetSetCurrentPreset) {
|
||||
EFFECT_TEST(EqualizerAudioEffectHidlTest, GetSetCurrentPreset) {
|
||||
description("Verify that manipulating the current preset for Equalizer effect");
|
||||
size_t presetCount;
|
||||
getPresetCount(&presetCount);
|
||||
@@ -723,7 +753,7 @@ TEST_F(EqualizerAudioEffectHidlTest, GetSetCurrentPreset) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(EqualizerAudioEffectHidlTest, GetSetAllProperties) {
|
||||
EFFECT_TEST(EqualizerAudioEffectHidlTest, GetSetAllProperties) {
|
||||
description(
|
||||
"Verify that setting band levels and presets works via Get / "
|
||||
"SetAllProperties for Equalizer effect");
|
||||
@@ -787,7 +817,7 @@ class LoudnessEnhancerAudioEffectHidlTest : public AudioEffectHidlTest {
|
||||
sp<ILoudnessEnhancerEffect> enhancer;
|
||||
};
|
||||
|
||||
TEST_F(LoudnessEnhancerAudioEffectHidlTest, GetSetTargetGain) {
|
||||
EFFECT_TEST(LoudnessEnhancerAudioEffectHidlTest, GetSetTargetGain) {
|
||||
description(
|
||||
"Verify that manipulating the target gain works for Loudness Enhancer "
|
||||
"effect");
|
||||
@@ -808,6 +838,7 @@ TEST_F(LoudnessEnhancerAudioEffectHidlTest, GetSetTargetGain) {
|
||||
EXPECT_EQ(gain, actualGain);
|
||||
}
|
||||
|
||||
#if MAJOR_VERSION <= 5
|
||||
int main(int argc, char** argv) {
|
||||
::testing::AddGlobalTestEnvironment(AudioEffectsFactoryHidlEnvironment::Instance());
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
@@ -816,3 +847,17 @@ int main(int argc, char** argv) {
|
||||
LOG(INFO) << "Test result = " << status;
|
||||
return status;
|
||||
}
|
||||
#elif MAJOR_VERSION >= 6
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
EffectsFactory, AudioEffectsFactoryHidlTest,
|
||||
testing::ValuesIn(android::hardware::getAllHalInstanceNames(IEffectsFactory::descriptor)),
|
||||
android::hardware::PrintInstanceNameToString);
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
Equalizer, EqualizerAudioEffectHidlTest,
|
||||
testing::ValuesIn(android::hardware::getAllHalInstanceNames(IEffectsFactory::descriptor)),
|
||||
android::hardware::PrintInstanceNameToString);
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
LoudnessEnhancer, LoudnessEnhancerAudioEffectHidlTest,
|
||||
testing::ValuesIn(android::hardware::getAllHalInstanceNames(IEffectsFactory::descriptor)),
|
||||
android::hardware::PrintInstanceNameToString);
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user