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