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

Commit 7d50550b authored by Sungtak Lee's avatar Sungtak Lee Committed by Gerrit Code Review
Browse files

Merge "C2 Vts: Avoid using strings to pass integer and bool values"

parents 5e3cf46b fdd62ff6

media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp

+22 −27
Original line number Diff line number Diff line
@@ -33,11 +33,11 @@ 
using android::C2AllocatorIon;



#include "media_c2_hidl_test_common.h"

using DecodeTestParameters = std::tuple<std::string, std::string, uint32_t, bool>;

static std::vector<DecodeTestParameters> kDecodeTestParameters;



static std::vector<std::tuple<std::string, std::string, std::string, std::string>>

        kDecodeTestParameters;



static std::vector<std::tuple<std::string, std::string, std::string>> kCsdFlushTestParameters;

using CsdFlushTestParameters = std::tuple<std::string, std::string, bool>;

static std::vector<CsdFlushTestParameters> kCsdFlushTestParameters;



struct CompToURL {

    std::string mime;
@@ -202,9 +202,8 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test { 
    }

};



class Codec2AudioDecHidlTest

    : public Codec2AudioDecHidlTestBase,

      public ::testing::WithParamInterface<std::tuple<std::string, std::string>> {

class Codec2AudioDecHidlTest : public Codec2AudioDecHidlTestBase,

                               public ::testing::WithParamInterface<TestParameters> {

    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());
@@ -428,10 +427,8 @@ TEST_P(Codec2AudioDecHidlTest, configComp) { 
    ASSERT_EQ(mComponent->stop(), C2_OK);

}



class Codec2AudioDecDecodeTest

    : public Codec2AudioDecHidlTestBase,

      public ::testing::WithParamInterface<

              std::tuple<std::string, std::string, std::string, std::string>> {

class Codec2AudioDecDecodeTest : public Codec2AudioDecHidlTestBase,

                                 public ::testing::WithParamInterface<DecodeTestParameters> {

    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());
@@ -442,9 +439,8 @@ TEST_P(Codec2AudioDecDecodeTest, DecodeTest) { 
    description("Decodes input file");

    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    uint32_t streamIndex = std::stoi(std::get<2>(GetParam()));

    ;

    bool signalEOS = !std::get<3>(GetParam()).compare("true");

    uint32_t streamIndex = std::get<2>(GetParam());

    bool signalEOS = std::get<3>(GetParam());

    mTimestampDevTest = true;

    char mURL[512], info[512];

    android::Vector<FrameInfo> Info;
@@ -761,9 +757,8 @@ TEST_P(Codec2AudioDecHidlTest, DecodeTestEmptyBuffersInserted) { 
    ASSERT_EQ(mComponent->stop(), C2_OK);

}



class Codec2AudioDecCsdInputTests

    : public Codec2AudioDecHidlTestBase,

      public ::testing::WithParamInterface<std::tuple<std::string, std::string, std::string>> {

class Codec2AudioDecCsdInputTests : public Codec2AudioDecHidlTestBase,

                                    public ::testing::WithParamInterface<CsdFlushTestParameters> {

    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());
@@ -809,7 +804,7 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) { 
    ASSERT_EQ(eleStream.is_open(), true);



    bool signalEOS = false;

    bool flushCsd = !std::get<2>(GetParam()).compare("true");

    bool flushCsd = std::get<2>(GetParam());

    ALOGV("sending %d csd data ", numCsds);

    int framesToDecode = numCsds;

    ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
@@ -865,16 +860,16 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) { 
}



INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioDecHidlTest, testing::ValuesIn(kTestParameters),

                         android::hardware::PrintInstanceTupleNameToString<>);

                         PrintInstanceTupleNameToString<>);



// DecodeTest with StreamIndex and EOS / No EOS

INSTANTIATE_TEST_SUITE_P(StreamIndexAndEOS, Codec2AudioDecDecodeTest,

                         testing::ValuesIn(kDecodeTestParameters),

                         android::hardware::PrintInstanceTupleNameToString<>);

                         PrintInstanceTupleNameToString<>);



INSTANTIATE_TEST_SUITE_P(CsdInputs, Codec2AudioDecCsdInputTests,

                         testing::ValuesIn(kCsdFlushTestParameters),

                         android::hardware::PrintInstanceTupleNameToString<>);

                         PrintInstanceTupleNameToString<>);



}  // anonymous namespace
@@ -883,18 +878,18 @@ int main(int argc, char** argv) { 
    kTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_DECODER);

    for (auto params : kTestParameters) {

        kDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "0", "false"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false));

        kDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "0", "true"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true));

        kDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "1", "false"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 1, false));

        kDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "1", "true"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 1, true));



        kCsdFlushTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "true"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), true));

        kCsdFlushTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "false"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), false));

    }



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

media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp

+15 −17
Original line number Diff line number Diff line
@@ -35,8 +35,9 @@ using android::C2AllocatorIon; 


#include "media_c2_hidl_test_common.h"



static std::vector<std::tuple<std::string, std::string, std::string, std::string>>

        kEncodeTestParameters;

using EncodeTestParameters = std::tuple<std::string, std::string, bool, int32_t>;



static std::vector<EncodeTestParameters> kEncodeTestParameters;



class LinearBuffer : public C2Buffer {

  public:
@@ -170,9 +171,8 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test { 
    }

};



class Codec2AudioEncHidlTest

    : public Codec2AudioEncHidlTestBase,

      public ::testing::WithParamInterface<std::tuple<std::string, std::string>> {

class Codec2AudioEncHidlTest : public Codec2AudioEncHidlTestBase,

                               public ::testing::WithParamInterface<TestParameters> {

    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());
@@ -362,10 +362,8 @@ TEST_P(Codec2AudioEncHidlTest, validateCompName) { 
    ASSERT_EQ(mDisableTest, false);

}



class Codec2AudioEncEncodeTest

    : public Codec2AudioEncHidlTestBase,

      public ::testing::WithParamInterface<

              std::tuple<std::string, std::string, std::string, std::string>> {

class Codec2AudioEncEncodeTest : public Codec2AudioEncHidlTestBase,

                                 public ::testing::WithParamInterface<EncodeTestParameters> {

    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());
@@ -378,9 +376,9 @@ TEST_P(Codec2AudioEncEncodeTest, EncodeTest) { 
    char mURL[512];

    strcpy(mURL, sResourceDir.c_str());

    GetURLForComponent(mURL);

    bool signalEOS = !std::get<2>(GetParam()).compare("true");

    bool signalEOS = std::get<2>(GetParam());

    // Ratio w.r.t to mInputMaxBufSize

    int32_t inputMaxBufRatio = std::stoi(std::get<3>(GetParam()));

    int32_t inputMaxBufRatio = std::get<3>(GetParam());



    int32_t nChannels;

    int32_t nSampleRate;
@@ -751,13 +749,13 @@ TEST_P(Codec2AudioEncHidlTest, MultiSampleRateTest) { 
}



INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioEncHidlTest, testing::ValuesIn(kTestParameters),

                         android::hardware::PrintInstanceTupleNameToString<>);

                         PrintInstanceTupleNameToString<>);



// EncodeTest with EOS / No EOS and inputMaxBufRatio

// inputMaxBufRatio is ratio w.r.t. to mInputMaxBufSize

INSTANTIATE_TEST_SUITE_P(EncodeTest, Codec2AudioEncEncodeTest,

                         testing::ValuesIn(kEncodeTestParameters),

                         android::hardware::PrintInstanceTupleNameToString<>);

                         PrintInstanceTupleNameToString<>);



}  // anonymous namespace
@@ -766,13 +764,13 @@ int main(int argc, char** argv) { 
    kTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_ENCODER);

    for (auto params : kTestParameters) {

        kEncodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "false", "1"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), false, 1));

        kEncodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "false", "2"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), false, 2));

        kEncodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "true", "1"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), true, 1));

        kEncodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "true", "2"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), true, 2));

    }



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

media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.cpp

+4 −4
Original line number Diff line number Diff line
@@ -176,15 +176,15 @@ int64_t getNowUs() { 
}



// Return all test parameters, a list of tuple of <instance, component>

const std::vector<std::tuple<std::string, std::string>>& getTestParameters() {

const std::vector<TestParameters>& getTestParameters() {

    return getTestParameters(C2Component::DOMAIN_OTHER, C2Component::KIND_OTHER);

}



// Return all test parameters, a list of tuple of <instance, component> with matching domain and

// kind.

const std::vector<std::tuple<std::string, std::string>>& getTestParameters(

        C2Component::domain_t domain, C2Component::kind_t kind) {

    static std::vector<std::tuple<std::string, std::string>> parameters;

const std::vector<TestParameters>& getTestParameters(C2Component::domain_t domain,

                                                     C2Component::kind_t kind) {

    static std::vector<TestParameters> parameters;



    auto instances = android::Codec2Client::GetServiceNames();

    for (std::string instance : instances) {

media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h

+17 −4
Original line number Diff line number Diff line
@@ -40,7 +40,8 @@ using ::android::hardware::Void; 


using namespace ::std::chrono;



static std::vector<std::tuple<std::string, std::string>> kTestParameters;

using TestParameters = std::tuple<std::string, std::string>;

static std::vector<TestParameters> kTestParameters;



// Resource directory

extern std::string sResourceDir;
@@ -54,6 +55,18 @@ struct FrameInfo { 
    int64_t timestamp;

};



template <typename... T>

static inline std::string PrintInstanceTupleNameToString(

        const testing::TestParamInfo<std::tuple<T...>>& info) {

    std::stringstream ss;

    std::apply([&ss](auto&&... elems) { ((ss << elems << '_'), ...); }, info.param);

    ss << info.index;

    std::string param_string = ss.str();

    auto isNotAlphaNum = [](char c) { return !std::isalnum(c); };

    std::replace_if(param_string.begin(), param_string.end(), isNotAlphaNum, '_');

    return param_string;

}



/*

 * Handle Callback functions onWorkDone(), onTripped(),

 * onError(), onDeath(), onFramesRendered()
@@ -114,12 +127,12 @@ struct CodecListener : public android::Codec2Client::Listener { 
void parseArgs(int argc, char** argv);



// Return all test parameters, a list of tuple of <instance, component>.

const std::vector<std::tuple<std::string, std::string>>& getTestParameters();

const std::vector<TestParameters>& getTestParameters();



// Return all test parameters, a list of tuple of <instance, component> with matching domain and

// kind.

const std::vector<std::tuple<std::string, std::string>>& getTestParameters(

        C2Component::domain_t domain, C2Component::kind_t kind);

const std::vector<TestParameters>& getTestParameters(C2Component::domain_t domain,

                                                     C2Component::kind_t kind);



/*

 * common functions declarations

media/codec2/hidl/1.0/vts/functional/component/VtsHalMediaC2V1_0TargetComponentTest.cpp

+18 −26
Original line number Diff line number Diff line
@@ -53,9 +53,8 @@ 
    }



namespace {



static std::vector<std::tuple<std::string, std::string, std::string, std::string>>

        kInputTestParameters;

using InputTestParameters = std::tuple<std::string, std::string, uint32_t, bool>;

static std::vector<InputTestParameters> kInputTestParameters;



// google.codec2 Component test setup

class Codec2ComponentHidlTestBase : public ::testing::Test {
@@ -120,9 +119,8 @@ class Codec2ComponentHidlTestBase : public ::testing::Test { 
    }

};



class Codec2ComponentHidlTest

    : public Codec2ComponentHidlTestBase,

      public ::testing::WithParamInterface<std::tuple<std::string, std::string>> {

class Codec2ComponentHidlTest : public Codec2ComponentHidlTestBase,

                                public ::testing::WithParamInterface<TestParameters> {

    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());
@@ -317,10 +315,8 @@ TEST_P(Codec2ComponentHidlTest, Timeout) { 
    ASSERT_EQ(err, C2_OK);

}



class Codec2ComponentInputTests

    : public Codec2ComponentHidlTestBase,

      public ::testing::WithParamInterface<

              std::tuple<std::string, std::string, std::string, std::string>> {

class Codec2ComponentInputTests : public Codec2ComponentHidlTestBase,

                                  public ::testing::WithParamInterface<InputTestParameters> {

    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());
@@ -330,8 +326,8 @@ class Codec2ComponentInputTests 
TEST_P(Codec2ComponentInputTests, InputBufferTest) {

    description("Tests for different inputs");



    uint32_t flags = std::stoul(std::get<2>(GetParam()));

    bool isNullBuffer = !std::get<3>(GetParam()).compare("true");

    uint32_t flags = std::get<2>(GetParam());

    bool isNullBuffer = std::get<3>(GetParam());

    if (isNullBuffer)

        ALOGD("Testing for null input buffer with flag : %u", flags);

    else
@@ -350,11 +346,10 @@ TEST_P(Codec2ComponentInputTests, InputBufferTest) { 
}



INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2ComponentHidlTest, testing::ValuesIn(kTestParameters),

                         android::hardware::PrintInstanceTupleNameToString<>);

                         PrintInstanceTupleNameToString<>);



INSTANTIATE_TEST_CASE_P(NonStdInputs, Codec2ComponentInputTests,

                        testing::ValuesIn(kInputTestParameters),

                        android::hardware::PrintInstanceTupleNameToString<>);

                        testing::ValuesIn(kInputTestParameters), PrintInstanceTupleNameToString<>);

}  // anonymous namespace



// TODO: Add test for Invalid work,
@@ -364,18 +359,15 @@ int main(int argc, char** argv) { 
    kTestParameters = getTestParameters();

    for (auto params : kTestParameters) {

        kInputTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "0", "true"));

        kInputTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params),

                                std::to_string(C2FrameData::FLAG_END_OF_STREAM), "true"));

        kInputTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), "0", "false"));

        kInputTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params),

                                std::to_string(C2FrameData::FLAG_CODEC_CONFIG), "false"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true));

        kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

                                                       C2FrameData::FLAG_END_OF_STREAM, true));

        kInputTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params),

                                std::to_string(C2FrameData::FLAG_END_OF_STREAM), "false"));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false));

        kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

                                                       C2FrameData::FLAG_CODEC_CONFIG, false));

        kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

                                                       C2FrameData::FLAG_END_OF_STREAM, false));

    }



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