Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 58b2237f authored by Chilun's avatar Chilun
Browse files

Merge some unit test classes 

Merge
TaskRecordTests into TaskTests.
TaskStackTests and ActivityStackTests into RootTaskTests.
RootActivityContainerTests into RootWindowContainerTests.
ActivityDisplayTests into DisplayContentTests.

Also move some TaskDisplayArea tests to TaskDisplayAreaTests.

Bug: 144248496
Test: atest TaskTests RootTaskTests
      atest RootWindowContainerTests
      atest DisplayContentTests
      atest TaskDisplayAreaTests
Change-Id: I4ef9abad9e73d5ecb1bc19beda890e10a478d172
parent 15615ed0

services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java

deleted100644 → 0
+0 −346
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 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;



import static android.app.WindowConfiguration.ACTIVITY_TYPE_ASSISTANT;

import static android.app.WindowConfiguration.ACTIVITY_TYPE_DREAM;

import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;

import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;

import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;

import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;

import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;

import static android.content.pm.ActivityInfo.FLAG_ALWAYS_FOCUSABLE;

import static android.content.pm.ActivityInfo.FLAG_SHOW_WHEN_LOCKED;



import static com.android.dx.mockito.inline.extended.ExtendedMockito.clearInvocations;

import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;

import static com.android.dx.mockito.inline.extended.ExtendedMockito.never;

import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify;

import static com.android.server.wm.ActivityTaskSupervisor.ON_TOP;

import static com.android.server.wm.WindowContainer.POSITION_TOP;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyBoolean;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.doAnswer;



import android.platform.test.annotations.Presubmit;



import androidx.test.filters.SmallTest;



import org.junit.Test;

import org.junit.runner.RunWith;



/**

 * Tests for the {@link DisplayContent} class.

 *

 * Build/Install/Run:

 *  atest WmTests:ActivityDisplayTests

 */

@SmallTest

@Presubmit

@RunWith(WindowTestRunner.class)

// TODO(b/144248496): Merge to DisplayContentTests

public class ActivityDisplayTests extends WindowTestsBase {



    @Test

    public void testLastFocusedStackIsUpdatedWhenMovingStack() {

        // Create a stack at bottom.

        final TaskDisplayArea taskDisplayAreas =

                mRootWindowContainer.getDefaultDisplay().getDefaultTaskDisplayArea();

        final Task stack =

                new TaskBuilder(mSupervisor).setOnTop(!ON_TOP).setCreateActivity(true).build();

        final Task prevFocusedStack = taskDisplayAreas.getFocusedRootTask();



        stack.moveToFront("moveStackToFront");

        // After moving the stack to front, the previous focused should be the last focused.

        assertTrue(stack.isFocusedRootTaskOnDisplay());

        assertEquals(prevFocusedStack, taskDisplayAreas.getLastFocusedRootTask());



        stack.moveToBack("moveStackToBack", null /* task */);

        // After moving the stack to back, the stack should be the last focused.

        assertEquals(stack, taskDisplayAreas.getLastFocusedRootTask());

    }



    /**

     * This test simulates the picture-in-picture menu activity launches an activity to fullscreen

     * stack. The fullscreen stack should be the top focused for resuming correctly.

     */

    @Test

    public void testFullscreenStackCanBeFocusedWhenFocusablePinnedStackExists() {

        // Create a pinned stack and move to front.

        final Task pinnedStack = mRootWindowContainer.getDefaultTaskDisplayArea()

                .createRootTask(WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, ON_TOP);

        final Task pinnedTask = new TaskBuilder(mAtm.mTaskSupervisor)

                .setParentTask(pinnedStack).build();

        new ActivityBuilder(mAtm).setActivityFlags(FLAG_ALWAYS_FOCUSABLE)

                .setTask(pinnedTask).build();

        pinnedStack.moveToFront("movePinnedStackToFront");



        // The focused stack should be the pinned stack.

        assertTrue(pinnedStack.isFocusedRootTaskOnDisplay());



        // Create a fullscreen stack and move to front.

        final Task fullscreenStack = createFullscreenStackWithSimpleActivityAt(

                mRootWindowContainer.getDefaultDisplay());

        fullscreenStack.moveToFront("moveFullscreenStackToFront");



        // The focused stack should be the fullscreen stack.

        assertTrue(fullscreenStack.isFocusedRootTaskOnDisplay());

    }



    /**

     * Test {@link TaskDisplayArea#mPreferredTopFocusableRootTask} will be cleared when

     * the stack is removed or moved to back, and the focused stack will be according to z-order.

     */

    @Test

    public void testStackShouldNotBeFocusedAfterMovingToBackOrRemoving() {

        // Create a display which only contains 2 stacks.

        final DisplayContent display = addNewDisplayContentAt(POSITION_TOP);

        final Task stack1 = createFullscreenStackWithSimpleActivityAt(display);

        final Task stack2 = createFullscreenStackWithSimpleActivityAt(display);



        // Put stack1 and stack2 on top.

        stack1.moveToFront("moveStack1ToFront");

        stack2.moveToFront("moveStack2ToFront");

        assertTrue(stack2.isFocusedRootTaskOnDisplay());



        // Stack1 should be focused after moving stack2 to back.

        stack2.moveToBack("moveStack2ToBack", null /* task */);

        assertTrue(stack1.isFocusedRootTaskOnDisplay());



        // Stack2 should be focused after removing stack1.

        stack1.getDisplayArea().removeRootTask(stack1);

        assertTrue(stack2.isFocusedRootTaskOnDisplay());

    }



    /**

     * Verifies {@link DisplayContent#remove} should not resume home stack on the removing display.

     */

    @Test

    public void testNotResumeHomeStackOnRemovingDisplay() {

        // Create a display which supports system decoration and allows reparenting stacks to

        // another display when the display is removed.

        final DisplayContent display = new TestDisplayContent.Builder(

                mAtm, 1000, 1500).setSystemDecorations(true).build();

        doReturn(false).when(display).shouldDestroyContentOnRemove();



        // Put home stack on the display.

        final Task homeStack = new TaskBuilder(mSupervisor)

                .setDisplay(display).setActivityType(ACTIVITY_TYPE_HOME).build();



        // Put a finishing standard activity which will be reparented.

        final Task stack = createFullscreenStackWithSimpleActivityAt(display);

        stack.topRunningActivity().makeFinishingLocked();



        clearInvocations(homeStack);

        display.remove();



        // The removed display should have no focused stack and its home stack should never resume.

        assertNull(display.getFocusedRootTask());

        verify(homeStack, never()).resumeTopActivityUncheckedLocked(any(), any());

    }



    private Task createFullscreenStackWithSimpleActivityAt(DisplayContent display) {

        final Task fullscreenStack = display.getDefaultTaskDisplayArea().createRootTask(

                WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, ON_TOP);

        final Task fullscreenTask = new TaskBuilder(mAtm.mTaskSupervisor)

                .setParentTask(fullscreenStack).build();

        new ActivityBuilder(mAtm).setTask(fullscreenTask).build();

        return fullscreenStack;

    }



    /**

     * Verifies the correct activity is returned when querying the top running activity.

     */

    @Test

    public void testTopRunningActivity() {

        final DisplayContent display = mRootWindowContainer.getDefaultDisplay();

        final KeyguardController keyguard = mSupervisor.getKeyguardController();

        final Task stack = new TaskBuilder(mSupervisor).setCreateActivity(true).build();

        final ActivityRecord activity = stack.getTopNonFinishingActivity();



        // Create empty stack on top.

        final Task emptyStack = new TaskBuilder(mSupervisor).build();



        // Make sure the top running activity is not affected when keyguard is not locked.

        assertTopRunningActivity(activity, display);



        // Check to make sure activity not reported when it cannot show on lock and lock is on.

        doReturn(true).when(keyguard).isKeyguardLocked();

        assertEquals(activity, display.topRunningActivity());

        assertNull(display.topRunningActivity(true /* considerKeyguardState */));



        // Move stack with activity to top.

        stack.moveToFront("testStackToFront");

        assertEquals(stack, display.getFocusedRootTask());

        assertEquals(activity, display.topRunningActivity());

        assertNull(display.topRunningActivity(true /* considerKeyguardState */));



        // Add activity that should be shown on the keyguard.

        final ActivityRecord showWhenLockedActivity = new ActivityBuilder(mAtm)

                .setTask(stack)

                .setActivityFlags(FLAG_SHOW_WHEN_LOCKED)

                .build();



        // Ensure the show when locked activity is returned.

        assertTopRunningActivity(showWhenLockedActivity, display);



        // Move empty stack to front. The running activity in focusable stack which below the

        // empty stack should be returned.

        emptyStack.moveToFront("emptyStackToFront");

        assertEquals(stack, display.getFocusedRootTask());

        assertTopRunningActivity(showWhenLockedActivity, display);

    }



    private static void assertTopRunningActivity(ActivityRecord top, DisplayContent display) {

        assertEquals(top, display.topRunningActivity());

        assertEquals(top, display.topRunningActivity(true /* considerKeyguardState */));

    }



    /**

     * This test enforces that alwaysOnTop stack is placed at proper position.

     */

    @Test

    public void testAlwaysOnTopStackLocation() {

        final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();

        final Task alwaysOnTopStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FREEFORM,

                ACTIVITY_TYPE_STANDARD, true /* onTop */);

        final ActivityRecord activity = new ActivityBuilder(mAtm)

                .setTask(alwaysOnTopStack).build();

        alwaysOnTopStack.setAlwaysOnTop(true);

        taskDisplayArea.positionChildAt(POSITION_TOP, alwaysOnTopStack,

                false /* includingParents */);

        assertTrue(alwaysOnTopStack.isAlwaysOnTop());

        // Ensure always on top state is synced to the children of the stack.

        assertTrue(alwaysOnTopStack.getTopNonFinishingActivity().isAlwaysOnTop());

        assertEquals(alwaysOnTopStack, taskDisplayArea.getTopRootTask());



        final Task pinnedStack = taskDisplayArea.createRootTask(

                WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */);

        assertEquals(pinnedStack, taskDisplayArea.getRootPinnedTask());

        assertEquals(pinnedStack, taskDisplayArea.getTopRootTask());



        final Task anotherAlwaysOnTopStack = taskDisplayArea.createRootTask(

                WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */);

        anotherAlwaysOnTopStack.setAlwaysOnTop(true);

        taskDisplayArea.positionChildAt(POSITION_TOP, anotherAlwaysOnTopStack,

                false /* includingParents */);

        assertTrue(anotherAlwaysOnTopStack.isAlwaysOnTop());

        int topPosition = taskDisplayArea.getRootTaskCount() - 1;

        // Ensure the new alwaysOnTop stack is put below the pinned stack, but on top of the

        // existing alwaysOnTop stack.

        assertEquals(topPosition - 1, getTaskIndexOf(taskDisplayArea, anotherAlwaysOnTopStack));



        final Task nonAlwaysOnTopStack = taskDisplayArea.createRootTask(

                WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */);

        assertEquals(taskDisplayArea, nonAlwaysOnTopStack.getDisplayArea());

        topPosition = taskDisplayArea.getRootTaskCount() - 1;

        // Ensure the non-alwaysOnTop stack is put below the three alwaysOnTop stacks, but above the

        // existing other non-alwaysOnTop stacks.

        assertEquals(topPosition - 3, getTaskIndexOf(taskDisplayArea, nonAlwaysOnTopStack));



        anotherAlwaysOnTopStack.setAlwaysOnTop(false);

        taskDisplayArea.positionChildAt(POSITION_TOP, anotherAlwaysOnTopStack,

                false /* includingParents */);

        assertFalse(anotherAlwaysOnTopStack.isAlwaysOnTop());

        // Ensure, when always on top is turned off for a stack, the stack is put just below all

        // other always on top stacks.

        assertEquals(topPosition - 2, getTaskIndexOf(taskDisplayArea, anotherAlwaysOnTopStack));

        anotherAlwaysOnTopStack.setAlwaysOnTop(true);



        // Ensure always on top state changes properly when windowing mode changes.

        anotherAlwaysOnTopStack.setWindowingMode(WINDOWING_MODE_FULLSCREEN);

        assertFalse(anotherAlwaysOnTopStack.isAlwaysOnTop());

        assertEquals(topPosition - 2, getTaskIndexOf(taskDisplayArea, anotherAlwaysOnTopStack));

        anotherAlwaysOnTopStack.setWindowingMode(WINDOWING_MODE_FREEFORM);

        assertTrue(anotherAlwaysOnTopStack.isAlwaysOnTop());

        assertEquals(topPosition - 1, getTaskIndexOf(taskDisplayArea, anotherAlwaysOnTopStack));



        final Task dreamStack = taskDisplayArea.createRootTask(

                WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_DREAM, true /* onTop */);

        assertEquals(taskDisplayArea, dreamStack.getDisplayArea());

        assertTrue(dreamStack.isAlwaysOnTop());

        topPosition = taskDisplayArea.getRootTaskCount() - 1;

        // Ensure dream shows above all activities, including PiP

        assertEquals(dreamStack, taskDisplayArea.getTopRootTask());

        assertEquals(topPosition - 1, getTaskIndexOf(taskDisplayArea, pinnedStack));



        final Task assistStack = taskDisplayArea.createRootTask(

                WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_ASSISTANT, true /* onTop */);

        assertEquals(taskDisplayArea, assistStack.getDisplayArea());

        assertFalse(assistStack.isAlwaysOnTop());

        topPosition = taskDisplayArea.getRootTaskCount() - 1;



        // Ensure Assistant shows as a non-always-on-top activity when config_assistantOnTopOfDream

        // is false and on top of everything when true.

        final boolean isAssistantOnTop = mContext.getResources()

                .getBoolean(com.android.internal.R.bool.config_assistantOnTopOfDream);

        assertEquals(isAssistantOnTop ? topPosition : topPosition - 4,

                getTaskIndexOf(taskDisplayArea, assistStack));

    }



    @Test

    public void testRemoveRootTaskInWindowingModes() {

        removeStackTests(() -> mRootWindowContainer.removeRootTasksInWindowingModes(

                WINDOWING_MODE_FULLSCREEN));

    }



    @Test

    public void testRemoveStackWithActivityTypes() {

        removeStackTests(() -> mRootWindowContainer.removeRootTasksWithActivityTypes(

                ACTIVITY_TYPE_STANDARD));

    }



    private void removeStackTests(Runnable runnable) {

        final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();

        final Task stack1 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,

                ACTIVITY_TYPE_STANDARD, ON_TOP);

        final Task stack2 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,

                ACTIVITY_TYPE_STANDARD, ON_TOP);

        final Task stack3 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,

                ACTIVITY_TYPE_STANDARD, ON_TOP);

        final Task stack4 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,

                ACTIVITY_TYPE_STANDARD, ON_TOP);

        final Task task1 = new TaskBuilder(mAtm.mTaskSupervisor).setParentTask(stack1).build();

        final Task task2 = new TaskBuilder(mAtm.mTaskSupervisor).setParentTask(stack2).build();

        final Task task3 = new TaskBuilder(mAtm.mTaskSupervisor).setParentTask(stack3).build();

        final Task task4 = new TaskBuilder(mAtm.mTaskSupervisor).setParentTask(stack4).build();



        // Reordering stacks while removing stacks.

        doAnswer(invocation -> {

            taskDisplayArea.positionChildAt(POSITION_TOP, stack3, false /*includingParents*/);

            return true;

        }).when(mSupervisor).removeTask(eq(task4), anyBoolean(), anyBoolean(), any());



        // Removing stacks from the display while removing stacks.

        doAnswer(invocation -> {

            taskDisplayArea.removeRootTask(stack2);

            return true;

        }).when(mSupervisor).removeTask(eq(task2), anyBoolean(), anyBoolean(), any());



        runnable.run();

        verify(mSupervisor).removeTask(eq(task4), anyBoolean(), anyBoolean(), any());

        verify(mSupervisor).removeTask(eq(task3), anyBoolean(), anyBoolean(), any());

        verify(mSupervisor).removeTask(eq(task2), anyBoolean(), anyBoolean(), any());

        verify(mSupervisor).removeTask(eq(task1), anyBoolean(), anyBoolean(), any());

    }

}

services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java

+168 −101

File changed.

Preview size limit exceeded, changes collapsed.

services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java

deleted100644 → 0
+0 −953

File deleted.

Preview size limit exceeded, changes collapsed.

services/tests/wmtests/src/com/android/server/wm/ActivityStackTests.java→services/tests/wmtests/src/com/android/server/wm/RootTaskTests.java

+523 −371

File changed and moved.

Preview size limit exceeded, changes collapsed.

services/tests/wmtests/src/com/android/server/wm/RootWindowContainerTests.java

+909 −3

File changed.

Preview size limit exceeded, changes collapsed.