1/ Integrate legacySplitScreen Flicker tests into individual assertions

1) Integrate companion object inheritance and the default test runner
2) Move launch activity to setup: avoid noise of splash screen
3) Move setRotate() to setup: avoid noise of system windows
   (LetterBox, NavBar, StatusBar...) visibility changes
4) Reducing test time of each test case: remove redundant transition
5) Remve redundant val for readibility
6) Remove navBarLayerIsAlwaysVisible assertion from split test
   the rotation flow of enter split screen :
   Overview(land) -> enter split(portrait) -> split mode(land)
7) Partially enable ROTATION_90 tests
8) Bypass visibleLayersShownMoreThanOneConsecutiveEntry assertion
   for flaky reasons(Splash Screen, LetterBox, BackGestureSurface)

Test: atest WMShellFlickerTests
Bug: 176134495
Bug: 178685668
Bug: 178447631
Change-Id: I1d6153b987e5913a5d9a1fa5b72b9341b40db6fc

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/CommonAssertions.kt

@@ -18,10 +18,11 @@ package com.android.wm.shell.flicker
 
 import android.graphics.Region
 import android.view.Surface
+import com.android.server.wm.flicker.APP_PAIR_SPLIT_DIVIDER
+import com.android.server.wm.flicker.DOCKED_STACK_DIVIDER
 import com.android.server.wm.flicker.dsl.LayersAssertionBuilder
 import com.android.server.wm.flicker.helpers.WindowUtils
 import com.android.server.wm.flicker.traces.layers.getVisibleBounds
-import com.android.wm.shell.flicker.FlickerTestBase.Companion.DOCKED_STACK_DIVIDER
 
 @JvmOverloads
 fun LayersAssertionBuilder.appPairsDividerIsVisible(
@@ -29,7 +30,7 @@ fun LayersAssertionBuilder.appPairsDividerIsVisible(
     enabled: Boolean = bugId == 0
 ) {
     end("appPairsDividerIsVisible", bugId, enabled) {
-        this.isVisible(FlickerTestBase.APP_PAIR_SPLIT_DIVIDER)
+        this.isVisible(APP_PAIR_SPLIT_DIVIDER)
     }
 }
 
@@ -39,7 +40,7 @@ fun LayersAssertionBuilder.appPairsDividerIsInvisible(
     enabled: Boolean = bugId == 0
 ) {
     end("appPairsDividerIsInVisible", bugId, enabled) {
-        this.notExists(FlickerTestBase.APP_PAIR_SPLIT_DIVIDER)
+        this.notExists(APP_PAIR_SPLIT_DIVIDER)
     }
 }
 
@@ -107,7 +108,7 @@ fun LayersAssertionBuilder.appPairsPrimaryBoundsIsVisible(
     enabled: Boolean = bugId == 0
 ) {
     end("PrimaryAppBounds", bugId, enabled) {
-        val dividerRegion = entry.getVisibleBounds(FlickerTestBase.APP_PAIR_SPLIT_DIVIDER)
+        val dividerRegion = entry.getVisibleBounds(APP_PAIR_SPLIT_DIVIDER)
         this.hasVisibleRegion(primaryLayerName, getPrimaryRegion(dividerRegion, rotation))
     }
 }
@@ -120,7 +121,7 @@ fun LayersAssertionBuilder.appPairsSecondaryBoundsIsVisible(
     enabled: Boolean = bugId == 0
 ) {
     end("SecondaryAppBounds", bugId, enabled) {
-        val dividerRegion = entry.getVisibleBounds(FlickerTestBase.APP_PAIR_SPLIT_DIVIDER)
+        val dividerRegion = entry.getVisibleBounds(APP_PAIR_SPLIT_DIVIDER)
         this.hasVisibleRegion(secondaryLayerName, getSecondaryRegion(dividerRegion, rotation))
     }
 }

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/FlickerTestBase.kt

@@ -135,12 +135,4 @@ abstract class FlickerTestBase {
             throw RuntimeException(e)
         }
     }
-
-    companion object {
-        const val NAVIGATION_BAR_WINDOW_TITLE = "NavigationBar"
-        const val STATUS_BAR_WINDOW_TITLE = "StatusBar"
-        const val DOCKED_STACK_DIVIDER = "DockedStackDivider"
-        const val APP_PAIR_SPLIT_DIVIDER = "AppPairSplitDivider"
-        const val IMAGE_WALLPAPER = "ImageWallpaper"
-    }
 }

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/apppairs/AppPairsTestPairPrimaryAndSecondaryApps.kt

@@ -21,12 +21,12 @@ import android.os.SystemClock
 import android.platform.test.annotations.Presubmit
 import androidx.test.filters.RequiresDevice
 import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.APP_PAIR_SPLIT_DIVIDER
 import com.android.server.wm.flicker.FlickerTestRunner
 import com.android.server.wm.flicker.FlickerTestRunnerFactory
 import com.android.server.wm.flicker.dsl.FlickerBuilder
 import com.android.server.wm.flicker.helpers.buildTestTag
 import com.android.server.wm.flicker.traces.layers.getVisibleBounds
-import com.android.wm.shell.flicker.FlickerTestBase.Companion.APP_PAIR_SPLIT_DIVIDER
 import com.android.wm.shell.flicker.appPairsDividerIsVisible
 import com.android.wm.shell.flicker.helpers.AppPairsHelper
 import org.junit.FixMethodOrder

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/apppairs/AppPairsTestUnpairPrimaryAndSecondaryApps.kt

@@ -21,12 +21,12 @@ import android.os.SystemClock
 import android.platform.test.annotations.Presubmit
 import androidx.test.filters.RequiresDevice
 import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.APP_PAIR_SPLIT_DIVIDER
 import com.android.server.wm.flicker.FlickerTestRunner
 import com.android.server.wm.flicker.FlickerTestRunnerFactory
 import com.android.server.wm.flicker.dsl.FlickerBuilder
 import com.android.server.wm.flicker.helpers.buildTestTag
 import com.android.server.wm.flicker.traces.layers.getVisibleBounds
-import com.android.wm.shell.flicker.FlickerTestBase.Companion.APP_PAIR_SPLIT_DIVIDER
 import com.android.wm.shell.flicker.appPairsDividerIsInvisible
 import com.android.wm.shell.flicker.helpers.AppPairsHelper
 import org.junit.FixMethodOrder

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/EnterLegacySplitScreenTest.kt

@@ -1,208 +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.wm.shell.flicker.legacysplitscreen
-
-import android.platform.test.annotations.Presubmit
-import android.view.Surface
-import androidx.test.filters.FlakyTest
-import androidx.test.filters.RequiresDevice
-import com.android.server.wm.flicker.dsl.FlickerBuilder
-import com.android.server.wm.flicker.dsl.runWithFlicker
-import com.android.server.wm.flicker.helpers.canSplitScreen
-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.openQuickstep
-import com.android.server.wm.flicker.helpers.openQuickStepAndClearRecentAppsFromOverview
-import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
-import com.android.wm.shell.flicker.dockedStackDividerIsInvisible
-import com.android.wm.shell.flicker.helpers.SplitScreenHelper.Companion.TEST_REPETITIONS
-import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
-import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
-import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
-import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
-import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
-import com.android.wm.shell.flicker.dockedStackSecondaryBoundsIsVisible
-import org.junit.Assert
-import com.android.wm.shell.flicker.dockedStackDividerBecomesVisible
-import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
-import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
-import org.junit.FixMethodOrder
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-import org.junit.runners.Parameterized
-
-/**
- * Test SplitScreen launch.
- * To run this test: `atest WMShellFlickerTests:EnterLegacySplitScreenTest`
- */
-@Presubmit
-@RequiresDevice
-@RunWith(Parameterized::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class EnterLegacySplitScreenTest(
-    rotationName: String,
-    rotation: Int
-) : SplitScreenTestBase(rotationName, rotation) {
-    private val splitScreenSetup: FlickerBuilder
-        get() = FlickerBuilder(instrumentation).apply {
-            val testLaunchActivity = "launch_splitScreen_test_activity"
-            withTestName {
-                testLaunchActivity
-            }
-            setup {
-                eachRun {
-                    uiDevice.wakeUpAndGoToHomeScreen()
-                    uiDevice.openQuickStepAndClearRecentAppsFromOverview()
-                }
-            }
-            teardown {
-                eachRun {
-                    if (uiDevice.isInSplitScreen()) {
-                        uiDevice.exitSplitScreen()
-                    }
-                    splitScreenApp.exit()
-                    secondaryApp.exit()
-                    nonResizeableApp.exit()
-                }
-            }
-            assertions {
-                layersTrace {
-                    navBarLayerIsAlwaysVisible()
-                    statusBarLayerIsAlwaysVisible()
-                }
-                windowManagerTrace {
-                    navBarWindowIsAlwaysVisible()
-                    statusBarWindowIsAlwaysVisible()
-                }
-            }
-        }
-
-    @Test
-    fun testEnterSplitScreen_dockActivity() {
-        val testTag = "testEnterSplitScreen_dockActivity"
-        runWithFlicker(splitScreenSetup) {
-            withTestName { testTag }
-            repeat {
-                TEST_REPETITIONS
-            }
-            transitions {
-                splitScreenApp.launchViaIntent()
-                uiDevice.launchSplitScreen()
-            }
-            assertions {
-                layersTrace {
-                    dockedStackPrimaryBoundsIsVisible(
-                            rotation, splitScreenApp.defaultWindowName, 169271943)
-                    dockedStackDividerBecomesVisible()
-                    visibleLayersShownMoreThanOneConsecutiveEntry(
-                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
-                                    LIVE_WALLPAPER_PACKAGE_NAME)
-                    )
-                }
-                windowManagerTrace {
-                    end("appWindowIsVisible") {
-                        isVisible(splitScreenApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    @Test
-    fun testEnterSplitScreen_launchToSide() {
-        val testTag = "testEnterSplitScreen_launchToSide"
-        runWithFlicker(splitScreenSetup) {
-            withTestName { testTag }
-            repeat {
-                TEST_REPETITIONS
-            }
-            transitions {
-                secondaryApp.launchViaIntent()
-                splitScreenApp.launchViaIntent()
-                uiDevice.launchSplitScreen()
-                splitScreenApp.reopenAppFromOverview()
-            }
-            assertions {
-                layersTrace {
-                    dockedStackPrimaryBoundsIsVisible(
-                        rotation, splitScreenApp.defaultWindowName, 169271943)
-                    dockedStackSecondaryBoundsIsVisible(
-                        rotation, secondaryApp.defaultWindowName, 169271943)
-                    dockedStackDividerBecomesVisible()
-                    visibleLayersShownMoreThanOneConsecutiveEntry(
-                        listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
-                            secondaryApp.defaultWindowName)
-                    )
-                }
-                windowManagerTrace {
-                    end("appWindowIsVisible") {
-                        isVisible(splitScreenApp.defaultWindowName)
-                            .isVisible(secondaryApp.defaultWindowName)
-                    }
-                    visibleWindowsShownMoreThanOneConsecutiveEntry(
-                        listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
-                            secondaryApp.defaultWindowName))
-                }
-            }
-        }
-    }
-
-    @FlakyTest(bugId = 173875043)
-    @Test
-    fun testNonResizeableNotDocked() {
-        val testTag = "testNonResizeableNotDocked"
-        runWithFlicker(splitScreenSetup) {
-            withTestName { testTag }
-            repeat {
-                TEST_REPETITIONS
-            }
-            transitions {
-                nonResizeableApp.launchViaIntent()
-                uiDevice.openQuickstep()
-                if (uiDevice.canSplitScreen()) {
-                    Assert.fail("Non-resizeable app should not enter split screen")
-                }
-            }
-            assertions {
-                layersTrace {
-                    dockedStackDividerIsInvisible()
-                    visibleLayersShownMoreThanOneConsecutiveEntry(
-                        listOf(LAUNCHER_PACKAGE_NAME, nonResizeableApp.defaultWindowName)
-                    )
-                }
-                windowManagerTrace {
-                    end("appWindowIsVisible") {
-                        isInvisible(nonResizeableApp.defaultWindowName)
-                    }
-                    visibleWindowsShownMoreThanOneConsecutiveEntry(
-                        listOf(LAUNCHER_PACKAGE_NAME, nonResizeableApp.defaultWindowName))
-                }
-            }
-        }
-    }
-
-    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) }
-        }
-    }
-}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/EnterSplitScreenDockActivity.kt

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2021 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.WALLPAPER_TITLE
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.startRotation
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
+import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
+import com.android.wm.shell.flicker.dockedStackDividerBecomesVisible
+import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test open activity and dock to primary split screen
+ * To run this test: `atest WMShellFlickerTests:EnterSplitScreenDockActivity`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class EnterSplitScreenDockActivity(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testLegacySplitScreenDockActivity", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    device.launchSplitScreen()
+                }
+                assertions {
+                    layersTrace {
+                        dockedStackPrimaryBoundsIsVisible(
+                            configuration.startRotation,
+                            splitScreenApp.defaultWindowName, bugId = 169271943)
+                        dockedStackDividerBecomesVisible()
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME,
+                                WALLPAPER_TITLE, LIVE_WALLPAPER_PACKAGE_NAME,
+                                splitScreenApp.defaultWindowName),
+                            bugId = 178531736
+                        )
+                    }
+                    windowManagerTrace {
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                        visibleWindowsShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME,
+                                WALLPAPER_TITLE, LIVE_WALLPAPER_PACKAGE_NAME,
+                                splitScreenApp.defaultWindowName),
+                            bugId = 178531736
+                        )
+                        end("appWindowIsVisible") {
+                            isVisible(splitScreenApp.defaultWindowName)
+                        }
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, defaultTransitionSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS)
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/EnterSplitScreenLaunchToSide.kt

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2021 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.startRotation
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
+import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
+import com.android.wm.shell.flicker.dockedStackDividerBecomesVisible
+import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
+import com.android.wm.shell.flicker.dockedStackSecondaryBoundsIsVisible
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test open activity to primary split screen and dock secondary activity to side
+ * To run this test: `atest WMShellFlickerTests:EnterSplitScreenLaunchToSide`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class EnterSplitScreenLaunchToSide(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testLegacySplitScreenLaunchToSide", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    device.launchSplitScreen()
+                    secondaryApp.reopenAppFromOverview()
+                }
+                assertions {
+                    layersTrace {
+                        dockedStackPrimaryBoundsIsVisible(
+                            configuration.startRotation,
+                            splitScreenApp.defaultWindowName, bugId = 169271943)
+                        dockedStackSecondaryBoundsIsVisible(
+                            configuration.startRotation,
+                            secondaryApp.defaultWindowName, bugId = 169271943)
+                        dockedStackDividerBecomesVisible()
+                        // TODO(b/178447631) Remove Splash Screen from white list when flicker lib
+                        //                   add a wait for splash screen be gone
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME, SPLASH_SCREEN_NAME,
+                                splitScreenApp.defaultWindowName,
+                                secondaryApp.defaultWindowName),
+                            bugId = 178447631
+                        )
+                    }
+                    windowManagerTrace {
+                        appWindowBecomesVisible(secondaryApp.defaultWindowName)
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                        visibleWindowsShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME, SPLASH_SCREEN_NAME,
+                                splitScreenApp.defaultWindowName,
+                                secondaryApp.defaultWindowName)
+                        )
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, defaultTransitionSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS)
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/EnterSplitScreenNonResizableNotDock.kt

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2021 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import android.view.Surface
+import androidx.test.filters.FlakyTest
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.WALLPAPER_TITLE
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.canSplitScreen
+import com.android.server.wm.flicker.helpers.openQuickstep
+import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
+import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
+import com.android.wm.shell.flicker.dockedStackDividerIsInvisible
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.Assert
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test open non-resizable activity will auto exit split screen mode
+ * To run this test: `atest WMShellFlickerTests:EnterSplitScreenNonResizableNotDock`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@FlakyTest(bugId = 173875043)
+class EnterSplitScreenNonResizableNotDock(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testLegacySplitScreenNonResizeableActivityNotDock", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    nonResizeableApp.launchViaIntent(wmHelper)
+                    device.openQuickstep()
+                    if (device.canSplitScreen()) {
+                        Assert.fail("Non-resizeable app should not enter split screen")
+                    }
+                }
+                assertions {
+                    layersTrace {
+                        dockedStackDividerIsInvisible()
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME,
+                                SPLASH_SCREEN_NAME,
+                                nonResizeableApp.defaultWindowName,
+                                splitScreenApp.defaultWindowName),
+                            bugId = 178447631
+                        )
+                    }
+                    windowManagerTrace {
+                        visibleWindowsShownMoreThanOneConsecutiveEntry(
+                            listOf(WALLPAPER_TITLE,
+                                LAUNCHER_PACKAGE_NAME,
+                                SPLASH_SCREEN_NAME,
+                                nonResizeableApp.defaultWindowName,
+                                splitScreenApp.defaultWindowName)
+                        )
+                        end("appWindowIsVisible") {
+                            isInvisible(nonResizeableApp.defaultWindowName)
+                        }
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, defaultTransitionSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS,
+                supportedRotations = listOf(Surface.ROTATION_0 /* bugId = 178685668 */))
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/ExitLegacySplitScreenFromBottom.kt

@@ -0,0 +1,91 @@
+/*
+ * 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.DOCKED_STACK_DIVIDER
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesInVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.exitSplitScreenFromBottom
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.layerBecomesInvisible
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
+import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test open resizeable activity split in primary, and drag divider to bottom exit split screen
+ * To run this test: `atest WMShellFlickerTests:ExitLegacySplitScreenFromBottom`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class ExitLegacySplitScreenFromBottom(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testExitLegacySplitScreenFromBottom", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    device.launchSplitScreen()
+                    device.exitSplitScreenFromBottom()
+                }
+                assertions {
+                    layersTrace {
+                        layerBecomesInvisible(DOCKED_STACK_DIVIDER)
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
+                                secondaryApp.defaultWindowName),
+                            bugId = 178447631
+                        )
+                    }
+                    windowManagerTrace {
+                        appWindowBecomesInVisible(secondaryApp.defaultWindowName)
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                        visibleWindowsShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
+                                secondaryApp.defaultWindowName)
+                        )
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, defaultTransitionSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS)
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/ExitLegacySplitScreenFromBottomTest.kt

@@ -1,95 +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.wm.shell.flicker.legacysplitscreen
-
-import android.platform.test.annotations.Presubmit
-import android.view.Surface
-import androidx.test.filters.RequiresDevice
-import androidx.test.platform.app.InstrumentationRegistry
-import com.android.server.wm.flicker.FlickerTestRunner
-import com.android.server.wm.flicker.FlickerTestRunnerFactory
-import com.android.server.wm.flicker.endRotation
-import com.android.server.wm.flicker.helpers.buildTestTag
-import com.android.server.wm.flicker.helpers.exitSplitScreen
-import com.android.server.wm.flicker.helpers.exitSplitScreenFromBottom
-import com.android.server.wm.flicker.helpers.isInSplitScreen
-import com.android.server.wm.flicker.helpers.launchSplitScreen
-import com.android.server.wm.flicker.helpers.openQuickStepAndClearRecentAppsFromOverview
-import com.android.server.wm.flicker.helpers.setRotation
-import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
-import com.android.server.wm.flicker.repetitions
-import com.android.wm.shell.flicker.helpers.SplitScreenHelper
-import org.junit.FixMethodOrder
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-import org.junit.runners.Parameterized
-
-/**
- * Test open app to split screen.
- * To run this test: `atest WMShellFlickerTests:ExitLegacySplitScreenFromBottomTest`
- */
-@Presubmit
-@RequiresDevice
-@RunWith(Parameterized::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class ExitLegacySplitScreenFromBottomTest(
-    testSpec: FlickerTestRunnerFactory.TestSpec
-) : FlickerTestRunner(testSpec) {
-    companion object {
-        @Parameterized.Parameters(name = "{0}")
-        @JvmStatic
-        fun getParams(): Collection<Array<Any>> {
-            val instrumentation = InstrumentationRegistry.getInstrumentation()
-            val splitScreenApp = SplitScreenHelper.getPrimary(instrumentation)
-            // TODO(b/162923992) Use of multiple segments of flicker spec for testing
-            return FlickerTestRunnerFactory.getInstance().buildTest(instrumentation,
-                supportedRotations = listOf(Surface.ROTATION_0, Surface.ROTATION_90)) {
-                configuration ->
-                        withTestName {
-                            buildTestTag("exitSplitScreenFromBottom", configuration)
-                        }
-                        repeat { configuration.repetitions }
-                        setup {
-                            eachRun {
-                                device.wakeUpAndGoToHomeScreen()
-                                device.openQuickStepAndClearRecentAppsFromOverview()
-                                splitScreenApp.launchViaIntent(wmHelper)
-                                device.launchSplitScreen()
-                                device.waitForIdle()
-                                this.setRotation(configuration.endRotation)
-                            }
-                        }
-                        teardown {
-                            eachRun {
-                                if (device.isInSplitScreen()) {
-                                    device.exitSplitScreen()
-                                }
-                                splitScreenApp.exit()
-                            }
-                        }
-                        transitions {
-                            device.exitSplitScreenFromBottom()
-                        }
-                        assertions {
-                            windowManagerTrace {
-                                all("isNotEmpty") { isNotEmpty() }
-                            }
-                        }
-                    }
-        }
-    }
-}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/ExitLegacySplitScreenTest.kt

@@ -1,153 +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.wm.shell.flicker.legacysplitscreen
-
-import android.platform.test.annotations.Presubmit
-import android.util.Rational
-import android.view.Surface
-import androidx.test.filters.FlakyTest
-import androidx.test.filters.RequiresDevice
-import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
-import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
-import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
-import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
-import com.android.server.wm.flicker.layerBecomesInvisible
-import com.android.server.wm.flicker.dsl.FlickerBuilder
-import com.android.server.wm.flicker.dsl.runWithFlicker
-import com.android.server.wm.flicker.helpers.exitSplitScreen
-import com.android.server.wm.flicker.helpers.launchSplitScreen
-import com.android.server.wm.flicker.helpers.openQuickStepAndClearRecentAppsFromOverview
-import com.android.server.wm.flicker.helpers.resizeSplitScreen
-import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
-import com.android.wm.shell.flicker.dockedStackDividerIsInvisible
-import com.android.wm.shell.flicker.helpers.SplitScreenHelper.Companion.TEST_REPETITIONS
-import org.junit.FixMethodOrder
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-import org.junit.runners.Parameterized
-
-/**
- * Test exit SplitScreen mode.
- * To run this test: `atest WMShellFlickerTests:ExitLegacySplitScreenTest`
- */
-@Presubmit
-@RequiresDevice
-@RunWith(Parameterized::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class ExitLegacySplitScreenTest(
-    rotationName: String,
-    rotation: Int
-) : SplitScreenTestBase(rotationName, rotation) {
-    private val splitScreenSetup: FlickerBuilder
-        get() = FlickerBuilder(instrumentation).apply {
-            val testLaunchActivity = "launch_splitScreen_test_activity"
-            withTestName {
-                testLaunchActivity
-            }
-            setup {
-                eachRun {
-                    uiDevice.wakeUpAndGoToHomeScreen()
-                    uiDevice.openQuickStepAndClearRecentAppsFromOverview()
-                    secondaryApp.launchViaIntent()
-                    splitScreenApp.launchViaIntent()
-                    uiDevice.launchSplitScreen()
-                }
-            }
-            teardown {
-                eachRun {
-                    splitScreenApp.exit()
-                    secondaryApp.exit()
-                }
-            }
-            assertions {
-                windowManagerTrace {
-                    visibleWindowsShownMoreThanOneConsecutiveEntry()
-                }
-                layersTrace {
-                    visibleLayersShownMoreThanOneConsecutiveEntry(
-                            listOf(LAUNCHER_PACKAGE_NAME))
-                }
-            }
-        }
-
-    @Test
-    fun testEnterSplitScreen_exitPrimarySplitScreenMode() {
-        val testTag = "testEnterSplitScreen_exitPrimarySplitScreenMode"
-        runWithFlicker(splitScreenSetup) {
-            withTestName { testTag }
-            repeat {
-                TEST_REPETITIONS
-            }
-            transitions {
-                uiDevice.exitSplitScreen()
-            }
-            assertions {
-                layersTrace {
-                    dockedStackDividerIsInvisible()
-                    layerBecomesInvisible(splitScreenApp.defaultWindowName)
-                }
-                windowManagerTrace {
-                    navBarWindowIsAlwaysVisible()
-                    statusBarWindowIsAlwaysVisible()
-                    end("appWindowIsInvisible") {
-                        isInvisible(splitScreenApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    @Test
-    @FlakyTest(bugId = 172811376)
-    fun testEnterSplitScreen_exitPrimary_showSecondaryAppFullScreen() {
-        val testTag = "testEnterSplitScreen_exitPrimary_showSecondaryAppFullScreen"
-        runWithFlicker(splitScreenSetup) {
-            withTestName { testTag }
-            repeat {
-                TEST_REPETITIONS
-            }
-            transitions {
-                splitScreenApp.reopenAppFromOverview()
-                uiDevice.resizeSplitScreen(startRatio)
-            }
-            assertions {
-                layersTrace {
-                    dockedStackDividerIsInvisible()
-                }
-                windowManagerTrace {
-                    navBarWindowIsAlwaysVisible()
-                    statusBarWindowIsAlwaysVisible()
-                    end("appWindowIsVisible") {
-                        isVisible(splitScreenApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    companion object {
-        private val startRatio = Rational(1, 3)
-
-        @Parameterized.Parameters(name = "{0}")
-        @JvmStatic
-        fun getParams(): Collection<Array<Any>> {
-            val supportedRotations = intArrayOf(Surface.ROTATION_0)
-            return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) }
-        }
-    }
-}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/ExitPrimarySplitScreenShowSecondaryFullscreen.kt

@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2021 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesInVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.layerBecomesInvisible
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
+import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
+import com.android.wm.shell.flicker.dockedStackDividerIsInvisible
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test dock activity to primary split screen, and open secondary to side, exit primary split
+ * and test secondary activity become full screen.
+ * To run this test: `atest WMShellFlickerTests:ExitPrimarySplitScreenShowSecondaryFullscreen`
+ */
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class ExitPrimarySplitScreenShowSecondaryFullscreen(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testExitPrimarySplitScreenShowSecondaryFullscreen", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    device.launchSplitScreen()
+                    secondaryApp.reopenAppFromOverview()
+                    // TODO(b/175687842) Can not find Split screen divider, use exit() instead
+                    splitScreenApp.exit()
+                }
+                assertions {
+                    layersTrace {
+                        dockedStackDividerIsInvisible(bugId = 175687842)
+                        layerBecomesInvisible(splitScreenApp.defaultWindowName)
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
+                                secondaryApp.defaultWindowName),
+                            bugId = 178447631
+                        )
+                    }
+                    windowManagerTrace {
+                        appWindowBecomesInVisible(splitScreenApp.defaultWindowName)
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                        visibleWindowsShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
+                                secondaryApp.defaultWindowName),
+                            bugId = 178447631
+                        )
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, defaultTransitionSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS)
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/LegacySplitScreenToLauncher.kt

@@ -52,13 +52,13 @@ import org.junit.runners.Parameterized
 
 /**
  * Test open app to split screen.
- * To run this test: `atest WMShellFlickerTests:LegacySplitScreenToLauncherTest`
+ * To run this test: `atest WMShellFlickerTests:LegacySplitScreenToLauncher`
  */
 @Presubmit
 @RequiresDevice
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class LegacySplitScreenToLauncherTest(
+class LegacySplitScreenToLauncher(
     testSpec: FlickerTestRunnerFactory.TestSpec
 ) : FlickerTestRunner(testSpec) {
     companion object {
@@ -67,68 +67,68 @@ class LegacySplitScreenToLauncherTest(
         fun getParams(): Collection<Array<Any>> {
             val instrumentation = InstrumentationRegistry.getInstrumentation()
             val launcherPackageName = LauncherStrategyFactory.getInstance(instrumentation)
-                    .launcherStrategy.supportedLauncherPackage
+                .launcherStrategy.supportedLauncherPackage
             val testApp = SimpleAppHelper(instrumentation)
 
             // b/161435597 causes the test not to work on 90 degrees
             return FlickerTestRunnerFactory.getInstance().buildTest(instrumentation,
                 supportedRotations = listOf(Surface.ROTATION_0)) { configuration ->
-                    withTestName {
-                        buildTestTag("splitScreenToLauncher", configuration)
+                withTestName {
+                    buildTestTag("splitScreenToLauncher", configuration)
+                }
+                repeat { configuration.repetitions }
+                setup {
+                    test {
+                        device.wakeUpAndGoToHomeScreen()
+                        device.openQuickStepAndClearRecentAppsFromOverview()
                     }
-                    repeat { configuration.repetitions }
-                    setup {
-                        test {
-                            device.wakeUpAndGoToHomeScreen()
-                            device.openQuickStepAndClearRecentAppsFromOverview()
-                        }
-                        eachRun {
-                            testApp.launchViaIntent(wmHelper)
-                            this.setRotation(configuration.endRotation)
-                            device.launchSplitScreen()
-                            device.waitForIdle()
-                        }
+                    eachRun {
+                        testApp.launchViaIntent(wmHelper)
+                        this.setRotation(configuration.endRotation)
+                        device.launchSplitScreen()
+                        device.waitForIdle()
                     }
-                    teardown {
-                        eachRun {
-                            testApp.exit()
-                        }
-                        test {
-                            if (device.isInSplitScreen()) {
-                                device.exitSplitScreen()
-                            }
-                        }
+                }
+                teardown {
+                    eachRun {
+                        testApp.exit()
                     }
-                    transitions {
-                        device.exitSplitScreen()
-                    }
-                    assertions {
-                        windowManagerTrace {
-                            navBarWindowIsAlwaysVisible()
-                            statusBarWindowIsAlwaysVisible()
-                            visibleWindowsShownMoreThanOneConsecutiveEntry()
-                        }
-
-                        layersTrace {
-                            navBarLayerIsAlwaysVisible()
-                            statusBarLayerIsAlwaysVisible()
-                            noUncoveredRegions(configuration.endRotation)
-                            navBarLayerRotatesAndScales(configuration.endRotation)
-                            statusBarLayerRotatesScales(configuration.endRotation)
-                            visibleLayersShownMoreThanOneConsecutiveEntry(
-                                    listOf(launcherPackageName))
-
-                            // b/161435597 causes the test not to work on 90 degrees
-                            dockedStackDividerBecomesInvisible()
-
-                            layerBecomesInvisible(testApp.getPackage())
-                        }
-
-                        eventLog {
-                            focusDoesNotChange(bugId = 151179149)
+                    test {
+                        if (device.isInSplitScreen()) {
+                            device.exitSplitScreen()
                         }
                     }
                 }
+                transitions {
+                    device.exitSplitScreen()
+                }
+                assertions {
+                    windowManagerTrace {
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                        visibleWindowsShownMoreThanOneConsecutiveEntry()
+                    }
+
+                    layersTrace {
+                        navBarLayerIsAlwaysVisible()
+                        statusBarLayerIsAlwaysVisible()
+                        noUncoveredRegions(configuration.endRotation)
+                        navBarLayerRotatesAndScales(configuration.endRotation)
+                        statusBarLayerRotatesScales(configuration.endRotation)
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                            listOf(launcherPackageName))
+
+                        // b/161435597 causes the test not to work on 90 degrees
+                        dockedStackDividerBecomesInvisible()
+
+                        layerBecomesInvisible(testApp.getPackage())
+                    }
+
+                    eventLog {
+                        focusDoesNotChange(bugId = 151179149)
+                    }
+                }
+            }
         }
     }
 }

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/LegacySplitScreenTransition.kt

@@ -0,0 +1,99 @@
+/*
+ * 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/LICENSE2.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.wm.shell.flicker.legacysplitscreen
+
+import android.app.Instrumentation
+import android.os.Bundle
+import android.support.test.launcherhelper.LauncherStrategyFactory
+import android.view.Surface
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.helpers.openQuickStepAndClearRecentAppsFromOverview
+import com.android.server.wm.flicker.helpers.setRotation
+import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
+import com.android.server.wm.flicker.startRotation
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+
+abstract class LegacySplitScreenTransition(
+    protected val instrumentation: Instrumentation
+) {
+    internal val splitScreenApp = SplitScreenHelper.getPrimary(instrumentation)
+    internal val secondaryApp = SplitScreenHelper.getSecondary(instrumentation)
+    internal val nonResizeableApp = SplitScreenHelper.getNonResizeable(instrumentation)
+    internal val LAUNCHER_PACKAGE_NAME = LauncherStrategyFactory.getInstance(instrumentation)
+        .launcherStrategy.supportedLauncherPackage
+    internal val LIVE_WALLPAPER_PACKAGE_NAME =
+        "com.breel.wallpapers18.soundviz.wallpaper.variations.SoundVizWallpaperV2"
+    internal val LETTERBOX_NAME = "Letterbox"
+    internal val TOAST_NAME = "Toast"
+    internal val SPLASH_SCREEN_NAME = "Splash Screen"
+
+    internal open val defaultTransitionSetup: FlickerBuilder.(Bundle) -> Unit
+        get() = { configuration ->
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    device.openQuickStepAndClearRecentAppsFromOverview()
+                    secondaryApp.launchViaIntent(wmHelper)
+                    splitScreenApp.launchViaIntent(wmHelper)
+                    this.setRotation(configuration.startRotation)
+                }
+            }
+            teardown {
+                eachRun {
+                    splitScreenApp.exit()
+                    secondaryApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+        }
+
+    internal open val cleanSetup: FlickerBuilder.(Bundle) -> Unit
+        get() = { configuration ->
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    device.openQuickStepAndClearRecentAppsFromOverview()
+                    this.setRotation(configuration.startRotation)
+                }
+            }
+            teardown {
+                eachRun {
+                    nonResizeableApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+        }
+
+    internal open val customRotateSetup: FlickerBuilder.(Bundle) -> Unit
+        get() = { configuration ->
+            setup {
+                eachRun {
+                    device.wakeUpAndGoToHomeScreen()
+                    device.openQuickStepAndClearRecentAppsFromOverview()
+                    secondaryApp.launchViaIntent(wmHelper)
+                    splitScreenApp.launchViaIntent(wmHelper)
+                }
+            }
+            teardown {
+                eachRun {
+                    splitScreenApp.exit()
+                    secondaryApp.exit()
+                    this.setRotation(Surface.ROTATION_0)
+                }
+            }
+        }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/NonResizableDismissInLegacySplitScreen.kt

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2021 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import android.view.Surface
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.DOCKED_STACK_DIVIDER
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesInVisible
+import com.android.server.wm.flicker.appWindowBecomesVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.layerBecomesInvisible
+import com.android.server.wm.flicker.layerBecomesVisible
+import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
+import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test launch non resizable activity in split screen mode will trigger exit split screen mode
+ * (Non resizable activity launch via recent overview)
+ * To run this test: `atest WMShellFlickerTests:NonResizableDismissInLegacySplitScreen`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class NonResizableDismissInLegacySplitScreen(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testNonResizableDismissInLegacySplitScreen", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    nonResizeableApp.launchViaIntent(wmHelper)
+                    splitScreenApp.launchViaIntent(wmHelper)
+                    device.launchSplitScreen()
+                    nonResizeableApp.reopenAppFromOverview()
+                    wmHelper.waitForAppTransitionIdle()
+                }
+                assertions {
+                    layersTrace {
+                        layerBecomesVisible(nonResizeableApp.defaultWindowName)
+                        layerBecomesInvisible(splitScreenApp.defaultWindowName)
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                            listOf(DOCKED_STACK_DIVIDER, LAUNCHER_PACKAGE_NAME,
+                                LETTERBOX_NAME, TOAST_NAME,
+                                splitScreenApp.defaultWindowName,
+                                nonResizeableApp.defaultWindowName),
+                            bugId = 178447631
+                        )
+                    }
+                    windowManagerTrace {
+                        appWindowBecomesVisible(nonResizeableApp.defaultWindowName)
+                        appWindowBecomesInVisible(splitScreenApp.defaultWindowName)
+                        visibleWindowsShownMoreThanOneConsecutiveEntry(
+                            listOf(DOCKED_STACK_DIVIDER, LAUNCHER_PACKAGE_NAME,
+                                LETTERBOX_NAME, TOAST_NAME,
+                                splitScreenApp.defaultWindowName,
+                                nonResizeableApp.defaultWindowName)
+                        )
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, cleanSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS,
+                supportedRotations = listOf(Surface.ROTATION_0 /* bugId = 178685668 */))
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/NonResizableDismissInLegacySplitScreenTest.kt

@@ -1,92 +0,0 @@
-/*
- * Copyright (C) 2021 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.wm.shell.flicker.legacysplitscreen
-
-import android.platform.test.annotations.Presubmit
-import android.view.Surface
-import androidx.test.filters.RequiresDevice
-import com.android.server.wm.flicker.dsl.runWithFlicker
-import com.android.server.wm.flicker.helpers.WindowUtils
-import com.android.server.wm.flicker.helpers.launchSplitScreen
-import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
-import com.android.wm.shell.flicker.dockedStackDividerIsInvisible
-import com.android.wm.shell.flicker.helpers.SplitScreenHelper
-import org.junit.FixMethodOrder
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-import org.junit.runners.Parameterized
-
-/**
- * Test open app to split screen.
- * To run this test: `atest WMShellFlickerTests:NonResizableDismissInLegacySplitScreenTest`
- */
-@Presubmit
-@RequiresDevice
-@RunWith(Parameterized::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class NonResizableDismissInLegacySplitScreenTest(
-    rotationName: String,
-    rotation: Int
-) : SplitScreenTestBase(rotationName, rotation) {
-
-    @Test
-    fun testNonResizableDismissInLegacySplitScreenTest() {
-        val testTag = "testNonResizableDismissInLegacySplitScreenTest"
-
-        runWithFlicker(transitionSetup) {
-            withTestName { testTag }
-            repeat { SplitScreenHelper.TEST_REPETITIONS }
-            transitions {
-                nonResizeableApp.launchViaIntent(wmHelper)
-                splitScreenApp.launchViaIntent(wmHelper)
-                device.launchSplitScreen()
-                nonResizeableApp.reopenAppFromOverview()
-            }
-            assertions {
-                layersTrace {
-                    dockedStackDividerIsInvisible()
-                    end("appsEndingBounds", enabled = false) {
-                        val displayBounds = WindowUtils.getDisplayBounds(rotation)
-                        this.hasVisibleRegion(nonResizeableApp.defaultWindowName, displayBounds)
-                    }
-                    visibleLayersShownMoreThanOneConsecutiveEntry(
-                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
-                                    nonResizeableApp.defaultWindowName, LETTER_BOX_NAME,
-                                    TOAST_NAME, LIVE_WALLPAPER_PACKAGE_NAME),
-                            bugId = 178447631
-                    )
-                }
-                windowManagerTrace {
-                    end("nonResizeableAppWindowIsVisible") {
-                        isVisible(nonResizeableApp.defaultWindowName)
-                            .isInvisible(splitScreenApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    companion object {
-        @Parameterized.Parameters(name = "{0}")
-        @JvmStatic
-        fun getParams(): Collection<Array<Any>> {
-            val supportedRotations = intArrayOf(Surface.ROTATION_0, Surface.ROTATION_90)
-            return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) }
-        }
-    }
-}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/NonResizableLaunchInLegacySplitScreen.kt

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2021 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import android.view.Surface
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.DOCKED_STACK_DIVIDER
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesInVisible
+import com.android.server.wm.flicker.appWindowBecomesVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.layerBecomesInvisible
+import com.android.server.wm.flicker.layerBecomesVisible
+import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
+import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test launch non resizable activity in split screen mode will trigger exit split screen mode
+ * (Non resizable activity launch via intent)
+ * To run this test: `atest WMShellFlickerTests:NonResizableLaunchInLegacySplitScreen`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class NonResizableLaunchInLegacySplitScreen(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testNonResizableLaunchInLegacySplitScreen", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    splitScreenApp.launchViaIntent(wmHelper)
+                    device.launchSplitScreen()
+                    nonResizeableApp.launchViaIntent(wmHelper)
+                    wmHelper.waitForAppTransitionIdle()
+                }
+                assertions {
+                    layersTrace {
+                        layerBecomesVisible(nonResizeableApp.defaultWindowName)
+                        layerBecomesInvisible(splitScreenApp.defaultWindowName)
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                                listOf(DOCKED_STACK_DIVIDER,
+                                        LAUNCHER_PACKAGE_NAME,
+                                        LETTERBOX_NAME,
+                                        nonResizeableApp.defaultWindowName,
+                                        splitScreenApp.defaultWindowName)
+                        )
+                    }
+                    windowManagerTrace {
+                        appWindowBecomesVisible(nonResizeableApp.defaultWindowName)
+                        appWindowBecomesInVisible(splitScreenApp.defaultWindowName)
+                        visibleWindowsShownMoreThanOneConsecutiveEntry(
+                                listOf(DOCKED_STACK_DIVIDER,
+                                        LAUNCHER_PACKAGE_NAME,
+                                        LETTERBOX_NAME,
+                                        nonResizeableApp.defaultWindowName,
+                                        splitScreenApp.defaultWindowName)
+                        )
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, cleanSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS,
+                supportedRotations = listOf(Surface.ROTATION_0 /* bugId = 178685668 */))
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/NonResizableLaunchInLegacySplitScreenTest.kt

@@ -1,92 +0,0 @@
-/*
- * Copyright (C) 2021 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.wm.shell.flicker.legacysplitscreen
-
-import android.platform.test.annotations.Presubmit
-import android.view.Surface
-import androidx.test.filters.RequiresDevice
-import com.android.server.wm.flicker.dsl.runWithFlicker
-import com.android.server.wm.flicker.helpers.WindowUtils
-import com.android.server.wm.flicker.helpers.launchSplitScreen
-import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
-import com.android.wm.shell.flicker.dockedStackDividerIsInvisible
-import com.android.wm.shell.flicker.helpers.SplitScreenHelper
-import org.junit.FixMethodOrder
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-import org.junit.runners.Parameterized
-
-/**
- * Test open app to split screen.
- * To run this test: `atest WMShellFlickerTests:NonResizableLaunchInLegacySplitScreenTest`
- */
-@Presubmit
-@RequiresDevice
-@RunWith(Parameterized::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class NonResizableLaunchInLegacySplitScreenTest(
-    rotationName: String,
-    rotation: Int
-) : SplitScreenTestBase(rotationName, rotation) {
-
-    @Test
-    fun testNonResizableLaunchInLegacySplitScreenTest() {
-        val testTag = "testNonResizableLaunchInLegacySplitScreenTest"
-
-        runWithFlicker(transitionSetup) {
-            withTestName { testTag }
-            repeat { SplitScreenHelper.TEST_REPETITIONS }
-            transitions {
-                nonResizeableApp.launchViaIntent(wmHelper)
-                splitScreenApp.launchViaIntent(wmHelper)
-                device.launchSplitScreen()
-                nonResizeableApp.reopenAppFromOverview()
-            }
-            assertions {
-                layersTrace {
-                    dockedStackDividerIsInvisible()
-                    end("appsEndingBounds", enabled = false) {
-                        val displayBounds = WindowUtils.getDisplayBounds(rotation)
-                        this.hasVisibleRegion(nonResizeableApp.defaultWindowName, displayBounds)
-                    }
-                    visibleLayersShownMoreThanOneConsecutiveEntry(
-                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
-                                    nonResizeableApp.defaultWindowName, LETTER_BOX_NAME,
-                                    TOAST_NAME, LIVE_WALLPAPER_PACKAGE_NAME),
-                        bugId = 178447631
-                    )
-                }
-                windowManagerTrace {
-                    end("nonResizeableAppWindowIsVisible") {
-                        isVisible(nonResizeableApp.defaultWindowName)
-                            .isInvisible(splitScreenApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    companion object {
-        @Parameterized.Parameters(name = "{0}")
-        @JvmStatic
-        fun getParams(): Collection<Array<Any>> {
-            val supportedRotations = intArrayOf(Surface.ROTATION_0, Surface.ROTATION_90)
-            return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) }
-        }
-    }
-}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/OpenAppToLegacySplitScreen.kt

@@ -16,94 +16,84 @@
 
 package com.android.wm.shell.flicker.legacysplitscreen
 
+import android.os.Bundle
 import android.platform.test.annotations.Presubmit
-import android.view.Surface
 import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
 import com.android.server.wm.flicker.appWindowBecomesVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.focusChanges
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.layerBecomesVisible
+import com.android.server.wm.flicker.noUncoveredRegions
+import com.android.server.wm.flicker.startRotation
 import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
 import com.android.server.wm.flicker.visibleLayersShownMoreThanOneConsecutiveEntry
-import com.android.server.wm.flicker.layerBecomesVisible
-import com.android.server.wm.flicker.focusChanges
-import com.android.server.wm.flicker.helpers.launchSplitScreen
-import com.android.server.wm.flicker.dsl.runWithFlicker
-import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
-import com.android.server.wm.flicker.noUncoveredRegions
 import com.android.server.wm.flicker.visibleWindowsShownMoreThanOneConsecutiveEntry
 import com.android.server.wm.traces.parser.windowmanager.WindowManagerStateHelper
 import com.android.wm.shell.flicker.appPairsDividerBecomesVisible
 import com.android.wm.shell.flicker.helpers.SplitScreenHelper
 import org.junit.FixMethodOrder
-import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.MethodSorters
 import org.junit.runners.Parameterized
 
 /**
  * Test open app to split screen.
- * To run this test: `atest WMShellFlickerTests:OpenAppToLegacySplitScreenTest`
+ * To run this test: `atest WMShellFlickerTests:OpenAppToLegacySplitScreen`
  */
 @Presubmit
 @RequiresDevice
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class OpenAppToLegacySplitScreenTest(
-    rotationName: String,
-    rotation: Int
-) : SplitScreenTestBase(rotationName, rotation) {
-    @Test
-    fun OpenAppToLegacySplitScreenTest() {
-        val testTag = "OpenAppToLegacySplitScreenTest"
-        val helper = WindowManagerStateHelper()
-        runWithFlicker(transitionSetup) {
-            withTestName { testTag }
-            repeat { SplitScreenHelper.TEST_REPETITIONS }
-            setup {
-                eachRun {
-                    splitScreenApp.launchViaIntent(wmHelper)
-                    device.pressHome()
-                    this.setRotation(rotation)
-                }
-            }
-            transitions {
-                device.launchSplitScreen()
-                helper.waitForAppTransitionIdle()
-            }
-            assertions {
-                windowManagerTrace {
-                    visibleWindowsShownMoreThanOneConsecutiveEntry(
-                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
-                                    LETTER_BOX_NAME)
-                    )
-                    appWindowBecomesVisible(splitScreenApp.getPackage())
-                }
-
-                layersTrace {
-                    navBarLayerIsAlwaysVisible()
-                    noUncoveredRegions(rotation, enabled = false)
-                    statusBarLayerIsAlwaysVisible()
-                    visibleLayersShownMoreThanOneConsecutiveEntry(
-                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName,
-                                    LETTER_BOX_NAME))
-                    appPairsDividerBecomesVisible()
-                    layerBecomesVisible(splitScreenApp.getPackage())
-                }
-
-                eventLog {
-                    focusChanges(splitScreenApp.`package`,
-                            "recents_animation_input_consumer", "NexusLauncherActivity",
-                            bugId = 151179149)
-                }
-            }
-        }
-    }
-
-    companion object {
+class OpenAppToLegacySplitScreen(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
         @Parameterized.Parameters(name = "{0}")
         @JvmStatic
         fun getParams(): Collection<Array<Any>> {
-            // TODO(b/161435597) causes the test not to work on 90 degrees
-            val supportedRotations = intArrayOf(Surface.ROTATION_0)
-            return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) }
+            val wmHelper = WindowManagerStateHelper()
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testOpenAppToLegacySplitScreen", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    device.launchSplitScreen()
+                    wmHelper.waitForAppTransitionIdle()
+                }
+                assertions {
+                    windowManagerTrace {
+                        visibleWindowsShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName),
+                            bugId = 178447631)
+                        appWindowBecomesVisible(splitScreenApp.getPackage())
+                    }
+
+                    layersTrace {
+                        noUncoveredRegions(configuration.startRotation, enabled = false)
+                        statusBarLayerIsAlwaysVisible()
+                        appPairsDividerBecomesVisible()
+                        layerBecomesVisible(splitScreenApp.getPackage())
+                        visibleLayersShownMoreThanOneConsecutiveEntry(
+                            listOf(LAUNCHER_PACKAGE_NAME, splitScreenApp.defaultWindowName),
+                            bugId = 178447631)
+                    }
+
+                    eventLog {
+                        focusChanges(splitScreenApp.`package`,
+                            "recents_animation_input_consumer", "NexusLauncherActivity",
+                            bugId = 151179149)
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, defaultTransitionSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS)
         }
     }
 }

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/ResizeLegacySplitScreen.kt

@@ -58,7 +58,7 @@ import org.junit.runners.Parameterized
 
 /**
  * Test split screen resizing window transitions.
- * To run this test: `atest WMShellFlickerTests:ResizeLegacySplitScreenTest`
+ * To run this test: `atest WMShellFlickerTests:ResizeLegacySplitScreen`
  *
  * Currently it runs only in 0 degrees because of b/156100803
  */
@@ -67,7 +67,7 @@ import org.junit.runners.Parameterized
 @RunWith(Parameterized::class)
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 @FlakyTest(bugId = 159096424)
-class ResizeLegacySplitScreenTest(
+class ResizeLegacySplitScreen(
     testSpec: FlickerTestRunnerFactory.TestSpec
 ) : FlickerTestRunner(testSpec) {
     companion object {

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/RotateOneLaunchedAppAndEnterSplitScreen.kt

@@ -0,0 +1,95 @@
+/*
+ * 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import android.view.Surface
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.endRotation
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.helpers.setRotation
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.startRotation
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
+import com.android.wm.shell.flicker.dockedStackDividerIsVisible
+import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test dock activity to primary split screen and rotate
+ * To run this test: `atest WMShellFlickerTests:RotateOneLaunchedAppAndEnterSplitScreen`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class RotateOneLaunchedAppAndEnterSplitScreen(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testRotateOneLaunchedAppAndEnterSplitScreen", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    device.launchSplitScreen()
+                    this.setRotation(configuration.startRotation)
+                }
+                assertions {
+                    layersTrace {
+                        dockedStackDividerIsVisible(bugId = 175687842)
+                        dockedStackPrimaryBoundsIsVisible(
+                            configuration.startRotation,
+                            splitScreenApp.defaultWindowName, bugId = 175687842)
+                        navBarLayerRotatesAndScales(
+                            configuration.startRotation,
+                            configuration.endRotation, bugId = 169271943)
+                        statusBarLayerRotatesScales(
+                            configuration.startRotation,
+                            configuration.endRotation, bugId = 169271943)
+                    }
+                    windowManagerTrace {
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                        appWindowBecomesVisible(splitScreenApp.defaultWindowName)
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, customRotateSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS,
+                supportedRotations = listOf(Surface.ROTATION_0 /* bugId = 178685668 */))
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/RotateOneLaunchedAppInSplitScreenMode.kt

@@ -0,0 +1,95 @@
+/*
+ * 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import android.view.Surface
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.endRotation
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.helpers.setRotation
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.startRotation
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
+import com.android.wm.shell.flicker.dockedStackDividerIsVisible
+import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Rotate
+ * To run this test: `atest WMShellFlickerTests:RotateOneLaunchedAppInSplitScreenMode`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class RotateOneLaunchedAppInSplitScreenMode(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testRotateOneLaunchedAppInSplitScreenMode", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    this.setRotation(configuration.startRotation)
+                    device.launchSplitScreen()
+                }
+                assertions {
+                    layersTrace {
+                        dockedStackDividerIsVisible(bugId = 175687842)
+                        dockedStackPrimaryBoundsIsVisible(
+                            configuration.startRotation,
+                            splitScreenApp.defaultWindowName, bugId = 175687842)
+                        navBarLayerRotatesAndScales(
+                            configuration.startRotation,
+                            configuration.endRotation, bugId = 169271943)
+                        statusBarLayerRotatesScales(
+                            configuration.startRotation,
+                            configuration.endRotation, bugId = 169271943)
+                    }
+                    windowManagerTrace {
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                        appWindowBecomesVisible(splitScreenApp.defaultWindowName)
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, customRotateSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS,
+                supportedRotations = listOf(Surface.ROTATION_0 /* bugId = 178685668 */))
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/RotateOneLaunchedAppTest.kt

@@ -1,150 +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.wm.shell.flicker.legacysplitscreen
-
-import android.platform.test.annotations.Presubmit
-import android.view.Surface
-import androidx.test.filters.RequiresDevice
-import com.android.server.wm.flicker.dsl.FlickerBuilder
-import com.android.server.wm.flicker.dsl.runWithFlicker
-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.openQuickStepAndClearRecentAppsFromOverview
-import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
-import com.android.server.wm.flicker.navBarLayerRotatesAndScales
-import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
-import com.android.server.wm.flicker.statusBarLayerRotatesScales
-import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
-import com.android.wm.shell.flicker.dockedStackDividerIsVisible
-import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
-import com.android.wm.shell.flicker.helpers.SplitScreenHelper
-import org.junit.FixMethodOrder
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-import org.junit.runners.Parameterized
-
-/**
- * Test open app to split screen.
- * To run this test: `atest WMShellFlickerTests:RotateOneLaunchedAppTest`
- */
-@Presubmit
-@RequiresDevice
-@RunWith(Parameterized::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class RotateOneLaunchedAppTest(
-    rotationName: String,
-    rotation: Int
-) : SplitScreenTestBase(rotationName, rotation) {
-    private val splitScreenRotationSetup: FlickerBuilder
-        get() = FlickerBuilder(instrumentation).apply {
-            val testSetupRotation = "testSetupRotation"
-            withTestName {
-                testSetupRotation
-            }
-            setup {
-                test {
-                    uiDevice.wakeUpAndGoToHomeScreen()
-                    uiDevice.openQuickStepAndClearRecentAppsFromOverview()
-                }
-            }
-            teardown {
-                eachRun {
-                    if (uiDevice.isInSplitScreen()) {
-                        uiDevice.exitSplitScreen()
-                    }
-                    setRotation(Surface.ROTATION_0)
-                    splitScreenApp.exit()
-                    secondaryApp.exit()
-                }
-            }
-        }
-
-    @Test
-    fun testRotateInSplitScreenMode() {
-        val testTag = "testEnterSplitScreen_launchToSide"
-        runWithFlicker(splitScreenRotationSetup) {
-            withTestName { testTag }
-            repeat {
-                SplitScreenHelper.TEST_REPETITIONS
-            }
-            transitions {
-                splitScreenApp.launchViaIntent()
-                uiDevice.launchSplitScreen()
-                setRotation(rotation)
-            }
-            assertions {
-                layersTrace {
-                    navBarLayerRotatesAndScales(Surface.ROTATION_0, rotation, 169271943)
-                    statusBarLayerRotatesScales(Surface.ROTATION_0, rotation, 169271943)
-                    dockedStackDividerIsVisible()
-                    dockedStackPrimaryBoundsIsVisible(
-                            rotation, splitScreenApp.defaultWindowName, 169271943)
-                }
-                windowManagerTrace {
-                    navBarWindowIsAlwaysVisible()
-                    statusBarWindowIsAlwaysVisible()
-                    end("appWindowIsVisible") {
-                        isVisible(splitScreenApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    @Test
-    fun testRotateAndEnterSplitScreenMode() {
-        val testTag = "testRotateAndEnterSplitScreenMode"
-        runWithFlicker(splitScreenRotationSetup) {
-            withTestName { testTag }
-            repeat {
-                SplitScreenHelper.TEST_REPETITIONS
-            }
-            transitions {
-                splitScreenApp.launchViaIntent()
-                setRotation(rotation)
-                uiDevice.launchSplitScreen()
-            }
-            assertions {
-                layersTrace {
-                    navBarLayerRotatesAndScales(Surface.ROTATION_0, rotation, 169271943)
-                    statusBarLayerRotatesScales(Surface.ROTATION_0, rotation, 169271943)
-                    dockedStackDividerIsVisible()
-                    dockedStackPrimaryBoundsIsVisible(
-                            rotation, splitScreenApp.defaultWindowName, 169271943)
-                }
-                windowManagerTrace {
-                    navBarWindowIsAlwaysVisible()
-                    statusBarWindowIsAlwaysVisible()
-                    end("appWindowIsVisible") {
-                        isVisible(splitScreenApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    companion object {
-        @Parameterized.Parameters(name = "{0}")
-        @JvmStatic
-        fun getParams(): Collection<Array<Any>> {
-            val supportedRotations = intArrayOf(Surface.ROTATION_90, Surface.ROTATION_270)
-            return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) }
-        }
-    }
-}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/RotateTwoLaunchedAppAndEnterSplitScreen.kt

@@ -0,0 +1,100 @@
+/*
+ * 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import android.view.Surface
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.endRotation
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.helpers.setRotation
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.startRotation
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
+import com.android.wm.shell.flicker.dockedStackDividerIsVisible
+import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
+import com.android.wm.shell.flicker.dockedStackSecondaryBoundsIsVisible
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test open app to split screen.
+ * To run this test: `atest WMShellFlickerTests:RotateTwoLaunchedAppAndEnterSplitScreen`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class RotateTwoLaunchedAppAndEnterSplitScreen(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testRotateTwoLaunchedAppAndEnterSplitScreen", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                transitions {
+                    this.setRotation(configuration.startRotation)
+                    device.launchSplitScreen()
+                    secondaryApp.reopenAppFromOverview()
+                }
+                assertions {
+                    layersTrace {
+                        dockedStackDividerIsVisible(bugId = 175687842)
+                        dockedStackPrimaryBoundsIsVisible(
+                            configuration.startRotation,
+                            splitScreenApp.defaultWindowName, 175687842)
+                        dockedStackSecondaryBoundsIsVisible(
+                            configuration.startRotation,
+                            secondaryApp.defaultWindowName, bugId = 175687842)
+                        navBarLayerRotatesAndScales(
+                            configuration.startRotation,
+                            configuration.endRotation, bugId = 169271943)
+                        statusBarLayerRotatesScales(
+                            configuration.startRotation,
+                            configuration.endRotation, bugId = 169271943)
+                    }
+                    windowManagerTrace {
+                        appWindowBecomesVisible(secondaryApp.defaultWindowName)
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, customRotateSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS,
+                supportedRotations = listOf(Surface.ROTATION_0 /* bugId = 178685668 */))
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/RotateTwoLaunchedAppInSplitScreenMode.kt

@@ -0,0 +1,105 @@
+/*
+ * 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.wm.shell.flicker.legacysplitscreen
+
+import android.os.Bundle
+import android.platform.test.annotations.Presubmit
+import android.view.Surface
+import androidx.test.filters.RequiresDevice
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.server.wm.flicker.FlickerTestRunner
+import com.android.server.wm.flicker.FlickerTestRunnerFactory
+import com.android.server.wm.flicker.appWindowBecomesVisible
+import com.android.server.wm.flicker.dsl.FlickerBuilder
+import com.android.server.wm.flicker.endRotation
+import com.android.server.wm.flicker.helpers.buildTestTag
+import com.android.server.wm.flicker.helpers.launchSplitScreen
+import com.android.server.wm.flicker.helpers.setRotation
+import com.android.server.wm.flicker.navBarLayerRotatesAndScales
+import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
+import com.android.server.wm.flicker.startRotation
+import com.android.server.wm.flicker.statusBarLayerRotatesScales
+import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
+import com.android.wm.shell.flicker.dockedStackDividerIsVisible
+import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
+import com.android.wm.shell.flicker.dockedStackSecondaryBoundsIsVisible
+import com.android.wm.shell.flicker.helpers.SplitScreenHelper
+import org.junit.FixMethodOrder
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.junit.runners.Parameterized
+
+/**
+ * Test open app to split screen.
+ * To run this test: `atest WMShellFlickerTests:RotateTwoLaunchedAppInSplitScreenMode`
+ */
+@Presubmit
+@RequiresDevice
+@RunWith(Parameterized::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class RotateTwoLaunchedAppInSplitScreenMode(
+    testSpec: FlickerTestRunnerFactory.TestSpec
+) : FlickerTestRunner(testSpec) {
+    companion object : LegacySplitScreenTransition(InstrumentationRegistry.getInstrumentation()) {
+        @Parameterized.Parameters(name = "{0}")
+        @JvmStatic
+        fun getParams(): Collection<Array<Any>> {
+            val testSpec: FlickerBuilder.(Bundle) -> Unit = { configuration ->
+                withTestName {
+                    buildTestTag("testRotateTwoLaunchedAppInSplitScreenMode", configuration)
+                }
+                repeat { SplitScreenHelper.TEST_REPETITIONS }
+                setup {
+                    eachRun {
+                        device.launchSplitScreen()
+                        splitScreenApp.reopenAppFromOverview()
+                        this.setRotation(configuration.startRotation)
+                    }
+                }
+                transitions {
+                    this.setRotation(configuration.startRotation)
+                }
+                assertions {
+                    layersTrace {
+                        dockedStackDividerIsVisible(bugId = 175687842)
+                        dockedStackPrimaryBoundsIsVisible(
+                            configuration.startRotation,
+                            splitScreenApp.defaultWindowName, bugId = 175687842)
+                        dockedStackSecondaryBoundsIsVisible(
+                            configuration.startRotation,
+                            secondaryApp.defaultWindowName, bugId = 175687842)
+                        navBarLayerRotatesAndScales(
+                            configuration.startRotation,
+                            configuration.endRotation, bugId = 169271943)
+                        statusBarLayerRotatesScales(
+                            configuration.startRotation,
+                            configuration.endRotation, bugId = 169271943)
+                    }
+                    windowManagerTrace {
+                        appWindowBecomesVisible(secondaryApp.defaultWindowName)
+                        navBarWindowIsAlwaysVisible()
+                        statusBarWindowIsAlwaysVisible()
+                    }
+                }
+            }
+            return FlickerTestRunnerFactory.getInstance().buildTest(
+                instrumentation, customRotateSetup, testSpec,
+                repetitions = SplitScreenHelper.TEST_REPETITIONS,
+                supportedRotations = listOf(Surface.ROTATION_0 /* bugId = 178685668 */))
+        }
+    }
+}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/RotateTwoLaunchedAppTest.kt

@@ -1,163 +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.wm.shell.flicker.legacysplitscreen
-
-import android.platform.test.annotations.Presubmit
-import android.view.Surface
-import androidx.test.filters.FlakyTest
-import androidx.test.filters.RequiresDevice
-import com.android.server.wm.flicker.dsl.FlickerBuilder
-import com.android.server.wm.flicker.dsl.runWithFlicker
-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.openQuickStepAndClearRecentAppsFromOverview
-import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
-import com.android.server.wm.flicker.navBarLayerRotatesAndScales
-import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
-import com.android.server.wm.flicker.statusBarLayerRotatesScales
-import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
-import com.android.wm.shell.flicker.dockedStackDividerIsVisible
-import com.android.wm.shell.flicker.dockedStackPrimaryBoundsIsVisible
-import com.android.wm.shell.flicker.dockedStackSecondaryBoundsIsVisible
-import com.android.wm.shell.flicker.helpers.SplitScreenHelper
-import org.junit.FixMethodOrder
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.MethodSorters
-import org.junit.runners.Parameterized
-
-/**
- * Test open app to split screen.
- * To run this test: `atest WMShellFlickerTests:RotateTwoLaunchedAppTest`
- */
-@Presubmit
-@RequiresDevice
-@RunWith(Parameterized::class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-class RotateTwoLaunchedAppTest(
-    rotationName: String,
-    rotation: Int
-) : SplitScreenTestBase(rotationName, rotation) {
-    private val splitScreenRotationSetup: FlickerBuilder
-        get() = FlickerBuilder(instrumentation).apply {
-            val testSetupRotation = "testSetupRotation"
-            withTestName {
-                testSetupRotation
-            }
-            setup {
-                test {
-                    uiDevice.wakeUpAndGoToHomeScreen()
-                    uiDevice.openQuickStepAndClearRecentAppsFromOverview()
-                }
-            }
-            teardown {
-                eachRun {
-                    if (uiDevice.isInSplitScreen()) {
-                        uiDevice.exitSplitScreen()
-                    }
-                    setRotation(Surface.ROTATION_0)
-                    splitScreenApp.exit()
-                    secondaryApp.exit()
-                }
-            }
-        }
-
-    @Test
-    fun testRotateInSplitScreenMode() {
-        val testTag = "testRotateInSplitScreenMode"
-        runWithFlicker(splitScreenRotationSetup) {
-            withTestName { testTag }
-            repeat {
-                SplitScreenHelper.TEST_REPETITIONS
-            }
-            transitions {
-                secondaryApp.launchViaIntent()
-                splitScreenApp.launchViaIntent()
-                uiDevice.launchSplitScreen()
-                splitScreenApp.reopenAppFromOverview()
-                setRotation(rotation)
-            }
-            assertions {
-                layersTrace {
-                    navBarLayerRotatesAndScales(Surface.ROTATION_0, rotation, 169271943)
-                    statusBarLayerRotatesScales(Surface.ROTATION_0, rotation, 169271943)
-                    dockedStackDividerIsVisible()
-                    dockedStackPrimaryBoundsIsVisible(
-                            rotation, splitScreenApp.defaultWindowName, 169271943)
-                    dockedStackSecondaryBoundsIsVisible(
-                            rotation, secondaryApp.defaultWindowName, 169271943)
-                }
-                windowManagerTrace {
-                    navBarWindowIsAlwaysVisible()
-                    statusBarWindowIsAlwaysVisible()
-                    end("appWindowIsVisible") {
-                        isVisible(splitScreenApp.defaultWindowName)
-                            .isVisible(secondaryApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    @FlakyTest(bugId = 173875043)
-    @Test
-    fun testRotateAndEnterSplitScreenMode() {
-        val testTag = "testRotateAndEnterSplitScreenMode"
-        runWithFlicker(splitScreenRotationSetup) {
-            withTestName { testTag }
-            repeat {
-                SplitScreenHelper.TEST_REPETITIONS
-            }
-            transitions {
-                secondaryApp.launchViaIntent()
-                splitScreenApp.launchViaIntent()
-                setRotation(rotation)
-                uiDevice.launchSplitScreen()
-                splitScreenApp.reopenAppFromOverview()
-            }
-            assertions {
-                layersTrace {
-                    navBarLayerRotatesAndScales(Surface.ROTATION_0, rotation, 169271943)
-                    statusBarLayerRotatesScales(Surface.ROTATION_0, rotation, 169271943)
-                    dockedStackDividerIsVisible()
-                    dockedStackPrimaryBoundsIsVisible(
-                            rotation, splitScreenApp.defaultWindowName, 169271943)
-                    dockedStackSecondaryBoundsIsVisible(
-                            rotation, secondaryApp.defaultWindowName, 169271943)
-                }
-                windowManagerTrace {
-                    navBarWindowIsAlwaysVisible()
-                    statusBarWindowIsAlwaysVisible()
-                    end("appWindowIsVisible") {
-                        isVisible(splitScreenApp.defaultWindowName)
-                                .isVisible(secondaryApp.defaultWindowName)
-                    }
-                }
-            }
-        }
-    }
-
-    companion object {
-        @Parameterized.Parameters(name = "{0}")
-        @JvmStatic
-        fun getParams(): Collection<Array<Any>> {
-            val supportedRotations = intArrayOf(Surface.ROTATION_90, Surface.ROTATION_270)
-            return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) }
-        }
-    }
-}

libs/WindowManager/Shell/tests/flicker/src/com/android/wm/shell/flicker/legacysplitscreen/SplitScreenTestBase.kt

@@ -1,74 +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.wm.shell.flicker.legacysplitscreen
-
-import android.support.test.launcherhelper.LauncherStrategyFactory
-import com.android.server.wm.flicker.dsl.FlickerBuilder
-import com.android.server.wm.flicker.helpers.exitSplitScreen
-import com.android.server.wm.flicker.helpers.isInSplitScreen
-import com.android.server.wm.flicker.helpers.openQuickStepAndClearRecentAppsFromOverview
-import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen
-import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible
-import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible
-import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible
-import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible
-import com.android.wm.shell.flicker.NonRotationTestBase
-import com.android.wm.shell.flicker.helpers.SplitScreenHelper
-
-abstract class SplitScreenTestBase(
-    rotationName: String,
-    rotation: Int
-) : NonRotationTestBase(rotationName, rotation) {
-    protected val splitScreenApp = SplitScreenHelper.getPrimary(instrumentation)
-    protected val secondaryApp = SplitScreenHelper.getSecondary(instrumentation)
-    protected val nonResizeableApp = SplitScreenHelper.getNonResizeable(instrumentation)
-    protected val LAUNCHER_PACKAGE_NAME = LauncherStrategyFactory.getInstance(instrumentation)
-            .launcherStrategy.supportedLauncherPackage
-    protected val LIVE_WALLPAPER_PACKAGE_NAME =
-            "com.breel.wallpapers18.soundviz.wallpaper.variations.SoundVizWallpaperV2"
-    protected val LETTER_BOX_NAME = "Letterbox"
-    protected val TOAST_NAME = "Toast"
-
-    protected val transitionSetup: FlickerBuilder
-        get() = FlickerBuilder(instrumentation).apply {
-                setup {
-                    eachRun {
-                        uiDevice.wakeUpAndGoToHomeScreen()
-                        uiDevice.openQuickStepAndClearRecentAppsFromOverview()
-                    }
-                }
-                teardown {
-                    eachRun {
-                        if (uiDevice.isInSplitScreen()) {
-                            uiDevice.exitSplitScreen()
-                        }
-                        splitScreenApp.exit()
-                        nonResizeableApp.exit()
-                    }
-                }
-                assertions {
-                    layersTrace {
-                        navBarLayerIsAlwaysVisible()
-                        statusBarLayerIsAlwaysVisible()
-                    }
-                    windowManagerTrace {
-                        navBarWindowIsAlwaysVisible()
-                        statusBarWindowIsAlwaysVisible()
-                    }
-                }
-            }
-}

tests/FlickerTests/src/com/android/server/wm/flicker/CommonAssertions.kt

@@ -21,9 +21,12 @@ import com.android.server.wm.flicker.dsl.EventLogAssertionBuilder
 import com.android.server.wm.flicker.dsl.LayersAssertionBuilder
 import com.android.server.wm.flicker.dsl.WmAssertionBuilder
 import com.android.server.wm.flicker.helpers.WindowUtils
+import com.android.server.wm.traces.parser.windowmanager.WindowManagerStateHelper.Companion.NAV_BAR_LAYER_NAME
+import com.android.server.wm.traces.parser.windowmanager.WindowManagerStateHelper.Companion.NAV_BAR_WINDOW_NAME
+import com.android.server.wm.traces.parser.windowmanager.WindowManagerStateHelper.Companion.STATUS_BAR_LAYER_NAME
+import com.android.server.wm.traces.parser.windowmanager.WindowManagerStateHelper.Companion.STATUS_BAR_WINDOW_NAME
 
-const val NAVIGATION_BAR_WINDOW_TITLE = "NavigationBar"
-const val STATUS_BAR_WINDOW_TITLE = "StatusBar"
+const val APP_PAIR_SPLIT_DIVIDER = "AppPairSplitDivider"
 const val DOCKED_STACK_DIVIDER = "DockedStackDivider"
 const val WALLPAPER_TITLE = "Wallpaper"
 
@@ -33,7 +36,7 @@ fun WmAssertionBuilder.statusBarWindowIsAlwaysVisible(
     enabled: Boolean = bugId == 0
 ) {
     all("statusBarWindowIsAlwaysVisible", bugId, enabled) {
-        this.showsAboveAppWindow(STATUS_BAR_WINDOW_TITLE)
+        this.showsAboveAppWindow(STATUS_BAR_WINDOW_NAME)
     }
 }
 
@@ -43,7 +46,7 @@ fun WmAssertionBuilder.navBarWindowIsAlwaysVisible(
     enabled: Boolean = bugId == 0
 ) {
     all("navBarWindowIsAlwaysVisible", bugId, enabled) {
-        this.showsAboveAppWindow(NAVIGATION_BAR_WINDOW_TITLE)
+        this.showsAboveAppWindow(NAV_BAR_WINDOW_NAME)
     }
 }
 
@@ -113,6 +116,18 @@ fun WmAssertionBuilder.appWindowBecomesVisible(
     }
 }
 
+fun WmAssertionBuilder.appWindowBecomesInVisible(
+    appName: String,
+    bugId: Int = 0,
+    enabled: Boolean = bugId == 0
+) {
+    all("appWindowBecomesInVisible", bugId, enabled) {
+        this.showsAppWindow(appName)
+                .then()
+                .hidesAppWindow(appName)
+    }
+}
+
 @JvmOverloads
 fun LayersAssertionBuilder.noUncoveredRegions(
     beginRotation: Int,
@@ -151,15 +166,15 @@ fun LayersAssertionBuilder.navBarLayerIsAlwaysVisible(
 ) {
     if (rotatesScreen) {
         all("navBarLayerIsAlwaysVisible", bugId, enabled) {
-            this.showsLayer(NAVIGATION_BAR_WINDOW_TITLE)
+            this.showsLayer(NAV_BAR_LAYER_NAME)
                     .then()
-                    .hidesLayer(NAVIGATION_BAR_WINDOW_TITLE)
+                    .hidesLayer(NAV_BAR_LAYER_NAME)
                     .then()
-                    .showsLayer(NAVIGATION_BAR_WINDOW_TITLE)
+                    .showsLayer(NAV_BAR_LAYER_NAME)
         }
     } else {
         all("navBarLayerIsAlwaysVisible", bugId, enabled) {
-            this.showsLayer(NAVIGATION_BAR_WINDOW_TITLE)
+            this.showsLayer(NAV_BAR_LAYER_NAME)
         }
     }
 }
@@ -172,15 +187,15 @@ fun LayersAssertionBuilder.statusBarLayerIsAlwaysVisible(
 ) {
     if (rotatesScreen) {
         all("statusBarLayerIsAlwaysVisible", bugId, enabled) {
-            this.showsLayer(STATUS_BAR_WINDOW_TITLE)
+            this.showsLayer(STATUS_BAR_LAYER_NAME)
                     .then()
-                    hidesLayer(STATUS_BAR_WINDOW_TITLE)
+                    hidesLayer(STATUS_BAR_LAYER_NAME)
                     .then()
-                    .showsLayer(STATUS_BAR_WINDOW_TITLE)
+                    .showsLayer(STATUS_BAR_LAYER_NAME)
         }
     } else {
         all("statusBarLayerIsAlwaysVisible", bugId, enabled) {
-            this.showsLayer(STATUS_BAR_WINDOW_TITLE)
+            this.showsLayer(STATUS_BAR_LAYER_NAME)
         }
     }
 }
@@ -196,15 +211,15 @@ fun LayersAssertionBuilder.navBarLayerRotatesAndScales(
     val endingPos = WindowUtils.getNavigationBarPosition(endRotation)
 
     start("navBarLayerRotatesAndScales_StartingPos", bugId, enabled) {
-        this.hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, startingPos)
+        this.hasVisibleRegion(NAV_BAR_LAYER_NAME, startingPos)
     }
     end("navBarLayerRotatesAndScales_EndingPost", bugId, enabled) {
-        this.hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, endingPos)
+        this.hasVisibleRegion(NAV_BAR_LAYER_NAME, endingPos)
     }
 
     if (startingPos == endingPos) {
         all("navBarLayerRotatesAndScales", enabled = false, bugId = 167747321) {
-            this.hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, startingPos)
+            this.hasVisibleRegion(NAV_BAR_LAYER_NAME, startingPos)
         }
     }
 }
@@ -220,10 +235,10 @@ fun LayersAssertionBuilder.statusBarLayerRotatesScales(
     val endingPos = WindowUtils.getStatusBarPosition(endRotation)
 
     start("statusBarLayerRotatesScales_StartingPos", bugId, enabled) {
-        this.hasVisibleRegion(STATUS_BAR_WINDOW_TITLE, startingPos)
+        this.hasVisibleRegion(STATUS_BAR_LAYER_NAME, startingPos)
     }
     end("statusBarLayerRotatesScales_EndingPos", bugId, enabled) {
-        this.hasVisibleRegion(STATUS_BAR_WINDOW_TITLE, endingPos)
+        this.hasVisibleRegion(STATUS_BAR_LAYER_NAME, endingPos)
     }
 }
 

tests/FlickerTests/src/com/android/server/wm/flicker/helpers/FlickerExtensions.kt

@@ -41,6 +41,9 @@ fun Flicker.setRotation(rotation: Int) {
         wmHelper.waitForRotation(rotation)
         wmHelper.waitForNavBarStatusBarVisible()
         wmHelper.waitForAppTransitionIdle()
+
+        // Ensure WindowManagerService wait until all animations have completed
+        instrumentation.getUiAutomation().syncInputTransactions()
     } catch (e: RemoteException) {
         throw RuntimeException(e)
     }