Merge "Add audio health tests." (23d01901) · Commits · e / os / android_frameworks_av

services/audiopolicy/tests/Android.bp

+31 −0

Original line number	Diff line number	Diff line
		@@ -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"],

		}

services/audiopolicy/tests/AudioPolicyManagerTestClient.h

0 → 100644

+112 −0

Original line number	Diff line number	Diff line
		/*
		* 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

services/audiopolicy/tests/AudioPolicyTestManager.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -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;
		using AudioPolicyManager::getOutputs;
		};

services/audiopolicy/tests/audio_health_tests.cpp

0 → 100644

+76 −0

Original line number	Diff line number	Diff line
		/*
		* 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()));
		}
		}

services/audiopolicy/tests/audiopolicymanager_tests.cpp

+1 −86

Original line number	Diff line number	Diff line
		@@ -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)