From 6362660b3bfb4fb41719496f1037dc3acb0597ea Mon Sep 17 00:00:00 2001
From: Andrii <aabrasha@gmail.com>
Date: Thu, 24 Nov 2016 22:46:15 +0200
Subject: [PATCH] add tests to cover ArrayUtils

---
 .../apache/commons/lang3/ArrayUtilsTest.java  | 521 ++++++++++++++++++
 1 file changed, 521 insertions(+)

diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
index 06ded81df4f..0990b1783f8 100644
--- a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
@@ -2162,6 +2162,87 @@ public void testSwapCharRange() {
         assertEquals(3, array[0]);
         assertEquals(2, array[1]);
         assertEquals(1, array[2]);
+    
+        array = new char[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+    
+        array = new char[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+    
+        array = new char[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+    }
+    
+    @Test
+    public void testSwapByte() {
+        final byte[] array = new byte[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+    }
+    
+    @Test
+    public void testSwapNullByteArray() {
+        final byte[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyByteArray() {
+        final byte[] array = new byte[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
+    
+    @Test
+    public void testSwapByteRange() {
+        byte[] array = new byte[] {1, 2, 3, 4};
+        ArrayUtils.swap(array, 0, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(4, array[1]);
+        assertEquals(1, array[2]);
+        assertEquals(2, array[3]);
+        
+        array = new byte[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, 3);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+        
+        array = new byte[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+        
+        array = new byte[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+        
+        array = new byte[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+        
+        array = new byte[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
     }
     
     @Test
@@ -2172,6 +2253,20 @@ public void testSwapFloat() {
         assertEquals(2, array[1], 0);
         assertEquals(1, array[2], 0);
     }
+    
+    @Test
+    public void testSwapNullFloatArray() {
+        final float[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyFloatArray() {
+        final float[] array = new float[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
 
     @Test
     public void testSwapFloatRange() {
@@ -2193,6 +2288,24 @@ public void testSwapFloatRange() {
         assertEquals(3, array[0], 0);
         assertEquals(2, array[1], 0);
         assertEquals(1, array[2], 0);
+    
+        array = new float[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, 2, 2);
+        assertEquals(3, array[0], 0);
+        assertEquals(2, array[1], 0);
+        assertEquals(1, array[2], 0);
+    
+        array = new float[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, -1, 2);
+        assertEquals(1, array[0], 0);
+        assertEquals(2, array[1], 0);
+        assertEquals(3, array[2], 0);
+    
+        array = new float[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, -1, 2);
+        assertEquals(1, array[0], 0);
+        assertEquals(2, array[1], 0);
+        assertEquals(3, array[2], 0);
     }
     
     @Test
@@ -2203,6 +2316,20 @@ public void testSwapDouble() {
         assertEquals(2, array[1], 0);
         assertEquals(1, array[2], 0);
     }
+    
+    @Test
+    public void testSwapNullDoubleArray() {
+        final double[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyDoubleArray() {
+        final double[] array = new double[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
 
     @Test
     public void testSwapDoubleRange() {
@@ -2224,6 +2351,24 @@ public void testSwapDoubleRange() {
         assertEquals(3, array[0], 0);
         assertEquals(2, array[1], 0);
         assertEquals(1, array[2], 0);
+    
+        array = new double[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, 2, 2);
+        assertEquals(3, array[0], 0);
+        assertEquals(2, array[1], 0);
+        assertEquals(1, array[2], 0);
+    
+        array = new double[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, -1, 2);
+        assertEquals(1, array[0], 0);
+        assertEquals(2, array[1], 0);
+        assertEquals(3, array[2], 0);
+    
+        array = new double[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, -1, 2);
+        assertEquals(1, array[0], 0);
+        assertEquals(2, array[1], 0);
+        assertEquals(3, array[2], 0);
     }
     
     @Test
@@ -2234,6 +2379,20 @@ public void testSwapInt() {
         assertEquals(2, array[1]);
         assertEquals(1, array[2]);
     }
+    
+    @Test
+    public void testSwapNullIntArray() {
+        final int[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyIntArray() {
+        final int[] array = new int[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
 
     @Test
     public void testSwapIntRange() {
@@ -2255,6 +2414,24 @@ public void testSwapIntRange() {
         assertEquals(3, array[0]);
         assertEquals(2, array[1]);
         assertEquals(1, array[2]);
+    
+        array = new int[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+    
+        array = new int[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+    
+        array = new int[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
     }
     
     @Test
@@ -2268,6 +2445,83 @@ public void testSwapIntExchangedOffsets() {
         ArrayUtils.swap(array, 1, 0, 2);
         assertArrayEquals(new int[] {2, 3, 1}, array);
     }
+    
+    @Test
+    public void testSwapShort() {
+        final short[] array = new short[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+    }
+    
+    @Test
+    public void testSwapNullShortArray() {
+        final short[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyShortArray() {
+        final short[] array = new short[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
+    
+    @Test
+    public void testSwapShortRange() {
+        short[] array = new short[] {1, 2, 3, 4};
+        ArrayUtils.swap(array, 0, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(4, array[1]);
+        assertEquals(1, array[2]);
+        assertEquals(2, array[3]);
+        
+        array = new short[] {1, 2, 3};
+        ArrayUtils.swap(array, 3, 0);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+        
+        array = new short[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+        
+        array = new short[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+        
+        array = new short[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+        
+        array = new short[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+    }
+    
+    @Test
+    public void testSwapNullCharArray() {
+        final char[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyCharArray() {
+        final char[] array = new char[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
 
     @Test
     public void testSwapLong() {
@@ -2277,6 +2531,20 @@ public void testSwapLong() {
         assertEquals(2, array[1]);
         assertEquals(1, array[2]);
     }
+    
+    @Test
+    public void testSwapNullLongArray() {
+        final long[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyLongArray() {
+        final long[] array = new long[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
 
     @Test
     public void testSwapLongRange() {
@@ -2298,6 +2566,87 @@ public void testSwapLongRange() {
         assertEquals(3, array[0]);
         assertEquals(2, array[1]);
         assertEquals(1, array[2]);
+    
+        array = new long[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, 2, 2);
+        assertEquals(3, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(1, array[2]);
+    
+        array = new long[] {1, 2, 3};
+        ArrayUtils.swap(array, 0, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+    
+        array = new long[] {1, 2, 3};
+        ArrayUtils.swap(array, -1, -1, 2);
+        assertEquals(1, array[0]);
+        assertEquals(2, array[1]);
+        assertEquals(3, array[2]);
+    }
+    
+    @Test
+    public void testSwapBoolean() {
+        final boolean[] array = new boolean[] {true, false, false};
+        ArrayUtils.swap(array, 0, 2);
+        assertFalse(array[0]);
+        assertFalse(array[1]);
+        assertTrue(array[2]);
+    }
+    
+    @Test
+    public void testSwapNullBooleanArray() {
+        final boolean[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyBooleanArray() {
+        final boolean[] array = new boolean[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
+    
+    @Test
+    public void testSwapBooleanRange() {
+        boolean[] array = new boolean[] {false, false, true, true};
+        ArrayUtils.swap(array, 0, 2, 2);
+        assertTrue(array[0]);
+        assertTrue(array[1]);
+        assertFalse(array[2]);
+        assertFalse(array[3]);
+        
+        array = new boolean[] {false, true, false};
+        ArrayUtils.swap(array, 0, 3);
+        assertFalse(array[0]);
+        assertTrue(array[1]);
+        assertFalse(array[2]);
+        
+        array = new boolean[] {true, true, false};
+        ArrayUtils.swap(array, 0, 2, 2);
+        assertFalse(array[0]);
+        assertTrue(array[1]);
+        assertTrue(array[2]);
+        
+        array = new boolean[] {true, true, false};
+        ArrayUtils.swap(array, -1, 2, 2);
+        assertFalse(array[0]);
+        assertTrue(array[1]);
+        assertTrue(array[2]);
+        
+        array = new boolean[] {true, true, false};
+        ArrayUtils.swap(array, 0, -1, 2);
+        assertTrue(array[0]);
+        assertTrue(array[1]);
+        assertFalse(array[2]);
+        
+        array = new boolean[] {true, true, false};
+        ArrayUtils.swap(array, -1, -1, 2);
+        assertTrue(array[0]);
+        assertTrue(array[1]);
+        assertFalse(array[2]);
     }
 
     @Test
@@ -2308,6 +2657,20 @@ public void testSwapObject() {
         assertEquals("2", array[1]);
         assertEquals("1", array[2]);
     }
+    
+    @Test
+    public void testSwapNullObjectArray() {
+        final String[] array = null;
+        ArrayUtils.swap(array, 0, 2);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testSwapEmptyObjectArray() {
+        final String[] array = new String[0];
+        ArrayUtils.swap(array, 0, 2);
+        assertEquals(0, array.length);
+    }
 
     @Test
     public void testSwapObjectRange() {
@@ -2332,6 +2695,22 @@ public void testSwapObjectRange() {
         assertEquals("5", array[2]);
         assertEquals("2", array[3]);
         assertEquals("1", array[4]);
+    
+        array = new String[] {"1", "2", "3", "4", "5"};
+        ArrayUtils.swap(array, 2, -2, 3);
+        assertEquals("3", array[0]);
+        assertEquals("4", array[1]);
+        assertEquals("5", array[2]);
+        assertEquals("2", array[3]);
+        assertEquals("1", array[4]);
+    
+        array = new String[0];
+        ArrayUtils.swap(array, 0, 2, 2);
+        assertEquals(0, array.length);
+    
+        array = null;
+        ArrayUtils.swap(array, 0, 2, 2);
+        assertNull(array);
     }
 
     //-----------------------------------------------------------------------
@@ -2386,6 +2765,21 @@ public void testShiftRangeNoElemDouble() {
         assertEquals(3, array[2], 0);
         assertEquals(4, array[3], 0);
     }
+    
+    @Test
+    public void testShiftRangeNullDouble() {
+        final double[] array = null;
+        ArrayUtils.shift(array, 1, 1, 1);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testShiftNullDouble() {
+        final double[] array = null;
+        
+        ArrayUtils.shift(array, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftAllDouble() {
@@ -2453,6 +2847,21 @@ public void testShiftRangeNoElemFloat() {
         assertEquals(3, array[2], 0);
         assertEquals(4, array[3], 0);
     }
+    
+    @Test
+    public void testShiftRangeNullFloat() {
+        final float[] array = null;
+        ArrayUtils.shift(array, 1, 1, 1);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testShiftNullFloat() {
+        final float[] array = null;
+        
+        ArrayUtils.shift(array, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftAllFloat() {
@@ -2500,6 +2909,14 @@ public void testShiftShort() {
         assertEquals(2, array[3]);
         assertEquals(3, array[4]);
     }
+    
+    @Test
+    public void testShiftNullShort() {
+        final short[] array = null;
+        
+        ArrayUtils.shift(array, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftRangeShort() {
@@ -2527,6 +2944,14 @@ public void testShiftRangeNoElemShort() {
         assertEquals(3, array[2]);
         assertEquals(4, array[3]);
     }
+    
+    @Test
+    public void testShiftRangeNullShort() {
+        final short[] array = null;
+        
+        ArrayUtils.shift(array, 1, 1, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftAllShort() {
@@ -2594,6 +3019,13 @@ public void testShiftRangeNoElemByte() {
         assertEquals(3, array[2]);
         assertEquals(4, array[3]);
     }
+    
+    @Test
+    public void testShiftRangeNullByte() {
+        final byte[] array = null;
+        ArrayUtils.shift(array, 1, 1, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftAllByte() {
@@ -2661,6 +3093,13 @@ public void testShiftRangeNoElemChar() {
         assertEquals(3, array[2]);
         assertEquals(4, array[3]);
     }
+    
+    @Test
+    public void testShiftRangeNullChar() {
+        final char[] array = null;
+        ArrayUtils.shift(array, 1, 1, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftAllChar() {
@@ -2728,6 +3167,21 @@ public void testShiftRangeNoElemLong() {
         assertEquals(3, array[2]);
         assertEquals(4, array[3]);
     }
+    
+    @Test
+    public void testShiftRangeNullLong() {
+        final long[] array = null;
+        ArrayUtils.shift(array, 1, 1, 1);
+        assertNull(array);
+    }
+    
+    @Test
+    public void testShiftNullLong() {
+        final long[] array = null;
+        
+        ArrayUtils.shift(array, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftAllLong() {
@@ -2768,6 +3222,14 @@ public void testShiftInt() {
         assertEquals(1, array[2]);
         assertEquals(2, array[3]);
     }
+    
+    @Test
+    public void testShiftNullInt() {
+        final int[] array = null;
+        
+        ArrayUtils.shift(array, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftRangeInt() {
@@ -2795,6 +3257,13 @@ public void testShiftRangeNoElemInt() {
         assertEquals(3, array[2]);
         assertEquals(4, array[3]);
     }
+    
+    @Test
+    public void testShiftRangeNullInt() {
+        final int[] array = null;
+        ArrayUtils.shift(array, 1, 1, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftAllInt() {
@@ -2835,6 +3304,14 @@ public void testShiftObject() {
         assertEquals("1", array[2]);
         assertEquals("2", array[3]);
     }
+    
+    @Test
+    public void testShiftNullObject() {
+        final String[] array = null;
+        
+        ArrayUtils.shift(array, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftRangeObject() {
@@ -2862,6 +3339,13 @@ public void testShiftRangeNoElemObject() {
         assertEquals("3", array[2]);
         assertEquals("4", array[3]);
     }
+    
+    @Test
+    public void testShiftRangeNullObject() {
+        final String[] array = null;
+        ArrayUtils.shift(array, 1, 1, 1);
+        assertNull(array);
+    }
 
     @Test
     public void testShiftAllObject() {
@@ -2878,6 +3362,43 @@ public void testShiftAllObject() {
         assertEquals("4", array[3]);
     }
     
+    @Test
+    public void testShiftBoolean() {
+        final boolean[] array = new boolean[] {true, true, false, false};
+        
+        ArrayUtils.shift(array, 1);
+        assertFalse(array[0]);
+        assertTrue(array[1]);
+        assertTrue(array[2]);
+        assertFalse(array[3]);
+        
+        ArrayUtils.shift(array, -1);
+        assertTrue(array[0]);
+        assertTrue(array[1]);
+        assertFalse(array[2]);
+        assertFalse(array[3]);
+        
+        ArrayUtils.shift(array, 5);
+        assertFalse(array[0]);
+        assertTrue(array[1]);
+        assertTrue(array[2]);
+        assertFalse(array[3]);
+        
+        ArrayUtils.shift(array, -3);
+        assertFalse(array[0]);
+        assertFalse(array[1]);
+        assertTrue(array[2]);
+        assertTrue(array[3]);
+    }
+    
+    @Test
+    public void testShiftNullBoolean() {
+        final boolean[] array = null;
+        
+        ArrayUtils.shift(array, 1);
+        assertNull(array);
+    }
+    
     //-----------------------------------------------------------------------
     @Test
     public void testIndexOf() {