commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From djo...@apache.org
Subject [lang] Added new vararg methods to insert values into an array at an index.
Date Mon, 12 Dec 2016 14:00:34 GMT
Repository: commons-lang
Updated Branches:
  refs/heads/master 0136218fa -> 795fe5d86


Added new vararg methods to insert values into an array at an index.

This implements LANG-660. This commit also deprecates the add() methods
that inserted a single value into an array at an index.

Project: http://git-wip-us.apache.org/repos/asf/commons-lang/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-lang/commit/795fe5d8
Tree: http://git-wip-us.apache.org/repos/asf/commons-lang/tree/795fe5d8
Diff: http://git-wip-us.apache.org/repos/asf/commons-lang/diff/795fe5d8

Branch: refs/heads/master
Commit: 795fe5d869594bde53f8490d75eedef6185b6c37
Parents: 0136218
Author: duncan <duncan@wortharead.com>
Authored: Mon Dec 12 14:00:19 2016 +0000
Committer: duncan <duncan@wortharead.com>
Committed: Mon Dec 12 14:00:19 2016 +0000

----------------------------------------------------------------------
 src/changes/changes.xml                         |   1 +
 .../org/apache/commons/lang3/ArrayUtils.java    | 431 +++++++++++++++++++
 .../commons/lang3/ArrayUtilsInsertTest.java     | 349 +++++++++++++++
 3 files changed, 781 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-lang/blob/795fe5d8/src/changes/changes.xml
----------------------------------------------------------------------
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 994ad1b..c4603fa 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -46,6 +46,7 @@ The <action> type attribute can be add,update,fix,remove.
   <body>
 
   <release version="3.6" date="2016-MM-DD" description="TBD">
+    <action issue="LANG-660" type="add" dev="djones">Add methods to insert arrays into
arrays at an index</action>
     <action issue="LANG-1292" type="fix" dev="djones">WordUtils.wrap throws StringIndexOutOfBoundsException</action>
     <action issue="LANG-1287" type="fix" dev="pschumacher" due-to="Ivan Morozov">RandomStringUtils#random
can enter infinite loop if end parameter is to small</action>
     <action issue="LANG-1285" type="fix" dev="pschumacher" due-to="Francesco Chicchiriccò">NullPointerException
in FastDateParser$TimeZoneStrategy</action>

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/795fe5d8/src/main/java/org/apache/commons/lang3/ArrayUtils.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/lang3/ArrayUtils.java b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
index ebb47a8..1e1217b 100644
--- a/src/main/java/org/apache/commons/lang3/ArrayUtils.java
+++ b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
@@ -5629,7 +5629,11 @@ public class ArrayUtils {
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range (index &lt; 0 ||
index &gt; array.length).
      * @throws IllegalArgumentException if both array and element are null
+     * @deprecated this method has been superseded by {@link #insert(int, Object[], Object...)
insert(int, T[], T...)} and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static <T> T[] add(final T[] array, final int index, final T element) {
         Class<?> clss = null;
         if (array != null) {
@@ -5669,7 +5673,11 @@ public class ArrayUtils {
      * @param element  the object to add
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range (index &lt; 0 ||
index &gt; array.length).
+     * @deprecated this method has been superseded by {@link #insert(int, boolean[], boolean...)}
and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static boolean[] add(final boolean[] array, final int index, final boolean element)
{
         return (boolean[]) add(array, index, Boolean.valueOf(element), Boolean.TYPE);
     }
@@ -5701,7 +5709,11 @@ public class ArrayUtils {
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range
      * (index &lt; 0 || index &gt; array.length).
+     * @deprecated this method has been superseded by {@link #insert(int, char[], char...)}
and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static char[] add(final char[] array, final int index, final char element) {
         return (char[]) add(array, index, Character.valueOf(element), Character.TYPE);
     }
@@ -5732,7 +5744,11 @@ public class ArrayUtils {
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range
      * (index &lt; 0 || index &gt; array.length).
+     * @deprecated this method has been superseded by {@link #insert(int, byte[], byte...)}
and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static byte[] add(final byte[] array, final int index, final byte element) {
         return (byte[]) add(array, index, Byte.valueOf(element), Byte.TYPE);
     }
@@ -5763,7 +5779,11 @@ public class ArrayUtils {
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range
      * (index &lt; 0 || index &gt; array.length).
+     * @deprecated this method has been superseded by {@link #insert(int, short[], short...)}
and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static short[] add(final short[] array, final int index, final short element)
{
         return (short[]) add(array, index, Short.valueOf(element), Short.TYPE);
     }
@@ -5794,7 +5814,11 @@ public class ArrayUtils {
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range
      * (index &lt; 0 || index &gt; array.length).
+     * @deprecated this method has been superseded by {@link #insert(int, int[], int...)}
and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static int[] add(final int[] array, final int index, final int element) {
         return (int[]) add(array, index, Integer.valueOf(element), Integer.TYPE);
     }
@@ -5825,7 +5849,11 @@ public class ArrayUtils {
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range
      * (index &lt; 0 || index &gt; array.length).
+     * @deprecated this method has been superseded by {@link #insert(int, long[], long...)}
and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static long[] add(final long[] array, final int index, final long element) {
         return (long[]) add(array, index, Long.valueOf(element), Long.TYPE);
     }
@@ -5856,7 +5884,11 @@ public class ArrayUtils {
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range
      * (index &lt; 0 || index &gt; array.length).
+     * @deprecated this method has been superseded by {@link #insert(int, float[], float...)}
and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static float[] add(final float[] array, final int index, final float element)
{
         return (float[]) add(array, index, Float.valueOf(element), Float.TYPE);
     }
@@ -5887,7 +5919,11 @@ public class ArrayUtils {
      * @return A new array containing the existing elements and the new element
      * @throws IndexOutOfBoundsException if the index is out of range
      * (index &lt; 0 || index &gt; array.length).
+     * @deprecated this method has been superseded by {@link #insert(int, double[], double...)}
and
+     * may be removed in a future release. Please note the handling of {@code null} input
arrays differs
+     * in the new method: inserting {@code X} into a {@code null} array results in {@code
null} not {@code X}.
      */
+    @Deprecated
     public static double[] add(final double[] array, final int index, final double element)
{
         return (double[]) add(array, index, Double.valueOf(element), Double.TYPE);
     }
@@ -8021,4 +8057,399 @@ public class ArrayUtils {
 
         return result;
     }
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    public static boolean[] insert(final int index, final boolean[] array, final boolean...
values) {     
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        boolean[] result = new boolean[array.length + values.length];
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    }
+    
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    public static byte[] insert(final int index, final byte[] array, final byte... values)
{     
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        byte[] result = new byte[array.length + values.length];
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    }
+    
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    public static char[] insert(final int index, final char[] array, final char... values)
{     
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        char[] result = new char[array.length + values.length];
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    }    
+    
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    public static double[] insert(final int index, final double[] array, final double...
values) {     
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        double[] result = new double[array.length + values.length];
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    } 
+    
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    public static float[] insert(final int index, final float[] array, final float... values)
{     
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        float[] result = new float[array.length + values.length];
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    }     
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    public static int[] insert(final int index, final int[] array, final int... values) {
    
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        int[] result = new int[array.length + values.length];
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    }     
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    public static long[] insert(final int index, final long[] array, final long... values)
{     
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        long[] result = new long[array.length + values.length];
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    }    
+    
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    public static short[] insert(final int index, final short[] array, final short... values)
{     
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        short[] result = new short[array.length + values.length];
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    }    
+    
+    
+    /**
+     * <p>Inserts elements into an array at the given index (starting from zero).</p>
+     * 
+     * <p>When an array is returned, it is always a new array.</p>
+     * 
+     * <pre>
+     * ArrayUtils.insert(index, null, null)      = null
+     * ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
+     * ArrayUtils.insert(index, null, values)    = null
+     * </pre>
+     *  
+     * @param index the position within {@code array} to insert the new values
+     * @param array the array to insert the values into, may be {@code null}
+     * @param values the new values to insert, may be {@code null}
+     * @return The new array.
+     * @throws IndexOutOfBoundsException if {@code array} is provided 
+     * and either {@code index < 0} or {@code index > array.length}
+     * @since 3.6
+     */
+    @SafeVarargs
+    public static <T> T[] insert(final int index, final T[] array, final T... values)
{
+        /*
+         * Note on use of @SafeVarargs:
+         * 
+         * By returning null when 'array' is null, we avoid returning the vararg
+         * array to the caller. We also avoid relying on the type of the vararg
+         * array, by inspecting the component type of 'array'.
+         */
+        
+        if (array == null) {
+            return null;
+        }
+        if (values == null || values.length == 0) {
+            return clone(array);
+        }
+        if (index < 0 || index > array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + array.length);
+        }
+        
+        final Class<?> type = array.getClass().getComponentType();
+        @SuppressWarnings("unchecked") // OK, because array and values are of type T
+        T[] result = (T[]) Array.newInstance(type, array.length + values.length);
+        
+        System.arraycopy(values, 0, result, index, values.length);
+        if (index > 0) {
+            System.arraycopy(array, 0, result, 0, index);
+        }
+        if (index < array.length) {
+            System.arraycopy(array, index, result, index + values.length, array.length -
index);
+        }
+        return result;
+    } 
 }

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/795fe5d8/src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java
new file mode 100644
index 0000000..0c06c1f
--- /dev/null
+++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java
@@ -0,0 +1,349 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.commons.lang3;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+/**
+ * Tests ArrayUtils insert methods.
+ */
+public class ArrayUtilsInsertTest {
+    
+    @Test
+    public void testInsertBooleans() throws Exception {
+        final boolean[] array = {true,false,true};
+        final boolean[] values = {false,true,false};
+        
+        boolean[] result = ArrayUtils.insert(42, array, null);
+        assertArrayEquals(array, result);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new boolean[0], ArrayUtils.insert(0, new boolean[0], null));  
     
+        assertNull(ArrayUtils.insert(42, (boolean[]) null, null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new boolean[]{false,true,false,true}, ArrayUtils.insert(0, array,
false));
+        assertArrayEquals(new boolean[]{true,false,false,true}, ArrayUtils.insert(1, array,
false));
+        assertArrayEquals(new boolean[]{true,false,true,false}, ArrayUtils.insert(array.length,
array, false));
+        assertArrayEquals(new boolean[]{false,true,false,true,false,true}, ArrayUtils.insert(0,
array, values));
+        assertArrayEquals(new boolean[]{true,false,true,false,false,true}, ArrayUtils.insert(1,
array, values));
+        assertArrayEquals(new boolean[]{true,false,true,false,true,false}, ArrayUtils.insert(array.length,
array, values));
+    }
+
+
+    @Test
+    public void testInsertBytes() throws Exception {
+        final byte[] array = {1,2,3};
+        final byte[] values = {4,5,6};
+        
+        byte[] result = ArrayUtils.insert(42, array, null);
+        assertArrayEquals(array, result);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new byte[0], ArrayUtils.insert(0, new byte[0], null));
+        assertNull(ArrayUtils.insert(42, (byte[]) null, null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new byte[]{0,1,2,3}, ArrayUtils.insert(0, array, (byte) 0));
+        assertArrayEquals(new byte[]{1,0,2,3}, ArrayUtils.insert(1, array, (byte) 0));
+        assertArrayEquals(new byte[]{1,2,3,0}, ArrayUtils.insert(array.length, array, (byte)
0));
+        assertArrayEquals(new byte[]{4,5,6,1,2,3}, ArrayUtils.insert(0, array, values));
+        assertArrayEquals(new byte[]{1,4,5,6,2,3}, ArrayUtils.insert(1, array, values));
+        assertArrayEquals(new byte[]{1,2,3,4,5,6}, ArrayUtils.insert(array.length, array,
values));
+    }
+    
+    @Test
+    public void testInsertChars() throws Exception {
+        final char[] array = {'a','b','c'};
+        final char[] values = {'d','e','f'};
+        
+        char[] result = ArrayUtils.insert(42, array, null);
+        assertArrayEquals(array, result);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new char[0], ArrayUtils.insert(0, new char[0], null));
+        assertNull(ArrayUtils.insert(42, (char[]) null, null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new char[]{'z','a','b','c'}, ArrayUtils.insert(0, array, 'z'));
+        assertArrayEquals(new char[]{'a','z','b','c'}, ArrayUtils.insert(1, array, 'z'));
+        assertArrayEquals(new char[]{'a','b','c','z'}, ArrayUtils.insert(array.length, array,
'z'));
+        assertArrayEquals(new char[]{'d','e','f','a','b','c'}, ArrayUtils.insert(0, array,
values));
+        assertArrayEquals(new char[]{'a','d','e','f','b','c'}, ArrayUtils.insert(1, array,
values));
+        assertArrayEquals(new char[]{'a','b','c','d','e','f'}, ArrayUtils.insert(array.length,
array, values));
+    }
+    
+    @Test
+    public void testInsertDoubles() throws Exception {
+        final double[] array = {1,2,3};
+        final double[] values = {4,5,6};
+        final double delta = 0.000001;
+        
+        double[] result = ArrayUtils.insert(42, array, null);
+        assertArrayEquals(array, result, delta);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new double[0], ArrayUtils.insert(0, new double[0], null), delta);
+        assertNull(ArrayUtils.insert(42, (double[]) null, null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new double[]{0,1,2,3}, ArrayUtils.insert(0, array, 0), delta);
+        assertArrayEquals(new double[]{1,0,2,3}, ArrayUtils.insert(1, array, 0), delta);
+        assertArrayEquals(new double[]{1,2,3,0}, ArrayUtils.insert(array.length, array, 0),
delta);
+        assertArrayEquals(new double[]{4,5,6,1,2,3}, ArrayUtils.insert(0, array, values),
delta);
+        assertArrayEquals(new double[]{1,4,5,6,2,3}, ArrayUtils.insert(1, array, values),
delta);
+        assertArrayEquals(new double[]{1,2,3,4,5,6}, ArrayUtils.insert(array.length, array,
values), delta);
+    }    
+    
+    @Test
+    public void testInsertFloats() throws Exception {
+        final float[] array = {1,2,3};
+        final float[] values = {4,5,6};
+        final float delta = 0.000001f;
+        
+        float[] result = ArrayUtils.insert(42, array, null);
+        assertArrayEquals(array, result, delta);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new float[0], ArrayUtils.insert(0, new float[0], null), delta);
+        assertNull(ArrayUtils.insert(42, (float[]) null, null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new float[]{0,1,2,3}, ArrayUtils.insert(0, array, 0), delta);
+        assertArrayEquals(new float[]{1,0,2,3}, ArrayUtils.insert(1, array, 0), delta);
+        assertArrayEquals(new float[]{1,2,3,0}, ArrayUtils.insert(array.length, array, 0),
delta);
+        assertArrayEquals(new float[]{4,5,6,1,2,3}, ArrayUtils.insert(0, array, values),
delta);
+        assertArrayEquals(new float[]{1,4,5,6,2,3}, ArrayUtils.insert(1, array, values),
delta);
+        assertArrayEquals(new float[]{1,2,3,4,5,6}, ArrayUtils.insert(array.length, array,
values), delta);
+    }     
+    
+    @Test
+    public void testInsertInts() throws Exception {
+        final int[] array = {1,2,3};
+        final int[] values = {4,5,6};
+        
+        int[] result = ArrayUtils.insert(42, array, null);
+        assertArrayEquals(array, result);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new int[0], ArrayUtils.insert(0, new int[0], null));
+        assertNull(ArrayUtils.insert(42, (int[]) null, null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new int[]{0,1,2,3}, ArrayUtils.insert(0, array, 0));
+        assertArrayEquals(new int[]{1,0,2,3}, ArrayUtils.insert(1, array, 0));
+        assertArrayEquals(new int[]{1,2,3,0}, ArrayUtils.insert(array.length, array, 0));
+        assertArrayEquals(new int[]{4,5,6,1,2,3}, ArrayUtils.insert(0, array, values));
+        assertArrayEquals(new int[]{1,4,5,6,2,3}, ArrayUtils.insert(1, array, values));
+        assertArrayEquals(new int[]{1,2,3,4,5,6}, ArrayUtils.insert(array.length, array,
values));
+    }    
+    
+    
+    @Test
+    public void testInsertLongs() throws Exception {
+        final long[] array = {1,2,3};
+        final long[] values = {4,5,6};
+        
+        long[] result = ArrayUtils.insert(42, array, null);
+        assertArrayEquals(array, result);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new long[0], ArrayUtils.insert(0, new long[0], null));
+        assertNull(ArrayUtils.insert(42, (long[]) null, null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new long[]{0,1,2,3}, ArrayUtils.insert(0, array, 0));
+        assertArrayEquals(new long[]{1,0,2,3}, ArrayUtils.insert(1, array, 0));
+        assertArrayEquals(new long[]{1,2,3,0}, ArrayUtils.insert(array.length, array, 0));
+        assertArrayEquals(new long[]{4,5,6,1,2,3}, ArrayUtils.insert(0, array, values));
+        assertArrayEquals(new long[]{1,4,5,6,2,3}, ArrayUtils.insert(1, array, values));
+        assertArrayEquals(new long[]{1,2,3,4,5,6}, ArrayUtils.insert(array.length, array,
values));
+    } 
+    
+    
+    @Test
+    public void testInsertShorts() throws Exception {
+        final short[] array = {1,2,3};
+        final short[] values = {4,5,6};
+        
+        short[] result = ArrayUtils.insert(42, array, null);
+        assertArrayEquals(array, result);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new short[0], ArrayUtils.insert(0, new short[0], null));
+        assertNull(ArrayUtils.insert(42, (short[]) null, null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new short[]{0,1,2,3}, ArrayUtils.insert(0, array, (short) 0));
+        assertArrayEquals(new short[]{1,0,2,3}, ArrayUtils.insert(1, array, (short) 0));
+        assertArrayEquals(new short[]{1,2,3,0}, ArrayUtils.insert(array.length, array, (short)
0));
+        assertArrayEquals(new short[]{4,5,6,1,2,3}, ArrayUtils.insert(0, array, values));
+        assertArrayEquals(new short[]{1,4,5,6,2,3}, ArrayUtils.insert(1, array, values));
+        assertArrayEquals(new short[]{1,2,3,4,5,6}, ArrayUtils.insert(array.length, array,
values));
+    } 
+    
+    
+    @Test
+    public void testInsertGenericArray() throws Exception {
+        final String[] array = {"a","b","c"};
+        final String[] values = {"d","e","f"};
+        
+        String[] result = ArrayUtils.insert(42, array, (String[]) null);
+        assertArrayEquals(array, result);
+        assertFalse(array == result);
+        
+        assertNull(ArrayUtils.insert(42, null, array));    
+        assertArrayEquals(new String[0], ArrayUtils.insert(0, new String[0], (String[]) null));
+        assertNull(ArrayUtils.insert(42, (String[]) null, (String[]) null));
+        
+        try {
+            ArrayUtils.insert(-1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        
+        try {
+            ArrayUtils.insert(array.length + 1, array, array);
+            fail("Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }        
+        
+        assertArrayEquals(new String[]{"z","a","b","c"}, ArrayUtils.insert(0, array, "z"));
+        assertArrayEquals(new String[]{"a","z","b","c"}, ArrayUtils.insert(1, array, "z"));
+        assertArrayEquals(new String[]{"a","b","c","z"}, ArrayUtils.insert(array.length,
array, "z"));
+        assertArrayEquals(new String[]{"d","e","f","a","b","c"}, ArrayUtils.insert(0, array,
values));
+        assertArrayEquals(new String[]{"a","d","e","f","b","c"}, ArrayUtils.insert(1, array,
values));
+        assertArrayEquals(new String[]{"a","b","c","d","e","f"}, ArrayUtils.insert(array.length,
array, values));
+    }     
+}


Mime
View raw message