Conversion.hexTo*() methods now throw IllegalArgumentException instead

of StringIndexOutOfBoundsException

Better exception messages

Author: garydgregory

src/changes/changes.xml

@@ -58,6 +58,7 @@ The <action> type attribute can be add,update,fix,remove.
     <action issue="LANG-1597" type="fix" dev="ggregory" due-to="Richard Eckart de Castilho, Gary Gregory">Invocation fails because matching varargs method found but then discarded.</action>
     <action                   type="fix" dev="ggregory" due-to="Gary Gregory">Don't check accessibility twice in MemberUtils.setAccessibleWorkaround(T).</action>
     <action issue="LANG-1774" type="fix" dev="ggregory" due-to="Zhongxin Yan, Madhur Lathi, Yudan Liu, Gary Gregory">Improve handling of ClassUtils.getShortCanonicalName() for invalid input #1437.</action>
+    <action issue="LANG-1720" type="fix" dev="ggregory" due-to="Sheung Chi Chan, Arthur Chan, Gary Gregory, Elliotte Rusty Harold">Conversion.hexTo*() methods now throw IllegalArgumentException instead of StringIndexOutOfBoundsException.</action>
     <!-- FIX Javadoc -->
     <action                   type="fix" dev="ggregory" due-to="Gary Gregory">[javadoc] General improvements.</action>
     <action                   type="fix" dev="ggregory" due-to="Gary Gregory">[javadoc] Fix thrown exception documentation for org.apache.commons.lang3.reflect.MethodUtils.getMethodObject(Class&lt;?&gt;, String, Class&lt;?&gt;...).</action>

src/main/java/org/apache/commons/lang3/Conversion.java

@@ -557,7 +557,7 @@ public static boolean[] byteToBinary(final byte src, final int srcPos, final boo
      * @param srcPos the position in {@code src}, in bits, from where to start the conversion
      * @param dstInit the initial value for the result String
      * @param dstPos the position in {@code dst} where to copy the result
-     * @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the
+     * @param nHexs the number of chars to copy to {@code dst}, must be smaller or equal to the
      *            width of the input (from srcPos to MSB)
      * @return {@code dst}
      * @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 8}
@@ -782,7 +782,7 @@ public static int hexDigitToInt(final char hexDigit) {
      * @param srcPos  the position in {@code src}, in char unit, from where to start the conversion.
      * @param dstInit initial value of the destination byte.
      * @param dstPos  the position of the LSB, in bits, in the result byte.
-     * @param nHex    the number of Chars to convert.
+     * @param nHex    the number of chars to convert.
      * @return a byte containing the selected bits.
      * @throws IllegalArgumentException Thrown on invalid input like {@code (nHex - 1) * 4 + dstPos >= 8}.
      */
@@ -815,7 +815,7 @@ public static byte hexToByte(final String src, final int srcPos, final byte dstI
      *            conversion
      * @param dstInit initial value of the destination int
      * @param dstPos the position of the LSB, in bits, in the result int
-     * @param nHex the number of Chars to convert
+     * @param nHex the number of chars to convert
      * @return an int containing the selected bits
      * @throws IllegalArgumentException Thrown on invalid input like {@code (nHex - 1) * 4 + dstPos >= 32}
      */
@@ -826,8 +826,9 @@ public static int hexToInt(final String src, final int srcPos, final int dstInit
         if ((nHex - 1) * 4 + dstPos >= 32) {
             throw new IllegalArgumentException("(nHex - 1) * 4 + dstPos is greater or equal to than 32");
         }
-        if (srcPos + nHex > src.length()) {
-            throw new IllegalArgumentException(String.format("srcPos %,d, + nHex %,d  > src.length()", srcPos, nHex, src.length()));
+        if (srcPos < 0 || nHex < 0 || srcPos > src.length() - nHex) {
+            throw new IllegalArgumentException(
+                    String.format("srcPos %,d, dstInit %,d, dstPos %,d, nHex %,d, src.length() %,d", srcPos, dstInit, dstPos, nHex, src.length()));
         }
         int out = dstInit;
         for (int i = 0; i < nHex; i++) {
@@ -848,20 +849,20 @@ public static int hexToInt(final String src, final int srcPos, final int dstInit
      *            conversion
      * @param dstInit initial value of the destination long
      * @param dstPos the position of the LSB, in bits, in the result long
-     * @param nHex the number of Chars to convert
+     * @param nHex the number of chars to convert
      * @return a long containing the selected bits
      * @throws IllegalArgumentException Thrown on invalid input like {@code (nHex - 1) * 4 + dstPos >= 64}
      */
-    public static long hexToLong(final String src, final int srcPos, final long dstInit, final int dstPos,
-            final int nHex) {
+    public static long hexToLong(final String src, final int srcPos, final long dstInit, final int dstPos, final int nHex) {
         if (0 == nHex) {
             return dstInit;
         }
         if ((nHex - 1) * 4 + dstPos >= 64) {
             throw new IllegalArgumentException("(nHex - 1) * 4 + dstPos is greater or equal to than 64");
         }
-        if (srcPos + nHex > src.length()) {
-            throw new IllegalArgumentException(String.format("srcPos %,d, + nHex %,d  > src.length()", srcPos, nHex, src.length()));
+        if (srcPos < 0 || nHex < 0 || srcPos > src.length() - nHex) {
+            throw new IllegalArgumentException(
+                    String.format("srcPos %,d, dstInit %,d, dstPos %,d, nHex %,d, src.length() %,d", srcPos, dstInit, dstPos, nHex, src.length()));
         }
         long out = dstInit;
         for (int i = 0; i < nHex; i++) {
@@ -882,20 +883,20 @@ public static long hexToLong(final String src, final int srcPos, final long dstI
      *            conversion
      * @param dstInit initial value of the destination short
      * @param dstPos the position of the LSB, in bits, in the result short
-     * @param nHex the number of Chars to convert
+     * @param nHex the number of chars to convert
      * @return a short containing the selected bits
      * @throws IllegalArgumentException Thrown on invalid input like {@code (nHex - 1) * 4 + dstPos >= 16}
      */
-    public static short hexToShort(final String src, final int srcPos, final short dstInit, final int dstPos,
-            final int nHex) {
+    public static short hexToShort(final String src, final int srcPos, final short dstInit, final int dstPos, final int nHex) {
         if (0 == nHex) {
             return dstInit;
         }
         if ((nHex - 1) * 4 + dstPos >= 16) {
             throw new IllegalArgumentException("(nHex - 1) * 4 + dstPos is greater or equal to than 16");
         }
-        if (srcPos + nHex > src.length()) {
-            throw new IllegalArgumentException(String.format("srcPos %,d, + nHex %,d  > src.length()", srcPos, nHex, src.length()));
+        if (srcPos < 0 || nHex < 0 || srcPos > src.length() - nHex) {
+            throw new IllegalArgumentException(
+                    String.format("srcPos %,d, dstInit %,d, dstPos %,d, nHex %,d, src.length() %,d", srcPos, dstInit, dstPos, nHex, src.length()));
         }
         short out = dstInit;
         for (int i = 0; i < nHex; i++) {
@@ -1008,7 +1009,7 @@ public static byte[] intToByteArray(final int src, final int srcPos, final byte[
      * @param srcPos the position in {@code src}, in bits, from where to start the conversion
      * @param dstInit the initial value for the result String
      * @param dstPos the position in {@code dst} where to copy the result
-     * @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the
+     * @param nHexs the number of chars to copy to {@code dst}, must be smaller or equal to the
      *            width of the input (from srcPos to MSB)
      * @return {@code dst}
      * @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 32}
@@ -1216,7 +1217,7 @@ public static byte[] longToByteArray(final long src, final int srcPos, final byt
      * @param srcPos the position in {@code src}, in bits, from where to start the conversion
      * @param dstInit the initial value for the result String
      * @param dstPos the position in {@code dst} where to copy the result
-     * @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the
+     * @param nHexs the number of chars to copy to {@code dst}, must be smaller or equal to the
      *            width of the input (from srcPos to MSB)
      * @return {@code dst}
      * @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 64}
@@ -1440,7 +1441,7 @@ public static byte[] shortToByteArray(final short src, final int srcPos, final b
      * @param srcPos the position in {@code src}, in bits, from where to start the conversion
      * @param dstInit the initial value for the result String
      * @param dstPos the position in {@code dst} where to copy the result
-     * @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the
+     * @param nHexs the number of chars to copy to {@code dst}, must be smaller or equal to the
      *            width of the input (from srcPos to MSB)
      * @return {@code dst}
      * @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 16}

src/test/java/org/apache/commons/lang3/ConversionTest.java

@@ -724,6 +724,8 @@ void testHexToInt() {
         assertEquals(0x12345679, Conversion.hexToInt(src, 0, 0x12345679, 0, 0));
         assertEquals(0x87645679, Conversion.hexToInt(src, 15, 0x12345679, 20, 3));
         assertThrows(IllegalArgumentException.class, () -> Conversion.hexToInt(src, src.length(), 0, 0, 1));
+        assertThrows(IllegalArgumentException.class, () -> Conversion.hexToInt(src, Integer.MIN_VALUE, 0, 0, 1));
+        assertThrows(IllegalArgumentException.class, () -> Conversion.hexToInt(src, Integer.MAX_VALUE, 0, 0, 1));
     }
 
     /**
@@ -739,6 +741,8 @@ void testHexToLong() {
         assertEquals(0x123456798ABCDEF0L, Conversion.hexToLong(src, 0, 0x123456798ABCDEF0L, 0, 0));
         assertEquals(0x1234567876BCDEF0L, Conversion.hexToLong(src, 15, 0x123456798ABCDEF0L, 24, 3));
         assertThrows(IllegalArgumentException.class, () -> Conversion.hexToLong(src, src.length(), 0, 0, 1));
+        assertThrows(IllegalArgumentException.class, () -> Conversion.hexToLong(src, Integer.MIN_VALUE, 0, 0, 1));
+        assertThrows(IllegalArgumentException.class, () -> Conversion.hexToLong(src, Integer.MAX_VALUE, 0, 0, 1));
     }
 
     /**
@@ -754,6 +758,8 @@ void testHexToShort() {
         assertEquals((short) 0x1234, Conversion.hexToShort(src, 0, (short) 0x1234, 0, 0));
         assertEquals((short) 0x8764, Conversion.hexToShort(src, 15, (short) 0x1234, 4, 3));
         assertThrows(IllegalArgumentException.class, () -> Conversion.hexToShort(src, src.length(), (short) 0, 0, 1));
+        assertThrows(IllegalArgumentException.class, () -> Conversion.hexToShort(src, Integer.MIN_VALUE, (short) 0, 0, 1));
+        assertThrows(IllegalArgumentException.class, () -> Conversion.hexToShort(src, Integer.MAX_VALUE, (short) 0, 0, 1));
     }
 
     /**