xref: /aosp_15_r20/hardware/interfaces/tv/tuner/aidl/vts/functional/VtsHalTvTunerTargetTest.cpp (revision 4d7e907c777eeecc4c5bd7cf640a754fac206ff7) 
1 /*
2  * Copyright 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "VtsHalTvTunerTargetTest.h"
18 
19 #include <aidl/Gtest.h>
20 #include <aidl/Vintf.h>
21 #include <android/binder_manager.h>
22 #include <android/binder_process.h>
23 
24 namespace {
25 
filterDataOutputTest()26 AssertionResult TunerBroadcastAidlTest::filterDataOutputTest() {
27     return filterDataOutputTestBase(mFilterTests);
28 }
29 
filterDataOutputTest()30 AssertionResult TunerPlaybackAidlTest::filterDataOutputTest() {
31     return filterDataOutputTestBase(mFilterTests);
32 }
33 
filterDataOutputTest()34 AssertionResult TunerDescramblerAidlTest::filterDataOutputTest() {
35     return filterDataOutputTestBase(mFilterTests);
36 }
37 
configSingleFilterInDemuxTest(FilterConfig filterConf,FrontendConfig frontendConf)38 void TunerFilterAidlTest::configSingleFilterInDemuxTest(FilterConfig filterConf,
39                                                         FrontendConfig frontendConf) {
40     int32_t feId;
41     int32_t demuxId;
42     std::shared_ptr<IDemux> demux;
43     int64_t filterId;
44 
45     mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
46     ASSERT_TRUE(feId != INVALID_ID);
47     ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
48     ASSERT_TRUE(mFrontendTests.setFrontendCallback());
49     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
50     ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
51     mFrontendTests.setDemux(demux);
52     mFilterTests.setDemux(demux);
53     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
54     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
55     ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
56     if (filterConf.type.mainType == DemuxFilterMainType::IP) {
57         ASSERT_TRUE(mFilterTests.configIpFilterCid(filterConf.ipCid, filterId));
58     }
59     if (filterConf.monitorEventTypes > 0) {
60         ASSERT_TRUE(mFilterTests.configureMonitorEvent(filterId, filterConf.monitorEventTypes));
61     }
62     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
63     ASSERT_TRUE(mFilterTests.startFilter(filterId));
64     ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
65     if (filterConf.monitorEventTypes > 0) {
66         ASSERT_TRUE(mFilterTests.testMonitorEvent(filterId, filterConf.monitorEventTypes));
67     }
68     ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
69     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
70     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
71     ASSERT_TRUE(mDemuxTests.closeDemux());
72     ASSERT_TRUE(mFrontendTests.closeFrontend());
73 }
74 
reconfigSingleFilterInDemuxTest(FilterConfig filterConf,FilterConfig filterReconf,FrontendConfig frontendConf)75 void TunerFilterAidlTest::reconfigSingleFilterInDemuxTest(FilterConfig filterConf,
76                                                           FilterConfig filterReconf,
77                                                           FrontendConfig frontendConf) {
78     int32_t feId;
79     int32_t demuxId;
80     std::shared_ptr<IDemux> demux;
81     int64_t filterId;
82 
83     mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
84     ASSERT_TRUE(feId != INVALID_ID);
85     ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
86     ASSERT_TRUE(mFrontendTests.setFrontendCallback());
87     if (frontendConf.isSoftwareFe) {
88         mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
89     }
90     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
91     ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
92     mFrontendTests.setDemux(demux);
93     mFilterTests.setDemux(demux);
94     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
95     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
96     ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
97     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
98     ASSERT_TRUE(mFilterTests.startFilter(filterId));
99     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
100     ASSERT_TRUE(mFilterTests.configFilter(filterReconf.settings, filterId));
101     ASSERT_TRUE(mFilterTests.startFilter(filterId));
102     ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
103     ASSERT_TRUE(mFilterTests.startIdTest(filterId));
104     ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
105     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
106     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
107     ASSERT_TRUE(mDemuxTests.closeDemux());
108     ASSERT_TRUE(mFrontendTests.closeFrontend());
109 }
110 
testTimeFilter(TimeFilterConfig filterConf)111 void TunerFilterAidlTest::testTimeFilter(TimeFilterConfig filterConf) {
112     int32_t demuxId;
113     std::shared_ptr<IDemux> demux;
114     DemuxCapabilities caps;
115 
116     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
117     ASSERT_TRUE(mDemuxTests.getDemuxCaps(caps));
118     ASSERT_TRUE(caps.bTimeFilter);
119     mFilterTests.setDemux(demux);
120     ASSERT_TRUE(mFilterTests.openTimeFilterInDemux());
121     ASSERT_TRUE(mFilterTests.setTimeStamp(filterConf.timeStamp));
122     ASSERT_TRUE(mFilterTests.getTimeStamp());
123     ASSERT_TRUE(mFilterTests.clearTimeStamp());
124     ASSERT_TRUE(mFilterTests.closeTimeFilter());
125     ASSERT_TRUE(mDemuxTests.closeDemux());
126 }
127 
broadcastSingleFilterTest(FilterConfig filterConf,FrontendConfig frontendConf)128 void TunerBroadcastAidlTest::broadcastSingleFilterTest(FilterConfig filterConf,
129                                                        FrontendConfig frontendConf) {
130     int32_t feId;
131     int32_t demuxId;
132     std::shared_ptr<IDemux> demux;
133     int64_t filterId;
134 
135     mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
136     ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
137     ASSERT_TRUE(mFrontendTests.setFrontendCallback());
138     if (mLnbId != INVALID_LNB_ID) {
139         ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
140     }
141     if (frontendConf.isSoftwareFe) {
142         mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
143     }
144     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
145     ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
146     mFrontendTests.setDemux(demux);
147     mFilterTests.setDemux(demux);
148     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
149     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
150     ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
151     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
152     ASSERT_TRUE(mFilterTests.startFilter(filterId));
153     // tune test
154     ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
155     ASSERT_TRUE(filterDataOutputTest());
156     ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
157     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
158     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
159     ASSERT_TRUE(mDemuxTests.closeDemux());
160     ASSERT_TRUE(mFrontendTests.closeFrontend());
161 }
162 
broadcastSingleFilterTestWithLnb(FilterConfig filterConf,FrontendConfig frontendConf,LnbConfig lnbConf)163 void TunerBroadcastAidlTest::broadcastSingleFilterTestWithLnb(FilterConfig filterConf,
164                                                               FrontendConfig frontendConf,
165                                                               LnbConfig lnbConf) {
166     if (lnbConf.name.compare(emptyHardwareId) == 0) {
167         vector<int32_t> ids;
168         ASSERT_TRUE(mLnbTests.getLnbIds(ids));
169         ASSERT_TRUE(ids.size() > 0);
170         ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
171         mLnbId = ids[0];
172     } else {
173         ASSERT_TRUE(mLnbTests.openLnbByName(lnbConf.name, mLnbId));
174     }
175     ASSERT_TRUE(mLnbTests.setLnbCallback());
176     ASSERT_TRUE(mLnbTests.setVoltage(lnbConf.voltage));
177     ASSERT_TRUE(mLnbTests.setTone(lnbConf.tone));
178     ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConf.position));
179     if (!frontendConf.isSoftwareFe) {
180         broadcastSingleFilterTest(filterConf, frontendConf);
181     }
182     ASSERT_TRUE(mLnbTests.closeLnb());
183     mLnbId = INVALID_LNB_ID;
184 }
185 
mediaFilterUsingSharedMemoryTest(FilterConfig filterConf,FrontendConfig frontendConf)186 void TunerBroadcastAidlTest::mediaFilterUsingSharedMemoryTest(FilterConfig filterConf,
187                                                               FrontendConfig frontendConf) {
188     int32_t feId;
189     int32_t demuxId;
190     std::shared_ptr<IDemux> demux;
191     int64_t filterId;
192 
193     mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
194     ASSERT_TRUE(feId != INVALID_ID);
195     ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
196     ASSERT_TRUE(mFrontendTests.setFrontendCallback());
197     if (frontendConf.isSoftwareFe) {
198         mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
199     }
200     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
201     ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
202     mFrontendTests.setDemux(demux);
203     mFilterTests.setDemux(demux);
204     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
205     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
206     ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
207     ASSERT_TRUE(mFilterTests.getSharedAvMemoryHandle(filterId));
208     ASSERT_TRUE(mFilterTests.configAvFilterStreamType(filterConf.streamType, filterId));
209     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
210     ASSERT_TRUE(mFilterTests.startFilter(filterId));
211     // tune test
212     ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
213     ASSERT_TRUE(filterDataOutputTest());
214     ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
215     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
216     ASSERT_TRUE(mFilterTests.releaseShareAvHandle(filterId));
217     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
218     ASSERT_TRUE(mDemuxTests.closeDemux());
219     ASSERT_TRUE(mFrontendTests.closeFrontend());
220 }
221 
playbackSingleFilterTest(FilterConfig filterConf,DvrConfig dvrConf)222 void TunerPlaybackAidlTest::playbackSingleFilterTest(FilterConfig filterConf, DvrConfig dvrConf) {
223     int32_t demuxId;
224     std::shared_ptr<IDemux> demux;
225     int64_t filterId;
226 
227     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
228     mFilterTests.setDemux(demux);
229     mDvrTests.setDemux(demux);
230     ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
231     ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrConf.settings));
232     ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
233     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
234     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
235     ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
236     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
237     mDvrTests.startPlaybackInputThread(dvrConf.playbackInputFile,
238                                        dvrConf.settings.get<DvrSettings::Tag::playback>());
239     ASSERT_TRUE(mDvrTests.startDvrPlayback());
240     ASSERT_TRUE(mFilterTests.startFilter(filterId));
241     ASSERT_TRUE(filterDataOutputTest());
242     mDvrTests.stopPlaybackThread();
243     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
244     ASSERT_TRUE(mDvrTests.stopDvrPlayback());
245     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
246     mDvrTests.closeDvrPlayback();
247     ASSERT_TRUE(mDemuxTests.closeDemux());
248 }
249 
setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,DvrConfig dvrConf)250 void TunerPlaybackAidlTest::setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,
251                                                            DvrConfig dvrConf) {
252     int32_t demuxId;
253     std::shared_ptr<IDemux> demux;
254 
255     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
256     mDvrTests.setDemux(demux);
257     ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
258     ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrConf.settings));
259     ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
260 
261     ASSERT_TRUE(mDvrTests.setPlaybackStatusCheckIntervalHint(statusCheckIntervalHint));
262 
263     mDvrTests.startPlaybackInputThread(dvrConf.playbackInputFile,
264                                        dvrConf.settings.get<DvrSettings::Tag::playback>());
265     ASSERT_TRUE(mDvrTests.startDvrPlayback());
266     mDvrTests.stopPlaybackThread();
267     ASSERT_TRUE(mDvrTests.stopDvrPlayback());
268     mDvrTests.closeDvrPlayback();
269     ASSERT_TRUE(mDemuxTests.closeDemux());
270 }
271 
recordSingleFilterTestWithLnb(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf,LnbConfig lnbConf)272 void TunerRecordAidlTest::recordSingleFilterTestWithLnb(FilterConfig filterConf,
273                                                         FrontendConfig frontendConf,
274                                                         DvrConfig dvrConf, LnbConfig lnbConf) {
275     if (lnbConf.name.compare(emptyHardwareId) == 0) {
276         vector<int32_t> ids;
277         ASSERT_TRUE(mLnbTests.getLnbIds(ids));
278         ASSERT_TRUE(ids.size() > 0);
279         ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
280         mLnbId = ids[0];
281     } else {
282         ASSERT_TRUE(mLnbTests.openLnbByName(lnbConf.name, mLnbId));
283     }
284     ASSERT_TRUE(mLnbTests.setLnbCallback());
285     ASSERT_TRUE(mLnbTests.setVoltage(lnbConf.voltage));
286     ASSERT_TRUE(mLnbTests.setTone(lnbConf.tone));
287     ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConf.position));
288     for (auto msgName : lnbRecord.diseqcMsgs) {
289         ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgMap[msgName]));
290     }
291     if (!frontendConf.isSoftwareFe) {
292         recordSingleFilterTest(filterConf, frontendConf, dvrConf, Dataflow_Context::LNBRECORD);
293     }
294     ASSERT_TRUE(mLnbTests.closeLnb());
295     mLnbId = INVALID_LNB_ID;
296 }
297 
attachSingleFilterToRecordDvrTest(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf)298 void TunerRecordAidlTest::attachSingleFilterToRecordDvrTest(FilterConfig filterConf,
299                                                             FrontendConfig frontendConf,
300                                                             DvrConfig dvrConf) {
301     int32_t demuxId;
302     std::shared_ptr<IDemux> demux;
303     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
304     mDvrTests.setDemux(demux);
305 
306     DvrConfig dvrSourceConfig;
307     if (record.hasFrontendConnection) {
308         int32_t feId;
309         mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
310         ASSERT_TRUE(feId != INVALID_ID);
311         ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
312         ASSERT_TRUE(mFrontendTests.setFrontendCallback());
313         ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
314     } else {
315         dvrSourceConfig = dvrMap[record.dvrSourceId];
316         ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
317         ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
318         ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
319     }
320 
321     int64_t filterId;
322     std::shared_ptr<IFilter> filter;
323     mFilterTests.setDemux(demux);
324 
325     ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
326     ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
327     ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
328 
329     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
330     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
331     ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
332     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
333     filter = mFilterTests.getFilterById(filterId);
334     ASSERT_TRUE(filter != nullptr);
335     ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
336     ASSERT_TRUE(mDvrTests.startDvrRecord());
337     ASSERT_TRUE(mFilterTests.startFilter(filterId));
338     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
339     ASSERT_TRUE(mDvrTests.stopDvrRecord());
340     ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
341     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
342     mDvrTests.closeDvrRecord();
343     ASSERT_TRUE(mDemuxTests.closeDemux());
344 
345     if (record.hasFrontendConnection) {
346         ASSERT_TRUE(mFrontendTests.closeFrontend());
347     }
348 }
349 
recordSingleFilterTest(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf,Dataflow_Context context)350 void TunerRecordAidlTest::recordSingleFilterTest(FilterConfig filterConf,
351                                                  FrontendConfig frontendConf, DvrConfig dvrConf,
352                                                  Dataflow_Context context) {
353     int32_t demuxId;
354     std::shared_ptr<IDemux> demux;
355     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
356     mDvrTests.setDemux(demux);
357 
358     DvrConfig dvrSourceConfig;
359     if (context == Dataflow_Context::RECORD) {
360         if (record.hasFrontendConnection) {
361             int32_t feId;
362             mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
363             ASSERT_TRUE(feId != INVALID_ID);
364             ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
365             ASSERT_TRUE(mFrontendTests.setFrontendCallback());
366             if (frontendConf.isSoftwareFe) {
367                 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[record.dvrSoftwareFeId]);
368             }
369             ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
370             mFrontendTests.setDvrTests(&mDvrTests);
371         } else {
372             dvrSourceConfig = dvrMap[record.dvrSourceId];
373             ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
374             ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
375             ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
376         }
377     } else if (context == Dataflow_Context::LNBRECORD) {
378         // If function arrives here, frontend should not be software, so no need to configure a dvr
379         // source or dvr fe connection that might be used for recording without an Lnb
380         int32_t feId;
381         mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
382         ASSERT_TRUE(feId != INVALID_ID);
383         ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
384         ASSERT_TRUE(mFrontendTests.setFrontendCallback());
385         if (mLnbId != INVALID_LNB_ID) {
386             ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
387         } else {
388             FAIL();
389         }
390         ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
391         mFrontendTests.setDvrTests(&mDvrTests);
392     }
393 
394     int64_t filterId;
395     std::shared_ptr<IFilter> filter;
396     mFilterTests.setDemux(demux);
397     ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
398     ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
399     ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
400     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
401     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
402     ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
403     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
404     filter = mFilterTests.getFilterById(filterId);
405     ASSERT_TRUE(filter != nullptr);
406     mDvrTests.startRecordOutputThread(dvrConf.settings.get<DvrSettings::Tag::record>());
407     ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
408     ASSERT_TRUE(mDvrTests.startDvrRecord());
409     ASSERT_TRUE(mFilterTests.startFilter(filterId));
410 
411     if (context == Dataflow_Context::RECORD) {
412         if (record.hasFrontendConnection) {
413             ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
414         } else {
415             // Start DVR Source
416             mDvrTests.startPlaybackInputThread(
417                     dvrSourceConfig.playbackInputFile,
418                     dvrSourceConfig.settings.get<DvrSettings::Tag::playback>());
419             ASSERT_TRUE(mDvrTests.startDvrPlayback());
420         }
421     } else if (context == Dataflow_Context::LNBRECORD) {
422         ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
423     }
424     mDvrTests.testRecordOutput();
425     mDvrTests.stopRecordThread();
426 
427     if (context == Dataflow_Context::RECORD) {
428         if (record.hasFrontendConnection) {
429             ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
430         } else {
431             mDvrTests.stopPlaybackThread();
432             ASSERT_TRUE(mDvrTests.stopDvrPlayback());
433         }
434     } else if (context == Dataflow_Context::LNBRECORD) {
435         ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
436     }
437 
438     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
439     ASSERT_TRUE(mDvrTests.stopDvrRecord());
440     ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
441     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
442     mDvrTests.closeDvrRecord();
443 
444     if (context == Dataflow_Context::RECORD) {
445         if (record.hasFrontendConnection) {
446             ASSERT_TRUE(mFrontendTests.closeFrontend());
447         } else {
448             mDvrTests.closeDvrPlayback();
449         }
450     } else if (context == Dataflow_Context::LNBRECORD) {
451         ASSERT_TRUE(mFrontendTests.closeFrontend());
452     }
453 
454     ASSERT_TRUE(mDemuxTests.closeDemux());
455 }
456 
setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,FrontendConfig frontendConf,DvrConfig dvrConf)457 void TunerRecordAidlTest::setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,
458                                                          FrontendConfig frontendConf,
459                                                          DvrConfig dvrConf) {
460     int32_t demuxId;
461     std::shared_ptr<IDemux> demux;
462     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
463     mDvrTests.setDemux(demux);
464 
465     DvrConfig dvrSourceConfig;
466     if (record.hasFrontendConnection) {
467         int32_t feId;
468         mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
469         ASSERT_TRUE(feId != INVALID_ID);
470         ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
471         ASSERT_TRUE(mFrontendTests.setFrontendCallback());
472         ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
473     } else {
474         dvrSourceConfig = dvrMap[record.dvrSourceId];
475         ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
476         ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
477         ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
478     }
479 
480     ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
481     ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
482     ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
483 
484     ASSERT_TRUE(mDvrTests.setRecordStatusCheckIntervalHint(statusCheckIntervalHint));
485 
486     ASSERT_TRUE(mDvrTests.startDvrRecord());
487     ASSERT_TRUE(mDvrTests.stopDvrRecord());
488     mDvrTests.closeDvrRecord();
489     ASSERT_TRUE(mDemuxTests.closeDemux());
490 
491     if (record.hasFrontendConnection) {
492         ASSERT_TRUE(mFrontendTests.closeFrontend());
493     }
494 }
495 
scrambledBroadcastTest(set<struct FilterConfig> mediaFilterConfs,FrontendConfig frontendConf,DescramblerConfig descConfig,Dataflow_Context context)496 void TunerDescramblerAidlTest::scrambledBroadcastTest(set<struct FilterConfig> mediaFilterConfs,
497                                                       FrontendConfig frontendConf,
498                                                       DescramblerConfig descConfig,
499                                                       Dataflow_Context context) {
500     int32_t demuxId;
501     std::shared_ptr<IDemux> demux;
502     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
503 
504     DvrConfig dvrSourceConfig;
505     if (context == Dataflow_Context::DESCRAMBLING) {
506         if (descrambling.hasFrontendConnection) {
507             int32_t feId;
508             mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
509             ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
510             ASSERT_TRUE(mFrontendTests.setFrontendCallback());
511             if (frontendConf.isSoftwareFe) {
512                 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[descrambling.dvrSoftwareFeId]);
513             }
514             ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
515             mFrontendTests.setDemux(demux);
516         } else {
517             dvrSourceConfig = dvrMap[descrambling.dvrSourceId];
518             mDvrTests.setDemux(demux);
519             ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
520             ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
521             ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
522         }
523     } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
524         int32_t feId;
525         mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
526         ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
527         ASSERT_TRUE(mFrontendTests.setFrontendCallback());
528         if (mLnbId != INVALID_LNB_ID) {
529             ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
530         } else {
531             // If, for some reason, the test got here without failing. We fail it here.
532             ALOGD("mLnbId is null. Something went wrong. Exiting ScrambledBroadcastWithLnbId.");
533             FAIL();
534         }
535         ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
536         mFrontendTests.setDemux(demux);
537     }
538 
539     set<int64_t> filterIds;
540     int64_t filterId;
541     set<struct FilterConfig>::iterator config;
542     set<int64_t>::iterator id;
543     mFilterTests.setDemux(demux);
544     for (config = mediaFilterConfs.begin(); config != mediaFilterConfs.end(); config++) {
545         ASSERT_TRUE(mFilterTests.openFilterInDemux((*config).type, (*config).bufferSize));
546         ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
547         ASSERT_TRUE(mFilterTests.configFilter((*config).settings, filterId));
548         filterIds.insert(filterId);
549     }
550     ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
551     vector<uint8_t> token;
552     ASSERT_TRUE(mDescramblerTests.getKeyToken(descConfig.casSystemId, descConfig.provisionStr,
553                                               descConfig.hidlPvtData, token));
554     mDescramblerTests.setKeyToken(token);
555     vector<DemuxPid> pids;
556     DemuxPid pid;
557     for (config = mediaFilterConfs.begin(); config != mediaFilterConfs.end(); config++) {
558         ASSERT_TRUE(mDescramblerTests.getDemuxPidFromFilterSettings((*config).type,
559                                                                     (*config).settings, pid));
560         pids.push_back(pid);
561         ASSERT_TRUE(mDescramblerTests.addPid(pid, nullptr));
562     }
563     for (id = filterIds.begin(); id != filterIds.end(); id++) {
564         ASSERT_TRUE(mFilterTests.startFilter(*id));
565     }
566 
567     if (context == Dataflow_Context::DESCRAMBLING) {
568         if (descrambling.hasFrontendConnection) {
569             // tune test
570             ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
571         } else {
572             // Start DVR Source
573             mDvrTests.startPlaybackInputThread(
574                     dvrSourceConfig.playbackInputFile,
575                     dvrSourceConfig.settings.get<DvrSettings::Tag::playback>());
576             ASSERT_TRUE(mDvrTests.startDvrPlayback());
577         }
578     } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
579         ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
580     }
581 
582     ASSERT_TRUE(filterDataOutputTest());
583 
584     if (context == Dataflow_Context::DESCRAMBLING) {
585         if (descrambling.hasFrontendConnection) {
586             ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
587         } else {
588             mDvrTests.stopPlaybackThread();
589             ASSERT_TRUE(mDvrTests.stopDvrPlayback());
590         }
591     } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
592         ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
593     }
594 
595     for (id = filterIds.begin(); id != filterIds.end(); id++) {
596         ASSERT_TRUE(mFilterTests.stopFilter(*id));
597     }
598     for (auto pid : pids) {
599         ASSERT_TRUE(mDescramblerTests.removePid(pid, nullptr));
600     }
601     ASSERT_TRUE(mDescramblerTests.closeDescrambler());
602     for (id = filterIds.begin(); id != filterIds.end(); id++) {
603         ASSERT_TRUE(mFilterTests.closeFilter(*id));
604     }
605 
606     if (context == Dataflow_Context::DESCRAMBLING) {
607         if (descrambling.hasFrontendConnection) {
608             ASSERT_TRUE(mFrontendTests.closeFrontend());
609         } else {
610             mDvrTests.closeDvrPlayback();
611         }
612     } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
613         ASSERT_TRUE(mFrontendTests.closeFrontend());
614     }
615 
616     ASSERT_TRUE(mDemuxTests.closeDemux());
617 }
618 
scrambledBroadcastTestWithLnb(set<struct FilterConfig> & mediaFilterConfs,FrontendConfig & frontendConf,DescramblerConfig & descConfig,LnbConfig & lnbConfig)619 void TunerDescramblerAidlTest::scrambledBroadcastTestWithLnb(
620         set<struct FilterConfig>& mediaFilterConfs, FrontendConfig& frontendConf,
621         DescramblerConfig& descConfig, LnbConfig& lnbConfig) {
622     // We can test the Lnb individually and make sure it functions properly. If the frontend is
623     // software, we cannot test the whole dataflow. If the frontend is hardware, we can
624     if (lnbConfig.name.compare(emptyHardwareId) == 0) {
625         vector<int32_t> ids;
626         ASSERT_TRUE(mLnbTests.getLnbIds(ids));
627         ASSERT_TRUE(ids.size() > 0);
628         ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
629         mLnbId = ids[0];
630     } else {
631         ASSERT_TRUE(mLnbTests.openLnbByName(lnbConfig.name, mLnbId));
632     }
633     // Once Lnb is opened, test some of its basic functionality
634     ASSERT_TRUE(mLnbTests.setLnbCallback());
635     ASSERT_TRUE(mLnbTests.setVoltage(lnbConfig.voltage));
636     ASSERT_TRUE(mLnbTests.setTone(lnbConfig.tone));
637     ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConfig.position));
638     if (!frontendConf.isSoftwareFe) {
639         ALOGD("Frontend is not software, testing entire dataflow.");
640         scrambledBroadcastTest(mediaFilterConfs, frontendConf, descConfig,
641                                Dataflow_Context::LNBDESCRAMBLING);
642     } else {
643         ALOGD("Frontend is software, did not test the entire dataflow, but tested the Lnb "
644               "individually.");
645     }
646     ASSERT_TRUE(mLnbTests.closeLnb());
647     mLnbId = INVALID_LNB_ID;
648 }
649 
TEST_P(TunerLnbAidlTest,SendDiseqcMessageToLnb)650 TEST_P(TunerLnbAidlTest, SendDiseqcMessageToLnb) {
651     description("Open and configure an Lnb with specific settings then send a diseqc msg to it.");
652     if (!lnbLive.support) {
653         return;
654     }
655     vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
656     if (lnbLive_configs.empty()) {
657         ALOGD("No frontends that support satellites.");
658         return;
659     }
660     for (auto& combination : lnbLive_configs) {
661         lnbLive = combination;
662         if (lnbMap[lnbLive.lnbId].name.compare(emptyHardwareId) == 0) {
663             vector<int32_t> ids;
664             ASSERT_TRUE(mLnbTests.getLnbIds(ids));
665             ASSERT_TRUE(ids.size() > 0);
666             ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
667         } else {
668             int32_t id;
669             ASSERT_TRUE(mLnbTests.openLnbByName(lnbMap[lnbLive.lnbId].name, id));
670         }
671         ASSERT_TRUE(mLnbTests.setLnbCallback());
672         ASSERT_TRUE(mLnbTests.setVoltage(lnbMap[lnbLive.lnbId].voltage));
673         ASSERT_TRUE(mLnbTests.setTone(lnbMap[lnbLive.lnbId].tone));
674         ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbMap[lnbLive.lnbId].position));
675         for (auto msgName : lnbLive.diseqcMsgs) {
676             ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgMap[msgName]));
677         }
678         ASSERT_TRUE(mLnbTests.closeLnb());
679     }
680 }
681 
TEST_P(TunerDemuxAidlTest,openDemux)682 TEST_P(TunerDemuxAidlTest, openDemux) {
683     description("Open and close a Demux.");
684     if (!live.hasFrontendConnection) {
685         return;
686     }
687     auto live_configs = generateLiveConfigurations();
688     for (auto& configuration : live_configs) {
689         live = configuration;
690         int32_t feId;
691         int32_t demuxId;
692         std::shared_ptr<IDemux> demux;
693         mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
694         ASSERT_TRUE(feId != INVALID_ID);
695         ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
696         ASSERT_TRUE(mFrontendTests.setFrontendCallback());
697         ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
698         ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
699         ASSERT_TRUE(mDemuxTests.closeDemux());
700         ASSERT_TRUE(mFrontendTests.closeFrontend());
701     }
702 }
703 
TEST_P(TunerDemuxAidlTest,openDemuxById)704 TEST_P(TunerDemuxAidlTest, openDemuxById) {
705     description("Open (with id) and close a Demux.");
706     std::vector<int32_t> demuxIds;
707     ASSERT_TRUE(mDemuxTests.getDemuxIds(demuxIds));
708     for (int i = 0; i < demuxIds.size(); i++) {
709         std::shared_ptr<IDemux> demux;
710         ASSERT_TRUE(mDemuxTests.openDemuxById(demuxIds[i], demux));
711         ASSERT_TRUE(mDemuxTests.closeDemux());
712     }
713 }
714 
TEST_P(TunerDemuxAidlTest,getDemuxInfo)715 TEST_P(TunerDemuxAidlTest, getDemuxInfo) {
716     description("Check getDemuxInfo against demux caps");
717     std::vector<int32_t> demuxIds;
718     ASSERT_TRUE(mDemuxTests.getDemuxIds(demuxIds));
719     int32_t combinedFilterTypes = 0;
720     for (int i = 0; i < demuxIds.size(); i++) {
721         DemuxInfo demuxInfo;
722         ASSERT_TRUE(mDemuxTests.getDemuxInfo(demuxIds[i], demuxInfo));
723         combinedFilterTypes |= demuxInfo.filterTypes;
724     }
725     if (demuxIds.size() > 0) {
726         DemuxCapabilities demuxCaps;
727         ASSERT_TRUE(mDemuxTests.getDemuxCaps(demuxCaps));
728         ASSERT_TRUE(demuxCaps.filterCaps == combinedFilterTypes);
729     }
730 }
731 
TEST_P(TunerDemuxAidlTest,getAvSyncTime)732 TEST_P(TunerDemuxAidlTest, getAvSyncTime) {
733     description("Get the A/V sync time from a PCR filter.");
734     if (!live.hasFrontendConnection) {
735         return;
736     }
737     auto live_configs = generateLiveConfigurations();
738     for (auto& configuration : live_configs) {
739         live = configuration;
740         if (live.pcrFilterId.compare(emptyHardwareId) == 0) {
741             continue;
742         }
743         int32_t feId;
744         int32_t demuxId;
745         std::shared_ptr<IDemux> demux;
746         int64_t mediaFilterId;
747         int64_t pcrFilterId;
748         int32_t avSyncHwId;
749         std::shared_ptr<IFilter> mediaFilter;
750 
751         mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
752         ASSERT_TRUE(feId != INVALID_ID);
753         ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
754         ASSERT_TRUE(mFrontendTests.setFrontendCallback());
755         ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
756         ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
757         mFilterTests.setDemux(demux);
758         ASSERT_TRUE(mFilterTests.openFilterInDemux(filterMap[live.videoFilterId].type,
759                                                    filterMap[live.videoFilterId].bufferSize));
760         ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(mediaFilterId));
761         ASSERT_TRUE(
762                 mFilterTests.configFilter(filterMap[live.videoFilterId].settings, mediaFilterId));
763         mediaFilter = mFilterTests.getFilterById(mediaFilterId);
764         ASSERT_TRUE(mFilterTests.openFilterInDemux(filterMap[live.pcrFilterId].type,
765                                                    filterMap[live.pcrFilterId].bufferSize));
766         ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(pcrFilterId));
767         ASSERT_TRUE(mFilterTests.configFilter(filterMap[live.pcrFilterId].settings, pcrFilterId));
768         ASSERT_TRUE(mDemuxTests.getAvSyncId(mediaFilter, avSyncHwId));
769         ASSERT_TRUE(pcrFilterId == avSyncHwId);
770         ASSERT_TRUE(mDemuxTests.getAvSyncTime(pcrFilterId));
771         ASSERT_TRUE(mFilterTests.closeFilter(pcrFilterId));
772         ASSERT_TRUE(mFilterTests.closeFilter(mediaFilterId));
773         ASSERT_TRUE(mDemuxTests.closeDemux());
774         ASSERT_TRUE(mFrontendTests.closeFrontend());
775     }
776 }
777 
TEST_P(TunerFilterAidlTest,StartFilterInDemux)778 TEST_P(TunerFilterAidlTest, StartFilterInDemux) {
779     description("Open and start a filter in Demux.");
780     if (!live.hasFrontendConnection) {
781         return;
782     }
783     // TODO use parameterized tests
784     auto live_configs = generateLiveConfigurations();
785     for (auto& configuration : live_configs) {
786         live = configuration;
787         configSingleFilterInDemuxTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
788     }
789 }
790 
TEST_P(TunerFilterAidlTest,ConfigIpFilterInDemuxWithCid)791 TEST_P(TunerFilterAidlTest, ConfigIpFilterInDemuxWithCid) {
792     description("Open and configure an ip filter in Demux.");
793     // TODO use parameterized tests
794     if (!live.hasFrontendConnection) {
795         return;
796     }
797     auto live_configs = generateLiveConfigurations();
798     for (auto& configuration : live_configs) {
799         live = configuration;
800         if (live.ipFilterId.compare(emptyHardwareId) == 0) {
801             continue;
802         }
803         configSingleFilterInDemuxTest(filterMap[live.ipFilterId], frontendMap[live.frontendId]);
804     }
805 }
806 
TEST_P(TunerFilterAidlTest,ReconfigFilterToReceiveStartId)807 TEST_P(TunerFilterAidlTest, ReconfigFilterToReceiveStartId) {
808     description("Recofigure and restart a filter to test start id.");
809     if (!live.hasFrontendConnection) {
810         return;
811     }
812     // TODO use parameterized tests
813     auto live_configs = generateLiveConfigurations();
814     for (auto& configuration : live_configs) {
815         live = configuration;
816         reconfigSingleFilterInDemuxTest(filterMap[live.videoFilterId],
817                                         filterMap[live.videoFilterId],
818                                         frontendMap[live.frontendId]);
819     }
820 }
821 
TEST_P(TunerFilterAidlTest,SetFilterLinkage)822 TEST_P(TunerFilterAidlTest, SetFilterLinkage) {
823     description("Pick up all the possible linkages from the demux caps and set them up.");
824     DemuxCapabilities caps;
825     int32_t demuxId;
826     std::shared_ptr<IDemux> demux;
827     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
828     ASSERT_TRUE(mDemuxTests.getDemuxCaps(caps));
829     mFilterTests.setDemux(demux);
830     for (int i = 0; i < caps.linkCaps.size(); i++) {
831         uint32_t bitMask = 1;
832         for (int j = 0; j < FILTER_MAIN_TYPE_BIT_COUNT; j++) {
833             if (caps.linkCaps[i] & (bitMask << j)) {
834                 int64_t sourceFilterId;
835                 int64_t sinkFilterId;
836                 ASSERT_TRUE(mFilterTests.openFilterInDemux(getLinkageFilterType(i), FMQ_SIZE_16M));
837                 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(sourceFilterId));
838                 ASSERT_TRUE(mFilterTests.openFilterInDemux(getLinkageFilterType(j), FMQ_SIZE_16M));
839                 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(sinkFilterId));
840                 ASSERT_TRUE(mFilterTests.setFilterDataSource(sourceFilterId, sinkFilterId));
841                 ASSERT_TRUE(mFilterTests.setFilterDataSourceToDemux(sinkFilterId));
842                 ASSERT_TRUE(mFilterTests.closeFilter(sinkFilterId));
843                 ASSERT_TRUE(mFilterTests.closeFilter(sourceFilterId));
844             }
845         }
846     }
847     ASSERT_TRUE(mDemuxTests.closeDemux());
848 }
849 
TEST_P(TunerFilterAidlTest,testTimeFilter)850 TEST_P(TunerFilterAidlTest, testTimeFilter) {
851     description("Open a timer filter in Demux and set time stamp.");
852     if (!timeFilter.support) {
853         return;
854     }
855     // TODO use parameterized tests
856     auto timeFilter_configs = generateTimeFilterConfigurations();
857     for (auto& configuration : timeFilter_configs) {
858         timeFilter = configuration;
859         testTimeFilter(timeFilterMap[timeFilter.timeFilterId]);
860     }
861 }
862 
isEventProducingFilter(const FilterConfig & filterConfig)863 static bool isEventProducingFilter(const FilterConfig& filterConfig) {
864     switch (filterConfig.type.mainType) {
865         case DemuxFilterMainType::TS: {
866             auto tsFilterType =
867                     filterConfig.type.subType.get<DemuxFilterSubType::Tag::tsFilterType>();
868             return (tsFilterType == DemuxTsFilterType::SECTION ||
869                     tsFilterType == DemuxTsFilterType::PES ||
870                     tsFilterType == DemuxTsFilterType::AUDIO ||
871                     tsFilterType == DemuxTsFilterType::VIDEO ||
872                     tsFilterType == DemuxTsFilterType::RECORD ||
873                     tsFilterType == DemuxTsFilterType::TEMI);
874         }
875         case DemuxFilterMainType::MMTP: {
876             auto mmtpFilterType =
877                     filterConfig.type.subType.get<DemuxFilterSubType::Tag::mmtpFilterType>();
878             return (mmtpFilterType == DemuxMmtpFilterType::SECTION ||
879                     mmtpFilterType == DemuxMmtpFilterType::PES ||
880                     mmtpFilterType == DemuxMmtpFilterType::AUDIO ||
881                     mmtpFilterType == DemuxMmtpFilterType::VIDEO ||
882                     mmtpFilterType == DemuxMmtpFilterType::RECORD ||
883                     mmtpFilterType == DemuxMmtpFilterType::DOWNLOAD);
884         }
885         case DemuxFilterMainType::IP: {
886             auto ipFilterType =
887                     filterConfig.type.subType.get<DemuxFilterSubType::Tag::ipFilterType>();
888             return (ipFilterType == DemuxIpFilterType::SECTION);
889         }
890         case DemuxFilterMainType::TLV: {
891             auto tlvFilterType =
892                     filterConfig.type.subType.get<DemuxFilterSubType::Tag::tlvFilterType>();
893             return (tlvFilterType == DemuxTlvFilterType::SECTION);
894         }
895         case DemuxFilterMainType::ALP: {
896             auto alpFilterType =
897                     filterConfig.type.subType.get<DemuxFilterSubType::Tag::alpFilterType>();
898             return (alpFilterType == DemuxAlpFilterType::SECTION);
899         }
900         default:
901             return false;
902     }
903 }
904 
isMediaFilter(const FilterConfig & filterConfig)905 static bool isMediaFilter(const FilterConfig& filterConfig) {
906     switch (filterConfig.type.mainType) {
907         case DemuxFilterMainType::TS: {
908             // TS Audio and Video filters are media filters
909             auto tsFilterType =
910                     filterConfig.type.subType.get<DemuxFilterSubType::Tag::tsFilterType>();
911             return (tsFilterType == DemuxTsFilterType::AUDIO ||
912                     tsFilterType == DemuxTsFilterType::VIDEO);
913         }
914         case DemuxFilterMainType::MMTP: {
915             // MMTP Audio and Video filters are media filters
916             auto mmtpFilterType =
917                     filterConfig.type.subType.get<DemuxFilterSubType::Tag::mmtpFilterType>();
918             return (mmtpFilterType == DemuxMmtpFilterType::AUDIO ||
919                     mmtpFilterType == DemuxMmtpFilterType::VIDEO);
920         }
921         default:
922             return false;
923     }
924 }
925 
getDemuxFilterEventDataLength(const DemuxFilterEvent & event)926 static int getDemuxFilterEventDataLength(const DemuxFilterEvent& event) {
927     switch (event.getTag()) {
928         case DemuxFilterEvent::Tag::section:
929             return event.get<DemuxFilterEvent::Tag::section>().dataLength;
930         case DemuxFilterEvent::Tag::media:
931             return event.get<DemuxFilterEvent::Tag::media>().dataLength;
932         case DemuxFilterEvent::Tag::pes:
933             return event.get<DemuxFilterEvent::Tag::pes>().dataLength;
934         case DemuxFilterEvent::Tag::download:
935             return event.get<DemuxFilterEvent::Tag::download>().dataLength;
936         case DemuxFilterEvent::Tag::ipPayload:
937             return event.get<DemuxFilterEvent::Tag::ipPayload>().dataLength;
938 
939         case DemuxFilterEvent::Tag::tsRecord:
940         case DemuxFilterEvent::Tag::mmtpRecord:
941         case DemuxFilterEvent::Tag::temi:
942         case DemuxFilterEvent::Tag::monitorEvent:
943         case DemuxFilterEvent::Tag::startId:
944             return 0;
945     }
946 }
947 
948 // TODO: move boilerplate into text fixture
testDelayHint(const FilterConfig & filterConf)949 void TunerFilterAidlTest::testDelayHint(const FilterConfig& filterConf) {
950     if (!filterConf.timeDelayInMs && !filterConf.dataDelayInBytes) {
951         return;
952     }
953     if (!isEventProducingFilter(filterConf)) {
954         return;
955     }
956     int32_t feId;
957     int32_t demuxId;
958     std::shared_ptr<IDemux> demux;
959     int64_t filterId;
960 
961     mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
962     ASSERT_TRUE(feId != INVALID_ID);
963     ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
964     ASSERT_TRUE(mFrontendTests.setFrontendCallback());
965     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
966     ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
967     mFilterTests.setDemux(demux);
968 
969     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
970     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
971 
972     bool mediaFilter = isMediaFilter(filterConf);
973     auto filter = mFilterTests.getFilterById(filterId);
974 
975     // startTime needs to be set before calling setDelayHint.
976     auto startTime = std::chrono::steady_clock::now();
977 
978     int timeDelayInMs = filterConf.timeDelayInMs;
979     if (timeDelayInMs > 0) {
980         FilterDelayHint delayHint;
981         delayHint.hintType = FilterDelayHintType::TIME_DELAY_IN_MS;
982         delayHint.hintValue = timeDelayInMs;
983 
984         // setDelayHint should fail for media filters.
985         ASSERT_EQ(filter->setDelayHint(delayHint).isOk(), !mediaFilter);
986     }
987 
988     int dataDelayInBytes = filterConf.dataDelayInBytes;
989     if (dataDelayInBytes > 0) {
990         FilterDelayHint delayHint;
991         delayHint.hintType = FilterDelayHintType::DATA_SIZE_DELAY_IN_BYTES;
992         delayHint.hintValue = dataDelayInBytes;
993 
994         // setDelayHint should fail for media filters.
995         ASSERT_EQ(filter->setDelayHint(delayHint).isOk(), !mediaFilter);
996     }
997 
998     // start and stop filter (and wait for first callback) in order to
999     // circumvent callback scheduler race conditions after adjusting filter
1000     // delays.
1001     auto cb = mFilterTests.getFilterCallbacks().at(filterId);
1002     auto future =
1003             cb->verifyFilterCallback([](const std::vector<DemuxFilterEvent>&) { return true; });
1004 
1005     // The configure stage can also produce events, so we should set the delay
1006     // hint beforehand.
1007     ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
1008     mFilterTests.startFilter(filterId);
1009 
1010     auto timeout = std::chrono::seconds(30);
1011     ASSERT_EQ(future.wait_for(timeout), std::future_status::ready);
1012 
1013     mFilterTests.stopFilter(filterId);
1014 
1015     if (!mediaFilter) {
1016         int callbackSize = 0;
1017         future = cb->verifyFilterCallback(
1018                 [&callbackSize](const std::vector<DemuxFilterEvent>& events) {
1019                     for (const auto& event : events) {
1020                         callbackSize += getDemuxFilterEventDataLength(event);
1021                     }
1022                     return true;
1023                 });
1024 
1025         ASSERT_TRUE(mFilterTests.startFilter(filterId));
1026 
1027         // block and wait for callback to be received.
1028         ASSERT_EQ(future.wait_for(timeout), std::future_status::ready);
1029 
1030         auto duration = std::chrono::steady_clock::now() - startTime;
1031         bool delayHintTest = duration >= std::chrono::milliseconds(timeDelayInMs);
1032         bool dataSizeTest = callbackSize >= dataDelayInBytes;
1033 
1034         if (timeDelayInMs > 0 && dataDelayInBytes > 0) {
1035             ASSERT_TRUE(delayHintTest || dataSizeTest);
1036         } else {
1037             // if only one of time delay / data delay is configured, one of them
1038             // holds true by default, so we want both assertions to be true.
1039             ASSERT_TRUE(delayHintTest && dataSizeTest);
1040         }
1041 
1042         ASSERT_TRUE(mFilterTests.stopFilter(filterId));
1043     }
1044 
1045     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
1046     ASSERT_TRUE(mDemuxTests.closeDemux());
1047     ASSERT_TRUE(mFrontendTests.closeFrontend());
1048 }
1049 
TEST_P(TunerFilterAidlTest,FilterDelayHintTest)1050 TEST_P(TunerFilterAidlTest, FilterDelayHintTest) {
1051     description("Test filter time delay hint.");
1052     if (!live.hasFrontendConnection) {
1053         return;
1054     }
1055     for (const auto& obj : filterMap) {
1056         testDelayHint(obj.second);
1057     }
1058 }
1059 
TEST_P(TunerPlaybackAidlTest,PlaybackDataFlowWithTsSectionFilterTest)1060 TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsSectionFilterTest) {
1061     description("Feed ts data from playback and configure Ts section filter to get output");
1062     if (!playback.support) {
1063         return;
1064     }
1065     vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1066     for (auto& configuration : playback_configs) {
1067         if (configuration.sectionFilterId.compare(emptyHardwareId) != 0) {
1068             playback = configuration;
1069             playbackSingleFilterTest(filterMap[playback.sectionFilterId], dvrMap[playback.dvrId]);
1070         }
1071     }
1072 }
1073 
TEST_P(TunerPlaybackAidlTest,PlaybackDataFlowWithTsAudioFilterTest)1074 TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsAudioFilterTest) {
1075     description("Feed ts data from playback and configure Ts audio filter to get output");
1076     if (!playback.support) {
1077         return;
1078     }
1079     vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1080     for (auto& configuration : playback_configs) {
1081         playback = configuration;
1082         playbackSingleFilterTest(filterMap[playback.audioFilterId], dvrMap[playback.dvrId]);
1083     }
1084 }
1085 
TEST_P(TunerPlaybackAidlTest,PlaybackDataFlowWithTsVideoFilterTest)1086 TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsVideoFilterTest) {
1087     description("Feed ts data from playback and configure Ts video filter to get output");
1088     if (!playback.support) {
1089         return;
1090     }
1091     vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1092     for (auto& configuration : playback_configs) {
1093         playback = configuration;
1094         playbackSingleFilterTest(filterMap[playback.videoFilterId], dvrMap[playback.dvrId]);
1095     }
1096 }
1097 
TEST_P(TunerPlaybackAidlTest,SetStatusCheckIntervalHintToPlaybackTest)1098 TEST_P(TunerPlaybackAidlTest, SetStatusCheckIntervalHintToPlaybackTest) {
1099     description("Set status check interval hint to playback test.");
1100     if (!playback.support) {
1101         return;
1102     }
1103     vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1104     for (auto& configuration : playback_configs) {
1105         playback = configuration;
1106         setStatusCheckIntervalHintTest(STATUS_CHECK_INTERVAL_MS, dvrMap[playback.dvrId]);
1107     }
1108 }
1109 
TEST_P(TunerRecordAidlTest,RecordDataFlowWithTsRecordFilterTest)1110 TEST_P(TunerRecordAidlTest, RecordDataFlowWithTsRecordFilterTest) {
1111     description("Feed ts data from frontend to recording and test with ts record filter");
1112     if (!record.support) {
1113         return;
1114     }
1115     // Recording is not currently supported for IPTV frontend
1116     if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
1117         return;
1118     }
1119     auto record_configs = generateRecordConfigurations();
1120     for (auto& configuration : record_configs) {
1121         record = configuration;
1122         recordSingleFilterTest(filterMap[record.recordFilterId], frontendMap[record.frontendId],
1123                                dvrMap[record.dvrRecordId], Dataflow_Context::RECORD);
1124     }
1125 }
1126 
TEST_P(TunerRecordAidlTest,AttachFiltersToRecordTest)1127 TEST_P(TunerRecordAidlTest, AttachFiltersToRecordTest) {
1128     description("Attach a single filter to the record dvr test.");
1129     // TODO use parameterized tests
1130     if (!record.support) {
1131         return;
1132     }
1133     // Recording is not currently supported for IPTV frontend
1134     if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
1135         return;
1136     }
1137     auto record_configs = generateRecordConfigurations();
1138     for (auto& configuration : record_configs) {
1139         record = configuration;
1140         attachSingleFilterToRecordDvrTest(filterMap[record.recordFilterId],
1141                                           frontendMap[record.frontendId],
1142                                           dvrMap[record.dvrRecordId]);
1143     }
1144 }
1145 
TEST_P(TunerRecordAidlTest,LnbRecordDataFlowWithTsRecordFilterTest)1146 TEST_P(TunerRecordAidlTest, LnbRecordDataFlowWithTsRecordFilterTest) {
1147     description("Feed ts data from Fe with Lnb to recording and test with ts record filter");
1148     if (!lnbRecord.support) {
1149         return;
1150     }
1151     vector<LnbRecordHardwareConnections> lnbRecord_configs = generateLnbRecordConfigurations();
1152     if (lnbRecord_configs.empty()) {
1153         ALOGD("No frontends that support satellites.");
1154         return;
1155     }
1156     for (auto& configuration : lnbRecord_configs) {
1157         lnbRecord = configuration;
1158         recordSingleFilterTestWithLnb(filterMap[lnbRecord.recordFilterId],
1159                                       frontendMap[lnbRecord.frontendId],
1160                                       dvrMap[lnbRecord.dvrRecordId], lnbMap[lnbRecord.lnbId]);
1161     }
1162 }
1163 
TEST_P(TunerRecordAidlTest,SetStatusCheckIntervalHintToRecordTest)1164 TEST_P(TunerRecordAidlTest, SetStatusCheckIntervalHintToRecordTest) {
1165     description("Set status check interval hint to record test.");
1166     if (!record.support) {
1167         return;
1168     }
1169     // Recording is not currently supported for IPTV frontend
1170     if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
1171         return;
1172     }
1173     auto record_configs = generateRecordConfigurations();
1174     for (auto& configuration : record_configs) {
1175         record = configuration;
1176         setStatusCheckIntervalHintTest(STATUS_CHECK_INTERVAL_MS, frontendMap[record.frontendId],
1177                                        dvrMap[record.dvrRecordId]);
1178     }
1179 }
1180 
TEST_P(TunerFrontendAidlTest,TuneFrontend)1181 TEST_P(TunerFrontendAidlTest, TuneFrontend) {
1182     description("Tune one Frontend with specific setting and check Lock event");
1183     if (!live.hasFrontendConnection) {
1184         return;
1185     }
1186     auto live_configs = generateLiveConfigurations();
1187     for (auto& configuration : live_configs) {
1188         live = configuration;
1189         mFrontendTests.tuneTest(frontendMap[live.frontendId]);
1190     }
1191 }
1192 
TEST_P(TunerFrontendAidlTest,AutoScanFrontend)1193 TEST_P(TunerFrontendAidlTest, AutoScanFrontend) {
1194     description("Run an auto frontend scan with specific setting and check lock scanMessage");
1195     if (!scan.hasFrontendConnection) {
1196         return;
1197     }
1198     vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1199     for (auto& configuration : scan_configs) {
1200         scan = configuration;
1201         mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_AUTO);
1202     }
1203 }
1204 
TEST_P(TunerFrontendAidlTest,BlindScanFrontend)1205 TEST_P(TunerFrontendAidlTest, BlindScanFrontend) {
1206     description("Run an blind frontend scan with specific setting and check lock scanMessage");
1207     if (!scan.hasFrontendConnection) {
1208         return;
1209     }
1210     // Blind scan is not applicable for IPTV frontend
1211     if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
1212         return;
1213     }
1214     vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1215     for (auto& configuration : scan_configs) {
1216         scan = configuration;
1217         // Skip test if the frontend implementation doesn't support blind scan
1218         if (!frontendMap[scan.frontendId].supportBlindScan) {
1219             continue;
1220         }
1221         mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
1222     }
1223 }
1224 
TEST_P(TunerFrontendAidlTest,TuneFrontendWithFrontendSettings)1225 TEST_P(TunerFrontendAidlTest, TuneFrontendWithFrontendSettings) {
1226     description("Tune one Frontend with setting and check Lock event");
1227     if (!live.hasFrontendConnection) {
1228         return;
1229     }
1230     auto live_configs = generateLiveConfigurations();
1231     for (auto& configuration : live_configs) {
1232         live = configuration;
1233         mFrontendTests.tuneTest(frontendMap[live.frontendId]);
1234     }
1235 }
1236 
TEST_P(TunerFrontendAidlTest,BlindScanFrontendWithEndFrequency)1237 TEST_P(TunerFrontendAidlTest, BlindScanFrontendWithEndFrequency) {
1238     description("Run an blind frontend scan with setting and check lock scanMessage");
1239     if (!scan.hasFrontendConnection) {
1240         return;
1241     }
1242     // Blind scan is not application for IPTV frontend
1243     if (frontendMap[live.frontendId].type == FrontendType::IPTV) {
1244         return;
1245     }
1246     vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1247     for (auto& configuration : scan_configs) {
1248         scan = configuration;
1249         // Skip test if the frontend implementation doesn't support blind scan
1250         if (!frontendMap[scan.frontendId].supportBlindScan) {
1251             continue;
1252         }
1253         mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
1254     }
1255 }
1256 
TEST_P(TunerFrontendAidlTest,LinkToCiCam)1257 TEST_P(TunerFrontendAidlTest, LinkToCiCam) {
1258     description("Test Frontend link to CiCam");
1259     if (!live.hasFrontendConnection) {
1260         return;
1261     }
1262     auto live_configs = generateLiveConfigurations();
1263     for (auto& configuration : live_configs) {
1264         live = configuration;
1265         if (!frontendMap[live.frontendId].canConnectToCiCam) {
1266             continue;
1267         }
1268         mFrontendTests.tuneTest(frontendMap[live.frontendId]);
1269     }
1270 }
1271 
TEST_P(TunerFrontendAidlTest,getHardwareInfo)1272 TEST_P(TunerFrontendAidlTest, getHardwareInfo) {
1273     description("Test Frontend get hardware info");
1274     if (!live.hasFrontendConnection) {
1275         return;
1276     }
1277     auto live_configs = generateLiveConfigurations();
1278     for (auto& configuration : live_configs) {
1279         live = configuration;
1280         mFrontendTests.debugInfoTest(frontendMap[live.frontendId]);
1281     }
1282 }
1283 
TEST_P(TunerFrontendAidlTest,maxNumberOfFrontends)1284 TEST_P(TunerFrontendAidlTest, maxNumberOfFrontends) {
1285     description("Test Max Frontend number");
1286     if (!live.hasFrontendConnection) {
1287         return;
1288     }
1289     mFrontendTests.maxNumberOfFrontendsTest();
1290 }
1291 
TEST_P(TunerFrontendAidlTest,statusReadinessTest)1292 TEST_P(TunerFrontendAidlTest, statusReadinessTest) {
1293     description("Test Max Frontend status readiness");
1294     if (!live.hasFrontendConnection) {
1295         return;
1296     }
1297     auto live_configs = generateLiveConfigurations();
1298     for (auto& configuration : live_configs) {
1299         live = configuration;
1300         mFrontendTests.statusReadinessTest(frontendMap[live.frontendId]);
1301     }
1302 }
1303 
TEST_P(TunerBroadcastAidlTest,BroadcastDataFlowVideoFilterTest)1304 TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowVideoFilterTest) {
1305     description("Test Video Filter functionality in Broadcast use case.");
1306     if (!live.hasFrontendConnection) {
1307         return;
1308     }
1309     auto live_configs = generateLiveConfigurations();
1310     for (auto& configuration : live_configs) {
1311         live = configuration;
1312         broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
1313     }
1314 }
1315 
TEST_P(TunerBroadcastAidlTest,BroadcastDataFlowAudioFilterTest)1316 TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowAudioFilterTest) {
1317     description("Test Audio Filter functionality in Broadcast use case.");
1318     if (!live.hasFrontendConnection) {
1319         return;
1320     }
1321     auto live_configs = generateLiveConfigurations();
1322     for (auto& configuration : live_configs) {
1323         live = configuration;
1324         broadcastSingleFilterTest(filterMap[live.audioFilterId], frontendMap[live.frontendId]);
1325     }
1326 }
1327 
TEST_P(TunerBroadcastAidlTest,BroadcastDataFlowSectionFilterTest)1328 TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowSectionFilterTest) {
1329     description("Test Section Filter functionality in Broadcast use case.");
1330     if (!live.hasFrontendConnection) {
1331         return;
1332     }
1333     auto live_configs = generateLiveConfigurations();
1334     for (auto& configuration : live_configs) {
1335         live = configuration;
1336         if (live.sectionFilterId.compare(emptyHardwareId) == 0) {
1337             continue;
1338         }
1339         broadcastSingleFilterTest(filterMap[live.sectionFilterId], frontendMap[live.frontendId]);
1340     }
1341 }
1342 
TEST_P(TunerBroadcastAidlTest,IonBufferTest)1343 TEST_P(TunerBroadcastAidlTest, IonBufferTest) {
1344     description("Test the av filter data bufferring.");
1345     if (!live.hasFrontendConnection) {
1346         return;
1347     }
1348     auto live_configs = generateLiveConfigurations();
1349     for (auto& configuration : live_configs) {
1350         live = configuration;
1351         broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
1352     }
1353 }
1354 
TEST_P(TunerBroadcastAidlTest,LnbBroadcastDataFlowVideoFilterTest)1355 TEST_P(TunerBroadcastAidlTest, LnbBroadcastDataFlowVideoFilterTest) {
1356     description("Test Video Filter functionality in Broadcast with Lnb use case.");
1357     if (!lnbLive.support) {
1358         return;
1359     }
1360     vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
1361     if (lnbLive_configs.empty()) {
1362         ALOGD("No frontends that support satellites.");
1363         return;
1364     }
1365     for (auto& combination : lnbLive_configs) {
1366         lnbLive = combination;
1367         broadcastSingleFilterTestWithLnb(filterMap[lnbLive.videoFilterId],
1368                                          frontendMap[lnbLive.frontendId], lnbMap[lnbLive.lnbId]);
1369     }
1370 }
1371 
TEST_P(TunerBroadcastAidlTest,MediaFilterWithSharedMemoryHandle)1372 TEST_P(TunerBroadcastAidlTest, MediaFilterWithSharedMemoryHandle) {
1373     description("Test the Media Filter with shared memory handle");
1374     if (!live.hasFrontendConnection) {
1375         return;
1376     }
1377     auto live_configs = generateLiveConfigurations();
1378     for (auto& configuration : live_configs) {
1379         live = configuration;
1380         mediaFilterUsingSharedMemoryTest(filterMap[live.videoFilterId],
1381                                          frontendMap[live.frontendId]);
1382     }
1383 }
1384 
TEST_P(TunerDescramblerAidlTest,CreateDescrambler)1385 TEST_P(TunerDescramblerAidlTest, CreateDescrambler) {
1386     description("Create Descrambler");
1387     if (!descrambling.support) {
1388         return;
1389     }
1390     vector<DescramblingHardwareConnections> descrambling_configs =
1391             generateDescramblingConfigurations();
1392     if (descrambling_configs.empty()) {
1393         ALOGD("No valid descrambling combinations in the configuration file.");
1394         return;
1395     }
1396     for (auto& combination : descrambling_configs) {
1397         descrambling = combination;
1398         int32_t demuxId;
1399         std::shared_ptr<IDemux> demux;
1400         ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
1401 
1402         if (descrambling.hasFrontendConnection) {
1403             int32_t feId;
1404             mFrontendTests.getFrontendIdByType(frontendMap[descrambling.frontendId].type, feId);
1405             ASSERT_TRUE(feId != INVALID_ID);
1406             ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
1407             ASSERT_TRUE(mFrontendTests.setFrontendCallback());
1408             ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
1409         }
1410 
1411         ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
1412         ASSERT_TRUE(mDescramblerTests.closeDescrambler());
1413         ASSERT_TRUE(mDemuxTests.closeDemux());
1414 
1415         if (descrambling.hasFrontendConnection) {
1416             ASSERT_TRUE(mFrontendTests.closeFrontend());
1417         }
1418     }
1419 }
1420 
TEST_P(TunerDescramblerAidlTest,ScrambledBroadcastDataFlowMediaFiltersTest)1421 TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTest) {
1422     description("Test ts audio filter in scrambled broadcast use case");
1423     if (!descrambling.support) {
1424         return;
1425     }
1426     vector<DescramblingHardwareConnections> descrambling_configs =
1427             generateDescramblingConfigurations();
1428     if (descrambling_configs.empty()) {
1429         ALOGD("No valid descrambling combinations in the configuration file.");
1430         return;
1431     }
1432     for (auto& combination : descrambling_configs) {
1433         descrambling = combination;
1434         set<FilterConfig> filterConfs;
1435         filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.audioFilterId]));
1436         filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.videoFilterId]));
1437         scrambledBroadcastTest(filterConfs, frontendMap[descrambling.frontendId],
1438                                descramblerMap[descrambling.descramblerId],
1439                                Dataflow_Context::DESCRAMBLING);
1440     }
1441 }
1442 
TEST_P(TunerDescramblerAidlTest,ScrambledBroadcastDataFlowMediaFiltersTestWithLnb)1443 TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTestWithLnb) {
1444     description("Test media filters in scrambled broadcast use case with Lnb");
1445     if (!lnbDescrambling.support) {
1446         return;
1447     }
1448     auto lnbDescrambling_configs = generateLnbDescramblingConfigurations();
1449     if (lnbDescrambling_configs.empty()) {
1450         ALOGD("No frontends that support satellites.");
1451         return;
1452     }
1453     for (auto& configuration : lnbDescrambling_configs) {
1454         lnbDescrambling = configuration;
1455         set<FilterConfig> filterConfs;
1456         filterConfs.insert(static_cast<FilterConfig>(filterMap[lnbDescrambling.audioFilterId]));
1457         filterConfs.insert(static_cast<FilterConfig>(filterMap[lnbDescrambling.videoFilterId]));
1458         scrambledBroadcastTestWithLnb(filterConfs, frontendMap[lnbDescrambling.frontendId],
1459                                       descramblerMap[lnbDescrambling.descramblerId],
1460                                       lnbMap[lnbDescrambling.lnbId]);
1461     }
1462 }
1463 
1464 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerBroadcastAidlTest,
1465                          testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1466                          android::PrintInstanceNameToString);
1467 
1468 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerFrontendAidlTest,
1469                          testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1470                          android::PrintInstanceNameToString);
1471 
1472 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerFilterAidlTest,
1473                          testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1474                          android::PrintInstanceNameToString);
1475 
1476 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerRecordAidlTest,
1477                          testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1478                          android::PrintInstanceNameToString);
1479 
1480 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerLnbAidlTest,
1481                          testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1482                          android::PrintInstanceNameToString);
1483 
1484 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerDemuxAidlTest,
1485                          testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1486                          android::PrintInstanceNameToString);
1487 
1488 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerPlaybackAidlTest,
1489                          testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1490                          android::PrintInstanceNameToString);
1491 
1492 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerDescramblerAidlTest,
1493                          testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1494                          android::PrintInstanceNameToString);
1495 
1496 }  // namespace
1497 
1498 // Start thread pool to receive callbacks from AIDL service.
main(int argc,char ** argv)1499 int main(int argc, char** argv) {
1500     ::testing::InitGoogleTest(&argc, argv);
1501     ABinderProcess_setThreadPoolMaxThreadCount(1);
1502     ABinderProcess_startThreadPool();
1503     return RUN_ALL_TESTS();
1504 }
1505