tv/tuner/aidl/vts/functional/VtsHalTvTunerTargetTest.cpp

/*
 * Copyright 2021 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 "VtsHalTvTunerTargetTest.h"

#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>

namespace {

AssertionResult TunerBroadcastAidlTest::filterDataOutputTest() {
    return filterDataOutputTestBase(mFilterTests);
}

AssertionResult TunerPlaybackAidlTest::filterDataOutputTest() {
    return filterDataOutputTestBase(mFilterTests);
}

AssertionResult TunerDescramblerAidlTest::filterDataOutputTest() {
    return filterDataOutputTestBase(mFilterTests);
}

void TunerFilterAidlTest::configSingleFilterInDemuxTest(FilterConfig filterConf,
                                                        FrontendConfig frontendConf) {
    int32_t feId;
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    int64_t filterId;

    mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
    ASSERT_TRUE(feId != INVALID_ID);
    ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
    ASSERT_TRUE(mFrontendTests.setFrontendCallback());
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
    mFrontendTests.setDemux(demux);
    mFilterTests.setDemux(demux);
    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
    ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
    if (filterConf.type.mainType == DemuxFilterMainType::IP) {
        ASSERT_TRUE(mFilterTests.configIpFilterCid(filterConf.ipCid, filterId));
    }
    if (filterConf.monitorEventTypes > 0) {
        ASSERT_TRUE(mFilterTests.configureMonitorEvent(filterId, filterConf.monitorEventTypes));
    }
    ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
    ASSERT_TRUE(mFilterTests.startFilter(filterId));
    ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
    if (filterConf.monitorEventTypes > 0) {
        ASSERT_TRUE(mFilterTests.testMonitorEvent(filterId, filterConf.monitorEventTypes));
    }
    ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
    ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    ASSERT_TRUE(mFilterTests.closeFilter(filterId));
    ASSERT_TRUE(mDemuxTests.closeDemux());
    ASSERT_TRUE(mFrontendTests.closeFrontend());
}

void TunerFilterAidlTest::reconfigSingleFilterInDemuxTest(FilterConfig filterConf,
                                                          FilterConfig filterReconf,
                                                          FrontendConfig frontendConf) {
    int32_t feId;
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    int64_t filterId;

    mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
    ASSERT_TRUE(feId != INVALID_ID);
    ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
    ASSERT_TRUE(mFrontendTests.setFrontendCallback());
    if (frontendConf.isSoftwareFe) {
        mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
    }
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
    mFrontendTests.setDemux(demux);
    mFilterTests.setDemux(demux);
    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
    ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
    ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
    ASSERT_TRUE(mFilterTests.startFilter(filterId));
    ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    ASSERT_TRUE(mFilterTests.configFilter(filterReconf.settings, filterId));
    ASSERT_TRUE(mFilterTests.startFilter(filterId));
    ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
    if (!isPassthroughFilter(filterReconf)) {
        ASSERT_TRUE(mFilterTests.startIdTest(filterId));
    }
    ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
    ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    ASSERT_TRUE(mFilterTests.closeFilter(filterId));
    ASSERT_TRUE(mDemuxTests.closeDemux());
    ASSERT_TRUE(mFrontendTests.closeFrontend());
}

void TunerFilterAidlTest::testTimeFilter(TimeFilterConfig filterConf) {
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    DemuxCapabilities caps;

    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    ASSERT_TRUE(mDemuxTests.getDemuxCaps(caps));
    ASSERT_TRUE(caps.bTimeFilter);
    mFilterTests.setDemux(demux);
    ASSERT_TRUE(mFilterTests.openTimeFilterInDemux());
    ASSERT_TRUE(mFilterTests.setTimeStamp(filterConf.timeStamp));
    ASSERT_TRUE(mFilterTests.getTimeStamp());
    ASSERT_TRUE(mFilterTests.clearTimeStamp());
    ASSERT_TRUE(mFilterTests.closeTimeFilter());
    ASSERT_TRUE(mDemuxTests.closeDemux());
}

void TunerBroadcastAidlTest::broadcastSingleFilterTest(FilterConfig filterConf,
                                                       FrontendConfig frontendConf) {
    int32_t feId;
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    int64_t filterId;

    mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
    ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
    ASSERT_TRUE(mFrontendTests.setFrontendCallback());
    if (mLnbId != INVALID_LNB_ID) {
        ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
    }
    if (frontendConf.isSoftwareFe) {
        mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
    }
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
    mFrontendTests.setDemux(demux);
    mFilterTests.setDemux(demux);
    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
    ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
    ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
    ASSERT_TRUE(mFilterTests.startFilter(filterId));
    // tune test
    ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
    if (!isPassthroughFilter(filterConf)) {
        ASSERT_TRUE(filterDataOutputTest());
    }
    ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
    ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    ASSERT_TRUE(mFilterTests.closeFilter(filterId));
    ASSERT_TRUE(mDemuxTests.closeDemux());
    ASSERT_TRUE(mFrontendTests.closeFrontend());
}

void TunerBroadcastAidlTest::broadcastSingleFilterTestWithLnb(FilterConfig filterConf,
                                                              FrontendConfig frontendConf,
                                                              LnbConfig lnbConf) {
    if (lnbConf.name.compare(emptyHardwareId) == 0) {
        vector<int32_t> ids;
        ASSERT_TRUE(mLnbTests.getLnbIds(ids));
        ASSERT_TRUE(ids.size() > 0);
        ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
        mLnbId = ids[0];
    } else {
        ASSERT_TRUE(mLnbTests.openLnbByName(lnbConf.name, mLnbId));
    }
    ASSERT_TRUE(mLnbTests.setLnbCallback());
    ASSERT_TRUE(mLnbTests.setVoltage(lnbConf.voltage));
    ASSERT_TRUE(mLnbTests.setTone(lnbConf.tone));
    ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConf.position));
    if (!frontendConf.isSoftwareFe) {
        broadcastSingleFilterTest(filterConf, frontendConf);
    }
    ASSERT_TRUE(mLnbTests.closeLnb());
    mLnbId = INVALID_LNB_ID;
}

void TunerBroadcastAidlTest::mediaFilterUsingSharedMemoryTest(FilterConfig filterConf,
                                                              FrontendConfig frontendConf) {
    int32_t feId;
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    int64_t filterId;

    mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
    ASSERT_TRUE(feId != INVALID_ID);
    ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
    ASSERT_TRUE(mFrontendTests.setFrontendCallback());
    if (frontendConf.isSoftwareFe) {
        mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
    }
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
    mFrontendTests.setDemux(demux);
    mFilterTests.setDemux(demux);
    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
    ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
    ASSERT_TRUE(mFilterTests.getSharedAvMemoryHandle(filterId));
    ASSERT_TRUE(mFilterTests.configAvFilterStreamType(filterConf.streamType, filterId));
    ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
    ASSERT_TRUE(mFilterTests.startFilter(filterId));
    // tune test
    ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
    ASSERT_TRUE(filterDataOutputTest());
    ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
    ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    ASSERT_TRUE(mFilterTests.releaseShareAvHandle(filterId));
    ASSERT_TRUE(mFilterTests.closeFilter(filterId));
    ASSERT_TRUE(mDemuxTests.closeDemux());
    ASSERT_TRUE(mFrontendTests.closeFrontend());
}

void TunerPlaybackAidlTest::playbackSingleFilterTest(FilterConfig filterConf, DvrConfig dvrConf) {
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    int64_t filterId;

    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    mFilterTests.setDemux(demux);
    mDvrTests.setDemux(demux);
    ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
    ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrConf.settings));
    ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
    ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
    ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
    mDvrTests.startPlaybackInputThread(dvrConf.playbackInputFile,
                                       dvrConf.settings.get<DvrSettings::Tag::playback>());
    ASSERT_TRUE(mDvrTests.startDvrPlayback());
    ASSERT_TRUE(mFilterTests.startFilter(filterId));
    ASSERT_TRUE(filterDataOutputTest());
    mDvrTests.stopPlaybackThread();
    ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    ASSERT_TRUE(mDvrTests.stopDvrPlayback());
    ASSERT_TRUE(mFilterTests.closeFilter(filterId));
    mDvrTests.closeDvrPlayback();
    ASSERT_TRUE(mDemuxTests.closeDemux());
}

void TunerPlaybackAidlTest::setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,
                                                           DvrConfig dvrConf) {
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;

    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    mDvrTests.setDemux(demux);
    ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
    ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrConf.settings));
    ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());

    ASSERT_TRUE(mDvrTests.setPlaybackStatusCheckIntervalHint(statusCheckIntervalHint));

    mDvrTests.startPlaybackInputThread(dvrConf.playbackInputFile,
                                       dvrConf.settings.get<DvrSettings::Tag::playback>());
    ASSERT_TRUE(mDvrTests.startDvrPlayback());
    mDvrTests.stopPlaybackThread();
    ASSERT_TRUE(mDvrTests.stopDvrPlayback());
    mDvrTests.closeDvrPlayback();
    ASSERT_TRUE(mDemuxTests.closeDemux());
}

void TunerRecordAidlTest::recordSingleFilterTestWithLnb(FilterConfig filterConf,
                                                        FrontendConfig frontendConf,
                                                        DvrConfig dvrConf, LnbConfig lnbConf) {
    if (lnbConf.name.compare(emptyHardwareId) == 0) {
        vector<int32_t> ids;
        ASSERT_TRUE(mLnbTests.getLnbIds(ids));
        ASSERT_TRUE(ids.size() > 0);
        ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
        mLnbId = ids[0];
    } else {
        ASSERT_TRUE(mLnbTests.openLnbByName(lnbConf.name, mLnbId));
    }
    ASSERT_TRUE(mLnbTests.setLnbCallback());
    ASSERT_TRUE(mLnbTests.setVoltage(lnbConf.voltage));
    ASSERT_TRUE(mLnbTests.setTone(lnbConf.tone));
    ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConf.position));
    for (auto msgName : lnbRecord.diseqcMsgs) {
        ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgMap[msgName]));
    }
    if (!frontendConf.isSoftwareFe) {
        recordSingleFilterTest(filterConf, frontendConf, dvrConf, Dataflow_Context::LNBRECORD);
    }
    ASSERT_TRUE(mLnbTests.closeLnb());
    mLnbId = INVALID_LNB_ID;
}

void TunerRecordAidlTest::attachSingleFilterToRecordDvrTest(FilterConfig filterConf,
                                                            FrontendConfig frontendConf,
                                                            DvrConfig dvrConf) {
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    mDvrTests.setDemux(demux);

    DvrConfig dvrSourceConfig;
    if (record.hasFrontendConnection) {
        int32_t feId;
        mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
        ASSERT_TRUE(feId != INVALID_ID);
        ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
        ASSERT_TRUE(mFrontendTests.setFrontendCallback());
        ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
    } else {
        dvrSourceConfig = dvrMap[record.dvrSourceId];
        ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
        ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
        ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
    }

    int64_t filterId;
    std::shared_ptr<IFilter> filter;
    mFilterTests.setDemux(demux);

    ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
    ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
    ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());

    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
    ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
    ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
    filter = mFilterTests.getFilterById(filterId);
    ASSERT_TRUE(filter != nullptr);
    ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
    ASSERT_TRUE(mDvrTests.startDvrRecord());
    ASSERT_TRUE(mFilterTests.startFilter(filterId));
    ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    ASSERT_TRUE(mDvrTests.stopDvrRecord());
    ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
    ASSERT_TRUE(mFilterTests.closeFilter(filterId));
    mDvrTests.closeDvrRecord();
    ASSERT_TRUE(mDemuxTests.closeDemux());

    if (record.hasFrontendConnection) {
        ASSERT_TRUE(mFrontendTests.closeFrontend());
    }
}

void TunerRecordAidlTest::recordSingleFilterTest(FilterConfig filterConf,
                                                 FrontendConfig frontendConf, DvrConfig dvrConf,
                                                 Dataflow_Context context) {
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    mDvrTests.setDemux(demux);

    DvrConfig dvrSourceConfig;
    if (context == Dataflow_Context::RECORD) {
        if (record.hasFrontendConnection) {
            int32_t feId;
            mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
            ASSERT_TRUE(feId != INVALID_ID);
            ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
            ASSERT_TRUE(mFrontendTests.setFrontendCallback());
            if (frontendConf.isSoftwareFe) {
                mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[record.dvrSoftwareFeId]);
            }
            ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
            mFrontendTests.setDvrTests(&mDvrTests);
        } else {
            dvrSourceConfig = dvrMap[record.dvrSourceId];
            ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
            ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
            ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
        }
    } else if (context == Dataflow_Context::LNBRECORD) {
        // If function arrives here, frontend should not be software, so no need to configure a dvr
        // source or dvr fe connection that might be used for recording without an Lnb
        int32_t feId;
        mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
        ASSERT_TRUE(feId != INVALID_ID);
        ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
        ASSERT_TRUE(mFrontendTests.setFrontendCallback());
        if (mLnbId != INVALID_LNB_ID) {
            ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
        } else {
            FAIL();
        }
        ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
        mFrontendTests.setDvrTests(&mDvrTests);
    }

    int64_t filterId;
    std::shared_ptr<IFilter> filter;
    mFilterTests.setDemux(demux);
    ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
    ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
    ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
    ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
    ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
    filter = mFilterTests.getFilterById(filterId);
    ASSERT_TRUE(filter != nullptr);
    mDvrTests.startRecordOutputThread(dvrConf.settings.get<DvrSettings::Tag::record>());
    ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
    ASSERT_TRUE(mDvrTests.startDvrRecord());
    ASSERT_TRUE(mFilterTests.startFilter(filterId));

    if (context == Dataflow_Context::RECORD) {
        if (record.hasFrontendConnection) {
            ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
        } else {
            // Start DVR Source
            mDvrTests.startPlaybackInputThread(
                    dvrSourceConfig.playbackInputFile,
                    dvrSourceConfig.settings.get<DvrSettings::Tag::playback>());
            ASSERT_TRUE(mDvrTests.startDvrPlayback());
        }
    } else if (context == Dataflow_Context::LNBRECORD) {
        ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
    }
    mDvrTests.testRecordOutput();
    mDvrTests.stopRecordThread();

    if (context == Dataflow_Context::RECORD) {
        if (record.hasFrontendConnection) {
            ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
        } else {
            mDvrTests.stopPlaybackThread();
            ASSERT_TRUE(mDvrTests.stopDvrPlayback());
        }
    } else if (context == Dataflow_Context::LNBRECORD) {
        ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
    }

    ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    ASSERT_TRUE(mDvrTests.stopDvrRecord());
    ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
    ASSERT_TRUE(mFilterTests.closeFilter(filterId));
    mDvrTests.closeDvrRecord();

    if (context == Dataflow_Context::RECORD) {
        if (record.hasFrontendConnection) {
            ASSERT_TRUE(mFrontendTests.closeFrontend());
        } else {
            mDvrTests.closeDvrPlayback();
        }
    } else if (context == Dataflow_Context::LNBRECORD) {
        ASSERT_TRUE(mFrontendTests.closeFrontend());
    }

    ASSERT_TRUE(mDemuxTests.closeDemux());
}

void TunerRecordAidlTest::setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,
                                                         FrontendConfig frontendConf,
                                                         DvrConfig dvrConf) {
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    mDvrTests.setDemux(demux);

    DvrConfig dvrSourceConfig;
    if (record.hasFrontendConnection) {
        int32_t feId;
        mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
        ASSERT_TRUE(feId != INVALID_ID);
        ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
        ASSERT_TRUE(mFrontendTests.setFrontendCallback());
        ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
    } else {
        dvrSourceConfig = dvrMap[record.dvrSourceId];
        ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
        ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
        ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
    }

    ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
    ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
    ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());

    ASSERT_TRUE(mDvrTests.setRecordStatusCheckIntervalHint(statusCheckIntervalHint));

    ASSERT_TRUE(mDvrTests.startDvrRecord());
    ASSERT_TRUE(mDvrTests.stopDvrRecord());
    mDvrTests.closeDvrRecord();
    ASSERT_TRUE(mDemuxTests.closeDemux());

    if (record.hasFrontendConnection) {
        ASSERT_TRUE(mFrontendTests.closeFrontend());
    }
}

void TunerDescramblerAidlTest::scrambledBroadcastTest(set<struct FilterConfig> mediaFilterConfs,
                                                      FrontendConfig frontendConf,
                                                      DescramblerConfig descConfig,
                                                      Dataflow_Context context) {
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));

    DvrConfig dvrSourceConfig;
    if (context == Dataflow_Context::DESCRAMBLING) {
        if (descrambling.hasFrontendConnection) {
            int32_t feId;
            mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
            ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
            ASSERT_TRUE(mFrontendTests.setFrontendCallback());
            if (frontendConf.isSoftwareFe) {
                mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[descrambling.dvrSoftwareFeId]);
            }
            ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
            mFrontendTests.setDemux(demux);
        } else {
            dvrSourceConfig = dvrMap[descrambling.dvrSourceId];
            mDvrTests.setDemux(demux);
            ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
            ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
            ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
        }
    } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
        int32_t feId;
        mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
        ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
        ASSERT_TRUE(mFrontendTests.setFrontendCallback());
        if (mLnbId != INVALID_LNB_ID) {
            ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
        } else {
            // If, for some reason, the test got here without failing. We fail it here.
            ALOGD("mLnbId is null. Something went wrong. Exiting ScrambledBroadcastWithLnbId.");
            FAIL();
        }
        ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
        mFrontendTests.setDemux(demux);
    }

    set<int64_t> filterIds;
    int64_t filterId;
    set<struct FilterConfig>::iterator config;
    set<int64_t>::iterator id;
    mFilterTests.setDemux(demux);
    for (config = mediaFilterConfs.begin(); config != mediaFilterConfs.end(); config++) {
        ASSERT_TRUE(mFilterTests.openFilterInDemux((*config).type, (*config).bufferSize));
        ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
        ASSERT_TRUE(mFilterTests.configFilter((*config).settings, filterId));
        filterIds.insert(filterId);
    }
    ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
    vector<uint8_t> token;
    ASSERT_TRUE(mDescramblerTests.getKeyToken(descConfig.casSystemId, descConfig.provisionStr,
                                              descConfig.hidlPvtData, token));
    mDescramblerTests.setKeyToken(token);
    vector<DemuxPid> pids;
    DemuxPid pid;
    for (config = mediaFilterConfs.begin(); config != mediaFilterConfs.end(); config++) {
        ASSERT_TRUE(mDescramblerTests.getDemuxPidFromFilterSettings((*config).type,
                                                                    (*config).settings, pid));
        pids.push_back(pid);
        ASSERT_TRUE(mDescramblerTests.addPid(pid, nullptr));
    }
    for (id = filterIds.begin(); id != filterIds.end(); id++) {
        ASSERT_TRUE(mFilterTests.startFilter(*id));
    }

    if (context == Dataflow_Context::DESCRAMBLING) {
        if (descrambling.hasFrontendConnection) {
            // tune test
            ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
        } else {
            // Start DVR Source
            mDvrTests.startPlaybackInputThread(
                    dvrSourceConfig.playbackInputFile,
                    dvrSourceConfig.settings.get<DvrSettings::Tag::playback>());
            ASSERT_TRUE(mDvrTests.startDvrPlayback());
        }
    } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
        ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
    }

    ASSERT_TRUE(filterDataOutputTest());

    if (context == Dataflow_Context::DESCRAMBLING) {
        if (descrambling.hasFrontendConnection) {
            ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
        } else {
            mDvrTests.stopPlaybackThread();
            ASSERT_TRUE(mDvrTests.stopDvrPlayback());
        }
    } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
        ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
    }

    for (id = filterIds.begin(); id != filterIds.end(); id++) {
        ASSERT_TRUE(mFilterTests.stopFilter(*id));
    }
    for (auto pid : pids) {
        ASSERT_TRUE(mDescramblerTests.removePid(pid, nullptr));
    }
    ASSERT_TRUE(mDescramblerTests.closeDescrambler());
    for (id = filterIds.begin(); id != filterIds.end(); id++) {
        ASSERT_TRUE(mFilterTests.closeFilter(*id));
    }

    if (context == Dataflow_Context::DESCRAMBLING) {
        if (descrambling.hasFrontendConnection) {
            ASSERT_TRUE(mFrontendTests.closeFrontend());
        } else {
            mDvrTests.closeDvrPlayback();
        }
    } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
        ASSERT_TRUE(mFrontendTests.closeFrontend());
    }

    ASSERT_TRUE(mDemuxTests.closeDemux());
}

void TunerDescramblerAidlTest::scrambledBroadcastTestWithLnb(
        set<struct FilterConfig>& mediaFilterConfs, FrontendConfig& frontendConf,
        DescramblerConfig& descConfig, LnbConfig& lnbConfig) {
    // We can test the Lnb individually and make sure it functions properly. If the frontend is
    // software, we cannot test the whole dataflow. If the frontend is hardware, we can
    if (lnbConfig.name.compare(emptyHardwareId) == 0) {
        vector<int32_t> ids;
        ASSERT_TRUE(mLnbTests.getLnbIds(ids));
        ASSERT_TRUE(ids.size() > 0);
        ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
        mLnbId = ids[0];
    } else {
        ASSERT_TRUE(mLnbTests.openLnbByName(lnbConfig.name, mLnbId));
    }
    // Once Lnb is opened, test some of its basic functionality
    ASSERT_TRUE(mLnbTests.setLnbCallback());
    ASSERT_TRUE(mLnbTests.setVoltage(lnbConfig.voltage));
    ASSERT_TRUE(mLnbTests.setTone(lnbConfig.tone));
    ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConfig.position));
    if (!frontendConf.isSoftwareFe) {
        ALOGD("Frontend is not software, testing entire dataflow.");
        scrambledBroadcastTest(mediaFilterConfs, frontendConf, descConfig,
                               Dataflow_Context::LNBDESCRAMBLING);
    } else {
        ALOGD("Frontend is software, did not test the entire dataflow, but tested the Lnb "
              "individually.");
    }
    ASSERT_TRUE(mLnbTests.closeLnb());
    mLnbId = INVALID_LNB_ID;
}

TEST_P(TunerLnbAidlTest, SendDiseqcMessageToLnb) {
    description("Open and configure an Lnb with specific settings then send a diseqc msg to it.");
    if (!lnbLive.support) {
        return;
    }
    vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
    if (lnbLive_configs.empty()) {
        ALOGD("No frontends that support satellites.");
        return;
    }
    for (auto& combination : lnbLive_configs) {
        lnbLive = combination;
        if (lnbMap[lnbLive.lnbId].name.compare(emptyHardwareId) == 0) {
            vector<int32_t> ids;
            ASSERT_TRUE(mLnbTests.getLnbIds(ids));
            ASSERT_TRUE(ids.size() > 0);
            ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
        } else {
            int32_t id;
            ASSERT_TRUE(mLnbTests.openLnbByName(lnbMap[lnbLive.lnbId].name, id));
        }
        ASSERT_TRUE(mLnbTests.setLnbCallback());
        ASSERT_TRUE(mLnbTests.setVoltage(lnbMap[lnbLive.lnbId].voltage));
        ASSERT_TRUE(mLnbTests.setTone(lnbMap[lnbLive.lnbId].tone));
        ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbMap[lnbLive.lnbId].position));
        for (auto msgName : lnbLive.diseqcMsgs) {
            ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgMap[msgName]));
        }
        ASSERT_TRUE(mLnbTests.closeLnb());
    }
}

TEST_P(TunerDemuxAidlTest, openDemux) {
    description("Open and close a Demux.");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        int32_t feId;
        int32_t demuxId;
        std::shared_ptr<IDemux> demux;
        mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
        ASSERT_TRUE(feId != INVALID_ID);
        ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
        ASSERT_TRUE(mFrontendTests.setFrontendCallback());
        ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
        ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
        ASSERT_TRUE(mDemuxTests.closeDemux());
        ASSERT_TRUE(mFrontendTests.closeFrontend());
    }
}

TEST_P(TunerDemuxAidlTest, openDemuxById) {
    description("Open (with id) and close a Demux.");
    std::vector<int32_t> demuxIds;
    ASSERT_TRUE(mDemuxTests.getDemuxIds(demuxIds));
    for (int i = 0; i < demuxIds.size(); i++) {
        std::shared_ptr<IDemux> demux;
        ASSERT_TRUE(mDemuxTests.openDemuxById(demuxIds[i], demux));
        ASSERT_TRUE(mDemuxTests.closeDemux());
    }
}

TEST_P(TunerDemuxAidlTest, getDemuxInfo) {
    description("Check getDemuxInfo against demux caps");
    std::vector<int32_t> demuxIds;
    ASSERT_TRUE(mDemuxTests.getDemuxIds(demuxIds));
    int32_t combinedFilterTypes = 0;
    for (int i = 0; i < demuxIds.size(); i++) {
        DemuxInfo demuxInfo;
        ASSERT_TRUE(mDemuxTests.getDemuxInfo(demuxIds[i], demuxInfo));
        combinedFilterTypes |= demuxInfo.filterTypes;
    }
    if (demuxIds.size() > 0) {
        DemuxCapabilities demuxCaps;
        ASSERT_TRUE(mDemuxTests.getDemuxCaps(demuxCaps));
        ASSERT_TRUE(demuxCaps.filterCaps == combinedFilterTypes);
    }
}

TEST_P(TunerDemuxAidlTest, getAvSyncTime) {
    description("Get the A/V sync time from a PCR filter.");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        if (live.pcrFilterId.compare(emptyHardwareId) == 0) {
            continue;
        }
        int32_t feId;
        int32_t demuxId;
        std::shared_ptr<IDemux> demux;
        int64_t mediaFilterId;
        int64_t pcrFilterId;
        int32_t avSyncHwId;
        std::shared_ptr<IFilter> mediaFilter;

        mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
        ASSERT_TRUE(feId != INVALID_ID);
        ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
        ASSERT_TRUE(mFrontendTests.setFrontendCallback());
        ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
        ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
        mFilterTests.setDemux(demux);
        ASSERT_TRUE(mFilterTests.openFilterInDemux(filterMap[live.videoFilterId].type,
                                                   filterMap[live.videoFilterId].bufferSize));
        ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(mediaFilterId));
        ASSERT_TRUE(
                mFilterTests.configFilter(filterMap[live.videoFilterId].settings, mediaFilterId));
        mediaFilter = mFilterTests.getFilterById(mediaFilterId);
        ASSERT_TRUE(mFilterTests.openFilterInDemux(filterMap[live.pcrFilterId].type,
                                                   filterMap[live.pcrFilterId].bufferSize));
        ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(pcrFilterId));
        ASSERT_TRUE(mFilterTests.configFilter(filterMap[live.pcrFilterId].settings, pcrFilterId));
        ASSERT_TRUE(mDemuxTests.getAvSyncId(mediaFilter, avSyncHwId));
        ASSERT_TRUE(pcrFilterId == avSyncHwId);
        ASSERT_TRUE(mDemuxTests.getAvSyncTime(pcrFilterId));
        ASSERT_TRUE(mFilterTests.closeFilter(pcrFilterId));
        ASSERT_TRUE(mFilterTests.closeFilter(mediaFilterId));
        ASSERT_TRUE(mDemuxTests.closeDemux());
        ASSERT_TRUE(mFrontendTests.closeFrontend());
    }
}

TEST_P(TunerFilterAidlTest, StartFilterInDemux) {
    description("Open and start a filter in Demux.");
    if (!live.hasFrontendConnection) {
        return;
    }
    // TODO use parameterized tests
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        configSingleFilterInDemuxTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
    }
}

TEST_P(TunerFilterAidlTest, ConfigIpFilterInDemuxWithCid) {
    description("Open and configure an ip filter in Demux.");
    // TODO use parameterized tests
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        if (live.ipFilterId.compare(emptyHardwareId) == 0) {
            continue;
        }
        configSingleFilterInDemuxTest(filterMap[live.ipFilterId], frontendMap[live.frontendId]);
    }
}

TEST_P(TunerFilterAidlTest, ReconfigFilterToReceiveStartId) {
    description("Recofigure and restart a filter to test start id.");
    if (!live.hasFrontendConnection) {
        return;
    }
    // TODO use parameterized tests
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        reconfigSingleFilterInDemuxTest(filterMap[live.videoFilterId],
                                        filterMap[live.videoFilterId],
                                        frontendMap[live.frontendId]);
    }
}

TEST_P(TunerFilterAidlTest, SetFilterLinkage) {
    description("Pick up all the possible linkages from the demux caps and set them up.");
    DemuxCapabilities caps;
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    ASSERT_TRUE(mDemuxTests.getDemuxCaps(caps));
    mFilterTests.setDemux(demux);
    for (int i = 0; i < caps.linkCaps.size(); i++) {
        uint32_t bitMask = 1;
        for (int j = 0; j < FILTER_MAIN_TYPE_BIT_COUNT; j++) {
            if (caps.linkCaps[i] & (bitMask << j)) {
                int64_t sourceFilterId;
                int64_t sinkFilterId;
                ASSERT_TRUE(mFilterTests.openFilterInDemux(getLinkageFilterType(i), FMQ_SIZE_16M));
                ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(sourceFilterId));
                ASSERT_TRUE(mFilterTests.openFilterInDemux(getLinkageFilterType(j), FMQ_SIZE_16M));
                ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(sinkFilterId));
                ASSERT_TRUE(mFilterTests.setFilterDataSource(sourceFilterId, sinkFilterId));
                ASSERT_TRUE(mFilterTests.setFilterDataSourceToDemux(sinkFilterId));
                ASSERT_TRUE(mFilterTests.closeFilter(sinkFilterId));
                ASSERT_TRUE(mFilterTests.closeFilter(sourceFilterId));
            }
        }
    }
    ASSERT_TRUE(mDemuxTests.closeDemux());
}

TEST_P(TunerFilterAidlTest, testTimeFilter) {
    description("Open a timer filter in Demux and set time stamp.");
    if (!timeFilter.support) {
        return;
    }
    // TODO use parameterized tests
    auto timeFilter_configs = generateTimeFilterConfigurations();
    for (auto& configuration : timeFilter_configs) {
        timeFilter = configuration;
        testTimeFilter(timeFilterMap[timeFilter.timeFilterId]);
    }
}

static bool isEventProducingFilter(const FilterConfig& filterConfig) {
    switch (filterConfig.type.mainType) {
        case DemuxFilterMainType::TS: {
            auto tsFilterType =
                    filterConfig.type.subType.get<DemuxFilterSubType::Tag::tsFilterType>();
            return (tsFilterType == DemuxTsFilterType::SECTION ||
                    tsFilterType == DemuxTsFilterType::PES ||
                    tsFilterType == DemuxTsFilterType::AUDIO ||
                    tsFilterType == DemuxTsFilterType::VIDEO ||
                    tsFilterType == DemuxTsFilterType::RECORD ||
                    tsFilterType == DemuxTsFilterType::TEMI);
        }
        case DemuxFilterMainType::MMTP: {
            auto mmtpFilterType =
                    filterConfig.type.subType.get<DemuxFilterSubType::Tag::mmtpFilterType>();
            return (mmtpFilterType == DemuxMmtpFilterType::SECTION ||
                    mmtpFilterType == DemuxMmtpFilterType::PES ||
                    mmtpFilterType == DemuxMmtpFilterType::AUDIO ||
                    mmtpFilterType == DemuxMmtpFilterType::VIDEO ||
                    mmtpFilterType == DemuxMmtpFilterType::RECORD ||
                    mmtpFilterType == DemuxMmtpFilterType::DOWNLOAD);
        }
        case DemuxFilterMainType::IP: {
            auto ipFilterType =
                    filterConfig.type.subType.get<DemuxFilterSubType::Tag::ipFilterType>();
            return (ipFilterType == DemuxIpFilterType::SECTION);
        }
        case DemuxFilterMainType::TLV: {
            auto tlvFilterType =
                    filterConfig.type.subType.get<DemuxFilterSubType::Tag::tlvFilterType>();
            return (tlvFilterType == DemuxTlvFilterType::SECTION);
        }
        case DemuxFilterMainType::ALP: {
            auto alpFilterType =
                    filterConfig.type.subType.get<DemuxFilterSubType::Tag::alpFilterType>();
            return (alpFilterType == DemuxAlpFilterType::SECTION);
        }
        default:
            return false;
    }
}

static bool isMediaFilter(const FilterConfig& filterConfig) {
    switch (filterConfig.type.mainType) {
        case DemuxFilterMainType::TS: {
            // TS Audio and Video filters are media filters
            auto tsFilterType =
                    filterConfig.type.subType.get<DemuxFilterSubType::Tag::tsFilterType>();
            return (tsFilterType == DemuxTsFilterType::AUDIO ||
                    tsFilterType == DemuxTsFilterType::VIDEO);
        }
        case DemuxFilterMainType::MMTP: {
            // MMTP Audio and Video filters are media filters
            auto mmtpFilterType =
                    filterConfig.type.subType.get<DemuxFilterSubType::Tag::mmtpFilterType>();
            return (mmtpFilterType == DemuxMmtpFilterType::AUDIO ||
                    mmtpFilterType == DemuxMmtpFilterType::VIDEO);
        }
        default:
            return false;
    }
}

static int getDemuxFilterEventDataLength(const DemuxFilterEvent& event) {
    switch (event.getTag()) {
        case DemuxFilterEvent::Tag::section:
            return event.get<DemuxFilterEvent::Tag::section>().dataLength;
        case DemuxFilterEvent::Tag::media:
            return event.get<DemuxFilterEvent::Tag::media>().dataLength;
        case DemuxFilterEvent::Tag::pes:
            return event.get<DemuxFilterEvent::Tag::pes>().dataLength;
        case DemuxFilterEvent::Tag::download:
            return event.get<DemuxFilterEvent::Tag::download>().dataLength;
        case DemuxFilterEvent::Tag::ipPayload:
            return event.get<DemuxFilterEvent::Tag::ipPayload>().dataLength;

        case DemuxFilterEvent::Tag::tsRecord:
        case DemuxFilterEvent::Tag::mmtpRecord:
        case DemuxFilterEvent::Tag::temi:
        case DemuxFilterEvent::Tag::monitorEvent:
        case DemuxFilterEvent::Tag::startId:
            return 0;
    }
}

// TODO: move boilerplate into text fixture
void TunerFilterAidlTest::testDelayHint(const FilterConfig& filterConf) {
    if (!filterConf.timeDelayInMs && !filterConf.dataDelayInBytes) {
        return;
    }
    if (!isEventProducingFilter(filterConf)) {
        return;
    }
    int32_t feId;
    int32_t demuxId;
    std::shared_ptr<IDemux> demux;
    int64_t filterId;

    mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
    ASSERT_TRUE(feId != INVALID_ID);
    ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
    ASSERT_TRUE(mFrontendTests.setFrontendCallback());
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
    ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
    mFilterTests.setDemux(demux);

    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));

    bool mediaFilter = isMediaFilter(filterConf);
    auto filter = mFilterTests.getFilterById(filterId);

    // startTime needs to be set before calling setDelayHint.
    auto startTime = std::chrono::steady_clock::now();

    int timeDelayInMs = filterConf.timeDelayInMs;
    if (timeDelayInMs > 0) {
        FilterDelayHint delayHint;
        delayHint.hintType = FilterDelayHintType::TIME_DELAY_IN_MS;
        delayHint.hintValue = timeDelayInMs;

        // setDelayHint should fail for media filters.
        ASSERT_EQ(filter->setDelayHint(delayHint).isOk(), !mediaFilter);
    }

    int dataDelayInBytes = filterConf.dataDelayInBytes;
    if (dataDelayInBytes > 0) {
        FilterDelayHint delayHint;
        delayHint.hintType = FilterDelayHintType::DATA_SIZE_DELAY_IN_BYTES;
        delayHint.hintValue = dataDelayInBytes;

        // setDelayHint should fail for media filters.
        ASSERT_EQ(filter->setDelayHint(delayHint).isOk(), !mediaFilter);
    }

    // start and stop filter (and wait for first callback) in order to
    // circumvent callback scheduler race conditions after adjusting filter
    // delays.
    auto cb = mFilterTests.getFilterCallbacks().at(filterId);
    auto future =
            cb->verifyFilterCallback([](const std::vector<DemuxFilterEvent>&) { return true; });

    // The configure stage can also produce events, so we should set the delay
    // hint beforehand.
    ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
    mFilterTests.startFilter(filterId);

    auto timeout = std::chrono::seconds(30);
    ASSERT_EQ(future.wait_for(timeout), std::future_status::ready);

    mFilterTests.stopFilter(filterId);

    if (!mediaFilter) {
        int callbackSize = 0;
        future = cb->verifyFilterCallback(
                [&callbackSize](const std::vector<DemuxFilterEvent>& events) {
                    for (const auto& event : events) {
                        callbackSize += getDemuxFilterEventDataLength(event);
                    }
                    return true;
                });

        ASSERT_TRUE(mFilterTests.startFilter(filterId));

        // block and wait for callback to be received.
        ASSERT_EQ(future.wait_for(timeout), std::future_status::ready);

        auto duration = std::chrono::steady_clock::now() - startTime;
        bool delayHintTest = duration >= std::chrono::milliseconds(timeDelayInMs);
        bool dataSizeTest = callbackSize >= dataDelayInBytes;

        if (timeDelayInMs > 0 && dataDelayInBytes > 0) {
            ASSERT_TRUE(delayHintTest || dataSizeTest);
        } else {
            // if only one of time delay / data delay is configured, one of them
            // holds true by default, so we want both assertions to be true.
            ASSERT_TRUE(delayHintTest && dataSizeTest);
        }

        ASSERT_TRUE(mFilterTests.stopFilter(filterId));
    }

    ASSERT_TRUE(mFilterTests.closeFilter(filterId));
    ASSERT_TRUE(mDemuxTests.closeDemux());
    ASSERT_TRUE(mFrontendTests.closeFrontend());
}

TEST_P(TunerFilterAidlTest, FilterDelayHintTest) {
    description("Test filter time delay hint.");
    if (!live.hasFrontendConnection) {
        return;
    }
    for (const auto& obj : filterMap) {
        testDelayHint(obj.second);
    }
}

TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsSectionFilterTest) {
    description("Feed ts data from playback and configure Ts section filter to get output");
    if (!playback.support) {
        return;
    }
    vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
    for (auto& configuration : playback_configs) {
        if (configuration.sectionFilterId.compare(emptyHardwareId) != 0) {
            playback = configuration;
            playbackSingleFilterTest(filterMap[playback.sectionFilterId], dvrMap[playback.dvrId]);
        }
    }
}

TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsAudioFilterTest) {
    description("Feed ts data from playback and configure Ts audio filter to get output");
    if (!playback.support) {
        return;
    }
    vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
    for (auto& configuration : playback_configs) {
        playback = configuration;
        playbackSingleFilterTest(filterMap[playback.audioFilterId], dvrMap[playback.dvrId]);
    }
}

TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsVideoFilterTest) {
    description("Feed ts data from playback and configure Ts video filter to get output");
    if (!playback.support) {
        return;
    }
    vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
    for (auto& configuration : playback_configs) {
        playback = configuration;
        playbackSingleFilterTest(filterMap[playback.videoFilterId], dvrMap[playback.dvrId]);
    }
}

TEST_P(TunerPlaybackAidlTest, SetStatusCheckIntervalHintToPlaybackTest) {
    description("Set status check interval hint to playback test.");
    if (!playback.support) {
        return;
    }
    vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
    for (auto& configuration : playback_configs) {
        playback = configuration;
        setStatusCheckIntervalHintTest(STATUS_CHECK_INTERVAL_MS, dvrMap[playback.dvrId]);
    }
}

TEST_P(TunerRecordAidlTest, RecordDataFlowWithTsRecordFilterTest) {
    description("Feed ts data from frontend to recording and test with ts record filter");
    if (!record.support) {
        return;
    }
    // Recording is not currently supported for IPTV frontend
    if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
        return;
    }
    auto record_configs = generateRecordConfigurations();
    for (auto& configuration : record_configs) {
        record = configuration;
        recordSingleFilterTest(filterMap[record.recordFilterId], frontendMap[record.frontendId],
                               dvrMap[record.dvrRecordId], Dataflow_Context::RECORD);
    }
}

TEST_P(TunerRecordAidlTest, AttachFiltersToRecordTest) {
    description("Attach a single filter to the record dvr test.");
    // TODO use parameterized tests
    if (!record.support) {
        return;
    }
    // Recording is not currently supported for IPTV frontend
    if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
        return;
    }
    auto record_configs = generateRecordConfigurations();
    for (auto& configuration : record_configs) {
        record = configuration;
        attachSingleFilterToRecordDvrTest(filterMap[record.recordFilterId],
                                          frontendMap[record.frontendId],
                                          dvrMap[record.dvrRecordId]);
    }
}

TEST_P(TunerRecordAidlTest, LnbRecordDataFlowWithTsRecordFilterTest) {
    description("Feed ts data from Fe with Lnb to recording and test with ts record filter");
    if (!lnbRecord.support) {
        return;
    }
    vector<LnbRecordHardwareConnections> lnbRecord_configs = generateLnbRecordConfigurations();
    if (lnbRecord_configs.empty()) {
        ALOGD("No frontends that support satellites.");
        return;
    }
    for (auto& configuration : lnbRecord_configs) {
        lnbRecord = configuration;
        recordSingleFilterTestWithLnb(filterMap[lnbRecord.recordFilterId],
                                      frontendMap[lnbRecord.frontendId],
                                      dvrMap[lnbRecord.dvrRecordId], lnbMap[lnbRecord.lnbId]);
    }
}

TEST_P(TunerRecordAidlTest, SetStatusCheckIntervalHintToRecordTest) {
    description("Set status check interval hint to record test.");
    if (!record.support) {
        return;
    }
    // Recording is not currently supported for IPTV frontend
    if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
        return;
    }
    auto record_configs = generateRecordConfigurations();
    for (auto& configuration : record_configs) {
        record = configuration;
        setStatusCheckIntervalHintTest(STATUS_CHECK_INTERVAL_MS, frontendMap[record.frontendId],
                                       dvrMap[record.dvrRecordId]);
    }
}

TEST_P(TunerFrontendAidlTest, TuneFrontend) {
    description("Tune one Frontend with specific setting and check Lock event");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        mFrontendTests.tuneTest(frontendMap[live.frontendId]);
    }
}

TEST_P(TunerFrontendAidlTest, AutoScanFrontend) {
    description("Run an auto frontend scan with specific setting and check lock scanMessage");
    if (!scan.hasFrontendConnection) {
        return;
    }
    vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
    for (auto& configuration : scan_configs) {
        scan = configuration;
        mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_AUTO);
    }
}

TEST_P(TunerFrontendAidlTest, BlindScanFrontend) {
    description("Run an blind frontend scan with specific setting and check lock scanMessage");
    if (!scan.hasFrontendConnection) {
        return;
    }
    // Blind scan is not applicable for IPTV frontend
    if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
        return;
    }
    vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
    for (auto& configuration : scan_configs) {
        scan = configuration;
        // Skip test if the frontend implementation doesn't support blind scan
        if (!frontendMap[scan.frontendId].supportBlindScan) {
            continue;
        }
        mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
    }
}

TEST_P(TunerFrontendAidlTest, TuneFrontendWithFrontendSettings) {
    description("Tune one Frontend with setting and check Lock event");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        mFrontendTests.tuneTest(frontendMap[live.frontendId]);
    }
}

TEST_P(TunerFrontendAidlTest, BlindScanFrontendWithEndFrequency) {
    description("Run an blind frontend scan with setting and check lock scanMessage");
    if (!scan.hasFrontendConnection) {
        return;
    }
    // Blind scan is not application for IPTV frontend
    if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
        return;
    }
    vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
    for (auto& configuration : scan_configs) {
        scan = configuration;
        // Skip test if the frontend implementation doesn't support blind scan
        if (!frontendMap[scan.frontendId].supportBlindScan) {
            continue;
        }
        mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
    }
}

TEST_P(TunerFrontendAidlTest, LinkToCiCam) {
    description("Test Frontend link to CiCam");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        if (!frontendMap[live.frontendId].canConnectToCiCam) {
            continue;
        }
        mFrontendTests.tuneTest(frontendMap[live.frontendId]);
    }
}

TEST_P(TunerFrontendAidlTest, getHardwareInfo) {
    description("Test Frontend get hardware info");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        mFrontendTests.debugInfoTest(frontendMap[live.frontendId]);
    }
}

TEST_P(TunerFrontendAidlTest, maxNumberOfFrontends) {
    description("Test Max Frontend number");
    if (!live.hasFrontendConnection) {
        return;
    }
    mFrontendTests.maxNumberOfFrontendsTest();
}

TEST_P(TunerFrontendAidlTest, statusReadinessTest) {
    description("Test Max Frontend status readiness");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        mFrontendTests.statusReadinessTest(frontendMap[live.frontendId]);
    }
}

TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowVideoFilterTest) {
    description("Test Video Filter functionality in Broadcast use case.");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
    }
}

TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowAudioFilterTest) {
    description("Test Audio Filter functionality in Broadcast use case.");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        broadcastSingleFilterTest(filterMap[live.audioFilterId], frontendMap[live.frontendId]);
    }
}

TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowSectionFilterTest) {
    description("Test Section Filter functionality in Broadcast use case.");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        if (live.sectionFilterId.compare(emptyHardwareId) == 0) {
            continue;
        }
        broadcastSingleFilterTest(filterMap[live.sectionFilterId], frontendMap[live.frontendId]);
    }
}

TEST_P(TunerBroadcastAidlTest, IonBufferTest) {
    description("Test the av filter data bufferring.");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
    }
}

TEST_P(TunerBroadcastAidlTest, LnbBroadcastDataFlowVideoFilterTest) {
    description("Test Video Filter functionality in Broadcast with Lnb use case.");
    if (!lnbLive.support) {
        return;
    }
    vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
    if (lnbLive_configs.empty()) {
        ALOGD("No frontends that support satellites.");
        return;
    }
    for (auto& combination : lnbLive_configs) {
        lnbLive = combination;
        broadcastSingleFilterTestWithLnb(filterMap[lnbLive.videoFilterId],
                                         frontendMap[lnbLive.frontendId], lnbMap[lnbLive.lnbId]);
    }
}

TEST_P(TunerBroadcastAidlTest, MediaFilterWithSharedMemoryHandle) {
    description("Test the Media Filter with shared memory handle");
    if (!live.hasFrontendConnection) {
        return;
    }
    auto live_configs = generateLiveConfigurations();
    for (auto& configuration : live_configs) {
        live = configuration;
        // shared memory handle is not used by a passthrough filter at all
        if (isPassthroughFilter(filterMap[live.videoFilterId])) {
            continue;
        }
        mediaFilterUsingSharedMemoryTest(filterMap[live.videoFilterId],
                                         frontendMap[live.frontendId]);
    }
}

TEST_P(TunerDescramblerAidlTest, CreateDescrambler) {
    description("Create Descrambler");
    if (!descrambling.support) {
        return;
    }
    vector<DescramblingHardwareConnections> descrambling_configs =
            generateDescramblingConfigurations();
    if (descrambling_configs.empty()) {
        ALOGD("No valid descrambling combinations in the configuration file.");
        return;
    }
    for (auto& combination : descrambling_configs) {
        descrambling = combination;
        int32_t demuxId;
        std::shared_ptr<IDemux> demux;
        ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));

        if (descrambling.hasFrontendConnection) {
            int32_t feId;
            mFrontendTests.getFrontendIdByType(frontendMap[descrambling.frontendId].type, feId);
            ASSERT_TRUE(feId != INVALID_ID);
            ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
            ASSERT_TRUE(mFrontendTests.setFrontendCallback());
            ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
        }

        ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
        ASSERT_TRUE(mDescramblerTests.closeDescrambler());
        ASSERT_TRUE(mDemuxTests.closeDemux());

        if (descrambling.hasFrontendConnection) {
            ASSERT_TRUE(mFrontendTests.closeFrontend());
        }
    }
}

TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTest) {
    description("Test ts audio filter in scrambled broadcast use case");
    if (!descrambling.support) {
        return;
    }
    vector<DescramblingHardwareConnections> descrambling_configs =
            generateDescramblingConfigurations();
    if (descrambling_configs.empty()) {
        ALOGD("No valid descrambling combinations in the configuration file.");
        return;
    }
    for (auto& combination : descrambling_configs) {
        descrambling = combination;
        set<FilterConfig> filterConfs;
        filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.audioFilterId]));
        filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.videoFilterId]));
        scrambledBroadcastTest(filterConfs, frontendMap[descrambling.frontendId],
                               descramblerMap[descrambling.descramblerId],
                               Dataflow_Context::DESCRAMBLING);
    }
}

TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTestWithLnb) {
    description("Test media filters in scrambled broadcast use case with Lnb");
    if (!lnbDescrambling.support) {
        return;
    }
    auto lnbDescrambling_configs = generateLnbDescramblingConfigurations();
    if (lnbDescrambling_configs.empty()) {
        ALOGD("No frontends that support satellites.");
        return;
    }
    for (auto& configuration : lnbDescrambling_configs) {
        lnbDescrambling = configuration;
        set<FilterConfig> filterConfs;
        filterConfs.insert(static_cast<FilterConfig>(filterMap[lnbDescrambling.audioFilterId]));
        filterConfs.insert(static_cast<FilterConfig>(filterMap[lnbDescrambling.videoFilterId]));
        scrambledBroadcastTestWithLnb(filterConfs, frontendMap[lnbDescrambling.frontendId],
                                      descramblerMap[lnbDescrambling.descramblerId],
                                      lnbMap[lnbDescrambling.lnbId]);
    }
}

INSTANTIATE_TEST_SUITE_P(PerInstance, TunerBroadcastAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
                         android::PrintInstanceNameToString);

INSTANTIATE_TEST_SUITE_P(PerInstance, TunerFrontendAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
                         android::PrintInstanceNameToString);

INSTANTIATE_TEST_SUITE_P(PerInstance, TunerFilterAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
                         android::PrintInstanceNameToString);

INSTANTIATE_TEST_SUITE_P(PerInstance, TunerRecordAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
                         android::PrintInstanceNameToString);

INSTANTIATE_TEST_SUITE_P(PerInstance, TunerLnbAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
                         android::PrintInstanceNameToString);

INSTANTIATE_TEST_SUITE_P(PerInstance, TunerDemuxAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
                         android::PrintInstanceNameToString);

INSTANTIATE_TEST_SUITE_P(PerInstance, TunerPlaybackAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
                         android::PrintInstanceNameToString);

INSTANTIATE_TEST_SUITE_P(PerInstance, TunerDescramblerAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
                         android::PrintInstanceNameToString);

}  // namespace

// Start thread pool to receive callbacks from AIDL service.
int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    ABinderProcess_setThreadPoolMaxThreadCount(1);
    ABinderProcess_startThreadPool();
    return RUN_ALL_TESTS();
}