Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor One handed mode Unit tests

Browse Source 
1) Fix all broken tests and use mock for unit tests
2) Integrate TestableContext for unit tests
3) Do not update/restore Settings from TestBase
4) Limit to grant permissions for test cases

Fixes: 167943723
Test: atest WMShellUnitTests
Change-Id: Id02aa26e63b96962d955fcfbf061d668a6cb731c
This commit is contained in:
Bill Lin
2021-02-19 19:54:30 +08:00
parent a052eef726
commit b221eb4c78
13 changed files with 196 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
libs/WindowManager/Shell/src/com/android/wm/shell/onehanded/OneHandedController.java
View File

@@ -31,6 +31,7 @@ import android.os.ServiceManager;
import android.os.SystemProperties;
import android.provider.Settings;
import android.util.Slog;
import android.view.ViewConfiguration;
import android.view.accessibility.AccessibilityManager;
import androidx.annotation.NonNull;
@@ -154,7 +155,7 @@ public class OneHandedController {
OneHandedTouchHandler touchHandler = new OneHandedTouchHandler(timeoutHandler,
mainExecutor);
OneHandedGestureHandler gestureHandler = new OneHandedGestureHandler(
context, displayController, mainExecutor);
context, displayController, ViewConfiguration.get(context), mainExecutor);
OneHandedBackgroundPanelOrganizer oneHandedBackgroundPanelOrganizer =
new OneHandedBackgroundPanelOrganizer(context, displayController, mainExecutor);
OneHandedDisplayAreaOrganizer organizer = new OneHandedDisplayAreaOrganizer(
@@ -222,8 +223,7 @@ public class OneHandedController {
setupGesturalOverlay();
updateSettings();
mAccessibilityManager = (AccessibilityManager)
context.getSystemService(Context.ACCESSIBILITY_SERVICE);
mAccessibilityManager = AccessibilityManager.getInstance(context);
mAccessibilityManager.addAccessibilityStateChangeListener(
mAccessibilityStateChangeListener);
}
@@ -345,7 +345,8 @@ public class OneHandedController {
};
}
private void onEnabledSettingChanged() {
@VisibleForTesting
void onEnabledSettingChanged() {
final boolean enabled = OneHandedSettingsUtil.getSettingsOneHandedModeEnabled(
mContext.getContentResolver());
mOneHandedUiEventLogger.writeEvent(enabled
@@ -360,7 +361,8 @@ public class OneHandedController {
mContext.getContentResolver()));
}
private void onTimeoutSettingChanged() {
@VisibleForTesting
void onTimeoutSettingChanged() {
final int newTimeout = OneHandedSettingsUtil.getSettingsOneHandedModeTimeout(
mContext.getContentResolver());
int metricsId = OneHandedUiEventLogger.OneHandedSettingsTogglesEvent.INVALID.getId();
@@ -388,7 +390,8 @@ public class OneHandedController {
}
}
private void onTaskChangeExitSettingChanged() {
@VisibleForTesting
void onTaskChangeExitSettingChanged() {
final boolean enabled = OneHandedSettingsUtil.getSettingsTapsAppToExit(
mContext.getContentResolver());
mOneHandedUiEventLogger.writeEvent(enabled
@@ -398,7 +401,8 @@ public class OneHandedController {
setTaskChangeToExit(enabled);
}
private void onSwipeToNotificationEnabledSettingChanged() {
@VisibleForTesting
void onSwipeToNotificationEnabledSettingChanged() {
final boolean enabled =
OneHandedSettingsUtil.getSettingsSwipeToNotificationEnabled(
mContext.getContentResolver());
@@ -461,7 +465,6 @@ public class OneHandedController {
OverlayInfo info = null;
try {
// TODO(b/157958539) migrate new RRO config file after S+
mOverlayManager.setHighestPriority(ONE_HANDED_MODE_GESTURAL_OVERLAY, USER_CURRENT);
info = mOverlayManager.getOverlayInfo(ONE_HANDED_MODE_GESTURAL_OVERLAY, USER_CURRENT);
} catch (RemoteException e) { /* Do nothing */ }

3
libs/WindowManager/Shell/src/com/android/wm/shell/onehanded/OneHandedGestureHandler.java
View File

@@ -87,6 +87,7 @@ public class OneHandedGestureHandler implements OneHandedTransitionCallback,
* @param displayController {@link DisplayController}
*/
public OneHandedGestureHandler(Context context, DisplayController displayController,
ViewConfiguration viewConfig,
ShellExecutor mainExecutor) {
mDisplayController = displayController;
mMainExecutor = mainExecutor;
@@ -95,7 +96,7 @@ public class OneHandedGestureHandler implements OneHandedTransitionCallback,
com.android.internal.R.dimen.navigation_bar_gesture_larger_height);
mDragDistThreshold = context.getResources().getDimensionPixelSize(
R.dimen.gestures_onehanded_drag_threshold);
final float slop = ViewConfiguration.get(context).getScaledTouchSlop();
final float slop = viewConfig.getScaledTouchSlop();
mSquaredSlop = slop * slop;
updateIsEnabled();

3
libs/WindowManager/Shell/src/com/android/wm/shell/onehanded/OneHandedTutorialHandler.java
View File

@@ -103,8 +103,7 @@ public class OneHandedTutorialHandler implements OneHandedTransitionCallback {
mPackageName = context.getPackageName();
mContentResolver = context.getContentResolver();
mWindowManager = context.getSystemService(WindowManager.class);
mAccessibilityManager = (AccessibilityManager)
context.getSystemService(Context.ACCESSIBILITY_SERVICE);
mAccessibilityManager = AccessibilityManager.getInstance(context);
mStartOneHandedDescription = context.getResources().getString(
R.string.accessibility_action_start_one_handed);

3
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedAnimationControllerTest.java
View File

@@ -47,7 +47,6 @@ public class OneHandedAnimationControllerTest extends OneHandedTestCase {
private static final int TEST_BOUNDS_HEIGHT = 1000;
OneHandedAnimationController mOneHandedAnimationController;
OneHandedTutorialHandler mTutorialHandler;
@Mock
private SurfaceControl mMockLeash;
@@ -60,8 +59,6 @@ public class OneHandedAnimationControllerTest extends OneHandedTestCase {
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
mTutorialHandler = new OneHandedTutorialHandler(mContext, mMainExecutor);
mOneHandedAnimationController = new OneHandedAnimationController(mContext);
}

11
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedBackgroundPanelOrganizerTest.java
View File

@@ -59,7 +59,7 @@ public class OneHandedBackgroundPanelOrganizerTest extends OneHandedTestCase {
DisplayController mMockDisplayController;
@Before
public void setUp() throws Exception {
public void setUp() {
MockitoAnnotations.initMocks(this);
mTestableLooper = TestableLooper.get(this);
mToken = new WindowContainerToken(mMockRealToken);
@@ -81,15 +81,6 @@ public class OneHandedBackgroundPanelOrganizerTest extends OneHandedTestCase {
assertThat(mBackgroundPanelOrganizer.getBackgroundSurface()).isNotNull();
}
@Test
public void testUnregisterOrganizer() {
mBackgroundPanelOrganizer.onDisplayAreaAppeared(mDisplayAreaInfo, mLeash);
mTestableLooper.processAllMessages();
mBackgroundPanelOrganizer.unregisterOrganizer();
assertThat(mBackgroundPanelOrganizer.getBackgroundSurface()).isNull();
}
@Test
public void testShowBackgroundLayer() {
mBackgroundPanelOrganizer.onDisplayAreaAppeared(mDisplayAreaInfo, mLeash);

132
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedControllerTest.java
View File

@@ -16,17 +16,20 @@
package com.android.wm.shell.onehanded;
import static android.window.DisplayAreaOrganizer.FEATURE_ONE_HANDED;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.om.IOverlayManager;
import android.os.Handler;
import android.provider.Settings;
import android.testing.AndroidTestingRunner;
import android.util.ArrayMap;
import android.view.Display;
@@ -39,19 +42,17 @@ import com.android.wm.shell.common.ShellExecutor;
import com.android.wm.shell.common.TaskStackListenerImpl;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
@SmallTest
@RunWith(AndroidTestingRunner.class)
public class OneHandedControllerTest extends OneHandedTestCase {
Display mDisplay;
OneHandedController mOneHandedController;
OneHandedTimeoutHandler mTimeoutHandler;
OneHandedController mSpiedOneHandedController;
OneHandedTimeoutHandler mSpiedTimeoutHandler;
@Mock
DisplayController mMockDisplayController;
@@ -66,8 +67,6 @@ public class OneHandedControllerTest extends OneHandedTestCase {
@Mock
OneHandedGestureHandler mMockGestureHandler;
@Mock
OneHandedTimeoutHandler mMockTimeoutHandler;
@Mock
OneHandedUiEventLogger mMockUiEventLogger;
@Mock
IOverlayManager mMockOverlayManager;
@@ -80,18 +79,24 @@ public class OneHandedControllerTest extends OneHandedTestCase {
@Mock
Handler mMockShellMainHandler;
final boolean mDefaultEnabled = OneHandedSettingsUtil.getSettingsOneHandedModeEnabled(
getTestContext().getContentResolver());
final boolean mDefaultSwipeToNotificationEnabled =
OneHandedSettingsUtil.getSettingsSwipeToNotificationEnabled(
getTestContext().getContentResolver());
@Before
public void setUp() throws Exception {
public void setUp() {
MockitoAnnotations.initMocks(this);
mDisplay = mContext.getDisplay();
mTimeoutHandler = Mockito.spy(new OneHandedTimeoutHandler(mMockShellMainExecutor));
mSpiedTimeoutHandler = spy(new OneHandedTimeoutHandler(mMockShellMainExecutor));
when(mMockDisplayController.getDisplay(anyInt())).thenReturn(mDisplay);
when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(false);
when(mMockDisplayAreaOrganizer.getDisplayAreaTokenMap()).thenReturn(new ArrayMap<>());
when(mMockBackgroundOrganizer.getBackgroundSurface()).thenReturn(mMockLeash);
OneHandedController oneHandedController = new OneHandedController(
mSpiedOneHandedController = spy(new OneHandedController(
mContext,
mMockDisplayController,
mMockBackgroundOrganizer,
@@ -99,13 +104,13 @@ public class OneHandedControllerTest extends OneHandedTestCase {
mMockTouchHandler,
mMockTutorialHandler,
mMockGestureHandler,
mTimeoutHandler,
mSpiedTimeoutHandler,
mMockUiEventLogger,
mMockOverlayManager,
mMockTaskStackListener,
mMockShellMainExecutor,
mMockShellMainHandler);
mOneHandedController = Mockito.spy(oneHandedController);
mMockShellMainHandler)
);
}
@Test
@@ -120,32 +125,36 @@ public class OneHandedControllerTest extends OneHandedTestCase {
}
@Test
public void testEnabledNoRegisterAndUnregisterInSameCall() {
mOneHandedController.setOneHandedEnabled(true);
verify(mMockDisplayAreaOrganizer).registerOrganizer(anyInt());
public void testNoRegisterAndUnregisterInSameCall() {
if (mDefaultEnabled) {
verify(mMockDisplayAreaOrganizer, never()).unregisterOrganizer();
} else {
verify(mMockDisplayAreaOrganizer, never()).registerOrganizer(FEATURE_ONE_HANDED);
}
}
@Test
public void testDisabledNoRegisterAndUnregisterInSameCall() {
mOneHandedController.setOneHandedEnabled(false);
verify(mMockDisplayAreaOrganizer, never()).registerOrganizer(anyInt());
}
@Test
public void testStartOneHanded() {
mOneHandedController.setOneHandedEnabled(true);
mOneHandedController.startOneHanded();
public void testStartOneHandedShouldTriggerScheduleOffset() {
when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(false);
mSpiedOneHandedController.setOneHandedEnabled(true);
mSpiedOneHandedController.startOneHanded();
verify(mMockDisplayAreaOrganizer).scheduleOffset(anyInt(), anyInt());
}
@Test
public void testStartOneHandedShouldNotTriggerScheduleOffset() {
mSpiedOneHandedController.setOneHandedEnabled(true);
when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(true);
mSpiedOneHandedController.startOneHanded();
verify(mMockDisplayAreaOrganizer, never()).scheduleOffset(anyInt(), anyInt());
}
@Test
public void testStopOneHanded() {
when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(false);
mOneHandedController.setOneHandedEnabled(true);
mOneHandedController.stopOneHanded();
mSpiedOneHandedController.stopOneHanded();
verify(mMockDisplayAreaOrganizer, never()).scheduleOffset(anyInt(), anyInt());
}
@@ -159,71 +168,66 @@ public class OneHandedControllerTest extends OneHandedTestCase {
@Test
public void testRegisterTransitionCallback() {
OneHandedTransitionCallback callback = new OneHandedTransitionCallback() {};
mOneHandedController.registerTransitionCallback(callback);
OneHandedTransitionCallback callback = new OneHandedTransitionCallback() {
};
mSpiedOneHandedController.registerTransitionCallback(callback);
verify(mMockDisplayAreaOrganizer).registerTransitionCallback(callback);
}
@Test
public void testStopOneHanded_shouldRemoveTimer() {
mOneHandedController.stopOneHanded();
when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(true);
mSpiedOneHandedController.stopOneHanded();
verify(mTimeoutHandler).removeTimer();
verify(mSpiedTimeoutHandler, atLeastOnce()).removeTimer();
}
@Test
public void testUpdateIsEnabled() {
final boolean enabled = true;
mOneHandedController.setOneHandedEnabled(enabled);
public void testUpdateEnabled() {
mSpiedOneHandedController.setOneHandedEnabled(true);
verify(mMockTouchHandler, atLeastOnce()).onOneHandedEnabled(enabled);
verify(mMockTouchHandler, atLeastOnce()).onOneHandedEnabled(mDefaultEnabled);
verify(mMockGestureHandler, atLeastOnce()).onOneHandedEnabled(
mDefaultEnabled || mDefaultSwipeToNotificationEnabled);
}
@Test
public void testUpdateSwipeToNotificationIsEnabled() {
final boolean enabled = true;
mOneHandedController.setSwipeToNotificationEnabled(enabled);
public void testUpdateSwipeToNotificationEnabled() {
final boolean swipeToNotificationEnabled = true;
mSpiedOneHandedController.setSwipeToNotificationEnabled(swipeToNotificationEnabled);
verify(mMockGestureHandler, atLeastOnce()).onOneHandedEnabled(enabled);
verify(mMockTouchHandler, atLeastOnce()).onOneHandedEnabled(mDefaultEnabled);
verify(mMockGestureHandler, atLeastOnce()).onOneHandedEnabled(
mDefaultEnabled || swipeToNotificationEnabled);
}
@Ignore("b/167943723, refactor it and fix it")
@Test
public void tesSettingsObserver_updateTapAppToExit() {
Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.TAPS_APP_TO_EXIT, 1);
public void testUpdateTapAppToExitUpdate() {
mSpiedOneHandedController.onTaskChangeExitSettingChanged();
verify(mOneHandedController).setTaskChangeToExit(true);
verify(mMockTaskStackListener, atLeastOnce()).addListener(any());
}
@Ignore("b/167943723, refactor it and fix it")
@Test
public void tesSettingsObserver_updateEnabled() {
Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ONE_HANDED_MODE_ENABLED, 1);
public void tesSettingsObserverUpdateEnabled() {
mSpiedOneHandedController.onEnabledSettingChanged();
verify(mOneHandedController).setOneHandedEnabled(true);
verify(mSpiedOneHandedController, atLeastOnce()).setOneHandedEnabled(mDefaultEnabled);
}
@Ignore("b/167943723, refactor it and fix it")
@Test
public void tesSettingsObserver_updateTimeout() {
Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ONE_HANDED_MODE_TIMEOUT,
OneHandedSettingsUtil.ONE_HANDED_TIMEOUT_MEDIUM_IN_SECONDS);
public void testSettingsObserverUpdateTimeout() {
mSpiedOneHandedController.onTimeoutSettingChanged();
verify(mMockTimeoutHandler).setTimeout(
OneHandedSettingsUtil.ONE_HANDED_TIMEOUT_MEDIUM_IN_SECONDS);
verify(mSpiedTimeoutHandler, atLeastOnce()).setTimeout(anyInt());
}
@Ignore("b/167943723, refactor it and fix it")
@Test
public void tesSettingsObserver_updateSwipeToNotification() {
Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.SWIPE_BOTTOM_TO_NOTIFICATION_ENABLED, 1);
public void tesSettingsObserverUpdateSwipeToNotification() {
mSpiedOneHandedController.onSwipeToNotificationEnabledSettingChanged();
verify(mOneHandedController).setSwipeToNotificationEnabled(true);
verify(mSpiedOneHandedController, atLeastOnce()).setSwipeToNotificationEnabled(
!mDefaultEnabled);
}
}

109
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedDisplayAreaOrganizerTest.java
View File

@@ -27,6 +27,7 @@ import static org.mockito.Mockito.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -37,6 +38,7 @@ import android.testing.TestableLooper;
import android.view.Display;
import android.view.Surface;
import android.view.SurfaceControl;
import android.window.DisplayAreaAppearedInfo;
import android.window.DisplayAreaInfo;
import android.window.IWindowContainerToken;
import android.window.WindowContainerToken;
@@ -53,15 +55,19 @@ import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.util.ArrayList;
import java.util.List;
@SmallTest
@RunWith(AndroidTestingRunner.class)
public class OneHandedDisplayAreaOrganizerTest extends OneHandedTestCase {
static final int DISPLAYAREA_INFO_COUNT = 3;
static final int DISPLAY_WIDTH = 1000;
static final int DISPLAY_HEIGHT = 1000;
DisplayAreaInfo mDisplayAreaInfo;
Display mDisplay;
OneHandedDisplayAreaOrganizer mDisplayAreaOrganizer;
OneHandedDisplayAreaOrganizer mSpiedDisplayAreaOrganizer;
OneHandedTutorialHandler mTutorialHandler;
OneHandedAnimationController.OneHandedTransitionAnimator mFakeAnimator;
WindowContainerToken mToken;
@@ -86,6 +92,8 @@ public class OneHandedDisplayAreaOrganizerTest extends OneHandedTestCase {
@Mock
ShellExecutor mMockShellMainExecutor;
List<DisplayAreaAppearedInfo> mDisplayAreaAppearedInfoList = new ArrayList<>();
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
@@ -112,170 +120,195 @@ public class OneHandedDisplayAreaOrganizerTest extends OneHandedTestCase {
when(mMockLeash.getWidth()).thenReturn(DISPLAY_WIDTH);
when(mMockLeash.getHeight()).thenReturn(DISPLAY_HEIGHT);
mDisplayAreaOrganizer = spy(new OneHandedDisplayAreaOrganizer(mContext,
mSpiedDisplayAreaOrganizer = spy(new OneHandedDisplayAreaOrganizer(mContext,
mMockDisplayController,
mMockAnimationController,
mTutorialHandler,
mMockBackgroundOrganizer,
mMockShellMainExecutor));
for (int i = 0; i < DISPLAYAREA_INFO_COUNT; i++) {
mDisplayAreaAppearedInfoList.add(getDummyDisplayAreaInfo());
}
doReturn(mDisplayAreaAppearedInfoList).when(mSpiedDisplayAreaOrganizer).registerOrganizer(
FEATURE_ONE_HANDED);
}
private DisplayAreaAppearedInfo getDummyDisplayAreaInfo() {
return new DisplayAreaAppearedInfo(mDisplayAreaInfo, mMockLeash);
}
@Test
public void testRegisterDisplayAreaOrganizer() {
assertThat(mSpiedDisplayAreaOrganizer.registerOrganizer(FEATURE_ONE_HANDED)).isNotNull();
}
@Test
public void testOnDisplayAreaAppeared() {
mDisplayAreaOrganizer.onDisplayAreaAppeared(mDisplayAreaInfo, mLeash);
mDisplayAreaAppearedInfoList.forEach(
(info) -> mSpiedDisplayAreaOrganizer.onDisplayAreaAppeared(
info.getDisplayAreaInfo(),
info.getLeash()));
verify(mMockAnimationController, never()).getAnimator(any(), any(), any(), any());
}
@Test
public void testOnDisplayAreaVanished() {
mDisplayAreaOrganizer.onDisplayAreaAppeared(mDisplayAreaInfo, mLeash);
mDisplayAreaOrganizer.onDisplayAreaVanished(mDisplayAreaInfo);
mDisplayAreaAppearedInfoList.forEach(
(info) -> mSpiedDisplayAreaOrganizer.onDisplayAreaAppeared(
info.getDisplayAreaInfo(),
info.getLeash()));
assertThat(mDisplayAreaOrganizer.getDisplayAreaTokenMap()).isEmpty();
mDisplayAreaAppearedInfoList.forEach(
(info) -> mSpiedDisplayAreaOrganizer.onDisplayAreaVanished(
info.getDisplayAreaInfo()));
verify(mSpiedDisplayAreaOrganizer, times(DISPLAYAREA_INFO_COUNT)).onDisplayAreaVanished(
any());
}
@Test
public void testRotation_portrait_0_to_landscape_90() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 0 -> 90
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_90,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_90,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_portrait_0_to_seascape_270() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 0 -> 270
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_270,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_270,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_portrait_180_to_landscape_90() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 180 -> 90
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_90,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_90,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_portrait_180_to_seascape_270() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 180 -> 270
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_270,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_270,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_landscape_90_to_portrait_0() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 90 -> 0
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_0,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_0,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_landscape_90_to_portrait_180() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 90 -> 180
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_180,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_180,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_Seascape_270_to_portrait_0() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 270 -> 0
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_0,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_0,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_seascape_90_to_portrait_180() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 270 -> 180
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_180,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_180,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_portrait_0_to_portrait_0() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 0 -> 0
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_0,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_0,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_portrait_0_to_portrait_180() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 0 -> 180
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_180,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_180,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_portrait_180_to_portrait_180() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 180 -> 180
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_180,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_180,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_portrait_180_to_portrait_0() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 180 -> 0
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_0,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_0,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_landscape_90_to_landscape_90() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 90 -> 90
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_90,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_90,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_landscape_90_to_seascape_270() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 90 -> 270
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_270,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_270,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_seascape_270_to_seascape_270() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 270 -> 270
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_270,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_270,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
}
@Test
public void testRotation_seascape_90_to_landscape_90() {
when(mMockLeash.isValid()).thenReturn(false);
// Rotate 270 -> 90
mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_90,
mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_90,
mMockWindowContainerTransaction);
verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
}
}

21
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedGestureHandlerTest.java
View File

@@ -18,10 +18,8 @@ package com.android.wm.shell.onehanded;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
import android.view.ViewConfiguration;
import androidx.test.filters.SmallTest;
@@ -29,7 +27,6 @@ import com.android.wm.shell.common.DisplayController;
import com.android.wm.shell.common.ShellExecutor;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
@@ -38,7 +35,6 @@ import org.mockito.MockitoAnnotations;
@SmallTest
@RunWith(AndroidTestingRunner.class)
public class OneHandedGestureHandlerTest extends OneHandedTestCase {
OneHandedTutorialHandler mTutorialHandler;
OneHandedGestureHandler mGestureHandler;
@Mock
DisplayController mMockDisplayController;
@@ -46,11 +42,10 @@ public class OneHandedGestureHandlerTest extends OneHandedTestCase {
ShellExecutor mMockShellMainExecutor;
@Before
public void setUp() throws Exception {
public void setUp() {
MockitoAnnotations.initMocks(this);
mTutorialHandler = new OneHandedTutorialHandler(mContext, mMockShellMainExecutor);
mGestureHandler = new OneHandedGestureHandler(mContext, mMockDisplayController,
mMockShellMainExecutor);
ViewConfiguration.get(mTestContext), mMockShellMainExecutor);
}
@Test
@@ -68,16 +63,6 @@ public class OneHandedGestureHandlerTest extends OneHandedTestCase {
assertThat(mGestureHandler.mGestureEventCallback).isEqualTo(callback);
}
@Ignore("b/167943723, refactor it and fix it")
@Test
public void testReceiveNewConfig_whenThreeButtonModeEnabled() {
mGestureHandler.onOneHandedEnabled(true);
mGestureHandler.onThreeButtonModeEnabled(true);
assertThat(mGestureHandler.mInputMonitor).isNotNull();
assertThat(mGestureHandler.mInputEventReceiver).isNotNull();
}
@Test
public void testOneHandedDisabled_shouldDisposeInputChannel() {
mGestureHandler.onOneHandedEnabled(false);

1
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedSettingsUtilTest.java
View File

@@ -28,7 +28,6 @@ import android.database.ContentObserver;
import android.net.Uri;
import android.provider.Settings;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
import androidx.test.filters.SmallTest;

71
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedTestCase.java
View File

@@ -19,86 +19,47 @@ package com.android.wm.shell.onehanded;
import static android.view.Display.DEFAULT_DISPLAY;
import static com.android.wm.shell.onehanded.OneHandedController.SUPPORT_ONE_HANDED_MODE;
import static com.android.wm.shell.onehanded.OneHandedSettingsUtil.ONE_HANDED_TIMEOUT_MEDIUM_IN_SECONDS;
import static org.junit.Assume.assumeTrue;
import android.content.Context;
import android.hardware.display.DisplayManager;
import android.os.SystemProperties;
import android.provider.Settings;
import android.testing.TestableContext;
import androidx.test.platform.app.InstrumentationRegistry;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.mockito.Answers;
import org.mockito.Mock;
/**
* Base class that does One Handed specific setup.
*/
public abstract class OneHandedTestCase {
static boolean sOrigEnabled;
static boolean sOrigTapsAppToExitEnabled;
static int sOrigTimeout;
static boolean sOrigSwipeToNotification;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
protected Context mContext;
@Rule
public TestableContext mTestContext = new TestableContext(
InstrumentationRegistry.getInstrumentation().getTargetContext(), null);
@Before
public void setupSettings() {
public void setUpContext() {
assumeTrue(SystemProperties.getBoolean(SUPPORT_ONE_HANDED_MODE, false));
final Context testContext =
InstrumentationRegistry.getInstrumentation().getTargetContext();
final DisplayManager dm = testContext.getSystemService(DisplayManager.class);
mContext = testContext.createDisplayContext(dm.getDisplay(DEFAULT_DISPLAY));
InstrumentationRegistry
.getInstrumentation()
.getUiAutomation()
.adoptShellPermissionIdentity();
sOrigEnabled = OneHandedSettingsUtil.getSettingsOneHandedModeEnabled(
getContext().getContentResolver());
sOrigTimeout = OneHandedSettingsUtil.getSettingsOneHandedModeTimeout(
getContext().getContentResolver());
sOrigTapsAppToExitEnabled = OneHandedSettingsUtil.getSettingsTapsAppToExit(
getContext().getContentResolver());
sOrigSwipeToNotification = OneHandedSettingsUtil.getSettingsSwipeToNotificationEnabled(
getContext().getContentResolver());
Settings.Secure.putInt(getContext().getContentResolver(),
Settings.Secure.ONE_HANDED_MODE_TIMEOUT, ONE_HANDED_TIMEOUT_MEDIUM_IN_SECONDS);
Settings.Secure.putInt(getContext().getContentResolver(),
Settings.Secure.TAPS_APP_TO_EXIT, 1);
Settings.Secure.putInt(getContext().getContentResolver(),
Settings.Secure.SWIPE_BOTTOM_TO_NOTIFICATION_ENABLED, 1);
final DisplayManager dm = getTestContext().getSystemService(DisplayManager.class);
mContext = getTestContext().createDisplayContext(dm.getDisplay(DEFAULT_DISPLAY));
}
@After
public void restoreSettings() {
if (mContext == null) {
// Return early if one-handed mode is not supported
return;
}
Settings.Secure.putInt(getContext().getContentResolver(),
Settings.Secure.ONE_HANDED_MODE_ENABLED, sOrigEnabled ? 1 : 0);
Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ONE_HANDED_MODE_TIMEOUT, sOrigTimeout);
Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.TAPS_APP_TO_EXIT, sOrigTapsAppToExitEnabled ? 1 : 0);
Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.SWIPE_BOTTOM_TO_NOTIFICATION_ENABLED,
sOrigSwipeToNotification ? 1 : 0);
InstrumentationRegistry
.getInstrumentation()
.getUiAutomation()
.dropShellPermissionIdentity();
/** return testable context */
protected TestableContext getTestContext() {
return mTestContext;
}
/** return display context */
protected Context getContext() {
return mContext;
}
}

8
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedTimeoutHandlerTest.java
View File

@@ -27,24 +27,18 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.verify;
import android.os.Looper;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
import androidx.test.filters.SmallTest;
import com.android.wm.shell.TestShellExecutor;
import com.android.wm.shell.common.ShellExecutor;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import java.util.ArrayList;
@SmallTest
@RunWith(AndroidTestingRunner.class)
public class OneHandedTimeoutHandlerTest extends OneHandedTestCase {
@@ -52,7 +46,7 @@ public class OneHandedTimeoutHandlerTest extends OneHandedTestCase {
private TestShellExecutor mMainExecutor;
@Before
public void setUp() throws Exception {
public void setUp() {
MockitoAnnotations.initMocks(this);
mMainExecutor = new TestShellExecutor();
mTimeoutHandler = Mockito.spy(new OneHandedTimeoutHandler(mMainExecutor));

19
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedTouchHandlerTest.java
View File

@@ -18,8 +18,9 @@ package com.android.wm.shell.onehanded;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.spy;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
import androidx.test.filters.SmallTest;
@@ -35,18 +36,20 @@ import org.mockito.MockitoAnnotations;
@SmallTest
@RunWith(AndroidTestingRunner.class)
public class OneHandedTouchHandlerTest extends OneHandedTestCase {
boolean mIsEventCallback = false;
private OneHandedTouchHandler mTouchHandler;
private OneHandedTimeoutHandler mSpiedTimeoutHandler;
private OneHandedTouchHandler.OneHandedTouchEventCallback mTouchEventCallback =
() -> mIsEventCallback = true;
@Mock
private OneHandedTimeoutHandler mTimeoutHandler;
@Mock
private ShellExecutor mMainExecutor;
private ShellExecutor mMockShellMainExecutor;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mTouchHandler = new OneHandedTouchHandler(mTimeoutHandler, mMainExecutor);
mSpiedTimeoutHandler = spy(new OneHandedTimeoutHandler(mMockShellMainExecutor));
mTouchHandler = new OneHandedTouchHandler(mSpiedTimeoutHandler, mMockShellMainExecutor);
}
@Test
@@ -55,7 +58,7 @@ public class OneHandedTouchHandlerTest extends OneHandedTestCase {
};
mTouchHandler.registerTouchEventListener(callback);
assertThat(mTouchHandler.mTouchEventCallback).isEqualTo(callback);
assertThat(mIsEventCallback).isFalse();
}
@Test

22
libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedTutorialHandlerTest.java
View File

@@ -39,12 +39,15 @@ import org.mockito.MockitoAnnotations;
@SmallTest
@RunWith(AndroidTestingRunner.class)
public class OneHandedTutorialHandlerTest extends OneHandedTestCase {
@Mock
OneHandedTouchHandler mTouchHandler;
OneHandedTutorialHandler mTutorialHandler;
OneHandedGestureHandler mGestureHandler;
OneHandedTimeoutHandler mTimeoutHandler;
OneHandedController mOneHandedController;
@Mock
OneHandedGestureHandler mMockGestureHandler;
@Mock
OneHandedTouchHandler mMockTouchHandler;
@Mock
OneHandedTutorialHandler mMockTutorialHandler;
@Mock
DisplayController mMockDisplayController;
@Mock
@@ -66,10 +69,7 @@ public class OneHandedTutorialHandlerTest extends OneHandedTestCase {
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mTutorialHandler = new OneHandedTutorialHandler(mContext, mMockShellMainExecutor);
mTimeoutHandler = new OneHandedTimeoutHandler(mMockShellMainExecutor);
mGestureHandler = new OneHandedGestureHandler(mContext, mMockDisplayController,
mMockShellMainExecutor);
when(mMockDisplayAreaOrganizer.getDisplayAreaTokenMap()).thenReturn(new ArrayMap<>());
mOneHandedController = new OneHandedController(
@@ -77,9 +77,9 @@ public class OneHandedTutorialHandlerTest extends OneHandedTestCase {
mMockDisplayController,
mMockBackgroundOrganizer,
mMockDisplayAreaOrganizer,
mTouchHandler,
mTutorialHandler,
mGestureHandler,
mMockTouchHandler,
mMockTutorialHandler,
mMockGestureHandler,
mTimeoutHandler,
mMockUiEventLogger,
mMockOverlayManager,
@@ -90,6 +90,6 @@ public class OneHandedTutorialHandlerTest extends OneHandedTestCase {
@Test
public void testRegisterForDisplayAreaOrganizer() {
verify(mMockDisplayAreaOrganizer).registerTransitionCallback(mTutorialHandler);
verify(mMockDisplayAreaOrganizer).registerTransitionCallback(mMockTutorialHandler);
}
}