diff --git a/OWNERS b/OWNERS
index 8771ccd..adb9461 100644
--- a/OWNERS
+++ b/OWNERS
@@ -12,6 +12,6 @@
 
 # Android EngProd Approvers
 wenshan@google.com
-guangzhu@google.com
-jdesprez@google.com
+guangzhu@google.com #{LAST_RESORT_SUGGESTION}
+jdesprez@google.com #{LAST_RESORT_SUGGESTION}
 normancheung@google.com #{LAST_RESORT_SUGGESTION}
\ No newline at end of file
diff --git a/apps/CtsVerifier/AndroidManifest.xml b/apps/CtsVerifier/AndroidManifest.xml
index e357e8f..2001b7b 100644
--- a/apps/CtsVerifier/AndroidManifest.xml
+++ b/apps/CtsVerifier/AndroidManifest.xml
@@ -5445,6 +5445,7 @@
                 <category android:name="android.cts.intent.category.MANUAL_TEST" />
             </intent-filter>
             <meta-data android:name="test_category" android:value="@string/test_category_audio" />
+            <meta-data android:name="test_required_features" android:value="android.hardware.hdmi.cec" />
             <meta-data android:name="display_mode" android:value="multi_display_mode" />
             <meta-data android:name="ApiTest"
                 android:value="android.media.AudioDescriptor#getStandard|
diff --git a/common/device-side/util-axt/src/com/android/compatibility/common/util/OWNERS b/common/device-side/util-axt/src/com/android/compatibility/common/util/OWNERS
index 2e17a8c..209ce99 100644
--- a/common/device-side/util-axt/src/com/android/compatibility/common/util/OWNERS
+++ b/common/device-side/util-axt/src/com/android/compatibility/common/util/OWNERS
@@ -1,6 +1,9 @@
 per-file AmMonitor.java = file:platform/frameworks/base:/services/core/java/com/android/server/am/OWNERS
 per-file AnrMonitor.java = file:platform/frameworks/base:/services/core/java/com/android/server/am/OWNERS
 per-file BaseDefaultPermissionGrantPolicyTest.java = file:platform/frameworks/base:/core/java/android/permission/DEFAULT_PERMISSION_GRANT_POLICY_OWNERS
+per-file CtsKeyEventUtil.java = file:platform/cts:/tests/tests/widget/OWNERS
+per-file CtsMouseUtil.java = file:platform/cts:/tests/tests/widget/OWNERS
+per-file CtsTouchUtils.java = file:platform/cts:/tests/tests/widget/OWNERS
 per-file ReadElf.java = enh@google.com
 per-file *Settings*.java = felipeal@google.com
 per-file User*Helper*.java = felipeal@google.com
diff --git a/hostsidetests/incident/AndroidTest.xml b/hostsidetests/incident/AndroidTest.xml
index 727277d..73be7b4 100644
--- a/hostsidetests/incident/AndroidTest.xml
+++ b/hostsidetests/incident/AndroidTest.xml
@@ -20,9 +20,6 @@
     <option name="config-descriptor:metadata" key="parameter" value="multi_abi" />
     <option name="config-descriptor:metadata" key="parameter" value="not_secondary_user" />
     <option name="config-descriptor:metadata" key="parameter" value="no_foldable_states" />
-    <target_preparer class="com.android.tradefed.targetprep.SwitchUserTargetPreparer">
-        <option name="user-type" value="system" />
-    </target_preparer>
     <test class="com.android.compatibility.common.tradefed.testtype.JarHostTest" >
         <option name="jar" value="CtsIncidentHostTestCases.jar" />
     </test>
diff --git a/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityFingerprintGestureTest.java b/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityFingerprintGestureTest.java
index e36d1ee..64cc0f1 100644
--- a/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityFingerprintGestureTest.java
+++ b/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityFingerprintGestureTest.java
@@ -18,6 +18,7 @@
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
@@ -90,9 +91,10 @@
 
     @Test
     public void testGestureDetectionListener_whenAuthenticationStartsAndStops_calledBack() {
-        if (!mFingerprintGestureController.isGestureDetectionAvailable()) {
-            return;
-        }
+        assumeTrue("Fingerprint gesture detection is not available",
+                mFingerprintGestureController.isGestureDetectionAvailable());
+        assumeTrue("No enrolled fingerprints; cannot open fingerprint prompt",
+                mFingerprintManager.hasEnrolledFingerprints());
         // Launch an activity to make sure we're in the foreground
         mActivityRule.launchActivity(null);
         mFingerprintGestureController.registerFingerprintGestureCallback(
diff --git a/tests/autofillservice/res/layout/scrollable_login_activity.xml b/tests/autofillservice/res/layout/scrollable_login_activity.xml
new file mode 100644
index 0000000..dfa5227
--- /dev/null
+++ b/tests/autofillservice/res/layout/scrollable_login_activity.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:focusable="true"
+    android:focusableInTouchMode="true"
+    android:orientation="vertical" >
+
+    <ScrollView android:layout_width="match_parent"
+                android:layout_height="wrap_content" >
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content" >
+
+            <include layout="@layout/login_activity" />
+
+        </LinearLayout>
+
+    </ScrollView>
+
+</LinearLayout>
diff --git a/tests/autofillservice/src/android/autofillservice/cts/SessionLifecycleTest.java b/tests/autofillservice/src/android/autofillservice/cts/SessionLifecycleTest.java
index 7f5e8d3..e8a58bd 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/SessionLifecycleTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/SessionLifecycleTest.java
@@ -542,10 +542,9 @@
         // It works fine for portrait but for the platforms that the default orientation
         // is landscape, e.g. automotive. Depending on the height of the IME, the ID_LOGIN
         // button may not be visible.
-        // In order to avoid that,
-        // generate back key event to hide IME before pressing ID_LOGIN button.
-        mUiBot.pressBack();
 
+        // In order to avoid that, scroll until the ID_LOGIN button appears.
+        mUiBot.scrollToTextObject(ID_LOGIN);
         mUiBot.selectByRelativeId(ID_LOGIN);
         mUiBot.assertSaveShowing(SAVE_DATA_TYPE_USERNAME);
 
diff --git a/tests/autofillservice/src/android/autofillservice/cts/activities/OutOfProcessLoginActivity.java b/tests/autofillservice/src/android/autofillservice/cts/activities/OutOfProcessLoginActivity.java
index 4cab12c..ca91090 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/activities/OutOfProcessLoginActivity.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/activities/OutOfProcessLoginActivity.java
@@ -41,7 +41,7 @@
         Log.i(TAG, "onCreate(" + savedInstanceState + ")");
         super.onCreate(savedInstanceState);
 
-        setContentView(R.layout.login_activity);
+        setContentView(R.layout.scrollable_login_activity);
 
         findViewById(R.id.login).setOnClickListener((v) -> finish());
 
diff --git a/tests/framework/base/windowmanager/src/android/server/wm/KeepClearRectsTests.java b/tests/framework/base/windowmanager/src/android/server/wm/KeepClearRectsTests.java
index 55eae8c..81173bb 100644
--- a/tests/framework/base/windowmanager/src/android/server/wm/KeepClearRectsTests.java
+++ b/tests/framework/base/windowmanager/src/android/server/wm/KeepClearRectsTests.java
@@ -361,6 +361,7 @@
 
         final Rect keepClearRect = new Rect(0, 0, 25, 25);
         final View v = createTestViewInActivity(activity, keepClearRect);
+        final List<Rect> prevKeepClearRectsOnDisplay = getKeepClearRectsOnDefaultDisplay();
         mTestSession.runOnMainSyncAndWait(() -> v.setPreferKeepClear(true));
         assertSameElementsEventually(Arrays.asList(keepClearRect),
                 () -> getKeepClearRectsForActivity(activity));
@@ -372,15 +373,16 @@
         assertSameElementsEventually(TEST_KEEP_CLEAR_RECTS,
                 () -> getKeepClearRectsForActivity(activity));
 
-        final List<Rect> expectedRectsInScreenSpace =
-                getRectsInScreenSpace(TEST_KEEP_CLEAR_RECTS, activity.getComponentName());
-        assertSameElementsEventually(expectedRectsInScreenSpace,
+        final List<Rect> expectedRectsOnDisplay = new ArrayList<Rect>();
+        expectedRectsOnDisplay.addAll(prevKeepClearRectsOnDisplay);
+        expectedRectsOnDisplay.addAll(
+                getRectsInScreenSpace(TEST_KEEP_CLEAR_RECTS, activity.getComponentName()));
+        assertSameElementsEventually(expectedRectsOnDisplay,
                 () -> getKeepClearRectsOnDefaultDisplay());
 
         activity.finishAndRemoveTask();
-        assertTrue(Collections.disjoint(
-                expectedRectsInScreenSpace,
-                getKeepClearRectsOnDefaultDisplay()));
+        assertSameElementsEventually(prevKeepClearRectsOnDisplay,
+                () -> getKeepClearRectsOnDefaultDisplay());
     }
 
     @Test
@@ -419,6 +421,7 @@
 
         final Rect viewBounds = new Rect(0, 0, 25, 25);
         final View v1 = createTestViewInActivity(activity1, viewBounds);
+        final List<Rect> prevKeepClearRectsOnDisplay = getKeepClearRectsOnDefaultDisplay();
         mTestSession.runOnMainSyncAndWait(() -> v1.setPreferKeepClear(true));
         assertSameElementsEventually(Arrays.asList(viewBounds),
                 () -> getKeepClearRectsForActivity(activity1));
@@ -438,8 +441,12 @@
         mWmState.assertVisibility(activity2.getComponentName(), true);
 
         // Since both activities are fullscreen, WM only takes the keep clear areas from the top one
-        assertSameElementsEventually(getRectsInScreenSpace(TEST_KEEP_CLEAR_RECTS,
-                activity2.getComponentName()), () -> getKeepClearRectsOnDefaultDisplay());
+        final List<Rect> expectedRectsOnDisplay = new ArrayList<Rect>();
+        expectedRectsOnDisplay.addAll(prevKeepClearRectsOnDisplay);
+        expectedRectsOnDisplay.addAll(getRectsInScreenSpace(TEST_KEEP_CLEAR_RECTS,
+                activity2.getComponentName()));
+        assertSameElementsEventually(expectedRectsOnDisplay,
+                () -> getKeepClearRectsOnDefaultDisplay());
     }
 
     @Test
@@ -449,15 +456,24 @@
         translucentTestSession.launchTestActivityOnDisplaySync(
                 TranslucentTestActivity.class, DEFAULT_DISPLAY);
         final TestActivity activity1 = translucentTestSession.getActivity();
-
         final Rect viewBounds = new Rect(0, 0, 25, 25);
         final View v1 = createTestViewInActivity(activity1, viewBounds);
+        final List<Rect> prevKeepClearRectsOnDisplay = getKeepClearRectsOnDefaultDisplay();
         translucentTestSession.runOnMainSyncAndWait(() -> v1.setPreferKeepClear(true));
-        assertSameElementsEventually(getRectsInScreenSpace(Arrays.asList(viewBounds),
-                activity1.getComponentName()), () -> getKeepClearRectsOnDefaultDisplay());
 
+        // Add keep-clear rects in the activity
+        final List<Rect> expectedRectsOnDisplay = new ArrayList<Rect>();
+        expectedRectsOnDisplay.addAll(prevKeepClearRectsOnDisplay);
+        expectedRectsOnDisplay.addAll(getRectsInScreenSpace(Arrays.asList(viewBounds),
+                activity1.getComponentName()));
+        assertSameElementsEventually(expectedRectsOnDisplay,
+                () -> getKeepClearRectsOnDefaultDisplay());
+
+        // Start an opaque activity on top
         mTestSession.launchTestActivityOnDisplaySync(TestActivity.class, DEFAULT_DISPLAY);
         final TestActivity activity2 = mTestSession.getActivity();
+
+        // Add keep-clear rects in the opaque activity
         final View v2 = createTestViewInActivity(activity2);
         mTestSession.runOnMainSyncAndWait(() -> v2.setPreferKeepClearRects(TEST_KEEP_CLEAR_RECTS));
         assertSameElementsEventually(TEST_KEEP_CLEAR_RECTS,
@@ -466,8 +482,13 @@
         mWmState.waitAndAssertVisibilityGone(activity1.getComponentName());
         mWmState.assertVisibility(activity2.getComponentName(), true);
 
-        assertSameElementsEventually(TEST_KEEP_CLEAR_RECTS,
-                () -> getKeepClearRectsForActivity(activity2));
+        // Only the opaque activity's keep-clear areas should be reported on the display
+        expectedRectsOnDisplay.clear();
+        expectedRectsOnDisplay.addAll(prevKeepClearRectsOnDisplay);
+        expectedRectsOnDisplay.addAll(getRectsInScreenSpace(
+                    TEST_KEEP_CLEAR_RECTS, activity2.getComponentName()));
+        assertSameElementsEventually(expectedRectsOnDisplay,
+                () -> getKeepClearRectsOnDefaultDisplay());
     }
 
     @Test
@@ -475,30 +496,15 @@
         assumeTrue("Skipping test: no split multi-window support",
                 supportsSplitScreenMultiWindow());
 
-        final LaunchActivityBuilder activityBuilder1 = getLaunchActivityBuilder()
-                .setUseInstrumentation()
-                .setIntentExtra(extra -> {
-                    extra.putParcelableArrayList(EXTRA_KEEP_CLEAR_RECTS,
-                            new ArrayList(TEST_KEEP_CLEAR_RECTS));
-                })
-                .setTargetActivity(KEEP_CLEAR_RECTS_ACTIVITY);
+        startKeepClearActivitiesInSplitscreen(KEEP_CLEAR_RECTS_ACTIVITY,
+                KEEP_CLEAR_RECTS_ACTIVITY2, Collections.emptyList(), Collections.emptyList());
+        final List<Rect> prevKeepClearRectsOnDisplay = getKeepClearRectsOnDefaultDisplay();
 
-        final LaunchActivityBuilder activityBuilder2 = getLaunchActivityBuilder()
-                .setUseInstrumentation()
-                .setIntentExtra(extra -> {
-                    extra.putParcelableArrayList(EXTRA_KEEP_CLEAR_RECTS,
-                            new ArrayList(TEST_KEEP_CLEAR_RECTS_2));
-                })
-                .setTargetActivity(KEEP_CLEAR_RECTS_ACTIVITY2);
+        removeRootTask(mWmState.getTaskByActivity(KEEP_CLEAR_RECTS_ACTIVITY).mTaskId);
+        removeRootTask(mWmState.getTaskByActivity(KEEP_CLEAR_RECTS_ACTIVITY2).mTaskId);
 
-        launchActivitiesInSplitScreen(activityBuilder1, activityBuilder2);
-
-        waitAndAssertResumedActivity(KEEP_CLEAR_RECTS_ACTIVITY, KEEP_CLEAR_RECTS_ACTIVITY
-                + " must be resumed");
-        waitAndAssertResumedActivity(KEEP_CLEAR_RECTS_ACTIVITY2, KEEP_CLEAR_RECTS_ACTIVITY2
-                + " must be resumed");
-        mWmState.assertVisibility(KEEP_CLEAR_RECTS_ACTIVITY, true);
-        mWmState.assertVisibility(KEEP_CLEAR_RECTS_ACTIVITY2, true);
+        startKeepClearActivitiesInSplitscreen(KEEP_CLEAR_RECTS_ACTIVITY,
+                KEEP_CLEAR_RECTS_ACTIVITY2, TEST_KEEP_CLEAR_RECTS, TEST_KEEP_CLEAR_RECTS_2);
 
         assertSameElementsEventually(TEST_KEEP_CLEAR_RECTS,
                 () -> getKeepClearRectsForActivity(KEEP_CLEAR_RECTS_ACTIVITY));
@@ -506,11 +512,38 @@
                 () -> getKeepClearRectsForActivity(KEEP_CLEAR_RECTS_ACTIVITY2));
 
         final List<Rect> expected = new ArrayList();
+        expected.addAll(prevKeepClearRectsOnDisplay);
         expected.addAll(getRectsInScreenSpace(TEST_KEEP_CLEAR_RECTS, KEEP_CLEAR_RECTS_ACTIVITY));
         expected.addAll(getRectsInScreenSpace(TEST_KEEP_CLEAR_RECTS_2, KEEP_CLEAR_RECTS_ACTIVITY2));
         assertSameElementsEventually(expected, () -> getKeepClearRectsOnDefaultDisplay());
     }
 
+    private void startKeepClearActivitiesInSplitscreen(ComponentName activity1,
+            ComponentName activity2, List<Rect> keepClearRects1, List<Rect> keepClearRects2) {
+        final LaunchActivityBuilder activityBuilder1 = getLaunchActivityBuilder()
+                .setUseInstrumentation()
+                .setTargetActivity(activity1)
+                .setIntentExtra(extra -> {
+                    extra.putParcelableArrayList(EXTRA_KEEP_CLEAR_RECTS,
+                            new ArrayList(keepClearRects1));
+                });
+
+        final LaunchActivityBuilder activityBuilder2 = getLaunchActivityBuilder()
+                .setUseInstrumentation()
+                .setTargetActivity(activity2)
+                .setIntentExtra(extra -> {
+                    extra.putParcelableArrayList(EXTRA_KEEP_CLEAR_RECTS,
+                            new ArrayList(keepClearRects2));
+                });
+
+        launchActivitiesInSplitScreen(activityBuilder1, activityBuilder2);
+
+        waitAndAssertResumedActivity(activity1, activity1 + " must be resumed");
+        waitAndAssertResumedActivity(activity2, activity2 + " must be resumed");
+        mWmState.assertVisibility(activity1, true);
+        mWmState.assertVisibility(activity2, true);
+    }
+
     @Test
     public void testUnrestrictedKeepClearRects() throws Exception {
         mTestSession.launchTestActivityOnDisplaySync(TestActivity.class, DEFAULT_DISPLAY);
@@ -547,6 +580,7 @@
         mTestSession.runOnMainSyncAndWait(() -> {
             activity.addView(newView, params);
         });
+        waitForIdle();
         return newView;
     }
 
@@ -607,7 +641,8 @@
 
     private static <T> void assertSameElementsEventually(List<T> expected, Callable<List<T>> actual)
             throws Exception {
-        PollingCheck.check("Lists do not have the same elements.",
+        PollingCheck.check("Lists do not have the same elements."
+                + "Expected=" + expected + ", actual=" + actual.call(),
                 SAME_ELEMENT_ASSERTION_TIMEOUT,
                 () -> hasSameElements(expected, actual.call()));
     }
diff --git a/tests/media/AndroidManifest.xml b/tests/media/AndroidManifest.xml
index 3a97bbe..0a1f5e0 100644
--- a/tests/media/AndroidManifest.xml
+++ b/tests/media/AndroidManifest.xml
@@ -23,6 +23,7 @@
 
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.CAMERA" />
 
     <application
         android:requestLegacyExternalStorage="true"
diff --git a/tests/media/common/src/android/mediav2/common/cts/BitStreamUtils.java b/tests/media/common/src/android/mediav2/common/cts/BitStreamUtils.java
index 616eaa4..66ed70f 100644
--- a/tests/media/common/src/android/mediav2/common/cts/BitStreamUtils.java
+++ b/tests/media/common/src/android/mediav2/common/cts/BitStreamUtils.java
@@ -16,6 +16,7 @@
 
 package android.mediav2.common.cts;
 
+import static android.media.MediaCodecInfo.CodecProfileLevel.*;
 import static android.media.MediaFormat.PICTURE_TYPE_B;
 import static android.media.MediaFormat.PICTURE_TYPE_I;
 import static android.media.MediaFormat.PICTURE_TYPE_P;
@@ -23,11 +24,13 @@
 
 import android.media.MediaCodec;
 import android.media.MediaFormat;
+import android.util.Pair;
 
 import org.junit.Assert;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
+import java.util.HashMap;
 
 /**
  * This class contains utility functions that parse compressed bitstream and returns metadata
@@ -38,9 +41,15 @@
  * Currently this class hosts utils that can,
  * <ul>
  *     <li>Return frame type of the access units of avc, hevc, av1.</li>
+ *     <li>Return profile/level information of avc, hevc, av1, vp9, mpeg4, h263, aac</li>
  * </ul>
  */
 public class BitStreamUtils {
+    public static int getHashMapVal(HashMap<Integer, Integer> obj, int key) {
+        Integer val = obj.get(key);
+        return val == null ? -1 : val;
+    }
+
     static class ParsableBitArray {
         protected final byte[] mData;
         protected final int mOffset;
@@ -71,9 +80,9 @@
         }
 
         public int readBits(int numBits) {
-            if (numBits > 31) {
-                throw new IllegalArgumentException(
-                        "left shift overflow exception, reading too many bits at one go");
+            if (numBits > 32) {
+                throw new IllegalArgumentException("readBits Exception: maximum storage space of "
+                        + "return value of readBits : 32, less than bits to read : " + numBits);
             }
             int value = 0;
             for (int i = 0; i < numBits; i++) {
@@ -84,9 +93,9 @@
         }
 
         public long readBitsLong(int numBits) {
-            if (numBits > 63) {
-                throw new IllegalArgumentException(
-                        "left shift overflow exception, reading too many bits at one go");
+            if (numBits > 64) {
+                throw new IllegalArgumentException("readBitsLong Exception: maximum storage space "
+                        + "of return value of readBits : 64, less than bits to read : " + numBits);
             }
             long value = 0;
             for (int i = 0; i < numBits; i++) {
@@ -168,10 +177,131 @@
         }
 
         public abstract int getFrameType();
+
+        public abstract Pair<Integer, Integer> getProfileLevel(boolean isCsd);
+
+        // .first = profile, .second = level
+        public Pair<Integer, Integer> plToPair(int profile, int level) {
+            return Pair.create(profile, level);
+        }
+    }
+
+    static class Mpeg4Parser extends ParserBase {
+        @Override
+        public int getFrameType() {
+            return PICTURE_TYPE_UNKNOWN;
+        }
+
+        @Override
+        public Pair<Integer, Integer> getProfileLevel(@SuppressWarnings("unused") boolean isCsd) {
+            ParsableBitArray bitArray = new ParsableBitArray(mData, mOffset, mLimit);
+            Assert.assertEquals(0, bitArray.readBits(8));
+            Assert.assertEquals(0, bitArray.readBits(8));
+            Assert.assertEquals(1, bitArray.readBits(8));
+            Assert.assertEquals(0xb0, bitArray.readBits(8));
+            int profileLevel = bitArray.readBits(8);
+            switch (profileLevel) {
+                case 0x08: return plToPair(MPEG4ProfileSimple, MPEG4Level0);
+                case 0x01: return plToPair(MPEG4ProfileSimple, MPEG4Level1);
+                case 0x02: return plToPair(MPEG4ProfileSimple, MPEG4Level2);
+                case 0x03: return plToPair(MPEG4ProfileSimple, MPEG4Level3);
+                case 0xf0: return plToPair(MPEG4ProfileAdvancedSimple, MPEG4Level0);
+                case 0xf1: return plToPair(MPEG4ProfileAdvancedSimple, MPEG4Level1);
+                case 0xf2: return plToPair(MPEG4ProfileAdvancedSimple, MPEG4Level2);
+                case 0xf3: return plToPair(MPEG4ProfileAdvancedSimple, MPEG4Level3);
+                case 0xf7: return plToPair(MPEG4ProfileAdvancedSimple, MPEG4Level3b);
+                case 0xf4: return plToPair(MPEG4ProfileAdvancedSimple, MPEG4Level4);
+                case 0xf5: return plToPair(MPEG4ProfileAdvancedSimple, MPEG4Level5);
+                default: return null;
+            }
+        }
+    }
+
+    static class H263Parser extends ParserBase {
+        @Override
+        public int getFrameType() {
+            return PICTURE_TYPE_UNKNOWN;
+        }
+
+        @Override
+        public Pair<Integer, Integer> getProfileLevel(@SuppressWarnings("unused") boolean isCsd) {
+            ParsableBitArray bitArray = new ParsableBitArray(mData, mOffset, mLimit);
+            Assert.assertEquals("bad psc", 0x20, bitArray.readBits(22));
+            bitArray.readBits(8); // tr
+            Assert.assertEquals(1, bitArray.readBits(1));
+            Assert.assertEquals(0, bitArray.readBits(1));
+            bitArray.readBits(1);  // split screen
+            bitArray.readBits(1);  // camera indicator
+            bitArray.readBits(1);  // freeze indicator
+            int sourceFormat = bitArray.readBits(3);
+            int picType;
+            int umv = 0, sac = 0, ap = 0, pb = 0;
+            int aic = 0, df = 0, ss = 0, rps = 0, isd = 0, aiv = 0, mq = 0;
+            int rpr = 0, rru = 0;
+            if (sourceFormat == 7) {
+                int ufep = bitArray.readBits(3);
+                if (ufep == 1) {
+                    sourceFormat = bitArray.readBits(3);
+                    bitArray.readBits(1); // custom pcf
+                    umv = bitArray.readBits(1);
+                    sac = bitArray.readBits(1);
+                    ap = bitArray.readBits(1);
+                    aic = bitArray.readBits(1);
+                    df = bitArray.readBits(1);
+                    ss = bitArray.readBits(1);
+                    rps = bitArray.readBits(1);
+                    isd = bitArray.readBits(1);
+                    aiv = bitArray.readBits(1);
+                    mq = bitArray.readBits(1);
+                    Assert.assertEquals(1, bitArray.readBits(1));
+                    Assert.assertEquals(0, bitArray.readBits(3));
+                }
+                picType = bitArray.readBits(3);
+                rpr = bitArray.readBits(1);
+                rru = bitArray.readBits(1);
+                bitArray.readBits(1);  // rtype
+                Assert.assertEquals(0, bitArray.readBits(1));  // reserved
+                Assert.assertEquals(0, bitArray.readBits(1));  // reserved
+                Assert.assertEquals(1, bitArray.readBits(1));  // start code emulation
+            } else {
+                picType = bitArray.readBits(1);
+                umv = bitArray.readBits(1);
+                sac = bitArray.readBits(1);
+                ap = bitArray.readBits(1);
+                pb = bitArray.readBits(1);
+            }
+            int profile = H263ProfileBaseline;
+            if (ap == 1) profile = H263ProfileBackwardCompatible;
+            if (aic == 1 && df == 1 && ss == 1 && mq == 1) profile = H263ProfileISWV2;
+            return plToPair(profile, -1);
+        }
     }
 
     static class AvcParser extends ParserBase {
         private static final int NO_NAL_UNIT_FOUND = -1;
+        private static final HashMap<Integer, Integer> LEVEL_MAP = new HashMap<>() {
+            {
+                put(10, AVCLevel1);
+                put(11, AVCLevel11);
+                put(12, AVCLevel12);
+                put(13, AVCLevel13);
+                put(20, AVCLevel2);
+                put(21, AVCLevel21);
+                put(22, AVCLevel22);
+                put(30, AVCLevel3);
+                put(31, AVCLevel31);
+                put(32, AVCLevel32);
+                put(40, AVCLevel4);
+                put(41, AVCLevel41);
+                put(42, AVCLevel42);
+                put(50, AVCLevel5);
+                put(51, AVCLevel51);
+                put(52, AVCLevel52);
+                put(60, AVCLevel6);
+                put(61, AVCLevel61);
+                put(62, AVCLevel62);
+            }
+        };
 
         private int getNalUnitStartOffset(byte[] dataArray, int start, int limit) {
             for (int pos = start; pos + 3 < limit; pos++) {
@@ -198,7 +328,8 @@
                 int nalUnitType = getNalUnitType(mData, offset);
                 if (nalUnitType == 1 || nalUnitType == 2 || nalUnitType == 5) {  // coded slice
                     NalParsableBitArray bitArray = new NalParsableBitArray(mData, offset, mLimit);
-                    bitArray.readBits(8); // forbidden zero bit + nal_ref_idc + nal_unit_type
+                    Assert.assertEquals(0, bitArray.readBits(1)); // forbidden zero bit
+                    bitArray.readBits(7); // nal_ref_idc + nal_unit_type
                     bitArray.readUEV(); // first_mb_in_slice
                     int sliceType = bitArray.readUEV();
                     if (sliceType % 5 == 0) {
@@ -215,6 +346,77 @@
             }
             return PICTURE_TYPE_UNKNOWN;
         }
+
+        @Override
+        public Pair<Integer, Integer> getProfileLevel(@SuppressWarnings("unused") boolean isCsd) {
+            for (int pos = mOffset; pos < mLimit; ) {
+                int offset = getNalUnitStartOffset(mData, pos, mLimit);
+                if (offset == NO_NAL_UNIT_FOUND) return null;
+                if (getNalUnitType(mData, offset) == 7) { // seq_parameter_set_rbsp
+                    NalParsableBitArray bitArray = new NalParsableBitArray(mData, offset, mLimit);
+                    Assert.assertEquals(0, bitArray.readBits(1)); // forbidden zero bit
+                    bitArray.readBits(7); // nal_ref_idc + nal_unit_type
+                    int profileIdc = bitArray.readBits(8);
+                    int constraintSet0Flag = bitArray.readBits(1);
+                    int constraintSet1Flag = bitArray.readBits(1);
+                    int constraintSet2Flag = bitArray.readBits(1);
+                    int constraintSet3Flag = bitArray.readBits(1);
+                    int constraintSet4Flag = bitArray.readBits(1);
+                    int constraintSet5Flag = bitArray.readBits(1);
+                    Assert.assertEquals(0, bitArray.readBits(2)); // reserved zero 2 bits
+                    int levelIdc = bitArray.readBits(8);
+
+                    int profile = -1;
+                    if (constraintSet0Flag == 1 || profileIdc == 66) {
+                        profile = constraintSet1Flag == 1 ? AVCProfileConstrainedBaseline :
+                                AVCProfileBaseline;
+                    } else if (constraintSet1Flag == 1 || profileIdc == 77) {
+                        profile = AVCProfileMain;
+                    } else if (constraintSet2Flag == 1 || profileIdc == 88) {
+                        profile = AVCProfileExtended;
+                    } else if (profileIdc == 100) {
+                        profile = (constraintSet4Flag == 1 && constraintSet5Flag == 1)
+                                ? AVCProfileConstrainedHigh : AVCProfileHigh;
+                    } else if (profileIdc == 110) {
+                        profile = AVCProfileHigh10;
+                    } else if (profileIdc == 122) {
+                        profile = AVCProfileHigh422;
+                    } else if (profileIdc == 244) {
+                        profile = AVCProfileHigh444;
+                    }
+
+                    // In bitstreams conforming to the Baseline, Constrained Baseline, Main, or
+                    // Extended profiles :
+                    // - If level_idc is equal to 11 and constraint_set3_flag is equal to 1, the
+                    // indicated level is level 1b.
+                    // - Otherwise (level_idc is not equal to 11 or constraint_set3_flag is not
+                    // equal to 1), level_idc is equal to a value of ten times the level number
+                    // (of the indicated level) specified in Table A-1.
+                    int level;
+                    if ((levelIdc == 11) && (profile == AVCProfileBaseline
+                            || profile == AVCProfileConstrainedBaseline || profile == AVCProfileMain
+                            || profile == AVCProfileExtended)) {
+                        level = constraintSet3Flag == 1 ? AVCLevel1b : AVCLevel11;
+                    } else if ((levelIdc == 9) && (profile == AVCProfileHigh
+                            || profile == AVCProfileHigh10 || profile == AVCProfileHigh422
+                            || profile == AVCProfileHigh444)) {
+                        // In bitstreams conforming to the High, High 10, High 4:2:2, High 4:4:4
+                        // Predictive, High 10 Intra, High 4:2:2 Intra, High 4:4:4 Intra, or
+                        // CAVLC 4:4:4 Intra profiles,
+                        // - If level_idc is equal to 9, the indicated level is level 1b.
+                        // - Otherwise (level_idc is not equal to 9), level_idc is equal to a
+                        // value of ten times the level number (of the indicated level) specified
+                        // in Table A-1
+                        level = AVCLevel1b;
+                    } else {
+                        level = getHashMapVal(LEVEL_MAP, levelIdc);
+                    }
+                    return plToPair(profile, level);
+                }
+                pos = offset;
+            }
+            return null;
+        }
     }
 
     static class HevcParser extends ParserBase {
@@ -223,6 +425,35 @@
         private static final int RASL_R = 9;
         private static final int BLA_W_LP = 16;
         private static final int RSV_IRAP_VCL23 = 23;
+        private static final HashMap<Integer, Integer> LEVEL_MAP_MAIN_TIER = new HashMap<>() {
+            {
+                put(30, HEVCMainTierLevel1);
+                put(60, HEVCMainTierLevel2);
+                put(63, HEVCMainTierLevel21);
+                put(90, HEVCMainTierLevel3);
+                put(93, HEVCMainTierLevel31);
+                put(120, HEVCMainTierLevel4);
+                put(123, HEVCMainTierLevel41);
+                put(150, HEVCMainTierLevel5);
+                put(153, HEVCMainTierLevel51);
+                put(156, HEVCMainTierLevel52);
+                put(180, HEVCMainTierLevel6);
+                put(183, HEVCMainTierLevel61);
+                put(186, HEVCMainTierLevel62);
+            }
+        };
+        private static final HashMap<Integer, Integer> LEVEL_MAP_HIGH_TIER = new HashMap<>() {
+            {
+                put(120, HEVCHighTierLevel4);
+                put(123, HEVCHighTierLevel41);
+                put(150, HEVCHighTierLevel5);
+                put(153, HEVCHighTierLevel51);
+                put(156, HEVCHighTierLevel52);
+                put(180, HEVCHighTierLevel6);
+                put(183, HEVCHighTierLevel61);
+                put(186, HEVCHighTierLevel62);
+            }
+        };
 
         private int getNalUnitStartOffset(byte[] dataArray, int start, int limit) {
             for (int pos = start; pos + 3 < limit; pos++) {
@@ -275,6 +506,120 @@
             }
             return PICTURE_TYPE_UNKNOWN;
         }
+
+        @Override
+        public Pair<Integer, Integer> getProfileLevel(@SuppressWarnings("unused") boolean isCsd) {
+            for (int pos = mOffset; pos < mLimit; ) {
+                int offset = getNalUnitStartOffset(mData, pos, mLimit);
+                if (offset == NO_NAL_UNIT_FOUND) return null;
+                if (getNalUnitType(mData, offset) == 33) { // sps_nut
+                    NalParsableBitArray bitArray = new NalParsableBitArray(mData, offset, mLimit);
+                    bitArray.readBits(16); // nal unit header
+                    bitArray.readBits(4); // sps video parameter set id
+                    bitArray.readBits(3); // sps_max_sub_layers_minus1
+                    bitArray.readBits(1); // sps temporal id nesting flag
+                    // profile_tier_level
+                    bitArray.readBits(2); // generalProfileSpace
+                    int generalTierFlag = bitArray.readBits(1);
+                    int generalProfileIdc = bitArray.readBits(5);
+                    int[] generalProfileCompatibility = new int[32];
+                    for (int j = 0; j < generalProfileCompatibility.length; j++) {
+                        generalProfileCompatibility[j] = bitArray.readBits(1);
+                    }
+                    bitArray.readBits(1); // general progressive source flag
+                    bitArray.readBits(1); // general interlaced source flag
+                    bitArray.readBits(1); // general non packed constraint flag
+                    bitArray.readBits(1); // general frame only constraint flag
+
+                    // interpretation of next 44 bits is dependent on generalProfileIdc and
+                    // generalProfileCompatibility; but we do not use them in this validation
+                    // process, so we're skipping over them.
+                    bitArray.readBitsLong(44);
+                    int generalLevelIdc = bitArray.readBits(8);
+
+                    int profile = -1;
+                    if (generalProfileIdc == 1 || generalProfileCompatibility[1] == 1) {
+                        profile = HEVCProfileMain;
+                    } else if (generalProfileIdc == 2 || generalProfileCompatibility[2] == 1) {
+                        profile = HEVCProfileMain10;
+                    } else if (generalProfileIdc == 3 || generalProfileCompatibility[3] == 1) {
+                        profile = HEVCProfileMainStill;
+                    }
+
+                    return plToPair(profile, getHashMapVal(
+                            generalTierFlag == 0 ? LEVEL_MAP_MAIN_TIER : LEVEL_MAP_HIGH_TIER,
+                            generalLevelIdc));
+                }
+                pos = offset;
+            }
+            return null;
+        }
+    }
+
+    static class Vp9Parser extends ParserBase {
+        private static final HashMap<Integer, Integer> PROFILE_MAP = new HashMap<>() {
+            {
+                put(0, VP9Profile0);
+                put(1, VP9Profile1);
+                put(2, VP9Profile2);
+                put(3, VP9Profile3);
+            }
+        };
+        private static final HashMap<Integer, Integer> LEVEL_MAP = new HashMap<>() {
+            {
+                put(10, VP9Level1);
+                put(11, VP9Level11);
+                put(20, VP9Level2);
+                put(21, VP9Level21);
+                put(30, VP9Level3);
+                put(31, VP9Level31);
+                put(40, VP9Level4);
+                put(41, VP9Level41);
+                put(50, VP9Level5);
+                put(51, VP9Level51);
+                put(60, VP9Level6);
+                put(61, VP9Level61);
+                put(62, VP9Level62);
+            }
+        };
+
+        private Pair<Integer, Integer> getProfileLevelFromCSD() { // parse vp9 codecprivate
+            int profile = -1, level = -1;
+            for (int pos = mOffset; pos < mLimit; ) {
+                ParsableBitArray bitArray = new ParsableBitArray(mData, pos + mOffset, mLimit);
+                int id = bitArray.readBits(8);
+                int len = bitArray.readBits(8);
+                pos += 2;
+                int val = bitArray.readBits(len * 8);
+                pos += len;
+                if (id == 1 || id == 2) {
+                    Assert.assertEquals(1, len);
+                    if (id == 1) profile = val;
+                    else level = val;
+                }
+                if (profile != -1 && level != -1) break;
+            }
+            return plToPair(getHashMapVal(PROFILE_MAP, profile), getHashMapVal(LEVEL_MAP, level));
+        }
+
+        private Pair<Integer, Integer> getProfileFromFrameHeader() { // parse uncompressed header
+            ParsableBitArray bitArray = new ParsableBitArray(mData, mOffset, mLimit);
+            bitArray.readBits(2); // frame marker
+            int profileLBit = bitArray.readBits(1);
+            int profileHBit = bitArray.readBits(1);
+            int profile = profileHBit << 1 + profileLBit;
+            return plToPair(getHashMapVal(PROFILE_MAP, profile), -1);
+        }
+
+        @Override
+        public int getFrameType() {
+            return PICTURE_TYPE_UNKNOWN;
+        }
+
+        @Override
+        public Pair<Integer, Integer> getProfileLevel(boolean isCsd) {
+            return isCsd ? getProfileLevelFromCSD() : getProfileFromFrameHeader();
+        }
     }
 
     static class Av1Parser extends ParserBase {
@@ -578,6 +923,48 @@
             return frameHeader;
         }
 
+        // parse av1 codec configuration record
+        private Pair<Integer, Integer> getProfileLevelFromCSD() {
+            int profile = -1;
+            ParsableBitArray bitArray = new ParsableBitArray(mData, mOffset, mLimit);
+            Assert.assertEquals(1, bitArray.readBits(1));  // marker
+            Assert.assertEquals(1, bitArray.readBits(7));  // version
+            int seqProfile = bitArray.readBits(3);
+            int seqLevelIdx0 = bitArray.readBits(5);
+            bitArray.readBits(1);  // seqTier0
+            int highBitDepth = bitArray.readBits(1);
+            bitArray.readBits(1);  // is input 12 bit;
+            if (seqProfile == 0) {
+                profile = highBitDepth == 0 ? AV1ProfileMain8 : AV1ProfileMain10;
+            }
+
+            int level = AV1Level2 << seqLevelIdx0;
+            return plToPair(profile, level);
+        }
+
+        // parse av1 sequence header
+        private Pair<Integer, Integer> getProfileLevelFromSeqHeader() {
+            for (int pos = mOffset; pos < mLimit; ) {
+                ObuInfo obuDetails = parseObuHeader(mData, pos, mLimit);
+                ObuParsableBitArray bitArray =
+                        new ObuParsableBitArray(mData, pos + obuDetails.getObuDataOffset(),
+                                pos + obuDetails.getTotalObuSize());
+                if (obuDetails.mObuType == OBU_SEQUENCE_HEADER) {
+                    int profile = -1;
+                    parseSequenceHeader(bitArray);
+                    if (mSeqHeader.seqProfile == 0) {
+                        profile = mSeqHeader.enableHighBitDepth == 0 ? AV1ProfileMain8 :
+                                AV1ProfileMain10;
+                    }
+
+                    int level = AV1Level2 << mSeqHeader.seqLevelIdx[0];
+                    return plToPair(profile, level);
+                }
+                pos += obuDetails.getTotalObuSize();
+            }
+            return null;
+        }
+
         @Override
         public int getFrameType() {
             ArrayList<FrameHeaderObu> headers = new ArrayList();
@@ -609,26 +996,68 @@
             }
             return PICTURE_TYPE_UNKNOWN;
         }
+
+        @Override
+        public Pair<Integer, Integer> getProfileLevel(boolean isCsd) {
+            return isCsd ? getProfileLevelFromCSD() : getProfileLevelFromSeqHeader();
+        }
+    }
+
+    static class AacParser extends ParserBase {
+        @Override
+        public int getFrameType() {
+            return PICTURE_TYPE_UNKNOWN;
+        }
+
+        @Override
+        public Pair<Integer, Integer> getProfileLevel(@SuppressWarnings("unused") boolean isCsd) {
+            // parse AudioSpecificConfig() of ISO 14496 Part 3
+            ParsableBitArray bitArray = new ParsableBitArray(mData, mOffset, mLimit);
+            int audioObjectType = bitArray.readBits(5);
+            if (audioObjectType == 31) {
+                audioObjectType = 32 + bitArray.readBits(6); // audio object type ext
+            }
+            return plToPair(audioObjectType, -1);
+        }
     }
 
     public static ParserBase getParserObject(String mediaType) {
         switch (mediaType) {
+            case MediaFormat.MIMETYPE_VIDEO_MPEG4:
+                return new Mpeg4Parser();
+            case MediaFormat.MIMETYPE_VIDEO_H263:
+                return new H263Parser();
             case MediaFormat.MIMETYPE_VIDEO_AVC:
                 return new AvcParser();
             case MediaFormat.MIMETYPE_VIDEO_HEVC:
                 return new HevcParser();
             case MediaFormat.MIMETYPE_VIDEO_AV1:
                 return new Av1Parser();
+            case MediaFormat.MIMETYPE_VIDEO_VP9:
+                return new Vp9Parser();
+            case MediaFormat.MIMETYPE_AUDIO_AAC:
+                return new AacParser();
         }
         return null;
     }
 
     public static int getFrameTypeFromBitStream(ByteBuffer buf, MediaCodec.BufferInfo info,
             ParserBase o) {
+        if (o == null) return PICTURE_TYPE_UNKNOWN;
         byte[] dataArray = new byte[info.size];
         buf.position(info.offset);
         buf.get(dataArray);
         o.set(dataArray, 0, info.size);
         return o.getFrameType();
     }
+
+    public static Pair<Integer, Integer> getProfileLevelFromBitStream(ByteBuffer buf,
+            MediaCodec.BufferInfo info, ParserBase o) {
+        if (o == null) return null;
+        byte[] dataArray = new byte[info.size];
+        buf.position(info.offset);
+        buf.get(dataArray);
+        o.set(dataArray, 0, info.size);
+        return o.getProfileLevel((info.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0);
+    }
 }
diff --git a/tests/media/common/src/android/mediav2/common/cts/CodecTestBase.java b/tests/media/common/src/android/mediav2/common/cts/CodecTestBase.java
index b1ccc46..2736823 100644
--- a/tests/media/common/src/android/mediav2/common/cts/CodecTestBase.java
+++ b/tests/media/common/src/android/mediav2/common/cts/CodecTestBase.java
@@ -26,6 +26,11 @@
 import static org.junit.Assert.fail;
 
 import android.content.Context;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CameraMetadata;
+import android.hardware.camera2.params.DynamicRangeProfiles;
 import android.hardware.display.DisplayManager;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
@@ -115,6 +120,7 @@
             SystemProperties.getInt("ro.vndk.version", Build.VERSION_CODES.CUR_DEVELOPMENT)
                     >= Build.VERSION_CODES.TIRAMISU;
     public static final boolean IS_HDR_EDITING_SUPPORTED;
+    public static final boolean IS_HDR_CAPTURE_SUPPORTED;
     private static final String LOG_TAG = CodecTestBase.class.getSimpleName();
 
     public static final ArrayList<String> HDR_INFO_IN_BITSTREAM_CODECS = new ArrayList<>();
@@ -280,6 +286,7 @@
     static {
         MEDIA_CODEC_LIST_ALL = new MediaCodecList(MediaCodecList.ALL_CODECS);
         MEDIA_CODEC_LIST_REGULAR = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
+        IS_HDR_CAPTURE_SUPPORTED = isHDRCaptureSupported();
         IS_HDR_EDITING_SUPPORTED = isHDREditingSupported();
         CODEC_SEL_KEY_MEDIA_TYPE_MAP.put("vp8", MediaFormat.MIMETYPE_VIDEO_VP8);
         CODEC_SEL_KEY_MEDIA_TYPE_MAP.put("vp9", MediaFormat.MIMETYPE_VIDEO_VP9);
@@ -455,6 +462,31 @@
         return isSupported;
     }
 
+    public static boolean isHDRCaptureSupported() {
+        // If the device supports HDR, hlg support should always return true
+        if (!MediaUtils.hasCamera()) return false;
+        CameraManager cm = CONTEXT.getSystemService(CameraManager.class);
+        try {
+            String[] cameraIds = cm.getCameraIdList();
+            for (String id : cameraIds) {
+                CameraCharacteristics ch = cm.getCameraCharacteristics(id);
+                int[] caps = ch.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);
+                if (IntStream.of(caps).anyMatch(x -> x
+                        == CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)) {
+                    Set<Long> profiles =
+                            ch.get(CameraCharacteristics.REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES)
+                                    .getSupportedProfiles();
+                    if (profiles.contains(DynamicRangeProfiles.HLG10)) return true;
+                }
+            }
+        } catch (CameraAccessException e) {
+            Log.e(LOG_TAG, "encountered " + e.getMessage()
+                    + " marking hdr capture to be available to catch your attention");
+            return true;
+        }
+        return false;
+    }
+
     public static boolean isHDREditingSupported() {
         for (MediaCodecInfo codecInfo : MEDIA_CODEC_LIST_REGULAR.getCodecInfos()) {
             if (!codecInfo.isEncoder()) {
@@ -508,7 +540,7 @@
     public static boolean canDisplaySupportHDRContent() {
         DisplayManager displayManager = CONTEXT.getSystemService(DisplayManager.class);
         return displayManager.getDisplay(Display.DEFAULT_DISPLAY).getHdrCapabilities()
-                .getSupportedHdrTypes().length != 0;
+                .getSupportedHdrTypes().length > 0;
     }
 
     public static boolean areFormatsSupported(String name, String mediaType,
diff --git a/tests/media/common/src/android/mediav2/common/cts/EncoderProfileLevelTestBase.java b/tests/media/common/src/android/mediav2/common/cts/EncoderProfileLevelTestBase.java
new file mode 100644
index 0000000..1d81c07b
--- /dev/null
+++ b/tests/media/common/src/android/mediav2/common/cts/EncoderProfileLevelTestBase.java
@@ -0,0 +1,563 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.mediav2.common.cts;
+
+import static android.media.MediaCodecInfo.CodecProfileLevel.*;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import android.media.MediaCodec;
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.util.Log;
+import android.util.Pair;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * Wrapper class for testing encoders support for profile and level
+ */
+public class EncoderProfileLevelTestBase extends CodecEncoderTestBase {
+    private static final String LOG_TAG = EncoderProfileLevelTestBase.class.getSimpleName();
+
+    private static int divUp(int num, int den) {
+        return (num + den - 1) / den;
+    }
+
+    public static int getMinLevel(String mediaType, int width, int height, int frameRate,
+            int bitrate, int profile) {
+        switch (mediaType) {
+            case MediaFormat.MIMETYPE_VIDEO_AVC:
+                return getMinLevelAVC(width, height, frameRate, bitrate);
+            case MediaFormat.MIMETYPE_VIDEO_HEVC:
+                return getMinLevelHEVC(width, height, frameRate, bitrate);
+            case MediaFormat.MIMETYPE_VIDEO_H263:
+                return getMinLevelH263(width, height, frameRate, bitrate);
+            case MediaFormat.MIMETYPE_VIDEO_MPEG2:
+                return getMinLevelMPEG2(width, height, frameRate, bitrate);
+            case MediaFormat.MIMETYPE_VIDEO_MPEG4:
+                return getMinLevelMPEG4(width, height, frameRate, bitrate, profile);
+            case MediaFormat.MIMETYPE_VIDEO_VP9:
+                return getMinLevelVP9(width, height, frameRate, bitrate);
+            case MediaFormat.MIMETYPE_VIDEO_AV1:
+                return getMinLevelAV1(width, height, frameRate, bitrate);
+            default:
+                return -1;
+        }
+    }
+
+    private static int getMinLevelAVC(int width, int height, int frameRate, int bitrate) {
+        class LevelLimitAVC {
+            private LevelLimitAVC(int level, int mbsPerSec, long mbs, int bitrate) {
+                this.mLevel = level;
+                this.mMbsPerSec = mbsPerSec;
+                this.mMbs = mbs;
+                this.mBitrate = bitrate;
+            }
+
+            private final int mLevel;
+            private final int mMbsPerSec;
+            private final long mMbs;
+            private final int mBitrate;
+        }
+        LevelLimitAVC[] limitsAVC = {
+                new LevelLimitAVC(AVCLevel1, 1485, 99, 64000),
+                new LevelLimitAVC(AVCLevel1b, 1485, 99, 128000),
+                new LevelLimitAVC(AVCLevel11, 3000, 396, 192000),
+                new LevelLimitAVC(AVCLevel12, 6000, 396, 384000),
+                new LevelLimitAVC(AVCLevel13, 11880, 396, 768000),
+                new LevelLimitAVC(AVCLevel2, 11880, 396, 2000000),
+                new LevelLimitAVC(AVCLevel21, 19800, 792, 4000000),
+                new LevelLimitAVC(AVCLevel22, 20250, 1620, 4000000),
+                new LevelLimitAVC(AVCLevel3, 40500, 1620, 10000000),
+                new LevelLimitAVC(AVCLevel31, 108000, 3600, 14000000),
+                new LevelLimitAVC(AVCLevel32, 216000, 5120, 20000000),
+                new LevelLimitAVC(AVCLevel4, 245760, 8192, 20000000),
+                new LevelLimitAVC(AVCLevel41, 245760, 8192, 50000000),
+                new LevelLimitAVC(AVCLevel42, 522240, 8704, 50000000),
+                new LevelLimitAVC(AVCLevel5, 589824, 22080, 135000000),
+                new LevelLimitAVC(AVCLevel51, 983040, 36864, 240000000),
+                new LevelLimitAVC(AVCLevel52, 2073600, 36864, 240000000),
+                new LevelLimitAVC(AVCLevel6, 4177920, 139264, 240000000),
+                new LevelLimitAVC(AVCLevel61, 8355840, 139264, 480000000),
+                new LevelLimitAVC(AVCLevel62, 16711680, 139264, 800000000),
+        };
+        int blockSize = 16;
+        int mbs = divUp(width, blockSize) * divUp(height, blockSize);
+        float mbsPerSec = mbs * frameRate;
+        for (LevelLimitAVC levelLimitsAVC : limitsAVC) {
+            if (mbs <= levelLimitsAVC.mMbs && mbsPerSec <= levelLimitsAVC.mMbsPerSec
+                    && bitrate <= levelLimitsAVC.mBitrate) {
+                return levelLimitsAVC.mLevel;
+            }
+        }
+        // if none of the levels suffice, select the highest level
+        return AVCLevel62;
+    }
+
+    private static int getMinLevelHEVC(int width, int height, int frameRate, int bitrate) {
+        class LevelLimitHEVC {
+            private LevelLimitHEVC(int level, int frameRate, long samples, int bitrate) {
+                this.mLevel = level;
+                this.mFrameRate = frameRate;
+                this.mSamples = samples;
+                this.mBitrate = bitrate;
+            }
+
+            private final int mLevel;
+            private final int mFrameRate;
+            private final long mSamples;
+            private final int mBitrate;
+        }
+        LevelLimitHEVC[] limitsHEVC = {
+                new LevelLimitHEVC(HEVCMainTierLevel1, 15, 36864, 128000),
+                new LevelLimitHEVC(HEVCMainTierLevel2, 30, 122880, 1500000),
+                new LevelLimitHEVC(HEVCMainTierLevel21, 30, 245760, 3000000),
+                new LevelLimitHEVC(HEVCMainTierLevel3, 30, 552960, 6000000),
+                new LevelLimitHEVC(HEVCMainTierLevel31, 30, 983040, 10000000),
+                new LevelLimitHEVC(HEVCMainTierLevel4, 30, 2228224, 12000000),
+                new LevelLimitHEVC(HEVCHighTierLevel4, 30, 2228224, 30000000),
+                new LevelLimitHEVC(HEVCMainTierLevel41, 60, 2228224, 20000000),
+                new LevelLimitHEVC(HEVCHighTierLevel41, 60, 2228224, 50000000),
+                new LevelLimitHEVC(HEVCMainTierLevel5, 30, 8912896, 25000000),
+                new LevelLimitHEVC(HEVCHighTierLevel5, 30, 8912896, 100000000),
+                new LevelLimitHEVC(HEVCMainTierLevel51, 60, 8912896, 40000000),
+                new LevelLimitHEVC(HEVCHighTierLevel51, 60, 8912896, 160000000),
+                new LevelLimitHEVC(HEVCMainTierLevel52, 120, 8912896, 60000000),
+                new LevelLimitHEVC(HEVCHighTierLevel52, 120, 8912896, 240000000),
+                new LevelLimitHEVC(HEVCMainTierLevel6, 30, 35651584, 60000000),
+                new LevelLimitHEVC(HEVCHighTierLevel6, 30, 35651584, 240000000),
+                new LevelLimitHEVC(HEVCMainTierLevel61, 60, 35651584, 120000000),
+                new LevelLimitHEVC(HEVCHighTierLevel61, 60, 35651584, 480000000),
+                new LevelLimitHEVC(HEVCMainTierLevel62, 120, 35651584, 240000000),
+                new LevelLimitHEVC(HEVCHighTierLevel62, 120, 35651584, 800000000),
+        };
+        int blockSize = 8;
+        int blocks = divUp(width, blockSize) * divUp(height, blockSize);
+        int samples = blocks * blockSize * blockSize;
+        for (LevelLimitHEVC levelLimitsHEVC : limitsHEVC) {
+            if (samples <= levelLimitsHEVC.mSamples && frameRate <= levelLimitsHEVC.mFrameRate
+                    && bitrate <= levelLimitsHEVC.mBitrate) {
+                return levelLimitsHEVC.mLevel;
+            }
+        }
+        // if none of the levels suffice, select the highest level
+        return HEVCHighTierLevel62;
+    }
+
+    private static int getMinLevelH263(int width, int height, int frameRate, int bitrate) {
+        class LevelLimitH263 {
+            private LevelLimitH263(int level, long sampleRate, int width, int height, int frameRate,
+                    int bitrate) {
+                this.mLevel = level;
+                this.mSampleRate = sampleRate;
+                this.mWidth = width;
+                this.mHeight = height;
+                this.mFrameRate = frameRate;
+                this.mBitrate = bitrate;
+            }
+
+            private final int mLevel;
+            private final long mSampleRate;
+            private final int mWidth;
+            private final int mHeight;
+            private final int mFrameRate;
+            private final int mBitrate;
+        }
+        LevelLimitH263[] limitsH263 = {
+                new LevelLimitH263(H263Level10, 380160, 176, 144, 15, 64000),
+                new LevelLimitH263(H263Level45, 380160, 176, 144, 15, 128000),
+                new LevelLimitH263(H263Level20, 1520640, 352, 288, 30, 128000),
+                new LevelLimitH263(H263Level30, 3041280, 352, 288, 30, 384000),
+                new LevelLimitH263(H263Level40, 3041280, 352, 288, 30, 2048000),
+                new LevelLimitH263(H263Level50, 5068800, 352, 288, 60, 4096000),
+                new LevelLimitH263(H263Level60, 10368000, 720, 288, 60, 8192000),
+                new LevelLimitH263(H263Level70, 20736000, 720, 576, 60, 16384000),
+        };
+        int blockSize = 16;
+        int mbs = divUp(width, blockSize) * divUp(height, blockSize);
+        int size = mbs * blockSize * blockSize;
+        int sampleRate = size * frameRate;
+        for (LevelLimitH263 levelLimitsH263 : limitsH263) {
+            if (sampleRate <= levelLimitsH263.mSampleRate && height <= levelLimitsH263.mHeight
+                    && width <= levelLimitsH263.mWidth && frameRate <= levelLimitsH263.mFrameRate
+                    && bitrate <= levelLimitsH263.mBitrate) {
+                return levelLimitsH263.mLevel;
+            }
+        }
+        // if none of the levels suffice, select the highest level
+        return H263Level70;
+    }
+
+    private static int getMinLevelVP9(int width, int height, int frameRate, int bitrate) {
+        class LevelLimitVP9 {
+            private LevelLimitVP9(int level, long sampleRate, int size, int maxWH, int bitrate) {
+                this.mLevel = level;
+                this.mSampleRate = sampleRate;
+                this.mSize = size;
+                this.mMaxWH = maxWH;
+                this.mBitrate = bitrate;
+            }
+
+            private final int mLevel;
+            private final long mSampleRate;
+            private final int mSize;
+            private final int mMaxWH;
+            private final int mBitrate;
+        }
+        LevelLimitVP9[] limitsVP9 = {
+                new LevelLimitVP9(VP9Level1, 829440, 36864, 512, 200000),
+                new LevelLimitVP9(VP9Level11, 2764800, 73728, 768, 800000),
+                new LevelLimitVP9(VP9Level2, 4608000, 122880, 960, 1800000),
+                new LevelLimitVP9(VP9Level21, 9216000, 245760, 1344, 3600000),
+                new LevelLimitVP9(VP9Level3, 20736000, 552960, 2048, 7200000),
+                new LevelLimitVP9(VP9Level31, 36864000, 983040, 2752, 12000000),
+                new LevelLimitVP9(VP9Level4, 83558400, 2228224, 4160, 18000000),
+                new LevelLimitVP9(VP9Level41, 160432128, 2228224, 4160, 30000000),
+                new LevelLimitVP9(VP9Level5, 311951360, 8912896, 8384, 60000000),
+                new LevelLimitVP9(VP9Level51, 588251136, 8912896, 8384, 120000000),
+                new LevelLimitVP9(VP9Level52, 1176502272, 8912896, 8384, 180000000),
+                new LevelLimitVP9(VP9Level6, 1176502272, 35651584, 16832, 180000000),
+                new LevelLimitVP9(VP9Level61, 2353004544L, 35651584, 16832, 240000000),
+                new LevelLimitVP9(VP9Level62, 4706009088L, 35651584, 16832, 480000000),
+        };
+        int blockSize = 8;
+        int blocks = divUp(width, blockSize) * divUp(height, blockSize);
+        int size = blocks * blockSize * blockSize;
+        int sampleRate = size * frameRate;
+        int maxWH = Math.max(width, height);
+        for (LevelLimitVP9 levelLimitsVP9 : limitsVP9) {
+            if (sampleRate <= levelLimitsVP9.mSampleRate && size <= levelLimitsVP9.mSize
+                    && maxWH <= levelLimitsVP9.mMaxWH && bitrate <= levelLimitsVP9.mBitrate) {
+                return levelLimitsVP9.mLevel;
+            }
+        }
+        // if none of the levels suffice, select the highest level
+        return VP9Level62;
+    }
+
+    private static int getMinLevelMPEG2(int width, int height, int frameRate, int bitrate) {
+        class LevelLimitMPEG2 {
+            private LevelLimitMPEG2(int level, long sampleRate, int width, int height,
+                    int frameRate, int bitrate) {
+                this.mLevel = level;
+                this.mSampleRate = sampleRate;
+                this.mWidth = width;
+                this.mHeight = height;
+                this.mFrameRate = frameRate;
+                this.mBitrate = bitrate;
+            }
+
+            private final int mLevel;
+            private final long mSampleRate;
+            private final int mWidth;
+            private final int mHeight;
+            private final int mFrameRate;
+            private final int mBitrate;
+        }
+        // main profile limits, higher profiles will also support selected level
+        LevelLimitMPEG2[] limitsMPEG2 = {
+                new LevelLimitMPEG2(MPEG2LevelLL, 3041280, 352, 288, 30, 4000000),
+                new LevelLimitMPEG2(MPEG2LevelML, 10368000, 720, 576, 30, 15000000),
+                new LevelLimitMPEG2(MPEG2LevelH14, 47001600, 1440, 1088, 60, 60000000),
+                new LevelLimitMPEG2(MPEG2LevelHL, 62668800, 1920, 1088, 60, 80000000),
+                new LevelLimitMPEG2(MPEG2LevelHP, 125337600, 1920, 1088, 60, 80000000),
+        };
+        int blockSize = 16;
+        int mbs = divUp(width, blockSize) * divUp(height, blockSize);
+        int size = mbs * blockSize * blockSize;
+        int sampleRate = size * frameRate;
+        for (LevelLimitMPEG2 levelLimitsMPEG2 : limitsMPEG2) {
+            if (sampleRate <= levelLimitsMPEG2.mSampleRate && width <= levelLimitsMPEG2.mWidth
+                    && height <= levelLimitsMPEG2.mHeight
+                    && frameRate <= levelLimitsMPEG2.mFrameRate
+                    && bitrate <= levelLimitsMPEG2.mBitrate) {
+                return levelLimitsMPEG2.mLevel;
+            }
+        }
+        // if none of the levels suffice, select the highest level
+        return MPEG2LevelHP;
+    }
+
+    private static int getMinLevelMPEG4(int width, int height, int frameRate, int bitrate,
+            int profile) {
+        class LevelLimitMPEG4 {
+            private LevelLimitMPEG4(int profile, int level, long sampleRate, int width, int height,
+                    int frameRate, int bitrate) {
+                this.mProfile = profile;
+                this.mLevel = level;
+                this.mSampleRate = sampleRate;
+                this.mWidth = width;
+                this.mHeight = height;
+                this.mFrameRate = frameRate;
+                this.mBitrate = bitrate;
+            }
+
+            private final int mProfile;
+            private final int mLevel;
+            private final long mSampleRate;
+            private final int mWidth;
+            private final int mHeight;
+            private final int mFrameRate;
+            private final int mBitrate;
+        }
+        // simple profile limits, higher profiles will also support selected level
+        LevelLimitMPEG4[] limitsMPEG4 = {
+                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level0, 380160, 176, 144, 15, 64000),
+                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level1, 380160, 176, 144, 30, 64000),
+                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level0b, 380160, 176, 144, 15, 128000),
+                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level2, 1520640, 352, 288, 30, 128000),
+                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level3, 3041280, 352, 288, 30, 384000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileSimple, MPEG4Level4a, 9216000, 640, 480, 30, 4000000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileSimple, MPEG4Level5, 10368000, 720, 576, 30, 8000000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileSimple, MPEG4Level6, 27648000, 1280, 720, 30, 12000000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileAdvancedSimple, MPEG4Level1, 760320, 176, 144, 30, 128000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileAdvancedSimple, MPEG4Level2, 1520640, 352, 288, 30, 384000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileAdvancedSimple, MPEG4Level3, 3041280, 352, 288, 30, 768000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileAdvancedSimple, MPEG4Level3b, 3041280, 352, 288, 30, 1500000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileAdvancedSimple, MPEG4Level4, 6082560, 704, 576, 30, 3000000),
+                new LevelLimitMPEG4(
+                        MPEG4ProfileAdvancedSimple, MPEG4Level5, 12441600, 720, 576, 30, 8000000),
+        };
+        int blockSize = 16;
+        int mbs = divUp(width, blockSize) * divUp(height, blockSize);
+        int size = mbs * blockSize * blockSize;
+        int sampleRate = size * frameRate;
+        if (profile != MPEG4ProfileAdvancedSimple && profile != MPEG4ProfileSimple) {
+            throw new RuntimeException("Unrecognized profile " + profile + " for "
+                    + MediaFormat.MIMETYPE_VIDEO_MPEG4);
+        }
+        for (LevelLimitMPEG4 levelLimitsMPEG4 : limitsMPEG4) {
+            if (profile == levelLimitsMPEG4.mProfile && sampleRate <= levelLimitsMPEG4.mSampleRate
+                    && width <= levelLimitsMPEG4.mWidth && height <= levelLimitsMPEG4.mHeight
+                    && frameRate <= levelLimitsMPEG4.mFrameRate
+                    && bitrate <= levelLimitsMPEG4.mBitrate) {
+                return levelLimitsMPEG4.mLevel;
+            }
+        }
+        // if none of the levels suffice, select the highest level
+        return MPEG4Level6;
+    }
+
+    private static int getMinLevelAV1(int width, int height, int frameRate, int bitrate) {
+        class LevelLimitAV1 {
+            private LevelLimitAV1(int level, int size, int width, int height, long sampleRate,
+                    int bitrate) {
+                this.mLevel = level;
+                this.mSize = size;
+                this.mWidth = width;
+                this.mHeight = height;
+                this.mSampleRate = sampleRate;
+                this.mBitrate = bitrate;
+            }
+
+            private final int mLevel;
+            private final int mSize;
+            private final int mWidth;
+            private final int mHeight;
+            private final long mSampleRate;
+            private final int mBitrate;
+        }
+        // taking bitrate from main profile, will also be supported by high profile
+        LevelLimitAV1[] limitsAV1 = {
+                new LevelLimitAV1(AV1Level2, 147456, 2048, 1152, 4423680, 1500000),
+                new LevelLimitAV1(AV1Level21, 278784, 2816, 1584, 8363520, 3000000),
+                new LevelLimitAV1(AV1Level3, 665856, 4352, 2448, 19975680, 6000000),
+                new LevelLimitAV1(AV1Level31, 1065024, 5504, 3096, 31950720, 10000000),
+                new LevelLimitAV1(AV1Level4, 2359296, 6144, 3456, 70778880, 12000000),
+                new LevelLimitAV1(AV1Level41, 2359296, 6144, 3456, 141557760, 20000000),
+                new LevelLimitAV1(AV1Level5, 8912896, 8192, 4352, 267386880, 30000000),
+                new LevelLimitAV1(AV1Level51, 8912896, 8192, 4352, 534773760, 40000000),
+                new LevelLimitAV1(AV1Level52, 8912896, 8192, 4352, 1069547520, 60000000),
+                new LevelLimitAV1(AV1Level53, 8912896, 8192, 4352, 1069547520, 60000000),
+                new LevelLimitAV1(AV1Level6, 35651584, 16384, 8704, 1069547520, 60000000),
+                new LevelLimitAV1(AV1Level61, 35651584, 16384, 8704, 2139095040, 100000000),
+                new LevelLimitAV1(AV1Level62, 35651584, 16384, 8704, 4278190080L, 160000000),
+                new LevelLimitAV1(AV1Level63, 35651584, 16384, 8704, 4278190080L, 160000000),
+        };
+        int blockSize = 8;
+        int blocks = divUp(width, blockSize) * divUp(height, blockSize);
+        int size = blocks * blockSize * blockSize;
+        int sampleRate = size * frameRate;
+        for (LevelLimitAV1 levelLimitsAV1 : limitsAV1) {
+            if (size <= levelLimitsAV1.mSize && width <= levelLimitsAV1.mWidth
+                    && height <= levelLimitsAV1.mHeight && sampleRate <= levelLimitsAV1.mSampleRate
+                    && bitrate <= levelLimitsAV1.mBitrate) {
+                return levelLimitsAV1.mLevel;
+            }
+        }
+        // if none of the levels suffice or high profile, select the highest level
+        return AV1Level73;
+    }
+
+    protected BitStreamUtils.ParserBase mParser;
+    protected Pair<Integer, Integer> mProfileLevel;
+    protected boolean mGotCsd;
+
+    public EncoderProfileLevelTestBase(String encoder, String mediaType,
+            EncoderConfigParams[] encCfgParams, String allTestParams) {
+        super(encoder, mediaType, encCfgParams, allTestParams);
+    }
+
+    @Override
+    protected void resetContext(boolean isAsync, boolean signalEOSWithLastFrame) {
+        super.resetContext(isAsync, signalEOSWithLastFrame);
+        mParser = BitStreamUtils.getParserObject(mMediaType);
+        mProfileLevel = null;
+        mGotCsd = false;
+    }
+
+    @Override
+    protected void dequeueOutput(int bufferIndex, MediaCodec.BufferInfo info) {
+        if (info.size > 0 && mProfileLevel == null) {
+            if ((info.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
+                ByteBuffer buf = mCodec.getOutputBuffer(bufferIndex);
+                mProfileLevel = BitStreamUtils.getProfileLevelFromBitStream(buf, info, mParser);
+                mGotCsd = true;
+            } else {
+                if ((mMediaType.equals(MediaFormat.MIMETYPE_VIDEO_VP9) || mMediaType.equals(
+                        MediaFormat.MIMETYPE_VIDEO_H263)) && mOutputCount == 0) {
+                    ByteBuffer buf = mCodec.getOutputBuffer(bufferIndex);
+                    mProfileLevel = BitStreamUtils.getProfileLevelFromBitStream(buf, info, mParser);
+                }
+            }
+        }
+        super.dequeueOutput(bufferIndex, info);
+    }
+
+    private int getProfile(MediaFormat format, String msg) {
+        // Query output profile. KEY_PROFILE gets precedence over KEY_AAC_PROFILE
+        int aacProfile = format.getInteger(MediaFormat.KEY_AAC_PROFILE, -1);
+        int profile = format.getInteger(MediaFormat.KEY_PROFILE, aacProfile);
+        if (profile != -1) {
+            return profile;
+        } else {
+            fail(msg + "profile key not present in format " + format + mTestConfig + mTestEnv);
+        }
+        return -1;
+    }
+
+    private int getLevel(MediaFormat format, String msg) {
+        assertTrue(msg + "level not present in format " + format + mTestConfig + mTestEnv,
+                format.containsKey(MediaFormat.KEY_LEVEL));
+        return format.getInteger(MediaFormat.KEY_LEVEL);
+    }
+
+    protected void validateProfile(int exp, int got, String msg) {
+        if (mMediaType.equals(MediaFormat.MIMETYPE_VIDEO_AVC)) {
+            if (exp == AVCProfileBaseline || exp == AVCProfileConstrainedBaseline) {
+                assertTrue(String.format(msg + "Profile information mismatch, Expected %d, Got %d ",
+                                exp, got) + mTestConfig + mTestEnv,
+                        (got == AVCProfileBaseline || got == AVCProfileConstrainedBaseline));
+                return;
+            } else if (exp == AVCProfileHigh || exp == AVCProfileConstrainedHigh) {
+                assertTrue(String.format(msg + "Profile information mismatch, Expected %d, Got %d ",
+                                exp, got) + mTestConfig + mTestEnv,
+                        (got == AVCProfileHigh || got == AVCProfileConstrainedHigh));
+                return;
+            }
+        }
+        assertEquals(String.format(msg + "Profile information mismatch, Expected %d, Got %d ",
+                exp, got) + mTestConfig + mTestEnv, exp, got);
+    }
+
+    protected void validateLevel(int exp, int got, String msg) {
+        assertEquals(String.format(msg + "Level information mismatch, Expected %d, Got %d ",
+                exp, got) + mTestConfig + mTestEnv, exp, got);
+    }
+
+    protected void validateMinLevel(int min, int got, String msg) {
+        assertTrue(String.format(msg + "Level information unexpected, Expected at least %d,"
+                + " Got %d ", min, got) + mTestConfig + mTestEnv, min <= got);
+    }
+
+    protected void validateBitStreamForProfileAndLevel(int cfgProfile, int cfgLevel) {
+        if (mProfileLevel != null) {
+            validateProfile(cfgProfile, mProfileLevel.first, "Validating profile of bitstream : ");
+            if (mProfileLevel.second != -1) {
+                validateMinLevel(cfgLevel, mProfileLevel.second,
+                        "Validating level of bitstream : ");
+            }
+        }
+    }
+
+    protected void validateFormatForProfileAndLevelWRTBitstream(MediaFormat format, String msg) {
+        if (mProfileLevel != null) {
+            validateProfile(mProfileLevel.first, getProfile(format, msg), msg);
+            if (mProfileLevel.second != -1) {
+                validateLevel(mProfileLevel.second, getLevel(format, msg), msg);
+            }
+        }
+    }
+
+    protected void validateFormatForProfileAndLevelWRTCfg(MediaFormat format, String msg) {
+        validateProfile(mActiveEncCfg.mProfile, getProfile(format, msg), msg);
+        if (mActiveEncCfg.mLevel != -1) {
+            validateMinLevel(mActiveEncCfg.mLevel, getLevel(format, msg), msg);
+        }
+    }
+
+    protected void validateFormatForProfileAndLevel(MediaFormat format, String msg) {
+        validateFormatForProfileAndLevelWRTBitstream(format, msg + " wrt to bitstream : ");
+        validateFormatForProfileAndLevelWRTCfg(format, msg + " wrt to cfg : ");
+    }
+
+    protected MediaFormat validateProfileAndLevel() throws IOException {
+        // check if bitstream is in accordance with configured profile and level info.
+        if (mProfileLevel != null) {
+            validateBitStreamForProfileAndLevel(mActiveEncCfg.mProfile, mActiveEncCfg.mLevel);
+        }
+
+        // check if output format is in accordance with configured profile and level info.
+        if (mCodecName.toUpperCase().startsWith("OMX")) {
+            Log.i(LOG_TAG, "omx components don't present prof/level in outputformat");
+        } else {
+            validateFormatForProfileAndLevel(mOutFormat, "Testing output format : ");
+        }
+
+        // check if extracted output profile and level information are in accordance with
+        // configured profile and level info
+        if (mMuxOutput && !mMediaType.equals(MediaFormat.MIMETYPE_VIDEO_H263)) {
+            // Explicit signaling of header information such as profile, level etc is not
+            // directly available as HLS in H263 header. That information is conveyed through
+            // external means of RTP header
+            MediaExtractor extractor = new MediaExtractor();
+            extractor.setDataSource(mMuxedOutputFile);
+            assertEquals("Should be only 1 track \n" + mTestConfig + mTestEnv, 1,
+                    extractor.getTrackCount());
+            MediaFormat trackFormat = extractor.getTrackFormat(0);
+            extractor.release();
+            if (mGotCsd || (trackFormat.containsKey(MediaFormat.KEY_PROFILE)
+                    || trackFormat.containsKey(MediaFormat.KEY_LEVEL))) {
+                validateFormatForProfileAndLevel(trackFormat, "Testing extractor format :- ");
+            }
+            return trackFormat;
+        }
+        return null;
+    }
+}
diff --git a/tests/media/src/android/mediav2/cts/CodecInfoTest.java b/tests/media/src/android/mediav2/cts/CodecInfoTest.java
index 5896b23..d295a59 100644
--- a/tests/media/src/android/mediav2/cts/CodecInfoTest.java
+++ b/tests/media/src/android/mediav2/cts/CodecInfoTest.java
@@ -19,28 +19,30 @@
 import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_Format32bitABGR2101010;
 import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface;
 import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible;
+import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar;
+import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar;
+import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar;
+import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar;
 import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUVP010;
 import static android.media.MediaCodecInfo.CodecCapabilities.FEATURE_HdrEditing;
-import static android.mediav2.common.cts.CodecTestBase.CONTEXT;
 import static android.mediav2.common.cts.CodecTestBase.FIRST_SDK_IS_AT_LEAST_T;
 import static android.mediav2.common.cts.CodecTestBase.IS_AT_LEAST_T;
+import static android.mediav2.common.cts.CodecTestBase.IS_HDR_CAPTURE_SUPPORTED;
 import static android.mediav2.common.cts.CodecTestBase.PROFILE_HDR10_MAP;
 import static android.mediav2.common.cts.CodecTestBase.PROFILE_HDR10_PLUS_MAP;
-import static android.mediav2.common.cts.CodecTestBase.PROFILE_HDR_MAP;
 import static android.mediav2.common.cts.CodecTestBase.VNDK_IS_AT_LEAST_T;
+import static android.mediav2.common.cts.CodecTestBase.canDisplaySupportHDRContent;
 import static android.mediav2.common.cts.CodecTestBase.isVendorCodec;
 import static android.mediav2.common.cts.CodecTestBase.selectCodecs;
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import android.hardware.display.DisplayManager;
 import android.media.MediaCodecInfo;
 import android.media.MediaCodecInfo.CodecProfileLevel;
 import android.media.MediaCodecList;
 import android.mediav2.common.cts.CodecTestBase;
 import android.os.Build;
-import android.view.Display;
 
 import androidx.test.filters.SmallTest;
 
@@ -68,19 +70,11 @@
 @RunWith(Parameterized.class)
 public class CodecInfoTest {
     private static final String LOG_TAG = CodecInfoTest.class.getSimpleName();
-    private static final int[] DISPLAY_HDR_TYPES;
 
     public String mMediaType;
     public String mCodecName;
     public MediaCodecInfo mCodecInfo;
 
-    static {
-        DisplayManager displayManager = CONTEXT.getSystemService(DisplayManager.class);
-        DISPLAY_HDR_TYPES =
-                displayManager.getDisplay(Display.DEFAULT_DISPLAY).getHdrCapabilities()
-                        .getSupportedHdrTypes();
-    }
-
     public CodecInfoTest(String mediaType, String codecName, MediaCodecInfo codecInfo) {
         mMediaType = mediaType;
         mCodecName = codecName;
@@ -145,7 +139,7 @@
             // native level, separate the following to independent checks for HDR10 and HDR10+
             if (isHdr10Profile || isHdr10PlusProfile) {
                 assertTrue(mCodecInfo.getName() + " Advertises support for HDR10/HDR10+ profile " +
-                        pl.profile + " without any HDR display", DISPLAY_HDR_TYPES.length > 0);
+                        pl.profile + " without any HDR display", canDisplaySupportHDRContent());
             }
         }
     }
@@ -155,7 +149,8 @@
      * formats. The test only checks if the decoder/encoder is advertising the required color
      * format. It doesn't verify if it actually supports by decoding/encoding.
      */
-    @CddTest(requirements = {"5.1.7/C-1-2", "5.1.7/C-4-1", "5.12/C-6-5", "5.12/C-7-3"})
+    @CddTest(requirements = {"5.1.7/C-1-2", "5.1.7/C-1-3", "5.1.7/C-4-1", "5.12/C-6-5",
+            "5.12/C-7-1", "5.12/C-7-3"})
     @Test
     public void testColorFormatSupport() {
         Assume.assumeTrue("Test is applicable for video codecs", mMediaType.startsWith("video/"));
@@ -164,20 +159,54 @@
                 IntStream.of(caps.colorFormats)
                         .noneMatch(x -> x == COLOR_FormatYUV420Flexible));
 
-        // Encoders that support FEATURE_HdrEditing, must support P010 and ABGR2101010
-        // color format and at least one HDR profile
-        boolean hdrEditingSupported = caps.isFeatureSupported(FEATURE_HdrEditing);
-        if (mCodecInfo.isEncoder() && hdrEditingSupported) {
-            boolean abgr2101010Supported =
-                    IntStream.of(caps.colorFormats)
-                            .anyMatch(x -> x == COLOR_Format32bitABGR2101010);
-            boolean p010Supported =
-                    IntStream.of(caps.colorFormats).anyMatch(x -> x == COLOR_FormatYUVP010);
-            assertTrue(mCodecName + " supports FEATURE_HdrEditing, but does not support " +
-                    "COLOR_FormatABGR2101010 and COLOR_FormatYUVP010 color formats.",
-                    abgr2101010Supported && p010Supported);
-            assertTrue(mCodecName + " supports FEATURE_HdrEditing, but does not support any HDR " +
-                    "profiles.", CodecTestBase.doesCodecSupportHDRProfile(mCodecName, mMediaType));
+        assertFalse(mCodecInfo.getName()
+                        + " does not support at least one of planar or semi planar yuv 420 888",
+                IntStream.of(caps.colorFormats)
+                        .noneMatch(x -> x == COLOR_FormatYUV420PackedPlanar)
+                        && IntStream.of(caps.colorFormats)
+                        .noneMatch(x -> x == COLOR_FormatYUV420Planar)
+                        && IntStream.of(caps.colorFormats)
+                        .noneMatch(x -> x == COLOR_FormatYUV420PackedSemiPlanar)
+                        && IntStream.of(caps.colorFormats)
+                        .noneMatch(x -> x == COLOR_FormatYUV420SemiPlanar));
+
+        boolean canHandleHdr = CodecTestBase.doesCodecSupportHDRProfile(mCodecName, mMediaType);
+        if (mCodecInfo.isEncoder()) {
+            if (IS_HDR_CAPTURE_SUPPORTED && canHandleHdr) {
+                assertFalse(mCodecInfo.getName()
+                                + " supports HDR profile but does not support COLOR_FormatYUVP010",
+                        IntStream.of(caps.colorFormats).noneMatch(x -> x == COLOR_FormatYUVP010));
+            }
+
+            // Encoders that support FEATURE_HdrEditing, must support ABGR2101010 color format
+            // and at least one HDR profile
+            boolean hdrEditingSupported = caps.isFeatureSupported(FEATURE_HdrEditing);
+            if (hdrEditingSupported) {
+                boolean abgr2101010Supported = IntStream.of(caps.colorFormats)
+                        .anyMatch(x -> x == COLOR_Format32bitABGR2101010);
+                assertTrue(mCodecName + " supports FEATURE_HdrEditing, but does not support"
+                        + " COLOR_FormatABGR2101010 color formats.", abgr2101010Supported);
+                assertTrue(mCodecName + " supports FEATURE_HdrEditing, but does not support"
+                        + " any HDR profiles.", canHandleHdr);
+            }
+        } else {
+            if (FIRST_SDK_IS_AT_LEAST_T && VNDK_IS_AT_LEAST_T && canDisplaySupportHDRContent()) {
+                if (MediaUtils.isTv()) {
+                    // Some TV devices support HDR10 display with VO instead of GPU. In this
+                    // case, skip checking P010 on TV devices.
+                    Assume.assumeFalse(mCodecInfo.getName()
+                                    + " supports HDR profile but does not support "
+                                    + "COLOR_FormatYUVP010. Skip checking on TV device",
+                            IntStream.of(caps.colorFormats)
+                                    .noneMatch(x -> x == COLOR_FormatYUVP010));
+                } else {
+                    assertFalse(mCodecInfo.getName()
+                                    + " supports HDR profile but does not support "
+                                    + "COLOR_FormatYUVP010",
+                            IntStream.of(caps.colorFormats)
+                                    .noneMatch(x -> x == COLOR_FormatYUVP010));
+                }
+            }
         }
 
         // COLOR_FormatSurface support is an existing requirement, but we did not
@@ -190,41 +219,6 @@
         }
     }
 
-    /** For devices launching with Android T or higher, if a codec supports an HDR profile and
-     * device supports HDR display, it must support COLOR_FormatYUVP010 as a video decoder output
-     * format. For TVs, this requirement is optional.
-     */
-    @CddTest(requirements = "5.12/C-6-5")
-    @Test
-    public void testP010SupportForHDRDisplay() {
-        Assume.assumeTrue("Test is applicable for video codecs", mMediaType.startsWith("video/"));
-        MediaCodecInfo.CodecCapabilities caps = mCodecInfo.getCapabilitiesForType(mMediaType);
-        int[] HdrProfileArray = PROFILE_HDR_MAP.get(mMediaType);
-        if (FIRST_SDK_IS_AT_LEAST_T && VNDK_IS_AT_LEAST_T
-                && HdrProfileArray != null && DISPLAY_HDR_TYPES.length > 0) {
-            for (CodecProfileLevel pl : caps.profileLevels) {
-                if (IntStream.of(HdrProfileArray).anyMatch(x -> x == pl.profile)) {
-                    if (MediaUtils.isTv()) {
-                        // Some TV devices support HDR10 display with VO instead of GPU. In this
-                        // case, skip checking P010 on TV devices.
-                        Assume.assumeFalse(mCodecInfo.getName() + " supports HDR profile "
-                                        + pl.profile + ","
-                                        + " but does not support COLOR_FormatYUVP010."
-                                        + " Skip checking on TV device",
-                                IntStream.of(caps.colorFormats)
-                                        .noneMatch(x -> x == COLOR_FormatYUVP010));
-                    } else {
-                        assertFalse(mCodecInfo.getName() + " supports HDR profile "
-                                        + pl.profile + "," +
-                                        " but does not support COLOR_FormatYUVP010",
-                                IntStream.of(caps.colorFormats)
-                                        .noneMatch(x -> x == COLOR_FormatYUVP010));
-                    }
-                }
-            }
-        }
-    }
-
     /**
      * For all the available encoders on the device, the test checks if their encoding
      * capabilities are in sync with the device's decoding capabilities.
diff --git a/tests/media/src/android/mediav2/cts/EncoderProfileLevelTest.java b/tests/media/src/android/mediav2/cts/EncoderProfileLevelTest.java
index 025f130..9a6b350 100644
--- a/tests/media/src/android/mediav2/cts/EncoderProfileLevelTest.java
+++ b/tests/media/src/android/mediav2/cts/EncoderProfileLevelTest.java
@@ -24,15 +24,12 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
 
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
-import android.media.MediaExtractor;
 import android.media.MediaFormat;
-import android.media.MediaMuxer;
-import android.mediav2.common.cts.CodecEncoderTestBase;
 import android.mediav2.common.cts.EncoderConfigParams;
+import android.mediav2.common.cts.EncoderProfileLevelTestBase;
 import android.mediav2.common.cts.OutputManager;
 import android.util.Log;
 import android.util.Pair;
@@ -45,9 +42,7 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
-import java.io.File;
 import java.io.IOException;
-import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -59,23 +54,26 @@
  * in its codec capabilities. The test sets profile and level keys in media format and uses it
  * during encoder configuration. Upon successful configuration, frames are queued for encoding
  * (byte buffer mode) and the encoded output (bitstream) is expected to contain the same profile
- * and level information that was used during configure.
+ * that was used during configure. The level shall be at least the input configured level.
  * <p>
- * NOTE: The test configures profile, level information basing on standard guidelines, not
- * arbitrarily so encoders ARE expected to place these values in the bitstream as-is.
+ * NOTE: The test configures level information basing on standard guidelines, not arbitrarily so
+ * encoders are expected to maintain at least the input configured level
  * <p>
- * The test additionally checks if the output format returned by component contains same profile
- * and level information. Having output format contain this information is useful during muxing
+ * The test parses the bitstream (csd or frame header) and determines profile and level
+ * information. This serves as reference for further validation. The test checks if the output
+ * format returned by component contains same profile and level information as the bitstream. The
+ * output of encoder is muxed and is extracted. The extracted format is expected to contain same
+ * profile and level information as the bitstream.
  * <p>
  * As per cdd, if a device contains an encoder capable of encoding a profile/level combination
  * then it should contain a decoder capable of decoding the same profile/level combination. This
  * is verified.
  * <p>
  * If device implementations support encoding in a media type, then as per cdd they are expected to
- * handle certain profile and level configurations. This is verified as well.
+ * handle certain profile and level configurations. This is verified.
  */
 @RunWith(Parameterized.class)
-public class EncoderProfileLevelTest extends CodecEncoderTestBase {
+public class EncoderProfileLevelTest extends EncoderProfileLevelTestBase {
     private static final String LOG_TAG = EncoderProfileLevelTest.class.getSimpleName();
     private static final HashMap<String, Pair<int[], Integer>> PROFILE_LEVEL_CDD = new HashMap<>();
 
@@ -85,16 +83,52 @@
         super(encoder, mediaType, encCfgParams, allTestParams);
     }
 
+    private static List<Object[]> prepareTestArgs(Object[] arg, int[] profiles, int colorFormat) {
+        List<Object[]> argsList = new ArrayList<>();
+        final int[] maxBFrames = {0, 2};
+        final String mediaType = (String) arg[0];
+        boolean isVideo = mediaType.startsWith("video/");
+        final int br = (int) arg[1];
+        final int param1 = (int) arg[2];
+        final int param2 = (int) arg[3];
+        final int fps = (int) arg[4];
+        if (isVideo) {
+            for (int maxBframe : maxBFrames) {
+                if (maxBframe != 0) {
+                    if (!mediaType.equals(MediaFormat.MIMETYPE_VIDEO_AVC)
+                            && !mediaType.equals(MediaFormat.MIMETYPE_VIDEO_HEVC)) {
+                        continue;
+                    }
+                }
+                Object[] testArgs = new Object[3];
+                testArgs[0] = arg[0];
+                testArgs[1] = getVideoEncoderCfgParams(mediaType, br, param1, param2, fps,
+                        colorFormat, maxBframe, profiles);
+                testArgs[2] = String.format("%dkbps_%dx%d_%dfps_%s_%d-bframes", br / 1000, param1,
+                        param2, fps, colorFormatToString(colorFormat, -1), maxBframe);
+                argsList.add(testArgs);
+            }
+        } else {
+            Object[] testArgs = new Object[3];
+            testArgs[0] = arg[0];
+            testArgs[1] = getAudioEncoderCfgParams(mediaType, br, param1, param2, profiles);
+            testArgs[2] = String.format("%dkbps_%dkHz_%dch", br / 1000, param1 / 1000, param2);
+            argsList.add(testArgs);
+        }
+        return argsList;
+    }
+
     private static EncoderConfigParams[] getVideoEncoderCfgParams(String mediaType, int bitRate,
             int width, int height, int frameRate, int colorFormat, int maxBframe, int[] profiles) {
         ArrayList<EncoderConfigParams> cfgParams = new ArrayList<>();
         for (int profile : profiles) {
             int level = getMinLevel(mediaType, width, height, frameRate, bitRate, profile);
-            if (mediaType.equals(MediaFormat.MIMETYPE_VIDEO_AVC)
-                    && maxBframe != 0
-                    && (profile == AVCProfileBaseline
-                    || profile == AVCProfileConstrainedBaseline)) {
-                continue;
+            if (maxBframe != 0) {
+                if (mediaType.equals(MediaFormat.MIMETYPE_VIDEO_AVC) && (
+                        profile == AVCProfileBaseline
+                                || profile == AVCProfileConstrainedBaseline)) {
+                    continue;
+                }
             }
             cfgParams.add(new EncoderConfigParams.Builder(mediaType)
                     .setBitRate(bitRate)
@@ -134,166 +168,133 @@
                 {MediaFormat.MIMETYPE_AUDIO_AAC, 64000, 48000, 1, -1},
                 {MediaFormat.MIMETYPE_AUDIO_AAC, 128000, 48000, 2, -1},
                 // Video - CodecMediaType, bit-rate, height, width, frame-rate
-                // TODO (b/151423508)
-                /*{MediaFormat.MIMETYPE_VIDEO_AVC, 64000, 176, 144, 15},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 128000, 176, 144, 15},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 192000, 352, 288, 7},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 384000, 352, 288, 15},*/
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 768000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 2000000, 352, 288, 30},
-                // TODO (b/151423508)
-                /*{MediaFormat.MIMETYPE_VIDEO_AVC, 4000000, 352, 576, 25},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 4000000, 720, 576, 12},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 10000000, 720, 576, 25},*/
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 14000000, 1280, 720, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 20000000, 1280, 1024, 42},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 20000000, 2048, 1024, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 50000000, 2048, 1024, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 50000000, 2048, 1080, 60},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 135000000, 3672, 1536, 25},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 240000000, 4096, 2304, 25},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 240000000, 4096, 2304, 50},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 240000000, 8192, 4320, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 480000000, 8192, 4320, 60},
-                {MediaFormat.MIMETYPE_VIDEO_AVC, 800000000, 8192, 4320, 120},
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 64000, 128, 96, 30},  // AVCLevel1
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 128000, 176, 144, 15}, // AVCLevel1b
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 192000, 320, 240, 10},  // AVCLevel11
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 384000, 320, 240, 20},  // AVCLevel12
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 512000, 352, 240, 30},  // AVCLevel13
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 832000, 352, 288, 30},  // AVCLevel2
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 1000000, 352, 576, 25},  // AVCLevel21
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 1500000, 640, 480, 15},  // AVCLevel22
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 2000000, 720, 480, 30},  // AVCLevel3
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 3000000, 1280, 720, 30},  // AVCLevel31
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 6000000, 1280, 1024, 42},  // AVCLevel32
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 10000000, 1920, 1088, 30},  // AVCLevel4
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 25000000, 2048, 1024, 30},  // AVCLevel41
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 50000000, 2048, 1088, 60},  // AVCLevel42
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 60000000, 2560, 1920, 30},  // AVCLevel5
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 80000000, 4096, 2048, 30},  // AVCLevel51
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 120000000, 4096, 2160, 60},  // AVCLevel52
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 240000000, 8192, 4320, 30},  // AVCLevel6
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 480000000, 8192, 4320, 60},  // AVCLevel61
+                {MediaFormat.MIMETYPE_VIDEO_AVC, 800000000, 8192, 4320, 120},  // AVCLevel62
 
-                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 4000000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 15000000, 720, 576, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 60000000, 1440, 1088, 60},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 80000000, 1920, 1088, 60},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 80000000, 1920, 1088, 60},
+                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 4000000, 352, 288, 30},  // MPEG2LevelLL
+                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 15000000, 720, 480, 30},  // MPEG2LevelML
+                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 60000000, 1440, 1088, 30},  // MPEG2LevelH14
+                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 80000000, 1920, 1088, 30},  // MPEG2LevelHL
+                {MediaFormat.MIMETYPE_VIDEO_MPEG2, 80000000, 1920, 1088, 60},  // MPEG2LevelHP
 
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 64000, 176, 144, 15},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 64000, 176, 144, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 128000, 176, 144, 15},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 128000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 384000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 4000000, 640, 480, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 8000000, 720, 576, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 12000000, 1280, 720, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 128000, 176, 144, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 384000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 768000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 1500000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 3000000, 704, 576, 30},
-                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 8000000, 720, 576, 30},
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 200000, 256, 144, 15},  // VP9Level1
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 512000, 384, 192, 30},  // VP9Level11
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 1000000, 480, 256, 30},  // VP9Level2
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 1500000, 640, 384, 30},  // VP9Level21
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 1600000, 720, 480, 30},  // VP9Level3
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 4000000, 1280, 720, 30},  // VP9Level31
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 5000000, 1920, 1080, 30},  // VP9Level4
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 16000000, 2048, 1088, 60},  // VP9Level41
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 20000000, 3840, 2160, 30},  // VP9Level5
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 80000000, 4096, 2176, 60},  // VP9Level51
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 160000000, 4096, 2176, 120},  // VP9Level52
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 180000000, 8192, 4352, 30},  // VP9Level6
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 240000000, 8192, 4352, 60},  // VP9Level61
+                {MediaFormat.MIMETYPE_VIDEO_VP9, 480000000, 8192, 4352, 120},  // VP9Level62
 
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 200000, 256, 144, 15},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 8000000, 384, 192, 30},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 1800000, 480, 256, 30},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 3600000, 640, 384, 30},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 7200000, 1080, 512, 30},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 12000000, 1280, 768, 30},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 18000000, 2048, 1088, 30},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 30000000, 2048, 1088, 60},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 60000000, 4096, 2176, 30},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 120000000, 4096, 2176, 60},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 180000000, 4096, 2176, 120},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 180000000, 8192, 4352, 30},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 240000000, 8192, 4352, 60},
-                {MediaFormat.MIMETYPE_VIDEO_VP9, 480000000, 8192, 4352, 120},
+                {MediaFormat.MIMETYPE_VIDEO_H263, 64000, 176, 144, 15},  // H263Level10
+                {MediaFormat.MIMETYPE_VIDEO_H263, 128000, 176, 144, 15},  // H263Level45
+                {MediaFormat.MIMETYPE_VIDEO_H263, 128000, 352, 288, 15},  // H263Level20
+                {MediaFormat.MIMETYPE_VIDEO_H263, 384000, 352, 288, 30},  // H263Level30
+                {MediaFormat.MIMETYPE_VIDEO_H263, 2048000, 352, 288, 30},  // H263Level40
+                {MediaFormat.MIMETYPE_VIDEO_H263, 4096000, 352, 240, 60},  // H263Level50
+                {MediaFormat.MIMETYPE_VIDEO_H263, 8192000, 720, 240, 60},  // H263Level60
+                {MediaFormat.MIMETYPE_VIDEO_H263, 16384000, 720, 576, 50},  // H263Level70
 
-                {MediaFormat.MIMETYPE_VIDEO_H263, 64000, 176, 144, 15},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 128000, 176, 144, 15},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 128000, 176, 144, 30},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 128000, 352, 288, 15},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 384000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 2048000, 352, 288, 30},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 4096000, 352, 240, 60},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 4096000, 352, 288, 50},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 8192000, 720, 240, 60},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 8192000, 720, 288, 50},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 16384000, 720, 480, 60},
-                {MediaFormat.MIMETYPE_VIDEO_H263, 16384000, 720, 576, 50},
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 128000, 176, 144, 15},  // HEVCMainTierLevel1
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 512000, 352, 288, 30},  // HEVCMainTierLevel2
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 1000000, 640, 360, 30},  // HEVCMainTierLevel21
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 1000000, 512, 512, 30},  // HEVCMainTierLevel3
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 1600000, 720, 480, 30},  // HEVCMainTierLevel3
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 4000000, 1280, 720, 30},  // HEVCMainTierLevel31
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 5000000, 1920, 1080, 30},  // HEVCMainTierLevel4
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 16000000, 1920, 1080, 30},  // HEVCHighTierLevel4
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 20000000, 1920, 1080, 60},  // HEVCMainTierLevel41
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 30000000, 1920, 1080, 60},  // HEVCHighTierLevel41
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 20000000, 3840, 2160, 30},  // HEVCMainTierLevel5
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 50000000, 3840, 2160, 30},  // HEVCHighTierLevel5
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 40000000, 3840, 2160, 60},  // HEVCMainTierLevel51
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 80000000, 3840, 2160, 60},  // HEVCHighTierLevel51
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 50000000, 3840, 2160, 120}, // HEVCMainTierLevel52
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 100000000, 3840, 2160, 120}, //HEVCHighTierLevel52
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 50000000, 7680, 4320, 30},  // HEVCMainTierLevel6
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 80000000, 7680, 4320, 30},  // HEVCHighTierLevel6
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 100000000, 7680, 4320, 60}, // HEVCMainTierLevel61
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 240000000, 7680, 4320, 60}, // HEVCHighTierLevel61
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 200000000, 7680, 4320, 120}, //HEVCMainTierLevel62
+                {MediaFormat.MIMETYPE_VIDEO_HEVC, 360000000, 7680, 4320, 120}, //HEVCHighTierLevel62
 
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 128000, 176, 144, 15},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 1500000, 352, 288, 30},
-                // TODO (b/152576008) - Limit HEVC Encoder test to 512x512
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 3000000, 512, 512, 30},
-                //{MediaFormat.MIMETYPE_VIDEO_HEVC, 3000000, 640, 360, 30},
-                //{MediaFormat.MIMETYPE_VIDEO_HEVC, 6000000, 960, 540, 30},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 10000000, 1280, 720, 33},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 12000000, 2048, 1080, 30},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 20000000, 2048, 1080, 60},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 25000000, 4096, 2160, 30},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 40000000, 4096, 2160, 60},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 60000000, 4096, 2160, 120},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 60000000, 8192, 4320, 30},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 120000000, 8192, 4320, 60},
-                {MediaFormat.MIMETYPE_VIDEO_HEVC, 240000000, 8192, 4320, 120},
-
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 1500000, 426, 240, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 3000000, 640, 360, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 6000000, 854, 480, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 10000000, 1280, 720, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 12000000, 1920, 1080, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 20000000, 1920, 1080, 60},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 30000000, 3840, 2160, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 40000000, 3840, 2160, 60},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 60000000, 3840, 2160, 120},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 60000000, 7680, 4320, 30},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 100000000, 7680, 4320, 60},
-                {MediaFormat.MIMETYPE_VIDEO_AV1, 160000000, 7680, 4320, 120},
-
-                {MediaFormat.MIMETYPE_VIDEO_VP8, 512000, 176, 144, 20},
-                {MediaFormat.MIMETYPE_VIDEO_VP8, 512000, 480, 360, 20},
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 1500000, 426, 240, 30},  // AV1Level2
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 3000000, 640, 360, 30},  // AV1Level21
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 6000000, 854, 480, 30},  // AV1Level3
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 10000000, 1280, 720, 30},  // AV1Level31
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 12000000, 1920, 1080, 30},  // AV1Level4
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 20000000, 1920, 1080, 60},  // AV1Level41
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 30000000, 3840, 2160, 30},  // AV1Level5
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 40000000, 3840, 2160, 60},  // AV1Level51
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 60000000, 3840, 2160, 120},  // AV1Level52
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 60000000, 7680, 4320, 30},  // AV1Level6
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 100000000, 7680, 4320, 60},  // AV1Level61
+                {MediaFormat.MIMETYPE_VIDEO_AV1, 160000000, 7680, 4320, 120},  // AV1Level62
         };
         final List<Object[]> argsList = new ArrayList<>();
-        final int[] maxBFrames = {0, 2};
         for (Object[] arg : exhaustiveArgsList) {
             final String mediaType = (String) arg[0];
-            boolean isVideo = mediaType.startsWith("video/");
-            final int br = (int) arg[1];
-            final int param1 = (int) arg[2];
-            final int param2 = (int) arg[3];
-            final int fps = (int) arg[4];
-            Object[] testArgs = new Object[3];
-            testArgs[0] = arg[0];
-            if (isVideo) {
-                for (int maxBframe : maxBFrames) {
-                    if (maxBframe != 0) {
-                        if (!mediaType.equals(MediaFormat.MIMETYPE_VIDEO_AVC)
-                                && !mediaType.equals(MediaFormat.MIMETYPE_VIDEO_HEVC)) {
-                            continue;
-                        }
-                    }
-                    testArgs[1] = getVideoEncoderCfgParams(mediaType, br, param1, param2, fps,
-                            COLOR_FormatYUV420Flexible, maxBframe,
-                            Objects.requireNonNull(PROFILE_SDR_MAP.get(mediaType)));
-                    testArgs[2] = String.format("%dkbps_%dx%d_%dfps_%s_%d-bframes", br / 1000,
-                            param1, param2, fps, colorFormatToString(COLOR_FormatYUV420Flexible, 8),
-                            maxBframe);
-                    argsList.add(testArgs);
-                }
-            } else {
-                testArgs[1] = getAudioEncoderCfgParams(mediaType, br, param1, param2,
-                        Objects.requireNonNull(PROFILE_SDR_MAP.get(mediaType)));
-                testArgs[2] = String.format("%dkbps_%dkHz_%dch", br / 1000, param1 / 1000, param2);
-                argsList.add(testArgs);
-            }
-
+            argsList.addAll(prepareTestArgs(arg,
+                    Objects.requireNonNull(PROFILE_SDR_MAP.get(mediaType)),
+                    COLOR_FormatYUV420Flexible));
             // P010 support was added in Android T, hence limit the following tests to Android
             // T and above
             if (IS_AT_LEAST_T && PROFILE_HLG_MAP.get(mediaType) != null) {
-                for (int maxBframe : maxBFrames) {
-                    if (maxBframe != 0) {
-                        if (!mediaType.equals(MediaFormat.MIMETYPE_VIDEO_HEVC)
-                                && !mediaType.equals(MediaFormat.MIMETYPE_VIDEO_AVC)) {
-                            continue;
-                        }
-                    }
-                    testArgs = new Object[3];
-                    testArgs[0] = arg[0];
-                    testArgs[1] = getVideoEncoderCfgParams(mediaType, br, param1, param2, fps,
-                            COLOR_FormatYUVP010, maxBframe,
-                            Objects.requireNonNull(PROFILE_HLG_MAP.get(mediaType)));
-                    testArgs[2] = String.format("%dkbps_%dx%d_%dfps_%s_%d-bframes", br / 1000,
-                            param1, param2, fps, colorFormatToString(COLOR_FormatYUVP010, 10),
-                            maxBframe);
-                    argsList.add(testArgs);
-                }
+                argsList.addAll(prepareTestArgs(arg,
+                        Objects.requireNonNull(PROFILE_HLG_MAP.get(mediaType)),
+                        COLOR_FormatYUVP010));
             }
         }
+        final Object[][] mpeg4SimpleProfileArgsList = new Object[][]{
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 64000, 176, 144, 15},  // MPEG4Level0 @sp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 128000, 176, 144, 15},  // MPEG4Level0b @sp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 64000, 128, 96, 30},  // MPEG4Level1 @sp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 128000, 352, 288, 15},  // MPEG4Level2 @sp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 384000, 352, 288, 30},  // MPEG4Level3 @sp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 4000000, 640, 480, 30},  // MPEG4Level4a @sp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 8000000, 720, 576, 24},  // MPEG4Level5 @sp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 12000000, 1280, 720, 30},  // MPEG4Level6 @sp
+        };
+        for (Object[] arg : mpeg4SimpleProfileArgsList) {
+            argsList.addAll(prepareTestArgs(arg, new int[]{MPEG4ProfileSimple},
+                    COLOR_FormatYUV420Flexible));
+        }
+        final Object[][] mpeg4AdvSimpleProfileArgsList = new Object[][]{
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 128000, 176, 144, 30},  // MPEG4Level1 @ asp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 384000, 352, 288, 15},  // MPEG4Level2 @ asp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 768000, 352, 288, 30},  // MPEG4Level3 @ asp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 1500000, 352, 288, 30},  // MPEG4Level3b @ asp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 3000000, 704, 576, 15},  // MPEG4Level4 @ asp
+                {MediaFormat.MIMETYPE_VIDEO_MPEG4, 8000000, 720, 576, 30},  // MPEG4Level5 @ asp
+        };
+        for (Object[] arg : mpeg4AdvSimpleProfileArgsList) {
+            argsList.addAll(prepareTestArgs(arg, new int[]{MPEG4ProfileAdvancedSimple},
+                    COLOR_FormatYUV420Flexible));
+        }
         return prepareParamList(argsList, isEncoder, needAudio, needVideo, false);
     }
 
@@ -306,601 +307,134 @@
                 new Pair<>(new int[]{AVCProfileBaseline}, AVCLevel3));
         PROFILE_LEVEL_CDD.put(MediaFormat.MIMETYPE_VIDEO_HEVC,
                 new Pair<>(new int[]{HEVCProfileMain}, HEVCMainTierLevel3));
-        PROFILE_LEVEL_CDD.put(MediaFormat.MIMETYPE_VIDEO_VP8,
-                new Pair<>(new int[]{VP8ProfileMain}, VP8Level_Version0));
         PROFILE_LEVEL_CDD.put(MediaFormat.MIMETYPE_VIDEO_VP9,
                 new Pair<>(new int[]{VP9Profile0}, VP9Level3));
     }
 
-    private static int getMinLevel(String mediaType, int width, int height, int frameRate,
-            int bitrate, int profile) {
-        switch (mediaType) {
-            case MediaFormat.MIMETYPE_VIDEO_AVC:
-                return getMinLevelAVC(width, height, frameRate, bitrate);
-            case MediaFormat.MIMETYPE_VIDEO_HEVC:
-                return getMinLevelHEVC(width, height, frameRate, bitrate);
-            case MediaFormat.MIMETYPE_VIDEO_H263:
-                return getMinLevelH263(width, height, frameRate, bitrate);
-            case MediaFormat.MIMETYPE_VIDEO_MPEG2:
-                return getMinLevelMPEG2(width, height, frameRate, bitrate);
-            case MediaFormat.MIMETYPE_VIDEO_MPEG4:
-                return getMinLevelMPEG4(width, height, frameRate, bitrate, profile);
-            // complex features disabled in VP8 Level/Version 0
-            case MediaFormat.MIMETYPE_VIDEO_VP8:
-                return VP8Level_Version0;
-            case MediaFormat.MIMETYPE_VIDEO_VP9:
-                return getMinLevelVP9(width, height, frameRate, bitrate);
-            case MediaFormat.MIMETYPE_VIDEO_AV1:
-                return getMinLevelAV1(width, height, frameRate, bitrate);
-            default:
-                return -1;
-        }
-    }
-
-    private static int getMinLevelAVC(int width, int height, int frameRate, int bitrate) {
-        class LevelLimitAVC {
-            private LevelLimitAVC(int level, int mbsPerSec, long mbs, int bitrate) {
-                this.level = level;
-                this.mbsPerSec = mbsPerSec;
-                this.mbs = mbs;
-                this.bitrate = bitrate;
-            }
-
-            private final int level;
-            private final int mbsPerSec;
-            private final long mbs;
-            private final int bitrate;
-        }
-        LevelLimitAVC[] limitsAVC = {
-                new LevelLimitAVC(AVCLevel1, 1485, 99, 64000),
-                new LevelLimitAVC(AVCLevel1b, 1485, 99, 128000),
-                new LevelLimitAVC(AVCLevel11, 3000, 396, 192000),
-                new LevelLimitAVC(AVCLevel12, 6000, 396, 384000),
-                new LevelLimitAVC(AVCLevel13, 11880, 396, 768000),
-                new LevelLimitAVC(AVCLevel2, 11880, 396, 2000000),
-                new LevelLimitAVC(AVCLevel21, 19800, 792, 4000000),
-                new LevelLimitAVC(AVCLevel22, 20250, 1620, 4000000),
-                new LevelLimitAVC(AVCLevel3, 40500, 1620, 10000000),
-                new LevelLimitAVC(AVCLevel31, 108000, 3600, 14000000),
-                new LevelLimitAVC(AVCLevel32, 216000, 5120, 20000000),
-                new LevelLimitAVC(AVCLevel4, 245760, 8192, 20000000),
-                new LevelLimitAVC(AVCLevel41, 245760, 8192, 50000000),
-                new LevelLimitAVC(AVCLevel42, 522240, 8704, 50000000),
-                new LevelLimitAVC(AVCLevel5, 589824, 22080, 135000000),
-                new LevelLimitAVC(AVCLevel51, 983040, 36864, 240000000),
-                new LevelLimitAVC(AVCLevel52, 2073600, 36864, 240000000),
-                new LevelLimitAVC(AVCLevel6, 4177920, 139264, 240000000),
-                new LevelLimitAVC(AVCLevel61, 8355840, 139264, 480000000),
-                new LevelLimitAVC(AVCLevel62, 16711680, 139264, 800000000),
-        };
-        int mbs = ((width + 15) / 16) * ((height + 15) / 16);
-        float mbsPerSec = mbs * frameRate;
-        for (LevelLimitAVC levelLimitsAVC : limitsAVC) {
-            if (mbs <= levelLimitsAVC.mbs && mbsPerSec <= levelLimitsAVC.mbsPerSec
-                    && bitrate <= levelLimitsAVC.bitrate) {
-                return levelLimitsAVC.level;
-            }
-        }
-        // if none of the levels suffice, select the highest level
-        return AVCLevel62;
-    }
-
-    private static int getMinLevelHEVC(int width, int height, int frameRate, int bitrate) {
-        class LevelLimitHEVC {
-            private LevelLimitHEVC(int level, int frameRate, long samples, int bitrate) {
-                this.level = level;
-                this.frameRate = frameRate;
-                this.samples = samples;
-                this.bitrate = bitrate;
-            }
-
-            private final int level;
-            private final int frameRate;
-            private final long samples;
-            private final int bitrate;
-        }
-        LevelLimitHEVC[] limitsHEVC = {
-                new LevelLimitHEVC(HEVCMainTierLevel1, 15, 36864, 128000),
-                new LevelLimitHEVC(HEVCMainTierLevel2, 30, 122880, 1500000),
-                new LevelLimitHEVC(HEVCMainTierLevel21, 30, 245760, 3000000),
-                new LevelLimitHEVC(HEVCMainTierLevel3, 30, 552960, 6000000),
-                new LevelLimitHEVC(HEVCMainTierLevel31, 30, 983040, 10000000),
-                new LevelLimitHEVC(HEVCMainTierLevel4, 30, 2228224, 12000000),
-                new LevelLimitHEVC(HEVCHighTierLevel4, 30, 2228224, 30000000),
-                new LevelLimitHEVC(HEVCMainTierLevel41, 60, 2228224, 20000000),
-                new LevelLimitHEVC(HEVCHighTierLevel41, 60, 2228224, 50000000),
-                new LevelLimitHEVC(HEVCMainTierLevel5, 30, 8912896, 25000000),
-                new LevelLimitHEVC(HEVCHighTierLevel5, 30, 8912896, 100000000),
-                new LevelLimitHEVC(HEVCMainTierLevel51, 60, 8912896, 40000000),
-                new LevelLimitHEVC(HEVCHighTierLevel51, 60, 8912896, 160000000),
-                new LevelLimitHEVC(HEVCMainTierLevel52, 120, 8912896, 60000000),
-                new LevelLimitHEVC(HEVCHighTierLevel52, 120, 8912896, 240000000),
-                new LevelLimitHEVC(HEVCMainTierLevel6, 30, 35651584, 60000000),
-                new LevelLimitHEVC(HEVCHighTierLevel6, 30, 35651584, 240000000),
-                new LevelLimitHEVC(HEVCMainTierLevel61, 60, 35651584, 120000000),
-                new LevelLimitHEVC(HEVCHighTierLevel61, 60, 35651584, 480000000),
-                new LevelLimitHEVC(HEVCMainTierLevel62, 120, 35651584, 240000000),
-                new LevelLimitHEVC(HEVCHighTierLevel62, 120, 35651584, 800000000),
-        };
-        int samples = width * height;
-        for (LevelLimitHEVC levelLimitsHEVC : limitsHEVC) {
-            if (samples <= levelLimitsHEVC.samples && frameRate <= levelLimitsHEVC.frameRate
-                    && bitrate <= levelLimitsHEVC.bitrate) {
-                return levelLimitsHEVC.level;
-            }
-        }
-        // if none of the levels suffice, select the highest level
-        return HEVCHighTierLevel62;
-    }
-
-    private static int getMinLevelH263(int width, int height, int frameRate, int bitrate) {
-        class LevelLimitH263 {
-            private LevelLimitH263(int level, int height, int width, int frameRate,
-                    int bitrate) {
-                this.level = level;
-                this.height = height;
-                this.width = width;
-                this.frameRate = frameRate;
-                this.bitrate = bitrate;
-            }
-
-            private final int level;
-            private final int height;
-            private final int width;
-            private final int frameRate;
-            private final int bitrate;
-        }
-        LevelLimitH263[] limitsH263 = {
-                new LevelLimitH263(H263Level10, 176, 144, 15, 64000),
-                new LevelLimitH263(H263Level45, 176, 144, 15, 128000),
-                new LevelLimitH263(H263Level20, 176, 144, 30, 128000),
-                new LevelLimitH263(H263Level20, 352, 288, 15, 128000),
-                new LevelLimitH263(H263Level30, 352, 288, 30, 384000),
-                new LevelLimitH263(H263Level40, 352, 288, 30, 2048000),
-                new LevelLimitH263(H263Level50, 352, 240, 60, 4096000),
-                new LevelLimitH263(H263Level50, 352, 288, 50, 4096000),
-                new LevelLimitH263(H263Level60, 720, 240, 60, 8192000),
-                new LevelLimitH263(H263Level60, 720, 288, 50, 8192000),
-                new LevelLimitH263(H263Level70, 720, 480, 60, 16384000),
-                new LevelLimitH263(H263Level70, 720, 576, 50, 16384000),
-        };
-        for (LevelLimitH263 levelLimitsH263 : limitsH263) {
-            if (height <= levelLimitsH263.height && width <= levelLimitsH263.width &&
-                    frameRate <= levelLimitsH263.frameRate && bitrate <= levelLimitsH263.bitrate) {
-                return levelLimitsH263.level;
-            }
-        }
-        // if none of the levels suffice, select the highest level
-        return H263Level70;
-    }
-
-    private static int getMinLevelVP9(int width, int height, int frameRate, int bitrate) {
-        class LevelLimitVP9 {
-            private LevelLimitVP9(int level, long sampleRate, int size, int breadth,
-                    int bitrate) {
-                this.level = level;
-                this.sampleRate = sampleRate;
-                this.size = size;
-                this.breadth = breadth;
-                this.bitrate = bitrate;
-            }
-
-            private final int level;
-            private final long sampleRate;
-            private final int size;
-            private final int breadth;
-            private final int bitrate;
-        }
-        LevelLimitVP9[] limitsVP9 = {
-                new LevelLimitVP9(VP9Level1, 829440, 36864, 512, 200000),
-                new LevelLimitVP9(VP9Level11, 2764800, 73728, 768, 800000),
-                new LevelLimitVP9(VP9Level2, 4608000, 122880, 960, 1800000),
-                new LevelLimitVP9(VP9Level21, 9216000, 245760, 1344, 3600000),
-                new LevelLimitVP9(VP9Level3, 20736000, 552960, 2048, 7200000),
-                new LevelLimitVP9(VP9Level31, 36864000, 983040, 2752, 12000000),
-                new LevelLimitVP9(VP9Level4, 83558400, 2228224, 4160, 18000000),
-                new LevelLimitVP9(VP9Level41, 160432128, 2228224, 4160, 30000000),
-                new LevelLimitVP9(VP9Level5, 311951360, 8912896, 8384, 60000000),
-                new LevelLimitVP9(VP9Level51, 588251136, 8912896, 8384, 120000000),
-                new LevelLimitVP9(VP9Level52, 1176502272, 8912896, 8384, 180000000),
-                new LevelLimitVP9(VP9Level6, 1176502272, 35651584, 16832, 180000000),
-                new LevelLimitVP9(VP9Level61, 2353004544L, 35651584, 16832, 240000000),
-                new LevelLimitVP9(VP9Level62, 4706009088L, 35651584, 16832, 480000000),
-        };
-        int size = width * height;
-        int sampleRate = size * frameRate;
-        int breadth = Math.max(width, height);
-        for (LevelLimitVP9 levelLimitsVP9 : limitsVP9) {
-            if (sampleRate <= levelLimitsVP9.sampleRate && size <= levelLimitsVP9.size &&
-                    breadth <= levelLimitsVP9.breadth && bitrate <= levelLimitsVP9.bitrate) {
-                return levelLimitsVP9.level;
-            }
-        }
-        // if none of the levels suffice, select the highest level
-        return VP9Level62;
-    }
-
-    private static int getMinLevelMPEG2(int width, int height, int frameRate, int bitrate) {
-        class LevelLimitMPEG2 {
-            private LevelLimitMPEG2(int level, long sampleRate, int width, int height,
-                    int frameRate, int bitrate) {
-                this.level = level;
-                this.sampleRate = sampleRate;
-                this.width = width;
-                this.height = height;
-                this.frameRate = frameRate;
-                this.bitrate = bitrate;
-            }
-
-            private final int level;
-            private final long sampleRate;
-            private final int width;
-            private final int height;
-            private final int frameRate;
-            private final int bitrate;
-        }
-        // main profile limits, higher profiles will also support selected level
-        LevelLimitMPEG2[] limitsMPEG2 = {
-                new LevelLimitMPEG2(MPEG2LevelLL, 3041280, 352, 288, 30, 4000000),
-                new LevelLimitMPEG2(MPEG2LevelML, 10368000, 720, 576, 30, 15000000),
-                new LevelLimitMPEG2(MPEG2LevelH14, 47001600, 1440, 1088, 60, 60000000),
-                new LevelLimitMPEG2(MPEG2LevelHL, 62668800, 1920, 1088, 60, 80000000),
-                new LevelLimitMPEG2(MPEG2LevelHP, 125337600, 1920, 1088, 60, 80000000),
-        };
-        int size = width * height;
-        int sampleRate = size * frameRate;
-        for (LevelLimitMPEG2 levelLimitsMPEG2 : limitsMPEG2) {
-            if (sampleRate <= levelLimitsMPEG2.sampleRate && width <= levelLimitsMPEG2.width &&
-                    height <= levelLimitsMPEG2.height && frameRate <= levelLimitsMPEG2.frameRate &&
-                    bitrate <= levelLimitsMPEG2.bitrate) {
-                return levelLimitsMPEG2.level;
-            }
-        }
-        // if none of the levels suffice, select the highest level
-        return MPEG2LevelHP;
-    }
-
-    private static int getMinLevelMPEG4(int width, int height, int frameRate, int bitrate,
-            int profile) {
-        class LevelLimitMPEG4 {
-            private LevelLimitMPEG4(int profile, int level, long sampleRate, int width,
-                    int height, int frameRate, int bitrate) {
-                this.profile = profile;
-                this.level = level;
-                this.sampleRate = sampleRate;
-                this.width = width;
-                this.height = height;
-                this.frameRate = frameRate;
-                this.bitrate = bitrate;
-            }
-
-            private final int profile;
-            private final int level;
-            private final long sampleRate;
-            private final int width;
-            private final int height;
-            private final int frameRate;
-            private final int bitrate;
-        }
-        // simple profile limits, higher profiles will also support selected level
-        LevelLimitMPEG4[] limitsMPEG4 = {
-                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level0, 380160, 176, 144, 15, 64000),
-                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level1, 380160, 176, 144, 30, 64000),
-                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level0b, 380160, 176, 144, 15, 128000),
-                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level2, 1520640, 352, 288, 30, 128000),
-                new LevelLimitMPEG4(MPEG4ProfileSimple, MPEG4Level3, 3041280, 352, 288, 30, 384000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileSimple, MPEG4Level4a, 9216000, 640, 480, 30, 4000000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileSimple, MPEG4Level5, 10368000, 720, 576, 30, 8000000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileSimple, MPEG4Level6, 27648000, 1280, 720, 30, 12000000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileAdvancedSimple, MPEG4Level1, 760320, 176, 144, 30, 128000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileAdvancedSimple, MPEG4Level2, 1520640, 352, 288, 30, 384000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileAdvancedSimple, MPEG4Level3, 3041280, 352, 288, 30, 768000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileAdvancedSimple, MPEG4Level3b, 3041280, 352, 288, 30, 1500000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileAdvancedSimple, MPEG4Level4, 3041280, 704, 576, 30, 3000000),
-                new LevelLimitMPEG4(
-                        MPEG4ProfileAdvancedSimple, MPEG4Level5, 3041280, 720, 576, 30, 8000000),
-        };
-        int size = width * height;
-        int sampleRate = size * frameRate;
-        for (LevelLimitMPEG4 levelLimitsMPEG4 : limitsMPEG4) {
-            if (((profile & (MPEG4ProfileAdvancedSimple | MPEG4ProfileSimple)) != 0) &&
-                    profile != levelLimitsMPEG4.profile) continue;
-            if (sampleRate <= levelLimitsMPEG4.sampleRate && width <= levelLimitsMPEG4.width &&
-                    height <= levelLimitsMPEG4.height && frameRate <= levelLimitsMPEG4.frameRate &&
-                    bitrate <= levelLimitsMPEG4.bitrate) {
-                return levelLimitsMPEG4.level;
-            }
-        }
-        // if none of the levels suffice, select the highest level
-        return MPEG4Level6;
-    }
-
-    private static int getMinLevelAV1(int width, int height, int frameRate, int bitrate) {
-        class LevelLimitAV1 {
-            private LevelLimitAV1(int level, int size, int width, int height, long sampleRate,
-                    int bitrate) {
-                this.level = level;
-                this.size = size;
-                this.width = width;
-                this.height = height;
-                this.sampleRate = sampleRate;
-                this.bitrate = bitrate;
-            }
-
-            private final int level;
-            private final int size;
-            private final int width;
-            private final int height;
-            private final long sampleRate;
-            private final int bitrate;
-        }
-        // taking bitrate from main profile, will also be supported by high profile
-        LevelLimitAV1[] limitsAV1 = {
-                new LevelLimitAV1(AV1Level2, 147456, 2048, 1152, 4423680, 1500000),
-                new LevelLimitAV1(AV1Level21, 278784, 2816, 1584, 8363520, 3000000),
-                new LevelLimitAV1(AV1Level3, 665856, 4352, 2448, 19975680, 6000000),
-                new LevelLimitAV1(AV1Level31, 1065024, 5504, 3096, 31950720, 10000000),
-                new LevelLimitAV1(AV1Level4, 2359296, 6144, 3456, 70778880, 12000000),
-                new LevelLimitAV1(AV1Level41, 2359296, 6144, 3456, 141557760, 20000000),
-                new LevelLimitAV1(AV1Level5, 8912896, 8192, 4352, 267386880, 30000000),
-                new LevelLimitAV1(AV1Level51, 8912896, 8192, 4352, 534773760, 40000000),
-                new LevelLimitAV1(AV1Level52, 8912896, 8192, 4352, 1069547520, 60000000),
-                new LevelLimitAV1(AV1Level53, 8912896, 8192, 4352, 1069547520, 60000000),
-                new LevelLimitAV1(AV1Level6, 35651584, 16384, 8704, 1069547520, 60000000),
-                new LevelLimitAV1(AV1Level61, 35651584, 16384, 8704, 2139095040, 100000000),
-                new LevelLimitAV1(AV1Level62, 35651584, 16384, 8704, 4278190080L, 160000000),
-                new LevelLimitAV1(AV1Level63, 35651584, 16384, 8704, 4278190080L, 160000000),
-        };
-        int size = width * height;
-        int sampleRate = size * frameRate;
-        for (LevelLimitAV1 levelLimitsAV1 : limitsAV1) {
-            if (size <= levelLimitsAV1.size && width <= levelLimitsAV1.width &&
-                    height <= levelLimitsAV1.height && sampleRate <= levelLimitsAV1.sampleRate &&
-                    bitrate <= levelLimitsAV1.bitrate) {
-                return levelLimitsAV1.level;
-            }
-        }
-        // if none of the levels suffice or high profile, select the highest level
-        return AV1Level73;
-    }
-
-    private int getAacProfile(MediaFormat format) {
-        int aacProfile = format.getInteger(MediaFormat.KEY_AAC_PROFILE, -1);
-        int profile = format.getInteger(MediaFormat.KEY_PROFILE, -1);
-
-        if (aacProfile != -1 && profile != -1) {
-            assertEquals(String.format("aac-profile :- %d and profile :- %d are different.",
-                    aacProfile, profile), aacProfile, profile);
-            return aacProfile;
-        } else if (aacProfile != -1) {
-            return aacProfile;
-        } else if (profile != -1) {
-            return profile;
+    void checkIfTrackFormatIsOk(MediaFormat trackFormat) {
+        assertEquals("Input media type and extracted media type are not identical " + mTestEnv
+                        + mTestConfig, mActiveEncCfg.mMediaType,
+                trackFormat.getString(MediaFormat.KEY_MIME));
+        if (mIsVideo) {
+            assertEquals("Input width and extracted width are not same " + mTestEnv + mTestConfig,
+                    mActiveEncCfg.mWidth, getWidth(trackFormat));
+            assertEquals("Input height and extracted height are not same " + mTestEnv + mTestConfig,
+                    mActiveEncCfg.mHeight, getHeight(trackFormat));
         } else {
-            Log.e(LOG_TAG, "format doesn't contain either KEY_AAC_PROFILE or KEY_PROFILE");
-            return -1;
+            int expSampleRate = mActiveEncCfg.mProfile != AACObjectHE ? mActiveEncCfg.mSampleRate
+                    : mActiveEncCfg.mSampleRate / 2;
+            int expChCount = mActiveEncCfg.mProfile != AACObjectHE_PS ? mActiveEncCfg.mChannelCount
+                    : mActiveEncCfg.mChannelCount / 2;
+            assertEquals("Input sample rate and extracted sample rate are not same " + mTestEnv
+                            + mTestConfig, expSampleRate,
+                    trackFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE));
+            assertEquals("Input channe count and extracted channel count are not same " + mTestEnv
+                            + mTestConfig, expChCount,
+                    trackFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT));
         }
     }
 
-    @Override
-    public boolean isFormatSimilar(MediaFormat inpFormat, MediaFormat outFormat) {
-        if (!super.isFormatSimilar(inpFormat, outFormat)) {
-            Log.e(LOG_TAG, "Basic channel-rate/resolution comparisons failed");
-            return false;
-        }
-        String inpMediaType = inpFormat.getString(MediaFormat.KEY_MIME);
-        String outMediaType = outFormat.getString(MediaFormat.KEY_MIME);
-        assertEquals(String.format("input mediaType :- %s and output mediaType :- %s are "
-                        + "different.", inpMediaType, outMediaType), inpMediaType, outMediaType);
-        if (outMediaType.startsWith("audio/")) {
-            if (outFormat.getString(MediaFormat.KEY_MIME).equals(MediaFormat.MIMETYPE_AUDIO_AAC)) {
-                int inputProfileKey, outputProfileKey;
-                outputProfileKey = getAacProfile(outFormat);
-                inputProfileKey = getAacProfile(inpFormat);
-                if (outputProfileKey != inputProfileKey) {
-                    Log.e(LOG_TAG, "aac-profile in output " + outputProfileKey +
-                            " doesn't match configured input " + inputProfileKey);
-                    return false;
+    private boolean shallSupportProfileAndLevel(EncoderConfigParams cfg) {
+        Pair<int[], Integer> cddProfileLevel =
+                Objects.requireNonNull(PROFILE_LEVEL_CDD.get(cfg.mMediaType));
+        int[] profileCdd = cddProfileLevel.first;
+        int levelCdd = cddProfileLevel.second;
+        for (int cddProfile : profileCdd) {
+            if (cfg.mProfile == cddProfile) {
+                if (!cfg.mIsAudio) {
+                    if (cfg.mLevel <= levelCdd) {
+                        if (cfg.mMediaType.equalsIgnoreCase(MediaFormat.MIMETYPE_VIDEO_H263)
+                                && cfg.mLevel != MediaCodecInfo.CodecProfileLevel.H263Level45
+                                && cfg.mLevel > MediaCodecInfo.CodecProfileLevel.H263Level10) {
+                            continue;
+                        }
+                    } else {
+                        continue;
+                    }
                 }
+                return true;
             }
-        } else if (outMediaType.startsWith("video/")) {
-            if (!outFormat.containsKey(MediaFormat.KEY_PROFILE)) {
-                Log.e(LOG_TAG, "Output format doesn't contain profile key");
-                //TODO (b/151398466)
-                if (true) return true;
-                return false;
-            }
-            if (!outFormat.containsKey(MediaFormat.KEY_LEVEL)) {
-                Log.e(LOG_TAG, "Output format doesn't contain level key");
-                //TODO (b/151398466)
-                if (true) return true;
-                return false;
-            }
-            if (!inpFormat.containsKey(MediaFormat.KEY_PROFILE)) {
-                Log.e(LOG_TAG, "Input format doesn't contain profile key");
-                return false;
-            }
-            if (!inpFormat.containsKey(MediaFormat.KEY_LEVEL)) {
-                Log.e(LOG_TAG, "Input format doesn't contain level key");
-                return false;
-            }
-            if (outFormat.getInteger(MediaFormat.KEY_PROFILE)
-                    != inpFormat.getInteger(MediaFormat.KEY_PROFILE)) {
-                Log.e(LOG_TAG, "profile in output doesn't match configured input");
-                return false;
-            }
-            if (outFormat.getInteger(MediaFormat.KEY_LEVEL)
-                    != inpFormat.getInteger(MediaFormat.KEY_LEVEL)) {
-                Log.e(LOG_TAG, "level key in output doesn't match configured input");
-                return false;
-            }
-        } else {
-            Log.w(LOG_TAG, "non media mediaType:" + outMediaType);
         }
-        return true;
+        return false;
     }
 
     /**
-     * @see EncoderProfileLevelTest
-     * Besides the above, the test muxes the encoder output in all supported container formats
-     * and checks if muxers and extractors on device are signalling profile/level information
-     * correctly
+     * Check description of class {@link EncoderProfileLevelTest}
      */
     @CddTest(requirements = {"2.2.2/5.1/H-0-3", "2.2.2/5.1/H-0-4", "2.2.2/5.1/H-0-5", "5/C-0-3",
-            "5.2.1/C-1-1", "5.2.2/C-2-1", "5.2.3/C-2-1", "5.2.4/C-1-2",
-            "5.2.5/C-1-1"})
+            "5.2.1/C-1-1", "5.2.2/C-1-1", "5.2.4/C-1-2", "5.2.5/C-1-1"})
     @ApiTest(apis = {"android.media.MediaFormat#KEY_PROFILE",
             "android.media.MediaFormat#KEY_AAC_PROFILE",
             "android.media.MediaFormat#KEY_LEVEL"})
     @Test(timeout = PER_TEST_TIMEOUT_LARGE_TEST_MS)
     public void testValidateProfileLevel() throws IOException, InterruptedException {
-        if (mEncCfgParams[0].mInputBitDepth != 8) {
+        if (mIsVideo && mEncCfgParams[0].mInputBitDepth != 8) {
             Assume.assumeTrue(mCodecName + " doesn't support " + colorFormatToString(
                             mEncCfgParams[0].mColorFormat, mEncCfgParams[0].mInputBitDepth),
                     hasSupportForColorFormat(mCodecName, mMediaType,
-                                             mEncCfgParams[0].mColorFormat));
+                            mEncCfgParams[0].mColorFormat));
         }
         boolean cddSupportedMediaType = PROFILE_LEVEL_CDD.get(mMediaType) != null;
-        int[] profileCdd = new int[0];
-        int levelCdd = 0;
-        if (cddSupportedMediaType) {
-            Pair<int[], Integer> cddProfileLevel = PROFILE_LEVEL_CDD.get(mMediaType);
-            profileCdd = cddProfileLevel.first;
-            levelCdd = cddProfileLevel.second;
-        }
 
         {
             mActiveRawRes = EncoderInput.getRawResource(mEncCfgParams[0]);
             assertNotNull("no raw resource found for testing config : "
-                    + mActiveEncCfg + mTestConfig + mTestEnv, mActiveRawRes);
+                    + mEncCfgParams[0] + mTestConfig + mTestEnv, mActiveRawRes);
             setUpSource(mActiveRawRes.mFileName);
             mSaveToMem = true;
+            mMuxOutput = true;
             mOutputBuff = new OutputManager();
             mCodec = MediaCodec.createByCodecName(mCodecName);
             MediaCodecInfo.CodecCapabilities codecCapabilities =
                     mCodec.getCodecInfo().getCapabilitiesForType(mMediaType);
+            int configsTested = 0;
             for (EncoderConfigParams cfg : mEncCfgParams) {
                 mActiveEncCfg = cfg;
                 MediaFormat format = cfg.getFormat();
                 if (!codecCapabilities.isFormatSupported(format)) {
                     if (cddSupportedMediaType) {
-                        boolean shallSupportProfileLevel = false;
-                        if (mIsAudio) {
-                            for (int cddProfile : profileCdd) {
-                                if (cfg.mProfile == cddProfile) {
-                                    shallSupportProfileLevel = true;
-                                    break;
-                                }
-                            }
-                        } else if (cfg.mProfile == profileCdd[0] && cfg.mLevel <= levelCdd) {
-                            shallSupportProfileLevel = true;
-                        }
-                        if (shallSupportProfileLevel) {
+                        if (shallSupportProfileAndLevel(cfg)) {
                             ArrayList<MediaFormat> formats = new ArrayList<>();
                             formats.add(format);
-                            assertFalse(String.format("No components present on the device supports"
-                                    + " cdd required profile:- %d, level:- %d, encode format:- %s",
-                                    cfg.mProfile, cfg.mLevel, format),
-                                    selectCodecs(mMediaType, formats, null, false).isEmpty());
+                            assertFalse("No components present on the device supports cdd "
+                                    + "required encode format:- " + format + mTestConfig + mTestEnv,
+                                    selectCodecs(mMediaType, formats, null, true).isEmpty());
                         }
                         Log.d(LOG_TAG, mCodecName + " doesn't support format: " + format);
                     }
                     continue;
                 }
 
-                // Verify if device has an equivalent decoder for the current format
-                {
-                    ArrayList<MediaFormat> formatList = new ArrayList<>();
-                    formatList.add(format);
-                    assertTrue("Device advertises support for encoding " + format
-                                    + " but cannot decode it. \n" + mTestConfig + mTestEnv,
-                            selectCodecs(mMediaType, formatList, null, false).size() > 0);
-                }
-
                 mOutputBuff.reset();
                 configureCodec(format, false, true, true);
                 mCodec.start();
                 doWork(5);
                 queueEOS();
                 waitForAllOutputs();
-                MediaFormat outFormat = mCodec.getOutputFormat();
-                /* TODO(b/147348711) */
-                if (false) mCodec.stop();
-                else mCodec.reset();
+                mCodec.reset();
 
-                // TODO (b/151398466)
-                if (mMediaType.equals(MediaFormat.MIMETYPE_AUDIO_AAC)) {
-                    Assume.assumeTrue("neither KEY_AAC_PROFILE nor KEY_PROFILE are present",
-                            outFormat.containsKey(MediaFormat.KEY_AAC_PROFILE) ||
-                                    outFormat.containsKey(MediaFormat.KEY_PROFILE));
-                } else {
-                    Assume.assumeTrue("KEY_PROFILE not present",
-                            outFormat.containsKey(MediaFormat.KEY_PROFILE));
-                    Assume.assumeTrue(outFormat.containsKey(MediaFormat.KEY_LEVEL));
-                }
-                // TODO (b/166300446) avc mediaType fails validation
-                if (mMediaType.equals(MediaFormat.MIMETYPE_VIDEO_AVC)) {
-                    Log.w(LOG_TAG, "Skip validation for mediaType = " + mMediaType);
-                    continue;
-                }
-                // TODO (b/166305723) hevc mediaType fails validation
-                if (mMediaType.equals(MediaFormat.MIMETYPE_VIDEO_HEVC)) {
-                    Log.w(LOG_TAG, "Skip validation for mediaType = " + mMediaType);
-                    continue;
-                }
-                // TODO (b/166300448) h263 and mpeg4 mediaTypes fails validation
-                if (mMediaType.equals(MediaFormat.MIMETYPE_VIDEO_H263)
-                        || mMediaType.equals(MediaFormat.MIMETYPE_VIDEO_MPEG4)) {
-                    Log.w(LOG_TAG, "Skip validation for mediaType = " + mMediaType);
-                    continue;
-                }
-                // TODO (b/184889671) aac for profile AACObjectHE fails validation
-                // TODO (b/184890155) aac for profile AACObjectLD, AACObjectELD fails validation
-                if (mMediaType.equals(MediaFormat.MIMETYPE_AUDIO_AAC)) {
-                    if (cfg.mProfile == AACObjectHE || cfg.mProfile == AACObjectELD
-                            || cfg.mProfile == AACObjectLD) {
-                        Log.w(LOG_TAG, "Skip validation for mediaType = " + mMediaType
-                                + " profile " + cfg.mProfile);
-                        continue;
-                    }
-                }
-                String msg = String.format("Configured input format and received output format are "
-                        + "not similar. \nConfigured Input format is :- %s \nReceived Output "
-                        + "format is :- %s \n", format, outFormat);
-                assertTrue(msg + mTestConfig + mTestEnv, isFormatSimilar(format, outFormat));
+                MediaFormat trackFormat = validateProfileAndLevel();
 
-                for (int muxerFormat = MediaMuxer.OutputFormat.MUXER_OUTPUT_FIRST;
-                     muxerFormat <= MediaMuxer.OutputFormat.MUXER_OUTPUT_LAST; muxerFormat++) {
-                    if (!isMediaTypeContainerPairValid(mMediaType, muxerFormat)) continue;
-                    ByteBuffer mBuff = mOutputBuff.getBuffer();
-                    String tmpPath = getTempFilePath((cfg.mInputBitDepth == 10) ? "10bit" : "");
-                    muxOutput(tmpPath, muxerFormat, outFormat, mBuff, mInfoList);
-                    MediaExtractor extractor = new MediaExtractor();
-                    extractor.setDataSource(tmpPath);
-                    assertEquals("Should be only 1 track \n" + mTestConfig + mTestEnv, 1,
-                            extractor.getTrackCount());
-                    MediaFormat extractedFormat = extractor.getTrackFormat(0);
-                    if (!isFormatSimilar(outFormat, extractedFormat)) {
-                        msg = " Input format and extracted format are not similar. "
-                                + "\n Muxer input format :- " + outFormat
-                                + "\n Extracted format :- " + extractedFormat
-                                + "\n Muxer writer :- " + muxerFormat + "\n" + mTestConfig
-                                + mTestEnv;
-                        fail(msg);
-                    }
-                    extractor.release();
-                    new File(tmpPath).delete();
+                deleteMuxedFile();
+
+                // validate extracted format for mandatory keys
+                if (trackFormat != null) checkIfTrackFormatIsOk(trackFormat);
+
+                // Verify if device has an equivalent decoder for the current format
+                ArrayList<MediaFormat> formatList = new ArrayList<>();
+                if (mProfileLevel != null && mProfileLevel.second != -1
+                        && cfg.mLevel != mProfileLevel.second) {
+                    format.setInteger(MediaFormat.KEY_LEVEL, mProfileLevel.second);
                 }
+                formatList.add(format);
+                assertTrue("Device advertises support for encoding " + format + " but cannot"
+                                + " decode it. \n" + mTestConfig + mTestEnv,
+                        selectCodecs(mMediaType, formatList, null, false).size() > 0);
+                configsTested++;
             }
             mCodec.release();
+            Assume.assumeTrue("skipping test, formats not supported by component",
+                    configsTested > 0);
         }
     }
 }
diff --git a/tests/tests/hibernation/src/android/hibernation/cts/AppHibernationUtils.kt b/tests/tests/hibernation/src/android/hibernation/cts/AppHibernationUtils.kt
index 9021f8e..843f490 100644
--- a/tests/tests/hibernation/src/android/hibernation/cts/AppHibernationUtils.kt
+++ b/tests/tests/hibernation/src/android/hibernation/cts/AppHibernationUtils.kt
@@ -25,6 +25,7 @@
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
+import android.graphics.Point
 import android.os.Handler
 import android.os.Looper
 import android.os.ParcelFileDescriptor
@@ -235,7 +236,12 @@
         waitFindObject(uiAutomation, By.text("Open")).click()
     } else {
         runShellCommandOrThrow(CMD_EXPAND_NOTIFICATIONS)
-        waitFindNotification(notifSelector, NOTIF_FIND_TIMEOUT).click()
+        val notification = waitFindNotification(notifSelector, NOTIF_FIND_TIMEOUT)
+        if (FeatureUtil.isAutomotive()) {
+            notification.click(Point(0, 0))
+        } else {
+            notification.click()
+        }
     }
 }
 
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/DecodeEditEncodeTest.java b/tests/tests/media/codec/src/android/media/codec/cts/DecodeEditEncodeTest.java
index a24638f..b584643 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/DecodeEditEncodeTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/DecodeEditEncodeTest.java
@@ -42,6 +42,7 @@
 import androidx.test.platform.app.InstrumentationRegistry;
 
 import com.android.compatibility.common.util.ApiLevelUtil;
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.MediaUtils;
 
 import org.junit.Before;
@@ -270,6 +271,15 @@
         mUseHighBitDepth = useHighBitDepth;
     }
 
+    @ApiTest(apis = {"android.opengl.GLES20#GL_FRAGMENT_SHADER",
+            "android.opengl.GLES20#glReadPixels",
+            "android.opengl.GLES30#glReadPixels",
+            "android.media.format.MediaFormat#KEY_ALLOW_FRAME_DROP",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_Format32bitABGR2101010",
+            "android.media.MediaFormat#KEY_COLOR_RANGE",
+            "android.media.MediaFormat#KEY_COLOR_STANDARD",
+            "android.media.MediaFormat#KEY_COLOR_TRANSFER"})
     @Test
     public void testVideoEdit() throws Throwable {
         VideoEditWrapper.runTest(this);
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/EncodeDecodeTest.java b/tests/tests/media/codec/src/android/media/codec/cts/EncodeDecodeTest.java
index 79b5eac..894d4b1 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/EncodeDecodeTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/EncodeDecodeTest.java
@@ -44,6 +44,7 @@
 import androidx.test.filters.SmallTest;
 
 import com.android.compatibility.common.util.ApiLevelUtil;
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.MediaUtils;
 
 import org.junit.Before;
@@ -1268,6 +1269,11 @@
      * a series of byte[] buffers and decoded into ByteBuffers.  The output is checked for
      * validity.
      */
+    @ApiTest(apis = {"android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatYUV420Planar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatYUV420PackedPlanar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatYUV420SemiPlanar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatYUV420PackedSemiPlanar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_TI_FormatYUV420PackedSemiPlanar"})
     @Test
     public void testEncodeDecodeVideoFromBufferToBuffer() throws Exception {
         encodeDecodeVideoFromBuffer(false);
@@ -1285,6 +1291,16 @@
      * the test thread, so we have to hand control off to a new thread for the duration of
      * the test.
      */
+    @ApiTest(apis = {"android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatYUV420Planar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatYUV420PackedPlanar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatYUV420SemiPlanar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatYUV420PackedSemiPlanar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_TI_FormatYUV420PackedSemiPlanar",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface",
+            "android.opengl.GLES20#glReadPixels",
+            "android.media.MediaFormat#KEY_COLOR_RANGE",
+            "android.media.MediaFormat#KEY_COLOR_STANDARD",
+            "android.media.MediaFormat#KEY_COLOR_TRANSFER"})
     @Test
     public void testEncodeDecodeVideoFromBufferToSurface() throws Throwable {
         BufferToSurfaceWrapper.runTest(this);
@@ -1294,11 +1310,22 @@
      * Tests streaming of AVC through the encoder and decoder.  Data is provided through
      * a Surface and decoded onto a Surface.  The output is checked for validity.
      */
+    @ApiTest(apis = {"android.media.MediaCodec#createInputSurface",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface",
+            "android.opengl.GLES20#glReadPixels",
+            "android.media.MediaFormat#KEY_COLOR_RANGE",
+            "android.media.MediaFormat#KEY_COLOR_STANDARD",
+            "android.media.MediaFormat#KEY_COLOR_TRANSFER"})
     @Test
     public void testEncodeDecodeVideoFromSurfaceToSurface() throws Throwable {
         SurfaceToSurfaceWrapper.runTest(this, false, false);
     }
-
+    @ApiTest(apis = {"AMediaCodec_createInputSurface",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface",
+            "android.opengl.GLES20#glReadPixels",
+            "android.media.MediaFormat#KEY_COLOR_RANGE",
+            "android.media.MediaFormat#KEY_COLOR_STANDARD",
+            "android.media.MediaFormat#KEY_COLOR_TRANSFER"})
     @Test
     public void testEncodeDecodeVideoFromSurfaceToSurfaceNdk() throws Throwable {
         SurfaceToSurfaceWrapper.runTest(this, false, USE_NDK);
@@ -1308,11 +1335,25 @@
      * Tests streaming of video through the encoder and decoder.  Data is provided through
      * a PersistentSurface and decoded onto a Surface.  The output is checked for validity.
      */
+    @ApiTest(apis = {"android.media.MediaCodec#createPersistentInputSurface",
+            "android.media.MediaCodec#setInputSurface",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface",
+            "android.opengl.GLES20#glReadPixels",
+            "android.media.MediaFormat#KEY_COLOR_RANGE",
+            "android.media.MediaFormat#KEY_COLOR_STANDARD",
+            "android.media.MediaFormat#KEY_COLOR_TRANSFER"})
     @Test
     public void testEncodeDecodeVideoFromSurfaceToPersistentSurface() throws Throwable {
         SurfaceToSurfaceWrapper.runTest(this, true, false);
     }
 
+    @ApiTest(apis = {"AMediaCodec_createPersistentInputSurface",
+            "AMediaCodec_setInputSurface",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface",
+            "android.opengl.GLES20#glReadPixels",
+            "android.media.MediaFormat#KEY_COLOR_RANGE",
+            "android.media.MediaFormat#KEY_COLOR_STANDARD",
+            "android.media.MediaFormat#KEY_COLOR_TRANSFER"})
     @Test
     public void testEncodeDecodeVideoFromSurfaceToPersistentSurfaceNdk() throws Throwable {
         SurfaceToSurfaceWrapper.runTest(this, true, USE_NDK);
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/EncodeVirtualDisplayTest.java b/tests/tests/media/codec/src/android/media/codec/cts/EncodeVirtualDisplayTest.java
old mode 100755
new mode 100644
index ca08397..fa4e2ac
--- a/tests/tests/media/codec/src/android/media/codec/cts/EncodeVirtualDisplayTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/EncodeVirtualDisplayTest.java
@@ -48,6 +48,7 @@
 import androidx.test.platform.app.InstrumentationRegistry;
 
 import com.android.compatibility.common.util.ApiLevelUtil;
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.MediaUtils;
 
 import org.junit.Before;
@@ -189,6 +190,13 @@
      *
      * @throws Exception
      */
+    @ApiTest(apis = {"AMediaCodec_createInputSurface",
+            "android.hardware.display.DisplayManager#createVirtualDisplay",
+            "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface",
+            "android.opengl.GLES20#glReadPixels",
+            "android.media.MediaFormat#KEY_COLOR_RANGE",
+            "android.media.MediaFormat#KEY_COLOR_STANDARD",
+            "android.media.MediaFormat#KEY_COLOR_TRANSFER"})
     @Test
     public void testEncodeVirtualDisplay() throws Throwable {
         if (!MediaUtils.check(sIsAtLeastR, "test needs Android 11")) return;
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/ExtractDecodeEditEncodeMuxTest.java b/tests/tests/media/codec/src/android/media/codec/cts/ExtractDecodeEditEncodeMuxTest.java
index 67c3ce8..1225822 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/ExtractDecodeEditEncodeMuxTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/ExtractDecodeEditEncodeMuxTest.java
@@ -41,7 +41,7 @@
 
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 
-import com.android.compatibility.common.util.CddTest;
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.Preconditions;
 
 import org.junit.After;
@@ -69,6 +69,30 @@
  * <p>It also tests the way the codec config buffers need to be passed from the MediaCodec to the
  * MediaMuxer.
  */
+@ApiTest(apis = {"android.opengl.GLES20#GL_FRAGMENT_SHADER",
+        "android.media.MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface",
+        "android.media.MediaFormat#KEY_BIT_RATE",
+        "android.media.MediaFormat#KEY_COLOR_FORMAT",
+        "android.media.MediaFormat#KEY_FRAME_RATE",
+        "android.media.MediaFormat#KEY_I_FRAME_INTERVAL",
+        "android.media.MediaFormat#KEY_SAMPLE_RATE",
+        "android.media.MediaFormat#KEY_CHANNEL_COUNT",
+        "android.media.MediaFormat#KEY_PROFILE",
+        "android.media.MediaFormat#KEY_AAC_PROFILE",
+        "android.media.MediaExtractor#setDataSource",
+        "android.media.MediaExtractor#getTrackCount",
+        "android.media.MediaExtractor#getTrackFormat",
+        "android.media.MediaExtractor#selectTrack",
+        "android.media.MediaExtractor#readSampleData",
+        "android.media.MediaExtractor#getSampleTime",
+        "android.media.MediaExtractor#getSampleFlags",
+        "android.media.MediaExtractor#advance",
+        "android.media.MediaExtractor#release",
+        "android.media.MediaMuxer#start",
+        "android.media.MediaMuxer#stop",
+        "android.media.MediaMuxer#addTrack",
+        "android.media.MediaMuxer#writeSampleData",
+        "android.media.MediaMuxer#release"})
 @TargetApi(18)
 @AppModeFull(reason = "Instant apps cannot access the SD card")
 @RunWith(AndroidJUnit4.class)
@@ -145,7 +169,6 @@
         super.tearDown();
     }
 
-    @CddTest(requirements = {"5.2", "5.3"})
     @Test
     public void testExtractDecodeEditEncodeMuxQCIF() throws Throwable {
         if(!setSize(176, 144)) return;
@@ -155,7 +178,6 @@
         TestWrapper.runTest(this);
     }
 
-    @CddTest(requirements = {"5.2", "5.3"})
     @Test
     public void testExtractDecodeEditEncodeMuxQVGA() throws Throwable {
         if(!setSize(320, 240)) return;
@@ -165,7 +187,6 @@
         TestWrapper.runTest(this);
     }
 
-    @CddTest(requirements = {"5.2", "5.3"})
     @Test
     public void testExtractDecodeEditEncodeMux720p() throws Throwable {
         if(!setSize(1280, 720)) return;
@@ -175,7 +196,6 @@
         TestWrapper.runTest(this);
     }
 
-    @CddTest(requirements = {"5.2", "5.3"})
     @Test
     public void testExtractDecodeEditEncodeMux2160pHevc() throws Throwable {
         if(!setSize(3840, 2160)) return;
@@ -185,7 +205,6 @@
         TestWrapper.runTest(this);
     }
 
-    @CddTest(requirements = {"5.1.1", "5.1.2"})
     @Test
     public void testExtractDecodeEditEncodeMuxAudio() throws Throwable {
         if(!setSize(1280, 720)) return;
@@ -195,7 +214,6 @@
         TestWrapper.runTest(this);
     }
 
-    @CddTest(requirements = {"5.1.1", "5.1.2", "5.2", "5.3"})
     @Test
     public void testExtractDecodeEditEncodeMuxAudioVideo() throws Throwable {
         if(!setSize(1280, 720)) return;
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecBlockModelTest.java b/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecBlockModelTest.java
index 29a14a0..5822063 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecBlockModelTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecBlockModelTest.java
@@ -41,6 +41,7 @@
 import androidx.test.filters.SmallTest;
 
 import com.android.compatibility.common.util.ApiLevelUtil;
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.MediaUtils;
 import com.android.compatibility.common.util.NonMainlineTest;
 import com.android.compatibility.common.util.Preconditions;
@@ -92,6 +93,7 @@
     @Presubmit
     @SmallTest
     @RequiresDevice
+    @ApiTest(apis = "MediaCodec#CONFIGURE_FLAG_USE_BLOCK_MODEL")
     @Test
     public void testDecodeShortVideo() throws InterruptedException {
         if (!MediaUtils.check(mIsAtLeastR, "test needs Android 11")) return;
@@ -112,6 +114,7 @@
     @Presubmit
     @SmallTest
     @RequiresDevice
+    @ApiTest(apis = "MediaCodec#CONFIGURE_FLAG_USE_BLOCK_MODEL")
     @Test
     public void testDecodeShortAudio() throws InterruptedException {
         if (!MediaUtils.check(mIsAtLeastR, "test needs Android 11")) return;
@@ -132,6 +135,7 @@
     @Presubmit
     @SmallTest
     @RequiresDevice
+    @ApiTest(apis = "MediaCodec#CONFIGURE_FLAG_USE_BLOCK_MODEL")
     @Test
     public void testEncodeShortAudio() throws InterruptedException {
         if (!MediaUtils.check(mIsAtLeastR, "test needs Android 11")) return;
@@ -145,6 +149,7 @@
     @Presubmit
     @SmallTest
     @RequiresDevice
+    @ApiTest(apis = "MediaCodec#CONFIGURE_FLAG_USE_BLOCK_MODEL")
     @Test
     public void testEncodeShortVideo() throws InterruptedException {
         if (!MediaUtils.check(mIsAtLeastR, "test needs Android 11")) return;
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecResourceTest.java b/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecResourceTest.java
index bb769ca..b94f2de 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecResourceTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecResourceTest.java
@@ -45,6 +45,8 @@
 import androidx.test.filters.SmallTest;
 import androidx.test.platform.app.InstrumentationRegistry;
 
+import com.android.compatibility.common.util.ApiTest;
+
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -80,6 +82,7 @@
         public final int uid;
     }
 
+    @ApiTest(apis = "MediaCodec#createByCodecNameForClient")
     @Test
     public void testCreateCodecForAnotherProcessWithoutPermissionsThrows() throws Exception {
         CodecInfo codecInfo = getFirstVideoHardwareDecoder();
@@ -102,6 +105,7 @@
 
     // A process with lower priority (e.g. background app) should not be able to reclaim
     // MediaCodec resources from a process with higher priority (e.g. foreground app).
+    @ApiTest(apis = "MediaCodec#createByCodecNameForClient")
     @Test
     public void testLowerPriorityProcessFailsToReclaimResources() throws Exception {
         CodecInfo codecInfo = getFirstVideoHardwareDecoder();
@@ -188,6 +192,7 @@
 
     // A process with higher priority (e.g. foreground app) should be able to reclaim
     // MediaCodec resources from a process with lower priority (e.g. background app).
+    @ApiTest(apis = "MediaCodec#createByCodecNameForClient")
     @Test
     public void testHigherPriorityProcessReclaimsResources() throws Exception {
         CodecInfo codecInfo = getFirstVideoHardwareDecoder();
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecTest.java b/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecTest.java
index 3173465..52d01b2 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/MediaCodecTest.java
@@ -68,6 +68,7 @@
 import androidx.test.filters.SmallTest;
 
 import com.android.compatibility.common.util.ApiLevelUtil;
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.MediaUtils;
 import com.android.compatibility.common.util.Preconditions;
 
@@ -142,6 +143,18 @@
      * A selective test to ensure proper exceptions are thrown from MediaCodec
      * methods when called in incorrect operational states.
      */
+    @ApiTest(apis = {"MediaCodec#createByCodecName", "MediaCodec#createDecoderByType",
+            "MediaCodec#createEncoderByType", "MediaCodec#start", "MediaCodec#flush",
+            "MediaCodec#configure", "MediaCodec#dequeueInputBuffer",
+            "MediaCodec#dequeueOutputBuffer", "MediaCodec#createInputSurface",
+            "MediaCodec#getInputBuffers", "MediaCodec#getQueueRequest",
+            "MediaCodec#getOutputFrame", "MediaCodec#stop", "MediaCodec#release",
+            "MediaCodec#getCodecInfo", "MediaCodec#getSupportedVendorParameters",
+            "MediaCodec#getParameterDescriptor",
+            "MediaCodec#subscribeToVendorParameters",
+            "MediaCodec#unsubscribeFromVendorParameters",
+            "MediaCodec#getInputBuffer", "MediaCodec#getOutputBuffer",
+            "MediaCodec#setCallback", "MediaCodec#getName"})
     @Test
     public void testException() throws Exception {
         boolean tested = false;
@@ -245,15 +258,6 @@
             fail("flush should not return MediaCodec.CodecException on wrong state");
         } catch (IllegalStateException e) { // expected
         }
-        try {
-            codec.setParameters(new Bundle());
-            fail("setParameters should not work if not yet configured/initialized");
-        } catch (MediaCodec.CodecException e) {
-            logMediaCodecException(e);
-            fail("setParameters should not return MediaCodec.CodecException if not yet "
-                    + "configured/initialized");
-        } catch (IllegalStateException e) { // expected
-        }
 
         MediaCodecInfo codecInfo = codec.getCodecInfo(); // obtaining the codec info now is fine.
         try {
@@ -553,6 +557,7 @@
      * <br> calling createInputSurface() after start() throws exception
      * <br> calling createInputSurface() with a non-Surface color format is not required to throw exception
      */
+    @ApiTest(apis = "MediaCodec#createInputSurface")
     @Test
     public void testCreateInputSurfaceErrors() {
         if (!supportsCodec(MIME_TYPE, true)) {
@@ -604,6 +609,7 @@
      * <br> signaling EOS twice throws exception
      * <br> submitting a frame after EOS throws exception [TODO]
      */
+    @ApiTest(apis = "MediaCodec#signalEndOfInputStream")
     @Test
     public void testSignalSurfaceEOS() {
         if (!supportsCodec(MIME_TYPE, true)) {
@@ -662,6 +668,7 @@
      * Tests:
      * <br> stopping with buffers in flight doesn't crash or hang
      */
+    @ApiTest(apis = "MediaCodec#stop")
     @Test
     public void testAbruptStop() {
         if (!supportsCodec(MIME_TYPE, true)) {
@@ -718,6 +725,7 @@
         }
     }
 
+    @ApiTest(apis = {"MediaCodec#flush", "MediaCodec#release"})
     @Test
     public void testReleaseAfterFlush() throws IOException, InterruptedException {
         String mimes[] = new String[] { MIME_TYPE, MIME_TYPE_AUDIO};
@@ -781,11 +789,13 @@
         callbackThread.join();
     }
 
+    @ApiTest(apis = {"MediaCodec#setCallback", "MediaCodec#flush", "MediaCodec#reset"})
     @Test
     public void testAsyncFlushAndReset() throws Exception, InterruptedException {
         testAsyncReset(false /* testStop */);
     }
 
+    @ApiTest(apis = {"MediaCodec#setCallback", "MediaCodec#stop", "MediaCodec#reset"})
     @Test
     public void testAsyncStopAndReset() throws Exception, InterruptedException {
         testAsyncReset(true /* testStop */);
@@ -1116,6 +1126,7 @@
      * Tests:
      * <br> dequeueInputBuffer() fails when encoder configured with an input Surface
      */
+    @ApiTest(apis = {"MediaCodec#dequeueInputBuffer", "MediaCodec#getMetrics"})
     @Test
     public void testDequeueSurface() {
         if (!supportsCodec(MIME_TYPE, true)) {
@@ -1175,6 +1186,8 @@
      * <br> configure() encoder with Surface, re-configure() without Surface works
      * <br> sending EOS with signalEndOfInputStream on non-Surface encoder fails
      */
+    @ApiTest(apis = {"MediaCodec#configure", "MediaCodec#signalEndOfInputStream",
+            "MediaCodec#getMetrics"})
     @Test
     public void testReconfigureWithoutSurface() {
         if (!supportsCodec(MIME_TYPE, true)) {
@@ -1244,6 +1257,7 @@
         }
     }
 
+    @ApiTest(apis = "MediaCodec#flush")
     @Test
     public void testDecodeAfterFlush() throws InterruptedException {
         testDecodeAfterFlush(true /* audio */);
@@ -1425,6 +1439,7 @@
      * Tests whether decoding a short group-of-pictures succeeds. The test queues a few video frames
      * then signals end-of-stream. The test fails if the decoder doesn't output the queued frames.
      */
+    @ApiTest(apis = {"MediaCodecInfo.CodecCapabilities#COLOR_FormatSurface"})
     @Test
     public void testDecodeShortInput() throws InterruptedException {
         // Input buffers from this input video are queued up to and including the video frame with
@@ -1536,6 +1551,10 @@
     /**
      * Tests creating two decoders for {@link #MIME_TYPE_AUDIO} at the same time.
      */
+    @ApiTest(apis = {"MediaCodec#createDecoderByType",
+            "android.media.MediaFormat#KEY_MIME",
+            "android.media.MediaFormat#KEY_SAMPLE_RATE",
+            "android.media.MediaFormat#KEY_CHANNEL_COUNT"})
     @Test
     public void testCreateTwoAudioDecoders() {
         final MediaFormat format = MediaFormat.createAudioFormat(
@@ -1583,6 +1602,10 @@
     /**
      * Tests creating an encoder and decoder for {@link #MIME_TYPE_AUDIO} at the same time.
      */
+    @ApiTest(apis = {"MediaCodec#createDecoderByType", "MediaCodec#createEncoderByType",
+            "android.media.MediaFormat#KEY_MIME",
+            "android.media.MediaFormat#KEY_SAMPLE_RATE",
+            "android.media.MediaFormat#KEY_CHANNEL_COUNT"})
     @Test
     public void testCreateAudioDecoderAndEncoder() {
         if (!supportsCodec(MIME_TYPE_AUDIO, true)) {
@@ -1641,6 +1664,12 @@
         }
     }
 
+    @ApiTest(apis = {"MediaCodec#createEncoderByType",
+            "android.media.MediaFormat#KEY_MIME",
+            "android.media.MediaFormat#KEY_SAMPLE_RATE",
+            "android.media.MediaFormat#KEY_CHANNEL_COUNT",
+            "android.media.MediaFormat#KEY_WIDTH",
+            "android.media.MediaFormat#KEY_HEIGHT"})
     @Test
     public void testConcurrentAudioVideoEncodings() throws InterruptedException {
         if (!supportsCodec(MIME_TYPE_AUDIO, true)) {
@@ -1689,6 +1718,7 @@
         public int mBitRate;
     }
 
+    @ApiTest(apis = {"MediaCodec#CryptoInfo", "MediaCodec#CryptoInfo#Pattern"})
     @Test
     public void testCryptoInfoPattern() {
         CryptoInfo info = new CryptoInfo();
@@ -1989,6 +2019,7 @@
     /**
      * Tests MediaCodec.CryptoException
      */
+    @ApiTest(apis = "MediaCodec#CryptoException")
     @Test
     public void testCryptoException() {
         int errorCode = CryptoException.ERROR_KEY_EXPIRED;
@@ -2007,6 +2038,8 @@
      *
      * As of Q, any codec of type "audio/raw" must support PCM encoding float.
      */
+    @ApiTest(apis = {"android.media.AudioFormat#ENCODING_PCM_16BIT",
+            "android.media.AudioFormat#ENCODING_PCM_FLOAT"})
     @MediumTest
     @Test
     public void testPCMEncoding() throws Exception {
@@ -2132,6 +2165,7 @@
         return actualEncoding;
     }
 
+    @ApiTest(apis = "android.media.AudioFormat#KEY_FLAC_COMPRESSION_LEVEL")
     @SmallTest
     @Test
     public void testFlacIdentity() throws Exception {
@@ -2185,6 +2219,7 @@
         }
     }
 
+    @ApiTest(apis = "MediaCodec#release")
     @Test
     public void testAsyncRelease() throws Exception {
         OutputSurface outputSurface = new OutputSurface(1, 1);
@@ -2272,6 +2307,7 @@
         }
     }
 
+    @ApiTest(apis = "MediaCodec#setAudioPresentation")
     @Test
     public void testSetAudioPresentation() throws Exception {
         MediaFormat format = MediaFormat.createAudioFormat(
@@ -2287,6 +2323,7 @@
                 (new AudioPresentation.Builder(42 /* presentationId */)).build());
     }
 
+    @ApiTest(apis = "android.media.MediaFormat#KEY_PREPEND_HEADER_TO_SYNC_FRAMES")
     @Test
     public void testPrependHeadersToSyncFrames() throws IOException {
         MediaCodecList mcl = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
@@ -2361,6 +2398,7 @@
      * codec is flushed after the first buffer is queued, so this test walks
      * through the scenario.
      */
+    @ApiTest(apis = "MediaCodec#flush")
     @Test
     public void testFlushAfterFirstBuffer() throws Exception {
         if (MediaUtils.check(mIsAtLeastR, "test needs Android 11")) {
@@ -2458,6 +2496,10 @@
         }
     }
 
+    @ApiTest(apis = {"MediaCodec#getSupportedVendorParameters",
+            "MediaCodec#getParameterDescriptor",
+            "MediaCodec#subscribeToVendorParameters",
+            "MediaCodec#unsubscribeFromVendorParameters"})
     @Test
     public void testVendorParameters() {
         if (!MediaUtils.check(mIsAtLeastS, "test needs Android 12")) {
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/VideoCodecTest.java b/tests/tests/media/codec/src/android/media/codec/cts/VideoCodecTest.java
index ac0dd0f..6c67812 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/VideoCodecTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/VideoCodecTest.java
@@ -26,6 +26,7 @@
 import android.platform.test.annotations.AppModeFull;
 import android.util.Log;
 
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.MediaUtils;
 
 import org.junit.Assume;
@@ -625,41 +626,65 @@
         }
     }
 
+    @ApiTest(apis = {"android.media.MediaFormat#KEY_BITRATE_MODE",
+            "android.media.MediaFormat#KEY_BIT_RATE",
+            "android.media.MediaFormat#KEY_COLOR_FORMAT",
+            "android.media.MediaFormat#KEY_FRAME_RATE",
+            "android.media.MediaFormat#KEY_I_FRAME_INTERVAL"})
     @Test
     public void testBasic() throws Exception {
         internalTestBasic(mCodecName, mCodecMimeType, mBitRateMode);
     }
 
+    @ApiTest(apis = {"android.media.MediaFormat#KEY_BITRATE_MODE",
+            "android.media.MediaFormat#KEY_BIT_RATE",
+            "android.media.MediaFormat#KEY_COLOR_FORMAT",
+            "android.media.MediaFormat#KEY_FRAME_RATE",
+            "android.media.MediaFormat#KEY_I_FRAME_INTERVAL"})
     @Test
     public void testAsyncEncode() throws Exception {
         internalTestAsyncEncoding(mCodecName, mCodecMimeType, mBitRateMode);
     }
 
+    @ApiTest(apis = "android.media.MediaCodec#PARAMETER_KEY_REQUEST_SYNC_FRAME")
     @Test
     public void testSyncFrame() throws Exception {
         internalTestSyncFrame(mCodecName, mCodecMimeType, mBitRateMode, false);
     }
 
+    @ApiTest(apis = "android.media.MediaCodec#PARAMETER_KEY_REQUEST_SYNC_FRAME")
     @Test
     public void testSyncFrameNdk() throws Exception {
         internalTestSyncFrame(mCodecName, mCodecMimeType, mBitRateMode, true);
     }
 
+    @ApiTest(apis = "android.media.MediaCodec#PARAMETER_KEY_VIDEO_BITRATE")
     @Test
     public void testDynamicBitrateChange() throws Exception {
         internalTestDynamicBitrateChange(mCodecName, mCodecMimeType, mBitRateMode, false);
     }
 
+    @ApiTest(apis = "android.media.MediaCodec#PARAMETER_KEY_VIDEO_BITRATE")
     @Test
     public void testDynamicBitrateChangeNdk() throws Exception {
         internalTestDynamicBitrateChange(mCodecName, mCodecMimeType, mBitRateMode, true);
     }
 
+    @ApiTest(apis = {"android.media.MediaFormat#KEY_BITRATE_MODE",
+            "android.media.MediaFormat#KEY_BIT_RATE",
+            "android.media.MediaFormat#KEY_COLOR_FORMAT",
+            "android.media.MediaFormat#KEY_FRAME_RATE",
+            "android.media.MediaFormat#KEY_I_FRAME_INTERVAL"})
     @Test
     public void testEncoderQuality() throws Exception {
         internalTestEncoderQuality(mCodecName, mCodecMimeType, mBitRateMode);
     }
 
+    @ApiTest(apis = {"android.media.MediaFormat#KEY_BITRATE_MODE",
+            "android.media.MediaFormat#KEY_BIT_RATE",
+            "android.media.MediaFormat#KEY_COLOR_FORMAT",
+            "android.media.MediaFormat#KEY_FRAME_RATE",
+            "android.media.MediaFormat#KEY_I_FRAME_INTERVAL"})
     @Test
     public void testParallelEncodingAndDecoding() throws Exception {
         Assume.assumeTrue("Parallel Encode Decode test is run only for VBR mode",
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/VideoDecoderRotationTest.java b/tests/tests/media/codec/src/android/media/codec/cts/VideoDecoderRotationTest.java
index 78021f4..fb61f78 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/VideoDecoderRotationTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/VideoDecoderRotationTest.java
@@ -26,6 +26,7 @@
 import androidx.test.filters.SmallTest;
 import androidx.test.platform.app.InstrumentationRegistry;
 
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.NonMainlineTest;
 
 import org.junit.Test;
@@ -96,6 +97,7 @@
         return testParams;
     }
 
+    @ApiTest(apis = "android.media.MediaFormat#KEY_ROTATION")
     @Test
     public void testRendering800x480Rotated() throws Throwable {
         if (mImpl.isConcurrentEncodingDecodingSupported(
diff --git a/tests/tests/media/codec/src/android/media/codec/cts/VideoEncodingStatisticsTest.java b/tests/tests/media/codec/src/android/media/codec/cts/VideoEncodingStatisticsTest.java
index 4979f76..4239679 100644
--- a/tests/tests/media/codec/src/android/media/codec/cts/VideoEncodingStatisticsTest.java
+++ b/tests/tests/media/codec/src/android/media/codec/cts/VideoEncodingStatisticsTest.java
@@ -26,6 +26,7 @@
 import android.platform.test.annotations.AppModeFull;
 import android.util.Log;
 
+import com.android.compatibility.common.util.ApiTest;
 import com.android.compatibility.common.util.MediaUtils;
 
 import org.junit.Assume;
@@ -195,6 +196,9 @@
         }
     }
 
+    @ApiTest(apis = {"MediaCodecInfo.CodecCapabilities#FEATURE_EncodingStatistics",
+            "android.media.MediaFormat#KEY_VIDEO_ENCODING_STATISTICS_LEVEL",
+            "android.media.MediaFormat#KEY_VIDEO_QP_AVERAGE"})
     @Test
     public void testEncodingStatisticsAvgQp() throws Exception {
        testEncStatRateAvgQp(mCodecName, mCodecMimeType, mBitRateMode);
diff --git a/tests/tests/os/src/android/os/storage/cts/StorageManagerHelper.java b/tests/tests/os/src/android/os/storage/cts/StorageManagerHelper.java
index 5c53270..bb747e6 100644
--- a/tests/tests/os/src/android/os/storage/cts/StorageManagerHelper.java
+++ b/tests/tests/os/src/android/os/storage/cts/StorageManagerHelper.java
@@ -16,8 +16,6 @@
 
 package android.os.storage.cts;
 
-import android.content.Context;
-import android.content.pm.PackageManager;
 import android.os.ParcelFileDescriptor;
 import android.util.Log;
 
@@ -125,23 +123,6 @@
         return null;
     }
 
-    public static boolean isAdoptableStorageSupported(Context context) throws Exception {
-        return hasAdoptableStorageFeature(context) || hasAdoptableStorageFstab();
-    }
-
-    private static boolean hasAdoptableStorageFstab() throws Exception {
-        List<String> hasAdoptable = executeShellCommand("sm has-adoptable");
-        if (hasAdoptable.isEmpty()) {
-            return false;
-        }
-        return Boolean.parseBoolean(hasAdoptable.get(0).trim());
-    }
-
-    private static boolean hasAdoptableStorageFeature(Context context) throws Exception {
-        return context.getPackageManager().hasSystemFeature(
-                PackageManager.FEATURE_ADOPTABLE_STORAGE);
-    }
-
     private static List<String> executeShellCommand(String command) throws Exception {
         final ParcelFileDescriptor pfd = InstrumentationRegistry.getInstrumentation()
                 .getUiAutomation().executeShellCommand(command);
diff --git a/tests/tests/os/src/android/os/storage/cts/StorageManagerTest.java b/tests/tests/os/src/android/os/storage/cts/StorageManagerTest.java
index a54dfd5..af72be9 100644
--- a/tests/tests/os/src/android/os/storage/cts/StorageManagerTest.java
+++ b/tests/tests/os/src/android/os/storage/cts/StorageManagerTest.java
@@ -18,13 +18,6 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 import static org.testng.Assert.assertThrows;
@@ -32,7 +25,6 @@
 import static java.util.stream.Collectors.joining;
 
 import android.app.PendingIntent;
-import android.content.Context;
 import android.content.res.Resources;
 import android.content.res.Resources.NotFoundException;
 import android.os.Environment;
@@ -53,18 +45,16 @@
 import android.system.ErrnoException;
 import android.system.Os;
 import android.system.OsConstants;
+import android.test.AndroidTestCase;
 import android.test.ComparisonFailure;
 import android.util.Log;
 
-import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.platform.app.InstrumentationRegistry;
 
 import com.android.compatibility.common.util.FileUtils;
 import com.android.compatibility.common.util.SystemUtil;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import junit.framework.AssertionFailedError;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -86,8 +76,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
-@RunWith(AndroidJUnit4.class)
-public class StorageManagerTest {
+public class StorageManagerTest extends AndroidTestCase {
 
     private static final String TAG = StorageManager.class.getSimpleName();
 
@@ -97,17 +86,15 @@
     private static final String OBB_MOUNT_PREFIX = "/mnt/obb/";
     private static final String TEST1_NEW_CONTENTS = "1\n";
 
-    private Context mContext;
     private StorageManager mStorageManager;
     private final Handler mHandler = new Handler(Looper.getMainLooper());
 
-    @Before
-    public void setUp() throws Exception {
-        mContext = InstrumentationRegistry.getInstrumentation().getContext();
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
         mStorageManager = mContext.getSystemService(StorageManager.class);
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testMountAndUnmountObbNormal() throws IOException {
         for (File target : getTargetFiles()) {
@@ -135,7 +122,6 @@
         }
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testAttemptMountNonObb() {
         for (File target : getTargetFiles()) {
@@ -160,7 +146,6 @@
                 mStorageManager.getMountedObbPath(outFile.getPath()));
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testAttemptMountObbWrongPackage() {
         for (File target : getTargetFiles()) {
@@ -181,7 +166,6 @@
                 mStorageManager.getMountedObbPath(outFile.getPath()));
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testMountAndUnmountTwoObbs() throws IOException {
         for (File target : getTargetFiles()) {
@@ -221,7 +205,6 @@
         }
     }
 
-    @Test
     public void testGetPrimaryVolume() throws Exception {
         final StorageVolume volume = mStorageManager.getPrimaryStorageVolume();
         assertNotNull("Did not get primary storage", volume);
@@ -273,7 +256,6 @@
         }
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testGetStorageVolumes() throws Exception {
         final List<StorageVolume> volumes = mStorageManager.getStorageVolumes();
@@ -289,7 +271,6 @@
         assertStorageVolumesEquals(primary, mStorageManager.getPrimaryStorageVolume());
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testGetRecentStorageVolumes() throws Exception {
         // At a minimum recent volumes should include current volumes
@@ -300,7 +281,6 @@
         assertTrue(recentNames.containsAll(currentNames));
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testGetStorageVolume() throws Exception {
         assertNull("Should not get volume for null path",
@@ -324,11 +304,8 @@
         assertStorageVolumesEquals(primary, childVolume);
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testGetStorageVolumeUSB() throws Exception {
-        assumeTrue(StorageManagerHelper.isAdoptableStorageSupported(mContext));
-
         String volumeName = StorageManagerHelper.createUSBVirtualDisk();
         Log.d(TAG, "testGetStorageVolumeUSB#volumeName: " + volumeName);
         List<StorageVolume> storageVolumes = mStorageManager.getStorageVolumes();
@@ -341,11 +318,8 @@
                 .collect(joining("\n")), usbStorageVolume.isPresent());
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testGetStorageVolumeSDCard() throws Exception {
-        assumeTrue(StorageManagerHelper.isAdoptableStorageSupported(mContext));
-
         String volumeName = StorageManagerHelper.createSDCardVirtualDisk();
         Log.d(TAG, "testGetStorageVolumeSDCard#volumeName: " + volumeName);
         List<StorageVolume> storageVolumes = mStorageManager.getStorageVolumes();
@@ -366,7 +340,6 @@
         }
     }
 
-    @Test
     public void testGetUuidForPath() throws Exception {
         assertEquals(StorageManager.UUID_DEFAULT,
                 mStorageManager.getUuidForPath(Environment.getDataDirectory()));
@@ -377,7 +350,6 @@
         assertNoUuid(new File("/proc/"));
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testGetExternalUuidForPath() throws Exception {
         final UUID extUuid = mStorageManager
@@ -390,7 +362,6 @@
         assertEquals(extUuid, mStorageManager.getUuidForPath(new File("/sdcard/")));
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot access external storage")
     public void testCallback() throws Exception {
         final CountDownLatch mounted = new CountDownLatch(1);
@@ -485,7 +456,6 @@
         }
     }
 
-    @Test
     public void testOpenProxyFileDescriptor() throws Exception {
         final TestProxyFileDescriptorCallback appleCallback =
                 new TestProxyFileDescriptorCallback(1024 * 1024, "Apple");
@@ -608,7 +578,7 @@
                 assertEquals(1, orangeCallback.releaseCount);
                 assertEquals(1, cherryCallback.releaseCount);
                 break;
-            } catch (AssertionError error) {
+            } catch (AssertionFailedError error) {
                 if (retry-- > 0) {
                    Thread.sleep(500);
                    continue;
@@ -619,7 +589,6 @@
         }
     }
 
-    @Test
     public void testOpenProxyFileDescriptor_error() throws Exception {
         final TestProxyFileDescriptorCallback callback =
                 new TestProxyFileDescriptorCallback(1024 * 1024, "Error");
@@ -681,7 +650,6 @@
         }
     }
 
-    @Test
     public void testOpenProxyFileDescriptor_async() throws Exception {
         final CountDownLatch blockReadLatch = new CountDownLatch(1);
         final CountDownLatch readBlockedLatch = new CountDownLatch(1);
@@ -759,7 +727,6 @@
         looperThread.join();
     }
 
-    @Test
     public void testOpenProxyFileDescriptor_largeFile() throws Exception {
         final ProxyFileDescriptorCallback callback = new ProxyFileDescriptorCallback() {
             @Override
@@ -792,7 +759,6 @@
         }
     }
 
-    @Test
     public void testOpenProxyFileDescriptor_largeRead() throws Exception {
         final int SIZE = 1024 * 1024;
         final TestProxyFileDescriptorCallback callback =
@@ -809,7 +775,6 @@
         }
     }
 
-    @Test
     public void testOpenProxyFileDescriptor_largeWrite() throws Exception {
         final int SIZE = 1024 * 1024;
         final TestProxyFileDescriptorCallback callback =
@@ -829,7 +794,6 @@
         }
     }
 
-    @Test
     public void testIsAllocationSupported() throws Exception {
         FileDescriptor good = Os.open(
             File.createTempFile("StorageManagerTest", "").getAbsolutePath(),
@@ -849,7 +813,6 @@
         }
     }
 
-    @Test
     public void testFatUuidHandling() throws Exception {
         assertEquals(UUID.fromString("fafafafa-fafa-5afa-8afa-fafa01234567"),
                 StorageManager.convert("0123-4567"));
@@ -874,7 +837,6 @@
                 StorageManager.convert(UUID.fromString("fafafafa-fafa-5afa-8afa-fafadeadbeef")));
     }
 
-    @Test
     @AppModeFull(reason = "Instant apps cannot hold MANAGE_EXTERNAL_STORAGE permission")
     public void testGetManageSpaceActivityIntent() throws Exception {
         String packageName = "android.os.cts";
@@ -1078,7 +1040,6 @@
         }
     }
 
-    @Test
     public void testComputeStorageCacheBytes() throws Exception {
         File mockFile = mock(File.class);
 
diff --git a/tests/tests/permission3/CreateNotificationChannelsApp31/src/android/permission3/cts/usepermission/CreateNotificationChannelsActivity.kt b/tests/tests/permission3/CreateNotificationChannelsApp31/src/android/permission3/cts/usepermission/CreateNotificationChannelsActivity.kt
index 104655f..3c8a35c 100644
--- a/tests/tests/permission3/CreateNotificationChannelsApp31/src/android/permission3/cts/usepermission/CreateNotificationChannelsActivity.kt
+++ b/tests/tests/permission3/CreateNotificationChannelsApp31/src/android/permission3/cts/usepermission/CreateNotificationChannelsActivity.kt
@@ -22,6 +22,7 @@
 import android.app.NotificationManager
 import android.content.Intent
 import android.content.pm.PackageManager
+import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 
@@ -43,9 +44,13 @@
     lateinit var notificationManager: NotificationManager
     var launchActivityOnSecondResume = false
     var isFirstResume = true
+    var windowHasFocus = false
+    var pendingCreateChannel = false
     val handler = Handler(Looper.getMainLooper())
 
-    override fun onStart() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
         val launchSecondActivity = intent.getBooleanExtra(EXTRA_START_SECOND_ACTIVITY, false)
         notificationManager = baseContext.getSystemService(NotificationManager::class.java)!!
         if (intent.getBooleanExtra(EXTRA_START_SECOND_APP, false)) {
@@ -73,7 +78,6 @@
             }
         }
 
-
         if (intent.getBooleanExtra(EXTRA_REQUEST_OTHER_PERMISSIONS, false)) {
             requestPermissions(arrayOf(Manifest.permission.RECORD_AUDIO), 0)
         } else if (intent.getBooleanExtra(EXTRA_REQUEST_OTHER_PERMISSIONS_DELAYED, false)) {
@@ -85,8 +89,6 @@
         if (intent.getBooleanExtra(EXTRA_REQUEST_NOTIF_PERMISSION, false)) {
             requestPermissions(arrayOf(Manifest.permission.POST_NOTIFICATIONS), 0)
         }
-
-        super.onStart()
     }
 
     private fun launchSecondActivity() {
@@ -99,7 +101,21 @@
                             }, LONG_DELAY_MS)
     }
 
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        windowHasFocus = hasFocus
+        if (windowHasFocus && pendingCreateChannel) {
+            pendingCreateChannel = false
+            createChannel()
+        }
+    }
+
     private fun createChannel() {
+        // Wait until window has focus so the permission prompt can be displayed
+        if (!windowHasFocus) {
+            pendingCreateChannel = true
+            return
+        }
+
         if (notificationManager.getNotificationChannel(CHANNEL_ID_31) == null) {
             notificationManager.createNotificationChannel(NotificationChannel(CHANNEL_ID_31,
                 "Foreground Services", NotificationManager.IMPORTANCE_HIGH))
diff --git a/tests/tests/permission3/src/android/permission3/cts/NotificationPermissionTest.kt b/tests/tests/permission3/src/android/permission3/cts/NotificationPermissionTest.kt
index d55e3a4..dee76c2 100644
--- a/tests/tests/permission3/src/android/permission3/cts/NotificationPermissionTest.kt
+++ b/tests/tests/permission3/src/android/permission3/cts/NotificationPermissionTest.kt
@@ -194,6 +194,7 @@
     fun notificationPromptShownForSubsequentStartsIfTaskStartWasLauncher() {
         installPackage(APP_APK_PATH_CREATE_NOTIFICATION_CHANNELS_31, expectSuccess = true)
         launchApp(startSecondActivity = true)
+        waitFindObject(By.res(ALLOW_BUTTON))
         pressBack()
         clickPermissionRequestAllowButton()
     }
diff --git a/tests/tests/security/src/android/security/cts/PackageSignatureTest.java b/tests/tests/security/src/android/security/cts/PackageSignatureTest.java
index 4bfe8fe..b6ee6ed 100644
--- a/tests/tests/security/src/android/security/cts/PackageSignatureTest.java
+++ b/tests/tests/security/src/android/security/cts/PackageSignatureTest.java
@@ -102,7 +102,7 @@
         wellKnownSignatures.add(getSignature(R.raw.sig_com_google_android_runtime_debug));
         wellKnownSignatures.add(getSignature(R.raw.sig_com_google_android_runtime_release));
         wellKnownSignatures.add(getSignature(R.raw.sig_com_google_android_tzdata3));
-        // The following keys are not not used by modules on the latest Android release, but it
+        // The following keys are not used by modules on the latest Android release, but it
         // won't negatively affect tests to include their signatures here too.
         wellKnownSignatures.add(getSignature(R.raw.sig_com_google_android_tzdata));
         wellKnownSignatures.add(getSignature(R.raw.sig_com_google_android_tzdata2));
diff --git a/tests/tests/vcn/src/android/net/vcn/cts/VcnManagerTest.java b/tests/tests/vcn/src/android/net/vcn/cts/VcnManagerTest.java
index 6051a5c..8de86d3 100644
--- a/tests/tests/vcn/src/android/net/vcn/cts/VcnManagerTest.java
+++ b/tests/tests/vcn/src/android/net/vcn/cts/VcnManagerTest.java
@@ -519,6 +519,128 @@
         }
     }
 
+    private class NetworkSelectionTestNetworkParams {
+        public final boolean isMetered;
+
+        NetworkSelectionTestNetworkParams(boolean isMetered) {
+            this.isMetered = isMetered;
+        }
+    }
+
+    private TestNetworkWrapper createTestNetworkForNetworkSelection(
+            int subId, NetworkSelectionTestNetworkParams params) throws Exception {
+        return createTestNetworkWrapper(params.isMetered, subId, LOCAL_ADDRESS);
+    }
+
+    private void verifyVcnMigratesToPreferredUnderlyingNetwork(
+            VcnConfig vcnConfig,
+            NetworkSelectionTestNetworkParams lessPreferred,
+            NetworkSelectionTestNetworkParams preferred)
+            throws Exception {
+        final int subId = verifyAndGetValidDataSubId();
+
+        // Start on a less preferred network.
+        try (TestNetworkWrapper testNetworkWrapperLessPreferred =
+                createTestNetworkForNetworkSelection(subId, lessPreferred)) {
+            verifyUnderlyingCellAndRunTest(
+                    subId,
+                    (subGrp, cellNetwork, cellNetworkCb) -> {
+                        final VcnSetupResult vcnSetupResult =
+                                setupAndGetVcnNetwork(
+                                        subGrp,
+                                        cellNetwork,
+                                        cellNetworkCb,
+                                        vcnConfig,
+                                        testNetworkWrapperLessPreferred);
+
+                        // Then bring up a more preferred network, and expect to switch to it.
+                        try (TestNetworkWrapper testNetworkWrapperPreferred =
+                                createTestNetworkForNetworkSelection(subId, preferred)) {
+                            injectAndVerifyIkeMobikePackets(
+                                    testNetworkWrapperPreferred.ikeTunUtils);
+
+                            clearVcnConfigsAndVerifyNetworkTeardown(
+                                    subGrp, cellNetworkCb, vcnSetupResult.vcnNetwork);
+                        }
+                    });
+        }
+    }
+
+    private void verifyVcnDoesNotSelectLessPreferredUnderlyingNetwork(
+            VcnConfig vcnConfig,
+            NetworkSelectionTestNetworkParams lessPreferred,
+            NetworkSelectionTestNetworkParams preferred)
+            throws Exception {
+        final int subId = verifyAndGetValidDataSubId();
+
+        // Start on a more preferred network.
+        try (TestNetworkWrapper testNetworkWrapperPreferred =
+                createTestNetworkForNetworkSelection(subId, preferred)) {
+            verifyUnderlyingCellAndRunTest(
+                    subId,
+                    (subGrp, cellNetwork, cellNetworkCb) -> {
+                        final VcnSetupResult vcnSetupResult =
+                                setupAndGetVcnNetwork(
+                                        subGrp,
+                                        cellNetwork,
+                                        cellNetworkCb,
+                                        vcnConfig,
+                                        testNetworkWrapperPreferred);
+
+                        // Then bring up a less preferred network, and expect the VCN underlying
+                        // network does not change.
+                        try (TestNetworkWrapper testNetworkWrapperLessPreferred =
+                                createTestNetworkForNetworkSelection(subId, lessPreferred)) {
+                            injectAndVerifyIkeDpdPackets(
+                                    testNetworkWrapperPreferred.ikeTunUtils,
+                                    vcnSetupResult.ikeExchangePortPair);
+
+                            clearVcnConfigsAndVerifyNetworkTeardown(
+                                    subGrp, cellNetworkCb, vcnSetupResult.vcnNetwork);
+                        }
+                    });
+        }
+    }
+
+    private void verifyVcnMigratesAfterPreferredUnderlyingNetworkDies(
+            VcnConfig vcnConfig,
+            NetworkSelectionTestNetworkParams lessPreferred,
+            NetworkSelectionTestNetworkParams preferred)
+            throws Exception {
+        final int subId = verifyAndGetValidDataSubId();
+
+        // Start on a more preferred network
+        try (TestNetworkWrapper testNetworkWrapperPreferred =
+                createTestNetworkForNetworkSelection(subId, preferred)) {
+            verifyUnderlyingCellAndRunTest(
+                    subId,
+                    (subGrp, cellNetwork, cellNetworkCb) -> {
+                        final VcnSetupResult vcnSetupResult =
+                                setupAndGetVcnNetwork(
+                                        subGrp,
+                                        cellNetwork,
+                                        cellNetworkCb,
+                                        vcnConfig,
+                                        testNetworkWrapperPreferred);
+
+                        // Bring up a less preferred network
+                        try (TestNetworkWrapper testNetworkWrapperLessPreferred =
+                                createTestNetworkForNetworkSelection(subId, lessPreferred)) {
+                            // Teardown the preferred network
+                            testNetworkWrapperPreferred.close();
+                            testNetworkWrapperPreferred.vcnNetworkCallback.waitForLost();
+
+                            // Verify the VCN switches to the remaining less preferred network
+                            injectAndVerifyIkeMobikePackets(
+                                    testNetworkWrapperLessPreferred.ikeTunUtils);
+
+                            clearVcnConfigsAndVerifyNetworkTeardown(
+                                    subGrp, cellNetworkCb, vcnSetupResult.vcnNetwork);
+                        }
+                    });
+        }
+    }
+
     private VcnConfig createVcnConfigPrefersMetered() throws Exception {
         final List<VcnUnderlyingNetworkTemplate> nwTemplates = new ArrayList<>();
         nwTemplates.add(
@@ -529,98 +651,29 @@
     }
 
     @Test
-    public void testVcnMigratesToPreferredUnderlyingNetwork() throws Exception {
-        final int subId = verifyAndGetValidDataSubId();
-        final VcnConfig vcnConfig = createVcnConfigPrefersMetered();
-
-        // Start on NOT_METERED, less preferred network.
-        try (TestNetworkWrapper testNetworkWrapperNotMetered =
-                createTestNetworkWrapper(false /* isMetered */, subId, LOCAL_ADDRESS)) {
-            verifyUnderlyingCellAndRunTest(subId, (subGrp, cellNetwork, cellNetworkCb) -> {
-                final VcnSetupResult vcnSetupResult =
-                    setupAndGetVcnNetwork(
-                        subGrp,
-                        cellNetwork,
-                        cellNetworkCb,
-                        vcnConfig,
-                        testNetworkWrapperNotMetered);
-
-                // Then bring up a more preferred network, and expect to switch to it.
-                try (TestNetworkWrapper testNetworkWrapperMetered =
-                        createTestNetworkWrapper(true /* isMetered */, subId, LOCAL_ADDRESS)) {
-                    injectAndVerifyIkeMobikePackets(testNetworkWrapperMetered.ikeTunUtils);
-
-                    clearVcnConfigsAndVerifyNetworkTeardown(
-                            subGrp, cellNetworkCb, vcnSetupResult.vcnNetwork);
-                }
-            });
-        }
+    public void testVcnMigratesToPreferredUnderlyingNetwork_preferMetered() throws Exception {
+        verifyVcnMigratesToPreferredUnderlyingNetwork(
+                createVcnConfigPrefersMetered(),
+                new NetworkSelectionTestNetworkParams(false /* isMetered */),
+                new NetworkSelectionTestNetworkParams(true /* isMetered */));
     }
 
     @Test
-    public void testVcnDoesNotSelectLessPreferredUnderlyingNetwork() throws Exception {
-        final int subId = verifyAndGetValidDataSubId();
-        final VcnConfig vcnConfig = createVcnConfigPrefersMetered();
-
-        // Start on METERED, more preferred network
-        try (TestNetworkWrapper testNetworkWrapperMetered =
-                createTestNetworkWrapper(true /* isMetered */, subId, LOCAL_ADDRESS)) {
-            verifyUnderlyingCellAndRunTest(subId, (subGrp, cellNetwork, cellNetworkCb) -> {
-                final VcnSetupResult vcnSetupResult =
-                        setupAndGetVcnNetwork(
-                                subGrp,
-                                cellNetwork,
-                                cellNetworkCb,
-                                vcnConfig,
-                                testNetworkWrapperMetered);
-
-                // Then bring up a less preferred network, and expect the VCN underlying
-                // network does not change.
-                try (TestNetworkWrapper testNetworkWrapperNotMetered =
-                        createTestNetworkWrapper(false /* isMetered */, subId, LOCAL_ADDRESS)) {
-                    injectAndVerifyIkeDpdPackets(
-                            testNetworkWrapperMetered.ikeTunUtils,
-                            vcnSetupResult.ikeExchangePortPair);
-
-                    clearVcnConfigsAndVerifyNetworkTeardown(
-                            subGrp, cellNetworkCb, vcnSetupResult.vcnNetwork);
-                }
-            });
-        }
+    public void testVcnDoesNotSelectLessPreferredUnderlyingNetwork_preferMetered()
+            throws Exception {
+        verifyVcnDoesNotSelectLessPreferredUnderlyingNetwork(
+                createVcnConfigPrefersMetered(),
+                new NetworkSelectionTestNetworkParams(false /* isMetered */),
+                new NetworkSelectionTestNetworkParams(true /* isMetered */));
     }
 
     @Test
-    public void testVcnMigratesAfterPreferredUnderlyingNetworkDies() throws Exception {
-        final int subId = verifyAndGetValidDataSubId();
-        final VcnConfig vcnConfig = createVcnConfigPrefersMetered();
-
-        // Start on METERED, more preferred network
-        try (TestNetworkWrapper testNetworkWrapperMetered =
-                createTestNetworkWrapper(true /* isMetered */, subId, LOCAL_ADDRESS)) {
-            verifyUnderlyingCellAndRunTest(subId, (subGrp, cellNetwork, cellNetworkCb) -> {
-                final VcnSetupResult vcnSetupResult =
-                        setupAndGetVcnNetwork(
-                                subGrp,
-                                cellNetwork,
-                                cellNetworkCb,
-                                vcnConfig,
-                                testNetworkWrapperMetered);
-
-                // Bring up a NOT_METERED, less preferred network
-                try (TestNetworkWrapper testNetworkWrapperNotMetered =
-                        createTestNetworkWrapper(false /* isMetered */, subId, LOCAL_ADDRESS)) {
-                    // Teardown the preferred network
-                    testNetworkWrapperMetered.close();
-                    testNetworkWrapperMetered.vcnNetworkCallback.waitForLost();
-
-                    // Verify the VCN switches to the remaining NOT_METERED network
-                    injectAndVerifyIkeMobikePackets(testNetworkWrapperNotMetered.ikeTunUtils);
-
-                    clearVcnConfigsAndVerifyNetworkTeardown(
-                            subGrp, cellNetworkCb, vcnSetupResult.vcnNetwork);
-                }
-            });
-        }
+    public void testVcnMigratesAfterPreferredUnderlyingNetworkDies_preferMetered()
+            throws Exception {
+        verifyVcnMigratesAfterPreferredUnderlyingNetworkDies(
+                createVcnConfigPrefersMetered(),
+                new NetworkSelectionTestNetworkParams(false /* isMetered */),
+                new NetworkSelectionTestNetworkParams(true /* isMetered */));
     }
 
     @Test
diff --git a/tests/tests/view/src/android/view/cts/PixelCopyViewProducerActivity.java b/tests/tests/view/src/android/view/cts/PixelCopyViewProducerActivity.java
index c89cdb8..9cff62b 100644
--- a/tests/tests/view/src/android/view/cts/PixelCopyViewProducerActivity.java
+++ b/tests/tests/view/src/android/view/cts/PixelCopyViewProducerActivity.java
@@ -72,6 +72,9 @@
         view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
         mContent.getViewTreeObserver().addOnDrawListener(this);
         mContent.setOnApplyWindowInsetsListener(this);
+
+        //setDecorFitsSystemWindows to false will ignore the cutout
+        getWindow().setDecorFitsSystemWindows(false);
     }
 
     @Override
diff --git a/tests/tests/view/surfacevalidator/src/android/view/cts/surfacevalidator/ASurfaceControlTestActivity.java b/tests/tests/view/surfacevalidator/src/android/view/cts/surfacevalidator/ASurfaceControlTestActivity.java
index d1e388b..08c2231 100644
--- a/tests/tests/view/surfacevalidator/src/android/view/cts/surfacevalidator/ASurfaceControlTestActivity.java
+++ b/tests/tests/view/surfacevalidator/src/android/view/cts/surfacevalidator/ASurfaceControlTestActivity.java
@@ -97,6 +97,7 @@
         decorView.setPointerIcon(
                 PointerIcon.getSystemIcon(this, PointerIcon.TYPE_NULL));
         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+        getWindow().setDecorFitsSystemWindows(false);
 
         mLayoutParams = new FrameLayout.LayoutParams(DEFAULT_LAYOUT_WIDTH, DEFAULT_LAYOUT_HEIGHT,
                 Gravity.LEFT | Gravity.TOP);