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

Commit 5a9a3f93 authored by Manisha Jajoo's avatar Manisha Jajoo Committed by Pawin Vongmasa
Browse files

VTS: move output validation after flush to a method 

Test: atest VtsHalMediaC2V1_0TargetAudioDecTest
Test: atest VtsHalMediaC2V1_0TargetAudioEncTest
Test: atest VtsHalMediaC2V1_0TargetVideoDecTest
Test: atest VtsHalMediaC2V1_0TargetVideoEncTest

Bug: 151703904
Change-Id: Ie3b71978a082cfe47568fc34b50e8b8f7748a548
parent 2a668731

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

+25 −48
Original line number Diff line number Diff line
@@ -563,7 +563,7 @@ TEST_P(Codec2AudioDecDecodeTest, DecodeTest) { 
    }

    // blocking call to ensures application to Wait till all the inputs are

    // consumed

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);

    eleStream.close();

    if (mFramesReceived != infoSize) {

        ALOGE("Input buffer count and Output buffer count mismatch");
@@ -624,7 +624,7 @@ TEST_P(Codec2AudioDecHidlTest, ThumbnailTest) { 
    ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                          mFlushedIndices, mLinearPool, eleStream, &Info, 0,

                                          i + 1));

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);

    eleStream.close();

    EXPECT_GE(mFramesReceived, 1U);

    ASSERT_EQ(mEos, true);
@@ -676,7 +676,6 @@ TEST_P(Codec2AudioDecHidlTest, EOSTest) { 
TEST_P(Codec2AudioDecHidlTest, FlushTest) {

    description("Tests Flush calls");

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

    typedef std::unique_lock<std::mutex> ULock;

    char mURL[512], info[512];

    android::Vector<FrameInfo> Info;
@@ -699,40 +698,32 @@ TEST_P(Codec2AudioDecHidlTest, FlushTest) { 
        return;

    }

    ASSERT_EQ(mComponent->start(), C2_OK);

    // flush

    std::list<std::unique_ptr<C2Work>> flushedWork;

    c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);



    ALOGV("mURL : %s", mURL);

    std::ifstream eleStream;

    eleStream.open(mURL, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

    // Decode 128 frames and flush. here 128 is chosen to ensure there is a key

    // frame after this so that the below section can be covered for all

    // components

    uint32_t numFramesFlushed = 128;

    // Decode 30 frames and flush.

    uint32_t numFramesFlushed = FLUSH_INTERVAL;

    ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                          mFlushedIndices, mLinearPool, eleStream, &Info, 0,

                                          numFramesFlushed, false));

    // flush

    std::list<std::unique_ptr<C2Work>> flushedWork;

    c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                                                   (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));

    uint64_t frameIndex;

    {

        // Update mFlushedIndices based on the index received from flush()

        ULock l(mQueueLock);

        for (std::unique_ptr<C2Work>& work : flushedWork) {

            ASSERT_NE(work, nullptr);

            frameIndex = work->input.ordinal.frameIndex.peeku();

            std::list<uint64_t>::iterator frameIndexIt =

                    std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);

            if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {

                mFlushedIndices.erase(frameIndexIt);

                work->input.buffers.clear();

                work->worklets.clear();

                mWorkQueue.push_back(std::move(work));

            }

        }

    }

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                           (size_t)MAX_INPUT_BUFFERS - flushedWork.size());

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);



    // Seek to next key frame and start decoding till the end

    mFlushedIndices.clear();

    int index = numFramesFlushed;
@@ -756,27 +747,13 @@ TEST_P(Codec2AudioDecHidlTest, FlushTest) { 
    eleStream.close();

    err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                                                   (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));

    {

        // Update mFlushedIndices based on the index received from flush()

        ULock l(mQueueLock);

        for (std::unique_ptr<C2Work>& work : flushedWork) {

            ASSERT_NE(work, nullptr);

            frameIndex = work->input.ordinal.frameIndex.peeku();

            std::list<uint64_t>::iterator frameIndexIt =

                    std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);

            if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {

                mFlushedIndices.erase(frameIndexIt);

                work->input.buffers.clear();

                work->worklets.clear();

                mWorkQueue.push_back(std::move(work));

            }

        }

    }

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                           (size_t)MAX_INPUT_BUFFERS - flushedWork.size());

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);

    // TODO: (b/154671521)

    // Add assert for mWorkResult

    ASSERT_EQ(mFlushedIndices.empty(), true);

    ASSERT_EQ(mComponent->stop(), C2_OK);

}
@@ -841,7 +818,7 @@ TEST_P(Codec2AudioDecHidlTest, DecodeTestEmptyBuffersInserted) { 
    // consumed

    if (!mEos) {

        ALOGV("Waiting for input consumption");

        ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));

        waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);

    }



    eleStream.close();

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

+20 −44
Original line number Diff line number Diff line
@@ -437,7 +437,7 @@ TEST_P(Codec2AudioEncEncodeTest, EncodeTest) { 


    // If EOS is not sent, sending empty input with EOS flag

    if (!signalEOS) {

        ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1));

        waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1);

        ASSERT_NO_FATAL_FAILURE(testInputBuffer(mComponent, mQueueLock, mWorkQueue,

                                                C2FrameData::FLAG_END_OF_STREAM, false));

        numFrames += 1;
@@ -445,7 +445,7 @@ TEST_P(Codec2AudioEncEncodeTest, EncodeTest) { 


    // blocking call to ensures application to Wait till all the inputs are

    // consumed

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);

    eleStream.close();

    if (mFramesReceived != numFrames) {

        ALOGE("Input buffer count and Output buffer count mismatch");
@@ -508,7 +508,6 @@ TEST_P(Codec2AudioEncHidlTest, FlushTest) { 
    description("Test Request for flush");

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



    typedef std::unique_lock<std::mutex> ULock;

    char mURL[512];

    strcpy(mURL, sResourceDir.c_str());

    GetURLForComponent(mCompName, mURL);
@@ -535,33 +534,24 @@ TEST_P(Codec2AudioEncHidlTest, FlushTest) { 
    uint32_t numFrames = 128;

    eleStream.open(mURL, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

    // flush

    std::list<std::unique_ptr<C2Work>> flushedWork;

    c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);

    ALOGV("mURL : %s", mURL);

    ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                          mFlushedIndices, mLinearPool, eleStream, numFramesFlushed,

                                          samplesPerFrame, nChannels, nSampleRate));

    std::list<std::unique_ptr<C2Work>> flushedWork;

    c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                                                   (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));

    uint64_t frameIndex;

    {

        // Update mFlushedIndices based on the index received from flush()

        ULock l(mQueueLock);

        for (std::unique_ptr<C2Work>& work : flushedWork) {

            ASSERT_NE(work, nullptr);

            frameIndex = work->input.ordinal.frameIndex.peeku();

            std::list<uint64_t>::iterator frameIndexIt =

                    std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);

            if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {

                mFlushedIndices.erase(frameIndexIt);

                work->input.buffers.clear();

                work->worklets.clear();

                mWorkQueue.push_back(std::move(work));

            }

        }

    }

    mFlushedIndices.clear();

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                           (size_t)MAX_INPUT_BUFFERS - flushedWork.size());

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);

    ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                          mFlushedIndices, mLinearPool, eleStream,

                                          numFrames - numFramesFlushed, samplesPerFrame, nChannels,
@@ -569,27 +559,13 @@ TEST_P(Codec2AudioEncHidlTest, FlushTest) { 
    eleStream.close();

    err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                                                   (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));

    {

        // Update mFlushedIndices based on the index received from flush()

        ULock l(mQueueLock);

        for (std::unique_ptr<C2Work>& work : flushedWork) {

            ASSERT_NE(work, nullptr);

            frameIndex = work->input.ordinal.frameIndex.peeku();

            std::list<uint64_t>::iterator frameIndexIt =

                    std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);

            if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {

                mFlushedIndices.erase(frameIndexIt);

                work->input.buffers.clear();

                work->worklets.clear();

                mWorkQueue.push_back(std::move(work));

            }

        }

    }

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                           (size_t)MAX_INPUT_BUFFERS - flushedWork.size());

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);

    // TODO: (b/154671521)

    // Add assert for mWorkResult

    ASSERT_EQ(mFlushedIndices.empty(), true);

    ASSERT_EQ(mComponent->stop(), C2_OK);

}

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

+23 −0
Original line number Diff line number Diff line
@@ -191,3 +191,26 @@ int32_t populateInfoVector(std::string info, android::Vector<FrameInfo>* frameIn 
    eleInfo.close();

    return numCsds;

}



void verifyFlushOutput(std::list<std::unique_ptr<C2Work>>& flushedWork,

                       std::list<std::unique_ptr<C2Work>>& workQueue,

                       std::list<uint64_t>& flushedIndices, std::mutex& queueLock) {

    // Update mFlushedIndices based on the index received from flush()

    typedef std::unique_lock<std::mutex> ULock;

    uint64_t frameIndex;

    ULock l(queueLock);

    for (std::unique_ptr<C2Work>& work : flushedWork) {

        ASSERT_NE(work, nullptr);

        frameIndex = work->input.ordinal.frameIndex.peeku();

        std::list<uint64_t>::iterator frameIndexIt =

                std::find(flushedIndices.begin(), flushedIndices.end(), frameIndex);

        if (!flushedIndices.empty() && (frameIndexIt != flushedIndices.end())) {

            flushedIndices.erase(frameIndexIt);

            work->input.buffers.clear();

            work->worklets.clear();

            workQueue.push_back(std::move(work));

        }

    }

    ASSERT_EQ(flushedIndices.empty(), true);

    flushedWork.clear();

}

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

+4 −0
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#define MAX_RETRY 20

#define TIME_OUT 400ms

#define MAX_INPUT_BUFFERS 8

#define FLUSH_INTERVAL 30



using ::android::hardware::hidl_string;

using ::android::hardware::hidl_vec;
@@ -134,4 +135,7 @@ int64_t getNowUs(); 
int32_t populateInfoVector(std::string info, android::Vector<FrameInfo>* frameInfo,

                           bool timestampDevTest, std::list<uint64_t>* timestampUslist);



void verifyFlushOutput(std::list<std::unique_ptr<C2Work>>& flushedWork,

                       std::list<std::unique_ptr<C2Work>>& workQueue,

                       std::list<uint64_t>& flushedIndices, std::mutex& queueLock);

#endif  // MEDIA_C2_HIDL_TEST_COMMON_H

media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp

+29 −49
Original line number Diff line number Diff line
@@ -165,7 +165,7 @@ class Codec2VideoDecHidlTestBase : public ::testing::Test { 
                        }

                    }

                }

                bool mCsd;

                bool mCsd = false;

                workDone(mComponent, work, mFlushedIndices, mQueueLock, mQueueCondition, mWorkQueue,

                         mEos, mCsd, mFramesReceived);

                (void)mCsd;
@@ -490,7 +490,7 @@ TEST_P(Codec2VideoDecDecodeTest, DecodeTest) { 
    // If EOS is not sent, sending empty input with EOS flag

    size_t infoSize = Info.size();

    if (!signalEOS) {

        ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1));

        waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1);

        ASSERT_NO_FATAL_FAILURE(testInputBuffer(mComponent, mQueueLock, mWorkQueue,

                                                C2FrameData::FLAG_END_OF_STREAM, false));

        infoSize += 1;
@@ -499,7 +499,7 @@ TEST_P(Codec2VideoDecDecodeTest, DecodeTest) { 
    // consumed

    if (!mEos) {

        ALOGV("Waiting for input consumption");

        ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));

        waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);

    }



    eleStream.close();
@@ -609,7 +609,7 @@ TEST_P(Codec2VideoDecHidlTest, AdaptiveDecodeTest) { 
    // blocking call to ensures application to Wait till all the inputs are

    // consumed

    ALOGV("Waiting for input consumption");

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);



    if (mFramesReceived != ((Info.size()) + 1)) {

        ALOGE("Input buffer count and Output buffer count mismatch");
@@ -656,7 +656,7 @@ TEST_P(Codec2VideoDecHidlTest, ThumbnailTest) { 
        ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                              mFlushedIndices, mLinearPool, eleStream, &Info, 0,

                                              j + 1));

        ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));

        waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);

        eleStream.close();

        EXPECT_GE(mFramesReceived, 1U);

        ASSERT_EQ(mEos, true);
@@ -710,7 +710,7 @@ TEST_P(Codec2VideoDecHidlTest, EOSTest) { 
TEST_P(Codec2VideoDecHidlTest, FlushTest) {

    description("Tests Flush calls");

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

    typedef std::unique_lock<std::mutex> ULock;



    ASSERT_EQ(mComponent->start(), C2_OK);



    char mURL[512], info[512];
@@ -726,40 +726,34 @@ TEST_P(Codec2VideoDecHidlTest, FlushTest) { 
    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;



    ALOGV("mURL : %s", mURL);



    // flush

    std::list<std::unique_ptr<C2Work>> flushedWork;

    c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);



    std::ifstream eleStream;

    eleStream.open(mURL, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

    // Decode 128 frames and flush. here 128 is chosen to ensure there is a key

    // Decode 30 frames and flush. here 30 is chosen to ensure there is a key

    // frame after this so that the below section can be covered for all

    // components

    uint32_t numFramesFlushed = 128;

    uint32_t numFramesFlushed = FLUSH_INTERVAL;

    ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                          mFlushedIndices, mLinearPool, eleStream, &Info, 0,

                                          numFramesFlushed, false));

    // flush

    std::list<std::unique_ptr<C2Work>> flushedWork;

    c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                                                   (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));



    {

        // Update mFlushedIndices based on the index received from flush()

        ULock l(mQueueLock);

        for (std::unique_ptr<C2Work>& work : flushedWork) {

            ASSERT_NE(work, nullptr);

            auto frameIndexIt = std::find(mFlushedIndices.begin(), mFlushedIndices.end(),

                                          work->input.ordinal.frameIndex.peeku());

            if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {

                mFlushedIndices.erase(frameIndexIt);

                work->input.buffers.clear();

                work->worklets.clear();

                mWorkQueue.push_back(std::move(work));

            }

        }

    }

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                           (size_t)MAX_INPUT_BUFFERS - flushedWork.size());

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);

    // Seek to next key frame and start decoding till the end

    mFlushedIndices.clear();

    int index = numFramesFlushed;

    bool keyFrame = false;

    uint32_t flags = 0;
@@ -781,27 +775,13 @@ TEST_P(Codec2VideoDecHidlTest, FlushTest) { 
    eleStream.close();

    err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                                                   (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));

    {

        // Update mFlushedIndices based on the index received from flush()

        ULock l(mQueueLock);

        for (std::unique_ptr<C2Work>& work : flushedWork) {

            ASSERT_NE(work, nullptr);

            uint64_t frameIndex = work->input.ordinal.frameIndex.peeku();

            std::list<uint64_t>::iterator frameIndexIt =

                    std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);

            if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {

                mFlushedIndices.erase(frameIndexIt);

                work->input.buffers.clear();

                work->worklets.clear();

                mWorkQueue.push_back(std::move(work));

            }

        }

    }

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,

                           (size_t)MAX_INPUT_BUFFERS - flushedWork.size());

    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);

    // TODO: (b/154671521)

    // Add assert for mWorkResult

    ASSERT_EQ(mFlushedIndices.empty(), true);

    ASSERT_EQ(mComponent->stop(), C2_OK);

}
@@ -856,7 +836,7 @@ TEST_P(Codec2VideoDecHidlTest, DecodeTestEmptyBuffersInserted) { 
    // consumed

    if (!mEos) {

        ALOGV("Waiting for input consumption");

        ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));

        waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);

    }



    eleStream.close();