Add audio health tests.

First test for audio health check. The test checks if all declared
devices found by checking if the audio device types of attached devices
can be seen by audio policy.

Bug: 141580284
Test: atest audio_health_tests audiopolicy_tests
Change-Id: I0374f382eaab7b36ab623b11a59e0634565f2187
Merged-In: I0374f382eaab7b36ab623b11a59e0634565f2187
gugelfrei
jiabin 5 years ago
parent 807d3ad2d8
commit 38b2c5d794

@ -38,3 +38,34 @@ cc_test {
test_suites: ["device-tests"],
}
cc_test {
name: "audio_health_tests",
shared_libs: [
"libaudiofoundation",
"libaudioclient",
"libaudiopolicymanagerdefault",
"liblog",
"libmedia_helper",
"libutils",
],
static_libs: ["libaudiopolicycomponents"],
header_libs: [
"libaudiopolicyengine_interface_headers",
"libaudiopolicymanager_interface_headers",
],
srcs: ["audio_health_tests.cpp"],
cflags: [
"-Werror",
"-Wall",
],
test_suites: ["device-tests"],
}

@ -0,0 +1,112 @@
/*
* 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.
*/
#include <map>
#include <system/audio.h>
#include <utils/Log.h>
#include <utils/String8.h>
#include "AudioPolicyTestClient.h"
namespace android {
class AudioPolicyManagerTestClient : public AudioPolicyTestClient {
public:
// AudioPolicyClientInterface implementation
audio_module_handle_t loadHwModule(const char * /*name*/) override {
return mNextModuleHandle++;
}
status_t openOutput(audio_module_handle_t module,
audio_io_handle_t *output,
audio_config_t * /*config*/,
audio_devices_t * /*devices*/,
const String8 & /*address*/,
uint32_t * /*latencyMs*/,
audio_output_flags_t /*flags*/) override {
if (module >= mNextModuleHandle) {
ALOGE("%s: Module handle %d has not been allocated yet (next is %d)",
__func__, module, mNextModuleHandle);
return BAD_VALUE;
}
*output = mNextIoHandle++;
return NO_ERROR;
}
audio_io_handle_t openDuplicateOutput(audio_io_handle_t /*output1*/,
audio_io_handle_t /*output2*/) override {
audio_io_handle_t id = mNextIoHandle++;
return id;
}
status_t openInput(audio_module_handle_t module,
audio_io_handle_t *input,
audio_config_t * /*config*/,
audio_devices_t * /*device*/,
const String8 & /*address*/,
audio_source_t /*source*/,
audio_input_flags_t /*flags*/) override {
if (module >= mNextModuleHandle) {
ALOGE("%s: Module handle %d has not been allocated yet (next is %d)",
__func__, module, mNextModuleHandle);
return BAD_VALUE;
}
*input = mNextIoHandle++;
return NO_ERROR;
}
status_t createAudioPatch(const struct audio_patch *patch,
audio_patch_handle_t *handle,
int /*delayMs*/) override {
*handle = mNextPatchHandle++;
mActivePatches.insert(std::make_pair(*handle, *patch));
return NO_ERROR;
}
status_t releaseAudioPatch(audio_patch_handle_t handle,
int /*delayMs*/) override {
if (mActivePatches.erase(handle) != 1) {
if (handle >= mNextPatchHandle) {
ALOGE("%s: Patch handle %d has not been allocated yet (next is %d)",
__func__, handle, mNextPatchHandle);
} else {
ALOGE("%s: Attempt to release patch %d twice", __func__, handle);
}
return BAD_VALUE;
}
return NO_ERROR;
}
// Helper methods for tests
size_t getActivePatchesCount() const { return mActivePatches.size(); }
const struct audio_patch *getLastAddedPatch() const {
if (mActivePatches.empty()) {
return nullptr;
}
auto it = --mActivePatches.end();
return &it->second;
};
private:
audio_module_handle_t mNextModuleHandle = AUDIO_MODULE_HANDLE_NONE + 1;
audio_io_handle_t mNextIoHandle = AUDIO_IO_HANDLE_NONE + 1;
audio_patch_handle_t mNextPatchHandle = AUDIO_PATCH_HANDLE_NONE + 1;
std::map<audio_patch_handle_t, struct audio_patch> mActivePatches;
};
} // namespace android

@ -24,6 +24,7 @@ class AudioPolicyTestManager : public AudioPolicyManager {
explicit AudioPolicyTestManager(AudioPolicyClientInterface *clientInterface)
: AudioPolicyManager(clientInterface, true /*forTesting*/) { }
using AudioPolicyManager::getConfig;
using AudioPolicyManager::loadConfig;
using AudioPolicyManager::initialize;
};

@ -0,0 +1,76 @@
/*
* 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.
*/
#define LOG_TAG "AudioPolicy_Boot_Test"
#include <unordered_set>
#include <gtest/gtest.h>
#include <media/AudioSystem.h>
#include <system/audio.h>
#include <utils/Log.h>
#include "AudioPolicyManagerTestClient.h"
#include "AudioPolicyTestManager.h"
using namespace android;
TEST(AudioHealthTest, AttachedDeviceFound) {
unsigned int numPorts;
unsigned int generation1;
unsigned int generation;
struct audio_port *audioPorts = NULL;
int attempts = 10;
do {
if (attempts-- < 0) {
free(audioPorts);
GTEST_FAIL() << "Query audio ports time out";
}
numPorts = 0;
ASSERT_EQ(NO_ERROR, AudioSystem::listAudioPorts(
AUDIO_PORT_ROLE_NONE, AUDIO_PORT_TYPE_DEVICE, &numPorts, NULL, &generation1));
if (numPorts == 0) {
free(audioPorts);
GTEST_FAIL() << "Number of audio ports should not be zero";
}
audioPorts = (struct audio_port *)realloc(audioPorts, numPorts * sizeof(struct audio_port));
status_t status = AudioSystem::listAudioPorts(
AUDIO_PORT_ROLE_NONE, AUDIO_PORT_TYPE_DEVICE, &numPorts, audioPorts, &generation);
if (status != NO_ERROR) {
free(audioPorts);
GTEST_FAIL() << "Query audio ports failed";
}
} while (generation1 != generation);
std::unordered_set<audio_devices_t> attachedDevices;
for (int i = 0 ; i < numPorts; i++) {
attachedDevices.insert(audioPorts[i].ext.device.type);
}
free(audioPorts);
AudioPolicyManagerTestClient client;
AudioPolicyTestManager manager(&client);
manager.loadConfig();
ASSERT_NE("AudioPolicyConfig::setDefault", manager.getConfig().getSource());
for (auto desc : manager.getConfig().getAvailableInputDevices()) {
ASSERT_NE(attachedDevices.end(), attachedDevices.find(desc->type()));
}
for (auto desc : manager.getConfig().getAvailableOutputDevices()) {
ASSERT_NE(attachedDevices.end(), attachedDevices.find(desc->type()));
}
}

@ -14,7 +14,6 @@
* limitations under the License.
*/
#include <map>
#include <memory>
#include <string>
#include <sys/wait.h>
@ -32,6 +31,7 @@
#include <utils/Vector.h>
#include "AudioPolicyInterface.h"
#include "AudioPolicyManagerTestClient.h"
#include "AudioPolicyTestClient.h"
#include "AudioPolicyTestManager.h"
@ -57,91 +57,6 @@ TEST(AudioPolicyManagerTestInit, ClientFailure) {
}
class AudioPolicyManagerTestClient : public AudioPolicyTestClient {
public:
// AudioPolicyClientInterface implementation
audio_module_handle_t loadHwModule(const char* /*name*/) override {
return mNextModuleHandle++;
}
status_t openOutput(audio_module_handle_t module,
audio_io_handle_t* output,
audio_config_t* /*config*/,
audio_devices_t* /*devices*/,
const String8& /*address*/,
uint32_t* /*latencyMs*/,
audio_output_flags_t /*flags*/) override {
if (module >= mNextModuleHandle) {
ALOGE("%s: Module handle %d has not been allocated yet (next is %d)",
__func__, module, mNextModuleHandle);
return BAD_VALUE;
}
*output = mNextIoHandle++;
return NO_ERROR;
}
audio_io_handle_t openDuplicateOutput(audio_io_handle_t /*output1*/,
audio_io_handle_t /*output2*/) override {
audio_io_handle_t id = mNextIoHandle++;
return id;
}
status_t openInput(audio_module_handle_t module,
audio_io_handle_t* input,
audio_config_t* /*config*/,
audio_devices_t* /*device*/,
const String8& /*address*/,
audio_source_t /*source*/,
audio_input_flags_t /*flags*/) override {
if (module >= mNextModuleHandle) {
ALOGE("%s: Module handle %d has not been allocated yet (next is %d)",
__func__, module, mNextModuleHandle);
return BAD_VALUE;
}
*input = mNextIoHandle++;
return NO_ERROR;
}
status_t createAudioPatch(const struct audio_patch* patch,
audio_patch_handle_t* handle,
int /*delayMs*/) override {
*handle = mNextPatchHandle++;
mActivePatches.insert(std::make_pair(*handle, *patch));
return NO_ERROR;
}
status_t releaseAudioPatch(audio_patch_handle_t handle,
int /*delayMs*/) override {
if (mActivePatches.erase(handle) != 1) {
if (handle >= mNextPatchHandle) {
ALOGE("%s: Patch handle %d has not been allocated yet (next is %d)",
__func__, handle, mNextPatchHandle);
} else {
ALOGE("%s: Attempt to release patch %d twice", __func__, handle);
}
return BAD_VALUE;
}
return NO_ERROR;
}
// Helper methods for tests
size_t getActivePatchesCount() const { return mActivePatches.size(); }
const struct audio_patch* getLastAddedPatch() const {
if (mActivePatches.empty()) {
return nullptr;
}
auto it = --mActivePatches.end();
return &it->second;
};
private:
audio_module_handle_t mNextModuleHandle = AUDIO_MODULE_HANDLE_NONE + 1;
audio_io_handle_t mNextIoHandle = AUDIO_IO_HANDLE_NONE + 1;
audio_patch_handle_t mNextPatchHandle = AUDIO_PATCH_HANDLE_NONE + 1;
std::map<audio_patch_handle_t, struct audio_patch> mActivePatches;
};
class PatchCountCheck {
public:
explicit PatchCountCheck(AudioPolicyManagerTestClient *client)

Loading…
Cancel
Save