diff --git a/tests/FlickerTests/Android.bp b/tests/FlickerTests/Android.bp
index 5161fba..952997e 100644
--- a/tests/FlickerTests/Android.bp
+++ b/tests/FlickerTests/Android.bp
@@ -24,6 +24,7 @@
     test_suites: ["device-tests"],
     libs: ["android.test.runner"],
     static_libs: [
+        "androidx.test.ext.junit",
         "flickertestapplib",
         "flickerlib",
         "truth-prebuilt",
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/CommonAssertions.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/CommonAssertions.kt
new file mode 100644
index 0000000..dcabce8
--- /dev/null
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/CommonAssertions.kt
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2020 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 com.android.server.wm.flicker
+
+import com.android.server.wm.flicker.dsl.LayersAssertion
+import com.android.server.wm.flicker.dsl.WmAssertion
+import com.android.server.wm.flicker.helpers.WindowUtils
+
+@JvmOverloads
+fun WmAssertion.statusBarWindowIsAlwaysVisible(
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("statusBarWindowIsAlwaysVisible", enabled, bugId) {
+        this.showsAboveAppWindow(FlickerTestBase.STATUS_BAR_WINDOW_TITLE)
+    }
+}
+
+@JvmOverloads
+fun WmAssertion.navBarWindowIsAlwaysVisible(
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("navBarWindowIsAlwaysVisible", enabled, bugId) {
+        this.showsAboveAppWindow(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE)
+    }
+}
+
+@JvmOverloads
+fun LayersAssertion.noUncoveredRegions(
+    beginRotation: Int,
+    endRotation: Int = beginRotation,
+    allStates: Boolean = true,
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    val startingBounds = WindowUtils.getDisplayBounds(beginRotation)
+    val endingBounds = WindowUtils.getDisplayBounds(endRotation)
+    if (allStates) {
+        all("noUncoveredRegions", enabled, bugId) {
+            if (startingBounds == endingBounds) {
+                this.coversRegion(startingBounds)
+            } else {
+                this.coversRegion(startingBounds)
+                        .then()
+                        .coversRegion(endingBounds)
+            }
+        }
+    } else {
+        start("noUncoveredRegions_StartingPos") {
+            this.coversRegion(startingBounds)
+        }
+        end("noUncoveredRegions_EndingPos") {
+            this.coversRegion(endingBounds)
+        }
+    }
+}
+
+@JvmOverloads
+fun LayersAssertion.navBarLayerIsAlwaysVisible(
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("navBarLayerIsAlwaysVisible", enabled, bugId) {
+        this.showsLayer(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE)
+    }
+}
+
+@JvmOverloads
+fun LayersAssertion.statusBarLayerIsAlwaysVisible(
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("statusBarLayerIsAlwaysVisible", enabled, bugId) {
+        this.showsLayer(FlickerTestBase.STATUS_BAR_WINDOW_TITLE)
+    }
+}
+
+@JvmOverloads
+fun LayersAssertion.navBarLayerRotatesAndScales(
+    beginRotation: Int,
+    endRotation: Int = beginRotation,
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    val startingPos = WindowUtils.getNavigationBarPosition(beginRotation)
+    val endingPos = WindowUtils.getNavigationBarPosition(endRotation)
+
+    start("navBarLayerRotatesAndScales_StartingPos", enabled, bugId) {
+        this.hasVisibleRegion(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE, startingPos)
+    }
+    end("navBarLayerRotatesAndScales_EndingPost", enabled, bugId) {
+        this.hasVisibleRegion(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE, endingPos)
+    }
+
+    if (startingPos == endingPos) {
+        all("navBarLayerRotatesAndScales", enabled, bugId) {
+            this.hasVisibleRegion(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE, startingPos)
+        }
+    }
+}
+
+@JvmOverloads
+fun LayersAssertion.statusBarLayerRotatesScales(
+    beginRotation: Int,
+    endRotation: Int = beginRotation,
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    val startingPos = WindowUtils.getStatusBarPosition(beginRotation)
+    val endingPos = WindowUtils.getStatusBarPosition(endRotation)
+
+    start("statusBarLayerRotatesScales_StartingPos", enabled, bugId) {
+        this.hasVisibleRegion(FlickerTestBase.STATUS_BAR_WINDOW_TITLE, startingPos)
+    }
+    end("statusBarLayerRotatesScales_EndingPos", enabled, bugId) {
+        this.hasVisibleRegion(FlickerTestBase.STATUS_BAR_WINDOW_TITLE, endingPos)
+    }
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/CommonTransitions.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/CommonTransitions.kt
deleted file mode 100644
index b69e6a9..0000000
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/CommonTransitions.kt
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
- * Copyright (C) 2020 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 com.android.server.wm.flicker
-
-import android.app.Instrumentation
-import android.content.Context
-import android.content.Intent
-import android.os.RemoteException
-import android.os.SystemClock
-import android.platform.helpers.IAppHelper
-import android.util.Rational
-import android.view.Surface
-import androidx.test.uiautomator.By
-import androidx.test.uiautomator.UiDevice
-import androidx.test.uiautomator.Until
-import com.android.server.wm.flicker.helpers.AutomationUtils
-import com.android.server.wm.flicker.helpers.ImeAppHelper
-import com.android.server.wm.flicker.helpers.PipAppHelper
-
-/**
- * Collection of common transitions which can be used to test different apps or scenarios.
- */
-internal object CommonTransitions {
-    private const val ITERATIONS = 1
-    private const val APP_LAUNCH_TIMEOUT: Long = 10000
-    private fun setRotation(device: UiDevice, rotation: Int) {
-        try {
-            when (rotation) {
-                Surface.ROTATION_270 -> device.setOrientationLeft()
-                Surface.ROTATION_90 -> device.setOrientationRight()
-                Surface.ROTATION_0 -> device.setOrientationNatural()
-                else -> device.setOrientationNatural()
-            }
-            // Wait for animation to complete
-            SystemClock.sleep(1000)
-        } catch (e: RemoteException) {
-            throw RuntimeException(e)
-        }
-    }
-
-    /**
-     * Build a test tag for the test
-     * @param testName Name of the transition(s) being tested
-     * @param app App being launcher
-     * @param rotation Initial screen rotation
-     *
-     * @return test tag with pattern <NAME>__<APP>__<ROTATION>
-    </ROTATION></APP></NAME> */
-    private fun buildTestTag(testName: String, app: IAppHelper, rotation: Int): String {
-        return buildTestTag(
-                testName, app, rotation, rotation, app2 = null, extraInfo = "")
-    }
-
-    /**
-     * Build a test tag for the test
-     * @param testName Name of the transition(s) being tested
-     * @param app App being launcher
-     * @param beginRotation Initial screen rotation
-     * @param endRotation End screen rotation (if any, otherwise use same as initial)
-     *
-     * @return test tag with pattern <NAME>__<APP>__<BEGIN_ROTATION>-<END_ROTATION>
-    </END_ROTATION></BEGIN_ROTATION></APP></NAME> */
-    private fun buildTestTag(
-        testName: String,
-        app: IAppHelper,
-        beginRotation: Int,
-        endRotation: Int
-    ): String {
-        return buildTestTag(
-                testName, app, beginRotation, endRotation, app2 = null, extraInfo = "")
-    }
-
-    /**
-     * Build a test tag for the test
-     * @param testName Name of the transition(s) being tested
-     * @param app App being launcher
-     * @param app2 Second app being launched (if any)
-     * @param beginRotation Initial screen rotation
-     * @param endRotation End screen rotation (if any, otherwise use same as initial)
-     * @param extraInfo Additional information to append to the tag
-     *
-     * @return test tag with pattern <NAME>__<APP></APP>(S)>__<ROTATION></ROTATION>(S)>[__<EXTRA>]
-    </EXTRA></NAME> */
-    private fun buildTestTag(
-        testName: String,
-        app: IAppHelper,
-        beginRotation: Int,
-        endRotation: Int,
-        app2: IAppHelper?,
-        extraInfo: String
-    ): String {
-        val testTag = StringBuilder()
-        testTag.append(testName)
-                .append("__")
-                .append(app.launcherName)
-        if (app2 != null) {
-            testTag.append("-")
-                    .append(app2.launcherName)
-        }
-        testTag.append("__")
-                .append(Surface.rotationToString(beginRotation))
-        if (endRotation != beginRotation) {
-            testTag.append("-")
-                    .append(Surface.rotationToString(endRotation))
-        }
-        if (extraInfo.isNotEmpty()) {
-            testTag.append("__")
-                    .append(extraInfo)
-        }
-        return testTag.toString()
-    }
-
-    fun openAppWarm(
-        testApp: IAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("openAppWarm", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBeforeAll { setRotation(device, beginRotation) }
-                .runBeforeAll { testApp.open() }
-                .runBefore { device.pressHome() }
-                .runBefore { device.waitForIdle() }
-                .runBefore { setRotation(device, beginRotation) }
-                .run { testApp.open() }
-                .runAfterAll { testApp.exit() }
-                .runAfterAll { AutomationUtils.setDefaultWait() }
-                .repeat(ITERATIONS)
-    }
-
-    fun closeAppWithBackKey(
-        testApp: IAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("closeAppWithBackKey", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { testApp.open() }
-                .runBefore { device.waitForIdle() }
-                .run { device.pressBack() }
-                .run { device.waitForIdle() }
-                .runAfterAll { testApp.exit() }
-                .runAfterAll { AutomationUtils.setDefaultWait() }
-                .repeat(ITERATIONS)
-    }
-
-    fun closeAppWithHomeKey(
-        testApp: IAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("closeAppWithHomeKey", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { testApp.open() }
-                .runBefore { device.waitForIdle() }
-                .run { device.pressHome() }
-                .run { device.waitForIdle() }
-                .runAfterAll { testApp.exit() }
-                .runAfterAll { AutomationUtils.setDefaultWait() }
-                .repeat(ITERATIONS)
-    }
-
-    fun openAppCold(
-        testApp: IAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("openAppCold", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { device.pressHome() }
-                .runBeforeAll { setRotation(device, beginRotation) }
-                .runBefore { testApp.exit() }
-                .runBefore { device.waitForIdle() }
-                .run { testApp.open() }
-                .runAfterAll { testApp.exit() }
-                .runAfterAll { setRotation(device, Surface.ROTATION_0) }
-                .repeat(ITERATIONS)
-    }
-
-    fun changeAppRotation(
-        testApp: IAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int,
-        endRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("changeAppRotation", testApp, beginRotation, endRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBeforeAll { testApp.open() }
-                .runBefore { setRotation(device, beginRotation) }
-                .run { setRotation(device, endRotation) }
-                .runAfterAll { testApp.exit() }
-                .runAfterAll { setRotation(device, Surface.ROTATION_0) }
-                .repeat(ITERATIONS)
-    }
-
-    fun changeAppRotation(
-        intent: Intent,
-        intentId: String,
-        context: Context,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int,
-        endRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        val testTag = "changeAppRotation_" + intentId + "_" +
-                Surface.rotationToString(beginRotation) + "_" +
-                Surface.rotationToString(endRotation)
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(testTag)
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBeforeAll {
-                    context.startActivity(intent)
-                    device.wait(Until.hasObject(By.pkg(intent.component?.packageName)
-                            .depth(0)), APP_LAUNCH_TIMEOUT)
-                }
-                .runBefore { setRotation(device, beginRotation) }
-                .run { setRotation(device, endRotation) }
-                .runAfterAll { AutomationUtils.stopPackage(context, intent.component?.packageName) }
-                .runAfterAll { setRotation(device, Surface.ROTATION_0) }
-                .repeat(ITERATIONS)
-    }
-
-    fun appToSplitScreen(
-        testApp: IAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("appToSplitScreen", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBeforeAll { setRotation(device, beginRotation) }
-                .runBefore { testApp.open() }
-                .runBefore { device.waitForIdle() }
-                .runBefore { SystemClock.sleep(500) }
-                .run { AutomationUtils.launchSplitScreen(device) }
-                .runAfter { AutomationUtils.exitSplitScreen(device) }
-                .runAfterAll { testApp.exit() }
-                .repeat(ITERATIONS)
-    }
-
-    fun splitScreenToLauncher(
-        testApp: IAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("splitScreenToLauncher", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { testApp.open() }
-                .runBefore { device.waitForIdle() }
-                .runBefore { AutomationUtils.launchSplitScreen(device) }
-                .run { AutomationUtils.exitSplitScreen(device) }
-                .runAfterAll { testApp.exit() }
-                .repeat(ITERATIONS)
-    }
-
-    fun editTextSetFocus(
-        testApp: ImeAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("editTextSetFocus", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { device.pressHome() }
-                .runBefore { setRotation(device, beginRotation) }
-                .runBefore { testApp.open() }
-                .run { testApp.openIME(device) }
-                .runAfterAll { testApp.exit() }
-                .repeat(ITERATIONS)
-    }
-
-    fun resizeSplitScreen(
-        testAppTop: IAppHelper,
-        testAppBottom: ImeAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int,
-        startRatio: Rational,
-        stopRatio: Rational
-    ): TransitionRunner.TransitionBuilder {
-        val description = (startRatio.toString().replace("/", "-") + "_to_" +
-                stopRatio.toString().replace("/", "-"))
-        val testTag = buildTestTag("resizeSplitScreen", testAppTop, beginRotation,
-                beginRotation, testAppBottom, description)
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(testTag)
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBeforeAll { setRotation(device, beginRotation) }
-                .runBeforeAll { AutomationUtils.clearRecents(instrumentation) }
-                .runBefore { testAppBottom.open() }
-                .runBefore { device.pressHome() }
-                .runBefore { testAppTop.open() }
-                .runBefore { device.waitForIdle() }
-                .runBefore { AutomationUtils.launchSplitScreen(device) }
-                .runBefore {
-                    val snapshot = device.findObject(
-                            By.res(device.launcherPackageName, "snapshot"))
-                    snapshot.click()
-                }
-                .runBefore { testAppBottom.openIME(device) }
-                .runBefore { device.pressBack() }
-                .runBefore { AutomationUtils.resizeSplitScreen(device, startRatio) }
-                .run { AutomationUtils.resizeSplitScreen(device, stopRatio) }
-                .runAfter { AutomationUtils.exitSplitScreen(device) }
-                .runAfter { device.pressHome() }
-                .runAfterAll { testAppTop.exit() }
-                .runAfterAll { testAppBottom.exit() }
-                .repeat(ITERATIONS)
-    }
-
-    fun editTextLoseFocusToHome(
-        testApp: ImeAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("editTextLoseFocusToHome", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { device.pressHome() }
-                .runBefore { setRotation(device, beginRotation) }
-                .runBefore { testApp.open() }
-                .runBefore { testApp.openIME(device) }
-                .run { device.pressHome() }
-                .run { device.waitForIdle() }
-                .runAfterAll { testApp.exit() }
-                .repeat(ITERATIONS)
-    }
-
-    fun editTextLoseFocusToApp(
-        testApp: ImeAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("editTextLoseFocusToApp", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { device.pressHome() }
-                .runBefore { setRotation(device, beginRotation) }
-                .runBefore { testApp.open() }
-                .runBefore { testApp.openIME(device) }
-                .run { device.pressBack() }
-                .run { device.waitForIdle() }
-                .runAfterAll { testApp.exit() }
-                .repeat(ITERATIONS)
-    }
-
-    fun enterPipMode(
-        testApp: PipAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("enterPipMode", testApp, beginRotation))
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { device.pressHome() }
-                .runBefore { setRotation(device, beginRotation) }
-                .runBefore { testApp.open() }
-                .run { testApp.clickEnterPipButton(device) }
-                .runAfter { testApp.closePipWindow(device) }
-                .runAfterAll { testApp.exit() }
-                .repeat(ITERATIONS)
-    }
-
-    fun exitPipModeToHome(
-        testApp: PipAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("exitPipModeToHome", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .runBefore { device.pressHome() }
-                .runBefore { setRotation(device, beginRotation) }
-                .runBefore { testApp.open() }
-                .run { testApp.clickEnterPipButton(device) }
-                .run { testApp.closePipWindow(device) }
-                .run { device.waitForIdle() }
-                .run { testApp.exit() }
-                .repeat(ITERATIONS)
-    }
-
-    fun exitPipModeToApp(
-        testApp: PipAppHelper,
-        instrumentation: Instrumentation,
-        device: UiDevice,
-        beginRotation: Int
-    ): TransitionRunner.TransitionBuilder {
-        return TransitionRunner.TransitionBuilder(instrumentation)
-                .withTag(buildTestTag("exitPipModeToApp", testApp, beginRotation))
-                .recordAllRuns()
-                .runBeforeAll { AutomationUtils.wakeUpAndGoToHomeScreen() }
-                .run { device.pressHome() }
-                .run { setRotation(device, beginRotation) }
-                .run { testApp.open() }
-                .run { testApp.clickEnterPipButton(device) }
-                .run { AutomationUtils.expandPipWindow(device) }
-                .run { device.waitForIdle() }
-                .run { testApp.exit() }
-                .repeat(ITERATIONS)
-    }
-}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/DebugTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/DebugTest.kt
deleted file mode 100644
index 43cfdff..0000000
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/DebugTest.kt
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (C) 2020 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 com.android.server.wm.flicker
-
-import android.platform.helpers.IAppHelper
-import android.util.Rational
-import android.view.Surface
-import androidx.test.InstrumentationRegistry
-import androidx.test.filters.FlakyTest
-import androidx.test.filters.LargeTest
-import androidx.test.runner.AndroidJUnit4
-import androidx.test.uiautomator.UiDevice
-import com.android.server.wm.flicker.helpers.ImeAppHelper
-import com.android.server.wm.flicker.helpers.PipAppHelper
-import org.junit.FixMethodOrder
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-
-/**
- * Tests to help debug individual transitions, capture video recordings and create test cases.
- *
- * Not actual tests
- */
-@LargeTest
-@FlakyTest
-@RunWith(AndroidJUnit4::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class DebugTest {
-    private val instrumentation = InstrumentationRegistry.getInstrumentation()
-    private val testApp: IAppHelper = StandardAppHelper(instrumentation,
-            "com.android.server.wm.flicker.testapp", "SimpleApp")
-    private val uiDevice = UiDevice.getInstance(instrumentation)
-
-    /**
-     * atest FlickerTests:DebugTest#openAppCold
-     */
-    @Test
-    fun openAppCold() {
-        CommonTransitions.openAppCold(testApp, instrumentation, uiDevice, Surface.ROTATION_0)
-                .recordAllRuns().build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#openAppWarm
-     */
-    @Test
-    fun openAppWarm() {
-        CommonTransitions.openAppWarm(testApp, instrumentation, uiDevice, Surface.ROTATION_0)
-                .recordAllRuns().build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#changeOrientationFromNaturalToLeft
-     */
-    @Test
-    fun changeOrientationFromNaturalToLeft() {
-        CommonTransitions.changeAppRotation(testApp, instrumentation, uiDevice, Surface.ROTATION_0,
-                Surface.ROTATION_270).recordAllRuns().build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#closeAppWithBackKey
-     */
-    @Test
-    fun closeAppWithBackKey() {
-        CommonTransitions.closeAppWithBackKey(testApp, instrumentation, uiDevice,
-                Surface.ROTATION_0).recordAllRuns().build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#closeAppWithHomeKey
-     */
-    @Test
-    fun closeAppWithHomeKey() {
-        CommonTransitions.closeAppWithHomeKey(testApp, instrumentation, uiDevice,
-                Surface.ROTATION_0).recordAllRuns().build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#openAppToSplitScreen
-     */
-    @Test
-    fun openAppToSplitScreen() {
-        CommonTransitions.appToSplitScreen(testApp, instrumentation, uiDevice,
-                Surface.ROTATION_0).includeJankyRuns().recordAllRuns()
-                .build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#splitScreenToLauncher
-     */
-    @Test
-    fun splitScreenToLauncher() {
-        CommonTransitions.splitScreenToLauncher(testApp, instrumentation, uiDevice,
-                Surface.ROTATION_0).includeJankyRuns().recordAllRuns().build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#resizeSplitScreen
-     */
-    @Test
-    fun resizeSplitScreen() {
-        val bottomApp = ImeAppHelper(instrumentation)
-        CommonTransitions.resizeSplitScreen(
-                testApp,
-                bottomApp,
-                instrumentation,
-                uiDevice,
-                Surface.ROTATION_0,
-                Rational(1, 3), Rational(2, 3)
-        ).includeJankyRuns().build().run()
-    }
-    // IME tests
-    /**
-     * atest FlickerTests:DebugTest#editTextSetFocus
-     */
-    @Test
-    fun editTextSetFocus() {
-        val testApp = ImeAppHelper(instrumentation)
-        CommonTransitions.editTextSetFocus(testApp, instrumentation, uiDevice, Surface.ROTATION_0)
-                .includeJankyRuns()
-                .build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#editTextLoseFocusToHome
-     */
-    @Test
-    fun editTextLoseFocusToHome() {
-        val testApp = ImeAppHelper(instrumentation)
-        CommonTransitions.editTextLoseFocusToHome(testApp, instrumentation, uiDevice,
-                Surface.ROTATION_0).includeJankyRuns().build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#editTextLoseFocusToApp
-     */
-    @Test
-    fun editTextLoseFocusToApp() {
-        val testApp = ImeAppHelper(instrumentation)
-        CommonTransitions.editTextLoseFocusToHome(testApp, instrumentation, uiDevice,
-                Surface.ROTATION_0).includeJankyRuns().build().run()
-    }
-    // PIP tests
-    /**
-     * atest FlickerTests:DebugTest#enterPipMode
-     */
-    @Test
-    fun enterPipMode() {
-        val testApp = PipAppHelper(instrumentation)
-        CommonTransitions.enterPipMode(testApp, instrumentation, uiDevice, Surface.ROTATION_0)
-                .includeJankyRuns().build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#exitPipModeToHome
-     */
-    @Test
-    fun exitPipModeToHome() {
-        val testApp = PipAppHelper(instrumentation)
-        CommonTransitions.exitPipModeToHome(testApp, instrumentation, uiDevice, Surface.ROTATION_0)
-                .includeJankyRuns()
-                .build().run()
-    }
-
-    /**
-     * atest FlickerTests:DebugTest#exitPipModeToApp
-     */
-    @Test
-    fun exitPipModeToApp() {
-        val testApp = PipAppHelper(instrumentation)
-        CommonTransitions.exitPipModeToApp(testApp, instrumentation, uiDevice, Surface.ROTATION_0)
-                .includeJankyRuns().build().run()
-    }
-}
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/FlickerTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/FlickerTestBase.kt
index d7586d0..eaf4d87 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/FlickerTestBase.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/FlickerTestBase.kt
@@ -16,15 +16,12 @@
 
 package com.android.server.wm.flicker
 
+import android.os.RemoteException
+import android.os.SystemClock
 import android.platform.helpers.IAppHelper
-import android.util.Log
-import androidx.test.InstrumentationRegistry
+import android.view.Surface
+import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.uiautomator.UiDevice
-import com.android.server.wm.flicker.helpers.AutomationUtils
-import com.google.common.truth.Truth
-import org.junit.After
-import org.junit.AfterClass
-import org.junit.Before
 
 /**
  * Base class of all Flicker test that performs common functions for all flicker tests:
@@ -37,101 +34,96 @@
  * - Fails tests if results are not available for any test due to jank.
  */
 abstract class FlickerTestBase {
-    lateinit var testApp: IAppHelper
-    open val instrumentation by lazy {
+    val instrumentation by lazy {
         InstrumentationRegistry.getInstrumentation()
     }
     val uiDevice by lazy {
         UiDevice.getInstance(instrumentation)
     }
-    lateinit var tesults: List<TransitionResult>
-    private var lastResult: TransitionResult? = null
 
     /**
-     * Runs a transition, returns a cached result if the transition has run before.
-     */
-    fun run(transition: TransitionRunner) {
-        if (transitionResults.containsKey(transition.testTag)) {
-            tesults = transitionResults[transition.testTag]
-                    ?: throw IllegalStateException("Results do not contain test tag " +
-                            transition.testTag)
-            return
+     * Build a test tag for the test
+     * @param testName Name of the transition(s) being tested
+     * @param app App being launcher
+     * @param rotation Initial screen rotation
+     *
+     * @return test tag with pattern <NAME>__<APP>__<ROTATION>
+    </ROTATION></APP></NAME> */
+    protected fun buildTestTag(testName: String, app: IAppHelper, rotation: Int): String {
+        return buildTestTag(
+                testName, app, rotation, rotation, app2 = null, extraInfo = "")
+    }
+
+    /**
+     * Build a test tag for the test
+     * @param testName Name of the transition(s) being tested
+     * @param app App being launcher
+     * @param beginRotation Initial screen rotation
+     * @param endRotation End screen rotation (if any, otherwise use same as initial)
+     *
+     * @return test tag with pattern <NAME>__<APP>__<BEGIN_ROTATION>-<END_ROTATION>
+    </END_ROTATION></BEGIN_ROTATION></APP></NAME> */
+    protected fun buildTestTag(
+        testName: String,
+        app: IAppHelper,
+        beginRotation: Int,
+        endRotation: Int
+    ): String {
+        return buildTestTag(
+                testName, app, beginRotation, endRotation, app2 = null, extraInfo = "")
+    }
+
+    /**
+     * Build a test tag for the test
+     * @param testName Name of the transition(s) being tested
+     * @param app App being launcher
+     * @param app2 Second app being launched (if any)
+     * @param beginRotation Initial screen rotation
+     * @param endRotation End screen rotation (if any, otherwise use same as initial)
+     * @param extraInfo Additional information to append to the tag
+     *
+     * @return test tag with pattern <NAME>__<APP></APP>(S)>__<ROTATION></ROTATION>(S)>[__<EXTRA>]
+    </EXTRA></NAME> */
+    protected fun buildTestTag(
+        testName: String,
+        app: IAppHelper,
+        beginRotation: Int,
+        endRotation: Int,
+        app2: IAppHelper?,
+        extraInfo: String
+    ): String {
+        var testTag = "${testName}__$${app.launcherName}"
+        if (app2 != null) {
+            testTag += "-${app2.launcherName}"
         }
-        tesults = transition.run().results
-        /* Fail if we don't have any results due to jank */
-        Truth.assertWithMessage("No results to test because all transition runs were invalid " +
-                "because of Jank").that(tesults).isNotEmpty()
-        transitionResults[transition.testTag] = tesults
-    }
-
-    /**
-     * Runs a transition, returns a cached result if the transition has run before.
-     */
-    @Before
-    fun runTransition() {
-        run(transitionToRun)
-    }
-
-    /**
-     * Gets the transition that will be executed
-     */
-    abstract val transitionToRun: TransitionRunner
-
-    /**
-     * Goes through a list of transition results and checks assertions on each result.
-     */
-    fun checkResults(assertion: (TransitionResult) -> Unit) {
-        for (result in tesults) {
-            lastResult = result
-            assertion(result)
+        testTag += "__${Surface.rotationToString(beginRotation)}"
+        if (endRotation != beginRotation) {
+            testTag += "-${Surface.rotationToString(endRotation)}"
         }
-        lastResult = null
+        if (extraInfo.isNotEmpty()) {
+            testTag += "__$extraInfo"
+        }
+        return testTag
     }
 
-    /**
-     * Kludge to mark a file for saving. If `checkResults` fails, the last result is not
-     * cleared. This indicates the assertion failed for the result, so mark it for saving.
-     */
-    @After
-    fun markArtifactsForSaving() {
-        lastResult?.flagForSaving()
+    protected fun Flicker.setRotation(rotation: Int) {
+        try {
+            when (rotation) {
+                Surface.ROTATION_270 -> device.setOrientationLeft()
+                Surface.ROTATION_90 -> device.setOrientationRight()
+                Surface.ROTATION_0 -> device.setOrientationNatural()
+                else -> device.setOrientationNatural()
+            }
+            // Wait for animation to complete
+            SystemClock.sleep(1000)
+        } catch (e: RemoteException) {
+            throw RuntimeException(e)
+        }
     }
 
     companion object {
-        const val TAG = "FLICKER"
         const val NAVIGATION_BAR_WINDOW_TITLE = "NavigationBar"
         const val STATUS_BAR_WINDOW_TITLE = "StatusBar"
         const val DOCKED_STACK_DIVIDER = "DockedStackDivider"
-        private val transitionResults = mutableMapOf<String, List<TransitionResult>>()
-
-        /**
-         * Teardown any system settings and clean up test artifacts from the file system.
-         *
-         * Note: test artifacts for failed tests will remain on the device.
-         */
-        @AfterClass
-        @JvmStatic
-        fun teardown() {
-            AutomationUtils.setDefaultWait()
-            transitionResults.values
-                .flatten()
-                .forEach {
-                    if (it.canDelete()) {
-                        it.delete()
-                    } else {
-                        if (it.layersTraceExists()) {
-                            Log.e(TAG, "Layers trace saved to ${it.layersTracePath}")
-                        }
-                        if (it.windowManagerTraceExists()) {
-                            Log.e(TAG,
-                                    "WindowManager trace saved to ${it.windowManagerTracePath}")
-                        }
-                        if (it.screenCaptureVideoExists()) {
-                            Log.e(TAG,
-                                    "Screen capture video saved to ${it.screenCaptureVideoPath()}")
-                        }
-                    }
-                }
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/NonRotationTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/NonRotationTestBase.kt
index 1f8150c..e7d1f8e 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/NonRotationTestBase.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/NonRotationTestBase.kt
@@ -17,52 +17,20 @@
 package com.android.server.wm.flicker
 
 import android.view.Surface
-import androidx.test.filters.FlakyTest
-import org.junit.Test
 import org.junit.runners.Parameterized
 
 abstract class NonRotationTestBase(
-    beginRotationName: String,
-    protected val beginRotation: Int
+    protected val rotationName: String,
+    protected val rotation: Int
 ) : FlickerTestBase() {
-    @FlakyTest(bugId = 141361128)
-    @Test
-    fun checkCoveredRegion_noUncoveredRegions() {
-        val displayBounds = WindowUtils.getDisplayBounds(beginRotation)
-        checkResults {
-            LayersTraceSubject.assertThat(it).coversRegion(
-                    displayBounds).forAllEntries()
-        }
-    }
-
-    @FlakyTest(bugId = 141361128)
-    @Test
-    fun checkVisibility_navBarLayerIsAlwaysVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(NAVIGATION_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
-    @FlakyTest(bugId = 141361128)
-    @Test
-    fun checkVisibility_statusBarLayerIsAlwaysVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(STATUS_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
     companion object {
+        const val SCREENSHOT_LAYER = "RotationLayer"
+
         @Parameterized.Parameters(name = "{0}")
         @JvmStatic
         fun getParams(): Collection<Array<Any>> {
             val supportedRotations = intArrayOf(Surface.ROTATION_0, Surface.ROTATION_90)
-            val params: MutableCollection<Array<Any>> = ArrayList()
-            for (begin in supportedRotations) {
-                params.add(arrayOf(Surface.rotationToString(begin), begin))
-            }
-            return params
+            return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/RotationTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/RotationTestBase.kt
index dfc3c07..3b67727 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/RotationTestBase.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/RotationTestBase.kt
@@ -17,8 +17,6 @@
 package com.android.server.wm.flicker
 
 import android.view.Surface
-import androidx.test.filters.FlakyTest
-import org.junit.Test
 import org.junit.runners.Parameterized
 
 abstract class RotationTestBase(
@@ -27,82 +25,7 @@
     protected val beginRotation: Int,
     protected val endRotation: Int
 ) : FlickerTestBase() {
-    @FlakyTest(bugId = 140855415)
-    @Test
-    fun checkVisibility_navBarWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAboveAppWindow(NAVIGATION_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
-    @FlakyTest(bugId = 140855415)
-    @Test
-    fun checkVisibility_statusBarWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAboveAppWindow(STATUS_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
-    @Test
-    fun checkPosition_navBarLayerRotatesAndScales() {
-        val startingPos = WindowUtils.getNavigationBarPosition(beginRotation)
-        val endingPos = WindowUtils.getNavigationBarPosition(endRotation)
-        if (startingPos == endingPos) {
-            checkResults {
-                LayersTraceSubject.assertThat(it)
-                        .hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, startingPos)
-                        .forAllEntries()
-            }
-        } else {
-            checkResults {
-                LayersTraceSubject.assertThat(it)
-                        .hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, startingPos)
-                        .inTheBeginning()
-            }
-            checkResults {
-                LayersTraceSubject.assertThat(it)
-                        .hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, endingPos)
-                        .atTheEnd()
-            }
-        }
-    }
-
-    @Test
-    fun checkPosition_statusBarLayerRotatesScales() {
-        val startingPos = WindowUtils.getStatusBarPosition(beginRotation)
-        val endingPos = WindowUtils.getStatusBarPosition(endRotation)
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .hasVisibleRegion(STATUS_BAR_WINDOW_TITLE, startingPos)
-                    .inTheBeginning()
-            LayersTraceSubject.assertThat(it)
-                    .hasVisibleRegion(STATUS_BAR_WINDOW_TITLE, endingPos).atTheEnd()
-        }
-    }
-
-    @FlakyTest(bugId = 140855415)
-    @Test
-    fun checkVisibility_navBarLayerIsAlwaysVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(NAVIGATION_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
-    @FlakyTest(bugId = 140855415)
-    @Test
-    fun checkVisibility_statusBarLayerIsAlwaysVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(STATUS_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
     companion object {
-        const val SCREENSHOT_LAYER = "RotationLayer"
-
         @Parameterized.Parameters(name = "{0}-{1}")
         @JvmStatic
         fun getParams(): Collection<Array<Any>> {
@@ -123,4 +46,4 @@
             return params
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/ImeAppHelper.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/ImeAppHelper.kt
index 979cbea..aa0d7e0 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/ImeAppHelper.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/ImeAppHelper.kt
@@ -29,12 +29,18 @@
     open fun openIME(device: UiDevice) {
         val editText = device.wait(
                 Until.findObject(By.res(getPackage(), "plain_text_input")),
-                AutomationUtils.FIND_TIMEOUT)
+                FIND_TIMEOUT)
         Assert.assertNotNull("Text field not found, this usually happens when the device " +
                 "was left in an unknown state (e.g. in split screen)", editText)
         editText.click()
-        if (!AutomationUtils.waitForIME(device)) {
+        if (!device.waitForIME()) {
             Assert.fail("IME did not appear")
         }
     }
+
+    open fun closeIME(device: UiDevice) {
+        device.pressBack()
+        // Using only the AccessibilityInfo it is not possible to identify if the IME is active
+        device.waitForIdle(1000)
+    }
 }
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/PipAppHelper.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/PipAppHelper.kt
index daee810..ca907d9 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/PipAppHelper.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/PipAppHelper.kt
@@ -27,10 +27,10 @@
         Assert.assertNotNull("Pip button not found, this usually happens when the device " +
                 "was left in an unknown state (e.g. in split screen)", enterPipButton)
         enterPipButton.click()
-        AutomationUtils.hasPipWindow(device)
+        device.hasPipWindow()
     }
 
     fun closePipWindow(device: UiDevice) {
-        AutomationUtils.closePipWindow(device)
+        device.closePipWindow()
     }
 }
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToAppTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToAppTest.kt
index 814cdcf..80d0394 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToAppTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToAppTest.kt
@@ -16,11 +16,19 @@
 
 package com.android.server.wm.flicker.ime
 
-import androidx.test.filters.FlakyTest
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.TransitionRunner
+import com.android.server.wm.flicker.dsl.flicker
 import com.android.server.wm.flicker.helpers.ImeAppAutoFocusHelper
+import com.android.server.wm.flicker.helpers.ImeAppHelper
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -35,33 +43,52 @@
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 class CloseImeAutoOpenWindowToAppTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : CloseImeWindowToAppTest(beginRotationName, beginRotation) {
-    init {
-        testApp = ImeAppAutoFocusHelper(instrumentation)
-    }
+    rotationName: String,
+    rotation: Int
+) : CloseImeWindowToAppTest(rotationName, rotation) {
+    override val testApp: ImeAppHelper
+        get() = ImeAppAutoFocusHelper(instrumentation)
 
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.editTextLoseFocusToApp(testApp as ImeAppAutoFocusHelper,
-                instrumentation, uiDevice, beginRotation)
-                .includeJankyRuns().build()
-
-    @FlakyTest(bugId = 141458352)
     @Test
-    override fun checkVisibility_imeLayerBecomesInvisible() {
-        super.checkVisibility_imeLayerBecomesInvisible()
-    }
+    override fun test() {
+        flicker(instrumentation) {
+            withTag { buildTestTag("imeToAppAutoOpen", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    this.setRotation(rotation)
+                    testApp.open()
+                    testApp.openIME(device)
+                }
+            }
+            teardown {
+                eachRun {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+            transitions {
+                device.pressBack()
+                device.waitForIdle()
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                    imeAppWindowIsAlwaysVisible(testApp, bugId = 141458352)
+                }
 
-    @FlakyTest(bugId = 141458352)
-    @Test
-    override fun checkVisibility_imeAppLayerIsAlwaysVisible() {
-        super.checkVisibility_imeAppLayerIsAlwaysVisible()
-    }
-
-    @FlakyTest(bugId = 141458352)
-    @Test
-    override fun checkVisibility_imeAppWindowIsAlwaysVisible() {
-        super.checkVisibility_imeAppWindowIsAlwaysVisible()
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
+                    imeLayerBecomesInvisible(bugId = 141458352)
+                    imeAppLayerIsAlwaysVisible(testApp, bugId = 141458352)
+                }
+            }
+        }
     }
 }
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToHomeTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToHomeTest.kt
index c2025b6..31d1fd3 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToHomeTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToHomeTest.kt
@@ -16,11 +16,19 @@
 
 package com.android.server.wm.flicker.ime
 
-import androidx.test.filters.FlakyTest
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.TransitionRunner
+import com.android.server.wm.flicker.dsl.flicker
 import com.android.server.wm.flicker.helpers.ImeAppAutoFocusHelper
+import com.android.server.wm.flicker.helpers.ImeAppHelper
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -35,33 +43,53 @@
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 class CloseImeAutoOpenWindowToHomeTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : CloseImeWindowToHomeTest(beginRotationName, beginRotation) {
-    init {
-        testApp = ImeAppAutoFocusHelper(instrumentation)
-    }
+    rotationName: String,
+    rotation: Int
+) : CloseImeWindowToHomeTest(rotationName, rotation) {
+    override val testApp: ImeAppHelper
+        get() = ImeAppAutoFocusHelper(instrumentation)
 
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.editTextLoseFocusToHome(testApp as ImeAppAutoFocusHelper,
-                instrumentation, uiDevice, beginRotation)
-                .includeJankyRuns().build()
-
-    @FlakyTest(bugId = 141458352)
     @Test
-    override fun checkVisibility_imeWindowBecomesInvisible() {
-        super.checkVisibility_imeWindowBecomesInvisible()
-    }
+    override fun test() {
+        flicker(instrumentation) {
+            withTag { buildTestTag("imeToHomeAutoOpen", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    this.setRotation(rotation)
+                    testApp.open()
+                    testApp.openIME(device)
+                }
+            }
+            teardown {
+                eachRun {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+            transitions {
+                device.pressHome()
+                device.waitForIdle()
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                    imeWindowBecomesInvisible(bugId = 141458352)
+                    imeAppWindowBecomesInvisible(testApp, bugId = 157449248)
+                }
 
-    @FlakyTest(bugId = 141458352)
-    @Test
-    override fun checkVisibility_imeLayerBecomesInvisible() {
-        super.checkVisibility_imeLayerBecomesInvisible()
-    }
-
-    @FlakyTest(bugId = 157449248)
-    @Test
-    override fun checkVisibility_imeAppWindowBecomesInvisible() {
-        super.checkVisibility_imeAppWindowBecomesInvisible()
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
+                    imeLayerBecomesInvisible(bugId = 141458352)
+                    imeAppLayerBecomesInvisible(testApp, bugId = 153739621)
+                }
+            }
+        }
     }
 }
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToAppTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToAppTest.kt
index b38262e..67c46d3 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToAppTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToAppTest.kt
@@ -16,14 +16,19 @@
 
 package com.android.server.wm.flicker.ime
 
-import androidx.test.filters.FlakyTest
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.LayersTraceSubject
 import com.android.server.wm.flicker.NonRotationTestBase
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WmTraceSubject
+import com.android.server.wm.flicker.dsl.flicker
 import com.android.server.wm.flicker.helpers.ImeAppHelper
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -38,49 +43,51 @@
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 open class CloseImeWindowToAppTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : NonRotationTestBase(beginRotationName, beginRotation) {
-    init {
-        testApp = ImeAppHelper(instrumentation)
-    }
-
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.editTextLoseFocusToApp(testApp as ImeAppHelper,
-                instrumentation, uiDevice, beginRotation)
-                .includeJankyRuns().build()
-
-    @FlakyTest
-    @Test
-    open fun checkVisibility_imeLayerBecomesInvisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(IME_WINDOW_TITLE)
-                    .then()
-                    .hidesLayer(IME_WINDOW_TITLE)
-                    .forAllEntries()
-        }
-    }
+    rotationName: String,
+    rotation: Int
+) : NonRotationTestBase(rotationName, rotation) {
+    open val testApp = ImeAppHelper(instrumentation)
 
     @Test
-    open fun checkVisibility_imeAppLayerIsAlwaysVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(testApp.getPackage())
-                    .forAllEntries()
+    open fun test() {
+        flicker(instrumentation) {
+            withTag { buildTestTag("imeToApp", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    this.setRotation(rotation)
+                    testApp.open()
+                    testApp.openIME(device)
+                }
+            }
+            teardown {
+                eachRun {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+            transitions {
+                device.pressBack()
+                device.waitForIdle()
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                    imeAppWindowIsAlwaysVisible(testApp)
+                }
+
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
+                    imeLayerBecomesInvisible(enabled = false)
+                    imeAppLayerIsAlwaysVisible(testApp)
+                }
+            }
         }
     }
-
-    @Test
-    open fun checkVisibility_imeAppWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAppWindowOnTop(testApp.getPackage())
-                    .forAllEntries()
-        }
-    }
-
-    companion object {
-        const val IME_WINDOW_TITLE = "InputMethod"
-    }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToHomeTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToHomeTest.kt
index ca04bab..b643ec2 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToHomeTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToHomeTest.kt
@@ -16,20 +16,26 @@
 
 package com.android.server.wm.flicker.ime
 
-import androidx.test.filters.FlakyTest
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.LayersTraceSubject
 import com.android.server.wm.flicker.NonRotationTestBase
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WmTraceSubject
+import com.android.server.wm.flicker.dsl.flicker
 import com.android.server.wm.flicker.helpers.ImeAppHelper
+import com.android.server.wm.flicker.helpers.openQuickstep
+import com.android.server.wm.flicker.helpers.reopenAppFromOverview
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.MethodSorters
 import org.junit.runners.Parameterized
-
 /**
  * Test IME window closing to home transitions.
  * To run this test: `atest FlickerTests:CloseImeWindowToHomeTest`
@@ -38,67 +44,60 @@
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 open class CloseImeWindowToHomeTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : NonRotationTestBase(beginRotationName, beginRotation) {
-    init {
-        testApp = ImeAppHelper(instrumentation)
-    }
-
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.editTextLoseFocusToHome(testApp as ImeAppHelper,
-                instrumentation, uiDevice, beginRotation)
-                .includeJankyRuns().build()
+    rotationName: String,
+    rotation: Int
+) : NonRotationTestBase(rotationName, rotation) {
+    open val testApp = ImeAppHelper(instrumentation)
 
     @Test
-    open fun checkVisibility_imeWindowBecomesInvisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsNonAppWindow(IME_WINDOW_TITLE)
-                    .then()
-                    .hidesNonAppWindow(IME_WINDOW_TITLE)
-                    .forAllEntries()
+    open fun test() {
+        flicker(instrumentation) {
+            withTag { buildTestTag("imeToHome", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                test {
+                    device.wakeUpAndGoToHomeScreen()
+                    this.setRotation(rotation)
+                    testApp.open()
+                }
+                eachRun {
+                    device.openQuickstep()
+                    device.reopenAppFromOverview()
+                    this.setRotation(rotation)
+                    testApp.openIME(device)
+                }
+            }
+            transitions {
+                device.pressHome()
+                device.waitForIdle()
+            }
+            teardown {
+                eachRun {
+                    device.pressHome()
+                }
+                test {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                    imeWindowBecomesInvisible()
+                    imeAppWindowBecomesInvisible(testApp)
+                }
+
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation, Surface.ROTATION_0)
+                    statusBarLayerRotatesScales(rotation, Surface.ROTATION_0)
+                    imeLayerBecomesInvisible(bugId = 153739621)
+                    imeAppLayerBecomesInvisible(testApp, bugId = 153739621)
+                }
+            }
         }
     }
-
-    @FlakyTest(bugId = 153739621)
-    @Test
-    open fun checkVisibility_imeLayerBecomesInvisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .skipUntilFirstAssertion()
-                    .showsLayer(IME_WINDOW_TITLE)
-                    .then()
-                    .hidesLayer(IME_WINDOW_TITLE)
-                    .forAllEntries()
-        }
-    }
-
-    @FlakyTest(bugId = 153739621)
-    @Test
-    fun checkVisibility_imeAppLayerBecomesInvisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .skipUntilFirstAssertion()
-                    .showsLayer(testApp.getPackage())
-                    .then()
-                    .hidesLayer(testApp.getPackage())
-                    .forAllEntries()
-        }
-    }
-
-    @Test
-    open fun checkVisibility_imeAppWindowBecomesInvisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAppWindowOnTop(testApp.getPackage())
-                    .then()
-                    .appWindowNotOnTop(testApp.getPackage())
-                    .forAllEntries()
-        }
-    }
-
-    companion object {
-        const val IME_WINDOW_TITLE: String = "InputMethod"
-    }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/ImeAssertions.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/ImeAssertions.kt
new file mode 100644
index 0000000..b2be54f
--- /dev/null
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/ImeAssertions.kt
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2020 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 com.android.server.wm.flicker.ime
+
+import android.platform.helpers.IAppHelper
+import com.android.server.wm.flicker.dsl.LayersAssertion
+import com.android.server.wm.flicker.dsl.WmAssertion
+
+const val IME_WINDOW_TITLE = "InputMethod"
+
+@JvmOverloads
+fun LayersAssertion.imeLayerBecomesVisible(
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("imeLayerBecomesVisible", enabled, bugId) {
+        this.hidesLayer(IME_WINDOW_TITLE)
+                .then()
+                .showsLayer(IME_WINDOW_TITLE)
+    }
+}
+
+fun LayersAssertion.imeLayerBecomesInvisible(
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("imeLayerBecomesInvisible", enabled, bugId) {
+        this.showsLayer(IME_WINDOW_TITLE)
+                .then()
+                .hidesLayer(IME_WINDOW_TITLE)
+    }
+}
+
+fun LayersAssertion.imeAppLayerIsAlwaysVisible(
+    testApp: IAppHelper,
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("imeAppLayerIsAlwaysVisible", enabled, bugId) {
+        this.showsLayer(testApp.getPackage())
+    }
+}
+
+fun WmAssertion.imeAppWindowIsAlwaysVisible(
+    testApp: IAppHelper,
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("imeAppWindowIsAlwaysVisible", enabled, bugId) {
+        this.showsAppWindowOnTop(testApp.getPackage())
+    }
+}
+
+fun WmAssertion.imeWindowBecomesInvisible(
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("imeWindowBecomesInvisible", enabled, bugId) {
+        this.showsNonAppWindow(IME_WINDOW_TITLE)
+                .then()
+                .hidesNonAppWindow(IME_WINDOW_TITLE)
+    }
+}
+
+fun WmAssertion.imeAppWindowBecomesInvisible(
+    testApp: IAppHelper,
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("imeAppWindowBecomesInvisible", enabled, bugId) {
+        this.showsAppWindowOnTop(testApp.getPackage())
+                .then()
+                .appWindowNotOnTop(testApp.getPackage())
+    }
+}
+
+fun LayersAssertion.imeAppLayerBecomesInvisible(
+    testApp: IAppHelper,
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("imeAppLayerBecomesInvisible", enabled, bugId) {
+        this.skipUntilFirstAssertion()
+                .showsLayer(testApp.getPackage())
+                .then()
+                .hidesLayer(testApp.getPackage())
+    }
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/OpenImeWindowTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/OpenImeWindowTest.kt
index c7731f3..5874a07 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/OpenImeWindowTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/OpenImeWindowTest.kt
@@ -16,13 +16,19 @@
 
 package com.android.server.wm.flicker.ime
 
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.LayersTraceSubject
 import com.android.server.wm.flicker.NonRotationTestBase
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WmTraceSubject
+import com.android.server.wm.flicker.dsl.flicker
 import com.android.server.wm.flicker.helpers.ImeAppHelper
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -37,38 +43,58 @@
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 class OpenImeWindowTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : NonRotationTestBase(beginRotationName, beginRotation) {
-    init {
-        testApp = ImeAppHelper(instrumentation)
-    }
-
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.editTextSetFocus(testApp as ImeAppHelper,
-                instrumentation, uiDevice, beginRotation)
-                .includeJankyRuns().build()
-
+    rotationName: String,
+    rotation: Int
+) : NonRotationTestBase(rotationName, rotation) {
     @Test
-    fun checkVisibility_imeWindowBecomesVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .skipUntilFirstAssertion()
-                    .hidesNonAppWindow(IME_WINDOW_TITLE)
-                    .then()
-                    .showsNonAppWindow(IME_WINDOW_TITLE)
-                    .forAllEntries()
-        }
-    }
+    fun test() {
+        val testApp = ImeAppHelper(instrumentation)
 
-    @Test
-    fun checkVisibility_imeLayerBecomesVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .hidesLayer(IME_WINDOW_TITLE)
-                    .then()
-                    .showsLayer(IME_WINDOW_TITLE)
-                    .forAllEntries()
+        flicker(instrumentation) {
+            withTag { buildTestTag("openIme", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                test {
+                    device.wakeUpAndGoToHomeScreen()
+                    this.setRotation(rotation)
+                    testApp.open()
+                }
+            }
+            transitions {
+                testApp.openIME(device)
+            }
+            teardown {
+                eachRun {
+                    testApp.closeIME(device)
+                }
+                test {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+
+                    all("imeWindowBecomesVisible") {
+                        this.skipUntilFirstAssertion()
+                            .hidesNonAppWindow(IME_WINDOW_TITLE)
+                            .then()
+                            .showsNonAppWindow(IME_WINDOW_TITLE)
+                    }
+                }
+
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
+
+                    imeLayerBecomesVisible()
+                }
+            }
         }
     }
 
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppColdTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppColdTest.kt
index 88b8854..1240e0d 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppColdTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppColdTest.kt
@@ -16,14 +16,17 @@
 
 package com.android.server.wm.flicker.launch
 
-import androidx.test.filters.FlakyTest
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.LayersTraceSubject
-import com.android.server.wm.flicker.NonRotationTestBase
-import com.android.server.wm.flicker.StandardAppHelper
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WmTraceSubject
+import com.android.server.wm.flicker.dsl.flicker
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -38,50 +41,49 @@
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 class OpenAppColdTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : NonRotationTestBase(beginRotationName, beginRotation) {
-    init {
-        testApp = StandardAppHelper(instrumentation,
-                "com.android.server.wm.flicker.testapp", "SimpleApp")
-    }
-
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.openAppCold(testApp, instrumentation, uiDevice, beginRotation)
-                .includeJankyRuns().build()
-
+    rotationName: String,
+    rotation: Int
+) : OpenAppTestBase(rotationName, rotation) {
     @Test
-    fun checkVisibility_wallpaperWindowBecomesInvisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsBelowAppWindow("Wallpaper")
-                    .then()
-                    .hidesBelowAppWindow("Wallpaper")
-                    .forAllEntries()
-        }
-    }
+    fun test() {
+        flicker(instrumentation) {
+            withTag { buildTestTag("openAppCold", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                test {
+                    device.wakeUpAndGoToHomeScreen()
+                }
+                eachRun {
+                    this.setRotation(rotation)
+                }
+            }
+            transitions {
+                testApp.open()
+            }
+            teardown {
+                eachRun {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                    appWindowReplacesLauncherAsTopWindow(bugId = 141361128)
+                    wallpaperWindowBecomesInvisible()
+                }
 
-    @FlakyTest(bugId = 140855415)
-    @Test
-    fun checkZOrder_appWindowReplacesLauncherAsTopWindow() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAppWindowOnTop(
-                            "com.android.launcher3/.Launcher")
-                    .then()
-                    .showsAppWindowOnTop(testApp.getPackage())
-                    .forAllEntries()
-        }
-    }
-
-    @Test
-    fun checkVisibility_wallpaperLayerBecomesInvisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer("Wallpaper")
-                    .then()
-                    .replaceVisibleLayer("Wallpaper", testApp.getPackage())
-                    .forAllEntries()
+                layersTrace {
+                    noUncoveredRegions(rotation, bugId = 141361128)
+                    // During testing the launcher is always in portrait mode
+                    navBarLayerRotatesAndScales(Surface.ROTATION_0, rotation)
+                    statusBarLayerRotatesScales(Surface.ROTATION_0, rotation)
+                    navBarLayerIsAlwaysVisible(bugId = 141361128)
+                    statusBarLayerIsAlwaysVisible(bugId = 141361128)
+                    wallpaperLayerBecomesInvisible(bugId = 141361128)
+                }
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppTestBase.kt
new file mode 100644
index 0000000..3cec077
--- /dev/null
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppTestBase.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2020 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 com.android.server.wm.flicker.launch
+
+import com.android.server.wm.flicker.NonRotationTestBase
+import com.android.server.wm.flicker.StandardAppHelper
+import com.android.server.wm.flicker.dsl.LayersAssertion
+import com.android.server.wm.flicker.dsl.WmAssertion
+
+abstract class OpenAppTestBase(
+    rotationName: String,
+    rotation: Int
+) : NonRotationTestBase(rotationName, rotation) {
+    protected val testApp = StandardAppHelper(instrumentation,
+            "com.android.server.wm.flicker.testapp", "SimpleApp")
+
+    protected fun WmAssertion.wallpaperWindowBecomesInvisible(
+        bugId: Int = 0,
+        enabled: Boolean = bugId == 0
+    ) {
+        all("wallpaperWindowBecomesInvisible", enabled, bugId) {
+            this.showsBelowAppWindow("Wallpaper")
+                    .then()
+                    .hidesBelowAppWindow("Wallpaper")
+        }
+    }
+
+    protected fun WmAssertion.appWindowReplacesLauncherAsTopWindow(
+        bugId: Int = 0,
+        enabled: Boolean = bugId == 0
+    ) {
+        all("appWindowReplacesLauncherAsTopWindow", enabled, bugId) {
+            this.showsAppWindowOnTop(
+                    "Launcher")
+                    .then()
+                    .showsAppWindowOnTop(testApp.getPackage())
+        }
+    }
+
+    protected fun LayersAssertion.wallpaperLayerBecomesInvisible(
+        bugId: Int = 0,
+        enabled: Boolean = bugId == 0
+    ) {
+        all("appWindowReplacesLauncherAsTopWindow", enabled, bugId) {
+            this.showsLayer("Wallpaper")
+                    .then()
+                    .replaceVisibleLayer("Wallpaper", testApp.getPackage())
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppWarmTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppWarmTest.kt
index f0bc3f0..98413a1 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppWarmTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppWarmTest.kt
@@ -16,14 +16,18 @@
 
 package com.android.server.wm.flicker.launch
 
-import androidx.test.filters.FlakyTest
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.LayersTraceSubject
-import com.android.server.wm.flicker.NonRotationTestBase
 import com.android.server.wm.flicker.StandardAppHelper
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WmTraceSubject
+import com.android.server.wm.flicker.dsl.flicker
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -38,50 +42,56 @@
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 class OpenAppWarmTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : NonRotationTestBase(beginRotationName, beginRotation) {
-    init {
-        testApp = StandardAppHelper(instrumentation,
+    rotationName: String,
+    rotation: Int
+) : OpenAppTestBase(rotationName, rotation) {
+    @Test
+    fun test() {
+        val testApp = StandardAppHelper(instrumentation,
                 "com.android.server.wm.flicker.testapp", "SimpleApp")
-    }
 
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.openAppWarm(testApp, instrumentation, uiDevice, beginRotation)
-                .includeJankyRuns().build()
+        flicker(instrumentation) {
+            withTag { buildTestTag("openAppWarm", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                test {
+                    device.wakeUpAndGoToHomeScreen()
+                    testApp.open()
+                }
+                eachRun {
+                    device.pressHome()
+                    this.setRotation(rotation)
+                }
+            }
+            transitions {
+                testApp.open()
+            }
+            teardown {
+                eachRun {
+                    this.setRotation(Surface.ROTATION_0)
+                }
+                test {
+                    testApp.exit()
+                }
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                    appWindowReplacesLauncherAsTopWindow(bugId = 141361128)
+                    wallpaperWindowBecomesInvisible(enabled = false)
+                }
 
-    @Test
-    fun checkVisibility_wallpaperBecomesInvisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsBelowAppWindow("Wallpaper")
-                    .then()
-                    .hidesBelowAppWindow("Wallpaper")
-                    .forAllEntries()
+                layersTrace {
+                    noUncoveredRegions(rotation, bugId = 141361128)
+                    // During testing the launcher is always in portrait mode
+                    navBarLayerRotatesAndScales(Surface.ROTATION_0, rotation)
+                    statusBarLayerRotatesScales(Surface.ROTATION_0, rotation)
+                    navBarLayerIsAlwaysVisible(bugId = 141361128)
+                    statusBarLayerIsAlwaysVisible(bugId = 141361128)
+                    wallpaperLayerBecomesInvisible(bugId = 141361128)
+                }
+            }
         }
     }
-
-    @FlakyTest(bugId = 140855415)
-    @Test
-    fun checkZOrder_appWindowReplacesLauncherAsTopWindow() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAppWindowOnTop(
-                            "com.android.launcher3/.Launcher")
-                    .then()
-                    .showsAppWindowOnTop(testApp.getPackage())
-                    .forAllEntries()
-        }
-    }
-
-    @Test
-    fun checkVisibility_wallpaperLayerBecomesInvisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer("Wallpaper")
-                    .then()
-                    .replaceVisibleLayer("Wallpaper", testApp.getPackage())
-                    .forAllEntries()
-        }
-    }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipTestBase.kt
index 79321f9..4afabd4 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipTestBase.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipTestBase.kt
@@ -16,66 +16,36 @@
 
 package com.android.server.wm.flicker.pip
 
-import androidx.test.InstrumentationRegistry
-import androidx.test.filters.LargeTest
-import androidx.test.uiautomator.UiDevice
-import com.android.server.wm.flicker.LayersTraceSubject
+import com.android.server.wm.flicker.dsl.LayersAssertion
 import com.android.server.wm.flicker.NonRotationTestBase
-import com.android.server.wm.flicker.WmTraceSubject
-import com.android.server.wm.flicker.helpers.AutomationUtils
+import com.android.server.wm.flicker.dsl.WmAssertion
 import com.android.server.wm.flicker.helpers.PipAppHelper
-import org.junit.AfterClass
-import org.junit.FixMethodOrder
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-import org.junit.runners.Parameterized
 
-@LargeTest
-@RunWith(Parameterized::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
 abstract class PipTestBase(
-    beginRotationName: String,
-    beginRotation: Int
-) : NonRotationTestBase(beginRotationName, beginRotation) {
-    init {
-        testApp = PipAppHelper(instrumentation)
-    }
+    rotationName: String,
+    rotation: Int
+) : NonRotationTestBase(rotationName, rotation) {
+    protected val testApp = PipAppHelper(instrumentation)
 
-    @Test
-    fun checkVisibility_pipWindowBecomesVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .skipUntilFirstAssertion()
+    protected fun WmAssertion.pipWindowBecomesVisible() {
+        all("pipWindowBecomesVisible") {
+            this.skipUntilFirstAssertion()
                     .showsAppWindowOnTop(sPipWindowTitle)
                     .then()
                     .hidesAppWindow(sPipWindowTitle)
-                    .forAllEntries()
         }
     }
 
-    @Test
-    fun checkVisibility_pipLayerBecomesVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .skipUntilFirstAssertion()
+    protected fun LayersAssertion.pipLayerBecomesVisible() {
+        all("pipLayerBecomesVisible") {
+            this.skipUntilFirstAssertion()
                     .showsLayer(sPipWindowTitle)
                     .then()
                     .hidesLayer(sPipWindowTitle)
-                    .forAllEntries()
         }
     }
 
     companion object {
         const val sPipWindowTitle = "PipMenuActivity"
-
-        @AfterClass
-        @JvmStatic
-        fun teardown() {
-            val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
-            if (AutomationUtils.hasPipWindow(device)) {
-                AutomationUtils.closePipWindow(device)
-            }
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToAppTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToAppTest.kt
index 89ffb7a..e5a73f7 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToAppTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToAppTest.kt
@@ -16,12 +16,21 @@
 
 package com.android.server.wm.flicker.pip
 
+import android.view.Surface
 import androidx.test.filters.FlakyTest
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WmTraceSubject
-import com.android.server.wm.flicker.helpers.PipAppHelper
+import com.android.server.wm.flicker.dsl.flicker
+import com.android.server.wm.flicker.helpers.closePipWindow
+import com.android.server.wm.flicker.helpers.expandPipWindow
+import com.android.server.wm.flicker.helpers.hasPipWindow
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -37,27 +46,55 @@
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 @FlakyTest(bugId = 152738416)
 class PipToAppTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : PipTestBase(beginRotationName, beginRotation) {
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.exitPipModeToApp(testApp as PipAppHelper, instrumentation,
-                uiDevice, beginRotation)
-                .includeJankyRuns().build()
-
+    rotationName: String,
+    rotation: Int
+) : PipTestBase(rotationName, rotation) {
     @Test
-    fun checkVisibility_backgroundWindowVisibleBehindPipLayer() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .skipUntilFirstAssertion()
-                    .showsAppWindowOnTop(sPipWindowTitle)
-                    .then()
-                    .showsBelowAppWindow("Wallpaper")
-                    .then()
-                    .showsAppWindowOnTop(testApp.getPackage())
-                    .then()
-                    .appWindowNotOnTop(testApp.getPackage())
-                    .forAllEntries()
+    fun test() {
+        flicker(instrumentation) {
+            withTag { buildTestTag("exitPipModeToApp", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                }
+            }
+            teardown {
+                eachRun {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+                test {
+                    if (device.hasPipWindow()) {
+                        device.closePipWindow()
+                    }
+                }
+            }
+            transitions {
+                device.pressHome()
+                this.setRotation(rotation)
+                testApp.open()
+                testApp.clickEnterPipButton(device)
+                device.expandPipWindow()
+                device.waitForIdle()
+                testApp.exit()
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                    pipWindowBecomesVisible()
+                }
+
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
+                    pipLayerBecomesVisible()
+                }
+            }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToHomeTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToHomeTest.kt
index 8591360..f6d9ce2 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToHomeTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToHomeTest.kt
@@ -16,12 +16,20 @@
 
 package com.android.server.wm.flicker.pip
 
+import android.view.Surface
 import androidx.test.filters.FlakyTest
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WmTraceSubject
-import com.android.server.wm.flicker.helpers.PipAppHelper
+import com.android.server.wm.flicker.dsl.flicker
+import com.android.server.wm.flicker.helpers.closePipWindow
+import com.android.server.wm.flicker.helpers.hasPipWindow
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -37,24 +45,63 @@
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 @FlakyTest(bugId = 152738416)
 class PipToHomeTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : PipTestBase(beginRotationName, beginRotation) {
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.exitPipModeToHome(testApp as PipAppHelper, instrumentation,
-                uiDevice, beginRotation)
-                .includeJankyRuns().build()
-
+    rotationName: String,
+    rotation: Int
+) : PipTestBase(rotationName, rotation) {
     @Test
-    fun checkVisibility_backgroundWindowVisibleBehindPipLayer() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAppWindowOnTop(sPipWindowTitle)
-                    .then()
-                    .showsBelowAppWindow("Wallpaper")
-                    .then()
-                    .showsAppWindowOnTop("Wallpaper")
-                    .forAllEntries()
+    fun test() {
+        flicker(instrumentation) {
+            withTag { buildTestTag("exitPipModeToApp", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    device.pressHome()
+                    this.setRotation(rotation)
+                    testApp.open()
+                }
+            }
+            teardown {
+                eachRun {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+                test {
+                    if (device.hasPipWindow()) {
+                        device.closePipWindow()
+                    }
+                }
+            }
+            transitions {
+                testApp.clickEnterPipButton(device)
+                testApp.closePipWindow(device)
+                device.waitForIdle()
+                testApp.exit()
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                    pipWindowBecomesVisible()
+
+                    all {
+                        this.showsAppWindowOnTop(sPipWindowTitle)
+                                .and()
+                                .showsBelowAppWindow("Wallpaper")
+                                .then()
+                                .showsAboveAppWindow("Wallpaper")
+                    }
+                }
+
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
+                    pipLayerBecomesVisible()
+                }
+            }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/ChangeAppRotationTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/ChangeAppRotationTest.kt
index fb1cb39..239c082 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/ChangeAppRotationTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/ChangeAppRotationTest.kt
@@ -16,15 +16,21 @@
 
 package com.android.server.wm.flicker.rotation
 
-import android.util.Log
-import androidx.test.filters.FlakyTest
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.LayersTraceSubject
+import com.android.server.wm.flicker.NonRotationTestBase.Companion.SCREENSHOT_LAYER
 import com.android.server.wm.flicker.RotationTestBase
 import com.android.server.wm.flicker.StandardAppHelper
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WindowUtils
+import com.android.server.wm.flicker.dsl.flicker
+import com.android.server.wm.flicker.helpers.WindowUtils
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -44,42 +50,76 @@
     beginRotation: Int,
     endRotation: Int
 ) : RotationTestBase(beginRotationName, endRotationName, beginRotation, endRotation) {
-    init {
-        testApp = StandardAppHelper(instrumentation,
+    @Test
+    fun test() {
+        val testApp = StandardAppHelper(instrumentation,
                 "com.android.server.wm.flicker.testapp", "SimpleApp")
-    }
 
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.changeAppRotation(testApp, instrumentation, uiDevice,
-                beginRotation, endRotation)
-                .includeJankyRuns().build()
+        flicker(instrumentation) {
+            withTag {
+                buildTestTag("changeAppRotation", testApp, beginRotation, endRotation)
+            }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    testApp.open()
+                    this.setRotation(beginRotation)
+                }
+            }
+            teardown {
+                eachRun {
+                    testApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+            transitions {
+                this.setRotation(endRotation)
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible(bugId = 140855415)
+                    statusBarWindowIsAlwaysVisible(bugId = 140855415)
+                }
 
-    @Test
-    fun checkPosition_appLayerRotates() {
-        val startingPos = WindowUtils.getAppPosition(beginRotation)
-        val endingPos = WindowUtils.getAppPosition(endRotation)
-        Log.e(TAG, "startingPos=$startingPos endingPos=$endingPos")
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .hasVisibleRegion(testApp.getPackage(), startingPos).inTheBeginning()
-            LayersTraceSubject.assertThat(it)
-                    .hasVisibleRegion(testApp.getPackage(), endingPos).atTheEnd()
+                layersTrace {
+                    navBarLayerIsAlwaysVisible(bugId = 140855415)
+                    statusBarLayerIsAlwaysVisible(bugId = 140855415)
+                    noUncoveredRegions(beginRotation, endRotation, allStates = false)
+                    navBarLayerRotatesAndScales(beginRotation, endRotation)
+                    statusBarLayerRotatesScales(beginRotation, endRotation)
+                }
+
+                layersTrace {
+                    val startingPos = WindowUtils.getDisplayBounds(beginRotation)
+                    val endingPos = WindowUtils.getDisplayBounds(endRotation)
+
+                    start("appLayerRotates_StartingPos") {
+                        this.hasVisibleRegion(testApp.getPackage(), startingPos)
+                    }
+
+                    end("appLayerRotates_EndingPos") {
+                        this.hasVisibleRegion(testApp.getPackage(), endingPos)
+                    }
+
+                    all("screenshotLayerBecomesInvisible", enabled = false) {
+                        this.showsLayer(testApp.getPackage())
+                                .then()
+                                .replaceVisibleLayer(
+                                        testApp.getPackage(),
+                                        SCREENSHOT_LAYER)
+                                .then()
+                                .showsLayer(testApp.getPackage())
+                                .and()
+                                .showsLayer(SCREENSHOT_LAYER)
+                                .then()
+                                .replaceVisibleLayer(
+                                        SCREENSHOT_LAYER,
+                                        testApp.getPackage()
+                                )
+                    }
+                }
+            }
         }
     }
-
-    @FlakyTest
-    @Test
-    fun checkVisibility_screenshotLayerBecomesInvisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(testApp.getPackage())
-                    .then()
-                    .replaceVisibleLayer(testApp.getPackage(), SCREENSHOT_LAYER)
-                    .then()
-                    .showsLayer(testApp.getPackage()).and().showsLayer(SCREENSHOT_LAYER)
-                    .then()
-                    .replaceVisibleLayer(SCREENSHOT_LAYER, testApp.getPackage())
-                    .forAllEntries()
-        }
-    }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/SeamlessAppRotationTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/SeamlessAppRotationTest.kt
index 1cd1998..4746376 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/SeamlessAppRotationTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/SeamlessAppRotationTest.kt
@@ -17,15 +17,24 @@
 package com.android.server.wm.flicker.rotation
 
 import android.content.Intent
+import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
 import android.view.Surface
-import androidx.test.InstrumentationRegistry
 import androidx.test.filters.FlakyTest
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.LayersTraceSubject
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.Until
 import com.android.server.wm.flicker.RotationTestBase
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WindowUtils
+import com.android.server.wm.flicker.helpers.WindowUtils
+import com.android.server.wm.flicker.dsl.flicker
+import com.android.server.wm.flicker.helpers.stopPackage
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import com.android.server.wm.flicker.testapp.ActivityOptions
 import org.junit.FixMethodOrder
 import org.junit.Test
@@ -42,67 +51,97 @@
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 @FlakyTest(bugId = 147659548)
 class SeamlessAppRotationTest(
+    testId: String,
     private val intent: Intent,
     beginRotationName: String,
     endRotationName: String,
     beginRotation: Int,
     endRotation: Int
 ) : RotationTestBase(beginRotationName, endRotationName, beginRotation, endRotation) {
-    override val transitionToRun: TransitionRunner
-        get() {
-            var intentId = ""
-            if (intent.extras?.getBoolean(ActivityOptions.EXTRA_STARVE_UI_THREAD) == true) {
-                intentId = "BUSY_UI_THREAD"
-            }
-            return CommonTransitions.changeAppRotation(intent, intentId,
-                    InstrumentationRegistry.getContext(), instrumentation, uiDevice,
-                    beginRotation, endRotation).build()
+    @Test
+    fun test() {
+        var intentId = ""
+        if (intent.extras?.getBoolean(ActivityOptions.EXTRA_STARVE_UI_THREAD) == true) {
+            intentId = "BUSY_UI_THREAD"
         }
 
-    @Test
-    fun checkPosition_appLayerRotates() {
-        val startingPos = WindowUtils.getAppPosition(beginRotation)
-        val endingPos = WindowUtils.getAppPosition(endRotation)
-        if (startingPos == endingPos) {
-            checkResults {
-                LayersTraceSubject.assertThat(it)
-                        .hasVisibleRegion(intent.component?.packageName ?: "", startingPos)
-                        .forAllEntries()
+        flicker(instrumentation) {
+            withTag {
+                "changeAppRotation_" + intentId + "_" +
+                        Surface.rotationToString(beginRotation) + "_" +
+                        Surface.rotationToString(endRotation)
             }
-        } else {
-            checkResults {
-                LayersTraceSubject.assertThat(it)
-                        .hasVisibleRegion(intent.component?.packageName ?: "", startingPos)
-                        .then()
-                        .hasVisibleRegion(intent.component?.packageName ?: "", endingPos)
-                        .forAllEntries()
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    instrumentation.targetContext.startActivity(intent)
+                    device.wait(Until.hasObject(By.pkg(intent.component?.packageName)
+                            .depth(0)), APP_LAUNCH_TIMEOUT)
+                    this.setRotation(beginRotation)
+                }
             }
-        }
-    }
+            teardown {
+                eachRun {
+                    stopPackage(
+                            instrumentation.targetContext,
+                            intent.component?.packageName
+                                    ?: error("Unable to determine package name for intent"))
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+            transitions {
+                this.setRotation(endRotation)
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible(bugId = 140855415)
+                    statusBarWindowIsAlwaysVisible(bugId = 140855415)
+                }
 
-    @Test
-    fun checkCoveredRegion_noUncoveredRegions() {
-        val startingBounds = WindowUtils.getDisplayBounds(beginRotation)
-        val endingBounds = WindowUtils.getDisplayBounds(endRotation)
-        if (startingBounds == endingBounds) {
-            checkResults {
-                LayersTraceSubject.assertThat(it)
-                        .coversRegion(startingBounds)
-                        .forAllEntries()
-            }
-        } else {
-            checkResults {
-                LayersTraceSubject.assertThat(it)
-                        .coversRegion(startingBounds)
-                        .then()
-                        .coversRegion(endingBounds)
-                        .forAllEntries()
+                layersTrace {
+                    navBarLayerIsAlwaysVisible(bugId = 140855415)
+                    statusBarLayerIsAlwaysVisible(bugId = 140855415)
+                    noUncoveredRegions(beginRotation, endRotation, allStates = true)
+                    navBarLayerRotatesAndScales(beginRotation, endRotation)
+                    statusBarLayerRotatesScales(beginRotation, endRotation, enabled = false)
+                }
+
+                layersTrace {
+                    all("appLayerRotates"/*, bugId = 147659548*/) {
+                        val startingPos = WindowUtils.getDisplayBounds(beginRotation)
+                        val endingPos = WindowUtils.getDisplayBounds(endRotation)
+
+                        if (startingPos == endingPos) {
+                            this.hasVisibleRegion(
+                                    intent.component?.packageName ?: "",
+                                    startingPos)
+                        } else {
+                            this.hasVisibleRegion(intent.component?.packageName ?: "", startingPos)
+                                    .then()
+                                    .hasVisibleRegion(intent.component?.packageName
+                                            ?: "", endingPos)
+                        }
+                    }
+
+                    all("noUncoveredRegions"/*, bugId = 147659548*/) {
+                        val startingBounds = WindowUtils.getDisplayBounds(beginRotation)
+                        val endingBounds = WindowUtils.getDisplayBounds(endRotation)
+                        if (startingBounds == endingBounds) {
+                            this.coversRegion(startingBounds)
+                        } else {
+                            this.coversRegion(startingBounds)
+                                    .then()
+                                    .coversRegion(endingBounds)
+                        }
+                    }
+                }
             }
         }
     }
 
     companion object {
-        // launch test activity that supports seamless rotation
+        private const val APP_LAUNCH_TIMEOUT: Long = 10000
 
         // launch test activity that supports seamless rotation with a busy UI thread to miss frames
         // when the app is asked to redraw
@@ -110,18 +149,20 @@
         @JvmStatic
         fun getParams(): Collection<Array<Any>> {
             val supportedRotations = intArrayOf(Surface.ROTATION_0, Surface.ROTATION_90)
-            val params: MutableCollection<Array<Any>> = ArrayList()
-            val testIntents = ArrayList<Intent>()
+            val params = mutableListOf<Array<Any>>()
+            val testIntents = mutableListOf<Intent>()
 
             // launch test activity that supports seamless rotation
             var intent = Intent(Intent.ACTION_MAIN)
             intent.component = ActivityOptions.SEAMLESS_ACTIVITY_COMPONENT_NAME
+            intent.flags = FLAG_ACTIVITY_NEW_TASK
             testIntents.add(intent)
 
             // launch test activity that supports seamless rotation with a busy UI thread to miss frames
             // when the app is asked to redraw
             intent = Intent(intent)
             intent.putExtra(ActivityOptions.EXTRA_STARVE_UI_THREAD, true)
+            intent.flags = FLAG_ACTIVITY_NEW_TASK
             testIntents.add(intent)
             for (testIntent in testIntents) {
                 for (begin in supportedRotations) {
@@ -133,7 +174,13 @@
                                             ActivityOptions.EXTRA_STARVE_UI_THREAD) == true) {
                                 testId += "_" + "BUSY_UI_THREAD"
                             }
-                            params.add(arrayOf(testId, testIntent, begin, end))
+                            params.add(arrayOf(
+                                    testId,
+                                    testIntent,
+                                    Surface.rotationToString(begin),
+                                    Surface.rotationToString(end),
+                                    begin,
+                                    end))
                         }
                     }
                 }
@@ -141,4 +188,4 @@
             return params
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/OpenAppToSplitScreenTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/OpenAppToSplitScreenTest.kt
index b5611a4..7c19696 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/OpenAppToSplitScreenTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/OpenAppToSplitScreenTest.kt
@@ -16,13 +16,22 @@
 
 package com.android.server.wm.flicker.splitscreen
 
+import android.os.SystemClock
+import android.view.Surface
 import androidx.test.filters.LargeTest
-import com.android.server.wm.flicker.CommonTransitions
-import com.android.server.wm.flicker.LayersTraceSubject
 import com.android.server.wm.flicker.NonRotationTestBase
 import com.android.server.wm.flicker.StandardAppHelper
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WmTraceSubject
+import com.android.server.wm.flicker.dsl.flicker
+import com.android.server.wm.flicker.helpers.exitSplitScreen
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -37,42 +46,63 @@
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 class OpenAppToSplitScreenTest(
-    beginRotationName: String,
-    beginRotation: Int
-) : NonRotationTestBase(beginRotationName, beginRotation) {
-    init {
-        testApp = StandardAppHelper(instrumentation,
-                "com.android.server.wm.flicker.testapp", "SimpleApp")
-    }
-
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.appToSplitScreen(testApp, instrumentation, uiDevice,
-                beginRotation).includeJankyRuns().build()
-
+    rotationName: String,
+    rotation: Int
+) : NonRotationTestBase(rotationName, rotation) {
     @Test
-    fun checkVisibility_navBarWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAboveAppWindow(NAVIGATION_BAR_WINDOW_TITLE).forAllEntries()
+    fun test() {
+        val testApp = StandardAppHelper(instrumentation,
+        "com.android.server.wm.flicker.testapp", "SimpleApp")
+
+        flicker(instrumentation) {
+            withTag { buildTestTag("appToSplitScreen", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    this.setRotation(rotation)
+                    testApp.open()
+                    SystemClock.sleep(500)
+                }
+            }
+            teardown {
+                eachRun {
+                    device.exitSplitScreen()
+                    testApp.exit()
+                }
+            }
+            transitions {
+                device.launchSplitScreen()
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                }
+
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
+
+                    all("dividerLayerBecomesVisible") {
+                        this.hidesLayer(DOCKED_STACK_DIVIDER)
+                                .then()
+                                .showsLayer(DOCKED_STACK_DIVIDER)
+                    }
+                }
+            }
         }
     }
 
-    @Test
-    fun checkVisibility_statusBarWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAboveAppWindow(STATUS_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
-    @Test
-    fun checkVisibility_dividerLayerBecomesVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .hidesLayer(DOCKED_STACK_DIVIDER)
-                    .then()
-                    .showsLayer(DOCKED_STACK_DIVIDER)
-                    .forAllEntries()
+    companion object {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val supportedRotations = intArrayOf(Surface.ROTATION_0)
+            return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) }
         }
     }
 }
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/ResizeSplitScreenTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/ResizeSplitScreenTest.kt
index 6b597e5..1a885bc 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/ResizeSplitScreenTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/ResizeSplitScreenTest.kt
@@ -19,24 +19,28 @@
 import android.graphics.Region
 import android.util.Rational
 import android.view.Surface
-import androidx.test.InstrumentationRegistry
 import androidx.test.filters.FlakyTest
 import androidx.test.filters.LargeTest
-import androidx.test.runner.AndroidJUnit4
-import androidx.test.uiautomator.UiDevice
-import com.android.server.wm.flicker.CommonTransitions
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.uiautomator.By
 import com.android.server.wm.flicker.FlickerTestBase
-import com.android.server.wm.flicker.LayersTrace
-import com.android.server.wm.flicker.LayersTraceSubject
 import com.android.server.wm.flicker.StandardAppHelper
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.TransitionResult
-import com.android.server.wm.flicker.WindowUtils
-import com.android.server.wm.flicker.WmTraceSubject
-import com.android.server.wm.flicker.helpers.AutomationUtils
+import com.android.server.wm.flicker.helpers.WindowUtils
+import com.android.server.wm.flicker.dsl.flicker
 import com.android.server.wm.flicker.helpers.ImeAppHelper
-import com.google.common.truth.Truth
-import org.junit.AfterClass
+import com.android.server.wm.flicker.helpers.clearRecents
+import com.android.server.wm.flicker.helpers.exitSplitScreen
+import com.android.server.wm.flicker.helpers.isInSplitScreen
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.helpers.resizeSplitScreen
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -53,146 +57,130 @@
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 @FlakyTest(bugId = 159096424)
 class ResizeSplitScreenTest : FlickerTestBase() {
-    init {
-        testApp = StandardAppHelper(instrumentation,
+    @Test
+    fun test() {
+        val testAppTop = StandardAppHelper(instrumentation,
                 "com.android.server.wm.flicker.testapp", "SimpleApp")
-    }
+        val testAppBottom = ImeAppHelper(instrumentation)
 
-    override val transitionToRun: TransitionRunner
-        get() {
-            val bottomApp = ImeAppHelper(instrumentation)
-            return CommonTransitions.resizeSplitScreen(testApp, bottomApp, instrumentation,
-                    uiDevice, Surface.ROTATION_0,
-                    Rational(1, 3), Rational(2, 3))
-                    .includeJankyRuns().build()
-        }
+        flicker(instrumentation) {
+            withTag {
+                val description = (startRatio.toString().replace("/", "-") + "_to_" +
+                        stopRatio.toString().replace("/", "-"))
+                buildTestTag("resizeSplitScreen", testAppTop, rotation,
+                        rotation, testAppBottom, description)
+            }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    this.setRotation(rotation)
+                    clearRecents(instrumentation)
+                    testAppBottom.open()
+                    device.pressHome()
+                    testAppTop.open()
+                    device.waitForIdle()
+                    device.launchSplitScreen()
+                    val snapshot = device.findObject(By.res(device.launcherPackageName, "snapshot"))
+                    snapshot.click()
+                    testAppBottom.openIME(device)
+                    device.pressBack()
+                    device.resizeSplitScreen(startRatio)
+                }
+            }
+            teardown {
+                eachRun {
+                    device.exitSplitScreen()
+                    device.pressHome()
+                    testAppTop.exit()
+                    testAppBottom.exit()
+                }
+                test {
+                    if (device.isInSplitScreen()) {
+                        device.exitSplitScreen()
+                    }
+                }
+            }
+            transitions {
+                device.resizeSplitScreen(stopRatio)
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
 
-    @Test
-    fun checkVisibility_topAppLayerIsAlwaysVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(sSimpleActivity)
-                    .forAllEntries()
-        }
-    }
+                    all("topAppWindowIsAlwaysVisible", bugId = 156223549) {
+                        this.showsAppWindow(sSimpleActivity)
+                    }
 
-    @Test
-    fun checkVisibility_bottomAppLayerIsAlwaysVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(sImeActivity)
-                    .forAllEntries()
-        }
-    }
+                    all("bottomAppWindowIsAlwaysVisible", bugId = 156223549) {
+                        this.showsAppWindow(sImeActivity)
+                    }
+                }
 
-    @Test
-    fun checkVisibility_dividerLayerIsAlwaysVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(DOCKED_STACK_DIVIDER)
-                    .forAllEntries()
-        }
-    }
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
 
-    @Test
-    @FlakyTest
-    fun checkPosition_appsStartingBounds() {
-        val displayBounds = WindowUtils.getDisplayBounds()
-        checkResults { result: TransitionResult ->
-            val entries = LayersTrace.parseFrom(result.layersTrace,
-                    result.layersTracePath, result.layersTraceChecksum)
-            Truth.assertThat(entries.entries).isNotEmpty()
-            val startingDividerBounds = entries.entries[0].getVisibleBounds(
-                    DOCKED_STACK_DIVIDER).bounds
-            val startingTopAppBounds = Region(0, 0, startingDividerBounds.right,
-                    startingDividerBounds.top + WindowUtils.getDockedStackDividerInset())
-            val startingBottomAppBounds = Region(0,
-                    startingDividerBounds.bottom - WindowUtils.getDockedStackDividerInset(),
-                    displayBounds.right,
-                    displayBounds.bottom - WindowUtils.getNavigationBarHeight())
-            LayersTraceSubject.assertThat(result)
-                    .hasVisibleRegion("SimpleActivity", startingTopAppBounds)
-                    .inTheBeginning()
-            LayersTraceSubject.assertThat(result)
-                    .hasVisibleRegion("ImeActivity", startingBottomAppBounds)
-                    .inTheBeginning()
-        }
-    }
+                    all("topAppLayerIsAlwaysVisible") {
+                        this.showsLayer(sSimpleActivity)
+                    }
 
-    @Test
-    @FlakyTest
-    fun checkPosition_appsEndingBounds() {
-        val displayBounds = WindowUtils.getDisplayBounds()
-        checkResults { result: TransitionResult ->
-            val entries = LayersTrace.parseFrom(result.layersTrace,
-                    result.layersTracePath, result.layersTraceChecksum)
-            Truth.assertThat(entries.entries).isNotEmpty()
-            val endingDividerBounds = entries.entries[entries.entries.size - 1].getVisibleBounds(
-                    DOCKED_STACK_DIVIDER).bounds
-            val startingTopAppBounds = Region(0, 0, endingDividerBounds.right,
-                    endingDividerBounds.top + WindowUtils.getDockedStackDividerInset())
-            val startingBottomAppBounds = Region(0,
-                    endingDividerBounds.bottom - WindowUtils.getDockedStackDividerInset(),
-                    displayBounds.right,
-                    displayBounds.bottom - WindowUtils.getNavigationBarHeight())
-            LayersTraceSubject.assertThat(result)
-                    .hasVisibleRegion(sSimpleActivity, startingTopAppBounds)
-                    .atTheEnd()
-            LayersTraceSubject.assertThat(result)
-                    .hasVisibleRegion(sImeActivity, startingBottomAppBounds)
-                    .atTheEnd()
-        }
-    }
+                    all("bottomAppLayerIsAlwaysVisible") {
+                        this.showsLayer(sImeActivity)
+                    }
 
-    @Test
-    fun checkVisibility_navBarWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAboveAppWindow(NAVIGATION_BAR_WINDOW_TITLE)
-                    .forAllEntries()
-        }
-    }
+                    all("dividerLayerIsAlwaysVisible") {
+                        this.showsLayer(DOCKED_STACK_DIVIDER)
+                    }
 
-    @Test
-    fun checkVisibility_statusBarWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAboveAppWindow(STATUS_BAR_WINDOW_TITLE)
-                    .forAllEntries()
-        }
-    }
+                    start("appsStartingBounds", enabled = false) {
+                        val displayBounds = WindowUtils.displayBounds
+                        val entry = this.trace.entries.firstOrNull()
+                                ?: throw IllegalStateException("Trace is empty")
+                        val dividerBounds = entry.getVisibleBounds(DOCKED_STACK_DIVIDER).bounds
 
-    @Test
-    @FlakyTest(bugId = 156223549)
-    fun checkVisibility_topAppWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAppWindow(sSimpleActivity)
-                    .forAllEntries()
-        }
-    }
+                        val topAppBounds = Region(0, 0, dividerBounds.right,
+                                dividerBounds.top + WindowUtils.dockedStackDividerInset)
+                        val bottomAppBounds = Region(0,
+                                dividerBounds.bottom - WindowUtils.dockedStackDividerInset,
+                                displayBounds.right,
+                                displayBounds.bottom - WindowUtils.navigationBarHeight)
+                        this.hasVisibleRegion("SimpleActivity", topAppBounds)
+                                .and()
+                                .hasVisibleRegion("ImeActivity", bottomAppBounds)
+                    }
 
-    @Test
-    @FlakyTest(bugId = 156223549)
-    fun checkVisibility_bottomAppWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAppWindow(sImeActivity)
-                    .forAllEntries()
+                    end("appsEndingBounds", enabled = false) {
+                        val displayBounds = WindowUtils.displayBounds
+                        val entry = this.trace.entries.lastOrNull()
+                                ?: throw IllegalStateException("Trace is empty")
+                        val dividerBounds = entry.getVisibleBounds(DOCKED_STACK_DIVIDER).bounds
+
+                        val topAppBounds = Region(0, 0, dividerBounds.right,
+                                dividerBounds.top + WindowUtils.dockedStackDividerInset)
+                        val bottomAppBounds = Region(0,
+                                dividerBounds.bottom - WindowUtils.dockedStackDividerInset,
+                                displayBounds.right,
+                                displayBounds.bottom - WindowUtils.navigationBarHeight)
+
+                        this.hasVisibleRegion(sSimpleActivity, topAppBounds)
+                                .and()
+                                .hasVisibleRegion(sImeActivity, bottomAppBounds)
+                    }
+                }
+            }
         }
     }
 
     companion object {
         private const val sSimpleActivity = "SimpleActivity"
         private const val sImeActivity = "ImeActivity"
-
-        @AfterClass
-        @JvmStatic
-        fun teardown() {
-            val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
-            if (AutomationUtils.isInSplitScreen(device)) {
-                AutomationUtils.exitSplitScreen(device)
-            }
-        }
+        private val rotation = Surface.ROTATION_0
+        private val startRatio = Rational(1, 3)
+        private val stopRatio = Rational(2, 3)
     }
 }
diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/SplitScreenToLauncherTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/SplitScreenToLauncherTest.kt
index fdcafdb..268ba9e 100644
--- a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/SplitScreenToLauncherTest.kt
+++ b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/SplitScreenToLauncherTest.kt
@@ -17,19 +17,22 @@
 package com.android.server.wm.flicker.splitscreen
 
 import android.view.Surface
-import androidx.test.InstrumentationRegistry
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.LargeTest
-import androidx.test.runner.AndroidJUnit4
-import androidx.test.uiautomator.UiDevice
-import com.android.server.wm.flicker.CommonTransitions
 import com.android.server.wm.flicker.FlickerTestBase
-import com.android.server.wm.flicker.LayersTraceSubject
 import com.android.server.wm.flicker.StandardAppHelper
-import com.android.server.wm.flicker.TransitionRunner
-import com.android.server.wm.flicker.WindowUtils
-import com.android.server.wm.flicker.WmTraceSubject
-import com.android.server.wm.flicker.helpers.AutomationUtils
-import org.junit.AfterClass
+import com.android.server.wm.flicker.dsl.flicker
+import com.android.server.wm.flicker.helpers.exitSplitScreen
+import com.android.server.wm.flicker.helpers.isInSplitScreen
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
 import org.junit.FixMethodOrder
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -43,68 +46,63 @@
 @RunWith(AndroidJUnit4::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 class SplitScreenToLauncherTest : FlickerTestBase() {
-    init {
-        testApp = StandardAppHelper(InstrumentationRegistry.getInstrumentation(),
+    private val rotation: Int = Surface.ROTATION_0
+    @Test
+    fun test() {
+        val testApp = StandardAppHelper(instrumentation,
                 "com.android.server.wm.flicker.testapp", "SimpleApp")
-    }
 
-    override val transitionToRun: TransitionRunner
-        get() = CommonTransitions.splitScreenToLauncher(testApp, instrumentation, uiDevice,
-                Surface.ROTATION_0).includeJankyRuns().build()
+        flicker(instrumentation) {
+            withTag { buildTestTag("splitScreenToLauncher", testApp, rotation) }
+            repeat { 1 }
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    testApp.open()
+                    this.setRotation(rotation)
+                    device.launchSplitScreen()
+                    device.waitForIdle()
+                }
+            }
+            teardown {
+                eachRun {
+                    testApp.exit()
+                }
+                test {
+                    if (device.isInSplitScreen()) {
+                        device.exitSplitScreen()
+                    }
+                }
+            }
+            transitions {
+                device.exitSplitScreen()
+            }
+            assertions {
+                windowManagerTrace {
+                    navBarWindowIsAlwaysVisible()
+                    statusBarWindowIsAlwaysVisible()
+                }
 
-    @Test
-    fun checkCoveredRegion_noUncoveredRegions() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .coversRegion(WindowUtils.getDisplayBounds()).forAllEntries()
-        }
-    }
+                layersTrace {
+                    navBarLayerIsAlwaysVisible()
+                    statusBarLayerIsAlwaysVisible()
+                    noUncoveredRegions(rotation)
+                    navBarLayerRotatesAndScales(rotation)
+                    statusBarLayerRotatesScales(rotation)
 
-    @Test
-    fun checkVisibility_dividerLayerBecomesInVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(DOCKED_STACK_DIVIDER)
-                    .then()
-                    .hidesLayer(DOCKED_STACK_DIVIDER)
-                    .forAllEntries()
-        }
-    }
+                    // b/161435597 causes the test not to work on 90 degrees
+                    all("dividerLayerBecomesInvisible") {
+                        this.showsLayer(DOCKED_STACK_DIVIDER)
+                                .then()
+                                .hidesLayer(DOCKED_STACK_DIVIDER)
+                    }
 
-    @Test
-    fun checkVisibility_appLayerBecomesInVisible() {
-        checkResults {
-            LayersTraceSubject.assertThat(it)
-                    .showsLayer(testApp.getPackage())
-                    .then()
-                    .hidesLayer(testApp.getPackage())
-                    .forAllEntries()
-        }
-    }
-
-    @Test
-    fun checkVisibility_navBarWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAboveAppWindow(NAVIGATION_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
-    @Test
-    fun checkVisibility_statusBarWindowIsAlwaysVisible() {
-        checkResults {
-            WmTraceSubject.assertThat(it)
-                    .showsAboveAppWindow(STATUS_BAR_WINDOW_TITLE).forAllEntries()
-        }
-    }
-
-    companion object {
-        @AfterClass
-        @JvmStatic
-        fun teardown() {
-            val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
-            if (AutomationUtils.isInSplitScreen(device)) {
-                AutomationUtils.exitSplitScreen(device)
+                    all("appLayerBecomesInvisible") {
+                        this.showsLayer(testApp.getPackage())
+                            .then()
+                            .hidesLayer(testApp.getPackage())
+                    }
+                }
             }
         }
     }