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

Commit c7b23433 authored by Mikhail Naganov's avatar Mikhail Naganov Committed by Automerger Merge Worker
Browse files

Merge changes from topic "cuttlefish_aidl_audio-3" into main am: 273b25cd 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/2890734



Change-Id: I64207e2289de0192dac5c60de90f64fe5b5862bc
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents afc37164 273b25cd

media/libaudioclient/tests/audiorecord_tests.cpp

+74 −17
Original line number Diff line number Diff line
@@ -14,9 +14,13 @@ 
 * limitations under the License.

 */



#include <sstream>



//#define LOG_NDEBUG 0

#define LOG_TAG "AudioRecordTest"



#include <android-base/logging.h>

#include <binder/ProcessState.h>

#include <gtest/gtest.h>



#include "audio_test_utils.h"
@@ -25,32 +29,40 @@ using namespace android; 


class AudioRecordTest : public ::testing::Test {

  public:

    virtual void SetUp() override {

    void SetUp() override {

        mAC = new AudioCapture(AUDIO_SOURCE_DEFAULT, 44100, AUDIO_FORMAT_PCM_16_BIT,

                               AUDIO_CHANNEL_IN_FRONT);

        ASSERT_NE(nullptr, mAC);

        ASSERT_EQ(OK, mAC->create()) << "record creation failed";

    }



    virtual void TearDown() override {

    void TearDown() override {

        if (mAC) ASSERT_EQ(OK, mAC->stop());

    }



    sp<AudioCapture> mAC;

};



class AudioRecordCreateTest

    : public ::testing::TestWithParam<

              std::tuple<uint32_t, audio_format_t, audio_channel_mask_t, audio_input_flags_t,

                         audio_session_t, audio_source_t>> {

using RecordCreateTestParam = std::tuple<uint32_t, audio_format_t, audio_channel_mask_t,

                                         audio_input_flags_t, audio_session_t, audio_source_t>;

enum {

    RECORD_PARAM_SAMPLE_RATE,

    RECORD_PARAM_FORMAT,

    RECORD_PARAM_CHANNEL_MASK,

    RECORD_PARAM_FLAGS,

    RECORD_PARAM_SESSION_ID,

    RECORD_PARAM_INPUT_SOURCE

};



class AudioRecordCreateTest : public ::testing::TestWithParam<RecordCreateTestParam> {

  public:

    AudioRecordCreateTest()

        : mSampleRate(std::get<0>(GetParam())),

          mFormat(std::get<1>(GetParam())),

          mChannelMask(std::get<2>(GetParam())),

          mFlags(std::get<3>(GetParam())),

          mSessionId(std::get<4>(GetParam())),

          mInputSource(std::get<5>(GetParam())){};

        : mSampleRate(std::get<RECORD_PARAM_SAMPLE_RATE>(GetParam())),

          mFormat(std::get<RECORD_PARAM_FORMAT>(GetParam())),

          mChannelMask(std::get<RECORD_PARAM_CHANNEL_MASK>(GetParam())),

          mFlags(std::get<RECORD_PARAM_FLAGS>(GetParam())),

          mSessionId(std::get<RECORD_PARAM_SESSION_ID>(GetParam())),

          mInputSource(std::get<RECORD_PARAM_INPUT_SOURCE>(GetParam())){};



    const uint32_t mSampleRate;

    const audio_format_t mFormat;
@@ -62,14 +74,14 @@ class AudioRecordCreateTest 


    sp<AudioCapture> mAC;



    virtual void SetUp() override {

    void SetUp() override {

        mAC = new AudioCapture(mInputSource, mSampleRate, mFormat, mChannelMask, mFlags, mSessionId,

                               mTransferType);

        ASSERT_NE(nullptr, mAC);

        ASSERT_EQ(OK, mAC->create()) << "record creation failed";

    }



    virtual void TearDown() override {

    void TearDown() override {

        if (mAC) ASSERT_EQ(OK, mAC->stop());

    }

};
@@ -197,6 +209,18 @@ TEST_P(AudioRecordCreateTest, TestCreateRecord) { 
    EXPECT_EQ(OK, mAC->audioProcess()) << "audioProcess failed";

}



static std::string GetRecordTestName(const testing::TestParamInfo<RecordCreateTestParam>& info) {

    const auto& p = info.param;

    std::ostringstream s;

    s << std::get<RECORD_PARAM_SAMPLE_RATE>(p) << "_"

      << audio_format_to_string(std::get<RECORD_PARAM_FORMAT>(p)) << "__"

      << audio_channel_mask_to_string(std::get<RECORD_PARAM_CHANNEL_MASK>(p)) << "__"

      << "Flags_0x" << std::hex << std::get<RECORD_PARAM_FLAGS>(p) << std::dec << "__"

      << "Session_" << std::get<RECORD_PARAM_SESSION_ID>(p) << "__"

      << audio_source_to_string(std::get<RECORD_PARAM_INPUT_SOURCE>(p));

    return s.str();

}



// for port primary input

INSTANTIATE_TEST_SUITE_P(AudioRecordPrimaryInput, AudioRecordCreateTest,

                         ::testing::Combine(::testing::Values(8000, 11025, 12000, 16000, 22050,
@@ -207,7 +231,8 @@ INSTANTIATE_TEST_SUITE_P(AudioRecordPrimaryInput, AudioRecordCreateTest, 
                                                              AUDIO_CHANNEL_IN_FRONT_BACK),

                                            ::testing::Values(AUDIO_INPUT_FLAG_NONE),

                                            ::testing::Values(AUDIO_SESSION_NONE),

                                            ::testing::Values(AUDIO_SOURCE_DEFAULT)));

                                            ::testing::Values(AUDIO_SOURCE_DEFAULT)),

                         GetRecordTestName);



// for port fast input

INSTANTIATE_TEST_SUITE_P(AudioRecordFastInput, AudioRecordCreateTest,
@@ -219,7 +244,8 @@ INSTANTIATE_TEST_SUITE_P(AudioRecordFastInput, AudioRecordCreateTest, 
                                                              AUDIO_CHANNEL_IN_FRONT_BACK),

                                            ::testing::Values(AUDIO_INPUT_FLAG_FAST),

                                            ::testing::Values(AUDIO_SESSION_NONE),

                                            ::testing::Values(AUDIO_SOURCE_DEFAULT)));

                                            ::testing::Values(AUDIO_SOURCE_DEFAULT)),

                         GetRecordTestName);



// misc

INSTANTIATE_TEST_SUITE_P(AudioRecordMiscInput, AudioRecordCreateTest,
@@ -232,4 +258,35 @@ INSTANTIATE_TEST_SUITE_P(AudioRecordMiscInput, AudioRecordCreateTest, 
                                                              AUDIO_SOURCE_CAMCORDER,

                                                              AUDIO_SOURCE_VOICE_RECOGNITION,

                                                              AUDIO_SOURCE_VOICE_COMMUNICATION,

                                                              AUDIO_SOURCE_UNPROCESSED)));
 
                                                              AUDIO_SOURCE_UNPROCESSED)),

                         GetRecordTestName);



namespace {



class TestExecutionTracer : public ::testing::EmptyTestEventListener {

  public:

    void OnTestStart(const ::testing::TestInfo& test_info) override {

        TraceTestState("Started", test_info);

    }

    void OnTestEnd(const ::testing::TestInfo& test_info) override {

        TraceTestState("Finished", test_info);

    }

    void OnTestPartResult(const ::testing::TestPartResult& result) override { LOG(INFO) << result; }



  private:

    static void TraceTestState(const std::string& state, const ::testing::TestInfo& test_info) {

        LOG(INFO) << state << " " << test_info.test_suite_name() << "::" << test_info.name();

    }

};



}  // namespace



int main(int argc, char** argv) {

    ::testing::InitGoogleTest(&argc, argv);

    ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());

    android::base::SetMinimumLogSeverity(::android::base::DEBUG);

    // This is for death handlers instantiated by the framework code.

    android::ProcessState::self()->setThreadPoolMaxThreadCount(1);

    android::ProcessState::self()->startThreadPool();

    return RUN_ALL_TESTS();

}