View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.lang3;
19  
20  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
21  import static org.junit.jupiter.api.Assertions.assertNotSame;
22  import static org.junit.jupiter.api.Assertions.assertNull;
23  import static org.junit.jupiter.api.Assertions.assertThrows;
24  
25  import org.junit.jupiter.api.Test;
26  
27  /**
28   * Tests ArrayUtils insert methods.
29   */
30  public class ArrayUtilsInsertTest extends AbstractLangTest {
31  
32      @Test
33      public void testInsertBooleans() {
34          final boolean[] array = {true, false, true};
35          final boolean[] values = {false, true, false};
36  
37          final boolean[] result = ArrayUtils.insert(42, array, null);
38          assertArrayEquals(array, result);
39          assertNotSame(array, result);
40  
41          assertNull(ArrayUtils.insert(42, null, array));
42          assertArrayEquals(new boolean[0], ArrayUtils.insert(0, new boolean[0], null));
43          assertNull(ArrayUtils.insert(42, (boolean[]) null, null));
44  
45          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
46          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
47  
48          assertArrayEquals(new boolean[]{false, true, false, true}, ArrayUtils.insert(0, array, false));
49          assertArrayEquals(new boolean[]{true, false, false, true}, ArrayUtils.insert(1, array, false));
50          assertArrayEquals(new boolean[]{true, false, true, false}, ArrayUtils.insert(array.length, array, false));
51          assertArrayEquals(new boolean[]{false, true, false, true, false, true}, ArrayUtils.insert(0, array, values));
52          assertArrayEquals(new boolean[]{true, false, true, false, false, true}, ArrayUtils.insert(1, array, values));
53          assertArrayEquals(new boolean[]{true, false, true, false, true, false}, ArrayUtils.insert(array.length, array, values));
54      }
55  
56      @Test
57      public void testInsertBytes() {
58          final byte[] array = {1, 2, 3};
59          final byte[] values = {4, 5, 6};
60  
61          final byte[] result = ArrayUtils.insert(42, array, null);
62          assertArrayEquals(array, result);
63          assertNotSame(array, result);
64  
65          assertNull(ArrayUtils.insert(42, null, array));
66          assertArrayEquals(new byte[0], ArrayUtils.insert(0, new byte[0], null));
67          assertNull(ArrayUtils.insert(42, (byte[]) null, null));
68  
69          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
70          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
71  
72          assertArrayEquals(new byte[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, (byte) 0));
73          assertArrayEquals(new byte[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, (byte) 0));
74          assertArrayEquals(new byte[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, (byte) 0));
75          assertArrayEquals(new byte[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values));
76          assertArrayEquals(new byte[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values));
77          assertArrayEquals(new byte[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values));
78      }
79  
80      @Test
81      public void testInsertChars() {
82          final char[] array = {'a', 'b', 'c'};
83          final char[] values = {'d', 'e', 'f'};
84  
85          final char[] result = ArrayUtils.insert(42, array, null);
86          assertArrayEquals(array, result);
87          assertNotSame(array, result);
88  
89          assertNull(ArrayUtils.insert(42, null, array));
90          assertArrayEquals(new char[0], ArrayUtils.insert(0, new char[0], null));
91          assertNull(ArrayUtils.insert(42, (char[]) null, null));
92  
93          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
94          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
95  
96          assertArrayEquals(new char[]{'z', 'a', 'b', 'c'}, ArrayUtils.insert(0, array, 'z'));
97          assertArrayEquals(new char[]{'a', 'z', 'b', 'c'}, ArrayUtils.insert(1, array, 'z'));
98          assertArrayEquals(new char[]{'a', 'b', 'c', 'z'}, ArrayUtils.insert(array.length, array, 'z'));
99          assertArrayEquals(new char[]{'d', 'e', 'f', 'a', 'b', 'c'}, ArrayUtils.insert(0, array, values));
100         assertArrayEquals(new char[]{'a', 'd', 'e', 'f', 'b', 'c'}, ArrayUtils.insert(1, array, values));
101         assertArrayEquals(new char[]{'a', 'b', 'c', 'd', 'e', 'f'}, ArrayUtils.insert(array.length, array, values));
102     }
103 
104     @Test
105     public void testInsertDoubles() {
106         final double[] array = {1, 2, 3};
107         final double[] values = {4, 5, 6};
108         final double delta = 0.000001;
109 
110         final double[] result = ArrayUtils.insert(42, array, null);
111         assertArrayEquals(array, result, delta);
112         assertNotSame(array, result);
113 
114         assertNull(ArrayUtils.insert(42, null, array));
115         assertArrayEquals(new double[0], ArrayUtils.insert(0, new double[0], null), delta);
116         assertNull(ArrayUtils.insert(42, (double[]) null, null));
117 
118         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
119         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
120 
121         assertArrayEquals(new double[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, 0), delta);
122         assertArrayEquals(new double[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, 0), delta);
123         assertArrayEquals(new double[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, 0), delta);
124         assertArrayEquals(new double[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values), delta);
125         assertArrayEquals(new double[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values), delta);
126         assertArrayEquals(new double[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values), delta);
127     }
128 
129     @Test
130     public void testInsertFloats() {
131         final float[] array = {1, 2, 3};
132         final float[] values = {4, 5, 6};
133         final float delta = 0.000001f;
134 
135         final float[] result = ArrayUtils.insert(42, array, null);
136         assertArrayEquals(array, result, delta);
137         assertNotSame(array, result);
138 
139         assertNull(ArrayUtils.insert(42, null, array));
140         assertArrayEquals(new float[0], ArrayUtils.insert(0, new float[0], null), delta);
141         assertNull(ArrayUtils.insert(42, (float[]) null, null));
142 
143         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
144         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
145 
146         assertArrayEquals(new float[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, 0), delta);
147         assertArrayEquals(new float[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, 0), delta);
148         assertArrayEquals(new float[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, 0), delta);
149         assertArrayEquals(new float[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values), delta);
150         assertArrayEquals(new float[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values), delta);
151         assertArrayEquals(new float[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values), delta);
152     }
153 
154     @Test
155     public void testInsertGenericArray() {
156         final String[] array = {"a", "b", "c"};
157         final String[] values = {"d", "e", "f"};
158 
159         final String[] result = ArrayUtils.insert(42, array, (String[]) null);
160         assertArrayEquals(array, result);
161         assertNotSame(array, result);
162 
163         assertNull(ArrayUtils.insert(42, null, array));
164         assertArrayEquals(new String[0], ArrayUtils.insert(0, new String[0], (String[]) null));
165         assertNull(ArrayUtils.insert(42, null, (String[]) null));
166 
167         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
168         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
169 
170         assertArrayEquals(new String[]{"z", "a", "b", "c"}, ArrayUtils.insert(0, array, "z"));
171         assertArrayEquals(new String[]{"a", "z", "b", "c"}, ArrayUtils.insert(1, array, "z"));
172         assertArrayEquals(new String[]{"a", "b", "c", "z"}, ArrayUtils.insert(array.length, array, "z"));
173         assertArrayEquals(new String[]{"d", "e", "f", "a", "b", "c"}, ArrayUtils.insert(0, array, values));
174         assertArrayEquals(new String[]{"a", "d", "e", "f", "b", "c"}, ArrayUtils.insert(1, array, values));
175         assertArrayEquals(new String[]{"a", "b", "c", "d", "e", "f"}, ArrayUtils.insert(array.length, array, values));
176     }
177 
178     @Test
179     public void testInsertInts() {
180         final int[] array = {1, 2, 3};
181         final int[] values = {4, 5, 6};
182 
183         final int[] result = ArrayUtils.insert(42, array, null);
184         assertArrayEquals(array, result);
185         assertNotSame(array, result);
186 
187         assertNull(ArrayUtils.insert(42, null, array));
188         assertArrayEquals(new int[0], ArrayUtils.insert(0, new int[0], null));
189         assertNull(ArrayUtils.insert(42, (int[]) null, null));
190 
191         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
192         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
193 
194         assertArrayEquals(new int[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, 0));
195         assertArrayEquals(new int[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, 0));
196         assertArrayEquals(new int[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, 0));
197         assertArrayEquals(new int[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values));
198         assertArrayEquals(new int[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values));
199         assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values));
200     }
201 
202     @Test
203     public void testInsertLongs() {
204         final long[] array = {1, 2, 3};
205         final long[] values = {4, 5, 6};
206 
207         final long[] result = ArrayUtils.insert(42, array, null);
208         assertArrayEquals(array, result);
209         assertNotSame(array, result);
210 
211         assertNull(ArrayUtils.insert(42, null, array));
212         assertArrayEquals(new long[0], ArrayUtils.insert(0, new long[0], null));
213         assertNull(ArrayUtils.insert(42, (long[]) null, null));
214 
215         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
216         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
217 
218         assertArrayEquals(new long[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, 0));
219         assertArrayEquals(new long[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, 0));
220         assertArrayEquals(new long[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, 0));
221         assertArrayEquals(new long[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values));
222         assertArrayEquals(new long[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values));
223         assertArrayEquals(new long[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values));
224     }
225 
226     @Test
227     public void testInsertShorts() {
228         final short[] array = {1, 2, 3};
229         final short[] values = {4, 5, 6};
230 
231         final short[] result = ArrayUtils.insert(42, array, null);
232         assertArrayEquals(array, result);
233         assertNotSame(array, result);
234 
235         assertNull(ArrayUtils.insert(42, null, array));
236         assertArrayEquals(new short[0], ArrayUtils.insert(0, new short[0], null));
237         assertNull(ArrayUtils.insert(42, (short[]) null, null));
238 
239         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
240         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
241 
242         assertArrayEquals(new short[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, (short) 0));
243         assertArrayEquals(new short[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, (short) 0));
244         assertArrayEquals(new short[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, (short) 0));
245         assertArrayEquals(new short[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values));
246         assertArrayEquals(new short[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values));
247         assertArrayEquals(new short[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values));
248     }
249 }