detox 20.15.1-prerelease.0 → 20.16.0

package/.eslintrc.js

@@ -16,10 +16,6 @@ module.exports = {
   env: {
     node: true
   },
-  globals: {
-    // TODO: remove use of fail() across the project because Jest Circus doesn't support it
-    'fail': true
-  },
   rules: {
     '@typescript-eslint/no-unused-vars': [
       'warn',

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0-javadoc.jar.md5

@@ -0,0 +1 @@
+56f5ec5b7efbb230f3238c004a5fe715

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0-javadoc.jar.sha1

@@ -0,0 +1 @@
+64494abc41fe95ddfa2592069865471684bee013

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0-javadoc.jar.sha256

@@ -0,0 +1 @@
+a59fe4333df991b4188fe010b85fd8cd739ea7244d8feb096ed77b42ec178d63

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0-javadoc.jar.sha512

@@ -0,0 +1 @@
+623c51f747c437bd88a7421ac94e30d1c4d9c11f7aca8066746213c80e79eb7aba7a1d067dbf1033ae710deb021fdaf503304f387e43ae6333c763786a64bf9f

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0-sources.jar.md5

@@ -0,0 +1 @@
+65e9a1e222c5bd2d0d8f1adbb87e81dc

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0-sources.jar.sha1

@@ -0,0 +1 @@
+a619619716feca26448febd692de8dac38314100

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0-sources.jar.sha256

@@ -0,0 +1 @@
+5aa3a4be5939728a238f7ed475ee6e6d55d0eef81d1f84fc842029a7ba597c58

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0-sources.jar.sha512

@@ -0,0 +1 @@
+61cf8afa304f860372a728279633e767070bddea071a2de58ff6b23fac2ef61e472ba4191704a8175cbd8cf1b10c526fae02db7205b8dcc5696d8f76e9441ab2

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0.aar.md5

@@ -0,0 +1 @@
+8a77aaff1489b4887d6873aaae1357a3

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0.aar.sha1

@@ -0,0 +1 @@
+d5f06bdfb31d314d08ef800ab5d9148502702d2a

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0.aar.sha256

@@ -0,0 +1 @@
+7f45586ecc61fe0f158c8701000529d566299aa4b24f9539e4cc4ea2d29d898e

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0.aar.sha512

@@ -0,0 +1 @@
+b00a7385379509967eb9ffed2c619e19008f03fc2d5534fb80bd08c31a6f9d937d9269858a4f3d03878d4979259d43da7ccec3173954454ff50c9a18590f1d20

package/Detox-android/com/wix/detox/{20.15.0-prerelease.0/detox-20.15.0-prerelease.0.pom → 20.16.0/detox-20.16.0.pom}

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
-  <version>20.15.0-prerelease.0</version>
+  <version>20.16.0</version>
   <packaging>aar</packaging>
   <name>Detox</name>
   <description>Gray box end-to-end testing and automation library for mobile apps</description>

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0.pom.md5

@@ -0,0 +1 @@
+6e8623d17be32c1363d08aa89e5fd3b2

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0.pom.sha1

@@ -0,0 +1 @@
+2b12affbd8b37c465ddc003dd59c224c83eb31fa

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0.pom.sha256

@@ -0,0 +1 @@
+1c812b8cb14e877335790a3dbf0ffd4db6e85c311e56050aa14853f1c78a7c90

package/Detox-android/com/wix/detox/20.16.0/detox-20.16.0.pom.sha512

@@ -0,0 +1 @@
+27641bf294e773373fa00156c73180d0260f0ee0611d5bb3f3e40001560a0a1537eed5807196397be5742d513974f7281bb682b0c09d2865888863080b305a05

package/Detox-android/com/wix/detox/maven-metadata.xml

@@ -3,11 +3,11 @@
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
   <versioning>
-    <latest>20.15.0-prerelease.0</latest>
-    <release>20.15.0-prerelease.0</release>
+    <latest>20.16.0</latest>
+    <release>20.16.0</release>
     <versions>
-      <version>20.15.0-prerelease.0</version>
+      <version>20.16.0</version>
     </versions>
-    <lastUpdated>20231220151542</lastUpdated>
+    <lastUpdated>20240114094649</lastUpdated>
   </versioning>
 </metadata>

package/Detox-android/com/wix/detox/maven-metadata.xml.md5

@@ -1 +1 @@
-ee9f1eb94c32676d922b9e0da9e6671b
+3a7cd4da4ea3dd3e5cf31ee3a0c6ad4b

package/Detox-android/com/wix/detox/maven-metadata.xml.sha1

@@ -1 +1 @@
-934e086bf9f633709c593f1ec59f2608365a9ade
+d32146f04f20a32ac69562f7fec718954e1f925d

package/Detox-android/com/wix/detox/maven-metadata.xml.sha256

@@ -1 +1 @@
-b98c156607dcfb76e3c5a73b1a3b6662123abb4f29b35e4aeb763cc953c6399f
+9440532f25a30a2d2c025159b566348219724e16f627e1c2cf80e384c9b40141

package/Detox-android/com/wix/detox/maven-metadata.xml.sha512

@@ -1 +1 @@
-a9bed986035caacdf70a97d955939f460022631330dee211eabc60e936e22d2c7c2cb6eb0d9adef5d32f24185832657fd45151fe72ffcc329f23ef48864bc67c
+ff53b142b83374497a6450075bf40da6df3996a77522efb5555d59b61b17e39c59b3891250a9c53789845add208bd28cfdbc975cd9e6a262ff47dead71e1dd74

package/android/detox/proguard-rules-app.pro

@@ -20,5 +20,4 @@
 -keep class kotlin.io.** { *; }
 -keep class okhttp3.** { *; }
 
--keep class androidx.concurrent.futures.CallbackToFutureAdapter$* { *; }
--keep class androidx.concurrent.futures.CallbackToFutureAdapter { *; }
+-keep class androidx.concurrent.futures.** { *; }

package/android/detox/src/full/java/com/wix/detox/espresso/DetoxAction.java

@@ -79,9 +79,14 @@ public class DetoxAction {
      * Scrolls to the edge of the given scrollable view.
      *
      * @param edge Direction to scroll (see {@link MotionDir})
+     * @param startOffsetPercentX Percentage denoting where the scroll should start from on the X-axis, with respect to the scrollable view.
+     * @param startOffsetPercentY Percentage denoting where the scroll should start from on the Y-axis, with respect to the scrollable view.
      * @return ViewAction
      */
-    public static ViewAction scrollToEdge(final int edge) {
+    public static ViewAction scrollToEdge(final int edge, double startOffsetPercentX, double startOffsetPercentY) {
+        final Float _startOffsetPercentX = startOffsetPercentX < 0 ? null : (float) startOffsetPercentX;
+        final Float _startOffsetPercentY = startOffsetPercentY < 0 ? null : (float) startOffsetPercentY;
+
         return actionWithAssertions(new ViewAction() {
             @Override
             public Matcher<View> getConstraints() {
@@ -97,7 +102,7 @@ public class DetoxAction {
             public void perform(UiController uiController, View view) {
                 try {
                     for (int i = 0; i < 100; i++) {
-                        ScrollHelper.performOnce(uiController, view, edge);
+                        ScrollHelper.performOnce(uiController, view, edge, _startOffsetPercentX, _startOffsetPercentY);
                     }
                     throw new DetoxRuntimeException("Scrolling a lot without reaching the edge: force-breaking the loop");
                 } catch (ScrollEdgeException e) {
@@ -112,8 +117,8 @@ public class DetoxAction {
      *
      * @param direction           Direction to scroll (see {@link MotionDir})
      * @param amountInDP          Density Independent Pixels
-     * @param startOffsetPercentX Percentage denoting where X-swipe should start, with respect to the scrollable view.
-     * @param startOffsetPercentY Percentage denoting where Y-swipe should start, with respect to the scrollable view.
+     * @param startOffsetPercentX Percentage denoting where the scroll should start from on the X-axis, with respect to the scrollable view.
+     * @param startOffsetPercentY Percentage denoting where the scroll should start from on the Y-axis, with respect to the scrollable view.
      */
     public static ViewAction scrollInDirection(final int direction, final double amountInDP, double startOffsetPercentX, double startOffsetPercentY) {
         final Float _startOffsetPercentX = startOffsetPercentX < 0 ? null : (float) startOffsetPercentX;
@@ -129,8 +134,8 @@ public class DetoxAction {
      *
      * @param direction           Direction to scroll (see {@link MotionDir})
      * @param amountInDP          Density Independent Pixels
-     * @param startOffsetPercentX Percentage denoting where X-swipe should start, with respect to the scrollable view.
-     * @param startOffsetPercentY Percentage denoting where Y-swipe should start, with respect to the scrollable view.
+     * @param startOffsetPercentX Percentage denoting where the scroll should start from on the X-axis, with respect to the scrollable view.
+     * @param startOffsetPercentY Percentage denoting where the scroll should start from on the Y-axis, with respect to the scrollable view.
      */
     public static ViewAction scrollInDirectionStaleAtEdge(final int direction, final double amountInDP, double startOffsetPercentX, double startOffsetPercentY) {
         final Float _startOffsetPercentX = startOffsetPercentX < 0 ? null : (float) startOffsetPercentX;

package/android/detox/src/main/java/com/wix/detox/espresso/DeviceDisplay.kt

@@ -17,7 +17,7 @@ object DeviceDisplay {
     }
 
     @JvmStatic
-    fun getScreenSizeInPX(): FloatArray? {
+    fun getScreenSizeInPX(): FloatArray {
         val metrics = getDisplayMetrics()
         return floatArrayOf(metrics.widthPixels.toFloat(), metrics.heightPixels.toFloat())
     }

package/android/detox/src/main/java/com/wix/detox/espresso/scroll/ScrollHelper.java

@@ -1,14 +1,18 @@
 package com.wix.detox.espresso.scroll;
 
 import android.content.Context;
+import android.graphics.Insets;
 import android.graphics.Point;
+import android.os.Build;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewConfiguration;
+import android.view.WindowInsets;
 
 import com.wix.detox.action.common.MotionDir;
 import com.wix.detox.espresso.DeviceDisplay;
 
+import androidx.annotation.VisibleForTesting;
 import androidx.test.espresso.UiController;
 import androidx.test.platform.app.InstrumentationRegistry;
 
@@ -42,8 +46,8 @@ public class ScrollHelper {
      *
      * @param direction Direction to scroll (see {@link MotionDir})
      * @param amountInDP Density Independent Pixels
-     * @param startOffsetPercentX Percentage denoting where X-swipe should start, with respect to the scrollable view. Null means select automatically.
-     * @param startOffsetPercentY Percentage denoting where Y-swipe should start, with respect to the scrollable view. Null means select automatically.
+     * @param startOffsetPercentX Percentage denoting where the scroll should start from on the X-axis, with respect to the scrollable view. Null means select automatically.
+     * @param startOffsetPercentY Percentage denoting where the scroll should start from on the Y-axis, with respect to the scrollable view. Null means select automatically.
      */
     public static void perform(UiController uiController, View view, @MotionDir int direction, double amountInDP, Float startOffsetPercentX, Float startOffsetPercentY) throws ScrollEdgeException {
         final int amountInPx = DeviceDisplay.convertDpiToPx(amountInDP);
@@ -51,7 +55,7 @@ public class ScrollHelper {
         final int times = amountInPx / safeScrollableRangePx;
         final int remainder = amountInPx % safeScrollableRangePx;
 
-        Log.d(LOG_TAG, "prescroll amountDP="+amountInDP + " amountPx="+amountInPx + " scrollableRangePx="+safeScrollableRangePx + " times="+times + " remainder="+remainder);
+        Log.d(LOG_TAG, "prescroll amountDP=" + amountInDP + " amountPx=" + amountInPx + " scrollableRangePx=" + safeScrollableRangePx + " times=" + times + " remainder=" + remainder);
 
         for (int i = 0; i < times; ++i) {
             scrollOnce(uiController, view, direction, safeScrollableRangePx, startOffsetPercentX, startOffsetPercentY);
@@ -64,10 +68,12 @@ public class ScrollHelper {
      * of the screen.)
      *
      * @param direction Direction to scroll (see {@link @MotionDir})
+     * @param startOffsetPercentX Percentage denoting where the scroll should start from on the X-axis, with respect to the scrollable view. Null means select automatically.
+     * @param startOffsetPercentY Percentage denoting where the scroll should start from on the Y-axis, with respect to the scrollable view. Null means select automatically.
      */
-    public static void performOnce(UiController uiController, View view, @MotionDir int direction) throws ScrollEdgeException {
+    public static void performOnce(UiController uiController, View view, @MotionDir int direction, Float startOffsetPercentX, Float startOffsetPercentY) throws ScrollEdgeException {
         final int scrollableRangePx = getViewSafeScrollableRangePix(view, direction);
-        scrollOnce(uiController, view, direction, scrollableRangePx, null, null);
+        scrollOnce(uiController, view, direction, scrollableRangePx, startOffsetPercentX, startOffsetPercentY);
     }
 
     private static void scrollOnce(UiController uiController, View view, @MotionDir int direction, int userAmountPx, Float startOffsetPercentX, Float startOffsetPercentY) throws ScrollEdgeException {
@@ -113,25 +119,32 @@ public class ScrollHelper {
         }
     }
 
-    private static int getViewSafeScrollableRangePix(View view, @MotionDir int direction) {
+    @VisibleForTesting
+    public static int getViewSafeScrollableRangePix(View view, @MotionDir int direction) {
         final float[] screenSize = DeviceDisplay.getScreenSizeInPX();
         final int[] pos = new int[2];
         view.getLocationInWindow(pos);
 
         int range;
         switch (direction) {
-            case MOTION_DIR_LEFT: range = (int) ((screenSize[0] - pos[0]) * SCROLL_RANGE_SAFE_PERCENT); break;
-            case MOTION_DIR_RIGHT: range = (int) ((pos[0] + view.getWidth()) * SCROLL_RANGE_SAFE_PERCENT); break;
-            case MOTION_DIR_UP: range = (int) ((screenSize[1] - pos[1]) * SCROLL_RANGE_SAFE_PERCENT); break;
-            default: range = (int) ((pos[1] + view.getHeight()) * SCROLL_RANGE_SAFE_PERCENT); break;
+            case MOTION_DIR_LEFT:
+                range = (int) ((screenSize[0] - pos[0]) * SCROLL_RANGE_SAFE_PERCENT);
+                break;
+            case MOTION_DIR_RIGHT:
+                range = (int) ((pos[0] + view.getWidth()) * SCROLL_RANGE_SAFE_PERCENT);
+                break;
+            case MOTION_DIR_UP:
+                range = (int) ((screenSize[1] - pos[1]) * SCROLL_RANGE_SAFE_PERCENT);
+                break;
+            default:
+                range = (int) ((pos[1] + view.getHeight()) * SCROLL_RANGE_SAFE_PERCENT);
+                break;
         }
         return range;
     }
 
-    private static Point getScrollStartPoint(View view, @MotionDir int direction, Float startOffsetPercentX, Float startOffsetPercentY) {
+    private static int[] getScrollStartOffsetInView(View view, @MotionDir int direction, Float startOffsetPercentX, Float startOffsetPercentY) {
         final int safetyOffset = DeviceDisplay.convertDpiToPx(1);
-
-        Point point = getGlobalViewLocation(view);
         float offsetFactorX;
         float offsetFactorY;
         int safetyOffsetX;
@@ -169,8 +182,87 @@ public class ScrollHelper {
         int offsetX = ((int) (view.getWidth() * offsetFactorX) + safetyOffsetX);
         int offsetY = ((int) (view.getHeight() * offsetFactorY) + safetyOffsetY);
 
-        point.offset(offsetX, offsetY);
-        return point;
+        return new int[]{offsetX, offsetY};
+    }
+
+    /**
+     * Calculates the scroll start point, with respect to the global screen coordinates and gesture insets.
+     * @param view The view to scroll.
+     * @param direction The scroll direction.
+     * @param startOffsetPercentX The scroll start offset, as a percentage of the view's width. Null means select automatically.
+     * @param startOffsetPercentY The scroll start offset, as a percentage of the view's height. Null means select automatically.
+     * @return a Point object, denoting the scroll start point.
+     */
+    private static Point getScrollStartPoint(View view, @MotionDir int direction, Float startOffsetPercentX, Float startOffsetPercentY) {
+        Point result = getGlobalViewLocation(view);
+
+        // 1. Calculate the scroll start point, with respect to the view's location.
+        int[] coordinates = getScrollStartOffsetInView(view, direction, startOffsetPercentX, startOffsetPercentY);
+
+        // 2. Make sure that the start point is within the scrollable area, taking into account the system gesture insets.
+        coordinates = applyScreenInsets(view, direction, coordinates[0], coordinates[1]);
+
+        result.offset(coordinates[0], coordinates[1]);
+        return result;
+    }
+
+    /**
+     * Calculates the scroll start point, with respect to the system gesture insets.
+     * @param view
+     * @param direction The scroll direction.
+     * @param x The scroll start point, with respect to the view's location.
+     * @param y The scroll start point, with respect to the view's location.
+     * @return an array of two integers, denoting the scroll start point, with respect to the system gesture insets.
+     */
+    private static int[] applyScreenInsets(View view, int direction, int x, int y) {
+        // System gesture insets are only available on Android Q (29) and above.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            return new int[]{x, y};
+        }
+
+        final float[] displaySize = DeviceDisplay.getScreenSizeInPX();
+
+        // Calculate the min/max scrollable area, taking into account the system gesture insets.
+        // By default we assume the scrollable area is the entire screen.
+        // 2dp is a safety offset to make sure we don't hit the system gesture area.
+        int gestureSafeOffset = DeviceDisplay.convertDpiToPx(2);
+        int minX = gestureSafeOffset;
+        int minY = gestureSafeOffset;
+        float maxX = displaySize[0] - gestureSafeOffset;
+        float maxY = displaySize[1] - gestureSafeOffset;
+
+        // Try to get the root window insets, and if available, use them to calculate the scrollable area.
+        WindowInsets rootWindowInsets = view.getRootWindowInsets();
+        if (rootWindowInsets == null) {
+            Log.w(LOG_TAG, "Could not get root window insets");
+        } else {
+            Insets gestureInsets = rootWindowInsets.getSystemGestureInsets();
+            minX = gestureInsets.left;
+            minY = gestureInsets.top;
+            maxX -= gestureInsets.right;
+            maxY -= gestureInsets.bottom;
+
+            Log.d(LOG_TAG,
+                "System gesture insets: " +
+                    gestureInsets + " minX=" + minX + " minY=" + minY + " maxX=" + maxX + " maxY=" + maxY + " currentX=" + x + " currentY=" + y);
+        }
+
+        switch (direction) {
+            case MOTION_DIR_UP:
+                y = (int) Math.max(y, minY);
+                break;
+            case MOTION_DIR_DOWN:
+                y = (int) Math.min(y, maxY);
+                break;
+            case MOTION_DIR_LEFT:
+                x = (int) Math.max(x, minX);
+                break;
+            case MOTION_DIR_RIGHT:
+                x = (int) Math.min(x, maxX);
+                break;
+        }
+
+        return new int[]{x, y};
     }
 
     private static Point getScrollEndPoint(Point startPoint, @MotionDir int direction, int userAmountPx, Float startOffsetPercentX, Float startOffsetPercentY) {
@@ -209,13 +301,18 @@ public class ScrollHelper {
         return point;
     }
 
+    /**
+     * Calculates the global location of the view on the screen.
+     * @param view The view to calculate.
+     * @return a Point object, denoting the global location of the view.
+     */
     private static Point getGlobalViewLocation(View view) {
         int[] pos = new int[2];
         view.getLocationInWindow(pos);
         return new Point(pos[0], pos[1]);
     }
 
-    private static ViewConfiguration getViewConfiguration() {
+    public static ViewConfiguration getViewConfiguration() {
         if (viewConfiguration == null) {
             final Context applicationContext = InstrumentationRegistry.getInstrumentation().getTargetContext().getApplicationContext();
             viewConfiguration = ViewConfiguration.get(applicationContext);

package/android/detox/src/testFull/java/com/wix/detox/espresso/scroll/ScrollHelperTest.kt

@@ -0,0 +1,188 @@
+package com.wix.detox.espresso.scroll
+
+import android.graphics.Insets
+import android.view.MotionEvent
+import android.view.View
+import android.view.WindowInsets
+import androidx.test.espresso.UiController
+import androidx.test.platform.app.InstrumentationRegistry
+import com.wix.detox.action.common.MOTION_DIR_DOWN
+import com.wix.detox.action.common.MOTION_DIR_LEFT
+import com.wix.detox.action.common.MOTION_DIR_RIGHT
+import com.wix.detox.action.common.MOTION_DIR_UP
+import com.wix.detox.espresso.DeviceDisplay
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import kotlin.test.assertEquals
+
+private const val INSETS_SIZE = 100
+private const val SCROLL_RANGE_SAFE_PERCENT = 0.9f // ScrollHelper.SCROLL_RANGE_SAFE_PERCENT
+
+@Config(
+    qualifiers = "xxxhdpi", // 1280x1880
+    sdk = [33]
+)
+@RunWith(RobolectricTestRunner::class)
+class ScrollHelperTest {
+
+    private val display = DeviceDisplay.getScreenSizeInPX()
+    private val displayWidth = display[0].toInt()
+    private val displayHeight = display[1].toInt()
+    private val touchSlopPx = ScrollHelper.getViewConfiguration().scaledTouchSlop
+    private val safetyMarginPx = DeviceDisplay.convertDpiToPx(2.0)
+
+    private val uiControllerMock = mock<UiController>()
+    private val viewMock = mockViewWithGestureNavigation(displayWidth, displayHeight)
+
+    @Test
+    fun `should scrolling down by 200 when gesture navigation enabled`() {
+        val amountInDp = 200.0
+        val amountInPx = amountInDp * DeviceDisplay.getDensity()
+
+        ScrollHelper.perform(uiControllerMock, viewMock, MOTION_DIR_DOWN, amountInDp, null, null)
+
+        val upEvent = getUpEvent()
+        // Verify that the scroll started at the center of the view
+        assertEquals(displayWidth / 2.0, upEvent.x.toDouble(), 0.0)
+        // Verify that the scroll ended at the center of the view minus the requested amount
+        assertEquals(displayHeight - amountInPx - touchSlopPx - safetyMarginPx - INSETS_SIZE, upEvent.y.toDouble(), 0.0)
+    }
+
+    @Test
+    fun `should scrolling down by 200 when gesture navigation disabled`() {
+        val amountInDp = 200.0
+        val amountInPx = amountInDp * DeviceDisplay.getDensity()
+
+        val viewMock = mockViewWithoutGestureNavigation(displayWidth, displayHeight)
+        ScrollHelper.perform(uiControllerMock, viewMock, MOTION_DIR_DOWN, amountInDp, null, null)
+
+        val upEvent = getUpEvent()
+        // Verify that the scroll started at the center of the view
+        assertEquals(displayWidth / 2.0, upEvent.x.toDouble(), 0.0)
+        // Verify that the scroll ended at the center of the view minus the requested amount
+        assertEquals(displayHeight - amountInPx - touchSlopPx - safetyMarginPx, upEvent.y.toDouble(), 0.0)
+    }
+
+    @Test
+    fun `should scroll down to edge on full screen view when gesture navigation enabled`() {
+        ScrollHelper.performOnce(uiControllerMock, viewMock, MOTION_DIR_DOWN, null, null)
+        val upEvent = getUpEvent()
+        val amountInPx = displayHeight * SCROLL_RANGE_SAFE_PERCENT
+
+        // Calculate where the scroll should end
+        val targetY = displayHeight - amountInPx -
+            touchSlopPx -
+            safetyMarginPx -
+            INSETS_SIZE
+
+        assertEquals(displayWidth / 2.0, upEvent.x.toDouble(), 0.0)
+        assertEquals(targetY, upEvent.y, 0.0f)
+    }
+
+    @Test
+    fun `should scroll left to edge on full screen view when gesture navigation enabled`() {
+        ScrollHelper.performOnce(uiControllerMock, viewMock, MOTION_DIR_LEFT, null, null)
+        val upEvent = getUpEvent()
+        val amountInPx = displayWidth * SCROLL_RANGE_SAFE_PERCENT
+
+        // Calculate where the scroll should end
+        val targetX = amountInPx +
+            touchSlopPx +
+            INSETS_SIZE
+
+        assertEquals(targetX, upEvent.x, 0.0f)
+        assertEquals(displayHeight / 2.0, upEvent.y.toDouble(), 0.0)
+    }
+
+    @Test
+    fun `should scroll up to edge on full screen view when gesture navigation enabled`() {
+        ScrollHelper.performOnce(uiControllerMock, viewMock, MOTION_DIR_UP,null, null)
+        val upEvent = getUpEvent()
+        val amountInPx = displayHeight * SCROLL_RANGE_SAFE_PERCENT
+
+        // Calculate where the scroll should end
+        val targetY = amountInPx +
+            touchSlopPx +
+            INSETS_SIZE
+
+        assertEquals(displayWidth / 2.0, upEvent.x.toDouble(), 0.0)
+        assertEquals(targetY, upEvent.y, 0.0f)
+    }
+
+    @Test
+    fun `should scroll right to edge on full screen view when gesture navigation enabled`() {
+        ScrollHelper.performOnce(uiControllerMock, viewMock, MOTION_DIR_RIGHT,  null, null)
+        val upEvent = getUpEvent()
+        val amountInPx = displayWidth * SCROLL_RANGE_SAFE_PERCENT
+
+        // Calculate where the scroll should end
+        val targetX = displayWidth - amountInPx -
+            touchSlopPx -
+            safetyMarginPx -
+            INSETS_SIZE
+
+        assertEquals(targetX, upEvent.x, 0.0f)
+        assertEquals(displayHeight / 2.0, upEvent.y.toDouble(), 0.0)
+    }
+
+    /**
+     * Get the performed UP event from the ui controller
+     */
+    private fun getUpEvent(): MotionEvent {
+        val capture = argumentCaptor<Iterable<MotionEvent>>()
+        // Capture the events from the ui controller
+        verify(uiControllerMock).injectMotionEventSequence(capture.capture())
+
+        val listOfCapturedEvents = capture.firstValue.toList()
+        // The last event is the UP event with the target coordinates. All of the rest are not interesting
+        return listOfCapturedEvents.last()
+    }
+
+    private fun mockViewWithoutGestureNavigation(displayWidth: Int, displayHeight: Int): View {
+        // This is how we disable gesture navigation
+        val windowInsets = mock<WindowInsets>() {
+            whenever(it.systemGestureInsets).thenReturn(
+                Insets.of(0, 0, 0, 0)
+            )
+        }
+
+        return mockView(displayWidth, displayHeight, windowInsets)
+    }
+
+    /**
+     * Mock a view with gesture navigation enabled
+     */
+    private fun mockViewWithGestureNavigation(displayWidth: Int, displayHeight: Int): View {
+        // This is how we enable gesture navigation
+        val windowInsets = mock<WindowInsets>() {
+            whenever(it.systemGestureInsets).thenReturn(
+                Insets.of(INSETS_SIZE, INSETS_SIZE, INSETS_SIZE, INSETS_SIZE)
+            )
+        }
+
+        return mockView(displayWidth, displayHeight, windowInsets)
+    }
+
+    private fun mockView(
+        displayWidth: Int,
+        displayHeight: Int,
+        windowInsets: WindowInsets
+    ): View {
+        val view = mock<View>() {
+            whenever(it.width).thenReturn(displayWidth)
+            whenever(it.height).thenReturn(displayHeight)
+            whenever(it.canScrollVertically(any())).thenReturn(true) // We allow endless scroll
+            whenever(it.canScrollHorizontally(any())).thenReturn(true) // We allow endless scroll
+            whenever(it.context).thenReturn(InstrumentationRegistry.getInstrumentation().targetContext)
+            whenever(it.rootWindowInsets).thenReturn(windowInsets)
+        }
+        return view
+    }
+}