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

Commit 0f15956f authored by Amy's avatar Amy
Browse files

Refactor Tuner VTS dvr and descrambler test implementation 

Note that we are not testing them right now
Test entry will be implemented or uncomment in next Tuner develop phase

Test: cuttlefish + vendor device
Bug: 135708935
Change-Id: Iea72bd54c85105f74133c67433bd51f8fd07f28d
(cherry picked from commit fc7cc15e)
parent c1353fce

tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp

+97 −144
Original line number Diff line number Diff line
@@ -154,7 +154,7 @@ const std::vector<uint8_t> goldenDataOutputBuffer{ 
};



// const uint16_t FMQ_SIZE_4K = 0x1000;

// const uint32_t FMQ_SIZE_1M = 0x100000;

const uint32_t FMQ_SIZE_1M = 0x100000;

const uint32_t FMQ_SIZE_16M = 0x1000000;

const uint8_t FRONTEND_EVENT_CALLBACK_WAIT_COUNT = 4;
@@ -698,9 +698,9 @@ void DvrCallback::stopRecordThread() { 
    mRecordThreadRunning = false;

    android::Mutex::Autolock autoLock(mRecordThreadLock);

}

/******************************** End DvrCallback **********************************/

/********************************** End DvrCallback ************************************/



/******************************** Start Test Implementation**********************************/

/***************************** Start Test Implementation ******************************/

class TunerHidlTest : public testing::TestWithParam<std::string> {

  public:

    virtual void SetUp() override {
@@ -734,7 +734,7 @@ class TunerHidlTest : public testing::TestWithParam<std::string> { 
    sp<FilterCallback> mFilterCallback;

    sp<DvrCallback> mDvrCallback;

    MQDesc mFilterMQDescriptor;

    MQDesc mPlaybackMQDescriptor;

    MQDesc mDvrMQDescriptor;

    MQDesc mRecordMQDescriptor;

    vector<uint32_t> mUsedFilterIds;

    hidl_vec<FrontendId> mFeIds;
@@ -759,6 +759,10 @@ class TunerHidlTest : public testing::TestWithParam<std::string> { 
    AssertionResult setDemuxFrontendDataSource(uint32_t frontendId);

    AssertionResult closeDemux();



    AssertionResult openDvrInDemux(DvrType type);

    AssertionResult configDvr(DvrSettings setting);

    AssertionResult getDvrMQDescriptor();



    AssertionResult openFilterInDemux(DemuxFilterType type);

    AssertionResult getNewlyOpenedFilterId(uint32_t& filterId);

    AssertionResult configFilter(DemuxFilterSettings setting, uint32_t filterId);
@@ -767,26 +771,20 @@ class TunerHidlTest : public testing::TestWithParam<std::string> { 
    AssertionResult stopFilter(uint32_t filterId);

    AssertionResult closeFilter(uint32_t filterId);



    AssertionResult broadcastDataFlowTest(vector<string> goldenOutputFiles);



    ::testing::AssertionResult getPlaybackMQDescriptor();

    ::testing::AssertionResult addPlaybackToDemux(PlaybackSettings setting);

    ::testing::AssertionResult getRecordMQDescriptor();

    ::testing::AssertionResult addRecordToDemux(RecordSettings setting);

    ::testing::AssertionResult createDescrambler();

    ::testing::AssertionResult closeDescrambler();

    AssertionResult createDescrambler();

    AssertionResult closeDescrambler();



    ::testing::AssertionResult playbackDataFlowTest(vector<FilterConfig> filterConf,

                                                    PlaybackConf playbackConf,

    AssertionResult playbackDataFlowTest(vector<FilterConfig> filterConf, PlaybackConf playbackConf,

                                         vector<string> goldenOutputFiles);

    ::testing::AssertionResult recordDataFlowTest(vector<FilterConfig> filterConf,

    AssertionResult recordDataFlowTest(vector<FilterConfig> filterConf,

                                       RecordSettings recordSetting,

                                       vector<string> goldenOutputFiles);

    AssertionResult broadcastDataFlowTest(vector<string> goldenOutputFiles);



    FilterEventType getFilterEventType(DemuxFilterType type);

};



/*============================Start Frontend APIs Tests Implementation============================*/

/*========================== Start Frontend APIs Tests Implementation ==========================*/

AssertionResult TunerHidlTest::getFrontendIds() {

    Result status;

    mService->getFrontendIds([&](Result result, const hidl_vec<FrontendId>& frontendIds) {
@@ -865,7 +863,7 @@ AssertionResult TunerHidlTest::closeFrontend() { 
    mFrontendCallback = nullptr;

    return AssertionResult(status == Result::SUCCESS);

}

/*============================End Frontend APIs Tests Implementation============================*/

/*=========================== End Frontend APIs Tests Implementation ===========================*/



/*============================ Start Demux APIs Tests Implementation ============================*/

AssertionResult TunerHidlTest::openDemux() {
@@ -914,7 +912,7 @@ AssertionResult TunerHidlTest::openFilterInDemux(DemuxFilterType type) { 
}

/*============================ End Demux APIs Tests Implementation ============================*/



/*============================Start Filter APIs Tests Implementation============================*/

/*=========================== Start Filter APIs Tests Implementation ===========================*/

AssertionResult TunerHidlTest::getNewlyOpenedFilterId(uint32_t& filterId) {

    Result status;

    EXPECT_TRUE(mDemux) << "Test with openDemux first.";
@@ -989,131 +987,79 @@ AssertionResult TunerHidlTest::closeFilter(uint32_t filterId) { 
    }

    return AssertionResult(status == Result::SUCCESS);

}

/*============================End Filter APIs Tests Implementation============================*/

/*=========================== End Filter APIs Tests Implementation ===========================*/



/*::testing::AssertionResult TunerHidlTest::createDescrambler() {

/*======================== Start Descrambler APIs Tests Implementation ========================*/

AssertionResult TunerHidlTest::createDescrambler() {

    Result status;



    EXPECT_TRUE(mDemux) << "Test with openDemux first.";

    mService->openDescrambler([&](Result result, const sp<IDescrambler>& descrambler) {

        mDescrambler = descrambler;

        status = result;

    });

    if (status != Result::SUCCESS) {

        return ::testing::AssertionFailure();

    }



    if (!mDemux && createDemux() == ::testing::AssertionFailure()) {

        return ::testing::AssertionFailure();

        return failure();

    }



    status = mDescrambler->setDemuxSource(mDemuxId);

    if (status != Result::SUCCESS) {

        return ::testing::AssertionFailure();

        return failure();

    }



    // Test if demux source can be set more than once.

    status = mDescrambler->setDemuxSource(mDemuxId);

    return ::testing::AssertionResult(status == Result::INVALID_STATE);

    return AssertionResult(status == Result::INVALID_STATE);

}



::testing::AssertionResult TunerHidlTest::closeDescrambler() {

AssertionResult TunerHidlTest::closeDescrambler() {

    Result status;

    if (!mDescrambler && createDescrambler() == ::testing::AssertionFailure()) {

        return ::testing::AssertionFailure();

    if (!mDescrambler && createDescrambler() == failure()) {

        return failure();

    }



    status = mDescrambler->close();

    mDescrambler = nullptr;

    return ::testing::AssertionResult(status == Result::SUCCESS);

    return AssertionResult(status == Result::SUCCESS);

}

/*========================= End Descrambler APIs Tests Implementation =========================*/



::testing::AssertionResult TunerHidlTest::addPlaybackToDemux(PlaybackSettings setting) {

/*============================ Start Dvr APIs Tests Implementation ============================*/

AssertionResult TunerHidlTest::openDvrInDemux(DvrType type) {

    Result status;



    if (!mDemux && createDemux() == ::testing::AssertionFailure()) {

        return ::testing::AssertionFailure();

    }

    EXPECT_TRUE(mDemux) << "Test with openDemux first.";



    // Create dvr callback

    mDvrCallback = new DvrCallback();



    // Add playback input to the local demux

    mDemux->openDvr(DvrType::PLAYBACK, FMQ_SIZE_1M, mDvrCallback,

                    [&](Result result, const sp<IDvr>& dvr) {

    mDemux->openDvr(type, FMQ_SIZE_1M, mDvrCallback, [&](Result result, const sp<IDvr>& dvr) {

        mDvr = dvr;

        status = result;

    });



    if (status != Result::SUCCESS) {

        return ::testing::AssertionFailure();

    return AssertionResult(status == Result::SUCCESS);

}



    DvrSettings dvrSetting;

    dvrSetting.playback(setting);

    status = mDvr->configure(dvrSetting);

AssertionResult TunerHidlTest::configDvr(DvrSettings setting) {

    Result status = mDvr->configure(setting);



    return ::testing::AssertionResult(status == Result::SUCCESS);

    return AssertionResult(status == Result::SUCCESS);

}



::testing::AssertionResult TunerHidlTest::getPlaybackMQDescriptor() {

AssertionResult TunerHidlTest::getDvrMQDescriptor() {

    Result status;



    if ((!mDemux && createDemux() == ::testing::AssertionFailure()) || !mDvr) {

        return ::testing::AssertionFailure();

    }

    EXPECT_TRUE(mDemux) << "Test with openDemux first.";

    EXPECT_TRUE(mDvr) << "Test with openDvr first.";



    mDvr->getQueueDesc([&](Result result, const MQDesc& dvrMQDesc) {

        mPlaybackMQDescriptor = dvrMQDesc;

        status = result;

    });



    return ::testing::AssertionResult(status == Result::SUCCESS);

}



::testing::AssertionResult TunerHidlTest::addRecordToDemux(RecordSettings setting) {

    Result status;



    if (!mDemux && createDemux() == ::testing::AssertionFailure()) {

        return ::testing::AssertionFailure();

    }



    // Create dvr callback

    mDvrCallback = new DvrCallback();



    // Add playback input to the local demux

    mDemux->openDvr(DvrType::RECORD, FMQ_SIZE_1M, mDvrCallback,

                    [&](Result result, const sp<IDvr>& dvr) {

                        mDvr = dvr;

        mDvrMQDescriptor = dvrMQDesc;

        status = result;

    });



    if (status != Result::SUCCESS) {

        return ::testing::AssertionFailure();

    }



    DvrSettings dvrSetting;

    dvrSetting.record(setting);

    status = mDvr->configure(dvrSetting);



    return ::testing::AssertionResult(status == Result::SUCCESS);

}



::testing::AssertionResult TunerHidlTest::getRecordMQDescriptor() {

    Result status;



    if ((!mDemux && createDemux() == ::testing::AssertionFailure()) || !mDvr) {

        return ::testing::AssertionFailure();

    return AssertionResult(status == Result::SUCCESS);

}

/*============================ End Dvr APIs Tests Implementation ============================*/



    mDvr->getQueueDesc([&](Result result, const MQDesc& dvrMQDesc) {

        mRecordMQDescriptor = dvrMQDesc;

        status = result;

    });



    return ::testing::AssertionResult(status == Result::SUCCESS);

}*/



/*============================Start Data Flow Tests Implementation============================*/

/*========================== Start Data Flow Tests Implementation ==========================*/

AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutputFiles*/) {

    EXPECT_TRUE(mFrontend) << "Test with openFilterInDemux first.";

    EXPECT_TRUE(mDemux) << "Test with openDemux first.";
@@ -1130,7 +1076,7 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 
/*

 * TODO: re-enable the tests after finalizing the test refactoring.

 */

/*::testing::AssertionResult TunerHidlTest::playbackDataFlowTest(

/*AssertionResult TunerHidlTest::playbackDataFlowTest(

        vector<FilterConf> filterConf, PlaybackConf playbackConf,

        vector<string> \/\*goldenOutputFiles\*\/) {

    Result status;
@@ -1138,10 +1084,10 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 
    // Filter Configuration Module

    for (int i = 0; i < filterConf.size(); i++) {

        if (addFilterToDemux(filterConf[i].type, filterConf[i].setting) ==

                    ::testing::AssertionFailure() ||

                    failure() ||

            // TODO use a map to save the FMQs/EvenFlags and pass to callback

            getFilterMQDescriptor() == ::testing::AssertionFailure()) {

            return ::testing::AssertionFailure();

            getFilterMQDescriptor() == failure()) {

            return failure();

        }

        filterIdsSize = mUsedFilterIds.size();

        mUsedFilterIds.resize(filterIdsSize + 1);
@@ -1152,25 +1098,25 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 
        // mDemuxCallback->updateGoldenOutputMap(goldenOutputFiles[i]);

        status = mFilter->start();

        if (status != Result::SUCCESS) {

            return ::testing::AssertionFailure();

            return failure();

        }

    }



    // Playback Input Module

    PlaybackSettings playbackSetting = playbackConf.setting;

    if (addPlaybackToDemux(playbackSetting) == ::testing::AssertionFailure() ||

        getPlaybackMQDescriptor() == ::testing::AssertionFailure()) {

        return ::testing::AssertionFailure();

    if (addPlaybackToDemux(playbackSetting) == failure() ||

        getPlaybackMQDescriptor() == failure()) {

        return failure();

    }

    for (int i = 0; i <= filterIdsSize; i++) {

        if (mDvr->attachFilter(mFilters[mUsedFilterIds[i]]) != Result::SUCCESS) {

            return ::testing::AssertionFailure();

            return failure();

        }

    }

    mDvrCallback->startPlaybackInputThread(playbackConf, mPlaybackMQDescriptor);

    status = mDvr->start();

    if (status != Result::SUCCESS) {

        return ::testing::AssertionFailure();

        return failure();

    }



    // Data Verify Module
@@ -1183,11 +1129,11 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 
    // Clean Up Module

    for (int i = 0; i <= filterIdsSize; i++) {

        if (mFilters[mUsedFilterIds[i]]->stop() != Result::SUCCESS) {

            return ::testing::AssertionFailure();

            return failure();

        }

    }

    if (mDvr->stop() != Result::SUCCESS) {

        return ::testing::AssertionFailure();

        return failure();

    }

    mUsedFilterIds.clear();

    mFilterCallbacks.clear();
@@ -1195,10 +1141,11 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 
    return closeDemux();

}



::testing::AssertionResult TunerHidlTest::recordDataFlowTest(vector<FilterConf> filterConf,

AssertionResult TunerHidlTest::recordDataFlowTest(vector<FilterConf> filterConf,

                                                  RecordSettings recordSetting,

                                                             vector<string>

\/\*goldenOutputFiles\*\/) { Result status; hidl_vec<FrontendId> feIds;

                                                  vector<string> goldenOutputFiles) {

    Result status;

    hidl_vec<FrontendId> feIds;



    mService->getFrontendIds([&](Result result, const hidl_vec<FrontendId>& frontendIds) {

        status = result;
@@ -1207,7 +1154,7 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 


    if (feIds.size() == 0) {

        ALOGW("[   WARN   ] Frontend isn't available");

        return ::testing::AssertionFailure();

        return failure();

    }



    FrontendDvbtSettings dvbt{
@@ -1220,10 +1167,10 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 
    // Filter Configuration Module

    for (int i = 0; i < filterConf.size(); i++) {

        if (addFilterToDemux(filterConf[i].type, filterConf[i].setting) ==

                    ::testing::AssertionFailure() ||

                    failure() ||

            // TODO use a map to save the FMQs/EvenFlags and pass to callback

            getFilterMQDescriptor() == ::testing::AssertionFailure()) {

            return ::testing::AssertionFailure();

            getFilterMQDescriptor() == failure()) {

            return failure();

        }

        filterIdsSize = mUsedFilterIds.size();

        mUsedFilterIds.resize(filterIdsSize + 1);
@@ -1232,24 +1179,24 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 
    }



    // Record Config Module

    if (addRecordToDemux(recordSetting) == ::testing::AssertionFailure() ||

        getRecordMQDescriptor() == ::testing::AssertionFailure()) {

        return ::testing::AssertionFailure();

    if (addRecordToDemux(recordSetting) == failure() ||

        getRecordMQDescriptor() == failure()) {

        return failure();

    }

    for (int i = 0; i <= filterIdsSize; i++) {

        if (mDvr->attachFilter(mFilters[mUsedFilterIds[i]]) != Result::SUCCESS) {

            return ::testing::AssertionFailure();

            return failure();

        }

    }



    mDvrCallback->startRecordOutputThread(recordSetting, mRecordMQDescriptor);

    status = mDvr->start();

    if (status != Result::SUCCESS) {

        return ::testing::AssertionFailure();

        return failure();

    }



    if (createDemuxWithFrontend(feIds[0], settings) != ::testing::AssertionSuccess()) {

        return ::testing::AssertionFailure();

    if (setDemuxFrontendDataSource(feIds[0]) != success()) {

        return failure();

    }



    // Data Verify Module
@@ -1258,20 +1205,20 @@ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector<string> /*goldenOutp 
    // Clean Up Module

    for (int i = 0; i <= filterIdsSize; i++) {

        if (mFilters[mUsedFilterIds[i]]->stop() != Result::SUCCESS) {

            return ::testing::AssertionFailure();

            return failure();

        }

    }

    if (mFrontend->stopTune() != Result::SUCCESS) {

        return ::testing::AssertionFailure();

        return failure();

    }

    mUsedFilterIds.clear();

    mFilterCallbacks.clear();

    mFilters.clear();

    return closeDemux();

}*/

/*============================End Data Flow Tests Implementation============================*/

/*========================= End Data Flow Tests Implementation =========================*/



/*============================Start Helper Functions============================*/

/*=============================== Start Helper Functions ===============================*/

FilterEventType TunerHidlTest::getFilterEventType(DemuxFilterType type) {

    FilterEventType eventType = FilterEventType::UNDEFINED;

    switch (type.mainType) {
@@ -1318,11 +1265,11 @@ FilterEventType TunerHidlTest::getFilterEventType(DemuxFilterType type) { 
    }

    return eventType;

}

/*============================End Helper Functions============================*/

/******************************** End Test Implementation**********************************/

/*============================== End Helper Functions ==============================*/

/***************************** End Test Implementation *****************************/



/******************************** Start Test Entry **********************************/

/*============================Start Frontend Tests============================*/

/*============================== Start Frontend Tests ==============================*/

TEST_P(TunerHidlTest, getFrontendIds) {

    description("Get Frontend ids and verify frontends exist");

    ASSERT_TRUE(getFrontendIds());
@@ -1380,7 +1327,7 @@ TEST_P(TunerHidlTest, AutoScanFrontend) { 
        break;

    }

}

/*============================End Frontend Tests============================*/

/*=============================== End Frontend Tests ===============================*/



/*============================ Start Demux/Filter Tests ============================*/

TEST_P(TunerHidlTest, OpenDemuxWithFrontendDataSource) {
@@ -1456,6 +1403,10 @@ TEST_P(TunerHidlTest, StartFilterInDemux) { 
}

/*============================ End Demux/Filter Tests ============================*/



/*============================ Start Descrambler Tests ============================*/

/*

 * TODO: re-enable the tests after finalizing the test refactoring.

 */

/*TEST_P(TunerHidlTest, CreateDescrambler) {

    description("Create Descrambler");

    ASSERT_TRUE(createDescrambler());
@@ -1465,8 +1416,9 @@ TEST_P(TunerHidlTest, CloseDescrambler) { 
    description("Close Descrambler");

    ASSERT_TRUE(closeDescrambler());

}*/

/*============================== End Descrambler Tests ==============================*/



/*============================Start Data Flow Tests============================*/

/*============================== Start Data Flow Tests ==============================*/

TEST_P(TunerHidlTest, BroadcastDataFlowWithAudioFilterTest) {

    description("Open Demux with a Frontend as its data source.");

    ASSERT_TRUE(getFrontendIds());
@@ -1583,6 +1535,7 @@ TEST_P(TunerHidlTest, RecordDataFlowWithTsRecordFilterTest) { 


    ASSERT_TRUE(recordDataFlowTest(filterConf, recordSetting, goldenOutputFiles));

}*/

/*============================== End Data Flow Tests ==============================*/

/******************************** End Test Entry **********************************/

}  // namespace