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  
57      @Test
58      public void testInsertBytes() {
59          final byte[] array = {1, 2, 3};
60          final byte[] values = {4, 5, 6};
61  
62          final byte[] result = ArrayUtils.insert(42, array, null);
63          assertArrayEquals(array, result);
64          assertNotSame(array, result);
65  
66          assertNull(ArrayUtils.insert(42, null, array));
67          assertArrayEquals(new byte[0], ArrayUtils.insert(0, new byte[0], null));
68          assertNull(ArrayUtils.insert(42, (byte[]) null, null));
69  
70          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
71          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
72  
73          assertArrayEquals(new byte[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, (byte) 0));
74          assertArrayEquals(new byte[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, (byte) 0));
75          assertArrayEquals(new byte[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, (byte) 0));
76          assertArrayEquals(new byte[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values));
77          assertArrayEquals(new byte[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values));
78          assertArrayEquals(new byte[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values));
79      }
80  
81      @Test
82      public void testInsertChars() {
83          final char[] array = {'a', 'b', 'c'};
84          final char[] values = {'d', 'e', 'f'};
85  
86          final char[] result = ArrayUtils.insert(42, array, null);
87          assertArrayEquals(array, result);
88          assertNotSame(array, result);
89  
90          assertNull(ArrayUtils.insert(42, null, array));
91          assertArrayEquals(new char[0], ArrayUtils.insert(0, new char[0], null));
92          assertNull(ArrayUtils.insert(42, (char[]) null, null));
93  
94          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
95          assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
96  
97          assertArrayEquals(new char[]{'z', 'a', 'b', 'c'}, ArrayUtils.insert(0, array, 'z'));
98          assertArrayEquals(new char[]{'a', 'z', 'b', 'c'}, ArrayUtils.insert(1, array, 'z'));
99          assertArrayEquals(new char[]{'a', 'b', 'c', 'z'}, ArrayUtils.insert(array.length, array, 'z'));
100         assertArrayEquals(new char[]{'d', 'e', 'f', 'a', 'b', 'c'}, ArrayUtils.insert(0, array, values));
101         assertArrayEquals(new char[]{'a', 'd', 'e', 'f', 'b', 'c'}, ArrayUtils.insert(1, array, values));
102         assertArrayEquals(new char[]{'a', 'b', 'c', 'd', 'e', 'f'}, ArrayUtils.insert(array.length, array, values));
103     }
104 
105     @Test
106     public void testInsertDoubles() {
107         final double[] array = {1, 2, 3};
108         final double[] values = {4, 5, 6};
109         final double delta = 0.000001;
110 
111         final double[] result = ArrayUtils.insert(42, array, null);
112         assertArrayEquals(array, result, delta);
113         assertNotSame(array, result);
114 
115         assertNull(ArrayUtils.insert(42, null, array));
116         assertArrayEquals(new double[0], ArrayUtils.insert(0, new double[0], null), delta);
117         assertNull(ArrayUtils.insert(42, (double[]) null, null));
118 
119         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
120         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
121 
122         assertArrayEquals(new double[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, 0), delta);
123         assertArrayEquals(new double[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, 0), delta);
124         assertArrayEquals(new double[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, 0), delta);
125         assertArrayEquals(new double[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values), delta);
126         assertArrayEquals(new double[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values), delta);
127         assertArrayEquals(new double[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values), delta);
128     }
129 
130     @Test
131     public void testInsertFloats() {
132         final float[] array = {1, 2, 3};
133         final float[] values = {4, 5, 6};
134         final float delta = 0.000001f;
135 
136         final float[] result = ArrayUtils.insert(42, array, null);
137         assertArrayEquals(array, result, delta);
138         assertNotSame(array, result);
139 
140         assertNull(ArrayUtils.insert(42, null, array));
141         assertArrayEquals(new float[0], ArrayUtils.insert(0, new float[0], null), delta);
142         assertNull(ArrayUtils.insert(42, (float[]) null, null));
143 
144         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
145         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
146 
147         assertArrayEquals(new float[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, 0), delta);
148         assertArrayEquals(new float[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, 0), delta);
149         assertArrayEquals(new float[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, 0), delta);
150         assertArrayEquals(new float[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values), delta);
151         assertArrayEquals(new float[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values), delta);
152         assertArrayEquals(new float[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values), delta);
153     }
154 
155     @Test
156     public void testInsertGenericArray() {
157         final String[] array = {"a", "b", "c"};
158         final String[] values = {"d", "e", "f"};
159 
160         final String[] result = ArrayUtils.insert(42, array, (String[]) null);
161         assertArrayEquals(array, result);
162         assertNotSame(array, result);
163 
164         assertNull(ArrayUtils.insert(42, null, array));
165         assertArrayEquals(new String[0], ArrayUtils.insert(0, new String[0], (String[]) null));
166         assertNull(ArrayUtils.insert(42, null, (String[]) null));
167 
168         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
169         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
170 
171         assertArrayEquals(new String[]{"z", "a", "b", "c"}, ArrayUtils.insert(0, array, "z"));
172         assertArrayEquals(new String[]{"a", "z", "b", "c"}, ArrayUtils.insert(1, array, "z"));
173         assertArrayEquals(new String[]{"a", "b", "c", "z"}, ArrayUtils.insert(array.length, array, "z"));
174         assertArrayEquals(new String[]{"d", "e", "f", "a", "b", "c"}, ArrayUtils.insert(0, array, values));
175         assertArrayEquals(new String[]{"a", "d", "e", "f", "b", "c"}, ArrayUtils.insert(1, array, values));
176         assertArrayEquals(new String[]{"a", "b", "c", "d", "e", "f"}, ArrayUtils.insert(array.length, array, values));
177     }
178 
179 
180     @Test
181     public void testInsertInts() {
182         final int[] array = {1, 2, 3};
183         final int[] values = {4, 5, 6};
184 
185         final int[] result = ArrayUtils.insert(42, array, null);
186         assertArrayEquals(array, result);
187         assertNotSame(array, result);
188 
189         assertNull(ArrayUtils.insert(42, null, array));
190         assertArrayEquals(new int[0], ArrayUtils.insert(0, new int[0], null));
191         assertNull(ArrayUtils.insert(42, (int[]) null, null));
192 
193         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
194         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
195 
196         assertArrayEquals(new int[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, 0));
197         assertArrayEquals(new int[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, 0));
198         assertArrayEquals(new int[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, 0));
199         assertArrayEquals(new int[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values));
200         assertArrayEquals(new int[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values));
201         assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values));
202     }
203 
204 
205     @Test
206     public void testInsertLongs() {
207         final long[] array = {1, 2, 3};
208         final long[] values = {4, 5, 6};
209 
210         final long[] result = ArrayUtils.insert(42, array, null);
211         assertArrayEquals(array, result);
212         assertNotSame(array, result);
213 
214         assertNull(ArrayUtils.insert(42, null, array));
215         assertArrayEquals(new long[0], ArrayUtils.insert(0, new long[0], null));
216         assertNull(ArrayUtils.insert(42, (long[]) null, null));
217 
218         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
219         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
220 
221         assertArrayEquals(new long[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, 0));
222         assertArrayEquals(new long[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, 0));
223         assertArrayEquals(new long[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, 0));
224         assertArrayEquals(new long[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values));
225         assertArrayEquals(new long[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values));
226         assertArrayEquals(new long[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values));
227     }
228 
229 
230     @Test
231     public void testInsertShorts() {
232         final short[] array = {1, 2, 3};
233         final short[] values = {4, 5, 6};
234 
235         final short[] result = ArrayUtils.insert(42, array, null);
236         assertArrayEquals(array, result);
237         assertNotSame(array, result);
238 
239         assertNull(ArrayUtils.insert(42, null, array));
240         assertArrayEquals(new short[0], ArrayUtils.insert(0, new short[0], null));
241         assertNull(ArrayUtils.insert(42, (short[]) null, null));
242 
243         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(-1, array, array));
244         assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.insert(array.length + 1, array, array));
245 
246         assertArrayEquals(new short[]{0, 1, 2, 3}, ArrayUtils.insert(0, array, (short) 0));
247         assertArrayEquals(new short[]{1, 0, 2, 3}, ArrayUtils.insert(1, array, (short) 0));
248         assertArrayEquals(new short[]{1, 2, 3, 0}, ArrayUtils.insert(array.length, array, (short) 0));
249         assertArrayEquals(new short[]{4, 5, 6, 1, 2, 3}, ArrayUtils.insert(0, array, values));
250         assertArrayEquals(new short[]{1, 4, 5, 6, 2, 3}, ArrayUtils.insert(1, array, values));
251         assertArrayEquals(new short[]{1, 2, 3, 4, 5, 6}, ArrayUtils.insert(array.length, array, values));
252     }
253 }