Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b3f98045 authored by jiabin's avatar jiabin
Browse files

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
parent 8649bbe5

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)