• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
testInsertBooleans()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
testInsertBytes()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
testInsertChars()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
testInsertDoubles()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
testInsertFloats()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
testInsertGenericArray()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
testInsertInts()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
testInsertLongs()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
testInsertShorts()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 }
254