• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2019 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 package android.mediav2.cts;
18 
19 import static org.junit.Assert.assertTrue;
20 import static org.junit.Assert.fail;
21 
22 import android.content.res.AssetFileDescriptor;
23 import android.media.MediaDataSource;
24 import android.media.MediaExtractor;
25 import android.os.Build;
26 import android.os.ParcelFileDescriptor;
27 import android.util.Log;
28 
29 import androidx.test.filters.SmallTest;
30 
31 import com.android.compatibility.common.util.ApiLevelUtil;
32 import com.android.compatibility.common.util.Preconditions;
33 
34 import org.junit.Ignore;
35 import org.junit.Rule;
36 import org.junit.Test;
37 import org.junit.experimental.runners.Enclosed;
38 import org.junit.rules.TestName;
39 import org.junit.runner.RunWith;
40 
41 import java.io.File;
42 import java.io.FileDescriptor;
43 import java.io.FileOutputStream;
44 import java.io.IOException;
45 import java.nio.ByteBuffer;
46 
47 @RunWith(Enclosed.class)
48 public class ExtractorUnitTest {
49     private static final int MAX_SAMPLE_SIZE = 4 * 1024 * 1024;
50     private static final String MEDIA_DIR = WorkDir.getMediaDirString();
51     private static final String INPUT_MEDIA = "ForBiggerEscapes.mp4";
52     private static final String TAG = "ExtractorUnitTest";
53 
54     private static boolean sIsAtLeastS = ApiLevelUtil.isAtLeast(Build.VERSION_CODES.S);
55 
56     @SmallTest
57     public static class TestApi {
58         @Rule
59         public TestName testName = new TestName();
60 
61         @Test
testGetTrackCountBeforeSetDataSource()62         public void testGetTrackCountBeforeSetDataSource() {
63             MediaExtractor extractor = new MediaExtractor();
64             try {
65                 assertTrue("received valid trackCount before setDataSource",
66                         extractor.getTrackCount() <= 0);
67             } catch (Exception e) {
68                 // expected
69             } finally {
70                 extractor.release();
71             }
72         }
73 
74         @Test
testGetTrackCountAfterRelease()75         public void testGetTrackCountAfterRelease() {
76             MediaExtractor extractor = new MediaExtractor();
77             extractor.release();
78             try {
79                 extractor.getTrackCount();
80                 fail("getTrackCount succeeds after release");
81             } catch (Exception e) {
82                 // expected
83             }
84         }
85 
86         @Test
testSelectTrackBeforeSetDataSource()87         public void testSelectTrackBeforeSetDataSource() {
88             MediaExtractor extractor = new MediaExtractor();
89             try {
90                 extractor.selectTrack(0);
91                 fail("selectTrack succeeds before setDataSource");
92             } catch (Exception e) {
93                 // expected
94             } finally {
95                 extractor.release();
96             }
97         }
98 
99         @Test
testSelectTrackForInvalidIndex()100         public void testSelectTrackForInvalidIndex() throws IOException {
101             MediaExtractor extractor = new MediaExtractor();
102             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
103             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
104             try {
105                 try {
106                     extractor.selectTrack(-1);
107                     fail("selectTrack succeeds for track index: -1");
108                 } catch (Exception e) {
109                     // expected
110                 }
111                 try {
112                     extractor.selectTrack(extractor.getTrackCount());
113                     fail("selectTrack succeeds for out of bounds track index: " +
114                             extractor.getTrackCount());
115                 } catch (Exception e) {
116                     // expected
117                 }
118             } finally {
119                 extractor.release();
120             }
121         }
122 
123         @Test
testIdempotentSelectTrack()124         public void testIdempotentSelectTrack() throws IOException {
125             MediaExtractor extractor = new MediaExtractor();
126             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
127             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
128             try {
129                 extractor.selectTrack(0);
130                 extractor.selectTrack(0);
131             } catch (Exception e) {
132                 fail("multiple selection of same track has failed");
133             } finally {
134                 extractor.release();
135             }
136         }
137 
138         @Test
testSelectTrackAfterRelease()139         public void testSelectTrackAfterRelease() {
140             MediaExtractor extractor = new MediaExtractor();
141             extractor.release();
142             try {
143                 extractor.selectTrack(0);
144                 fail("selectTrack succeeds after release");
145             } catch (Exception e) {
146                 // expected
147             }
148         }
149 
150         @Test
testUnselectTrackBeforeSetDataSource()151         public void testUnselectTrackBeforeSetDataSource() {
152             MediaExtractor extractor = new MediaExtractor();
153             try {
154                 extractor.unselectTrack(0);
155                 fail("unselectTrack succeeds before setDataSource");
156             } catch (Exception e) {
157                 // expected
158             } finally {
159                 extractor.release();
160             }
161         }
162 
163         @Test
testUnselectTrackForInvalidIndex()164         public void testUnselectTrackForInvalidIndex() throws IOException {
165             MediaExtractor extractor = new MediaExtractor();
166             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
167             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
168             try {
169                 try {
170                     extractor.unselectTrack(-1);
171                     fail("unselectTrack succeeds for track index: -1");
172                 } catch (Exception e) {
173                     // expected
174                 }
175                 try {
176                     extractor.unselectTrack(extractor.getTrackCount());
177                     fail("unselectTrack succeeds for out of bounds track index: " +
178                             extractor.getTrackCount());
179                 } catch (Exception e) {
180                     // expected
181                 }
182             } finally {
183                 extractor.release();
184             }
185         }
186 
187         @Test
testUnselectTrackForUnSelectedTrackIndex()188         public void testUnselectTrackForUnSelectedTrackIndex() throws IOException {
189             MediaExtractor extractor = new MediaExtractor();
190             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
191             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
192             try {
193                 extractor.unselectTrack(0);
194             } catch (Exception e) {
195                 fail("un-selection of non-selected track has failed");
196             } finally {
197                 extractor.release();
198             }
199         }
200 
201         @Test
testIdempotentUnselectTrack()202         public void testIdempotentUnselectTrack() throws IOException {
203             MediaExtractor extractor = new MediaExtractor();
204             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
205             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
206             try {
207                 extractor.selectTrack(0);
208                 extractor.unselectTrack(0);
209                 extractor.unselectTrack(0);
210             } catch (Exception e) {
211                 fail("multiple un-selection of selected track has failed");
212             } finally {
213                 extractor.release();
214             }
215         }
216 
217         @Test
testUnselectTrackAfterRelease()218         public void testUnselectTrackAfterRelease() {
219             MediaExtractor extractor = new MediaExtractor();
220             extractor.release();
221             try {
222                 extractor.unselectTrack(0);
223                 fail("unselectTrack succeeds after release");
224             } catch (Exception e) {
225                 // expected
226             }
227         }
228 
229         @Test
testSeekToBeforeSetDataSource()230         public void testSeekToBeforeSetDataSource() {
231             MediaExtractor extractor = new MediaExtractor();
232             try {
233                 extractor.seekTo(33000, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
234                 if (extractor.getSampleTime() != -1 || extractor.getSampleSize() != -1 ||
235                         extractor.getSampleFlags() != -1) {
236                     fail("seekTo() succeeds before setting data source, returns non-negative " +
237                             "sampleTime / sampleSize / sampleFlags");
238                 }
239             } catch (Exception e) {
240                 // expected
241             } finally {
242                 extractor.release();
243             }
244         }
245 
246         @Test
testSeekToBeforeSelectTrack()247         public void testSeekToBeforeSelectTrack() throws IOException {
248             MediaExtractor extractor = new MediaExtractor();
249             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
250             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
251             try {
252                 extractor.seekTo(33000, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
253                 if (extractor.getSampleTime() != -1 || extractor.getSampleSize() != -1 ||
254                         extractor.getSampleFlags() != -1) {
255                     fail("seekTo() succeeds before selectTrack, returns non-negative " +
256                             "sampleTime / sampleSize / sampleFlags");
257                 }
258             } catch (Exception e) {
259                 // expected
260             } finally {
261                 extractor.release();
262             }
263         }
264 
265         @Test
testSeekToForInvalidMode()266         public void testSeekToForInvalidMode() throws IOException {
267             MediaExtractor extractor = new MediaExtractor();
268             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
269             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
270             extractor.selectTrack(0);
271             long pts = 33000;
272             try {
273                 extractor.seekTo(pts, (int) pts);
274                 fail("seekTo() succeeds for invalid mode: " + pts);
275             } catch (Exception e) {
276                 // expected
277             } finally {
278                 extractor.release();
279             }
280         }
281 
282         @Test
testSeekToAfterRelease()283         public void testSeekToAfterRelease() throws IOException {
284             MediaExtractor extractor = new MediaExtractor();
285             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
286             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
287             extractor.release();
288             try {
289                 extractor.seekTo(33000, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
290                 fail("seekTo() succeeds after release");
291             } catch (Exception e) {
292                 // expected
293             }
294         }
295 
296         @Test
297         @Ignore("TODO(b/148205432)")
testGetCachedDurationBeforeSetDataSource()298         public void testGetCachedDurationBeforeSetDataSource() {
299             MediaExtractor extractor = new MediaExtractor();
300             try {
301                 assertTrue("received valid cachedDuration before setDataSource",
302                         extractor.getCachedDuration() == -1);
303             } catch (Exception e) {
304                 // expected
305             } finally {
306                 extractor.release();
307             }
308         }
309 
310         @Test
testGetCachedDurationAfterRelease()311         public void testGetCachedDurationAfterRelease() {
312             MediaExtractor extractor = new MediaExtractor();
313             extractor.release();
314             try {
315                 extractor.getCachedDuration();
316                 fail("cachedDuration succeeds after release");
317             } catch (Exception e) {
318                 // expected
319             }
320         }
321 
322         @Test
323         @Ignore("TODO(b/148204634)")
testHasCacheReachedEOSBeforeSetDataSource()324         public void testHasCacheReachedEOSBeforeSetDataSource() {
325             MediaExtractor extractor = new MediaExtractor();
326             try {
327                 assertTrue("unexpected value received from hasCacheReachedEndOfStream before" +
328                         " setDataSource", !extractor.hasCacheReachedEndOfStream());
329             } catch (Exception e) {
330                 // expected
331             } finally {
332                 extractor.release();
333             }
334         }
335 
336         @Test
testHasCacheReachedEOSAfterRelease()337         public void testHasCacheReachedEOSAfterRelease() {
338             MediaExtractor extractor = new MediaExtractor();
339             extractor.release();
340             try {
341                 extractor.hasCacheReachedEndOfStream();
342                 fail("hasCacheReachedEndOfStream succeeds after release");
343             } catch (Exception e) {
344                 // expected
345             }
346         }
347 
348         @Test
testGetMetricsBeforeSetDataSource()349         public void testGetMetricsBeforeSetDataSource() {
350             MediaExtractor extractor = new MediaExtractor();
351             try {
352                 assertTrue("received valid metrics before setDataSource",
353                         extractor.getMetrics() == null);
354             } catch (Exception e) {
355                 // expected
356             } finally {
357                 extractor.release();
358             }
359         }
360 
361         @Test
testGetMetricsAfterRelease()362         public void testGetMetricsAfterRelease() {
363             MediaExtractor extractor = new MediaExtractor();
364             extractor.release();
365             try {
366                 extractor.getMetrics();
367                 fail("getMetrics() succeeds after release");
368             } catch (Exception e) {
369                 // expected
370             }
371         }
372 
373         @Test
testIdempotentRelease()374         public void testIdempotentRelease() {
375             MediaExtractor extractor = new MediaExtractor();
376             try {
377                 extractor.release();
378                 extractor.release();
379             } catch (Exception e) {
380                 fail(e.getMessage());
381             }
382         }
383 
384         @Test
testAdvanceBeforeSetDataSource()385         public void testAdvanceBeforeSetDataSource() {
386             MediaExtractor extractor = new MediaExtractor();
387             try {
388                 assertTrue("advance succeeds before setDataSource", !extractor.advance());
389             } catch (Exception e) {
390                 // expected
391             } finally {
392                 extractor.release();
393             }
394         }
395 
396         @Test
testAdvanceBeforeSelectTrack()397         public void testAdvanceBeforeSelectTrack() throws IOException {
398             MediaExtractor extractor = new MediaExtractor();
399             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
400             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
401             try {
402                 assertTrue("advance succeeds without any active tracks", !extractor.advance());
403             } catch (Exception e) {
404                 // expected
405             } finally {
406                 extractor.release();
407             }
408         }
409 
410         @Test
testAdvanceAfterRelease()411         public void testAdvanceAfterRelease() {
412             MediaExtractor extractor = new MediaExtractor();
413             extractor.release();
414             try {
415                 extractor.advance();
416                 fail("advance succeeds after release");
417             } catch (Exception e) {
418                 // expected
419             }
420         }
421 
422         @Test
testGetSampleFlagsBeforeSetDataSource()423         public void testGetSampleFlagsBeforeSetDataSource() {
424             MediaExtractor extractor = new MediaExtractor();
425             try {
426                 assertTrue("received valid sampleFlag before setDataSource",
427                         extractor.getSampleFlags() == -1);
428             } catch (Exception e) {
429                 // expected
430             } finally {
431                 extractor.release();
432             }
433         }
434 
435         @Test
testGetSampleFlagsBeforeSelectTrack()436         public void testGetSampleFlagsBeforeSelectTrack() throws IOException {
437             MediaExtractor extractor = new MediaExtractor();
438             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
439             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
440             try {
441                 assertTrue("received valid sampleFlag without any active tracks",
442                         extractor.getSampleFlags() == -1);
443             } catch (Exception e) {
444                 // expected
445             } finally {
446                 extractor.release();
447             }
448         }
449 
450         @Test
testGetSampleFlagsAfterRelease()451         public void testGetSampleFlagsAfterRelease() {
452             MediaExtractor extractor = new MediaExtractor();
453             extractor.release();
454             try {
455                 extractor.getSampleFlags();
456                 fail("getSampleFlags succeeds after release");
457             } catch (Exception e) {
458                 // expected
459             }
460         }
461 
462         @Test
testGetSampleTimeBeforeSetDataSource()463         public void testGetSampleTimeBeforeSetDataSource() {
464             MediaExtractor extractor = new MediaExtractor();
465             try {
466                 assertTrue("received valid sampleTime before setDataSource",
467                         extractor.getSampleTime() == -1);
468             } catch (Exception e) {
469                 // expected
470             } finally {
471                 extractor.release();
472             }
473         }
474 
475         @Test
testGetSampleTimeBeforeSelectTrack()476         public void testGetSampleTimeBeforeSelectTrack() throws IOException {
477             MediaExtractor extractor = new MediaExtractor();
478             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
479             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
480             try {
481                 assertTrue("received valid sampleTime without any active tracks",
482                         extractor.getSampleTime() == -1);
483             } catch (Exception e) {
484                 // expected
485             } finally {
486                 extractor.release();
487             }
488         }
489 
490         @Test
testGetSampleTimeAfterRelease()491         public void testGetSampleTimeAfterRelease() {
492             MediaExtractor extractor = new MediaExtractor();
493             extractor.release();
494             try {
495                 extractor.getSampleTime();
496                 fail("getSampleTime succeeds after release");
497             } catch (Exception e) {
498                 // expected
499             }
500         }
501 
502         @Test
testGetSampleSizeBeforeSetDataSource()503         public void testGetSampleSizeBeforeSetDataSource() {
504             MediaExtractor extractor = new MediaExtractor();
505             try {
506                 assertTrue("received valid sampleSize before setDataSource",
507                         extractor.getSampleSize() == -1);
508             } catch (Exception e) {
509                 // expected
510             } finally {
511                 extractor.release();
512             }
513         }
514 
515         @Test
testGetSampleSizeBeforeSelectTrack()516         public void testGetSampleSizeBeforeSelectTrack() throws IOException {
517             MediaExtractor extractor = new MediaExtractor();
518             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
519             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
520             try {
521                 assertTrue("received valid sampleSize without any active tracks",
522                         extractor.getSampleSize() == -1);
523             } catch (Exception e) {
524                 // expected
525             } finally {
526                 extractor.release();
527             }
528         }
529 
530         @Test
testGetSampleSizeAfterRelease()531         public void testGetSampleSizeAfterRelease() {
532             MediaExtractor extractor = new MediaExtractor();
533             extractor.release();
534             try {
535                 extractor.getSampleSize();
536                 fail("getSampleSize succeeds after release");
537             } catch (Exception e) {
538                 // expected
539             }
540         }
541 
542         @Test
testGetSampleTrackIndexBeforeSetDataSource()543         public void testGetSampleTrackIndexBeforeSetDataSource() {
544             MediaExtractor extractor = new MediaExtractor();
545             try {
546                 assertTrue("received valid sampleTrackIndex before setDataSource",
547                         extractor.getSampleTrackIndex() == -1);
548             } catch (Exception e) {
549                 // expected
550             } finally {
551                 extractor.release();
552             }
553         }
554 
555         @Test
testGetSampleTrackIndexBeforeSelectTrack()556         public void testGetSampleTrackIndexBeforeSelectTrack() throws IOException {
557             MediaExtractor extractor = new MediaExtractor();
558             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
559             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
560             try {
561                 assertTrue("received valid sampleTrackIndex without any active tracks",
562                         extractor.getSampleTrackIndex() == -1);
563             } catch (Exception e) {
564                 // expected
565             } finally {
566                 extractor.release();
567             }
568         }
569 
570         @Test
testGetSampleTrackIndexAfterRelease()571         public void testGetSampleTrackIndexAfterRelease() {
572             MediaExtractor extractor = new MediaExtractor();
573             extractor.release();
574             try {
575                 extractor.getSampleTrackIndex();
576                 fail("getSampleTrackIndex succeeds after release");
577             } catch (Exception e) {
578                 // expected
579             }
580         }
581 
582         @Test
testGetTrackFormatBeforeSetDataSource()583         public void testGetTrackFormatBeforeSetDataSource() {
584             MediaExtractor extractor = new MediaExtractor();
585             try {
586                 extractor.getTrackFormat(0);
587                 fail("getTrackFormat succeeds before setDataSource");
588             } catch (Exception e) {
589                 // expected
590             } finally {
591                 extractor.release();
592             }
593         }
594 
595         @Test
testGetTrackFormatForInvalidIndex()596         public void testGetTrackFormatForInvalidIndex() throws IOException {
597             MediaExtractor extractor = new MediaExtractor();
598             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
599             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
600             try {
601                 try {
602                     extractor.getTrackFormat(-1);
603                     fail("getTrackFormat succeeds for track index: -1");
604                 } catch (Exception e) {
605                     // expected
606                 }
607                 try {
608                     extractor.getTrackFormat(extractor.getTrackCount());
609                     fail("getTrackFormat succeeds for out of bounds track index: " +
610                             extractor.getTrackCount());
611                 } catch (Exception e) {
612                     // expected
613                 }
614             } finally {
615                 extractor.release();
616             }
617         }
618 
619         @Test
testGetTrackFormatAfterRelease()620         public void testGetTrackFormatAfterRelease() {
621             MediaExtractor extractor = new MediaExtractor();
622             extractor.release();
623             try {
624                 extractor.getTrackFormat(0);
625                 fail("getTrackFormat succeeds after release");
626             } catch (Exception e) {
627                 // expected
628             }
629         }
630 
631         @Test
testReadSampleDataBeforeSetDataSource()632         public void testReadSampleDataBeforeSetDataSource() {
633             MediaExtractor extractor = new MediaExtractor();
634             ByteBuffer byteBuffer = ByteBuffer.allocate(MAX_SAMPLE_SIZE);
635             try {
636                 assertTrue("readSampleData returns val >= 0 before setDataSource",
637                         extractor.readSampleData(byteBuffer, 0) < 0);
638             } catch (Exception e) {
639                 // expected
640             } finally {
641                 extractor.release();
642             }
643         }
644 
645         @Test
testReadSampleDataBeforeSelectTrack()646         public void testReadSampleDataBeforeSelectTrack() throws IOException {
647             MediaExtractor extractor = new MediaExtractor();
648             ByteBuffer byteBuffer = ByteBuffer.allocate(MAX_SAMPLE_SIZE);
649             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
650             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
651             try {
652                 assertTrue("readSampleData returns val >= 0 without any active tracks",
653                         extractor.readSampleData(byteBuffer, 0) < 0);
654             } catch (Exception e) {
655                 // expected
656             } finally {
657                 extractor.release();
658             }
659         }
660 
661         @Test
testIfInvalidOffsetIsRejectedByReadSampleData()662         public void testIfInvalidOffsetIsRejectedByReadSampleData() throws IOException {
663             MediaExtractor extractor = new MediaExtractor();
664             ByteBuffer byteBuffer = ByteBuffer.allocate(MAX_SAMPLE_SIZE);
665             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
666             extractor.setDataSource(MEDIA_DIR + INPUT_MEDIA);
667             extractor.selectTrack(0);
668             try {
669                 // readSampleData with negative offset
670                 try {
671                     extractor.readSampleData(byteBuffer, -1);
672                     fail("readSampleData succeeds with negative offset");
673                 } catch (Exception e) {
674                     // expected
675                 }
676 
677                 // readSampleData with byteBuffer's capacity - offset < frame size
678                 int sampleSize = (int) extractor.getSampleSize();
679                 try {
680                     extractor.readSampleData(byteBuffer, MAX_SAMPLE_SIZE - sampleSize + 1);
681                     fail("readSampleData succeeds when available size of byteBuffer is less than " +
682                             "frame size");
683                 } catch (Exception e) {
684                     // expected
685                 }
686             } finally {
687                 extractor.release();
688             }
689         }
690 
691         @Test
testReadSampleDataAfterRelease()692         public void testReadSampleDataAfterRelease() {
693             MediaExtractor extractor = new MediaExtractor();
694             ByteBuffer byteBuffer = ByteBuffer.allocate(MAX_SAMPLE_SIZE);
695             extractor.release();
696             try {
697                 extractor.readSampleData(byteBuffer, 0);
698                 fail("readSampleData succeeds after release");
699             } catch (Exception e) {
700                 // expected
701             }
702         }
703 
704         @Test
testIfInvalidDataSourceIsRejectedBySetDataSource()705         public void testIfInvalidDataSourceIsRejectedBySetDataSource() throws IOException {
706             MediaExtractor extractor = new MediaExtractor();
707             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
708             TestMediaDataSource dataSource =
709                     TestMediaDataSource.fromString(MEDIA_DIR + INPUT_MEDIA, false, true);
710             try {
711                 extractor.setDataSource(dataSource);
712                 fail("setDataSource succeeds with malformed media data source");
713             } catch (Exception e) {
714                 // expected
715             } finally {
716                 assertTrue(dataSource.isClosed());
717                 extractor.release();
718             }
719         }
720 
721         @Test
testIfNullFDIsRejectedBySetDataSource()722         public void testIfNullFDIsRejectedBySetDataSource() {
723             MediaExtractor extractor = new MediaExtractor();
724             try {
725                 extractor.setDataSource((FileDescriptor) null);
726                 fail("setDataSource succeeds with null fd");
727             } catch (Exception e) {
728                 // expected
729             } finally {
730                 extractor.release();
731             }
732         }
733 
734         @Test
testIfWriteOnlyAssetFDIsRejectedBySetDataSource()735         public void testIfWriteOnlyAssetFDIsRejectedBySetDataSource() throws IOException {
736             File inpFile = File.createTempFile("ExtractorTestApisetDSAFD", ".in");
737             MediaExtractor extractor = new MediaExtractor();
738             try (ParcelFileDescriptor parcelFD = ParcelFileDescriptor
739                     .open(inpFile, ParcelFileDescriptor.MODE_WRITE_ONLY);
740                  AssetFileDescriptor afd = new AssetFileDescriptor(parcelFD, 0,
741                          AssetFileDescriptor.UNKNOWN_LENGTH)) {
742                 extractor.setDataSource(afd);
743                 fail("setDataSource succeeds write only afd");
744             } catch (Exception e) {
745                 // expected
746             } finally {
747                 extractor.release();
748             }
749             inpFile.delete();
750         }
751 
752         @Test
testIfWriteOnlyFDIsRejectedBySetDataSource()753         public void testIfWriteOnlyFDIsRejectedBySetDataSource() throws IOException {
754             MediaExtractor extractor = new MediaExtractor();
755             File inpFile = File.createTempFile("ExtractorTestApisetDSFD", ".in");
756             try (FileOutputStream fOut = new FileOutputStream(inpFile)) {
757                 extractor.setDataSource(fOut.getFD());
758                 fail("setDataSource succeeds write only fd");
759             } catch (Exception e) {
760                 // expected
761             } finally {
762                 extractor.release();
763             }
764             inpFile.delete();
765         }
766 
767         @Test
testIfNullMediaDataSourceIsRejectedBySetDataSource()768         public void testIfNullMediaDataSourceIsRejectedBySetDataSource() {
769             MediaExtractor extractor = new MediaExtractor();
770             try {
771                 extractor.setDataSource((MediaDataSource) null);
772                 fail("setDataSource succeeds with null data source");
773             } catch (Exception e) {
774                 // expected
775             } finally {
776                 extractor.release();
777             }
778         }
779 
780         @Test
testIfNullFileIsRejectedBySetDataSource()781         public void testIfNullFileIsRejectedBySetDataSource() {
782             MediaExtractor extractor = new MediaExtractor();
783             try {
784                 extractor.setDataSource((String) null);
785                 fail("setDataSource succeeds with null file path");
786             } catch (Exception e) {
787                 // expected
788             } finally {
789                 extractor.release();
790             }
791         }
792 
793         @Test
testIfNullAssetFDIsRejectedBySetDataSource()794         public void testIfNullAssetFDIsRejectedBySetDataSource() {
795             MediaExtractor extractor = new MediaExtractor();
796             try {
797                 extractor.setDataSource((AssetFileDescriptor) null);
798                 fail("setDataSource succeeds with null asset fd");
799             } catch (Exception e) {
800                 // expected
801             } finally {
802                 extractor.release();
803             }
804         }
805     }
806 
807     @SmallTest
808     public static class TestApiNative {
809         @Rule
810         public TestName testName = new TestName();
811 
812         static {
813             System.loadLibrary("ctsmediav2extractor_jni");
814         }
815 
816         @Test
testGetTrackCountBeforeSetDataSource()817         public void testGetTrackCountBeforeSetDataSource() {
818             assertTrue(nativeTestGetTrackCountBeforeSetDataSource());
819         }
nativeTestGetTrackCountBeforeSetDataSource()820         private native boolean nativeTestGetTrackCountBeforeSetDataSource();
821 
822         @Test
testSelectTrackBeforeSetDataSource()823         public void testSelectTrackBeforeSetDataSource() {
824             assertTrue(nativeTestSelectTrackBeforeSetDataSource());
825         }
nativeTestSelectTrackBeforeSetDataSource()826         private native boolean nativeTestSelectTrackBeforeSetDataSource();
827 
828         @Test
testSelectTrackForInvalidIndex()829         public void testSelectTrackForInvalidIndex() {
830             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
831             assertTrue(nativeTestSelectTrackForInvalidIndex(MEDIA_DIR + INPUT_MEDIA));
832         }
nativeTestSelectTrackForInvalidIndex(String srcPath)833         private native boolean nativeTestSelectTrackForInvalidIndex(String srcPath);
834 
835         @Test
testIdempotentSelectTrack()836         public void testIdempotentSelectTrack() {
837             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
838             assertTrue(nativeTestIdempotentSelectTrack(MEDIA_DIR + INPUT_MEDIA));
839         }
nativeTestIdempotentSelectTrack(String srcPath)840         private native boolean nativeTestIdempotentSelectTrack(String srcPath);
841 
842         @Test
testUnselectTrackBeforeSetDataSource()843         public void testUnselectTrackBeforeSetDataSource() {
844             assertTrue(nativeTestUnselectTrackBeforeSetDataSource());
845         }
nativeTestUnselectTrackBeforeSetDataSource()846         private native boolean nativeTestUnselectTrackBeforeSetDataSource();
847 
848         @Test
testUnselectTrackForInvalidIndex()849         public void testUnselectTrackForInvalidIndex() {
850             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
851             assertTrue(nativeTestUnselectTrackForInvalidIndex(MEDIA_DIR + INPUT_MEDIA));
852         }
nativeTestUnselectTrackForInvalidIndex(String srcPath)853         private native boolean nativeTestUnselectTrackForInvalidIndex(String srcPath);
854 
855         @Test
testUnselectTrackForUnSelectedTrackIndex()856         public void testUnselectTrackForUnSelectedTrackIndex() {
857             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
858             assertTrue(nativeTestUnselectTrackForUnSelectedTrackIndex(MEDIA_DIR + INPUT_MEDIA));
859         }
nativeTestUnselectTrackForUnSelectedTrackIndex(String srcPath)860         private native boolean nativeTestUnselectTrackForUnSelectedTrackIndex(String srcPath);
861 
862         @Test
testIdempotentUnselectTrack()863         public void testIdempotentUnselectTrack() {
864             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
865             assertTrue(nativeTestIdempotentUnselectTrack(MEDIA_DIR + INPUT_MEDIA));
866         }
nativeTestIdempotentUnselectTrack(String srcPath)867         private native boolean nativeTestIdempotentUnselectTrack(String srcPath);
868 
869         @Test
testSeekToBeforeSetDataSource()870         public void testSeekToBeforeSetDataSource() {
871             assertTrue(nativeTestSeekToBeforeSetDataSource());
872         }
nativeTestSeekToBeforeSetDataSource()873         private native boolean nativeTestSeekToBeforeSetDataSource();
874 
875         @Test
testSeekToBeforeSelectTrack()876         public void testSeekToBeforeSelectTrack() {
877             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
878             assertTrue(nativeTestSeekToBeforeSelectTrack(MEDIA_DIR + INPUT_MEDIA));
879         }
nativeTestSeekToBeforeSelectTrack(String srcPath)880         private native boolean nativeTestSeekToBeforeSelectTrack(String srcPath);
881 
882         @Test
883         @Ignore("TODO(b/148205432)")
testGetCachedDurationBeforeSetDataSource()884         public void testGetCachedDurationBeforeSetDataSource() {
885             assertTrue(nativeTestGetCachedDurationBeforeSetDataSource());
886         }
nativeTestGetCachedDurationBeforeSetDataSource()887         private native boolean nativeTestGetCachedDurationBeforeSetDataSource();
888 
889         @Test
testIfGetFileFormatSucceedsBeforeSetDataSource()890         public void testIfGetFileFormatSucceedsBeforeSetDataSource() {
891             assertTrue(nativeTestIfGetFileFormatSucceedsBeforeSetDataSource());
892         }
nativeTestIfGetFileFormatSucceedsBeforeSetDataSource()893         private native boolean nativeTestIfGetFileFormatSucceedsBeforeSetDataSource();
894 
895         @Test
testAdvanceBeforeSetDataSource()896         public void testAdvanceBeforeSetDataSource() {
897             assertTrue(nativeTestAdvanceBeforeSetDataSource());
898         }
nativeTestAdvanceBeforeSetDataSource()899         private native boolean nativeTestAdvanceBeforeSetDataSource();
900 
901         @Test
testAdvanceBeforeSelectTrack()902         public void testAdvanceBeforeSelectTrack() {
903             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
904             assertTrue(nativeTestAdvanceBeforeSelectTrack(MEDIA_DIR + INPUT_MEDIA));
905         }
nativeTestAdvanceBeforeSelectTrack(String srcPath)906         private native boolean nativeTestAdvanceBeforeSelectTrack(String srcPath);
907 
908         @Test
testGetSampleFlagsBeforeSetDataSource()909         public void testGetSampleFlagsBeforeSetDataSource() {
910             assertTrue(nativeTestGetSampleFlagsBeforeSetDataSource());
911         }
nativeTestGetSampleFlagsBeforeSetDataSource()912         private native boolean nativeTestGetSampleFlagsBeforeSetDataSource();
913 
914         @Test
testGetSampleFlagsBeforeSelectTrack()915         public void testGetSampleFlagsBeforeSelectTrack() {
916             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
917             assertTrue(nativeTestGetSampleFlagsBeforeSelectTrack(MEDIA_DIR + INPUT_MEDIA));
918         }
nativeTestGetSampleFlagsBeforeSelectTrack(String srcPath)919         private native boolean nativeTestGetSampleFlagsBeforeSelectTrack(String srcPath);
920 
921         @Test
testGetSampleTimeBeforeSetDataSource()922         public void testGetSampleTimeBeforeSetDataSource() {
923             assertTrue(nativeTestGetSampleTimeBeforeSetDataSource());
924         }
nativeTestGetSampleTimeBeforeSetDataSource()925         private native boolean nativeTestGetSampleTimeBeforeSetDataSource();
926 
927         @Test
testGetSampleTimeBeforeSelectTrack()928         public void testGetSampleTimeBeforeSelectTrack() {
929             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
930             assertTrue(nativeTestGetSampleTimeBeforeSelectTrack(MEDIA_DIR + INPUT_MEDIA));
931         }
nativeTestGetSampleTimeBeforeSelectTrack(String srcPath)932         private native boolean nativeTestGetSampleTimeBeforeSelectTrack(String srcPath);
933 
934         @Test
testGetSampleSizeBeforeSetDataSource()935         public void testGetSampleSizeBeforeSetDataSource() {
936             assertTrue(nativeTestGetSampleSizeBeforeSetDataSource());
937         }
nativeTestGetSampleSizeBeforeSetDataSource()938         private native boolean nativeTestGetSampleSizeBeforeSetDataSource();
939 
940         @Test
testGetSampleSizeBeforeSelectTrack()941         public void testGetSampleSizeBeforeSelectTrack() {
942             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
943             assertTrue(nativeTestGetSampleSizeBeforeSelectTrack(MEDIA_DIR + INPUT_MEDIA));
944         }
nativeTestGetSampleSizeBeforeSelectTrack(String srcPath)945         private native boolean nativeTestGetSampleSizeBeforeSelectTrack(String srcPath);
946 
947         @Test
testIfGetSampleFormatBeforeSetDataSource()948         public void testIfGetSampleFormatBeforeSetDataSource() {
949             assertTrue(nativeTestIfGetSampleFormatBeforeSetDataSource());
950         }
nativeTestIfGetSampleFormatBeforeSetDataSource()951         private native boolean nativeTestIfGetSampleFormatBeforeSetDataSource();
952 
953         @Test
testIfGetSampleFormatBeforeSelectTrack()954         public void testIfGetSampleFormatBeforeSelectTrack() {
955             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
956             assertTrue(nativeTestIfGetSampleFormatBeforeSelectTrack(MEDIA_DIR + INPUT_MEDIA));
957         }
nativeTestIfGetSampleFormatBeforeSelectTrack(String srcPath)958         private native boolean nativeTestIfGetSampleFormatBeforeSelectTrack(String srcPath);
959 
960         @Test
testGetSampleTrackIndexBeforeSetDataSource()961         public void testGetSampleTrackIndexBeforeSetDataSource() {
962             assertTrue(nativeTestGetSampleTrackIndexBeforeSetDataSource());
963         }
nativeTestGetSampleTrackIndexBeforeSetDataSource()964         private native boolean nativeTestGetSampleTrackIndexBeforeSetDataSource();
965 
966         @Test
testGetSampleTrackIndexBeforeSelectTrack()967         public void testGetSampleTrackIndexBeforeSelectTrack() {
968             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
969             assertTrue(
970                     nativeTestGetSampleTrackIndexBeforeSelectTrack(MEDIA_DIR + INPUT_MEDIA));
971         }
nativeTestGetSampleTrackIndexBeforeSelectTrack(String srcPath)972         private native boolean nativeTestGetSampleTrackIndexBeforeSelectTrack(String srcPath);
973 
974         @Test
testGetTrackFormatBeforeSetDataSource()975         public void testGetTrackFormatBeforeSetDataSource() {
976             assertTrue(nativeTestGetTrackFormatBeforeSetDataSource());
977         }
nativeTestGetTrackFormatBeforeSetDataSource()978         private native boolean nativeTestGetTrackFormatBeforeSetDataSource();
979 
980         @Test
testGetTrackFormatForInvalidIndex()981         public void testGetTrackFormatForInvalidIndex() {
982             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
983             assertTrue(nativeTestGetTrackFormatForInvalidIndex(MEDIA_DIR + INPUT_MEDIA));
984         }
nativeTestGetTrackFormatForInvalidIndex(String srcPath)985         private native boolean nativeTestGetTrackFormatForInvalidIndex(String srcPath);
986 
987         @Test
testReadSampleDataBeforeSetDataSource()988         public void testReadSampleDataBeforeSetDataSource() {
989             assertTrue(nativeTestReadSampleDataBeforeSetDataSource());
990         }
nativeTestReadSampleDataBeforeSetDataSource()991         private native boolean nativeTestReadSampleDataBeforeSetDataSource();
992 
993         @Test
testReadSampleDataBeforeSelectTrack()994         public void testReadSampleDataBeforeSelectTrack() {
995             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
996             assertTrue(nativeTestReadSampleDataBeforeSelectTrack(MEDIA_DIR + INPUT_MEDIA));
997         }
nativeTestReadSampleDataBeforeSelectTrack(String srcPath)998         private native boolean nativeTestReadSampleDataBeforeSelectTrack(String srcPath);
999 
1000         @Test
testIfNullLocationIsRejectedBySetDataSource()1001         public void testIfNullLocationIsRejectedBySetDataSource() {
1002             assertTrue(nativeTestIfNullLocationIsRejectedBySetDataSource());
1003         }
nativeTestIfNullLocationIsRejectedBySetDataSource()1004         private native boolean nativeTestIfNullLocationIsRejectedBySetDataSource();
1005 
1006         @Test
testVideoSampleFileOffsetByGetSampleFormat()1007         public void testVideoSampleFileOffsetByGetSampleFormat() {
1008             if (!sIsAtLeastS) {
1009                 Log.d(TAG, "testVideoSampleFileOffsetByGetSampleFormat requires Android 12");
1010                 return;
1011             }
1012             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
1013             assertTrue(nativeTestVideoSampleFileOffsetByGetSampleFormat(MEDIA_DIR + INPUT_MEDIA));
1014         }
nativeTestVideoSampleFileOffsetByGetSampleFormat(String srcPath)1015         private native boolean nativeTestVideoSampleFileOffsetByGetSampleFormat(String srcPath);
1016 
1017         @Test
testAudioSampleFileOffsetByGetSampleFormat()1018         public void testAudioSampleFileOffsetByGetSampleFormat() {
1019             if (!sIsAtLeastS) {
1020                 Log.d(TAG, "testAudioSampleFileOffsetByGetSampleFormat requires Android 12");
1021                 return;
1022             }
1023             Preconditions.assertTestFileExists(MEDIA_DIR + INPUT_MEDIA);
1024             assertTrue(nativeTestAudioSampleFileOffsetByGetSampleFormat(MEDIA_DIR + INPUT_MEDIA));
1025         }
nativeTestAudioSampleFileOffsetByGetSampleFormat(String srcPath)1026         private native boolean nativeTestAudioSampleFileOffsetByGetSampleFormat(String srcPath);
1027     }
1028 }
1029