From 26f70f777e44e05fa51b88ed3391a030d2eadde4 Mon Sep 17 00:00:00 2001 From: Pat Manning Date: Thu, 7 Jul 2022 13:50:39 +0100 Subject: [PATCH] Add DeviceProfile tests on all attributes across different configurations. Fix: 237542518 Test: DeviceProfilePhoneTest.kt Test: DeviceProfileVerticalBarTest.kt Test: DeviceProfilePhone3ButtonTest.kt Test: DeviceProfileVerticalBar3ButtonTest.kt Test: DeviceProfileTabletLandscapeTest.kt Test: DeviceProfileTabletPortraitTest.kt Test: DeviceProfileTabletLandscape3ButtonTest.kt Test: DeviceProfileTabletPortrait3ButtonTest.kt Test: DeviceProfileTwoPanelLandscapeTest.kt Test: DeviceProfileTwoPanelPortraitTest.kt Test: DeviceProfileTwoPanelLandscape3ButtonTest.kt Test: DeviceProfileTwoPanelPortrait3ButtonTest.kt Change-Id: I1596dcd1fb8c9b353cdfcab224d7670d88bed716 --- .../hybridhotseat/HotseatEduDialog.java | 4 +- .../launcher3/taskbar/TaskbarView.java | 3 +- .../launcher3/uioverrides/ApiWrapper.java | 25 - .../quickstep/views/OverviewActionsView.java | 6 +- .../DeviceProfilePhone3ButtonTest.kt | 486 ++++++++++++++++++ .../quickstep/DeviceProfilePhoneTest.kt | 486 ++++++++++++++++++ .../quickstep/DeviceProfileQuickstepTest.kt | 122 ----- ...DeviceProfileTabletLandscape3ButtonTest.kt | 486 ++++++++++++++++++ .../DeviceProfileTabletLandscapeTest.kt | 486 ++++++++++++++++++ .../DeviceProfileTabletPortrait3ButtonTest.kt | 486 ++++++++++++++++++ .../DeviceProfileTabletPortraitTest.kt | 486 ++++++++++++++++++ ...viceProfileTwoPanelLandscape3ButtonTest.kt | 486 ++++++++++++++++++ .../DeviceProfileTwoPanelLandscapeTest.kt | 486 ++++++++++++++++++ ...eviceProfileTwoPanelPortrait3ButtonTest.kt | 486 ++++++++++++++++++ .../DeviceProfileTwoPanelPortraitTest.kt | 486 ++++++++++++++++++ .../DeviceProfileVerticalBar3ButtonTest.kt | 486 ++++++++++++++++++ .../quickstep/DeviceProfileVerticalBarTest.kt | 486 ++++++++++++++++++ res/values/dimens.xml | 5 +- src/com/android/launcher3/DeviceProfile.java | 65 ++- .../launcher3/DeviceProfileBaseTest.kt | 40 +- .../launcher3/HotseatShownIconsTest.kt | 27 - .../com/android/launcher3/InlineQsbTest.kt | 103 ---- 22 files changed, 5918 insertions(+), 314 deletions(-) create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfilePhone3ButtonTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfilePhoneTest.kt delete mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileQuickstepTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscape3ButtonTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscapeTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortrait3ButtonTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortraitTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscape3ButtonTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscapeTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortrait3ButtonTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortraitTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBar3ButtonTest.kt create mode 100644 quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBarTest.kt delete mode 100644 tests/src/com/android/launcher3/InlineQsbTest.kt diff --git a/quickstep/src/com/android/launcher3/hybridhotseat/HotseatEduDialog.java b/quickstep/src/com/android/launcher3/hybridhotseat/HotseatEduDialog.java index 119ae907f7..7b48332e84 100644 --- a/quickstep/src/com/android/launcher3/hybridhotseat/HotseatEduDialog.java +++ b/quickstep/src/com/android/launcher3/hybridhotseat/HotseatEduDialog.java @@ -41,7 +41,6 @@ import com.android.launcher3.R; import com.android.launcher3.anim.Interpolators; import com.android.launcher3.config.FeatureFlags; import com.android.launcher3.model.data.WorkspaceItemInfo; -import com.android.launcher3.uioverrides.ApiWrapper; import com.android.launcher3.uioverrides.PredictedAppIcon; import com.android.launcher3.views.AbstractSlideInView; @@ -107,8 +106,7 @@ public class HotseatEduDialog extends AbstractSlideInView implements I mDismissBtn.setOnClickListener(this::onDismiss); LinearLayout buttonContainer = findViewById(R.id.button_container); - int adjustedMarginEnd = ApiWrapper.getHotseatEndOffset(context) - - buttonContainer.getPaddingEnd(); + int adjustedMarginEnd = grid.hotseatBarEndOffset - buttonContainer.getPaddingEnd(); if (InvariantDeviceProfile.INSTANCE.get(context) .getDeviceProfile(context).isTaskbarPresent && adjustedMarginEnd > 0) { ((LinearLayout.LayoutParams) buttonContainer.getLayoutParams()).setMarginEnd( diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java index 6a43cc5f4b..ea15acb78d 100644 --- a/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java +++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java @@ -42,7 +42,6 @@ import com.android.launcher3.icons.ThemedIconDrawable; import com.android.launcher3.model.data.FolderInfo; import com.android.launcher3.model.data.ItemInfo; import com.android.launcher3.model.data.WorkspaceItemInfo; -import com.android.launcher3.uioverrides.ApiWrapper; import com.android.launcher3.util.LauncherBindableItemsContainer; import com.android.launcher3.views.ActivityContext; import com.android.launcher3.views.AllAppsButton; @@ -292,7 +291,7 @@ public class TaskbarView extends FrameLayout implements FolderIcon.FolderIconPar countExcludingQsb--; } int spaceNeeded = countExcludingQsb * (mItemMarginLeftRight * 2 + mIconTouchSize); - int navSpaceNeeded = ApiWrapper.getHotseatEndOffset(getContext()); + int navSpaceNeeded = deviceProfile.hotseatBarEndOffset; boolean layoutRtl = isLayoutRtl(); int iconEnd = right - (right - left - spaceNeeded) / 2; boolean needMoreSpaceForNav = layoutRtl ? diff --git a/quickstep/src/com/android/launcher3/uioverrides/ApiWrapper.java b/quickstep/src/com/android/launcher3/uioverrides/ApiWrapper.java index 2f8e4d9dde..f450496b3b 100644 --- a/quickstep/src/com/android/launcher3/uioverrides/ApiWrapper.java +++ b/quickstep/src/com/android/launcher3/uioverrides/ApiWrapper.java @@ -17,14 +17,9 @@ package com.android.launcher3.uioverrides; import android.app.Person; -import android.content.Context; import android.content.pm.ShortcutInfo; -import android.content.res.Resources; -import com.android.launcher3.R; import com.android.launcher3.Utilities; -import com.android.launcher3.util.DisplayController; -import com.android.launcher3.util.DisplayController.NavigationMode; public class ApiWrapper { @@ -34,24 +29,4 @@ public class ApiWrapper { Person[] persons = si.getPersons(); return persons == null ? Utilities.EMPTY_PERSON_ARRAY : persons; } - - /** - * Returns the minimum space that should be left empty at the end of hotseat - */ - public static int getHotseatEndOffset(Context context) { - if (DisplayController.getNavigationMode(context) == NavigationMode.THREE_BUTTONS) { - Resources res = context.getResources(); - /* - * 3 nav buttons + - * Little space at the end for contextual buttons + - * Little space between icons and nav buttons - */ - return 3 * res.getDimensionPixelSize(R.dimen.taskbar_nav_buttons_size) - + res.getDimensionPixelSize(R.dimen.taskbar_contextual_button_margin) - + res.getDimensionPixelSize(R.dimen.taskbar_hotseat_nav_spacing); - } else { - return 0; - } - - } } diff --git a/quickstep/src/com/android/quickstep/views/OverviewActionsView.java b/quickstep/src/com/android/quickstep/views/OverviewActionsView.java index bfb43c1dc2..9b585fcf8b 100644 --- a/quickstep/src/com/android/quickstep/views/OverviewActionsView.java +++ b/quickstep/src/com/android/quickstep/views/OverviewActionsView.java @@ -31,7 +31,6 @@ import androidx.annotation.Nullable; import com.android.launcher3.DeviceProfile; import com.android.launcher3.Insettable; import com.android.launcher3.R; -import com.android.launcher3.uioverrides.ApiWrapper; import com.android.launcher3.util.DisplayController; import com.android.launcher3.util.DisplayController.NavigationMode; import com.android.launcher3.util.MultiValueAlpha; @@ -206,10 +205,9 @@ public class OverviewActionsView extends FrameLayo if (mDp == null) { return; } - boolean alignFor3ButtonTaskbar = mDp.isTaskbarPresent && !mDp.isGestureMode; - if (alignFor3ButtonTaskbar) { + if (mDp.areNavButtonsInline) { // Add extra horizontal spacing - int additionalPadding = ApiWrapper.getHotseatEndOffset(getContext()); + int additionalPadding = mDp.hotseatBarEndOffset; if (isLayoutRtl()) { setPadding(mInsets.left + additionalPadding, 0, mInsets.right, 0); } else { diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfilePhone3ButtonTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfilePhone3ButtonTest.kt new file mode 100644 index 0000000000..3daf81d8a6 --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfilePhone3ButtonTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for phone with 3-Button navigation. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfilePhone3ButtonTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForPhone(isGestureMode = false) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(265) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(343) + } + + @Test + fun getCellSizeX() { + assertThat(dp.getCellSize().x).isEqualTo(265) + } + + @Test + fun getCellSizeY() { + assertThat(dp.getCellSize().y).isEqualTo(552) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(66) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(66) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(38) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(38) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(38) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(196) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(49) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(25) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(265) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(343) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(196) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(49) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(27) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(38) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1050) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(0) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(232) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(58) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(25) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(409) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(265) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(66) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(66) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(91) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(0) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(669) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(221) + } + + @Test + fun hotseatBarBottomPaddingPx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(168) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(126) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(221) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(266) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(4) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(135) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(1189) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(false) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(0) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(91) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(53) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(53) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(573) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.182266f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(56) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(0) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(168) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(154) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(0) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(280) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(84) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(168) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(126) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(56) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(-112) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(0) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(112) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(196) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(56) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(84) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.74417657f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(2447) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(1334) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(1) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(364) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(2185) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(147) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(558) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(125) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(0) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(125) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(448) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(0) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfilePhoneTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfilePhoneTest.kt new file mode 100644 index 0000000000..e588c71277 --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfilePhoneTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for phone. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfilePhoneTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForPhone() + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(265) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(343) + } + + @Test + fun getCellSizeX() { + assertThat(dp.getCellSize().x).isEqualTo(265) + } + + @Test + fun getCellSizeY() { + assertThat(dp.getCellSize().y).isEqualTo(552) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(66) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(66) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(38) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(38) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(38) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(196) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(49) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(25) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(265) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(343) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(196) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(49) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(27) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(38) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1050) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(0) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(232) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(58) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(25) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(409) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(265) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(66) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(66) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(91) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(0) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(669) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(221) + } + + @Test + fun hotseatBarBottomPaddingPx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(168) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(126) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(221) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(266) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(4) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(135) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(1189) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(false) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(0) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(91) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(53) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(53) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(573) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.182266f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(56) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(0) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(168) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(154) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(0) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(280) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(84) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(168) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(126) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(56) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(-112) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(0) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(112) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(196) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(56) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(84) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.74417657f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(2447) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(1334) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(1) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(364) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(2185) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(147) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(558) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(125) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(0) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(125) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(448) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(0) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileQuickstepTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileQuickstepTest.kt deleted file mode 100644 index 20b5a64e50..0000000000 --- a/quickstep/tests/src/com/android/quickstep/DeviceProfileQuickstepTest.kt +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Copyright (C) 2022 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.quickstep - -import androidx.test.ext.junit.runners.AndroidJUnit4 -import androidx.test.filters.SmallTest -import com.android.launcher3.DeviceProfileBaseTest -import com.android.launcher3.InvariantDeviceProfile -import com.android.launcher3.util.WindowBounds -import com.google.common.truth.Truth.assertThat -import org.junit.Test -import org.junit.runner.RunWith -import org.mockito.ArgumentMatchers -import org.mockito.Mockito.`when` as whenever - -/** - * Test for [DeviceProfile] quickstep. - */ -@SmallTest -@RunWith(AndroidJUnit4::class) -class DeviceProfileQuickstepTest : DeviceProfileBaseTest() { - - @Test - fun getCellLayoutWidthAndHeight_twoPanelLandscapeScalable4By4GridTablet() { - val tabletWidth = 2560 - val tabletHeight = 1600 - val availableWidth = 2560 - val availableHeight = 1500 - windowBounds = WindowBounds(tabletWidth, tabletHeight, availableWidth, availableHeight, 0) - useTwoPanels = true - whenever(info.isTablet(ArgumentMatchers.any())).thenReturn(true) - whenever(info.densityDpi).thenReturn(320) - whenever(info.smallestSizeDp(ArgumentMatchers.any())).thenReturn(800f) - inv = newScalableInvariantDeviceProfile() - - val dp = newDP() - - assertThat(dp.cellLayoutWidth).isEqualTo(1237) - assertThat(dp.cellLayoutHeight).isEqualTo(1215) - } - - @Test - fun getCellSize_twoPanelLandscapeScalable4By4GridTablet() { - val tabletWidth = 2560 - val tabletHeight = 1600 - val availableWidth = 2560 - val availableHeight = 1500 - windowBounds = WindowBounds(tabletWidth, tabletHeight, availableWidth, availableHeight, 0) - useTwoPanels = true - whenever(info.isTablet(ArgumentMatchers.any())).thenReturn(true) - whenever(info.densityDpi).thenReturn(320) - whenever(info.smallestSizeDp(ArgumentMatchers.any())).thenReturn(800f) - inv = newScalableInvariantDeviceProfile() - - val dp = newDP() - - assertThat(dp.getCellSize().y).isEqualTo(260) - assertThat(dp.getCellSize().x).isEqualTo(259) - } - - @Test - fun getPanelCount_twoPanelLandscapeScalable4By4GridTablet() { - val tabletWidth = 2560 - val tabletHeight = 1600 - val availableWidth = 2560 - val availableHeight = 1500 - windowBounds = WindowBounds(tabletWidth, tabletHeight, availableWidth, availableHeight, 0) - useTwoPanels = true - whenever(info.isTablet(ArgumentMatchers.any())).thenReturn(true) - whenever(info.densityDpi).thenReturn(320) - whenever(info.smallestSizeDp(ArgumentMatchers.any())).thenReturn(800f) - inv = newScalableInvariantDeviceProfile() - - val dp = newDP() - - assertThat(dp.panelCount).isEqualTo(2) - } - - @Test - fun getWorkspaceSpringLoadShrunkTopBottom_landscapePhoneVerticalBar() { - inv = newScalableInvariantDeviceProfile() - initializeVarsForPhone(true) - inv = newScalableInvariantDeviceProfile().apply { - deviceType = InvariantDeviceProfile.TYPE_PHONE - transposeLayoutWithOrientation = true - } - - val dp = newDP() - - assertThat(dp.isVerticalBarLayout).isEqualTo(true) - assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(168) - assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1358) - } - - @Test - fun getWorkspaceSpringLoadShrunkTopBottom_portraitPhone() { - inv = newScalableInvariantDeviceProfile() - initializeVarsForPhone() - inv = newScalableInvariantDeviceProfile().apply { - deviceType = InvariantDeviceProfile.TYPE_PHONE - } - - val dp = newDP() - - assertThat(dp.isVerticalBarLayout).isEqualTo(false) - assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(364) - assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(2185) - } -} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscape3ButtonTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscape3ButtonTest.kt new file mode 100644 index 0000000000..3f8d2fb13f --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscape3ButtonTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for tablet in landscape with 3-Button navigation. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileTabletLandscape3ButtonTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForTablet(isLandscape = true, isGestureMode = false) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(227) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(294) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(558) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(294) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(57) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(57) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(59) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(59) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(59) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(112) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(28) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(227) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(294) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(112) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(28) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(48) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(0) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1600) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(0) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(199) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(50) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(351) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(227) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(57) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(57) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(64) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(1244) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(228) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(126) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(116) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(56) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(126) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(128) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(5) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(32) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(true) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(1237) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(true) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(120) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(78) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(19) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(19) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(93) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.7736843f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(32) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(32) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(96) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(88) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(88) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(160) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(40) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(96) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(72) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(88) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(40) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(128) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(0) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(144) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(64) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(48) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.7363184f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(1407) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(2522) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(1) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(208) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1244) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(109) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(112) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(1443) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(-7) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(428) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(109) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(428) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscapeTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscapeTest.kt new file mode 100644 index 0000000000..456ed2cfc0 --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscapeTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for tablet in landscape. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileTabletLandscapeTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForTablet(isLandscape = true) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(227) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(294) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(558) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(294) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(57) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(57) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(59) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(59) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(59) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(112) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(28) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(227) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(294) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(112) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(28) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(48) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(0) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1600) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(0) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(199) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(50) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(351) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(227) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(57) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(57) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(64) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(1244) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(228) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(126) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(116) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(56) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(126) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(128) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(4) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(503) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(true) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(-503) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(true) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(120) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(78) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(19) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(19) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(93) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.7736843f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(32) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(32) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(96) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(88) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(88) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(160) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(40) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(96) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(72) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(88) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(40) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(128) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(0) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(144) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(64) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(48) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.7363184f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(1407) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(2522) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(1) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(208) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1244) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(109) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(112) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(301) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(-7) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(301) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(109) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(0) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortrait3ButtonTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortrait3ButtonTest.kt new file mode 100644 index 0000000000..b53b36a9d9 --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortrait3ButtonTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for tablet in portrait with 3-Button navigation. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileTabletPortrait3ButtonTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForTablet(isGestureMode = false) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(294) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(382) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(294) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(482) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(74) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(74) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(72) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(72) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(72) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(112) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(28) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(294) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(382) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(112) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(28) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(77) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(600) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1960) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(600) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(257) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(64) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(456) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(294) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(74) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(74) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(56) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(781) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(386) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(126) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(116) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(56) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(126) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(216) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(4) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(32) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(1216) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(true) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(120) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(101) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(29) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(29) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(238) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(2.2988505f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(32) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(32) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(96) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(88) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(88) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(160) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(48) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(96) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(72) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(88) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(40) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(128) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(220) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(144) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(96) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(48) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.6741674f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(2222) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(1542) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(1) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(460) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1958) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(272) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(112) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(528) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(151) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(528) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(109) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(428) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortraitTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortraitTest.kt new file mode 100644 index 0000000000..4be3e45dce --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortraitTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for tablet in portrait. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileTabletPortraitTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForTablet() + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(294) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(382) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(294) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(482) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(74) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(74) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(72) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(72) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(72) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(112) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(28) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(294) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(382) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(112) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(28) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(77) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(600) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1960) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(600) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(257) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(64) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(456) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(294) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(74) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(74) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(56) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(781) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(386) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(126) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(116) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(56) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(126) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(216) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(4) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(256) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(1216) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(true) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(120) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(101) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(29) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(29) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(238) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(2.2988505f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(32) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(32) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(96) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(88) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(88) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(160) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(48) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(96) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(72) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(88) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(40) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(128) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(220) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(144) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(96) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(48) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.6741674f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(2222) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(1542) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(1) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(460) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1958) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(272) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(112) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(192) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(151) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(192) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(109) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(0) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscape3ButtonTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscape3ButtonTest.kt new file mode 100644 index 0000000000..274ca95405 --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscape3ButtonTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for two panel in landscape with 3-Button navigation. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileTwoPanelLandscape3ButtonTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForTablet(isLandscape = true, isTwoPanel = true, isGestureMode = false) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(200) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(260) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(259) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(260) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(50) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(50) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(25) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(25) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(25) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(112) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(28) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(200) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(260) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(112) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(28) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(36) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(0) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1600) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(0) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(175) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(44) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(310) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(200) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(50) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(50) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(64) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(1241) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(386) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(126) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(116) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(56) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(126) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(128) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(6) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(32) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(1039) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(true) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(120) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(68) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(43) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(43) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(285) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.5657895f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(32) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(32) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(96) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(88) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(88) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(160) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(40) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(96) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(72) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(88) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(40) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(128) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(0) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(144) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(64) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(48) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.7226337f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(1215) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(1237) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(2) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(208) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1086) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(272) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(112) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(864) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(151) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(864) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(109) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(428) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscapeTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscapeTest.kt new file mode 100644 index 0000000000..ba3ef55e3c --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscapeTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for two panel in landscape. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileTwoPanelLandscapeTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForTablet(isLandscape = true, isTwoPanel = true) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(200) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(260) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(259) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(260) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(50) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(50) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(25) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(25) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(25) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(112) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(28) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(200) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(260) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(112) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(28) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(36) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(0) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1600) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(0) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(175) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(44) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(310) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(200) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(50) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(50) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(64) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(1241) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(386) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(126) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(116) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(56) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(126) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(128) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(6) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(73) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(1039) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(true) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(120) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(68) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(43) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(43) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(285) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.5657895f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(32) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(32) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(96) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(88) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(88) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(160) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(40) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(96) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(72) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(88) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(40) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(128) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(0) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(144) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(64) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(48) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.7226337f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(1215) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(1237) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(2) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(208) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1086) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(272) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(112) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(761) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(151) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(761) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(109) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(0) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortrait3ButtonTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortrait3ButtonTest.kt new file mode 100644 index 0000000000..7dd95f99f6 --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortrait3ButtonTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for two panel in portrait with 3-Button navigation. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileTwoPanelPortrait3ButtonTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForTablet(isTwoPanel = true, isGestureMode = false) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(153) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(199) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(153) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(509) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(38) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(38) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(19) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(19) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(19) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(112) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(28) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(153) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(199) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(112) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(28) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(16) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(600) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1960) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(600) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(134) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(34) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(237) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(153) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(38) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(38) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(56) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(763) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(386) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(126) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(116) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(56) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(126) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(216) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(6) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(32) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(685) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(true) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(120) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(52) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(33) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(33) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(291) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.1976048f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(32) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(32) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(96) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(88) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(88) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(160) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(48) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(96) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(72) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(88) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(40) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(128) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(220) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(144) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(96) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(48) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.69064087f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(2169) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(767) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(2) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(460) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1958) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(272) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(112) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(340) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(151) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(428) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(109) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(428) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortraitTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortraitTest.kt new file mode 100644 index 0000000000..0c5968e1ef --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortraitTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for two panel in portrait. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileTwoPanelPortraitTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForTablet(isTwoPanel = true) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isTrue() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(153) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(199) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(153) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(509) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(38) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(38) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(19) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(19) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(19) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(112) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(28) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(153) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(199) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(112) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(28) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(16) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(600) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1960) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(600) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(134) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(34) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(237) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(153) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(38) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(38) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(56) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(763) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(386) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(126) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(116) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(0) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(0) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(56) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(126) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(216) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(6) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(2) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(685) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(true) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(120) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(52) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(33) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(33) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(291) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.1976048f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(32) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(32) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(96) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(88) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(88) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(160) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(48) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(96) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(72) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(88) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(40) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(128) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(220) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(144) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(96) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(48) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.69064087f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(2169) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(767) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(2) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(false) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(460) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1958) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(272) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(112) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(459) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(151) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(459) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(109) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(0) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBar3ButtonTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBar3ButtonTest.kt new file mode 100644 index 0000000000..2bad6bb20b --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBar3ButtonTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for landscape phone with vertical bar and 3-Button navigation. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileVerticalBar3ButtonTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForPhone(isVerticalBar = true, isGestureMode = false) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isFalse() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(210) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(221) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(675) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(321) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(70) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(70) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(53) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(196) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(0) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(0) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(260) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(304) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(196) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(49) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(53) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1050) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(0) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(196) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(49) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(28) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(422) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(252) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(56) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(56) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(0) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(0) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(336) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(221) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(168) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(84) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(56) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(126) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(221) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(158) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(4) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(0) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(2221) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(false) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(0) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(0) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(14) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(266) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(0) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.0f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(56) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(0) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(168) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(154) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(0) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(280) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(42) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(168) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(126) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(56) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(-112) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(0) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(21) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(126) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(21) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(84) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.8880597f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(1340) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(2840) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(1) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(true) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(168) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1358) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(147) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(225) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(56) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(0) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(84) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(165) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(0) + } +} \ No newline at end of file diff --git a/quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBarTest.kt b/quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBarTest.kt new file mode 100644 index 0000000000..6256a43f75 --- /dev/null +++ b/quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBarTest.kt @@ -0,0 +1,486 @@ +/* + * Copyright (C) 2022 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.quickstep + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.DeviceProfile +import com.android.launcher3.DeviceProfileBaseTest +import com.google.common.truth.Truth.assertThat +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +/** + * Tests for DeviceProfile for landscape phone with vertical bar. + */ +@SmallTest +@RunWith(AndroidJUnit4::class) +class DeviceProfileVerticalBarTest : DeviceProfileBaseTest() { + + lateinit var dp: DeviceProfile + + @Before + fun before() { + initializeVarsForPhone(isVerticalBar = true) + dp = newDP() + } + + @Test + fun isScalableGrid() { + assertThat(dp.isScalableGrid).isFalse() + } + + @Test + fun cellWidthPx() { + assertThat(dp.cellWidthPx).isEqualTo(210) + } + + @Test + fun cellHeightPx() { + assertThat(dp.cellHeightPx).isEqualTo(221) + } + + @Test + fun getCellSizeX() { + assertThat(dp.cellSize.x).isEqualTo(675) + } + + @Test + fun getCellSizeY() { + assertThat(dp.cellSize.y).isEqualTo(321) + } + + @Test + fun cellLayoutBorderSpacePxX() { + assertThat(dp.cellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun cellLayoutBorderSpacePxY() { + assertThat(dp.cellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxLeft() { + assertThat(dp.cellLayoutPaddingPx.left).isEqualTo(70) + } + + @Test + fun cellLayoutPaddingPxTop() { + assertThat(dp.cellLayoutPaddingPx.top).isEqualTo(0) + } + + @Test + fun cellLayoutPaddingPxRight() { + assertThat(dp.cellLayoutPaddingPx.right).isEqualTo(70) + } + + @Test + fun cellLayoutPaddingPxBottom() { + assertThat(dp.cellLayoutPaddingPx.bottom).isEqualTo(53) + } + + @Test + fun iconSizePx() { + assertThat(dp.iconSizePx).isEqualTo(196) + } + + @Test + fun iconTextSizePx() { + assertThat(dp.iconTextSizePx).isEqualTo(0) + } + + @Test + fun iconDrawablePaddingPx() { + assertThat(dp.iconDrawablePaddingPx).isEqualTo(0) + } + + @Test + fun folderCellWidthPx() { + assertThat(dp.folderCellWidthPx).isEqualTo(260) + } + + @Test + fun folderCellHeightPx() { + assertThat(dp.folderCellHeightPx).isEqualTo(304) + } + + @Test + fun folderChildIconSizePx() { + assertThat(dp.folderChildIconSizePx).isEqualTo(196) + } + + @Test + fun folderChildTextSizePx() { + assertThat(dp.folderChildTextSizePx).isEqualTo(49) + } + + @Test + fun folderChildDrawablePaddingPx() { + assertThat(dp.folderChildDrawablePaddingPx).isEqualTo(14) + } + + @Test + fun folderCellLayoutBorderSpaceOriginalPx() { + assertThat(dp.folderCellLayoutBorderSpaceOriginalPx).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxX() { + assertThat(dp.folderCellLayoutBorderSpacePx.x).isEqualTo(0) + } + + @Test + fun folderCellLayoutBorderSpacePxY() { + assertThat(dp.folderCellLayoutBorderSpacePx.y).isEqualTo(0) + } + + @Test + fun bottomSheetTopPadding() { + assertThat(dp.bottomSheetTopPadding).isEqualTo(53) + } + + @Test + fun allAppsShiftRange() { + assertThat(dp.allAppsShiftRange).isEqualTo(1050) + } + + @Test + fun allAppsTopPadding() { + assertThat(dp.allAppsTopPadding).isEqualTo(0) + } + + @Test + fun allAppsIconSizePx() { + assertThat(dp.allAppsIconSizePx).isEqualTo(196) + } + + @Test + fun allAppsIconTextSizePx() { + assertThat(dp.allAppsIconTextSizePx).isEqualTo(49) + } + + @Test + fun allAppsIconDrawablePaddingPx() { + assertThat(dp.allAppsIconDrawablePaddingPx).isEqualTo(28) + } + + @Test + fun allAppsCellHeightPx() { + assertThat(dp.allAppsCellHeightPx).isEqualTo(422) + } + + @Test + fun allAppsCellWidthPx() { + assertThat(dp.allAppsCellWidthPx).isEqualTo(252) + } + + @Test + fun allAppsBorderSpacePxX() { + assertThat(dp.allAppsBorderSpacePx.x).isEqualTo(56) + } + + @Test + fun allAppsBorderSpacePxY() { + assertThat(dp.allAppsBorderSpacePx.y).isEqualTo(56) + } + + @Test + fun numShownAllAppsColumns() { + assertThat(dp.numShownAllAppsColumns).isEqualTo(0) + } + + @Test + fun allAppsLeftRightPadding() { + assertThat(dp.allAppsLeftRightPadding).isEqualTo(0) + } + + @Test + fun allAppsLeftRightMargin() { + assertThat(dp.allAppsLeftRightMargin).isEqualTo(0) + } + + @Test + fun hotseatBarSizePx() { + assertThat(dp.hotseatBarSizePx).isEqualTo(336) + } + + @Test + fun hotseatCellHeightPx() { + assertThat(dp.hotseatCellHeightPx).isEqualTo(221) + } + + @Test + fun hotseatBarBottomSpacePx() { + assertThat(dp.hotseatBarBottomSpacePx).isEqualTo(168) + } + + @Test + fun hotseatBarSidePaddingStartPx() { + assertThat(dp.hotseatBarSidePaddingStartPx).isEqualTo(84) + } + + @Test + fun hotseatBarSidePaddingEndPx() { + assertThat(dp.hotseatBarSidePaddingEndPx).isEqualTo(56) + } + + @Test + fun hotseatQsbSpace() { + assertThat(dp.hotseatQsbSpace).isEqualTo(126) + } + + @Test + fun hotseatQsbHeight() { + assertThat(dp.hotseatQsbHeight).isEqualTo(221) + } + + @Test + fun springLoadedHotseatBarTopMarginPx() { + assertThat(dp.springLoadedHotseatBarTopMarginPx).isEqualTo(158) + } + + @Test + fun numShownHotseatIcons() { + assertThat(dp.numShownHotseatIcons).isEqualTo(4) + } + + @Test + fun hotseatBorderSpace() { + assertThat(dp.hotseatBorderSpace).isEqualTo(0) + } + + @Test + fun isQsbInline() { + assertThat(dp.isQsbInline).isEqualTo(false) + } + + @Test + fun qsbWidth() { + assertThat(dp.qsbWidth).isEqualTo(2221) + } + + @Test + fun isTaskbarPresent() { + assertThat(dp.isTaskbarPresent).isEqualTo(false) + } + + @Test + fun isTaskbarPresentInApps() { + assertThat(dp.isTaskbarPresentInApps).isEqualTo(false) + } + + @Test + fun taskbarSize() { + assertThat(dp.taskbarSize).isEqualTo(0) + } + + @Test + fun desiredWorkspaceHorizontalMarginPx() { + assertThat(dp.desiredWorkspaceHorizontalMarginPx).isEqualTo(0) + } + + @Test + fun workspacePaddingLeft() { + assertThat(dp.workspacePadding.left).isEqualTo(14) + } + + @Test + fun workspacePaddingTop() { + assertThat(dp.workspacePadding.top).isEqualTo(0) + } + + @Test + fun workspacePaddingRight() { + assertThat(dp.workspacePadding.right).isEqualTo(266) + } + + @Test + fun workspacePaddingBottom() { + assertThat(dp.workspacePadding.bottom).isEqualTo(0) + } + + @Test + fun iconScale() { + assertThat(dp.iconScale).isEqualTo(1) + } + + @Test + fun cellScaleToFit() { + assertThat(dp.cellScaleToFit).isEqualTo(1.0f) + } + + @Test + fun workspaceTopPadding() { + assertThat(dp.workspaceTopPadding).isEqualTo(0) + } + + @Test + fun workspaceBottomPadding() { + assertThat(dp.workspaceBottomPadding).isEqualTo(0) + } + + @Test + fun overviewTaskMarginPx() { + assertThat(dp.overviewTaskMarginPx).isEqualTo(56) + } + + @Test + fun overviewTaskMarginGridPx() { + assertThat(dp.overviewTaskMarginGridPx).isEqualTo(0) + } + + @Test + fun overviewTaskIconSizePx() { + assertThat(dp.overviewTaskIconSizePx).isEqualTo(168) + } + + @Test + fun overviewTaskIconDrawableSizePx() { + assertThat(dp.overviewTaskIconDrawableSizePx).isEqualTo(154) + } + + @Test + fun overviewTaskIconDrawableSizeGridPx() { + assertThat(dp.overviewTaskIconDrawableSizeGridPx).isEqualTo(0) + } + + @Test + fun overviewTaskThumbnailTopMarginPx() { + assertThat(dp.overviewTaskThumbnailTopMarginPx).isEqualTo(280) + } + + @Test + fun overviewActionsTopMarginPx() { + assertThat(dp.overviewActionsTopMarginPx).isEqualTo(42) + } + + @Test + fun overviewActionsHeight() { + assertThat(dp.overviewActionsHeight).isEqualTo(168) + } + + @Test + fun overviewActionsButtonSpacing() { + assertThat(dp.overviewActionsButtonSpacing).isEqualTo(126) + } + + @Test + fun overviewPageSpacing() { + assertThat(dp.overviewPageSpacing).isEqualTo(56) + } + + @Test + fun overviewRowSpacing() { + assertThat(dp.overviewRowSpacing).isEqualTo(-112) + } + + @Test + fun overviewGridSideMargin() { + assertThat(dp.overviewGridSideMargin).isEqualTo(0) + } + + @Test + fun dropTargetBarTopMarginPx() { + assertThat(dp.dropTargetBarTopMarginPx).isEqualTo(21) + } + + @Test + fun dropTargetBarSizePx() { + assertThat(dp.dropTargetBarSizePx).isEqualTo(126) + } + + @Test + fun dropTargetBarBottomMarginPx() { + assertThat(dp.dropTargetBarBottomMarginPx).isEqualTo(21) + } + + @Test + fun workspaceSpringLoadedMinNextPageVisiblePx() { + assertThat(dp.workspaceSpringLoadedMinNextPageVisiblePx).isEqualTo(84) + } + + @Test + fun getWorkspaceSpringLoadScale() { + assertThat(dp.workspaceSpringLoadScale).isEqualTo(0.8880597f) + } + + @Test + fun getCellLayoutHeight() { + assertThat(dp.cellLayoutHeight).isEqualTo(1340) + } + + @Test + fun getCellLayoutWidth() { + assertThat(dp.cellLayoutWidth).isEqualTo(2840) + } + + @Test + fun getPanelCount() { + assertThat(dp.panelCount).isEqualTo(1) + } + + @Test + fun isVerticalBarLayout() { + assertThat(dp.isVerticalBarLayout).isEqualTo(true) + } + + @Test + fun getCellLayoutSpringLoadShrunkTop() { + assertThat(dp.cellLayoutSpringLoadShrunkTop).isEqualTo(168) + } + + @Test + fun getCellLayoutSpringLoadShrunkBottom() { + assertThat(dp.cellLayoutSpringLoadShrunkBottom).isEqualTo(1358) + } + + @Test + fun getQsbOffsetY() { + assertThat(dp.qsbOffsetY).isEqualTo(147) + } + + @Test + fun getTaskbarOffsetY() { + assertThat(dp.taskbarOffsetY).isEqualTo(225) + } + + @Test + fun getHotseatLayoutPaddingLeft() { + assertThat(dp.getHotseatLayoutPadding(context).left).isEqualTo(56) + } + + @Test + fun getHotseatLayoutPaddingTop() { + assertThat(dp.getHotseatLayoutPadding(context).top).isEqualTo(0) + } + + @Test + fun getHotseatLayoutPaddingRight() { + assertThat(dp.getHotseatLayoutPadding(context).right).isEqualTo(84) + } + + @Test + fun getHotseatLayoutPaddingBottom() { + assertThat(dp.getHotseatLayoutPadding(context).bottom).isEqualTo(165) + } + + @Test + fun hotseatBarEndOffset() { + assertThat(dp.hotseatBarEndOffset).isEqualTo(0) + } +} \ No newline at end of file diff --git a/res/values/dimens.xml b/res/values/dimens.xml index a3a30e1a72..d095ae3b4a 100644 --- a/res/values/dimens.xml +++ b/res/values/dimens.xml @@ -22,8 +22,6 @@ 10.77dp 8dp 7dp - - 8dp 24dp @@ -362,6 +360,9 @@ 44dp 8dp + 0dp + 0dp + 0dp 16dp diff --git a/src/com/android/launcher3/DeviceProfile.java b/src/com/android/launcher3/DeviceProfile.java index 673ab54c7b..adf621653f 100644 --- a/src/com/android/launcher3/DeviceProfile.java +++ b/src/com/android/launcher3/DeviceProfile.java @@ -108,9 +108,8 @@ public class DeviceProfile { public final int edgeMarginPx; public final float workspaceContentScale; - public float workspaceSpringLoadShrunkTop; - public float workspaceSpringLoadShrunkBottom; - public final int workspaceSpringLoadedBottomSpace; + private float mWorkspaceSpringLoadShrunkTop; + private float mWorkspaceSpringLoadShrunkBottom; public final int workspaceSpringLoadedMinNextPageVisiblePx; private final int extraSpace; @@ -159,10 +158,11 @@ public class DeviceProfile { // Hotseat public final int numShownHotseatIcons; public int hotseatCellHeightPx; - private final boolean areNavButtonsInline; + public final boolean areNavButtonsInline; // In portrait: size = height, in landscape: size = width public int hotseatBarSizePx; public int hotseatBarBottomSpacePx; + public int hotseatBarEndOffset; public int hotseatQsbSpace; public int springLoadedHotseatBarTopMarginPx; // Start is the side next to the nav bar, end is the side next to the workspace @@ -351,8 +351,6 @@ public class DeviceProfile { dropTargetButtonWorkspaceEdgeGapPx = res.getDimensionPixelSize( R.dimen.drop_target_button_workspace_edge_gap); - workspaceSpringLoadedBottomSpace = - res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space); workspaceSpringLoadedMinNextPageVisiblePx = res.getDimensionPixelSize( R.dimen.dynamic_grid_spring_loaded_min_next_space_visible); @@ -412,6 +410,18 @@ public class DeviceProfile { // Add a bit of space between nav bar and hotseat in vertical bar layout. hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0; updateHotseatSizes(pxFromDp(inv.iconSize[INDEX_DEFAULT], mMetrics)); + if (areNavButtonsInline) { + /* + * 3 nav buttons + + * Little space at the end for contextual buttons + + * Little space between icons and nav buttons + */ + hotseatBarEndOffset = 3 * res.getDimensionPixelSize(R.dimen.taskbar_nav_buttons_size) + + res.getDimensionPixelSize(R.dimen.taskbar_contextual_button_margin) + + res.getDimensionPixelSize(R.dimen.taskbar_hotseat_nav_spacing); + } else { + hotseatBarEndOffset = 0; + } overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin); overviewTaskMarginGridPx = res.getDimensionPixelSize(R.dimen.overview_task_margin_grid); @@ -918,9 +928,9 @@ public class DeviceProfile { * Gets the scaled top of the workspace in px for the spring-loaded edit state. */ public float getCellLayoutSpringLoadShrunkTop() { - workspaceSpringLoadShrunkTop = mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx + mWorkspaceSpringLoadShrunkTop = mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx + dropTargetBarBottomMarginPx; - return workspaceSpringLoadShrunkTop; + return mWorkspaceSpringLoadShrunkTop; } /** @@ -928,10 +938,10 @@ public class DeviceProfile { */ public float getCellLayoutSpringLoadShrunkBottom() { int topOfHotseat = hotseatBarSizePx + springLoadedHotseatBarTopMarginPx; - workspaceSpringLoadShrunkBottom = + mWorkspaceSpringLoadShrunkBottom = heightPx - (isVerticalBarLayout() ? getVerticalHotseatLastItemBottomOffset() : topOfHotseat); - return workspaceSpringLoadShrunkBottom; + return mWorkspaceSpringLoadShrunkBottom; } /** @@ -1054,8 +1064,7 @@ public class DeviceProfile { int requiredWidth = iconSizePx * numShownHotseatIcons + hotseatBorderSpace * (numShownHotseatIcons - 1) + additionalQsbSpace; - int endOffset = ApiWrapper.getHotseatEndOffset(context); - int hotseatWidth = Math.min(requiredWidth, availableWidthPx - endOffset); + int hotseatWidth = Math.min(requiredWidth, availableWidthPx - hotseatBarEndOffset); int sideSpacing = (availableWidthPx - hotseatWidth) / 2; mHotseatBarPadding.set(sideSpacing, hotseatBarTopPadding, sideSpacing, @@ -1068,10 +1077,10 @@ public class DeviceProfile { mHotseatBarPadding.left += additionalQsbSpace; } - if (endOffset > sideSpacing) { + if (hotseatBarEndOffset > sideSpacing) { int diff = isRtl - ? sideSpacing - endOffset - : endOffset - sideSpacing; + ? sideSpacing - hotseatBarEndOffset + : hotseatBarEndOffset - sideSpacing; mHotseatBarPadding.left -= diff; mHotseatBarPadding.right += diff; } @@ -1235,6 +1244,7 @@ public class DeviceProfile { return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)"; } + // LINT.IfChange public void dump(String prefix, PrintWriter writer) { writer.println(prefix + "DeviceProfile:"); writer.println(prefix + "\t1 dp = " + mMetrics.density + " px"); @@ -1314,7 +1324,8 @@ public class DeviceProfile { allAppsIconDrawablePaddingPx)); writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx)); writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx)); - writer.println(prefix + pxToDpStr("allAppsBorderSpacePx", allAppsBorderSpacePx.x)); + writer.println(prefix + pxToDpStr("allAppsBorderSpacePxX", allAppsBorderSpacePx.x)); + writer.println(prefix + pxToDpStr("allAppsBorderSpacePxY", allAppsBorderSpacePx.y)); writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns); writer.println(prefix + pxToDpStr("allAppsLeftRightPadding", allAppsLeftRightPadding)); writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin)); @@ -1322,11 +1333,12 @@ public class DeviceProfile { writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx)); writer.println(prefix + "\tinv.hotseatColumnSpan: " + inv.hotseatColumnSpan[mTypeIndex]); writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx)); - writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomSpacePx)); + writer.println(prefix + pxToDpStr("hotseatBarBottomSpacePx", hotseatBarBottomSpacePx)); writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx", hotseatBarSidePaddingStartPx)); writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx", hotseatBarSidePaddingEndPx)); + writer.println(prefix + pxToDpStr("hotseatBarEndOffset", hotseatBarEndOffset)); writer.println(prefix + pxToDpStr("hotseatQsbSpace", hotseatQsbSpace)); writer.println(prefix + pxToDpStr("hotseatQsbHeight", hotseatQsbHeight)); writer.println(prefix + pxToDpStr("springLoadedHotseatBarTopMarginPx", @@ -1389,11 +1401,9 @@ public class DeviceProfile { prefix + pxToDpStr("dropTargetBarBottomMarginPx", dropTargetBarBottomMarginPx)); writer.println( - prefix + pxToDpStr("workspaceSpringLoadShrunkTop", workspaceSpringLoadShrunkTop)); + prefix + pxToDpStr("workspaceSpringLoadShrunkTop", mWorkspaceSpringLoadShrunkTop)); writer.println(prefix + pxToDpStr("workspaceSpringLoadShrunkBottom", - workspaceSpringLoadShrunkBottom)); - writer.println(prefix + pxToDpStr("workspaceSpringLoadedBottomSpace", - workspaceSpringLoadedBottomSpace)); + mWorkspaceSpringLoadShrunkBottom)); writer.println(prefix + pxToDpStr("workspaceSpringLoadedMinNextPageVisiblePx", workspaceSpringLoadedMinNextPageVisiblePx)); writer.println( @@ -1401,6 +1411,19 @@ public class DeviceProfile { writer.println(prefix + pxToDpStr("getCellLayoutHeight()", getCellLayoutHeight())); writer.println(prefix + pxToDpStr("getCellLayoutWidth()", getCellLayoutWidth())); } + // LINT.ThenChange( + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfilePhoneTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBarTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfilePhone3ButtonTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileVerticalBar3ButtonTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscapeTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortraitTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletLandscape3ButtonTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileTabletPortrait3ButtonTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscapeTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortraitTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelLandscape3ButtonTest.kt, + // packages/apps/Launcher3/quickstep/tests/src/com/android/quickstep/DeviceProfileTwoPanelPortrait3ButtonTest.kt) private static Context getContext(Context c, Info info, int orientation, WindowBounds bounds) { Configuration config = new Configuration(c.getResources().getConfiguration()); diff --git a/tests/src/com/android/launcher3/DeviceProfileBaseTest.kt b/tests/src/com/android/launcher3/DeviceProfileBaseTest.kt index 0635d84ca5..9a76336cd0 100644 --- a/tests/src/com/android/launcher3/DeviceProfileBaseTest.kt +++ b/tests/src/com/android/launcher3/DeviceProfileBaseTest.kt @@ -23,6 +23,8 @@ import com.android.launcher3.util.WindowBounds import org.junit.Before import org.mockito.ArgumentMatchers.any import org.mockito.Mockito.mock +import java.io.PrintWriter +import java.io.StringWriter import org.mockito.Mockito.`when` as whenever abstract class DeviceProfileBaseTest { @@ -55,8 +57,9 @@ abstract class DeviceProfileBaseTest { isGestureMode ) - protected fun initializeVarsForPhone(isLandscape: Boolean = false) { - val (x, y) = if (isLandscape) + protected fun initializeVarsForPhone(isGestureMode: Boolean = true, + isVerticalBar: Boolean = false) { + val (x, y) = if (isVerticalBar) Pair(3120, 1440) else Pair(1440, 3120) @@ -67,10 +70,17 @@ abstract class DeviceProfileBaseTest { whenever(info.getDensityDpi()).thenReturn(560) whenever(info.smallestSizeDp(any())).thenReturn(411f) - inv = newScalableInvariantDeviceProfile() + this.isGestureMode = isGestureMode + + inv = newScalableInvariantDeviceProfile().apply { + deviceType = InvariantDeviceProfile.TYPE_PHONE + transposeLayoutWithOrientation = isVerticalBar + } } - protected fun initializeVarsForTablet(isLandscape: Boolean = false) { + protected fun initializeVarsForTablet(isLandscape: Boolean = false, + isTwoPanel: Boolean = false, + isGestureMode: Boolean = true) { val (x, y) = if (isLandscape) Pair(2560, 1600) else @@ -82,7 +92,19 @@ abstract class DeviceProfileBaseTest { whenever(info.getDensityDpi()).thenReturn(320) whenever(info.smallestSizeDp(any())).thenReturn(800f) - inv = newScalableInvariantDeviceProfile() + this.isGestureMode = isGestureMode + useTwoPanels = isTwoPanel + + inv = newScalableInvariantDeviceProfile().apply { + deviceType = if (isTwoPanel) + InvariantDeviceProfile.TYPE_MULTI_DISPLAY else InvariantDeviceProfile.TYPE_TABLET + inlineQsb = booleanArrayOf( + false, + isLandscape, + false, + false + ) + } } /** @@ -137,4 +159,12 @@ abstract class DeviceProfileBaseTest { false ) } + + fun dump(dp: DeviceProfile): StringWriter { + val stringWriter = StringWriter() + val printWriter = PrintWriter(stringWriter) + dp.dump("", printWriter) + printWriter.flush() + return stringWriter + } } \ No newline at end of file diff --git a/tests/src/com/android/launcher3/HotseatShownIconsTest.kt b/tests/src/com/android/launcher3/HotseatShownIconsTest.kt index 593239d6f7..5dabb33a67 100644 --- a/tests/src/com/android/launcher3/HotseatShownIconsTest.kt +++ b/tests/src/com/android/launcher3/HotseatShownIconsTest.kt @@ -31,33 +31,6 @@ import org.junit.runner.RunWith @RunWith(AndroidJUnit4::class) class HotseatShownIconsTest : DeviceProfileBaseTest() { - @Test - fun hotseat_size_is_normal_for_handhelds() { - initializeVarsForPhone() - inv = newScalableInvariantDeviceProfile().apply { - deviceType = TYPE_PHONE - } - - val dp = newDP() - - assertThat(dp.isQsbInline).isFalse() - assertThat(dp.numShownHotseatIcons).isEqualTo(4) - } - - @Test - fun hotseat_size_is_max_when_large_screen() { - initializeVarsForTablet(isLandscape = true) - inv = newScalableInvariantDeviceProfile().apply { - deviceType = TYPE_MULTI_DISPLAY - } - useTwoPanels = true - - val dp = newDP() - - assertThat(dp.isQsbInline).isFalse() - assertThat(dp.numShownHotseatIcons).isEqualTo(6) - } - @Test fun hotseat_size_is_shrunk_if_needed_when_large_screen() { initializeVarsForTablet(isLandscape = true) diff --git a/tests/src/com/android/launcher3/InlineQsbTest.kt b/tests/src/com/android/launcher3/InlineQsbTest.kt deleted file mode 100644 index 905c1e1a0f..0000000000 --- a/tests/src/com/android/launcher3/InlineQsbTest.kt +++ /dev/null @@ -1,103 +0,0 @@ -/* - * Copyright (C) 2022 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.launcher3 - -import androidx.test.ext.junit.runners.AndroidJUnit4 -import androidx.test.filters.SmallTest -import com.google.common.truth.Truth.assertThat -import org.junit.Test -import org.junit.runner.RunWith - -/** - * Test for [DeviceProfile] - */ -@SmallTest -@RunWith(AndroidJUnit4::class) -class InlineQsbTest : DeviceProfileBaseTest() { - - @Test - fun qsb_is_not_inline_for_phones() { - initializeVarsForPhone() - - val dp = newDP() - - assertThat(dp.isQsbInline).isFalse() - } - - @Test - fun qsb_is_inline_for_tablet_portrait() { - initializeVarsForTablet() - inv = newScalableInvariantDeviceProfile().apply { - inlineQsb = booleanArrayOf( - false, - true, // landscape - false, - false - ) - } - - val dp = DeviceProfile( - context, - inv, - info, - windowBounds, - isMultiWindowMode, - transposeLayoutWithOrientation, - useTwoPanels, - isGestureMode - ) - - assertThat(dp.isQsbInline).isFalse() - } - - @Test - fun qsb_is_inline_for_tablet_landscape() { - initializeVarsForTablet(isLandscape = true) - inv = newScalableInvariantDeviceProfile().apply { - inlineQsb = booleanArrayOf( - false, - true, // landscape - false, - false - ) - numColumns = 6 - numRows = 5 - numShownHotseatIcons = 6 - } - - val dp = newDP() - - if (dp.hotseatQsbHeight > 0) { - assertThat(dp.isQsbInline).isTrue() - } else { // Launcher3 doesn't have QSB height - assertThat(dp.isQsbInline).isFalse() - } - } - - /** - * This test is to make sure that a tablet doesn't inline the QSB if the layout doesn't support - */ - @Test - fun qsb_is_not_inline_for_tablet_landscape_without_inline() { - initializeVarsForTablet(isLandscape = true) - useTwoPanels = true - - val dp = newDP() - - assertThat(dp.isQsbInline).isFalse() - } - -} \ No newline at end of file