This is an automated email from the ASF dual-hosted git repository.

garydgregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git


The following commit(s) were added to refs/heads/master by this push:
     new c99f2ddfe Fix ArrayUtils.reverse range underflow on Integer.MIN_VALUE 
end (#1750)
c99f2ddfe is described below

commit c99f2ddfe2fc9294070b697cdd1f603b0a31078b
Author: alhuda <[email protected]>
AuthorDate: Fri Jul 17 19:31:54 2026 +0530

    Fix ArrayUtils.reverse range underflow on Integer.MIN_VALUE end (#1750)
---
 .../java/org/apache/commons/lang3/ArrayUtils.java  | 18 +++++-----
 .../org/apache/commons/lang3/ArrayUtilsTest.java   | 41 ++++++++++++++++++++++
 2 files changed, 50 insertions(+), 9 deletions(-)

diff --git a/src/main/java/org/apache/commons/lang3/ArrayUtils.java 
b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
index dda747d0a..8a53a088c 100644
--- a/src/main/java/org/apache/commons/lang3/ArrayUtils.java
+++ b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
@@ -6721,7 +6721,7 @@ public static void reverse(final boolean[] array, final 
int startIndexInclusive,
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         boolean tmp;
         while (j > i) {
             tmp = array[j];
@@ -6763,7 +6763,7 @@ public static void reverse(final byte[] array, final int 
startIndexInclusive, fi
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         byte tmp;
         while (j > i) {
             tmp = array[j];
@@ -6805,7 +6805,7 @@ public static void reverse(final char[] array, final int 
startIndexInclusive, fi
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         char tmp;
         while (j > i) {
             tmp = array[j];
@@ -6847,7 +6847,7 @@ public static void reverse(final double[] array, final 
int startIndexInclusive,
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         double tmp;
         while (j > i) {
             tmp = array[j];
@@ -6889,7 +6889,7 @@ public static void reverse(final float[] array, final int 
startIndexInclusive, f
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         float tmp;
         while (j > i) {
             tmp = array[j];
@@ -6935,7 +6935,7 @@ public static void reverse(final int[] array, final int 
startIndexInclusive, fin
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         int tmp;
         while (j > i) {
             tmp = array[j];
@@ -6981,7 +6981,7 @@ public static void reverse(final long[] array, final int 
startIndexInclusive, fi
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         long tmp;
         while (j > i) {
             tmp = array[j];
@@ -7030,7 +7030,7 @@ public static void reverse(final Object[] array, final 
int startIndexInclusive,
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         Object tmp;
         while (j > i) {
             tmp = array[j];
@@ -7076,7 +7076,7 @@ public static void reverse(final short[] array, final int 
startIndexInclusive, f
             return;
         }
         int i = Math.max(startIndexInclusive, 0);
-        int j = Math.min(array.length, endIndexExclusive) - 1;
+        int j = max0(Math.min(array.length, endIndexExclusive)) - 1;
         short tmp;
         while (j > i) {
             tmp = array[j];
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java 
b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
index 2f61f9eef..dd5f24c7b 100644
--- a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
@@ -2854,6 +2854,47 @@ void testReverseShortRange() {
         assertNull(array);
     }
 
+    @Test
+    void testReverseRangeEndIntMinValue() {
+        // endIndexExclusive == Integer.MIN_VALUE is an undervalue (< start 
index), documented as no change.
+        // The unclamped `Math.min(length, end) - 1` underflowed to 
Integer.MAX_VALUE and indexed out of bounds.
+        final boolean[] booleans = {true, false, true};
+        ArrayUtils.reverse(booleans, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new boolean[]{true, false, true}, booleans);
+
+        final byte[] bytes = {1, 2, 3};
+        ArrayUtils.reverse(bytes, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new byte[]{1, 2, 3}, bytes);
+
+        final char[] chars = {'a', 'b', 'c'};
+        ArrayUtils.reverse(chars, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new char[]{'a', 'b', 'c'}, chars);
+
+        final double[] doubles = {1, 2, 3};
+        ArrayUtils.reverse(doubles, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new double[]{1, 2, 3}, doubles);
+
+        final float[] floats = {1, 2, 3};
+        ArrayUtils.reverse(floats, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new float[]{1, 2, 3}, floats);
+
+        final int[] ints = {1, 2, 3};
+        ArrayUtils.reverse(ints, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new int[]{1, 2, 3}, ints);
+
+        final long[] longs = {1, 2, 3};
+        ArrayUtils.reverse(longs, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new long[]{1, 2, 3}, longs);
+
+        final Object[] objects = {"a", "b", "c"};
+        ArrayUtils.reverse(objects, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new Object[]{"a", "b", "c"}, objects);
+
+        final short[] shorts = {1, 2, 3};
+        ArrayUtils.reverse(shorts, 0, Integer.MIN_VALUE);
+        assertArrayEquals(new short[]{1, 2, 3}, shorts);
+    }
+
     @Test
     void testSameLength() {
         final Object[] nullArray = null;

Reply via email to