diff --git a/tests/FlickerTests/Android.bp b/tests/FlickerTests/Android.bp index d430db525f4c3..3b9bec9ad0a72 100644 --- a/tests/FlickerTests/Android.bp +++ b/tests/FlickerTests/Android.bp @@ -54,4 +54,18 @@ android_test { "launcher-aosp-tapl", "platform-test-annotations", ], +} + +java_library { + name: "wm-flicker-common-assertions", + platform_apis: true, + srcs: ["src/**/*Assertions.java", "src/**/*Assertions.kt"], + exclude_srcs: [ + "**/helpers/*", + ], + static_libs: [ + "flickerlib", + "truth-prebuilt", + "app-helpers-core" + ], } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/CommonAssertions.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/CommonAssertions.kt index 69b11872e1231..8457039e03994 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/CommonAssertions.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/CommonAssertions.kt @@ -21,13 +21,17 @@ import com.android.server.wm.flicker.dsl.LayersAssertion import com.android.server.wm.flicker.dsl.WmAssertion import com.android.server.wm.flicker.helpers.WindowUtils +const val NAVIGATION_BAR_WINDOW_TITLE = "NavigationBar" +const val STATUS_BAR_WINDOW_TITLE = "StatusBar" +const val DOCKED_STACK_DIVIDER = "DockedStackDivider" + @JvmOverloads fun WmAssertion.statusBarWindowIsAlwaysVisible( bugId: Int = 0, enabled: Boolean = bugId == 0 ) { all("statusBarWindowIsAlwaysVisible", enabled, bugId) { - this.showsAboveAppWindow(FlickerTestBase.STATUS_BAR_WINDOW_TITLE) + this.showsAboveAppWindow(STATUS_BAR_WINDOW_TITLE) } } @@ -37,7 +41,7 @@ fun WmAssertion.navBarWindowIsAlwaysVisible( enabled: Boolean = bugId == 0 ) { all("navBarWindowIsAlwaysVisible", enabled, bugId) { - this.showsAboveAppWindow(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE) + this.showsAboveAppWindow(NAVIGATION_BAR_WINDOW_TITLE) } } @@ -77,7 +81,7 @@ fun LayersAssertion.navBarLayerIsAlwaysVisible( enabled: Boolean = bugId == 0 ) { all("navBarLayerIsAlwaysVisible", enabled, bugId) { - this.showsLayer(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE) + this.showsLayer(NAVIGATION_BAR_WINDOW_TITLE) } } @@ -87,7 +91,7 @@ fun LayersAssertion.statusBarLayerIsAlwaysVisible( enabled: Boolean = bugId == 0 ) { all("statusBarLayerIsAlwaysVisible", enabled, bugId) { - this.showsLayer(FlickerTestBase.STATUS_BAR_WINDOW_TITLE) + this.showsLayer(STATUS_BAR_WINDOW_TITLE) } } @@ -102,15 +106,15 @@ fun LayersAssertion.navBarLayerRotatesAndScales( val endingPos = WindowUtils.getNavigationBarPosition(endRotation) start("navBarLayerRotatesAndScales_StartingPos", enabled, bugId) { - this.hasVisibleRegion(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE, startingPos) + this.hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, startingPos) } end("navBarLayerRotatesAndScales_EndingPost", enabled, bugId) { - this.hasVisibleRegion(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE, endingPos) + this.hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, endingPos) } if (startingPos == endingPos) { all("navBarLayerRotatesAndScales", enabled = false, bugId = 167747321) { - this.hasVisibleRegion(FlickerTestBase.NAVIGATION_BAR_WINDOW_TITLE, startingPos) + this.hasVisibleRegion(NAVIGATION_BAR_WINDOW_TITLE, startingPos) } } } @@ -126,10 +130,10 @@ fun LayersAssertion.statusBarLayerRotatesScales( val endingPos = WindowUtils.getStatusBarPosition(endRotation) start("statusBarLayerRotatesScales_StartingPos", enabled, bugId) { - this.hasVisibleRegion(FlickerTestBase.STATUS_BAR_WINDOW_TITLE, startingPos) + this.hasVisibleRegion(STATUS_BAR_WINDOW_TITLE, startingPos) } end("statusBarLayerRotatesScales_EndingPos", enabled, bugId) { - this.hasVisibleRegion(FlickerTestBase.STATUS_BAR_WINDOW_TITLE, endingPos) + this.hasVisibleRegion(STATUS_BAR_WINDOW_TITLE, endingPos) } } diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/FlickerTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/FlickerTestBase.kt deleted file mode 100644 index abe7dbc57002c..0000000000000 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/FlickerTestBase.kt +++ /dev/null @@ -1,129 +0,0 @@ -/* - * Copyright (C) 2020 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.android.server.wm.flicker - -import android.os.RemoteException -import android.os.SystemClock -import android.platform.helpers.IAppHelper -import android.view.Surface -import androidx.test.platform.app.InstrumentationRegistry -import androidx.test.uiautomator.UiDevice - -/** - * Base class of all Flicker test that performs common functions for all flicker tests: - * - * - * - Caches transitions so that a transition is run once and the transition results are used by - * tests multiple times. This is needed for parameterized tests which call the BeforeClass methods - * multiple times. - * - Keeps track of all test artifacts and deletes ones which do not need to be reviewed. - * - Fails tests if results are not available for any test due to jank. - */ -abstract class FlickerTestBase { - val instrumentation by lazy { - InstrumentationRegistry.getInstrumentation() - } - val uiDevice by lazy { - UiDevice.getInstance(instrumentation) - } - - /** - * Build a test tag for the test - * @param testName Name of the transition(s) being tested - * @param app App being launcher - * @param rotation Initial screen rotation - * - * @return test tag with pattern ____ - */ - protected fun buildTestTag(testName: String, app: IAppHelper, rotation: Int): String { - return buildTestTag( - testName, app, rotation, rotation, app2 = null, extraInfo = "") - } - - /** - * Build a test tag for the test - * @param testName Name of the transition(s) being tested - * @param app App being launcher - * @param beginRotation Initial screen rotation - * @param endRotation End screen rotation (if any, otherwise use same as initial) - * - * @return test tag with pattern ____- - */ - protected fun buildTestTag( - testName: String, - app: IAppHelper, - beginRotation: Int, - endRotation: Int - ): String { - return buildTestTag( - testName, app, beginRotation, endRotation, app2 = null, extraInfo = "") - } - - /** - * Build a test tag for the test - * @param testName Name of the transition(s) being tested - * @param app App being launcher - * @param app2 Second app being launched (if any) - * @param beginRotation Initial screen rotation - * @param endRotation End screen rotation (if any, otherwise use same as initial) - * @param extraInfo Additional information to append to the tag - * - * @return test tag with pattern __(S)>__(S)>[__] - */ - protected fun buildTestTag( - testName: String, - app: IAppHelper, - beginRotation: Int, - endRotation: Int, - app2: IAppHelper?, - extraInfo: String - ): String { - var testTag = "${testName}__${app.launcherName}" - if (app2 != null) { - testTag += "-${app2.launcherName}" - } - testTag += "__${Surface.rotationToString(beginRotation)}" - if (endRotation != beginRotation) { - testTag += "-${Surface.rotationToString(endRotation)}" - } - if (extraInfo.isNotEmpty()) { - testTag += "__$extraInfo" - } - return testTag - } - - protected fun Flicker.setRotation(rotation: Int) { - try { - when (rotation) { - Surface.ROTATION_270 -> device.setOrientationLeft() - Surface.ROTATION_90 -> device.setOrientationRight() - Surface.ROTATION_0 -> device.setOrientationNatural() - else -> device.setOrientationNatural() - } - // Wait for animation to complete - SystemClock.sleep(1000) - } catch (e: RemoteException) { - throw RuntimeException(e) - } - } - - companion object { - const val NAVIGATION_BAR_WINDOW_TITLE = "NavigationBar" - const val STATUS_BAR_WINDOW_TITLE = "StatusBar" - const val DOCKED_STACK_DIVIDER = "DockedStackDivider" - } -} \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/NonRotationTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/NonRotationTestBase.kt deleted file mode 100644 index e7d1f8e94dbad..0000000000000 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/NonRotationTestBase.kt +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Copyright (C) 2020 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.android.server.wm.flicker - -import android.view.Surface -import org.junit.runners.Parameterized - -abstract class NonRotationTestBase( - protected val rotationName: String, - protected val rotation: Int -) : FlickerTestBase() { - companion object { - const val SCREENSHOT_LAYER = "RotationLayer" - - @Parameterized.Parameters(name = "{0}") - @JvmStatic - fun getParams(): Collection> { - val supportedRotations = intArrayOf(Surface.ROTATION_0, Surface.ROTATION_90) - return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) } - } - } -} \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/RotationTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/RotationTestBase.kt deleted file mode 100644 index 3b67727790291..0000000000000 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/RotationTestBase.kt +++ /dev/null @@ -1,49 +0,0 @@ -/* - * Copyright (C) 2020 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.android.server.wm.flicker - -import android.view.Surface -import org.junit.runners.Parameterized - -abstract class RotationTestBase( - beginRotationName: String, - endRotationName: String, - protected val beginRotation: Int, - protected val endRotation: Int -) : FlickerTestBase() { - companion object { - @Parameterized.Parameters(name = "{0}-{1}") - @JvmStatic - fun getParams(): Collection> { - val supportedRotations = intArrayOf(Surface.ROTATION_0, Surface.ROTATION_90) - val params: MutableCollection> = mutableListOf() - for (begin in supportedRotations) { - for (end in supportedRotations) { - if (begin != end) { - params.add(arrayOf( - Surface.rotationToString(begin), - Surface.rotationToString(end), - begin, - end - )) - } - } - } - return params - } - } -} \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/FlickerExtensions.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/FlickerExtensions.kt new file mode 100644 index 0000000000000..742003a9438e0 --- /dev/null +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/helpers/FlickerExtensions.kt @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.wm.flicker.helpers + +import android.os.Bundle +import android.os.RemoteException +import android.os.SystemClock +import android.platform.helpers.IAppHelper +import android.view.Surface +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.endRotation +import com.android.server.wm.flicker.startRotation + +fun Flicker.setRotation(rotation: Int) { + try { + when (rotation) { + Surface.ROTATION_270 -> device.setOrientationLeft() + Surface.ROTATION_90 -> device.setOrientationRight() + Surface.ROTATION_0 -> device.setOrientationNatural() + else -> device.setOrientationNatural() + } + // Wait for animation to complete + SystemClock.sleep(1000) + } catch (e: RemoteException) { + throw RuntimeException(e) + } +} + +/** + * Build a test tag for the test + * @param testName Name of the transition(s) being tested + * @param app App being launcher + * @param beginRotation Initial screen rotation + * @param endRotation End screen rotation (if any, otherwise use same as initial) + * + * @return test tag with pattern ____- + */ +fun buildTestTag( + testName: String, + app: IAppHelper, + beginRotation: Int, + endRotation: Int +): String { + return buildTestTag( + testName, app.launcherName, beginRotation, endRotation, app2 = null, extraInfo = "") +} + +/** + * Build a test tag for the test + * @param testName Name of the transition(s) being tested + * @param app App being launcher + * @param rotation Screen rotation configuration for the test + * + * @return test tag with pattern ____- + */ +fun buildTestTag( + testName: String, + app: IAppHelper?, + configuration: Bundle +): String { + return buildTestTag(testName, app?.launcherName ?: "", configuration.startRotation, + configuration.endRotation, app2 = null, extraInfo = "") +} + +/** + * Build a test tag for the test + * @param testName Name of the transition(s) being tested + * @param app App being launcher + * @param app2 Second app being launched (if any) + * @param beginRotation Initial screen rotation + * @param endRotation End screen rotation (if any, otherwise use same as initial) + * @param extraInfo Additional information to append to the tag + * + * @return test tag with pattern __(S)>__(S)>[__] + */ +fun buildTestTag( + testName: String, + app: String, + beginRotation: Int, + endRotation: Int, + app2: String?, + extraInfo: String +): String { + var testTag = "${testName}__$app" + if (app2 != null) { + testTag += "-$app2" + } + testTag += "__${Surface.rotationToString(beginRotation)}" + if (endRotation != beginRotation) { + testTag += "-${Surface.rotationToString(endRotation)}" + } + if (extraInfo.isNotEmpty()) { + testTag += "__$extraInfo" + } + return testTag +} diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToAppTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToAppTest.kt index 404c7891bcad8..a73264d304f81 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToAppTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToAppTest.kt @@ -16,21 +16,27 @@ package com.android.server.wm.flicker.ime +import android.platform.test.annotations.Presubmit import android.view.Surface import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory import com.android.server.wm.flicker.helpers.ImeAppAutoFocusHelper -import com.android.server.wm.flicker.helpers.ImeAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -39,56 +45,62 @@ import org.junit.runners.Parameterized * Test IME window closing back to app window transitions. * To run this test: `atest FlickerTests:CloseImeWindowToAppTest` */ +@Presubmit @RequiresDevice @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class CloseImeAutoOpenWindowToAppTest( - rotationName: String, - rotation: Int -) : CloseImeWindowToAppTest(rotationName, rotation) { - override val testApp: ImeAppHelper - get() = ImeAppAutoFocusHelper(instrumentation) + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { - @Test - override fun test() { - flicker(instrumentation) { - withTag { buildTestTag("imeToAppAutoOpen", testApp, rotation) } - repeat { 1 } - setup { - eachRun { - device.wakeUpAndGoToHomeScreen() - this.setRotation(rotation) - testApp.open() - testApp.openIME(device) - } - } - teardown { - eachRun { - testApp.exit() - this.setRotation(Surface.ROTATION_0) - } - } - transitions { - device.pressBack() - device.waitForIdle() - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - imeAppWindowIsAlwaysVisible(testApp, bugId = 141458352) - } + companion object { + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = ImeAppAutoFocusHelper(instrumentation) - layersTrace { - navBarLayerIsAlwaysVisible() - statusBarLayerIsAlwaysVisible() - noUncoveredRegions(rotation) - navBarLayerRotatesAndScales(rotation) - statusBarLayerRotatesScales(rotation) - imeLayerBecomesInvisible(bugId = 141458352) - imeAppLayerIsAlwaysVisible(testApp, bugId = 141458352) + return FlickerTestRunnerFactory(instrumentation) + .buildTest { configuration -> + withTag { buildTestTag("imeToAppAutoOpen", testApp, configuration) } + repeat { configuration.repetitions } + setup { + eachRun { + device.wakeUpAndGoToHomeScreen() + this.setRotation(configuration.startRotation) + testApp.open() + testApp.openIME(device) + } + } + teardown { + eachRun { + testApp.exit() + this.setRotation(Surface.ROTATION_0) + } + } + transitions { + device.pressBack() + device.waitForIdle() + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + imeAppWindowIsAlwaysVisible(testApp, bugId = 141458352) + } + + layersTrace { + navBarLayerIsAlwaysVisible() + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.startRotation) + navBarLayerRotatesAndScales(configuration.startRotation) + statusBarLayerRotatesScales(configuration.startRotation) + imeLayerBecomesInvisible(bugId = 141458352) + imeAppLayerIsAlwaysVisible(testApp, bugId = 141458352) + } + } } - } } } -} +} \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToHomeTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToHomeTest.kt index c1ba21a2977a9..76478025ee631 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToHomeTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeAutoOpenWindowToHomeTest.kt @@ -19,19 +19,24 @@ package com.android.server.wm.flicker.ime import android.platform.test.annotations.Presubmit import android.view.Surface import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory import com.android.server.wm.flicker.helpers.ImeAppAutoFocusHelper -import com.android.server.wm.flicker.helpers.ImeAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -45,53 +50,63 @@ import org.junit.runners.Parameterized @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class CloseImeAutoOpenWindowToHomeTest( - rotationName: String, - rotation: Int -) : CloseImeWindowToHomeTest(rotationName, rotation) { - override val testApp: ImeAppHelper - get() = ImeAppAutoFocusHelper(instrumentation) + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { - @Test - override fun test() { - flicker(instrumentation) { - withTag { buildTestTag("imeToHomeAutoOpen", testApp, rotation) } - repeat { 1 } - setup { - eachRun { - device.wakeUpAndGoToHomeScreen() - this.setRotation(rotation) - testApp.open() - testApp.openIME(device) - } - } - teardown { - eachRun { - testApp.exit() - this.setRotation(Surface.ROTATION_0) - } - } - transitions { - device.pressHome() - device.waitForIdle() - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - imeWindowBecomesInvisible(bugId = 141458352) - imeAppWindowBecomesInvisible(testApp, bugId = 157449248) - } + companion object { + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = ImeAppAutoFocusHelper(instrumentation) - layersTrace { - navBarLayerIsAlwaysVisible(bugId = 140855415) - statusBarLayerIsAlwaysVisible(bugId = 140855415) - noUncoveredRegions(rotation, Surface.ROTATION_0, allStates = false) - navBarLayerRotatesAndScales(rotation, Surface.ROTATION_0, bugId = 140855415) - statusBarLayerRotatesScales(rotation, Surface.ROTATION_0) - imeLayerBecomesInvisible(bugId = 141458352) - imeAppLayerBecomesInvisible(testApp, bugId = 153739621) + return FlickerTestRunnerFactory(instrumentation) + .buildTest { configuration -> + withTestName { + buildTestTag("imeToHomeAutoOpen", testApp, configuration) + } + repeat { configuration.repetitions } + setup { + eachRun { + device.wakeUpAndGoToHomeScreen() + this.setRotation(configuration.startRotation) + testApp.open() + testApp.openIME(device) + } + } + teardown { + eachRun { + testApp.exit() + this.setRotation(Surface.ROTATION_0) + } + } + transitions { + device.pressHome() + device.waitForIdle() + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + imeWindowBecomesInvisible(bugId = 141458352) + imeAppWindowBecomesInvisible(testApp, bugId = 157449248) + } + + layersTrace { + navBarLayerIsAlwaysVisible(bugId = 140855415) + statusBarLayerIsAlwaysVisible(bugId = 140855415) + noUncoveredRegions(configuration.startRotation, Surface.ROTATION_0, + allStates = false) + navBarLayerRotatesAndScales(configuration.startRotation, + Surface.ROTATION_0, bugId = 140855415) + statusBarLayerRotatesScales(configuration.startRotation, + Surface.ROTATION_0) + imeLayerBecomesInvisible(bugId = 141458352) + imeAppLayerBecomesInvisible(testApp, bugId = 153739621) + } + } } - } } } } diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToAppTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToAppTest.kt index 2c00722703788..136cf86037a1f 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToAppTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToAppTest.kt @@ -19,19 +19,24 @@ package com.android.server.wm.flicker.ime import android.platform.test.annotations.Presubmit import android.view.Surface import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.NonRotationTestBase -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory import com.android.server.wm.flicker.helpers.ImeAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -44,52 +49,57 @@ import org.junit.runners.Parameterized @RequiresDevice @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) -open class CloseImeWindowToAppTest( - rotationName: String, - rotation: Int -) : NonRotationTestBase(rotationName, rotation) { - open val testApp = ImeAppHelper(instrumentation) +class CloseImeWindowToAppTest( + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { - @Test - open fun test() { - flicker(instrumentation) { - withTag { buildTestTag("imeToApp", testApp, rotation) } - repeat { 1 } - setup { - eachRun { - device.wakeUpAndGoToHomeScreen() - this.setRotation(rotation) - testApp.open() - testApp.openIME(device) - } - } - teardown { - eachRun { - testApp.exit() - this.setRotation(Surface.ROTATION_0) - } - } - transitions { - device.pressBack() - device.waitForIdle() - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - imeAppWindowIsAlwaysVisible(testApp) - } + companion object { + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = ImeAppHelper(instrumentation) + return FlickerTestRunnerFactory(instrumentation) + .buildTest { configuration -> + withTestName { buildTestTag("imeToApp", testApp, configuration) } + repeat { configuration.repetitions } + setup { + eachRun { + device.wakeUpAndGoToHomeScreen() + this.setRotation(configuration.startRotation) + testApp.open() + testApp.openIME(device) + } + } + teardown { + eachRun { + testApp.exit() + this.setRotation(Surface.ROTATION_0) + } + } + transitions { + device.pressBack() + device.waitForIdle() + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + imeAppWindowIsAlwaysVisible(testApp) + } - layersTrace { - navBarLayerIsAlwaysVisible() - statusBarLayerIsAlwaysVisible() - noUncoveredRegions(rotation) - navBarLayerRotatesAndScales(rotation) - statusBarLayerRotatesScales(rotation) - imeLayerBecomesInvisible(enabled = false) - imeAppLayerIsAlwaysVisible(testApp) + layersTrace { + navBarLayerIsAlwaysVisible() + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.startRotation) + navBarLayerRotatesAndScales(configuration.startRotation) + statusBarLayerRotatesScales(configuration.startRotation) + imeLayerBecomesInvisible(enabled = false) + imeAppLayerIsAlwaysVisible(testApp) + } + } } - } } } } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToHomeTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToHomeTest.kt index 4697adcbce80f..6cfb28202b39c 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToHomeTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CloseImeWindowToHomeTest.kt @@ -19,21 +19,26 @@ package com.android.server.wm.flicker.ime import android.platform.test.annotations.Presubmit import android.view.Surface import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.NonRotationTestBase -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory import com.android.server.wm.flicker.helpers.ImeAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag import com.android.server.wm.flicker.helpers.openQuickstep import com.android.server.wm.flicker.helpers.reopenAppFromOverview +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -45,61 +50,69 @@ import org.junit.runners.Parameterized @RequiresDevice @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) -open class CloseImeWindowToHomeTest( - rotationName: String, - rotation: Int -) : NonRotationTestBase(rotationName, rotation) { - open val testApp = ImeAppHelper(instrumentation) +class CloseImeWindowToHomeTest( + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { - @Test - open fun test() { - flicker(instrumentation) { - withTag { buildTestTag("imeToHome", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - this.setRotation(rotation) - testApp.open() - } - eachRun { - device.openQuickstep() - device.reopenAppFromOverview() - this.setRotation(rotation) - testApp.openIME(device) - } - } - transitions { - device.pressHome() - device.waitForIdle() - } - teardown { - eachRun { - device.pressHome() - } - test { - testApp.exit() - this.setRotation(Surface.ROTATION_0) - } - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - imeWindowBecomesInvisible() - imeAppWindowBecomesInvisible(testApp) - } + companion object { + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = ImeAppHelper(instrumentation) + return FlickerTestRunnerFactory(instrumentation) + .buildTest { configuration -> + withTestName { buildTestTag("imeToHome", testApp, configuration) } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + this.setRotation(configuration.startRotation) + testApp.open() + } + eachRun { + device.openQuickstep() + device.reopenAppFromOverview() + this.setRotation(configuration.startRotation) + testApp.openIME(device) + } + } + transitions { + device.pressHome() + device.waitForIdle() + } + teardown { + eachRun { + device.pressHome() + } + test { + testApp.exit() + this.setRotation(Surface.ROTATION_0) + } + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + imeWindowBecomesInvisible() + imeAppWindowBecomesInvisible(testApp) + } - layersTrace { - navBarLayerIsAlwaysVisible(bugId = 140855415) - statusBarLayerIsAlwaysVisible(bugId = 140855415) - noUncoveredRegions(rotation, Surface.ROTATION_0, allStates = false) - navBarLayerRotatesAndScales(rotation, Surface.ROTATION_0, bugId = 140855415) - statusBarLayerRotatesScales(rotation, Surface.ROTATION_0) - imeLayerBecomesInvisible(bugId = 153739621) - imeAppLayerBecomesInvisible(testApp, bugId = 153739621) + layersTrace { + navBarLayerIsAlwaysVisible(bugId = 140855415) + statusBarLayerIsAlwaysVisible(bugId = 140855415) + noUncoveredRegions(configuration.startRotation, + Surface.ROTATION_0, allStates = false) + navBarLayerRotatesAndScales(configuration.startRotation, + Surface.ROTATION_0, bugId = 140855415) + statusBarLayerRotatesScales(configuration.startRotation, + Surface.ROTATION_0) + imeLayerBecomesInvisible(bugId = 153739621) + imeAppLayerBecomesInvisible(testApp, bugId = 153739621) + } + } } - } } } } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/ImeAssertions.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/CommonAssertions.kt similarity index 100% rename from tests/FlickerTests/src/com/android/server/wm/flicker/ime/ImeAssertions.kt rename to tests/FlickerTests/src/com/android/server/wm/flicker/ime/CommonAssertions.kt diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/OpenImeWindowTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/OpenImeWindowTest.kt index 2caa8f399be76..5767a94025e9f 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/ime/OpenImeWindowTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/ime/OpenImeWindowTest.kt @@ -19,19 +19,24 @@ package com.android.server.wm.flicker.ime import android.platform.test.annotations.Presubmit import android.view.Surface import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.NonRotationTestBase -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory import com.android.server.wm.flicker.helpers.ImeAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -45,62 +50,65 @@ import org.junit.runners.Parameterized @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class OpenImeWindowTest( - rotationName: String, - rotation: Int -) : NonRotationTestBase(rotationName, rotation) { - @Test - fun test() { - val testApp = ImeAppHelper(instrumentation) - - flicker(instrumentation) { - withTag { buildTestTag("openIme", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - this.setRotation(rotation) - testApp.open() - } - } - transitions { - testApp.openIME(device) - } - teardown { - eachRun { - testApp.closeIME(device) - } - test { - testApp.exit() - this.setRotation(Surface.ROTATION_0) - } - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - - all("imeWindowBecomesVisible") { - this.skipUntilFirstAssertion() - .hidesNonAppWindow(IME_WINDOW_TITLE) - .then() - .showsNonAppWindow(IME_WINDOW_TITLE) - } - } - - layersTrace { - navBarLayerIsAlwaysVisible() - statusBarLayerIsAlwaysVisible() - noUncoveredRegions(rotation) - navBarLayerRotatesAndScales(rotation) - statusBarLayerRotatesScales(rotation) - - imeLayerBecomesVisible() - } - } - } - } - + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { companion object { private const val IME_WINDOW_TITLE = "InputMethod" + + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = ImeAppHelper(instrumentation) + + return FlickerTestRunnerFactory(instrumentation) + .buildTest { configuration -> + withTestName { buildTestTag("openIme", testApp, configuration) } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + this.setRotation(configuration.startRotation) + testApp.open() + } + } + transitions { + testApp.openIME(device) + } + teardown { + eachRun { + testApp.closeIME(device) + } + test { + testApp.exit() + this.setRotation(Surface.ROTATION_0) + } + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + + all("imeWindowBecomesVisible") { + this.skipUntilFirstAssertion() + .hidesNonAppWindow(IME_WINDOW_TITLE) + .then() + .showsNonAppWindow(IME_WINDOW_TITLE) + } + } + + layersTrace { + navBarLayerIsAlwaysVisible() + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.startRotation) + navBarLayerRotatesAndScales(configuration.startRotation) + statusBarLayerRotatesScales(configuration.startRotation) + + imeLayerBecomesVisible() + } + } + } + } } } diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/CommonAssertions.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/CommonAssertions.kt new file mode 100644 index 0000000000000..7e857f3b56c0c --- /dev/null +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/CommonAssertions.kt @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.wm.flicker.launch + +import android.platform.helpers.IAppHelper +import com.android.server.wm.flicker.dsl.LayersAssertion +import com.android.server.wm.flicker.dsl.WmAssertion + +fun WmAssertion.wallpaperWindowBecomesInvisible( + bugId: Int = 0, + enabled: Boolean = bugId == 0 +) { + all("wallpaperWindowBecomesInvisible", enabled, bugId) { + this.showsBelowAppWindow("Wallpaper") + .then() + .hidesBelowAppWindow("Wallpaper") + } +} + +fun WmAssertion.appWindowReplacesLauncherAsTopWindow( + testApp: IAppHelper, + bugId: Int = 0, + enabled: Boolean = bugId == 0 +) { + all("appWindowReplacesLauncherAsTopWindow", enabled, bugId) { + this.showsAppWindowOnTop("Launcher") + .then() + .showsAppWindowOnTop("Snapshot", testApp.getPackage()) + } +} + +fun LayersAssertion.wallpaperLayerBecomesInvisible( + testApp: IAppHelper, + bugId: Int = 0, + enabled: Boolean = bugId == 0 +) { + all("wallpaperLayerBecomesInvisible", enabled, bugId) { + this.showsLayer("Wallpaper") + .then() + .replaceVisibleLayer("Wallpaper", testApp.getPackage()) + } +} \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppColdTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppColdTest.kt index 2c9c8ba75a109..1081414e9b6bc 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppColdTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppColdTest.kt @@ -19,18 +19,26 @@ package com.android.server.wm.flicker.launch import android.platform.test.annotations.Presubmit import android.view.Surface import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunnerFactory +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.endRotation import com.android.server.wm.flicker.focusChanges +import com.android.server.wm.flicker.helpers.StandardAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -44,53 +52,64 @@ import org.junit.runners.Parameterized @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class OpenAppColdTest( - rotationName: String, - rotation: Int -) : OpenAppTestBase(rotationName, rotation) { - @Test - fun test() { - flicker(instrumentation) { - withTag { buildTestTag("openAppCold", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - } - eachRun { - this.setRotation(rotation) - } - } - transitions { - testApp.open() - } - teardown { - eachRun { - testApp.exit() - this.setRotation(Surface.ROTATION_0) - } - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - appWindowReplacesLauncherAsTopWindow() - wallpaperWindowBecomesInvisible() - } + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { + companion object { + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = StandardAppHelper(instrumentation, + "com.android.server.wm.flicker.testapp", "SimpleApp") + return FlickerTestRunnerFactory(instrumentation) + .buildTest { configuration -> + withTag { buildTestTag("openAppCold", testApp, configuration) } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + } + eachRun { + this.setRotation(configuration.startRotation) + } + } + transitions { + testApp.open() + } + teardown { + eachRun { + testApp.exit() + this.setRotation(Surface.ROTATION_0) + } + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + appWindowReplacesLauncherAsTopWindow(testApp) + wallpaperWindowBecomesInvisible() + } - layersTrace { - // During testing the launcher is always in portrait mode - noUncoveredRegions(Surface.ROTATION_0, rotation, bugId = 141361128) - navBarLayerRotatesAndScales(Surface.ROTATION_0, rotation) - statusBarLayerRotatesScales(Surface.ROTATION_0, rotation) - navBarLayerIsAlwaysVisible(enabled = rotation == Surface.ROTATION_0) - statusBarLayerIsAlwaysVisible(enabled = false) - wallpaperLayerBecomesInvisible() - } + layersTrace { + // During testing the launcher is always in portrait mode + noUncoveredRegions(Surface.ROTATION_0, configuration.endRotation, + bugId = 141361128) + navBarLayerRotatesAndScales(Surface.ROTATION_0, + configuration.endRotation) + statusBarLayerRotatesScales(Surface.ROTATION_0, + configuration.endRotation) + navBarLayerIsAlwaysVisible( + enabled = configuration.endRotation == Surface.ROTATION_0) + statusBarLayerIsAlwaysVisible(enabled = false) + wallpaperLayerBecomesInvisible(testApp) + } - eventLog { - focusChanges("NexusLauncherActivity", testApp.`package`) + eventLog { + focusChanges("NexusLauncherActivity", testApp.`package`) + } + } } - } } } } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppTestBase.kt deleted file mode 100644 index 98e05d526bedf..0000000000000 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppTestBase.kt +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (C) 2020 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.android.server.wm.flicker.launch - -import com.android.server.wm.flicker.NonRotationTestBase -import com.android.server.wm.flicker.helpers.StandardAppHelper -import com.android.server.wm.flicker.dsl.LayersAssertion -import com.android.server.wm.flicker.dsl.WmAssertion - -abstract class OpenAppTestBase( - rotationName: String, - rotation: Int -) : NonRotationTestBase(rotationName, rotation) { - protected val testApp = StandardAppHelper(instrumentation, - "com.android.server.wm.flicker.testapp", "SimpleApp") - - protected fun WmAssertion.wallpaperWindowBecomesInvisible( - bugId: Int = 0, - enabled: Boolean = bugId == 0 - ) { - all("wallpaperWindowBecomesInvisible", enabled, bugId) { - this.showsBelowAppWindow("Wallpaper") - .then() - .hidesBelowAppWindow("Wallpaper") - } - } - - protected fun WmAssertion.appWindowReplacesLauncherAsTopWindow( - bugId: Int = 0, - enabled: Boolean = bugId == 0 - ) { - all("appWindowReplacesLauncherAsTopWindow", enabled, bugId) { - this.showsAppWindowOnTop("Launcher") - .then() - .showsAppWindowOnTop("Snapshot", testApp.getPackage()) - } - } - - protected fun LayersAssertion.wallpaperLayerBecomesInvisible( - bugId: Int = 0, - enabled: Boolean = bugId == 0 - ) { - all("appWindowReplacesLauncherAsTopWindow", enabled, bugId) { - this.showsLayer("Wallpaper") - .then() - .replaceVisibleLayer("Wallpaper", testApp.getPackage()) - } - } -} \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppWarmTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppWarmTest.kt index acd141a8d74f5..2061994b57b14 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppWarmTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/launch/OpenAppWarmTest.kt @@ -16,21 +16,29 @@ package com.android.server.wm.flicker.launch +import android.platform.test.annotations.Presubmit import android.view.Surface import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.helpers.StandardAppHelper -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunnerFactory +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.endRotation import com.android.server.wm.flicker.focusChanges +import com.android.server.wm.flicker.helpers.StandardAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -39,64 +47,73 @@ import org.junit.runners.Parameterized * Test warm launch app. * To run this test: `atest FlickerTests:OpenAppWarmTest` */ +@Presubmit @RequiresDevice @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class OpenAppWarmTest( - rotationName: String, - rotation: Int -) : OpenAppTestBase(rotationName, rotation) { - @Test - fun test() { - val testApp = StandardAppHelper(instrumentation, + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { + companion object { + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = StandardAppHelper(instrumentation, "com.android.server.wm.flicker.testapp", "SimpleApp") + return FlickerTestRunnerFactory(instrumentation) + .buildTest { configuration -> + withTag { buildTestTag("openAppWarm", testApp, configuration) } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + testApp.open() + } + eachRun { + device.pressHome() + this.setRotation(configuration.startRotation) + } + } + transitions { + testApp.open() + } + teardown { + eachRun { + this.setRotation(Surface.ROTATION_0) + } + test { + testApp.exit() + } + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + appWindowReplacesLauncherAsTopWindow(testApp) + wallpaperWindowBecomesInvisible(enabled = false) + } - flicker(instrumentation) { - withTag { buildTestTag("openAppWarm", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - testApp.open() - } - eachRun { - device.pressHome() - this.setRotation(rotation) - } - } - transitions { - testApp.open() - } - teardown { - eachRun { - this.setRotation(Surface.ROTATION_0) - } - test { - testApp.exit() - } - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - appWindowReplacesLauncherAsTopWindow() - wallpaperWindowBecomesInvisible(enabled = false) - } + layersTrace { + // During testing the launcher is always in portrait mode + noUncoveredRegions(Surface.ROTATION_0, configuration.endRotation, + bugId = 141361128) + navBarLayerRotatesAndScales(Surface.ROTATION_0, + configuration.endRotation) + statusBarLayerRotatesScales(Surface.ROTATION_0, + configuration.endRotation) + navBarLayerIsAlwaysVisible( + enabled = configuration.endRotation == Surface.ROTATION_0) + statusBarLayerIsAlwaysVisible(enabled = false) + wallpaperLayerBecomesInvisible(testApp) + } - layersTrace { - // During testing the launcher is always in portrait mode - noUncoveredRegions(Surface.ROTATION_0, rotation, bugId = 141361128) - navBarLayerRotatesAndScales(Surface.ROTATION_0, rotation) - statusBarLayerRotatesScales(Surface.ROTATION_0, rotation) - navBarLayerIsAlwaysVisible(enabled = rotation == Surface.ROTATION_0) - statusBarLayerIsAlwaysVisible(enabled = false) - wallpaperLayerBecomesInvisible() + eventLog { + focusChanges("NexusLauncherActivity", testApp.`package`) + } + } } - - eventLog { - focusChanges("NexusLauncherActivity", testApp.`package`) - } - } } } } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipTestBase.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/CommonAssertions.kt similarity index 63% rename from tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipTestBase.kt rename to tests/FlickerTests/src/com/android/server/wm/flicker/pip/CommonAssertions.kt index 691db7fbac5c0..6bc9dcb5d96ce 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipTestBase.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/CommonAssertions.kt @@ -16,16 +16,4 @@ package com.android.server.wm.flicker.pip -import com.android.server.wm.flicker.NonRotationTestBase -import com.android.server.wm.flicker.helpers.PipAppHelper - -abstract class PipTestBase( - rotationName: String, - rotation: Int -) : NonRotationTestBase(rotationName, rotation) { - protected val testApp = PipAppHelper(instrumentation) - - companion object { - const val sPipWindowTitle = "PipMenuActivity" - } -} \ No newline at end of file +internal const val PIP_WINDOW_TITLE = "PipMenuActivity" diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/EnterPipTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/EnterPipTest.kt index 9cfc03304fe7d..89539fd1a9eca 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/EnterPipTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/EnterPipTest.kt @@ -16,23 +16,31 @@ package com.android.server.wm.flicker.pip +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.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory +import com.android.server.wm.flicker.helpers.PipAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag import com.android.server.wm.flicker.helpers.closePipWindow import com.android.server.wm.flicker.helpers.expandPipWindow import com.android.server.wm.flicker.helpers.hasPipWindow +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -41,81 +49,85 @@ import org.junit.runners.Parameterized * Test Pip launch. * To run this test: `atest FlickerTests:PipToAppTest` */ +@Presubmit @RequiresDevice @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) @FlakyTest(bugId = 152738416) class EnterPipTest( - rotationName: String, - rotation: Int -) : PipTestBase(rotationName, rotation) { - @Test - fun test() { - flicker(instrumentation) { - withTag { buildTestTag("enterPip", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - } - eachRun { - device.pressHome() - testApp.open() - this.setRotation(rotation) - } - } - teardown { - eachRun { - if (device.hasPipWindow()) { - device.closePipWindow() - } - testApp.exit() - this.setRotation(Surface.ROTATION_0) - } - test { - if (device.hasPipWindow()) { - device.closePipWindow() - } - } - } - transitions { - testApp.clickEnterPipButton(device) - device.expandPipWindow() - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - all("pipWindowBecomesVisible") { - this.showsAppWindow(testApp.`package`) - .then() - .showsAppWindow(sPipWindowTitle) - } - } - - layersTrace { - navBarLayerIsAlwaysVisible() - statusBarLayerIsAlwaysVisible() - noUncoveredRegions(rotation, Surface.ROTATION_0, allStates = false) - navBarLayerRotatesAndScales(rotation, Surface.ROTATION_0) - statusBarLayerRotatesScales(rotation, Surface.ROTATION_0) - - all("pipLayerBecomesVisible") { - this.showsLayer(testApp.launcherName) - .then() - .showsLayer(sPipWindowTitle) - } - } - } - } - } - + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { companion object { @Parameterized.Parameters(name = "{0}") @JvmStatic - fun getParams(): Collection> { - val supportedRotations = intArrayOf(Surface.ROTATION_0) - return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) } + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = PipAppHelper(instrumentation) + return FlickerTestRunnerFactory(instrumentation, listOf(Surface.ROTATION_0)) + .buildTest { configuration -> + withTestName { buildTestTag("enterPip", testApp, configuration) } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + } + eachRun { + device.pressHome() + testApp.open() + this.setRotation(configuration.startRotation) + } + } + teardown { + eachRun { + if (device.hasPipWindow()) { + device.closePipWindow() + } + testApp.exit() + this.setRotation(Surface.ROTATION_0) + } + test { + if (device.hasPipWindow()) { + device.closePipWindow() + } + } + } + transitions { + testApp.clickEnterPipButton(device) + device.expandPipWindow() + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + + all("pipWindowBecomesVisible") { + this.showsAppWindow(testApp.`package`) + .then() + .showsAppWindow(PIP_WINDOW_TITLE) + } + } + + layersTrace { + navBarLayerIsAlwaysVisible(bugId = 140855415) + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.startRotation, Surface.ROTATION_0, + enabled = false) + navBarLayerRotatesAndScales(configuration.startRotation, + Surface.ROTATION_0, bugId = 140855415) + statusBarLayerRotatesScales(configuration.startRotation, + Surface.ROTATION_0) + } + + layersTrace { + all("pipLayerBecomesVisible") { + this.showsLayer(testApp.launcherName) + .then() + .showsLayer(PIP_WINDOW_TITLE) + } + } + } + } } } } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToAppTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToAppTest.kt index deccc908961d6..ac54a0a29350c 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToAppTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToAppTest.kt @@ -19,21 +19,28 @@ package com.android.server.wm.flicker.pip import android.view.Surface import androidx.test.filters.FlakyTest import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory import com.android.server.wm.flicker.focusChanges +import com.android.server.wm.flicker.helpers.PipAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag import com.android.server.wm.flicker.helpers.closePipWindow import com.android.server.wm.flicker.helpers.expandPipWindow import com.android.server.wm.flicker.helpers.hasPipWindow +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -47,73 +54,82 @@ import org.junit.runners.Parameterized @FixMethodOrder(MethodSorters.NAME_ASCENDING) @FlakyTest(bugId = 152738416) class PipToAppTest( - rotationName: String, - rotation: Int -) : PipTestBase(rotationName, rotation) { - @Test - fun test() { - flicker(instrumentation) { - withTag { buildTestTag("exitPipModeToApp", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - device.pressHome() - testApp.open() - } - eachRun { - this.setRotation(rotation) - testApp.clickEnterPipButton(device) - device.hasPipWindow() - } - } - teardown { - eachRun { - this.setRotation(Surface.ROTATION_0) - } - test { - if (device.hasPipWindow()) { - device.closePipWindow() + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { + companion object { + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = PipAppHelper(instrumentation) + return FlickerTestRunnerFactory(instrumentation, listOf(Surface.ROTATION_0)) + .buildTest { configuration -> + withTestName { buildTestTag("exitPipModeToApp", testApp, configuration) } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + device.pressHome() + testApp.open() + } + eachRun { + this.setRotation(configuration.startRotation) + testApp.clickEnterPipButton(device) + device.hasPipWindow() + } } - testApp.exit() - } - } - transitions { - device.expandPipWindow() - device.waitForIdle() - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() + teardown { + eachRun { + this.setRotation(Surface.ROTATION_0) + } + test { + if (device.hasPipWindow()) { + device.closePipWindow() + } + testApp.exit() + } + } + transitions { + device.expandPipWindow() + device.waitForIdle() + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() - all("appReplacesPipWindow") { - this.showsAppWindow(sPipWindowTitle) - .then() - .showsAppWindowOnTop(testApp.launcherName) + all("appReplacesPipWindow") { + this.showsAppWindow(PIP_WINDOW_TITLE) + .then() + .showsAppWindowOnTop(testApp.launcherName) + } + } + + layersTrace { + navBarLayerIsAlwaysVisible(bugId = 140855415) + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.startRotation, Surface.ROTATION_0, + enabled = false) + navBarLayerRotatesAndScales(configuration.startRotation, + Surface.ROTATION_0, bugId = 140855415) + statusBarLayerRotatesScales(configuration.startRotation, + Surface.ROTATION_0) + + all("appReplacesPipLayer") { + this.showsLayer(PIP_WINDOW_TITLE) + .then() + .showsLayer(testApp.launcherName) + } + } + + eventLog { + focusChanges( + "NexusLauncherActivity", testApp.launcherName, + "NexusLauncherActivity", bugId = 151179149) + } } } - - layersTrace { - navBarLayerIsAlwaysVisible() - statusBarLayerIsAlwaysVisible() - noUncoveredRegions(rotation) - navBarLayerRotatesAndScales(rotation) - statusBarLayerRotatesScales(rotation) - - all("appReplacesPipLayer") { - this.showsLayer(sPipWindowTitle) - .then() - .showsLayer(testApp.launcherName) - } - } - - eventLog { - focusChanges( - "NexusLauncherActivity", testApp.launcherName, "NexusLauncherActivity", - bugId = 151179149) - } - } } } } diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToHomeTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToHomeTest.kt index f40869c88d632..f14a27d31ad11 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToHomeTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/pip/PipToHomeTest.kt @@ -19,20 +19,27 @@ package com.android.server.wm.flicker.pip import android.view.Surface import androidx.test.filters.FlakyTest import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory import com.android.server.wm.flicker.focusChanges +import com.android.server.wm.flicker.helpers.PipAppHelper +import com.android.server.wm.flicker.helpers.buildTestTag import com.android.server.wm.flicker.helpers.closePipWindow import com.android.server.wm.flicker.helpers.hasPipWindow +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -46,83 +53,83 @@ import org.junit.runners.Parameterized @FixMethodOrder(MethodSorters.NAME_ASCENDING) @FlakyTest(bugId = 152738416) class PipToHomeTest( - rotationName: String, - rotation: Int -) : PipTestBase(rotationName, rotation) { - @Test - fun test() { - flicker(instrumentation) { - withTag { buildTestTag("exitPipModeToApp", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - device.pressHome() - } - eachRun { - testApp.open() - this.setRotation(rotation) - testApp.clickEnterPipButton(device) - device.hasPipWindow() - } - } - teardown { - eachRun { - this.setRotation(Surface.ROTATION_0) - if (device.hasPipWindow()) { - device.closePipWindow() - } - } - test { - if (device.hasPipWindow()) { - device.closePipWindow() - } - testApp.exit() - } - } - transitions { - testApp.closePipWindow(device) - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - - all("pipWindowBecomesInvisible") { - this.showsAppWindow(sPipWindowTitle) - .then() - .hidesAppWindow(sPipWindowTitle) - } - } - - layersTrace { - navBarLayerIsAlwaysVisible() - statusBarLayerIsAlwaysVisible() - // The final state is the launcher, so always in portrait mode - noUncoveredRegions(rotation, Surface.ROTATION_0, allStates = false) - navBarLayerRotatesAndScales(rotation) - statusBarLayerRotatesScales(rotation) - - all("pipLayerBecomesInvisible") { - this.showsLayer(sPipWindowTitle) - .then() - .hidesLayer(sPipWindowTitle) - } - } - - eventLog { - focusChanges(testApp.launcherName, "NexusLauncherActivity", bugId = 151179149) - } - } - } - } - + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { companion object { @Parameterized.Parameters(name = "{0}") @JvmStatic - fun getParams(): Collection> { - val supportedRotations = intArrayOf(Surface.ROTATION_0) - return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) } + fun getParams(): List> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = PipAppHelper(instrumentation) + return FlickerTestRunnerFactory(instrumentation, listOf(Surface.ROTATION_0)) + .buildTest { configuration -> + withTestName { buildTestTag("exitPipModeToApp", testApp, configuration) } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + device.pressHome() + } + eachRun { + testApp.open() + this.setRotation(configuration.startRotation) + testApp.clickEnterPipButton(device) + device.hasPipWindow() + } + } + teardown { + eachRun { + this.setRotation(Surface.ROTATION_0) + if (device.hasPipWindow()) { + device.closePipWindow() + } + } + test { + if (device.hasPipWindow()) { + device.closePipWindow() + } + testApp.exit() + } + } + transitions { + testApp.closePipWindow(device) + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + + all("pipWindowBecomesInvisible") { + this.showsAppWindow(PIP_WINDOW_TITLE) + .then() + .hidesAppWindow(PIP_WINDOW_TITLE) + } + } + + layersTrace { + navBarLayerIsAlwaysVisible(bugId = 140855415) + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.startRotation, Surface.ROTATION_0, + enabled = false) + navBarLayerRotatesAndScales(configuration.startRotation, + Surface.ROTATION_0, bugId = 140855415) + statusBarLayerRotatesScales(configuration.startRotation, + Surface.ROTATION_0) + + all("pipLayerBecomesInvisible") { + this.showsLayer(PIP_WINDOW_TITLE) + .then() + .hidesLayer(PIP_WINDOW_TITLE) + } + } + + eventLog { + focusChanges(testApp.launcherName, "NexusLauncherActivity", + bugId = 151179149) + } + } + } } } } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/ChangeAppRotationTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/ChangeAppRotationTest.kt index 99218c2c586dc..24ca31164ac97 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/ChangeAppRotationTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/ChangeAppRotationTest.kt @@ -16,24 +16,30 @@ package com.android.server.wm.flicker.rotation +import android.platform.test.annotations.Presubmit import androidx.test.filters.RequiresDevice import android.view.Surface -import com.android.server.wm.flicker.NonRotationTestBase.Companion.SCREENSHOT_LAYER -import com.android.server.wm.flicker.RotationTestBase -import com.android.server.wm.flicker.helpers.StandardAppHelper -import com.android.server.wm.flicker.dsl.flicker +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.Flicker +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.focusDoesNotChange +import com.android.server.wm.flicker.helpers.StandardAppHelper import com.android.server.wm.flicker.helpers.WindowUtils +import com.android.server.wm.flicker.helpers.setRotation +import com.android.server.wm.flicker.helpers.buildTestTag import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -42,84 +48,95 @@ import org.junit.runners.Parameterized * Cycle through supported app rotations. * To run this test: `atest FlickerTest:ChangeAppRotationTest` */ +@Presubmit @RequiresDevice @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class ChangeAppRotationTest( - beginRotationName: String, - endRotationName: String, - beginRotation: Int, - endRotation: Int -) : RotationTestBase(beginRotationName, endRotationName, beginRotation, endRotation) { - @Test - fun test() { - val testApp = StandardAppHelper(instrumentation, + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { + companion object { + private const val SCREENSHOT_LAYER = "RotationLayer" + + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): Collection> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = StandardAppHelper(instrumentation, "com.android.server.wm.flicker.testapp", "SimpleApp") - - flicker(instrumentation) { - withTag { - buildTestTag("changeAppRotation", testApp, beginRotation, endRotation) - } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - testApp.open() - } - eachRun { - this.setRotation(beginRotation) - } - } - teardown { - eachRun { - this.setRotation(Surface.ROTATION_0) - } - test { - testApp.exit() - } - } - transitions { - this.setRotation(endRotation) - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - } - - layersTrace { - navBarLayerIsAlwaysVisible(bugId = 140855415) - statusBarLayerIsAlwaysVisible(bugId = 140855415) - noUncoveredRegions(beginRotation, endRotation, allStates = false) - navBarLayerRotatesAndScales(beginRotation, endRotation) - statusBarLayerRotatesScales(beginRotation, endRotation) - } - - layersTrace { - val startingPos = WindowUtils.getDisplayBounds(beginRotation) - val endingPos = WindowUtils.getDisplayBounds(endRotation) - - start("appLayerRotates_StartingPos") { - this.hasVisibleRegion(testApp.getPackage(), startingPos) + return FlickerTestRunnerFactory(instrumentation) + .buildRotationTest { configuration -> + withTestName { + buildTestTag( + "changeAppRotation", testApp, configuration) } - - end("appLayerRotates_EndingPos") { - this.hasVisibleRegion(testApp.getPackage(), endingPos) + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + testApp.open() + } + eachRun { + this.setRotation(configuration.startRotation) + } } + teardown { + eachRun { + this.setRotation(Surface.ROTATION_0) + } + test { + testApp.exit() + } + } + transitions { + this.setRotation(configuration.endRotation) + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + } - all("screenshotLayerBecomesInvisible") { - this.showsLayer(testApp.getPackage()) - .then() - .showsLayer(SCREENSHOT_LAYER) - .then() + layersTrace { + navBarLayerIsAlwaysVisible(bugId = 140855415) + statusBarLayerIsAlwaysVisible(bugId = 140855415) + noUncoveredRegions(configuration.startRotation, + configuration.endRotation, allStates = false) + navBarLayerRotatesAndScales(configuration.startRotation, + configuration.endRotation) + statusBarLayerRotatesScales(configuration.startRotation, + configuration.endRotation) + } + + layersTrace { + val startingPos = WindowUtils.getDisplayBounds( + configuration.startRotation) + val endingPos = WindowUtils.getDisplayBounds( + configuration.endRotation) + + start("appLayerRotates_StartingPos") { + this.hasVisibleRegion(testApp.getPackage(), startingPos) + } + + end("appLayerRotates_EndingPos") { + this.hasVisibleRegion(testApp.getPackage(), endingPos) + } + + all("screenshotLayerBecomesInvisible") { + this.showsLayer(testApp.getPackage()) + .then() + .showsLayer(SCREENSHOT_LAYER) + .then() showsLayer(testApp.getPackage()) + } + } + + eventLog { + focusDoesNotChange(bugId = 151179149) + } } } - - eventLog { - focusDoesNotChange(bugId = 151179149) - } - } } } } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/SeamlessAppRotationTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/SeamlessAppRotationTest.kt index 33a823d6cfc9c..8ad6c46b913d3 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/SeamlessAppRotationTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/rotation/SeamlessAppRotationTest.kt @@ -16,29 +16,36 @@ package com.android.server.wm.flicker.rotation +import android.content.ComponentName import android.content.Intent -import android.content.Intent.FLAG_ACTIVITY_NEW_TASK +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 androidx.test.uiautomator.By import androidx.test.uiautomator.Until -import com.android.server.wm.flicker.RotationTestBase -import com.android.server.wm.flicker.dsl.flicker +import com.android.server.wm.flicker.Flicker +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.focusDoesNotChange import com.android.server.wm.flicker.helpers.WindowUtils +import com.android.server.wm.flicker.helpers.buildTestTag +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.stopPackage import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import com.android.server.wm.flicker.testapp.ActivityOptions import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -47,150 +54,142 @@ import org.junit.runners.Parameterized * Cycle through supported app rotations using seamless rotations. * To run this test: `atest FlickerTests:SeamlessAppRotationTest` */ +@Presubmit @RequiresDevice @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) -@FlakyTest(bugId = 147659548) class SeamlessAppRotationTest( - testId: String, - private val intent: Intent, - beginRotationName: String, - endRotationName: String, - beginRotation: Int, - endRotation: Int -) : RotationTestBase(beginRotationName, endRotationName, beginRotation, endRotation) { - @Test - fun test() { - var intentId = "" - if (intent.extras?.getBoolean(ActivityOptions.EXTRA_STARVE_UI_THREAD) == true) { - intentId = "BUSY_UI_THREAD" - } - - flicker(instrumentation) { - withTag { - "changeAppRotation_" + intentId + "_" + - Surface.rotationToString(beginRotation) + "_" + - Surface.rotationToString(endRotation) - } - repeat { 1 } - setup { - eachRun { - device.wakeUpAndGoToHomeScreen() - instrumentation.targetContext.startActivity(intent) - device.wait(Until.hasObject(By.pkg(intent.component?.packageName) - .depth(0)), APP_LAUNCH_TIMEOUT) - this.setRotation(beginRotation) - } - } - teardown { - eachRun { - stopPackage( - instrumentation.targetContext, - intent.component?.packageName - ?: error("Unable to determine package name for intent")) - this.setRotation(Surface.ROTATION_0) - } - } - transitions { - this.setRotation(endRotation) - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible(bugId = 140855415) - statusBarWindowIsAlwaysVisible(bugId = 140855415) - } - - layersTrace { - navBarLayerIsAlwaysVisible(bugId = 140855415) - statusBarLayerIsAlwaysVisible(bugId = 140855415) - noUncoveredRegions(beginRotation, endRotation, allStates = true) - navBarLayerRotatesAndScales(beginRotation, endRotation) - statusBarLayerRotatesScales(beginRotation, endRotation, enabled = false) - } - - layersTrace { - all("appLayerRotates"/*, bugId = 147659548*/) { - val startingPos = WindowUtils.getDisplayBounds(beginRotation) - val endingPos = WindowUtils.getDisplayBounds(endRotation) - - if (startingPos == endingPos) { - this.hasVisibleRegion( - intent.component?.packageName ?: "", - startingPos) - } else { - this.hasVisibleRegion(intent.component?.packageName ?: "", startingPos) - .then() - .hasVisibleRegion(intent.component?.packageName - ?: "", endingPos) - } - } - - all("noUncoveredRegions"/*, bugId = 147659548*/) { - val startingBounds = WindowUtils.getDisplayBounds(beginRotation) - val endingBounds = WindowUtils.getDisplayBounds(endRotation) - if (startingBounds == endingBounds) { - this.coversAtLeastRegion(startingBounds) - } else { - this.coversAtLeastRegion(startingBounds) - .then() - .coversAtLeastRegion(endingBounds) - } - } - } - - eventLog { - focusDoesNotChange(bugId = 151179149) - } - } - } - } - + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { companion object { private const val APP_LAUNCH_TIMEOUT: Long = 10000 - // launch test activity that supports seamless rotation with a busy UI thread to miss frames - // when the app is asked to redraw + private val Bundle.intent: Intent? + get() = this.getParcelable(Intent::class.java.simpleName) + + private val Bundle.intentPackageName: String + get() = this.intent?.component?.packageName ?: "" + + private val Bundle.intentId get() = if (this.intent?.getBooleanExtra( + ActivityOptions.EXTRA_STARVE_UI_THREAD, false) == true) { + "BUSY_UI_THREAD" + } else { + "" + } + + private fun Bundle.createConfig(starveUiThread: Boolean): Bundle { + val config = this.deepCopy() + val intent = Intent() + intent.addCategory(Intent.CATEGORY_LAUNCHER) + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + intent.component = ComponentName("com.android.server.wm.flicker.testapp", + "com.android.server.wm.flicker.testapp.SeamlessRotationActivity") + + intent.putExtra(ActivityOptions.EXTRA_STARVE_UI_THREAD, starveUiThread) + + config.putParcelable(Intent::class.java.simpleName, intent) + return config + } + + @JvmStatic + private fun FlickerTestRunnerFactory.getConfigurations(): List { + return this.getConfigRotationTests().flatMap { + val defaultRun = it.createConfig(starveUiThread = false) + val busyUiRun = it.createConfig(starveUiThread = true) + listOf(defaultRun, busyUiRun) + } + } + @Parameterized.Parameters(name = "{0}") @JvmStatic fun getParams(): Collection> { - val supportedRotations = intArrayOf(Surface.ROTATION_0, Surface.ROTATION_90) - val params = mutableListOf>() - val testIntents = mutableListOf() + val instrumentation = InstrumentationRegistry.getInstrumentation() + val factory = FlickerTestRunnerFactory(instrumentation) + val configurations = factory.getConfigurations() + return factory.buildRotationTest(configurations) { configuration -> + withTestName { + buildTestTag("seamlessRotation_" + configuration.intentId, + app = null, configuration = configuration) + } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + instrumentation.targetContext.startActivity(configuration.intent) + val searchQuery = By.pkg(configuration.intent?.component?.packageName) + .depth(0) + device.wait(Until.hasObject(searchQuery), APP_LAUNCH_TIMEOUT) + } + eachRun { + this.setRotation(configuration.startRotation) + } + } + teardown { + test { + this.setRotation(Surface.ROTATION_0) + stopPackage( + instrumentation.targetContext, + configuration.intent?.component?.packageName + ?: error("Unable to determine package name for intent")) + } + } + transitions { + this.setRotation(configuration.endRotation) + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible(bugId = 140855415) + statusBarWindowIsAlwaysVisible(bugId = 140855415) + } - // launch test activity that supports seamless rotation - var intent = Intent(Intent.ACTION_MAIN) - intent.component = ActivityOptions.SEAMLESS_ACTIVITY_COMPONENT_NAME - intent.flags = FLAG_ACTIVITY_NEW_TASK - testIntents.add(intent) + layersTrace { + navBarLayerIsAlwaysVisible(bugId = 140855415) + statusBarLayerIsAlwaysVisible(bugId = 140855415) + noUncoveredRegions(configuration.startRotation, + configuration.endRotation, allStates = false + /*, bugId = 147659548*/) + navBarLayerRotatesAndScales(configuration.startRotation, + configuration.endRotation) + statusBarLayerRotatesScales(configuration.startRotation, + configuration.endRotation, enabled = false) + } - // launch test activity that supports seamless rotation with a busy UI thread to miss frames - // when the app is asked to redraw - intent = Intent(intent) - intent.putExtra(ActivityOptions.EXTRA_STARVE_UI_THREAD, true) - intent.flags = FLAG_ACTIVITY_NEW_TASK - testIntents.add(intent) - for (testIntent in testIntents) { - for (begin in supportedRotations) { - for (end in supportedRotations) { - if (begin != end) { - var testId: String = Surface.rotationToString(begin) + - "_" + Surface.rotationToString(end) - if (testIntent.extras?.getBoolean( - ActivityOptions.EXTRA_STARVE_UI_THREAD) == true) { - testId += "_" + "BUSY_UI_THREAD" + layersTrace { + val startingBounds = WindowUtils + .getDisplayBounds(configuration.startRotation) + val endingBounds = WindowUtils + .getDisplayBounds(configuration.endRotation) + + all("appLayerRotates"/*, bugId = 147659548*/) { + if (startingBounds == endingBounds) { + this.hasVisibleRegion( + configuration.intentPackageName, startingBounds) + } else { + this.hasVisibleRegion(configuration.intentPackageName, + startingBounds) + .then() + .hasVisibleRegion(configuration.intentPackageName, + endingBounds) } - params.add(arrayOf( - testId, - testIntent, - Surface.rotationToString(begin), - Surface.rotationToString(end), - begin, - end)) } + + all("noUncoveredRegions"/*, bugId = 147659548*/) { + if (startingBounds == endingBounds) { + this.coversAtLeastRegion(startingBounds) + } else { + this.coversAtLeastRegion(startingBounds) + .then() + .coversAtLeastRegion(endingBounds) + } + } + } + + eventLog { + focusDoesNotChange(bugId = 151179149) } } } - return params } } } \ No newline at end of file diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/OpenAppToSplitScreenTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/OpenAppToSplitScreenTest.kt index 3b5e6694ef0fd..ae9fcf9a3b6e0 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/OpenAppToSplitScreenTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/OpenAppToSplitScreenTest.kt @@ -16,25 +16,32 @@ package com.android.server.wm.flicker.splitscreen -import android.view.Surface +import android.platform.test.annotations.Presubmit +import androidx.test.filters.FlakyTest import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.NonRotationTestBase +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.DOCKED_STACK_DIVIDER +import com.android.server.wm.flicker.Flicker +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.StandardAppHelper -import com.android.server.wm.flicker.dsl.flicker import com.android.server.wm.flicker.focusChanges +import com.android.server.wm.flicker.helpers.buildTestTag 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.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -43,78 +50,79 @@ import org.junit.runners.Parameterized * Test open app to split screen. * To run this test: `atest FlickerTests:OpenAppToSplitScreenTest` */ +@Presubmit @RequiresDevice @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) +@FlakyTest(bugId = 161435597) class OpenAppToSplitScreenTest( - rotationName: String, - rotation: Int -) : NonRotationTestBase(rotationName, rotation) { - @Test - fun test() { - val testApp = StandardAppHelper(instrumentation, - "com.android.server.wm.flicker.testapp", "SimpleApp") - - flicker(instrumentation) { - withTag { buildTestTag("appToSplitScreen", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - } - eachRun { - testApp.open() - this.setRotation(rotation) - } - } - teardown { - eachRun { - if (device.isInSplitScreen()) { - device.exitSplitScreen() - } - } - test { - testApp.exit() - } - } - transitions { - device.launchSplitScreen() - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - } - - layersTrace { - navBarLayerIsAlwaysVisible(bugId = 140855415) - statusBarLayerIsAlwaysVisible() - noUncoveredRegions(rotation, enabled = false) - navBarLayerRotatesAndScales(rotation, bugId = 140855415) - statusBarLayerRotatesScales(rotation) - - all("dividerLayerBecomesVisible") { - this.hidesLayer(DOCKED_STACK_DIVIDER) - .then() - .showsLayer(DOCKED_STACK_DIVIDER) - } - } - - eventLog { - focusChanges(testApp.`package`, - "recents_animation_input_consumer", "NexusLauncherActivity", - bugId = 151179149) - } - } - } - } - + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { companion object { @Parameterized.Parameters(name = "{0}") @JvmStatic fun getParams(): Collection> { - val supportedRotations = intArrayOf(Surface.ROTATION_0) - return supportedRotations.map { arrayOf(Surface.rotationToString(it), it) } + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = StandardAppHelper(instrumentation, + "com.android.server.wm.flicker.testapp", "SimpleApp") + + return FlickerTestRunnerFactory(instrumentation) + .buildTest { configuration -> + withTestName { + buildTestTag("appToSplitScreen", testApp, configuration) + } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + } + eachRun { + testApp.open() + this.setRotation(configuration.endRotation) + } + } + teardown { + eachRun { + if (device.isInSplitScreen()) { + device.exitSplitScreen() + } + } + test { + testApp.exit() + } + } + transitions { + device.launchSplitScreen() + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + } + + layersTrace { + navBarLayerIsAlwaysVisible(bugId = 140855415) + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.endRotation, enabled = false) + navBarLayerRotatesAndScales(configuration.endRotation, + bugId = 140855415) + statusBarLayerRotatesScales(configuration.endRotation) + + all("dividerLayerBecomesVisible") { + this.hidesLayer(DOCKED_STACK_DIVIDER) + .then() + .showsLayer(DOCKED_STACK_DIVIDER) + } + } + + eventLog { + focusChanges(testApp.`package`, + "recents_animation_input_consumer", "NexusLauncherActivity", + bugId = 151179149) + } + } + } } } } diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/ResizeSplitScreenTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/ResizeSplitScreenTest.kt index abf41a1fd4082..4b9f02412f2ad 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/ResizeSplitScreenTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/ResizeSplitScreenTest.kt @@ -19,32 +19,39 @@ package com.android.server.wm.flicker.splitscreen import android.graphics.Region import android.util.Rational import android.view.Surface -import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.filters.FlakyTest import androidx.test.filters.RequiresDevice +import androidx.test.platform.app.InstrumentationRegistry import androidx.test.uiautomator.By -import com.android.server.wm.flicker.FlickerTestBase +import com.android.server.wm.flicker.DOCKED_STACK_DIVIDER +import com.android.server.wm.flicker.Flicker +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.StandardAppHelper -import com.android.server.wm.flicker.dsl.flicker import com.android.server.wm.flicker.focusDoesNotChange import com.android.server.wm.flicker.helpers.ImeAppHelper import com.android.server.wm.flicker.helpers.WindowUtils +import com.android.server.wm.flicker.helpers.buildTestTag import com.android.server.wm.flicker.helpers.exitSplitScreen import com.android.server.wm.flicker.helpers.isInSplitScreen import com.android.server.wm.flicker.helpers.launchSplitScreen import com.android.server.wm.flicker.helpers.resizeSplitScreen +import com.android.server.wm.flicker.helpers.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions +import com.android.server.wm.flicker.startRotation import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters +import org.junit.runners.Parameterized /** * Test split screen resizing window transitions. @@ -53,138 +60,149 @@ import org.junit.runners.MethodSorters * Currently it runs only in 0 degrees because of b/156100803 */ @RequiresDevice -@RunWith(AndroidJUnit4::class) +@RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) @FlakyTest(bugId = 159096424) -class ResizeSplitScreenTest : FlickerTestBase() { - @Test - fun test() { - val testAppTop = StandardAppHelper(instrumentation, - "com.android.server.wm.flicker.testapp", "SimpleApp") - val testAppBottom = ImeAppHelper(instrumentation) - - flicker(instrumentation) { - withTag { - val description = (startRatio.toString().replace("/", "-") + "_to_" + - stopRatio.toString().replace("/", "-")) - buildTestTag("resizeSplitScreen", testAppTop, rotation, - rotation, testAppBottom, description) - } - repeat { 1 } - setup { - eachRun { - device.wakeUpAndGoToHomeScreen() - this.setRotation(rotation) - this.launcherStrategy.clearRecentAppsFromOverview() - testAppBottom.open() - device.pressHome() - testAppTop.open() - device.waitForIdle() - device.launchSplitScreen() - val snapshot = device.findObject(By.res(device.launcherPackageName, "snapshot")) - snapshot.click() - testAppBottom.openIME(device) - device.pressBack() - device.resizeSplitScreen(startRatio) - } - } - teardown { - eachRun { - device.exitSplitScreen() - device.pressHome() - testAppTop.exit() - testAppBottom.exit() - } - test { - if (device.isInSplitScreen()) { - device.exitSplitScreen() - } - } - } - transitions { - device.resizeSplitScreen(stopRatio) - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - - all("topAppWindowIsAlwaysVisible", bugId = 156223549) { - this.showsAppWindow(sSimpleActivity) - } - - all("bottomAppWindowIsAlwaysVisible", bugId = 156223549) { - this.showsAppWindow(sImeActivity) - } - } - - layersTrace { - navBarLayerIsAlwaysVisible() - statusBarLayerIsAlwaysVisible() - noUncoveredRegions(rotation) - navBarLayerRotatesAndScales(rotation) - statusBarLayerRotatesScales(rotation) - - all("topAppLayerIsAlwaysVisible") { - this.showsLayer(sSimpleActivity) - } - - all("bottomAppLayerIsAlwaysVisible") { - this.showsLayer(sImeActivity) - } - - all("dividerLayerIsAlwaysVisible") { - this.showsLayer(DOCKED_STACK_DIVIDER) - } - - start("appsStartingBounds", enabled = false) { - val displayBounds = WindowUtils.displayBounds - val entry = this.trace.entries.firstOrNull() - ?: throw IllegalStateException("Trace is empty") - val dividerBounds = entry.getVisibleBounds(DOCKED_STACK_DIVIDER).bounds - - val topAppBounds = Region(0, 0, dividerBounds.right, - dividerBounds.top + WindowUtils.dockedStackDividerInset) - val bottomAppBounds = Region(0, - dividerBounds.bottom - WindowUtils.dockedStackDividerInset, - displayBounds.right, - displayBounds.bottom - WindowUtils.navigationBarHeight) - this.hasVisibleRegion("SimpleActivity", topAppBounds) - .and() - .hasVisibleRegion("ImeActivity", bottomAppBounds) - } - - end("appsEndingBounds", enabled = false) { - val displayBounds = WindowUtils.displayBounds - val entry = this.trace.entries.lastOrNull() - ?: throw IllegalStateException("Trace is empty") - val dividerBounds = entry.getVisibleBounds(DOCKED_STACK_DIVIDER).bounds - - val topAppBounds = Region(0, 0, dividerBounds.right, - dividerBounds.top + WindowUtils.dockedStackDividerInset) - val bottomAppBounds = Region(0, - dividerBounds.bottom - WindowUtils.dockedStackDividerInset, - displayBounds.right, - displayBounds.bottom - WindowUtils.navigationBarHeight) - - this.hasVisibleRegion(sSimpleActivity, topAppBounds) - .and() - .hasVisibleRegion(sImeActivity, bottomAppBounds) - } - } - - eventLog { - focusDoesNotChange() - } - } - } - } - +class ResizeSplitScreenTest( + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { companion object { private const val sSimpleActivity = "SimpleActivity" private const val sImeActivity = "ImeActivity" - private val rotation = Surface.ROTATION_0 private val startRatio = Rational(1, 3) private val stopRatio = Rational(2, 3) + + @Parameterized.Parameters(name = "{0}") + @JvmStatic + fun getParams(): Collection> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testAppTop = StandardAppHelper(instrumentation, + "com.android.server.wm.flicker.testapp", "SimpleApp") + val testAppBottom = ImeAppHelper(instrumentation) + + return FlickerTestRunnerFactory(instrumentation, listOf(Surface.ROTATION_0)) + .buildTest { configuration -> + withTestName { + val description = (startRatio.toString().replace("/", "-") + "_to_" + + stopRatio.toString().replace("/", "-")) + buildTestTag("resizeSplitScreen", testAppTop.launcherName, + configuration.startRotation, configuration.endRotation, + testAppBottom.launcherName, description) + } + repeat { configuration.repetitions } + setup { + eachRun { + device.wakeUpAndGoToHomeScreen() + this.setRotation(configuration.startRotation) + this.launcherStrategy.clearRecentAppsFromOverview() + testAppBottom.open() + device.pressHome() + testAppTop.open() + device.waitForIdle() + device.launchSplitScreen() + val snapshot = + device.findObject(By.res(device.launcherPackageName, "snapshot")) + snapshot.click() + testAppBottom.openIME(device) + device.pressBack() + device.resizeSplitScreen(startRatio) + } + } + teardown { + eachRun { + if (device.isInSplitScreen()) { + device.exitSplitScreen() + } + device.pressHome() + testAppTop.exit() + testAppBottom.exit() + } + test { + if (device.isInSplitScreen()) { + device.exitSplitScreen() + } + } + } + transitions { + device.resizeSplitScreen(stopRatio) + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + + all("topAppWindowIsAlwaysVisible", bugId = 156223549) { + this.showsAppWindow(sSimpleActivity) + } + + all("bottomAppWindowIsAlwaysVisible", bugId = 156223549) { + this.showsAppWindow(sImeActivity) + } + } + + layersTrace { + navBarLayerIsAlwaysVisible() + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.endRotation) + navBarLayerRotatesAndScales(configuration.endRotation) + statusBarLayerRotatesScales(configuration.endRotation) + + all("topAppLayerIsAlwaysVisible") { + this.showsLayer(sSimpleActivity) + } + + all("bottomAppLayerIsAlwaysVisible") { + this.showsLayer(sImeActivity) + } + + all("dividerLayerIsAlwaysVisible") { + this.showsLayer(DOCKED_STACK_DIVIDER) + } + + start("appsStartingBounds", enabled = false) { + val displayBounds = WindowUtils.displayBounds + val entry = this.trace.entries.firstOrNull() + ?: throw IllegalStateException("Trace is empty") + val dividerBounds = + entry.getVisibleBounds(DOCKED_STACK_DIVIDER).bounds + + val topAppBounds = Region(0, 0, dividerBounds.right, + dividerBounds.top + WindowUtils.dockedStackDividerInset) + val bottomAppBounds = Region(0, + dividerBounds.bottom - WindowUtils.dockedStackDividerInset, + displayBounds.right, + displayBounds.bottom - WindowUtils.navigationBarHeight) + this.hasVisibleRegion("SimpleActivity", topAppBounds) + .and() + .hasVisibleRegion("ImeActivity", bottomAppBounds) + } + + end("appsEndingBounds", enabled = false) { + val displayBounds = WindowUtils.displayBounds + val entry = this.trace.entries.lastOrNull() + ?: throw IllegalStateException("Trace is empty") + val dividerBounds = + entry.getVisibleBounds(DOCKED_STACK_DIVIDER).bounds + + val topAppBounds = Region(0, 0, dividerBounds.right, + dividerBounds.top + WindowUtils.dockedStackDividerInset) + val bottomAppBounds = Region(0, + dividerBounds.bottom - WindowUtils.dockedStackDividerInset, + displayBounds.right, + displayBounds.bottom - WindowUtils.navigationBarHeight) + + this.hasVisibleRegion(sSimpleActivity, topAppBounds) + .and() + .hasVisibleRegion(sImeActivity, bottomAppBounds) + } + } + + eventLog { + focusDoesNotChange() + } + } + } + } } } diff --git a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/SplitScreenToLauncherTest.kt b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/SplitScreenToLauncherTest.kt index 7447bdae9abe8..f966a66aa0a17 100644 --- a/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/SplitScreenToLauncherTest.kt +++ b/tests/FlickerTests/src/com/android/server/wm/flicker/splitscreen/SplitScreenToLauncherTest.kt @@ -19,23 +19,29 @@ package com.android.server.wm.flicker.splitscreen import android.platform.test.annotations.Presubmit import android.view.Surface import androidx.test.filters.RequiresDevice -import com.android.server.wm.flicker.NonRotationTestBase +import androidx.test.platform.app.InstrumentationRegistry +import com.android.server.wm.flicker.DOCKED_STACK_DIVIDER +import com.android.server.wm.flicker.Flicker +import com.android.server.wm.flicker.FlickerTestRunner +import com.android.server.wm.flicker.FlickerTestRunnerFactory import com.android.server.wm.flicker.helpers.StandardAppHelper -import com.android.server.wm.flicker.dsl.flicker +import com.android.server.wm.flicker.endRotation import com.android.server.wm.flicker.focusDoesNotChange +import com.android.server.wm.flicker.helpers.buildTestTag 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.setRotation import com.android.server.wm.flicker.helpers.wakeUpAndGoToHomeScreen import com.android.server.wm.flicker.navBarLayerIsAlwaysVisible import com.android.server.wm.flicker.navBarLayerRotatesAndScales import com.android.server.wm.flicker.navBarWindowIsAlwaysVisible import com.android.server.wm.flicker.noUncoveredRegions +import com.android.server.wm.flicker.repetitions import com.android.server.wm.flicker.statusBarLayerIsAlwaysVisible import com.android.server.wm.flicker.statusBarLayerRotatesScales import com.android.server.wm.flicker.statusBarWindowIsAlwaysVisible import org.junit.FixMethodOrder -import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.MethodSorters import org.junit.runners.Parameterized @@ -49,82 +55,80 @@ import org.junit.runners.Parameterized @RunWith(Parameterized::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class SplitScreenToLauncherTest( - rotationName: String, - rotation: Int -) : NonRotationTestBase(rotationName, rotation) { - @Test - fun test() { - val testApp = StandardAppHelper(instrumentation, - "com.android.server.wm.flicker.testapp", "SimpleApp") - - flicker(instrumentation) { - withTag { buildTestTag("splitScreenToLauncher", testApp, rotation) } - repeat { 1 } - setup { - test { - device.wakeUpAndGoToHomeScreen() - } - eachRun { - testApp.open() - this.setRotation(rotation) - device.launchSplitScreen() - device.waitForIdle() - } - } - teardown { - eachRun { - testApp.exit() - } - test { - if (device.isInSplitScreen()) { - device.exitSplitScreen() - } - } - } - transitions { - device.exitSplitScreen() - } - assertions { - windowManagerTrace { - navBarWindowIsAlwaysVisible() - statusBarWindowIsAlwaysVisible() - } - - layersTrace { - navBarLayerIsAlwaysVisible() - statusBarLayerIsAlwaysVisible() - noUncoveredRegions(rotation) - navBarLayerRotatesAndScales(rotation) - statusBarLayerRotatesScales(rotation) - - // b/161435597 causes the test not to work on 90 degrees - all("dividerLayerBecomesInvisible") { - this.showsLayer(DOCKED_STACK_DIVIDER) - .then() - .hidesLayer(DOCKED_STACK_DIVIDER) - } - - all("appLayerBecomesInvisible") { - this.showsLayer(testApp.getPackage()) - .then() - .hidesLayer(testApp.getPackage()) - } - } - - eventLog { - focusDoesNotChange(bugId = 151179149) - } - } - } - } - + testName: String, + flickerSpec: Flicker +) : FlickerTestRunner(testName, flickerSpec) { companion object { @Parameterized.Parameters(name = "{0}") @JvmStatic fun getParams(): Collection> { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val testApp = StandardAppHelper(instrumentation, + "com.android.server.wm.flicker.testapp", "SimpleApp") + // 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) } + return FlickerTestRunnerFactory(instrumentation, listOf(Surface.ROTATION_0)) + .buildTest { configuration -> + withTestName { + buildTestTag("splitScreenToLauncher", testApp, configuration) + } + repeat { configuration.repetitions } + setup { + test { + device.wakeUpAndGoToHomeScreen() + } + eachRun { + testApp.open() + this.setRotation(configuration.endRotation) + device.launchSplitScreen() + device.waitForIdle() + } + } + teardown { + eachRun { + testApp.exit() + } + test { + if (device.isInSplitScreen()) { + device.exitSplitScreen() + } + } + } + transitions { + device.exitSplitScreen() + } + assertions { + windowManagerTrace { + navBarWindowIsAlwaysVisible() + statusBarWindowIsAlwaysVisible() + } + + layersTrace { + navBarLayerIsAlwaysVisible() + statusBarLayerIsAlwaysVisible() + noUncoveredRegions(configuration.endRotation) + navBarLayerRotatesAndScales(configuration.endRotation) + statusBarLayerRotatesScales(configuration.endRotation) + + // b/161435597 causes the test not to work on 90 degrees + all("dividerLayerBecomesInvisible") { + this.showsLayer(DOCKED_STACK_DIVIDER) + .then() + .hidesLayer(DOCKED_STACK_DIVIDER) + } + + all("appLayerBecomesInvisible") { + this.showsLayer(testApp.getPackage()) + .then() + .hidesLayer(testApp.getPackage()) + } + } + + eventLog { + focusDoesNotChange(bugId = 151179149) + } + } + } } } }