1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.lang3;
18
19 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertFalse;
22 import static org.junit.jupiter.api.Assertions.assertNotEquals;
23 import static org.junit.jupiter.api.Assertions.assertNotNull;
24 import static org.junit.jupiter.api.Assertions.assertNotSame;
25 import static org.junit.jupiter.api.Assertions.assertNull;
26 import static org.junit.jupiter.api.Assertions.assertSame;
27 import static org.junit.jupiter.api.Assertions.assertThrows;
28 import static org.junit.jupiter.api.Assertions.assertTrue;
29
30 import java.lang.reflect.Constructor;
31 import java.lang.reflect.Modifier;
32 import java.util.Arrays;
33 import java.util.BitSet;
34 import java.util.Collections;
35 import java.util.Comparator;
36 import java.util.Date;
37 import java.util.Map;
38 import java.util.Random;
39 import java.util.function.Function;
40 import java.util.function.Supplier;
41
42 import org.apache.commons.lang3.function.Suppliers;
43 import org.junit.jupiter.api.Test;
44
45
46
47
48 @SuppressWarnings("deprecation")
49 public class ArrayUtilsTest extends AbstractLangTest {
50
51 private static final class TestClass {
52
53 }
54
55
56 private static final long SEED = 16111981L;
57
58 @SafeVarargs
59 private static <T> T[] toArrayPropagatingType(final T... items) {
60 return ArrayUtils.toArray(items);
61 }
62
63 private void assertIsEquals(final Object array1, final Object array2, final Object array3) {
64 assertTrue(ArrayUtils.isEquals(array1, array1));
65 assertTrue(ArrayUtils.isEquals(array2, array2));
66 assertTrue(ArrayUtils.isEquals(array3, array3));
67 assertFalse(ArrayUtils.isEquals(array1, array2));
68 assertFalse(ArrayUtils.isEquals(array2, array1));
69 assertFalse(ArrayUtils.isEquals(array1, array3));
70 assertFalse(ArrayUtils.isEquals(array3, array1));
71 assertFalse(ArrayUtils.isEquals(array1, array2));
72 assertFalse(ArrayUtils.isEquals(array2, array1));
73 }
74
75 @Test
76 public void testArraycopyFunction() {
77 String[] arr = { "a", "b" };
78 assertThrows(NullPointerException.class, () -> ArrayUtils.arraycopy(null, 0, 0, 1, i -> new String[3]));
79 assertThrows(NullPointerException.class, () -> ArrayUtils.arraycopy(arr, 0, 0, 1, i -> null));
80 assertThrows(NullPointerException.class, () -> ArrayUtils.arraycopy(arr, 0, 0, 1, (Function<Integer, String[]>) null));
81 }
82
83 @Test
84 public void testArraycopySupplier() {
85 String[] arr = { "a", "b" };
86 assertThrows(NullPointerException.class, () -> ArrayUtils.arraycopy(null, 0, 0, 1, () -> new String[3]));
87 assertThrows(NullPointerException.class, () -> ArrayUtils.arraycopy(arr, 0, 0, 1, Suppliers.nul()));
88 assertThrows(NullPointerException.class, () -> ArrayUtils.arraycopy(arr, 0, 0, 1, (Supplier<String[]>) null));
89 }
90
91
92
93
94 @Test
95 public void testArrayCreation() {
96 final String[] array = ArrayUtils.toArray("foo", "bar");
97 assertEquals(2, array.length);
98 assertEquals("foo", array[0]);
99 assertEquals("bar", array[1]);
100 }
101
102
103
104 @Test
105 public void testArrayCreationWithDifferentTypes() {
106 final Number[] array = ArrayUtils.<Number>toArray(Integer.valueOf(42), Double.valueOf(Math.PI));
107 assertEquals(2, array.length);
108 assertEquals(Integer.valueOf(42), array[0]);
109 assertEquals(Double.valueOf(Math.PI), array[1]);
110 }
111
112
113
114
115 @Test
116 public void testArrayCreationWithGeneralReturnType() {
117 final Object obj = ArrayUtils.toArray("foo", "bar");
118 assertTrue(obj instanceof String[]);
119 }
120
121 @Test
122 public void testClone() {
123 assertArrayEquals(null, ArrayUtils.clone((Object[]) null));
124 Object[] original1 = {};
125 Object[] cloned1 = ArrayUtils.clone(original1);
126 assertArrayEquals(original1, cloned1);
127 assertNotSame(original1, cloned1);
128
129 final StringBuilder builder = new StringBuilder("pick");
130 original1 = new Object[]{builder, "a", new String[]{"stick"}};
131 cloned1 = ArrayUtils.clone(original1);
132 assertArrayEquals(original1, cloned1);
133 assertNotSame(original1, cloned1);
134 assertSame(original1[0], cloned1[0]);
135 assertSame(original1[1], cloned1[1]);
136 assertSame(original1[2], cloned1[2]);
137 }
138
139 @Test
140 public void testCloneBoolean() {
141 assertNull(ArrayUtils.clone((boolean[]) null));
142 final boolean[] original = {true, false};
143 final boolean[] cloned = ArrayUtils.clone(original);
144 assertArrayEquals(original, cloned);
145 assertNotSame(original, cloned);
146 }
147
148 @Test
149 public void testCloneByte() {
150 assertNull(ArrayUtils.clone((byte[]) null));
151 final byte[] original = {1, 6};
152 final byte[] cloned = ArrayUtils.clone(original);
153 assertArrayEquals(original, cloned);
154 assertNotSame(original, cloned);
155 }
156
157 @Test
158 public void testCloneChar() {
159 assertNull(ArrayUtils.clone((char[]) null));
160 final char[] original = {'a', '4'};
161 final char[] cloned = ArrayUtils.clone(original);
162 assertArrayEquals(original, cloned);
163 assertNotSame(original, cloned);
164 }
165
166 @Test
167 public void testCloneDouble() {
168 assertNull(ArrayUtils.clone((double[]) null));
169 final double[] original = {2.4d, 5.7d};
170 final double[] cloned = ArrayUtils.clone(original);
171 assertArrayEquals(original, cloned);
172 assertNotSame(original, cloned);
173 }
174
175 @Test
176 public void testCloneFloat() {
177 assertNull(ArrayUtils.clone((float[]) null));
178 final float[] original = {2.6f, 6.4f};
179 final float[] cloned = ArrayUtils.clone(original);
180 assertArrayEquals(original, cloned);
181 assertNotSame(original, cloned);
182 }
183
184 @Test
185 public void testCloneInt() {
186 assertNull(ArrayUtils.clone((int[]) null));
187 final int[] original = {5, 8};
188 final int[] cloned = ArrayUtils.clone(original);
189 assertArrayEquals(original, cloned);
190 assertNotSame(original, cloned);
191 }
192
193 @Test
194 public void testCloneLong() {
195 assertNull(ArrayUtils.clone((long[]) null));
196 final long[] original = {0L, 1L};
197 final long[] cloned = ArrayUtils.clone(original);
198 assertArrayEquals(original, cloned);
199 assertNotSame(original, cloned);
200 }
201
202 @Test
203 public void testCloneShort() {
204 assertNull(ArrayUtils.clone((short[]) null));
205 final short[] original = {1, 4};
206 final short[] cloned = ArrayUtils.clone(original);
207 assertArrayEquals(original, cloned);
208 assertNotSame(original, cloned);
209 }
210
211 @Test
212 public void testConstructor() {
213 assertNotNull(new ArrayUtils());
214 final Constructor<?>[] cons = ArrayUtils.class.getDeclaredConstructors();
215 assertEquals(1, cons.length);
216 assertTrue(Modifier.isPublic(cons[0].getModifiers()));
217 assertTrue(Modifier.isPublic(ArrayUtils.class.getModifiers()));
218 assertFalse(Modifier.isFinal(ArrayUtils.class.getModifiers()));
219 }
220
221 @Test
222 public void testContains() {
223 final Object[] array = {"0", "1", "2", "3", null, "0"};
224 assertFalse(ArrayUtils.contains(null, null));
225 assertFalse(ArrayUtils.contains(null, "1"));
226 assertTrue(ArrayUtils.contains(array, "0"));
227 assertTrue(ArrayUtils.contains(array, "1"));
228 assertTrue(ArrayUtils.contains(array, "2"));
229 assertTrue(ArrayUtils.contains(array, "3"));
230 assertFalse(ArrayUtils.contains(array, "notInArray"));
231 assertTrue(ArrayUtils.contains(array, null));
232 }
233
234 @Test
235 public void testContains_LANG_1261() {
236
237 class LANG1261ParentObject {
238 @Override
239 public boolean equals(final Object o) {
240 return true;
241 }
242 }
243
244 final class LANG1261ChildObject extends LANG1261ParentObject {
245
246 }
247
248 final Object[] array = new LANG1261ChildObject[]{new LANG1261ChildObject()};
249
250 assertTrue(ArrayUtils.contains(array, new LANG1261ParentObject()));
251 }
252
253 @Test
254 public void testContainsAny() {
255 final Object[] array = {"0", "1", "2", "3", null, "0"};
256 assertFalse(ArrayUtils.containsAny(null, (Object) null));
257 assertFalse(ArrayUtils.containsAny(null, "1"));
258 assertTrue(ArrayUtils.containsAny(array, "0"));
259 assertTrue(ArrayUtils.containsAny(array, "1"));
260 assertTrue(ArrayUtils.containsAny(array, "2"));
261 assertTrue(ArrayUtils.containsAny(array, "3"));
262 assertFalse(ArrayUtils.containsAny(array, "notInArray"));
263 assertTrue(ArrayUtils.containsAny(array, (Object[]) new String[] { null }));
264 }
265
266 @Test
267 public void testContainsBoolean() {
268 boolean[] array = null;
269 assertFalse(ArrayUtils.contains(array, true));
270 array = new boolean[]{true, false, true};
271 assertTrue(ArrayUtils.contains(array, true));
272 assertTrue(ArrayUtils.contains(array, false));
273 array = new boolean[]{true, true};
274 assertTrue(ArrayUtils.contains(array, true));
275 assertFalse(ArrayUtils.contains(array, false));
276 }
277
278 @Test
279 public void testContainsByte() {
280 byte[] array = null;
281 assertFalse(ArrayUtils.contains(array, (byte) 1));
282 array = new byte[]{0, 1, 2, 3, 0};
283 assertTrue(ArrayUtils.contains(array, (byte) 0));
284 assertTrue(ArrayUtils.contains(array, (byte) 1));
285 assertTrue(ArrayUtils.contains(array, (byte) 2));
286 assertTrue(ArrayUtils.contains(array, (byte) 3));
287 assertFalse(ArrayUtils.contains(array, (byte) 99));
288 }
289
290 @Test
291 public void testContainsChar() {
292 char[] array = null;
293 assertFalse(ArrayUtils.contains(array, 'b'));
294 array = new char[]{'a', 'b', 'c', 'd', 'a'};
295 assertTrue(ArrayUtils.contains(array, 'a'));
296 assertTrue(ArrayUtils.contains(array, 'b'));
297 assertTrue(ArrayUtils.contains(array, 'c'));
298 assertTrue(ArrayUtils.contains(array, 'd'));
299 assertFalse(ArrayUtils.contains(array, 'e'));
300 }
301
302 @Test
303 public void testContainsDouble() {
304 double[] array = null;
305 assertFalse(ArrayUtils.contains(array, 1));
306 array = new double[]{0, 1, 2, 3, 0};
307 assertTrue(ArrayUtils.contains(array, 0));
308 assertTrue(ArrayUtils.contains(array, 1));
309 assertTrue(ArrayUtils.contains(array, 2));
310 assertTrue(ArrayUtils.contains(array, 3));
311 assertFalse(ArrayUtils.contains(array, 99));
312 }
313
314 @Test
315 public void testContainsDoubleNaN() {
316 final double[] a = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY };
317 assertTrue(ArrayUtils.contains(a, Double.POSITIVE_INFINITY));
318 assertTrue(ArrayUtils.contains(a, Double.NEGATIVE_INFINITY));
319 assertTrue(ArrayUtils.contains(a, Double.NaN));
320 }
321
322 @Test
323 public void testContainsDoubleTolerance() {
324 double[] array = null;
325 assertFalse(ArrayUtils.contains(array, 1, 0));
326 array = new double[]{0, 1, 2, 3, 0};
327 assertFalse(ArrayUtils.contains(array, 4.0, 0.33));
328 assertFalse(ArrayUtils.contains(array, 2.5, 0.49));
329 assertTrue(ArrayUtils.contains(array, 2.5, 0.50));
330 assertTrue(ArrayUtils.contains(array, 2.5, 0.51));
331 }
332
333 @Test
334 public void testContainsFloat() {
335 float[] array = null;
336 assertFalse(ArrayUtils.contains(array, 1));
337 array = new float[]{0, 1, 2, 3, 0};
338 assertTrue(ArrayUtils.contains(array, 0));
339 assertTrue(ArrayUtils.contains(array, 1));
340 assertTrue(ArrayUtils.contains(array, 2));
341 assertTrue(ArrayUtils.contains(array, 3));
342 assertFalse(ArrayUtils.contains(array, 99));
343 }
344
345 @Test
346 public void testContainsFloatNaN() {
347 final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY };
348 assertTrue(ArrayUtils.contains(array, Float.POSITIVE_INFINITY));
349 assertTrue(ArrayUtils.contains(array, Float.NEGATIVE_INFINITY));
350 assertTrue(ArrayUtils.contains(array, Float.NaN));
351 }
352
353 @Test
354 public void testContainsInt() {
355 int[] array = null;
356 assertFalse(ArrayUtils.contains(array, 1));
357 array = new int[]{0, 1, 2, 3, 0};
358 assertTrue(ArrayUtils.contains(array, 0));
359 assertTrue(ArrayUtils.contains(array, 1));
360 assertTrue(ArrayUtils.contains(array, 2));
361 assertTrue(ArrayUtils.contains(array, 3));
362 assertFalse(ArrayUtils.contains(array, 99));
363 }
364
365 @Test
366 public void testContainsLong() {
367 long[] array = null;
368 assertFalse(ArrayUtils.contains(array, 1));
369 array = new long[]{0, 1, 2, 3, 0};
370 assertTrue(ArrayUtils.contains(array, 0));
371 assertTrue(ArrayUtils.contains(array, 1));
372 assertTrue(ArrayUtils.contains(array, 2));
373 assertTrue(ArrayUtils.contains(array, 3));
374 assertFalse(ArrayUtils.contains(array, 99));
375 }
376
377 @Test
378 public void testContainsShort() {
379 short[] array = null;
380 assertFalse(ArrayUtils.contains(array, (short) 1));
381 array = new short[]{0, 1, 2, 3, 0};
382 assertTrue(ArrayUtils.contains(array, (short) 0));
383 assertTrue(ArrayUtils.contains(array, (short) 1));
384 assertTrue(ArrayUtils.contains(array, (short) 2));
385 assertTrue(ArrayUtils.contains(array, (short) 3));
386 assertFalse(ArrayUtils.contains(array, (short) 99));
387 }
388
389 @Test
390 public void testCreatePrimitiveArray() {
391 assertNull(ArrayUtils.toPrimitive((Object[]) null));
392 assertArrayEquals(new boolean[]{true}, ArrayUtils.toPrimitive(new Boolean[]{true}));
393 assertArrayEquals(new char[]{'a'}, ArrayUtils.toPrimitive(new Character[]{'a'}));
394 assertArrayEquals(new byte[]{1}, ArrayUtils.toPrimitive(new Byte[]{1}));
395 assertArrayEquals(new int[]{}, ArrayUtils.toPrimitive(new Integer[]{}));
396 assertArrayEquals(new short[]{2}, ArrayUtils.toPrimitive(new Short[]{2}));
397 assertArrayEquals(new long[]{2, 3}, ArrayUtils.toPrimitive(new Long[]{2L, 3L}));
398 assertArrayEquals(new float[]{3.14f}, ArrayUtils.toPrimitive(new Float[]{3.14f}), 0.1f);
399 assertArrayEquals(new double[]{2.718}, ArrayUtils.toPrimitive(new Double[]{2.718}), 0.1);
400 }
401
402 @Test
403 public void testCreatePrimitiveArrayViaObjectArray() {
404 assertNull(ArrayUtils.toPrimitive((Object) null));
405 assertArrayEquals(new boolean[]{true}, (boolean[]) ArrayUtils.toPrimitive((Object) new Boolean[]{true}));
406 assertArrayEquals(new char[]{'a'}, (char[]) ArrayUtils.toPrimitive((Object) new Character[]{'a'}));
407 assertArrayEquals(new byte[]{1}, (byte[]) ArrayUtils.toPrimitive((Object) new Byte[]{1}));
408 assertArrayEquals(new int[]{}, (int[]) ArrayUtils.toPrimitive((Object) new Integer[]{}));
409 assertArrayEquals(new short[]{2}, (short[]) ArrayUtils.toPrimitive((Object) new Short[]{2}));
410 assertArrayEquals(new long[]{2, 3}, (long[]) ArrayUtils.toPrimitive((Object) new Long[]{2L, 3L}));
411 assertArrayEquals(new float[]{3.14f}, (float[]) ArrayUtils.toPrimitive((Object) new Float[]{3.14f}), 0.1f);
412 assertArrayEquals(new double[]{2.718}, (double[]) ArrayUtils.toPrimitive((Object) new Double[]{2.718}), 0.1);
413 }
414
415
416
417
418 @Test
419 public void testEmptyArrayCreation() {
420 final String[] array = ArrayUtils.<String>toArray();
421 assertEquals(0, array.length);
422 }
423
424 @Test
425 public void testGet() {
426 assertNull(ArrayUtils.get(null, -1));
427 assertNull(ArrayUtils.get(null, 0));
428 assertNull(ArrayUtils.get(null, 1));
429 final String[] array0 = {};
430 assertNull(ArrayUtils.get(array0, -1));
431 assertNull(ArrayUtils.get(array0, 0));
432 assertNull(ArrayUtils.get(array0, 1));
433 final String[] array1 = { StringUtils.EMPTY };
434 assertNull(ArrayUtils.get(array1, -1));
435 assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0));
436 assertNull(ArrayUtils.get(array1, 1));
437 }
438
439 @Test
440 public void testGetComponentType() {
441 final TestClass[] newArray = {};
442
443 final Class<TestClass> componentType = ArrayUtils.getComponentType(newArray);
444 assertEquals(TestClass.class, componentType);
445 assertNull(ArrayUtils.getComponentType(null));
446 }
447
448 @Test
449 public void testGetDefault() {
450
451 {
452 assertNull(ArrayUtils.get(null, -1, null));
453 assertNull(ArrayUtils.get(null, 0, null));
454 assertNull(ArrayUtils.get(null, 1, null));
455 final String[] array0 = {};
456 assertNull(ArrayUtils.get(array0, -1, null));
457 assertNull(ArrayUtils.get(array0, 0, null));
458 assertNull(ArrayUtils.get(array0, 1, null));
459 final String[] array1 = { StringUtils.EMPTY };
460 assertNull(ArrayUtils.get(array1, -1, null));
461 assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0, null));
462 assertNull(ArrayUtils.get(array1, 1, null));
463 }
464
465 {
466 final String defaultValue = "defaultValue";
467 final String[] array1 = { StringUtils.EMPTY };
468 assertEquals(defaultValue, ArrayUtils.get(array1, -1, defaultValue));
469 assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0, defaultValue));
470 assertEquals(defaultValue, ArrayUtils.get(array1, 1, defaultValue));
471 }
472 }
473
474 @Test
475 public void testGetLength() {
476 assertEquals(0, ArrayUtils.getLength(null));
477
478 final Object[] emptyObjectArray = {};
479 final Object[] notEmptyObjectArray = {"aValue"};
480 assertEquals(0, ArrayUtils.getLength(null));
481 assertEquals(0, ArrayUtils.getLength(emptyObjectArray));
482 assertEquals(1, ArrayUtils.getLength(notEmptyObjectArray));
483
484 final int[] emptyIntArray = {};
485 final int[] notEmptyIntArray = {1};
486 assertEquals(0, ArrayUtils.getLength(null));
487 assertEquals(0, ArrayUtils.getLength(emptyIntArray));
488 assertEquals(1, ArrayUtils.getLength(notEmptyIntArray));
489
490 final short[] emptyShortArray = {};
491 final short[] notEmptyShortArray = {1};
492 assertEquals(0, ArrayUtils.getLength(null));
493 assertEquals(0, ArrayUtils.getLength(emptyShortArray));
494 assertEquals(1, ArrayUtils.getLength(notEmptyShortArray));
495
496 final char[] emptyCharArray = {};
497 final char[] notEmptyCharArray = {1};
498 assertEquals(0, ArrayUtils.getLength(null));
499 assertEquals(0, ArrayUtils.getLength(emptyCharArray));
500 assertEquals(1, ArrayUtils.getLength(notEmptyCharArray));
501
502 final byte[] emptyByteArray = {};
503 final byte[] notEmptyByteArray = {1};
504 assertEquals(0, ArrayUtils.getLength(null));
505 assertEquals(0, ArrayUtils.getLength(emptyByteArray));
506 assertEquals(1, ArrayUtils.getLength(notEmptyByteArray));
507
508 final double[] emptyDoubleArray = {};
509 final double[] notEmptyDoubleArray = {1.0};
510 assertEquals(0, ArrayUtils.getLength(null));
511 assertEquals(0, ArrayUtils.getLength(emptyDoubleArray));
512 assertEquals(1, ArrayUtils.getLength(notEmptyDoubleArray));
513
514 final float[] emptyFloatArray = {};
515 final float[] notEmptyFloatArray = {1.0F};
516 assertEquals(0, ArrayUtils.getLength(null));
517 assertEquals(0, ArrayUtils.getLength(emptyFloatArray));
518 assertEquals(1, ArrayUtils.getLength(notEmptyFloatArray));
519
520 final boolean[] emptyBooleanArray = {};
521 final boolean[] notEmptyBooleanArray = {true};
522 assertEquals(0, ArrayUtils.getLength(null));
523 assertEquals(0, ArrayUtils.getLength(emptyBooleanArray));
524 assertEquals(1, ArrayUtils.getLength(notEmptyBooleanArray));
525
526 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.getLength("notAnArray"));
527 }
528
529 @Test
530 public void testHashCode() {
531 final long[][] array1 = {{2, 5}, {4, 5}};
532 final long[][] array2 = {{2, 5}, {4, 6}};
533 assertEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array1));
534 assertNotEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array2));
535
536 final Object[] array3 = {new String(new char[]{'A', 'B'})};
537 final Object[] array4 = {"AB"};
538 assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array3));
539 assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array4));
540
541 final Object[] arrayA = {new boolean[]{true, false}, new int[]{6, 7}};
542 final Object[] arrayB = {new boolean[]{true, false}, new int[]{6, 7}};
543 assertEquals(ArrayUtils.hashCode(arrayB), ArrayUtils.hashCode(arrayA));
544 }
545
546 @Test
547 public void testIndexesOf() {
548 final Object[] array = {"0", "1", "2", "3", null, "0"};
549 final BitSet emptySet = new BitSet();
550 final BitSet testSet = new BitSet();
551 assertEquals(emptySet, ArrayUtils.indexesOf((Object[]) null, null));
552 assertEquals(emptySet, ArrayUtils.indexesOf(new Object[0], "0"));
553 testSet.set(5);
554 testSet.set(0);
555 assertEquals(testSet, ArrayUtils.indexesOf(array, "0"));
556 testSet.clear();
557 testSet.set(2);
558 assertEquals(testSet, ArrayUtils.indexesOf(array, "2"));
559 testSet.clear();
560 testSet.set(3);
561 assertEquals(testSet, ArrayUtils.indexesOf(array, "3"));
562 testSet.clear();
563 testSet.set(4);
564 assertEquals(testSet, ArrayUtils.indexesOf(array, null));
565 assertEquals(emptySet, ArrayUtils.indexesOf(array, "notInArray"));
566 }
567
568 @Test
569 public void testIndexesOfBoolean() {
570 boolean[] array = null;
571 final BitSet emptySet = new BitSet();
572 final BitSet testSet = new BitSet();
573 assertEquals(emptySet, ArrayUtils.indexesOf(array, true));
574 array = new boolean[0];
575 assertEquals(emptySet, ArrayUtils.indexesOf(array, true));
576 array = new boolean[]{true, false, true};
577 testSet.set(0);
578 testSet.set(2);
579 assertEquals(testSet, ArrayUtils.indexesOf(array, true));
580 testSet.clear();
581 testSet.set(1);
582 assertEquals(testSet, ArrayUtils.indexesOf(array, false));
583 array = new boolean[]{true, true};
584 assertEquals(emptySet, ArrayUtils.indexesOf(array, false));
585 }
586
587 @Test
588 public void testIndexesOfBooleanWithStartIndex() {
589 boolean[] array = null;
590 final BitSet emptySet = new BitSet();
591 final BitSet testSet = new BitSet();
592 assertEquals(emptySet, ArrayUtils.indexesOf(array, true, 0));
593 array = new boolean[0];
594 assertEquals(emptySet, ArrayUtils.indexesOf(array, true, 0));
595 array = new boolean[]{true, false, true};
596 testSet.set(2);
597 assertEquals(testSet, ArrayUtils.indexesOf(array, true, 1));
598 testSet.set(0);
599 assertEquals(testSet, ArrayUtils.indexesOf(array, true, 0));
600 testSet.clear();
601 testSet.set(1);
602 assertEquals(testSet, ArrayUtils.indexesOf(array, false, 1));
603 array = new boolean[]{true, true};
604 assertEquals(emptySet, ArrayUtils.indexesOf(array, false, 0));
605 assertEquals(emptySet, ArrayUtils.indexesOf(array, false, -1));
606 }
607
608 @Test
609 public void testIndexesOfByte() {
610 byte[] array = null;
611 final BitSet emptySet = new BitSet();
612 final BitSet testSet = new BitSet();
613 assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 0));
614 array = new byte[]{0, 1, 2, 3, 0};
615 testSet.set(0);
616 testSet.set(4);
617 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0));
618 testSet.clear();
619 testSet.set(1);
620 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 1));
621 testSet.clear();
622 testSet.set(2);
623 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 2));
624 testSet.clear();
625 testSet.set(3);
626 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3));
627 assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 99));
628 }
629
630 @Test
631 public void testIndexesOfByteWithStartIndex() {
632 byte[] array = null;
633 final BitSet emptySet = new BitSet();
634 final BitSet testSet = new BitSet();
635 assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 0, 2));
636 array = new byte[]{0, 1, 2, 3, 0};
637 testSet.set(4);
638 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0, 2));
639 testSet.set(0);
640 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0, 0));
641 testSet.clear();
642 testSet.set(1);
643 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 1, 1));
644 testSet.clear();
645 testSet.set(2);
646 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 2, 0));
647 testSet.clear();
648 testSet.set(3);
649 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3, 0));
650 assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3, -1));
651 assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 99, 0));
652 }
653
654 @Test
655 public void testIndexesOfChar() {
656 char[] array = null;
657 final BitSet emptySet = new BitSet();
658 final BitSet testSet = new BitSet();
659 assertEquals(emptySet, ArrayUtils.indexesOf(array, 'a'));
660 array = new char[]{'a', 'b', 'c', 'd', 'a'};
661 testSet.set(0);
662 testSet.set(4);
663 assertEquals(testSet, ArrayUtils.indexesOf(array, 'a'));
664 testSet.clear();
665 testSet.set(1);
666 assertEquals(testSet, ArrayUtils.indexesOf(array, 'b'));
667 testSet.clear();
668 testSet.set(2);
669 assertEquals(testSet, ArrayUtils.indexesOf(array, 'c'));
670 testSet.clear();
671 testSet.set(3);
672 assertEquals(testSet, ArrayUtils.indexesOf(array, 'd'));
673 assertEquals(emptySet, ArrayUtils.indexesOf(array, 'e'));
674 }
675
676 @Test
677 public void testIndexesOfCharWithStartIndex() {
678 char[] array = null;
679 final BitSet emptySet = new BitSet();
680 final BitSet testSet = new BitSet();
681 assertEquals(emptySet, ArrayUtils.indexesOf(array, 'a', 0));
682 array = new char[]{'a', 'b', 'c', 'd', 'a'};
683 testSet.set(4);
684 assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', 2));
685 testSet.set(0);
686 assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', 0));
687 assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', -1));
688 testSet.clear();
689 testSet.set(1);
690 assertEquals(testSet, ArrayUtils.indexesOf(array, 'b', 1));
691 testSet.clear();
692 testSet.set(2);
693 assertEquals(testSet, ArrayUtils.indexesOf(array, 'c', 0));
694 testSet.clear();
695 testSet.set(3);
696 assertEquals(testSet, ArrayUtils.indexesOf(array, 'd', 0));
697 assertEquals(emptySet, ArrayUtils.indexesOf(array, 'd', 5));
698 assertEquals(emptySet, ArrayUtils.indexesOf(array, 'e', 0));
699 }
700
701 @Test
702 public void testIndexesOfDouble() {
703 double[] array = null;
704 final BitSet emptySet = new BitSet();
705 final BitSet testSet = new BitSet();
706 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0));
707 array = new double[]{0, 1, 2, 3, 0};
708 testSet.set(0);
709 testSet.set(4);
710 assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
711 testSet.clear();
712 testSet.set(1);
713 assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
714 testSet.clear();
715 testSet.set(2);
716 assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
717 testSet.clear();
718 testSet.set(3);
719 assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
720 assertEquals(emptySet, ArrayUtils.indexesOf(array, 99));
721 }
722
723 @Test
724 public void testIndexesOfDoubleTolerance() {
725 double[] array = null;
726 final BitSet emptySet = new BitSet();
727 final BitSet testSet = new BitSet();
728 assertEquals(emptySet, ArrayUtils.indexesOf(array, (double) 0, (double) 0));
729 array = new double[0];
730 assertEquals(emptySet, ArrayUtils.indexesOf(array, (double) 0, (double) 0));
731 array = new double[]{0, 1, 2, 3, 0};
732 testSet.set(0);
733 testSet.set(4);
734 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0.3));
735 testSet.clear();
736 testSet.set(3);
737 assertEquals(testSet, ArrayUtils.indexesOf(array, 4.15, 2.0));
738 testSet.clear();
739 testSet.set(1);
740 assertEquals(testSet, ArrayUtils.indexesOf(array, 1.00001324, 0.0001));
741 }
742
743 @Test
744 public void testIndexesOfDoubleWithStartIndex() {
745 double[] array = null;
746 final BitSet emptySet = new BitSet();
747 final BitSet testSet = new BitSet();
748 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2));
749 array = new double[]{0, 1, 2, 3, 0};
750 testSet.set(4);
751 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2));
752 testSet.set(0);
753 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0));
754 testSet.clear();
755 testSet.set(1);
756 assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1));
757 testSet.clear();
758 testSet.set(2);
759 assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0));
760 testSet.clear();
761 testSet.set(3);
762 assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0));
763 assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1));
764 assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0));
765 }
766
767 @Test
768 public void testIndexesOfDoubleWithStartIndexTolerance() {
769 double[] array = null;
770 final BitSet emptySet = new BitSet();
771 final BitSet testSet = new BitSet();
772 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 0, 0));
773 array = new double[0];
774 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 0, 0));
775 array = new double[]{0, 1, 2, 3, 0};
776 testSet.set(4);
777 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 1, 0.3));
778 testSet.set(0);
779 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0, 0.3));
780 testSet.clear();
781 testSet.set(2);
782 assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0, 0.35));
783 assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 2, 0.35));
784 assertEquals(testSet, ArrayUtils.indexesOf(array, 2, -1, 0.35));
785 assertEquals(emptySet, ArrayUtils.indexesOf(array, 2, 3, 0.35));
786 testSet.clear();
787 testSet.set(3);
788 assertEquals(testSet, ArrayUtils.indexesOf(array, 4.15, 0, 2.0));
789 testSet.clear();
790 testSet.set(1);
791 assertEquals(testSet, ArrayUtils.indexesOf(array, 1.00001324, 0, 0.0001));
792 }
793
794 @Test
795 public void testIndexesOfFloat() {
796 float[] array = null;
797 final BitSet emptySet = new BitSet();
798 final BitSet testSet = new BitSet();
799 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0));
800 array = new float[]{0, 1, 2, 3, 0};
801 testSet.set(0);
802 testSet.set(4);
803 assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
804 testSet.clear();
805 testSet.set(1);
806 assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
807 testSet.clear();
808 testSet.set(2);
809 assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
810 testSet.clear();
811 testSet.set(3);
812 assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
813 assertEquals(emptySet, ArrayUtils.indexesOf(array, 99));
814 }
815
816 @Test
817 public void testIndexesOfFloatWithStartIndex() {
818 float[] array = null;
819 final BitSet emptySet = new BitSet();
820 final BitSet testSet = new BitSet();
821 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2));
822 array = new float[]{0, 1, 2, 3, 0};
823 testSet.set(4);
824 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2));
825 testSet.set(0);
826 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0));
827 testSet.clear();
828 testSet.set(1);
829 assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1));
830 testSet.clear();
831 testSet.set(2);
832 assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0));
833 testSet.clear();
834 testSet.set(3);
835 assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0));
836 assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1));
837 assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0));
838 }
839
840 @Test
841 public void testIndexesOfIntWithStartIndex() {
842 int[] array = null;
843 final BitSet emptySet = new BitSet();
844 final BitSet testSet = new BitSet();
845 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2));
846 array = new int[]{0, 1, 2, 3, 0};
847 testSet.set(4);
848 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2));
849 testSet.set(0);
850 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0));
851 testSet.clear();
852 testSet.set(1);
853 assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1));
854 testSet.clear();
855 testSet.set(2);
856 assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0));
857 testSet.clear();
858 testSet.set(3);
859 assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0));
860 assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1));
861 assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0));
862 }
863
864 @Test
865 public void testIndexesOfLong() {
866 final long[] array = {0, 1, 2, 3};
867 final BitSet emptySet = new BitSet();
868 final BitSet testSet = new BitSet();
869 assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0));
870 assertEquals(emptySet, ArrayUtils.indexesOf(array, 4));
871 testSet.set(0);
872 assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
873 testSet.clear();
874 testSet.set(1);
875 assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
876 testSet.clear();
877 testSet.set(2);
878 assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
879 testSet.clear();
880 testSet.set(3);
881 assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
882 }
883
884 @Test
885 public void testIndexesOfLongWithStartIndex() {
886 final long[] array = {0, 1, 2, 3, 2, 1, 0, 1};
887 final BitSet emptySet = new BitSet();
888 final BitSet testSet = new BitSet();
889 assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0, 0));
890 assertEquals(emptySet, ArrayUtils.indexesOf(array, 4, 0));
891 testSet.set(6);
892 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 1));
893 testSet.set(0);
894 assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0));
895 testSet.clear();
896 testSet.set(1);
897 testSet.set(5);
898 testSet.set(7);
899 assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 0));
900 testSet.clear();
901 testSet.set(2);
902 testSet.set(4);
903 assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0));
904 testSet.clear();
905 testSet.set(3);
906 assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0));
907 assertEquals(emptySet, ArrayUtils.indexesOf(array, 3, 8));
908 }
909
910 @Test
911 public void testIndexesOfShort() {
912 short[] array = null;
913 final BitSet emptySet = new BitSet();
914 final BitSet testSet = new BitSet();
915 assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 0));
916 array = new short[]{0, 1, 2, 3, 0};
917 testSet.set(0);
918 testSet.set(4);
919 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0));
920 testSet.clear();
921 testSet.set(1);
922 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 1));
923 testSet.clear();
924 testSet.set(2);
925 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 2));
926 testSet.clear();
927 testSet.set(3);
928 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3));
929 assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 99));
930 }
931
932 @Test
933 public void testIndexesOfShortWithStartIndex() {
934 short[] array = null;
935 final BitSet emptySet = new BitSet();
936 final BitSet testSet = new BitSet();
937 assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 0, 2));
938 array = new short[]{0, 1, 2, 3, 0};
939 testSet.set(4);
940 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0, 2));
941 testSet.set(0);
942 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0, 0));
943 testSet.clear();
944 testSet.set(1);
945 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 1, 1));
946 testSet.clear();
947 testSet.set(2);
948 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 2, 0));
949 testSet.clear();
950 testSet.set(3);
951 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3, 0));
952 assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3, -1));
953 assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 99, 0));
954 }
955
956 @Test
957 public void testIndexesOfWithStartIndex() {
958 final Object[] array = {"0", "1", "2", "3", "2", "3", "1", null, "0"};
959 final BitSet emptySet = new BitSet();
960 final BitSet testSet = new BitSet();
961 assertEquals(emptySet, ArrayUtils.indexesOf(null, null, 2));
962 assertEquals(emptySet, ArrayUtils.indexesOf(new Object[0], "0", 0));
963 assertEquals(emptySet, ArrayUtils.indexesOf(null, "0", 2));
964 testSet.set(8);
965 assertEquals(testSet, ArrayUtils.indexesOf(array, "0", 8));
966 testSet.set(0);
967 assertEquals(testSet, ArrayUtils.indexesOf(array, "0", 0));
968 testSet.clear();
969 testSet.set(6);
970 testSet.set(1);
971 assertEquals(testSet, ArrayUtils.indexesOf(array, "1", 0));
972 assertEquals(emptySet, ArrayUtils.indexesOf(array, "1", 9));
973 testSet.clear();
974 testSet.set(4);
975 assertEquals(testSet, ArrayUtils.indexesOf(array, "2", 3));
976 testSet.set(2);
977 assertEquals(testSet, ArrayUtils.indexesOf(array, "2", 0));
978 testSet.clear();
979 testSet.set(3);
980 testSet.set(5);
981 assertEquals(testSet, ArrayUtils.indexesOf(array, "3", 0));
982 testSet.clear();
983 testSet.set(7);
984 assertEquals(testSet, ArrayUtils.indexesOf(array, null, 0));
985
986 }
987
988 @Test
989 public void testIndexOf() {
990 final Object[] array = {"0", "1", "2", "3", null, "0"};
991 assertEquals(-1, ArrayUtils.indexOf(null, null));
992 assertEquals(-1, ArrayUtils.indexOf(null, "0"));
993 assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0"));
994 assertEquals(0, ArrayUtils.indexOf(array, "0"));
995 assertEquals(1, ArrayUtils.indexOf(array, "1"));
996 assertEquals(2, ArrayUtils.indexOf(array, "2"));
997 assertEquals(3, ArrayUtils.indexOf(array, "3"));
998 assertEquals(4, ArrayUtils.indexOf(array, null));
999 assertEquals(-1, ArrayUtils.indexOf(array, "notInArray"));
1000 }
1001
1002 @Test
1003 public void testIndexOfBoolean() {
1004 boolean[] array = null;
1005 assertEquals(-1, ArrayUtils.indexOf(array, true));
1006 array = new boolean[0];
1007 assertEquals(-1, ArrayUtils.indexOf(array, true));
1008 array = new boolean[]{true, false, true};
1009 assertEquals(0, ArrayUtils.indexOf(array, true));
1010 assertEquals(1, ArrayUtils.indexOf(array, false));
1011 array = new boolean[]{true, true};
1012 assertEquals(-1, ArrayUtils.indexOf(array, false));
1013 }
1014
1015 @Test
1016 public void testIndexOfBooleanWithStartIndex() {
1017 boolean[] array = null;
1018 assertEquals(-1, ArrayUtils.indexOf(array, true, 2));
1019 array = new boolean[0];
1020 assertEquals(-1, ArrayUtils.indexOf(array, true, 2));
1021 array = new boolean[]{true, false, true};
1022 assertEquals(2, ArrayUtils.indexOf(array, true, 1));
1023 assertEquals(-1, ArrayUtils.indexOf(array, false, 2));
1024 assertEquals(1, ArrayUtils.indexOf(array, false, 0));
1025 assertEquals(1, ArrayUtils.indexOf(array, false, -1));
1026 array = new boolean[]{true, true};
1027 assertEquals(-1, ArrayUtils.indexOf(array, false, 0));
1028 assertEquals(-1, ArrayUtils.indexOf(array, false, -1));
1029 }
1030
1031 @Test
1032 public void testIndexOfByte() {
1033 byte[] array = null;
1034 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0));
1035 array = new byte[]{0, 1, 2, 3, 0};
1036 assertEquals(0, ArrayUtils.indexOf(array, (byte) 0));
1037 assertEquals(1, ArrayUtils.indexOf(array, (byte) 1));
1038 assertEquals(2, ArrayUtils.indexOf(array, (byte) 2));
1039 assertEquals(3, ArrayUtils.indexOf(array, (byte) 3));
1040 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99));
1041 }
1042
1043 @Test
1044 public void testIndexOfByteWithStartIndex() {
1045 byte[] array = null;
1046 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 2));
1047 array = new byte[]{0, 1, 2, 3, 0};
1048 assertEquals(4, ArrayUtils.indexOf(array, (byte) 0, 2));
1049 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 1, 2));
1050 assertEquals(2, ArrayUtils.indexOf(array, (byte) 2, 2));
1051 assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, 2));
1052 assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, -1));
1053 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99, 0));
1054 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 6));
1055 }
1056
1057 @Test
1058 public void testIndexOfChar() {
1059 char[] array = null;
1060 assertEquals(-1, ArrayUtils.indexOf(array, 'a'));
1061 array = new char[]{'a', 'b', 'c', 'd', 'a'};
1062 assertEquals(0, ArrayUtils.indexOf(array, 'a'));
1063 assertEquals(1, ArrayUtils.indexOf(array, 'b'));
1064 assertEquals(2, ArrayUtils.indexOf(array, 'c'));
1065 assertEquals(3, ArrayUtils.indexOf(array, 'd'));
1066 assertEquals(-1, ArrayUtils.indexOf(array, 'e'));
1067 }
1068
1069 @Test
1070 public void testIndexOfCharWithStartIndex() {
1071 char[] array = null;
1072 assertEquals(-1, ArrayUtils.indexOf(array, 'a', 2));
1073 array = new char[]{'a', 'b', 'c', 'd', 'a'};
1074 assertEquals(4, ArrayUtils.indexOf(array, 'a', 2));
1075 assertEquals(-1, ArrayUtils.indexOf(array, 'b', 2));
1076 assertEquals(2, ArrayUtils.indexOf(array, 'c', 2));
1077 assertEquals(3, ArrayUtils.indexOf(array, 'd', 2));
1078 assertEquals(3, ArrayUtils.indexOf(array, 'd', -1));
1079 assertEquals(-1, ArrayUtils.indexOf(array, 'e', 0));
1080 assertEquals(-1, ArrayUtils.indexOf(array, 'a', 6));
1081 }
1082
1083 @Test
1084 public void testIndexOfDouble() {
1085 double[] array = null;
1086 assertEquals(-1, ArrayUtils.indexOf(array, 0));
1087 array = new double[0];
1088 assertEquals(-1, ArrayUtils.indexOf(array, 0));
1089 array = new double[]{0, 1, 2, 3, 0};
1090 assertEquals(0, ArrayUtils.indexOf(array, 0));
1091 assertEquals(1, ArrayUtils.indexOf(array, 1));
1092 assertEquals(2, ArrayUtils.indexOf(array, 2));
1093 assertEquals(3, ArrayUtils.indexOf(array, 3));
1094 assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
1095 assertEquals(-1, ArrayUtils.indexOf(array, 99));
1096 }
1097
1098 @Test
1099 public void testIndexOfDoubleNaN() {
1100 final double[] array = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY, Double.NaN };
1101 assertEquals(0, ArrayUtils.indexOf(array, Double.NEGATIVE_INFINITY));
1102 assertEquals(1, ArrayUtils.indexOf(array, Double.NaN));
1103 assertEquals(2, ArrayUtils.indexOf(array, Double.POSITIVE_INFINITY));
1104
1105 }
1106
1107 @Test
1108 public void testIndexOfDoubleTolerance() {
1109 double[] array = null;
1110 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0));
1111 array = new double[0];
1112 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0));
1113 array = new double[]{0, 1, 2, 3, 0};
1114 assertEquals(0, ArrayUtils.indexOf(array, 0, 0.3));
1115 assertEquals(2, ArrayUtils.indexOf(array, 2.2, 0.35));
1116 assertEquals(3, ArrayUtils.indexOf(array, 4.15, 2.0));
1117 assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, 0.0001));
1118 }
1119
1120 @Test
1121 public void testIndexOfDoubleWithStartIndex() {
1122 double[] array = null;
1123 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
1124 array = new double[0];
1125 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
1126 array = new double[]{0, 1, 2, 3, 0};
1127 assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
1128 assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
1129 assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
1130 assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
1131 assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
1132 assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
1133 }
1134
1135 @Test
1136 public void testIndexOfDoubleWithStartIndexTolerance() {
1137 double[] array = null;
1138 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2, 0));
1139 array = new double[0];
1140 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2, 0));
1141 array = new double[]{0, 1, 2, 3, 0};
1142 assertEquals(-1, ArrayUtils.indexOf(array, 0, 99, 0.3));
1143 assertEquals(0, ArrayUtils.indexOf(array, 0, 0, 0.3));
1144 assertEquals(4, ArrayUtils.indexOf(array, 0, 3, 0.3));
1145 assertEquals(2, ArrayUtils.indexOf(array, 2.2, 0, 0.35));
1146 assertEquals(3, ArrayUtils.indexOf(array, 4.15, 0, 2.0));
1147 assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, 0, 0.0001));
1148 assertEquals(3, ArrayUtils.indexOf(array, 4.15, -1, 2.0));
1149 assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, -300, 0.0001));
1150 }
1151
1152 @Test
1153 public void testIndexOfFloat() {
1154 float[] array = null;
1155 assertEquals(-1, ArrayUtils.indexOf(array, 0));
1156 array = new float[0];
1157 assertEquals(-1, ArrayUtils.indexOf(array, 0));
1158 array = new float[]{0, 1, 2, 3, 0};
1159 assertEquals(0, ArrayUtils.indexOf(array, 0));
1160 assertEquals(1, ArrayUtils.indexOf(array, 1));
1161 assertEquals(2, ArrayUtils.indexOf(array, 2));
1162 assertEquals(3, ArrayUtils.indexOf(array, 3));
1163 assertEquals(-1, ArrayUtils.indexOf(array, 99));
1164 }
1165
1166 @Test
1167 public void testIndexOfFloatNaN() {
1168 final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY, Float.NaN };
1169 assertEquals(0, ArrayUtils.indexOf(array, Float.NEGATIVE_INFINITY));
1170 assertEquals(1, ArrayUtils.indexOf(array, Float.NaN));
1171 assertEquals(2, ArrayUtils.indexOf(array, Float.POSITIVE_INFINITY));
1172 }
1173
1174 @Test
1175 public void testIndexOfFloatWithStartIndex() {
1176 float[] array = null;
1177 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
1178 array = new float[0];
1179 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
1180 array = new float[]{0, 1, 2, 3, 0};
1181 assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
1182 assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
1183 assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
1184 assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
1185 assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
1186 assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
1187 assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
1188 }
1189
1190 @Test
1191 public void testIndexOfInt() {
1192 int[] array = null;
1193 assertEquals(-1, ArrayUtils.indexOf(array, 0));
1194 array = new int[]{0, 1, 2, 3, 0};
1195 assertEquals(0, ArrayUtils.indexOf(array, 0));
1196 assertEquals(1, ArrayUtils.indexOf(array, 1));
1197 assertEquals(2, ArrayUtils.indexOf(array, 2));
1198 assertEquals(3, ArrayUtils.indexOf(array, 3));
1199 assertEquals(-1, ArrayUtils.indexOf(array, 99));
1200 }
1201
1202 @Test
1203 public void testIndexOfIntWithStartIndex() {
1204 int[] array = null;
1205 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
1206 array = new int[]{0, 1, 2, 3, 0};
1207 assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
1208 assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
1209 assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
1210 assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
1211 assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
1212 assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
1213 assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
1214 }
1215
1216 @Test
1217 public void testIndexOfLong() {
1218 long[] array = null;
1219 assertEquals(-1, ArrayUtils.indexOf(array, 0));
1220 array = new long[]{0, 1, 2, 3, 0};
1221 assertEquals(0, ArrayUtils.indexOf(array, 0));
1222 assertEquals(1, ArrayUtils.indexOf(array, 1));
1223 assertEquals(2, ArrayUtils.indexOf(array, 2));
1224 assertEquals(3, ArrayUtils.indexOf(array, 3));
1225 assertEquals(-1, ArrayUtils.indexOf(array, 99));
1226 }
1227
1228 @Test
1229 public void testIndexOfLongWithStartIndex() {
1230 long[] array = null;
1231 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
1232 array = new long[]{0, 1, 2, 3, 0};
1233 assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
1234 assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
1235 assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
1236 assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
1237 assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
1238 assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
1239 assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
1240 }
1241
1242 @Test
1243 public void testIndexOfShort() {
1244 short[] array = null;
1245 assertEquals(-1, ArrayUtils.indexOf(array, (short) 0));
1246 array = new short[]{0, 1, 2, 3, 0};
1247 assertEquals(0, ArrayUtils.indexOf(array, (short) 0));
1248 assertEquals(1, ArrayUtils.indexOf(array, (short) 1));
1249 assertEquals(2, ArrayUtils.indexOf(array, (short) 2));
1250 assertEquals(3, ArrayUtils.indexOf(array, (short) 3));
1251 assertEquals(-1, ArrayUtils.indexOf(array, (short) 99));
1252 }
1253
1254 @Test
1255 public void testIndexOfShortWithStartIndex() {
1256 short[] array = null;
1257 assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 2));
1258 array = new short[]{0, 1, 2, 3, 0};
1259 assertEquals(4, ArrayUtils.indexOf(array, (short) 0, 2));
1260 assertEquals(-1, ArrayUtils.indexOf(array, (short) 1, 2));
1261 assertEquals(2, ArrayUtils.indexOf(array, (short) 2, 2));
1262 assertEquals(3, ArrayUtils.indexOf(array, (short) 3, 2));
1263 assertEquals(3, ArrayUtils.indexOf(array, (short) 3, -1));
1264 assertEquals(-1, ArrayUtils.indexOf(array, (short) 99, 0));
1265 assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 6));
1266 }
1267
1268 @Test
1269 public void testIndexOfWithStartIndex() {
1270 final Object[] array = {"0", "1", "2", "3", null, "0"};
1271 assertEquals(-1, ArrayUtils.indexOf(null, null, 2));
1272 assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0", 0));
1273 assertEquals(-1, ArrayUtils.indexOf(null, "0", 2));
1274 assertEquals(5, ArrayUtils.indexOf(array, "0", 2));
1275 assertEquals(-1, ArrayUtils.indexOf(array, "1", 2));
1276 assertEquals(2, ArrayUtils.indexOf(array, "2", 2));
1277 assertEquals(3, ArrayUtils.indexOf(array, "3", 2));
1278 assertEquals(4, ArrayUtils.indexOf(array, null, 2));
1279 assertEquals(-1, ArrayUtils.indexOf(array, "notInArray", 2));
1280
1281 assertEquals(4, ArrayUtils.indexOf(array, null, -1));
1282 assertEquals(-1, ArrayUtils.indexOf(array, null, 8));
1283 assertEquals(-1, ArrayUtils.indexOf(array, "0", 8));
1284 }
1285
1286
1287
1288
1289 @Test
1290 public void testIndirectArrayCreation() {
1291 final String[] array = toArrayPropagatingType("foo", "bar");
1292 assertEquals(2, array.length);
1293 assertEquals("foo", array[0]);
1294 assertEquals("bar", array[1]);
1295 }
1296
1297
1298
1299
1300 @Test
1301 public void testIndirectEmptyArrayCreation() {
1302 final String[] array = ArrayUtilsTest.<String>toArrayPropagatingType();
1303 assertEquals(0, array.length);
1304 }
1305
1306 @Test
1307 public void testIsArrayIndexValid() {
1308 assertFalse(ArrayUtils.isArrayIndexValid(null, 0));
1309 final String[] array = new String[1];
1310
1311
1312 assertFalse(ArrayUtils.isArrayIndexValid(array, 1));
1313
1314
1315 assertFalse(ArrayUtils.isArrayIndexValid(array, -1));
1316
1317
1318 assertTrue(ArrayUtils.isArrayIndexValid(array, 0));
1319 }
1320
1321
1322
1323
1324 @Test
1325 public void testIsEmptyObject() {
1326 final Object[] emptyArray = {};
1327 final Object[] notEmptyArray = {"Value"};
1328 assertTrue(ArrayUtils.isEmpty((Object[]) null));
1329 assertTrue(ArrayUtils.isEmpty(emptyArray));
1330 assertFalse(ArrayUtils.isEmpty(notEmptyArray));
1331 }
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343 @Test
1344 public void testIsEmptyPrimitives() {
1345 final long[] emptyLongArray = {};
1346 final long[] notEmptyLongArray = {1L};
1347 assertTrue(ArrayUtils.isEmpty((long[]) null));
1348 assertTrue(ArrayUtils.isEmpty(emptyLongArray));
1349 assertFalse(ArrayUtils.isEmpty(notEmptyLongArray));
1350
1351 final int[] emptyIntArray = {};
1352 final int[] notEmptyIntArray = {1};
1353 assertTrue(ArrayUtils.isEmpty((int[]) null));
1354 assertTrue(ArrayUtils.isEmpty(emptyIntArray));
1355 assertFalse(ArrayUtils.isEmpty(notEmptyIntArray));
1356
1357 final short[] emptyShortArray = {};
1358 final short[] notEmptyShortArray = {1};
1359 assertTrue(ArrayUtils.isEmpty((short[]) null));
1360 assertTrue(ArrayUtils.isEmpty(emptyShortArray));
1361 assertFalse(ArrayUtils.isEmpty(notEmptyShortArray));
1362
1363 final char[] emptyCharArray = {};
1364 final char[] notEmptyCharArray = {1};
1365 assertTrue(ArrayUtils.isEmpty((char[]) null));
1366 assertTrue(ArrayUtils.isEmpty(emptyCharArray));
1367 assertFalse(ArrayUtils.isEmpty(notEmptyCharArray));
1368
1369 final byte[] emptyByteArray = {};
1370 final byte[] notEmptyByteArray = {1};
1371 assertTrue(ArrayUtils.isEmpty((byte[]) null));
1372 assertTrue(ArrayUtils.isEmpty(emptyByteArray));
1373 assertFalse(ArrayUtils.isEmpty(notEmptyByteArray));
1374
1375 final double[] emptyDoubleArray = {};
1376 final double[] notEmptyDoubleArray = {1.0};
1377 assertTrue(ArrayUtils.isEmpty((double[]) null));
1378 assertTrue(ArrayUtils.isEmpty(emptyDoubleArray));
1379 assertFalse(ArrayUtils.isEmpty(notEmptyDoubleArray));
1380
1381 final float[] emptyFloatArray = {};
1382 final float[] notEmptyFloatArray = {1.0F};
1383 assertTrue(ArrayUtils.isEmpty((float[]) null));
1384 assertTrue(ArrayUtils.isEmpty(emptyFloatArray));
1385 assertFalse(ArrayUtils.isEmpty(notEmptyFloatArray));
1386
1387 final boolean[] emptyBooleanArray = {};
1388 final boolean[] notEmptyBooleanArray = {true};
1389 assertTrue(ArrayUtils.isEmpty((boolean[]) null));
1390 assertTrue(ArrayUtils.isEmpty(emptyBooleanArray));
1391 assertFalse(ArrayUtils.isEmpty(notEmptyBooleanArray));
1392 }
1393
1394 @Test
1395 public void testIsEquals() {
1396 final long[][] larray1 = {{2, 5}, {4, 5}};
1397 final long[][] larray2 = {{2, 5}, {4, 6}};
1398 final long[] larray3 = {2, 5};
1399 this.assertIsEquals(larray1, larray2, larray3);
1400
1401 final int[][] iarray1 = {{2, 5}, {4, 5}};
1402 final int[][] iarray2 = {{2, 5}, {4, 6}};
1403 final int[] iarray3 = {2, 5};
1404 this.assertIsEquals(iarray1, iarray2, iarray3);
1405
1406 final short[][] sarray1 = {{2, 5}, {4, 5}};
1407 final short[][] sarray2 = {{2, 5}, {4, 6}};
1408 final short[] sarray3 = {2, 5};
1409 this.assertIsEquals(sarray1, sarray2, sarray3);
1410
1411 final float[][] farray1 = {{2, 5}, {4, 5}};
1412 final float[][] farray2 = {{2, 5}, {4, 6}};
1413 final float[] farray3 = {2, 5};
1414 this.assertIsEquals(farray1, farray2, farray3);
1415
1416 final double[][] darray1 = {{2, 5}, {4, 5}};
1417 final double[][] darray2 = {{2, 5}, {4, 6}};
1418 final double[] darray3 = {2, 5};
1419 this.assertIsEquals(darray1, darray2, darray3);
1420
1421 final byte[][] byteArray1 = {{2, 5}, {4, 5}};
1422 final byte[][] byteArray2 = {{2, 5}, {4, 6}};
1423 final byte[] byteArray3 = {2, 5};
1424 this.assertIsEquals(byteArray1, byteArray2, byteArray3);
1425
1426 final char[][] charArray1 = {{2, 5}, {4, 5}};
1427 final char[][] charArray2 = {{2, 5}, {4, 6}};
1428 final char[] charArray3 = {2, 5};
1429 this.assertIsEquals(charArray1, charArray2, charArray3);
1430
1431 final boolean[][] barray1 = {{true, false}, {true, true}};
1432 final boolean[][] barray2 = {{true, false}, {true, false}};
1433 final boolean[] barray3 = {false, true};
1434 this.assertIsEquals(barray1, barray2, barray3);
1435
1436 final Object[] array3 = {new String(new char[]{'A', 'B'})};
1437 final Object[] array4 = {"AB"};
1438 assertTrue(ArrayUtils.isEquals(array3, array3));
1439 assertTrue(ArrayUtils.isEquals(array3, array4));
1440
1441 assertTrue(ArrayUtils.isEquals(null, null));
1442 assertFalse(ArrayUtils.isEquals(null, array4));
1443 }
1444
1445
1446
1447
1448 @Test
1449 public void testIsNotEmptyObject() {
1450 final Object[] emptyArray = {};
1451 final Object[] notEmptyArray = {"Value"};
1452 assertFalse(ArrayUtils.isNotEmpty((Object[]) null));
1453 assertFalse(ArrayUtils.isNotEmpty(emptyArray));
1454 assertTrue(ArrayUtils.isNotEmpty(notEmptyArray));
1455 }
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467 @Test
1468 public void testIsNotEmptyPrimitives() {
1469 final long[] emptyLongArray = {};
1470 final long[] notEmptyLongArray = {1L};
1471 assertFalse(ArrayUtils.isNotEmpty((long[]) null));
1472 assertFalse(ArrayUtils.isNotEmpty(emptyLongArray));
1473 assertTrue(ArrayUtils.isNotEmpty(notEmptyLongArray));
1474
1475 final int[] emptyIntArray = {};
1476 final int[] notEmptyIntArray = {1};
1477 assertFalse(ArrayUtils.isNotEmpty((int[]) null));
1478 assertFalse(ArrayUtils.isNotEmpty(emptyIntArray));
1479 assertTrue(ArrayUtils.isNotEmpty(notEmptyIntArray));
1480
1481 final short[] emptyShortArray = {};
1482 final short[] notEmptyShortArray = {1};
1483 assertFalse(ArrayUtils.isNotEmpty((short[]) null));
1484 assertFalse(ArrayUtils.isNotEmpty(emptyShortArray));
1485 assertTrue(ArrayUtils.isNotEmpty(notEmptyShortArray));
1486
1487 final char[] emptyCharArray = {};
1488 final char[] notEmptyCharArray = {1};
1489 assertFalse(ArrayUtils.isNotEmpty((char[]) null));
1490 assertFalse(ArrayUtils.isNotEmpty(emptyCharArray));
1491 assertTrue(ArrayUtils.isNotEmpty(notEmptyCharArray));
1492
1493 final byte[] emptyByteArray = {};
1494 final byte[] notEmptyByteArray = {1};
1495 assertFalse(ArrayUtils.isNotEmpty((byte[]) null));
1496 assertFalse(ArrayUtils.isNotEmpty(emptyByteArray));
1497 assertTrue(ArrayUtils.isNotEmpty(notEmptyByteArray));
1498
1499 final double[] emptyDoubleArray = {};
1500 final double[] notEmptyDoubleArray = {1.0};
1501 assertFalse(ArrayUtils.isNotEmpty((double[]) null));
1502 assertFalse(ArrayUtils.isNotEmpty(emptyDoubleArray));
1503 assertTrue(ArrayUtils.isNotEmpty(notEmptyDoubleArray));
1504
1505 final float[] emptyFloatArray = {};
1506 final float[] notEmptyFloatArray = {1.0F};
1507 assertFalse(ArrayUtils.isNotEmpty((float[]) null));
1508 assertFalse(ArrayUtils.isNotEmpty(emptyFloatArray));
1509 assertTrue(ArrayUtils.isNotEmpty(notEmptyFloatArray));
1510
1511 final boolean[] emptyBooleanArray = {};
1512 final boolean[] notEmptyBooleanArray = {true};
1513 assertFalse(ArrayUtils.isNotEmpty((boolean[]) null));
1514 assertFalse(ArrayUtils.isNotEmpty(emptyBooleanArray));
1515 assertTrue(ArrayUtils.isNotEmpty(notEmptyBooleanArray));
1516 }
1517
1518 @Test
1519 public void testIsSorted() {
1520 Integer[] array = null;
1521 assertTrue(ArrayUtils.isSorted(array));
1522
1523 array = new Integer[]{1};
1524 assertTrue(ArrayUtils.isSorted(array));
1525
1526 array = new Integer[]{1, 2, 3};
1527 assertTrue(ArrayUtils.isSorted(array));
1528
1529 array = new Integer[]{1, 3, 2};
1530 assertFalse(ArrayUtils.isSorted(array));
1531 }
1532
1533 @Test
1534 public void testIsSortedBool() {
1535 boolean[] array = null;
1536 assertTrue(ArrayUtils.isSorted(array));
1537
1538 array = new boolean[]{true};
1539 assertTrue(ArrayUtils.isSorted(array));
1540
1541 array = new boolean[]{false, true};
1542 assertTrue(ArrayUtils.isSorted(array));
1543
1544 array = new boolean[]{true, false};
1545 assertFalse(ArrayUtils.isSorted(array));
1546 }
1547
1548 @Test
1549 public void testIsSortedByte() {
1550 byte[] array = null;
1551 assertTrue(ArrayUtils.isSorted(array));
1552
1553 array = new byte[]{0x10};
1554 assertTrue(ArrayUtils.isSorted(array));
1555
1556 array = new byte[]{0x10, 0x20, 0x30};
1557 assertTrue(ArrayUtils.isSorted(array));
1558
1559 array = new byte[]{0x10, 0x30, 0x20};
1560 assertFalse(ArrayUtils.isSorted(array));
1561 }
1562
1563 @Test
1564 public void testIsSortedChar() {
1565 char[] array = null;
1566 assertTrue(ArrayUtils.isSorted(array));
1567
1568 array = new char[]{'a'};
1569 assertTrue(ArrayUtils.isSorted(array));
1570
1571 array = new char[]{'a', 'b', 'c'};
1572 assertTrue(ArrayUtils.isSorted(array));
1573
1574 array = new char[]{'a', 'c', 'b'};
1575 assertFalse(ArrayUtils.isSorted(array));
1576 }
1577
1578 @Test
1579 public void testIsSortedComparator() {
1580 final Comparator<Integer> c = Comparator.reverseOrder();
1581
1582 Integer[] array = null;
1583 assertTrue(ArrayUtils.isSorted(array, c));
1584
1585 array = new Integer[]{1};
1586 assertTrue(ArrayUtils.isSorted(array, c));
1587
1588 array = new Integer[]{3, 2, 1};
1589 assertTrue(ArrayUtils.isSorted(array, c));
1590
1591 array = new Integer[]{1, 3, 2};
1592 assertFalse(ArrayUtils.isSorted(array, c));
1593 }
1594
1595 @Test
1596 public void testIsSortedDouble() {
1597 double[] array = null;
1598 assertTrue(ArrayUtils.isSorted(array));
1599
1600 array = new double[]{0.0};
1601 assertTrue(ArrayUtils.isSorted(array));
1602
1603 array = new double[]{-1.0, 0.0, 0.1, 0.2};
1604 assertTrue(ArrayUtils.isSorted(array));
1605
1606 array = new double[]{-1.0, 0.2, 0.1, 0.0};
1607 assertFalse(ArrayUtils.isSorted(array));
1608 }
1609
1610 @Test
1611 public void testIsSortedFloat() {
1612 float[] array = null;
1613 assertTrue(ArrayUtils.isSorted(array));
1614
1615 array = new float[]{0f};
1616 assertTrue(ArrayUtils.isSorted(array));
1617
1618 array = new float[]{-1f, 0f, 0.1f, 0.2f};
1619 assertTrue(ArrayUtils.isSorted(array));
1620
1621 array = new float[]{-1f, 0.2f, 0.1f, 0f};
1622 assertFalse(ArrayUtils.isSorted(array));
1623 }
1624
1625 @Test
1626 public void testIsSortedInt() {
1627 int[] array = null;
1628 assertTrue(ArrayUtils.isSorted(array));
1629
1630 array = new int[]{1};
1631 assertTrue(ArrayUtils.isSorted(array));
1632
1633 array = new int[]{1, 2, 3};
1634 assertTrue(ArrayUtils.isSorted(array));
1635
1636 array = new int[]{1, 3, 2};
1637 assertFalse(ArrayUtils.isSorted(array));
1638 }
1639
1640 @Test
1641 public void testIsSortedLong() {
1642 long[] array = null;
1643 assertTrue(ArrayUtils.isSorted(array));
1644
1645 array = new long[]{0L};
1646 assertTrue(ArrayUtils.isSorted(array));
1647
1648 array = new long[]{-1L, 0L, 1L};
1649 assertTrue(ArrayUtils.isSorted(array));
1650
1651 array = new long[]{-1L, 1L, 0L};
1652 assertFalse(ArrayUtils.isSorted(array));
1653 }
1654
1655 @Test
1656 public void testIsSortedNullComparator() {
1657 assertThrows(NullPointerException.class, () -> ArrayUtils.isSorted(null, null));
1658 }
1659
1660 @Test
1661 public void testIsSortedShort() {
1662 short[] array = null;
1663 assertTrue(ArrayUtils.isSorted(array));
1664
1665 array = new short[]{0};
1666 assertTrue(ArrayUtils.isSorted(array));
1667
1668 array = new short[]{-1, 0, 1};
1669 assertTrue(ArrayUtils.isSorted(array));
1670
1671 array = new short[]{-1, 1, 0};
1672 assertFalse(ArrayUtils.isSorted(array));
1673 }
1674
1675 @Test
1676 public void testLastIndexOf() {
1677 final Object[] array = {"0", "1", "2", "3", null, "0"};
1678 assertEquals(-1, ArrayUtils.lastIndexOf(null, null));
1679 assertEquals(-1, ArrayUtils.lastIndexOf(null, "0"));
1680 assertEquals(5, ArrayUtils.lastIndexOf(array, "0"));
1681 assertEquals(1, ArrayUtils.lastIndexOf(array, "1"));
1682 assertEquals(2, ArrayUtils.lastIndexOf(array, "2"));
1683 assertEquals(3, ArrayUtils.lastIndexOf(array, "3"));
1684 assertEquals(4, ArrayUtils.lastIndexOf(array, null));
1685 assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray"));
1686 }
1687
1688 @Test
1689 public void testLastIndexOfBoolean() {
1690 boolean[] array = null;
1691 assertEquals(-1, ArrayUtils.lastIndexOf(array, true));
1692 array = new boolean[0];
1693 assertEquals(-1, ArrayUtils.lastIndexOf(array, true));
1694 array = new boolean[]{true, false, true};
1695 assertEquals(2, ArrayUtils.lastIndexOf(array, true));
1696 assertEquals(1, ArrayUtils.lastIndexOf(array, false));
1697 array = new boolean[]{true, true};
1698 assertEquals(-1, ArrayUtils.lastIndexOf(array, false));
1699 }
1700
1701 @Test
1702 public void testLastIndexOfBooleanWithStartIndex() {
1703 boolean[] array = null;
1704 assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2));
1705 array = new boolean[0];
1706 assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2));
1707 array = new boolean[]{true, false, true};
1708 assertEquals(2, ArrayUtils.lastIndexOf(array, true, 2));
1709 assertEquals(0, ArrayUtils.lastIndexOf(array, true, 1));
1710 assertEquals(1, ArrayUtils.lastIndexOf(array, false, 2));
1711 assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1));
1712 array = new boolean[]{true, true};
1713 assertEquals(-1, ArrayUtils.lastIndexOf(array, false, 2));
1714 assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1));
1715 }
1716
1717 @Test
1718 public void testLastIndexOfByte() {
1719 byte[] array = null;
1720 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0));
1721 array = new byte[]{0, 1, 2, 3, 0};
1722 assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0));
1723 assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1));
1724 assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2));
1725 assertEquals(3, ArrayUtils.lastIndexOf(array, (byte) 3));
1726 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99));
1727 }
1728
1729 @Test
1730 public void testLastIndexOfByteWithStartIndex() {
1731 byte[] array = null;
1732 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0, 2));
1733 array = new byte[]{0, 1, 2, 3, 0};
1734 assertEquals(0, ArrayUtils.lastIndexOf(array, (byte) 0, 2));
1735 assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1, 2));
1736 assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2, 2));
1737 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, 2));
1738 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, -1));
1739 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99));
1740 assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0, 88));
1741 }
1742
1743 @Test
1744 public void testLastIndexOfChar() {
1745 char[] array = null;
1746 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a'));
1747 array = new char[]{'a', 'b', 'c', 'd', 'a'};
1748 assertEquals(4, ArrayUtils.lastIndexOf(array, 'a'));
1749 assertEquals(1, ArrayUtils.lastIndexOf(array, 'b'));
1750 assertEquals(2, ArrayUtils.lastIndexOf(array, 'c'));
1751 assertEquals(3, ArrayUtils.lastIndexOf(array, 'd'));
1752 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e'));
1753 }
1754
1755 @Test
1756 public void testLastIndexOfCharWithStartIndex() {
1757 char[] array = null;
1758 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a', 2));
1759 array = new char[]{'a', 'b', 'c', 'd', 'a'};
1760 assertEquals(0, ArrayUtils.lastIndexOf(array, 'a', 2));
1761 assertEquals(1, ArrayUtils.lastIndexOf(array, 'b', 2));
1762 assertEquals(2, ArrayUtils.lastIndexOf(array, 'c', 2));
1763 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', 2));
1764 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', -1));
1765 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e'));
1766 assertEquals(4, ArrayUtils.lastIndexOf(array, 'a', 88));
1767 }
1768
1769 @Test
1770 public void testLastIndexOfDouble() {
1771 double[] array = null;
1772 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1773 array = new double[0];
1774 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1775 array = new double[]{0, 1, 2, 3, 0};
1776 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
1777 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
1778 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
1779 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
1780 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1781 }
1782
1783 @Test
1784 public void testLastIndexOfDoubleTolerance() {
1785 double[] array = null;
1786 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
1787 array = new double[0];
1788 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
1789 array = new double[]{0, 1, 2, 3, 0};
1790 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 0.3));
1791 assertEquals(2, ArrayUtils.lastIndexOf(array, 2.2, 0.35));
1792 assertEquals(3, ArrayUtils.lastIndexOf(array, 4.15, 2.0));
1793 assertEquals(1, ArrayUtils.lastIndexOf(array, 1.00001324, 0.0001));
1794 }
1795
1796 @Test
1797 public void testLastIndexOfDoubleWithStartIndex() {
1798 double[] array = null;
1799 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1800 array = new double[0];
1801 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1802 array = new double[]{0, 1, 2, 3, 0};
1803 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
1804 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
1805 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
1806 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
1807 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
1808 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1809 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
1810 }
1811
1812 @Test
1813 public void testLastIndexOfDoubleWithStartIndexTolerance() {
1814 double[] array = null;
1815 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2, 0));
1816 array = new double[0];
1817 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2, 0));
1818 array = new double[]{3};
1819 assertEquals(-1, ArrayUtils.lastIndexOf(array, 1, 0, 0));
1820 array = new double[]{0, 1, 2, 3, 0};
1821 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 99, 0.3));
1822 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 3, 0.3));
1823 assertEquals(2, ArrayUtils.lastIndexOf(array, 2.2, 3, 0.35));
1824 assertEquals(3, ArrayUtils.lastIndexOf(array, 4.15, array.length, 2.0));
1825 assertEquals(1, ArrayUtils.lastIndexOf(array, 1.00001324, array.length, 0.0001));
1826 assertEquals(-1, ArrayUtils.lastIndexOf(array, 4.15, -200, 2.0));
1827 }
1828
1829 @Test
1830 public void testLastIndexOfFloat() {
1831 float[] array = null;
1832 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1833 array = new float[0];
1834 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1835 array = new float[]{0, 1, 2, 3, 0};
1836 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
1837 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
1838 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
1839 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
1840 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1841 }
1842
1843 @Test
1844 public void testLastIndexOfFloatWithStartIndex() {
1845 float[] array = null;
1846 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1847 array = new float[0];
1848 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1849 array = new float[]{0, 1, 2, 3, 0};
1850 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
1851 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
1852 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
1853 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
1854 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
1855 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1856 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
1857 }
1858
1859 @Test
1860 public void testLastIndexOfInt() {
1861 int[] array = null;
1862 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1863 array = new int[]{0, 1, 2, 3, 0};
1864 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
1865 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
1866 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
1867 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
1868 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1869 }
1870
1871 @Test
1872 public void testLastIndexOfIntWithStartIndex() {
1873 int[] array = null;
1874 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1875 array = new int[]{0, 1, 2, 3, 0};
1876 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
1877 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
1878 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
1879 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
1880 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
1881 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1882 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
1883 }
1884
1885 @Test
1886 public void testLastIndexOfLong() {
1887 long[] array = null;
1888 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1889 array = new long[]{0, 1, 2, 3, 0};
1890 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
1891 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
1892 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
1893 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
1894 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1895 }
1896
1897 @Test
1898 public void testLastIndexOfLongWithStartIndex() {
1899 long[] array = null;
1900 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1901 array = new long[]{0, 1, 2, 3, 0};
1902 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
1903 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
1904 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
1905 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
1906 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
1907 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99, 4));
1908 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
1909 }
1910
1911 @Test
1912 public void testLastIndexOfShort() {
1913 short[] array = null;
1914 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0));
1915 array = new short[]{0, 1, 2, 3, 0};
1916 assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0));
1917 assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1));
1918 assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2));
1919 assertEquals(3, ArrayUtils.lastIndexOf(array, (short) 3));
1920 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
1921 }
1922
1923 @Test
1924 public void testLastIndexOfShortWithStartIndex() {
1925 short[] array = null;
1926 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0, 2));
1927 array = new short[]{0, 1, 2, 3, 0};
1928 assertEquals(0, ArrayUtils.lastIndexOf(array, (short) 0, 2));
1929 assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1, 2));
1930 assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2, 2));
1931 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, 2));
1932 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, -1));
1933 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
1934 assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0, 88));
1935 }
1936
1937 @Test
1938 public void testLastIndexOfWithStartIndex() {
1939 final Object[] array = {"0", "1", "2", "3", null, "0"};
1940 assertEquals(-1, ArrayUtils.lastIndexOf(null, null, 2));
1941 assertEquals(-1, ArrayUtils.lastIndexOf(null, "0", 2));
1942 assertEquals(0, ArrayUtils.lastIndexOf(array, "0", 2));
1943 assertEquals(1, ArrayUtils.lastIndexOf(array, "1", 2));
1944 assertEquals(2, ArrayUtils.lastIndexOf(array, "2", 2));
1945 assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", 2));
1946 assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", -1));
1947 assertEquals(4, ArrayUtils.lastIndexOf(array, null, 5));
1948 assertEquals(-1, ArrayUtils.lastIndexOf(array, null, 2));
1949 assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray", 5));
1950
1951 assertEquals(-1, ArrayUtils.lastIndexOf(array, null, -1));
1952 assertEquals(5, ArrayUtils.lastIndexOf(array, "0", 88));
1953 }
1954
1955 @Test
1956 public void testNullToEmptyBoolean() {
1957 final boolean[] original = {true, false};
1958 assertEquals(original, ArrayUtils.nullToEmpty(original));
1959 }
1960
1961 @Test
1962 public void testNullToEmptyBooleanEmptyArray() {
1963 final boolean[] empty = {};
1964 final boolean[] result = ArrayUtils.nullToEmpty(empty);
1965 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, result);
1966 assertNotSame(empty, result);
1967 }
1968
1969 @Test
1970 public void testNullToEmptyBooleanNull() {
1971 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.nullToEmpty((boolean[]) null));
1972 }
1973
1974 @Test
1975 public void testNullToEmptyBooleanObject() {
1976 final Boolean[] original = {Boolean.TRUE, Boolean.FALSE};
1977 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
1978 }
1979
1980 @Test
1981 public void testNullToEmptyBooleanObjectEmptyArray() {
1982 final Boolean[] empty = {};
1983 final Boolean[] result = ArrayUtils.nullToEmpty(empty);
1984 assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, result);
1985 assertNotSame(empty, result);
1986 }
1987
1988 @Test
1989 public void testNullToEmptyBooleanObjectNull() {
1990 assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Boolean[]) null));
1991 }
1992
1993 @Test
1994 public void testNullToEmptyByte() {
1995 final byte[] original = {0x0F, 0x0E};
1996 assertEquals(original, ArrayUtils.nullToEmpty(original));
1997 }
1998
1999 @Test
2000 public void testNullToEmptyByteEmptyArray() {
2001 final byte[] empty = {};
2002 final byte[] result = ArrayUtils.nullToEmpty(empty);
2003 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, result);
2004 assertNotSame(empty, result);
2005 }
2006
2007 @Test
2008 public void testNullToEmptyByteNull() {
2009 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.nullToEmpty((byte[]) null));
2010 }
2011
2012 @Test
2013 public void testNullToEmptyByteObject() {
2014 final Byte[] original = {0x0F, 0x0E};
2015 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2016 }
2017
2018 @Test
2019 public void testNullToEmptyByteObjectEmptyArray() {
2020 final Byte[] empty = {};
2021 final Byte[] result = ArrayUtils.nullToEmpty(empty);
2022 assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, result);
2023 assertNotSame(empty, result);
2024 }
2025
2026 @Test
2027 public void testNullToEmptyByteObjectNull() {
2028 assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Byte[]) null));
2029 }
2030
2031 @Test
2032 public void testNullToEmptyChar() {
2033 final char[] original = {'a', 'b'};
2034 assertEquals(original, ArrayUtils.nullToEmpty(original));
2035 }
2036
2037 @Test
2038 public void testNullToEmptyCharEmptyArray() {
2039 final char[] empty = {};
2040 final char[] result = ArrayUtils.nullToEmpty(empty);
2041 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, result);
2042 assertNotSame(empty, result);
2043 }
2044
2045 @Test
2046 public void testNullToEmptyCharNull() {
2047 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.nullToEmpty((char[]) null));
2048 }
2049
2050 @Test
2051 public void testNullToEmptyCharObject() {
2052 final Character[] original = {'a', 'b'};
2053 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2054 }
2055
2056 @Test
2057 public void testNullToEmptyCharObjectEmptyArray() {
2058 final Character[] empty = {};
2059 final Character[] result = ArrayUtils.nullToEmpty(empty);
2060 assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, result);
2061 assertNotSame(empty, result);
2062 }
2063
2064 @Test
2065 public void testNUllToEmptyCharObjectNull() {
2066 assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Character[]) null));
2067 }
2068
2069 @Test
2070 public void testNullToEmptyClass() {
2071 final Class<?>[] original = {Object.class, String.class};
2072 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2073 }
2074
2075 @Test
2076 public void testNullToEmptyClassEmptyArray() {
2077 final Class<?>[] empty = {};
2078 final Class<?>[] result = ArrayUtils.nullToEmpty(empty);
2079 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, result);
2080 assertNotSame(empty, result);
2081 }
2082
2083 @Test
2084 public void testNullToEmptyClassNull() {
2085 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ArrayUtils.nullToEmpty((Class<?>[]) null));
2086 }
2087
2088 @Test
2089 public void testNullToEmptyDouble() {
2090 final double[] original = {1L, 2L};
2091 assertEquals(original, ArrayUtils.nullToEmpty(original));
2092 }
2093
2094 @Test
2095 public void testNullToEmptyDoubleEmptyArray() {
2096 final double[] empty = {};
2097 final double[] result = ArrayUtils.nullToEmpty(empty);
2098 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, result);
2099 assertNotSame(empty, result);
2100 }
2101
2102 @Test
2103 public void testNullToEmptyDoubleNull() {
2104 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.nullToEmpty((double[]) null));
2105 }
2106
2107 @Test
2108 public void testNullToEmptyDoubleObject() {
2109 final Double[] original = {1D, 2D};
2110 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2111 }
2112
2113 @Test
2114 public void testNullToEmptyDoubleObjectEmptyArray() {
2115 final Double[] empty = {};
2116 final Double[] result = ArrayUtils.nullToEmpty(empty);
2117 assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, result);
2118 assertNotSame(empty, result);
2119 }
2120
2121 @Test
2122 public void testNullToEmptyDoubleObjectNull() {
2123 assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Double[]) null));
2124 }
2125
2126 @Test
2127 public void testNullToEmptyFloat() {
2128 final float[] original = {2.6f, 3.8f};
2129 assertEquals(original, ArrayUtils.nullToEmpty(original));
2130 }
2131
2132 @Test
2133 public void testNullToEmptyFloatEmptyArray() {
2134 final float[] empty = {};
2135 final float[] result = ArrayUtils.nullToEmpty(empty);
2136 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, result);
2137 assertNotSame(empty, result);
2138 }
2139
2140 @Test
2141 public void testNullToEmptyFloatNull() {
2142 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.nullToEmpty((float[]) null));
2143 }
2144
2145 @Test
2146 public void testNullToEmptyFloatObject() {
2147 final Float[] original = {2.6f, 3.8f};
2148 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2149 }
2150
2151 @Test
2152 public void testNullToEmptyFloatObjectEmptyArray() {
2153 final Float[] empty = {};
2154 final Float[] result = ArrayUtils.nullToEmpty(empty);
2155 assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, result);
2156 assertNotSame(empty, result);
2157 }
2158
2159 @Test
2160 public void testNullToEmptyFloatObjectNull() {
2161 assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Float[]) null));
2162 }
2163
2164 @Test
2165 public void testNullToEmptyGeneric() {
2166 final TestClass[] input = {new TestClass(), new TestClass()};
2167 final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class);
2168
2169 assertSame(input, output);
2170 }
2171
2172 @Test
2173 public void testNullToEmptyGenericEmpty() {
2174 final TestClass[] input = {};
2175 final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class);
2176
2177 assertSame(input, output);
2178 }
2179
2180 @Test
2181 public void testNullToEmptyGenericNull() {
2182 final TestClass[] output = ArrayUtils.nullToEmpty(null, TestClass[].class);
2183
2184 assertNotNull(output);
2185 assertEquals(0, output.length);
2186 }
2187
2188 @Test
2189 public void testNullToEmptyGenericNullType() {
2190 final TestClass[] input = {};
2191 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.nullToEmpty(input, null));
2192 }
2193
2194 @Test
2195 public void testNullToEmptyInt() {
2196 final int[] original = {1, 2};
2197 assertEquals(original, ArrayUtils.nullToEmpty(original));
2198 }
2199
2200 @Test
2201 public void testNullToEmptyIntEmptyArray() {
2202 final int[] empty = {};
2203 final int[] result = ArrayUtils.nullToEmpty(empty);
2204 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, result);
2205 assertNotSame(empty, result);
2206 }
2207
2208 @Test
2209 public void testNullToEmptyIntNull() {
2210 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.nullToEmpty((int[]) null));
2211 }
2212
2213 @Test
2214 public void testNullToEmptyIntObject() {
2215 final Integer[] original = {1, 2};
2216 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2217 }
2218
2219 @Test
2220 public void testNullToEmptyIntObjectEmptyArray() {
2221 final Integer[] empty = {};
2222 final Integer[] result = ArrayUtils.nullToEmpty(empty);
2223 assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, result);
2224 assertNotSame(empty, result);
2225 }
2226
2227 @Test
2228 public void testNullToEmptyIntObjectNull() {
2229 assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Integer[]) null));
2230 }
2231
2232 @Test
2233 public void testNullToEmptyLong() {
2234 final long[] original = {1L, 2L};
2235 assertEquals(original, ArrayUtils.nullToEmpty(original));
2236 }
2237
2238 @Test
2239 public void testNullToEmptyLongEmptyArray() {
2240 final long[] empty = {};
2241 final long[] result = ArrayUtils.nullToEmpty(empty);
2242 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, result);
2243 assertNotSame(empty, result);
2244 }
2245
2246 @Test
2247 public void testNullToEmptyLongNull() {
2248 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.nullToEmpty((long[]) null));
2249 }
2250
2251 @Test
2252 public void testNullToEmptyLongObject() {
2253 @SuppressWarnings("boxing") final Long[] original = {1L, 2L};
2254 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2255 }
2256
2257 @Test
2258 public void testNullToEmptyLongObjectEmptyArray() {
2259 final Long[] empty = {};
2260 final Long[] result = ArrayUtils.nullToEmpty(empty);
2261 assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, result);
2262 assertNotSame(empty, result);
2263 }
2264
2265 @Test
2266 public void testNullToEmptyLongObjectNull() {
2267 assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Long[]) null));
2268 }
2269
2270 @Test
2271 public void testNullToEmptyObject() {
2272 final Object[] original = {Boolean.TRUE, Boolean.FALSE};
2273 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2274 }
2275
2276 @Test
2277 public void testNullToEmptyObjectEmptyArray() {
2278 final Object[] empty = {};
2279 final Object[] result = ArrayUtils.nullToEmpty(empty);
2280 assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, result);
2281 assertNotSame(empty, result);
2282 }
2283
2284 @Test
2285 public void testNullToEmptyObjectNull() {
2286 assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Object[]) null));
2287 }
2288
2289 @Test
2290 public void testNullToEmptyShort() {
2291 final short[] original = {1, 2};
2292 assertEquals(original, ArrayUtils.nullToEmpty(original));
2293 }
2294
2295 @Test
2296 public void testNullToEmptyShortEmptyArray() {
2297 final short[] empty = {};
2298 final short[] result = ArrayUtils.nullToEmpty(empty);
2299 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, result);
2300 assertNotSame(empty, result);
2301 }
2302
2303 @Test
2304 public void testNullToEmptyShortNull() {
2305 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.nullToEmpty((short[]) null));
2306 }
2307
2308 @Test
2309 public void testNullToEmptyShortObject() {
2310 @SuppressWarnings("boxing") final Short[] original = {1, 2};
2311 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2312 }
2313
2314 @Test
2315 public void testNullToEmptyShortObjectEmptyArray() {
2316 final Short[] empty = {};
2317 final Short[] result = ArrayUtils.nullToEmpty(empty);
2318 assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, result);
2319 assertNotSame(empty, result);
2320 }
2321
2322 @Test
2323 public void testNullToEmptyShortObjectNull() {
2324 assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Short[]) null));
2325 }
2326
2327 @Test
2328 public void testNullToEmptyString() {
2329 final String[] original = {"abc", "def"};
2330 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2331 }
2332
2333 @Test
2334 public void testNullToEmptyStringEmptyArray() {
2335 final String[] empty = {};
2336 final String[] result = ArrayUtils.nullToEmpty(empty);
2337 assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, result);
2338 assertNotSame(empty, result);
2339 }
2340
2341 @Test
2342 public void testNullToEmptyStringNull() {
2343 assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, ArrayUtils.nullToEmpty((String[]) null));
2344 }
2345
2346 @Test
2347 public void testNullToShortObject() {
2348 @SuppressWarnings("boxing") final Short[] original = {1, 2};
2349 assertArrayEquals(original, ArrayUtils.nullTo(original, ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY));
2350 }
2351
2352 @Test
2353 public void testReverse() {
2354 final StringBuffer str1 = new StringBuffer("pick");
2355 final String str2 = "a";
2356 final String[] str3 = {"stick"};
2357 final String str4 = "up";
2358
2359 Object[] array = {str1, str2, str3};
2360 ArrayUtils.reverse(array);
2361 assertEquals(array[0], str3);
2362 assertEquals(array[1], str2);
2363 assertEquals(array[2], str1);
2364
2365 array = new Object[]{str1, str2, str3, str4};
2366 ArrayUtils.reverse(array);
2367 assertEquals(array[0], str4);
2368 assertEquals(array[1], str3);
2369 assertEquals(array[2], str2);
2370 assertEquals(array[3], str1);
2371
2372 array = null;
2373 ArrayUtils.reverse(array);
2374 assertArrayEquals(null, array);
2375 }
2376
2377 @Test
2378 public void testReverseBoolean() {
2379 boolean[] array = {false, false, true};
2380 ArrayUtils.reverse(array);
2381 assertTrue(array[0]);
2382 assertFalse(array[1]);
2383 assertFalse(array[2]);
2384
2385 array = null;
2386 ArrayUtils.reverse(array);
2387 assertNull(array);
2388 }
2389
2390 @Test
2391 public void testReverseBooleanRange() {
2392 boolean[] array = {false, false, true};
2393
2394 ArrayUtils.reverse(array, 0, 3);
2395 assertTrue(array[0]);
2396 assertFalse(array[1]);
2397 assertFalse(array[2]);
2398
2399 array = new boolean[]{false, false, true};
2400 ArrayUtils.reverse(array, 0, 2);
2401 assertFalse(array[0]);
2402 assertFalse(array[1]);
2403 assertTrue(array[2]);
2404
2405 array = new boolean[]{false, false, true};
2406 ArrayUtils.reverse(array, -1, 3);
2407 assertTrue(array[0]);
2408 assertFalse(array[1]);
2409 assertFalse(array[2]);
2410
2411 array = new boolean[]{false, false, true};
2412 ArrayUtils.reverse(array, -1, array.length + 1000);
2413 assertTrue(array[0]);
2414 assertFalse(array[1]);
2415 assertFalse(array[2]);
2416
2417 array = null;
2418 ArrayUtils.reverse(array, 0, 3);
2419 assertNull(array);
2420 }
2421
2422 @Test
2423 public void testReverseByte() {
2424 byte[] array = {2, 3, 4};
2425 ArrayUtils.reverse(array);
2426 assertEquals(4, array[0]);
2427 assertEquals(3, array[1]);
2428 assertEquals(2, array[2]);
2429
2430 array = null;
2431 ArrayUtils.reverse(array);
2432 assertNull(array);
2433 }
2434
2435 @Test
2436 public void testReverseByteRange() {
2437 byte[] array = {1, 2, 3};
2438
2439 ArrayUtils.reverse(array, 0, 3);
2440 assertEquals(3, array[0]);
2441 assertEquals(2, array[1]);
2442 assertEquals(1, array[2]);
2443
2444 array = new byte[]{1, 2, 3};
2445 ArrayUtils.reverse(array, 0, 2);
2446 assertEquals(2, array[0]);
2447 assertEquals(1, array[1]);
2448 assertEquals(3, array[2]);
2449
2450 array = new byte[]{1, 2, 3};
2451 ArrayUtils.reverse(array, -1, 3);
2452 assertEquals(3, array[0]);
2453 assertEquals(2, array[1]);
2454 assertEquals(1, array[2]);
2455
2456 array = new byte[]{1, 2, 3};
2457 ArrayUtils.reverse(array, -1, array.length + 1000);
2458 assertEquals(3, array[0]);
2459 assertEquals(2, array[1]);
2460 assertEquals(1, array[2]);
2461
2462 array = null;
2463 ArrayUtils.reverse(array, 0, 3);
2464 assertNull(array);
2465 }
2466
2467 @Test
2468 public void testReverseChar() {
2469 char[] array = {'a', 'f', 'C'};
2470 ArrayUtils.reverse(array);
2471 assertEquals('C', array[0]);
2472 assertEquals('f', array[1]);
2473 assertEquals('a', array[2]);
2474
2475 array = null;
2476 ArrayUtils.reverse(array);
2477 assertNull(array);
2478 }
2479
2480 @Test
2481 public void testReverseCharRange() {
2482 char[] array = {1, 2, 3};
2483
2484 ArrayUtils.reverse(array, 0, 3);
2485 assertEquals(3, array[0]);
2486 assertEquals(2, array[1]);
2487 assertEquals(1, array[2]);
2488
2489 array = new char[]{1, 2, 3};
2490 ArrayUtils.reverse(array, 0, 2);
2491 assertEquals(2, array[0]);
2492 assertEquals(1, array[1]);
2493 assertEquals(3, array[2]);
2494
2495 array = new char[]{1, 2, 3};
2496 ArrayUtils.reverse(array, -1, 3);
2497 assertEquals(3, array[0]);
2498 assertEquals(2, array[1]);
2499 assertEquals(1, array[2]);
2500
2501 array = new char[]{1, 2, 3};
2502 ArrayUtils.reverse(array, -1, array.length + 1000);
2503 assertEquals(3, array[0]);
2504 assertEquals(2, array[1]);
2505 assertEquals(1, array[2]);
2506
2507 array = null;
2508 ArrayUtils.reverse(array, 0, 3);
2509 assertNull(array);
2510 }
2511
2512 @Test
2513 public void testReverseDouble() {
2514 double[] array = {0.3d, 0.4d, 0.5d};
2515 ArrayUtils.reverse(array);
2516 assertEquals(0.5d, array[0]);
2517 assertEquals(0.4d, array[1]);
2518 assertEquals(0.3d, array[2]);
2519
2520 array = null;
2521 ArrayUtils.reverse(array);
2522 assertNull(array);
2523 }
2524
2525 @Test
2526 public void testReverseDoubleRange() {
2527 double[] array = {1, 2, 3};
2528
2529 ArrayUtils.reverse(array, 0, 3);
2530 assertEquals(3, array[0]);
2531 assertEquals(2, array[1]);
2532 assertEquals(1, array[2]);
2533
2534 array = new double[]{1, 2, 3};
2535 ArrayUtils.reverse(array, 0, 2);
2536 assertEquals(2, array[0]);
2537 assertEquals(1, array[1]);
2538 assertEquals(3, array[2]);
2539
2540 array = new double[]{1, 2, 3};
2541 ArrayUtils.reverse(array, -1, 3);
2542 assertEquals(3, array[0]);
2543 assertEquals(2, array[1]);
2544 assertEquals(1, array[2]);
2545
2546 array = new double[]{1, 2, 3};
2547 ArrayUtils.reverse(array, -1, array.length + 1000);
2548 assertEquals(3, array[0]);
2549 assertEquals(2, array[1]);
2550 assertEquals(1, array[2]);
2551
2552 array = null;
2553 ArrayUtils.reverse(array, 0, 3);
2554 assertNull(array);
2555 }
2556
2557 @Test
2558 public void testReverseFloat() {
2559 float[] array = {0.3f, 0.4f, 0.5f};
2560 ArrayUtils.reverse(array);
2561 assertEquals(0.5f, array[0]);
2562 assertEquals(0.4f, array[1]);
2563 assertEquals(0.3f, array[2]);
2564
2565 array = null;
2566 ArrayUtils.reverse(array);
2567 assertNull(array);
2568 }
2569
2570 @Test
2571 public void testReverseFloatRange() {
2572 float[] array = {1, 2, 3};
2573
2574 ArrayUtils.reverse(array, 0, 3);
2575 assertEquals(3, array[0]);
2576 assertEquals(2, array[1]);
2577 assertEquals(1, array[2]);
2578
2579 array = new float[]{1, 2, 3};
2580 ArrayUtils.reverse(array, 0, 2);
2581 assertEquals(2, array[0]);
2582 assertEquals(1, array[1]);
2583 assertEquals(3, array[2]);
2584
2585 array = new float[]{1, 2, 3};
2586 ArrayUtils.reverse(array, -1, 3);
2587 assertEquals(3, array[0]);
2588 assertEquals(2, array[1]);
2589 assertEquals(1, array[2]);
2590
2591 array = new float[]{1, 2, 3};
2592 ArrayUtils.reverse(array, -1, array.length + 1000);
2593 assertEquals(3, array[0]);
2594 assertEquals(2, array[1]);
2595 assertEquals(1, array[2]);
2596
2597 array = null;
2598 ArrayUtils.reverse(array, 0, 3);
2599 assertNull(array);
2600 }
2601
2602 @Test
2603 public void testReverseInt() {
2604 int[] array = {1, 2, 3};
2605 ArrayUtils.reverse(array);
2606 assertEquals(3, array[0]);
2607 assertEquals(2, array[1]);
2608 assertEquals(1, array[2]);
2609
2610 array = null;
2611 ArrayUtils.reverse(array);
2612 assertNull(array);
2613 }
2614
2615 @Test
2616 public void testReverseIntRange() {
2617 int[] array = {1, 2, 3};
2618
2619 ArrayUtils.reverse(array, 0, 3);
2620 assertEquals(3, array[0]);
2621 assertEquals(2, array[1]);
2622 assertEquals(1, array[2]);
2623
2624 array = new int[]{1, 2, 3};
2625 ArrayUtils.reverse(array, 0, 2);
2626 assertEquals(2, array[0]);
2627 assertEquals(1, array[1]);
2628 assertEquals(3, array[2]);
2629
2630 array = new int[]{1, 2, 3};
2631 ArrayUtils.reverse(array, -1, 3);
2632 assertEquals(3, array[0]);
2633 assertEquals(2, array[1]);
2634 assertEquals(1, array[2]);
2635
2636 array = new int[]{1, 2, 3};
2637 ArrayUtils.reverse(array, -1, array.length + 1000);
2638 assertEquals(3, array[0]);
2639 assertEquals(2, array[1]);
2640 assertEquals(1, array[2]);
2641
2642 array = null;
2643 ArrayUtils.reverse(array, 0, 3);
2644 assertNull(array);
2645 }
2646
2647 @Test
2648 public void testReverseLong() {
2649 long[] array = {1L, 2L, 3L};
2650 ArrayUtils.reverse(array);
2651 assertEquals(3L, array[0]);
2652 assertEquals(2L, array[1]);
2653 assertEquals(1L, array[2]);
2654
2655 array = null;
2656 ArrayUtils.reverse(array);
2657 assertNull(array);
2658 }
2659
2660 @Test
2661 public void testReverseLongRange() {
2662 long[] array = {1, 2, 3};
2663
2664 ArrayUtils.reverse(array, 0, 3);
2665 assertEquals(3, array[0]);
2666 assertEquals(2, array[1]);
2667 assertEquals(1, array[2]);
2668
2669 array = new long[]{1, 2, 3};
2670 ArrayUtils.reverse(array, 0, 2);
2671 assertEquals(2, array[0]);
2672 assertEquals(1, array[1]);
2673 assertEquals(3, array[2]);
2674
2675 array = new long[]{1, 2, 3};
2676 ArrayUtils.reverse(array, -1, 3);
2677 assertEquals(3, array[0]);
2678 assertEquals(2, array[1]);
2679 assertEquals(1, array[2]);
2680
2681 array = new long[]{1, 2, 3};
2682 ArrayUtils.reverse(array, -1, array.length + 1000);
2683 assertEquals(3, array[0]);
2684 assertEquals(2, array[1]);
2685 assertEquals(1, array[2]);
2686
2687 array = null;
2688 ArrayUtils.reverse(array, 0, 3);
2689 assertNull(array);
2690 }
2691
2692 @Test
2693 public void testReverseObjectRange() {
2694 String[] array = {"1", "2", "3"};
2695
2696 ArrayUtils.reverse(array, 0, 3);
2697 assertEquals("3", array[0]);
2698 assertEquals("2", array[1]);
2699 assertEquals("1", array[2]);
2700
2701 array = new String[]{"1", "2", "3"};
2702 ArrayUtils.reverse(array, 0, 2);
2703 assertEquals("2", array[0]);
2704 assertEquals("1", array[1]);
2705 assertEquals("3", array[2]);
2706
2707 array = new String[]{"1", "2", "3"};
2708 ArrayUtils.reverse(array, -1, 3);
2709 assertEquals("3", array[0]);
2710 assertEquals("2", array[1]);
2711 assertEquals("1", array[2]);
2712
2713 array = new String[]{"1", "2", "3"};
2714 ArrayUtils.reverse(array, -1, array.length + 1000);
2715 assertEquals("3", array[0]);
2716 assertEquals("2", array[1]);
2717 assertEquals("1", array[2]);
2718
2719 array = null;
2720 ArrayUtils.reverse(array, 0, 3);
2721 assertNull(array);
2722 }
2723
2724 @Test
2725 public void testReverseShort() {
2726 short[] array = {1, 2, 3};
2727 ArrayUtils.reverse(array);
2728 assertEquals(3, array[0]);
2729 assertEquals(2, array[1]);
2730 assertEquals(1, array[2]);
2731
2732 array = null;
2733 ArrayUtils.reverse(array);
2734 assertNull(array);
2735 }
2736
2737 @Test
2738 public void testReverseShortRange() {
2739 short[] array = {1, 2, 3};
2740
2741 ArrayUtils.reverse(array, 0, 3);
2742 assertEquals(3, array[0]);
2743 assertEquals(2, array[1]);
2744 assertEquals(1, array[2]);
2745
2746 array = new short[]{1, 2, 3};
2747 ArrayUtils.reverse(array, 0, 2);
2748 assertEquals(2, array[0]);
2749 assertEquals(1, array[1]);
2750 assertEquals(3, array[2]);
2751
2752 array = new short[]{1, 2, 3};
2753 ArrayUtils.reverse(array, -1, 3);
2754 assertEquals(3, array[0]);
2755 assertEquals(2, array[1]);
2756 assertEquals(1, array[2]);
2757
2758 array = new short[]{1, 2, 3};
2759 ArrayUtils.reverse(array, -1, array.length + 1000);
2760 assertEquals(3, array[0]);
2761 assertEquals(2, array[1]);
2762 assertEquals(1, array[2]);
2763
2764 array = null;
2765 ArrayUtils.reverse(array, 0, 3);
2766 assertNull(array);
2767 }
2768
2769 @Test
2770 public void testSameLength() {
2771 final Object[] nullArray = null;
2772 final Object[] emptyArray = {};
2773 final Object[] oneArray = {"pick"};
2774 final Object[] twoArray = {"pick", "stick"};
2775
2776 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
2777 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
2778 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
2779 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
2780
2781 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
2782 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
2783 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
2784 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
2785
2786 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
2787 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
2788 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
2789 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
2790
2791 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
2792 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
2793 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
2794 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
2795 }
2796
2797 @Test
2798 public void testSameLengthAll() {
2799 final Object[] nullArrayObject = null;
2800 final Object[] emptyArrayObject = {};
2801 final Object[] oneArrayObject = {"pick"};
2802 final Object[] twoArrayObject = {"pick", "stick"};
2803 final boolean[] nullArrayBoolean = null;
2804 final boolean[] emptyArrayBoolean = {};
2805 final boolean[] oneArrayBoolean = {true};
2806 final boolean[] twoArrayBoolean = {true, false};
2807 final long[] nullArrayLong = null;
2808 final long[] emptyArrayLong = {};
2809 final long[] oneArrayLong = {0L};
2810 final long[] twoArrayLong = {0L, 76L};
2811 final int[] nullArrayInt = null;
2812 final int[] emptyArrayInt = {};
2813 final int[] oneArrayInt = {4};
2814 final int[] twoArrayInt = {5, 7};
2815 final short[] nullArrayShort = null;
2816 final short[] emptyArrayShort = {};
2817 final short[] oneArrayShort = {4};
2818 final short[] twoArrayShort = {6, 8};
2819 final char[] nullArrayChar = null;
2820 final char[] emptyArrayChar = {};
2821 final char[] oneArrayChar = {'f'};
2822 final char[] twoArrayChar = {'d', 't'};
2823 final byte[] nullArrayByte = null;
2824 final byte[] emptyArrayByte = {};
2825 final byte[] oneArrayByte = {3};
2826 final byte[] twoArrayByte = {4, 6};
2827 final double[] nullArrayDouble = null;
2828 final double[] emptyArrayDouble = {};
2829 final double[] oneArrayDouble = {1.3d};
2830 final double[] twoArrayDouble = {4.5d, 6.3d};
2831 final float[] nullArrayFloat = null;
2832 final float[] emptyArrayFloat = {};
2833 final float[] oneArrayFloat = {2.5f};
2834 final float[] twoArrayFloat = {6.4f, 5.8f};
2835 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayObject));
2836 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayBoolean));
2837 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayLong));
2838 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayInt));
2839 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayShort));
2840 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayChar));
2841 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayByte));
2842 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayDouble));
2843 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayFloat));
2844 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayObject));
2845 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayBoolean));
2846 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayLong));
2847 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayInt));
2848 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayShort));
2849 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayChar));
2850 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayByte));
2851 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayDouble));
2852 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayFloat));
2853 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayObject));
2854 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayBoolean));
2855 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayLong));
2856 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayInt));
2857 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayShort));
2858 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayChar));
2859 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayByte));
2860 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayDouble));
2861 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayFloat));
2862 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayObject));
2863 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayBoolean));
2864 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayLong));
2865 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayInt));
2866 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayShort));
2867 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayChar));
2868 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayByte));
2869 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayDouble));
2870 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayFloat));
2871 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayObject));
2872 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayBoolean));
2873 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayLong));
2874 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayInt));
2875 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayShort));
2876 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayChar));
2877 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayByte));
2878 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayDouble));
2879 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayFloat));
2880 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayObject));
2881 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayBoolean));
2882 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayLong));
2883 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayInt));
2884 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayShort));
2885 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayChar));
2886 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayByte));
2887 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayDouble));
2888 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayFloat));
2889 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayObject));
2890 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayBoolean));
2891 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayLong));
2892 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayInt));
2893 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayShort));
2894 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayChar));
2895 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayByte));
2896 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayDouble));
2897 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayFloat));
2898 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayObject));
2899 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayBoolean));
2900 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayLong));
2901 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayInt));
2902 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayShort));
2903 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayChar));
2904 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayByte));
2905 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayDouble));
2906 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayFloat));
2907 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayObject));
2908 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayBoolean));
2909 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayLong));
2910 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayInt));
2911 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayShort));
2912 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayChar));
2913 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayByte));
2914 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayDouble));
2915 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayFloat));
2916 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayObject));
2917 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayBoolean));
2918 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayLong));
2919 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayInt));
2920 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayShort));
2921 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayChar));
2922 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayByte));
2923 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayDouble));
2924 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayFloat));
2925 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayObject));
2926 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayBoolean));
2927 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayLong));
2928 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayInt));
2929 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayShort));
2930 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayChar));
2931 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayByte));
2932 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayDouble));
2933 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayFloat));
2934 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayObject));
2935 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayBoolean));
2936 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayLong));
2937 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayInt));
2938 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayShort));
2939 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayChar));
2940 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayByte));
2941 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayDouble));
2942 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayFloat));
2943 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayObject));
2944 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayBoolean));
2945 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayLong));
2946 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayInt));
2947 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayShort));
2948 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayChar));
2949 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayByte));
2950 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayDouble));
2951 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayFloat));
2952 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayObject));
2953 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayBoolean));
2954 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayLong));
2955 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayInt));
2956 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayShort));
2957 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayChar));
2958 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayByte));
2959 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayDouble));
2960 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayFloat));
2961 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayObject));
2962 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayBoolean));
2963 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayLong));
2964 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayInt));
2965 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayShort));
2966 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayChar));
2967 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayByte));
2968 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayDouble));
2969 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayFloat));
2970 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayObject));
2971 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayBoolean));
2972 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayLong));
2973 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayInt));
2974 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayShort));
2975 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayChar));
2976 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayByte));
2977 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayDouble));
2978 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayFloat));
2979 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayObject));
2980 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayBoolean));
2981 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayLong));
2982 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayInt));
2983 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayShort));
2984 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayChar));
2985 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayByte));
2986 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayDouble));
2987 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayFloat));
2988 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayObject));
2989 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayBoolean));
2990 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayLong));
2991 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayInt));
2992 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayShort));
2993 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayChar));
2994 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayByte));
2995 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayDouble));
2996 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayFloat));
2997 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayObject));
2998 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayBoolean));
2999 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayLong));
3000 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayInt));
3001 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayShort));
3002 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayChar));
3003 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayByte));
3004 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayDouble));
3005 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayFloat));
3006 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayObject));
3007 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayBoolean));
3008 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayLong));
3009 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayInt));
3010 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayShort));
3011 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayChar));
3012 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayByte));
3013 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayDouble));
3014 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayFloat));
3015 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayObject));
3016 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayBoolean));
3017 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayLong));
3018 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayInt));
3019 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayShort));
3020 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayChar));
3021 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayByte));
3022 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayDouble));
3023 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayFloat));
3024 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayObject));
3025 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayBoolean));
3026 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayLong));
3027 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayInt));
3028 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayShort));
3029 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayChar));
3030 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayByte));
3031 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayDouble));
3032 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayFloat));
3033 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayObject));
3034 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayBoolean));
3035 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayLong));
3036 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayInt));
3037 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayShort));
3038 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayChar));
3039 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayByte));
3040 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayDouble));
3041 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayFloat));
3042 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayObject));
3043 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayBoolean));
3044 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayLong));
3045 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayInt));
3046 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayShort));
3047 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayChar));
3048 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayByte));
3049 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayDouble));
3050 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayFloat));
3051 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayObject));
3052 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayBoolean));
3053 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayLong));
3054 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayInt));
3055 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayShort));
3056 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayChar));
3057 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayByte));
3058 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayDouble));
3059 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayFloat));
3060 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayObject));
3061 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayBoolean));
3062 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayLong));
3063 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayInt));
3064 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayShort));
3065 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayChar));
3066 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayByte));
3067 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayDouble));
3068 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayFloat));
3069 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayObject));
3070 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayBoolean));
3071 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayLong));
3072 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayInt));
3073 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayShort));
3074 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayChar));
3075 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayByte));
3076 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayDouble));
3077 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayFloat));
3078 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayObject));
3079 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayBoolean));
3080 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayLong));
3081 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayInt));
3082 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayShort));
3083 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayChar));
3084 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayByte));
3085 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayDouble));
3086 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayFloat));
3087 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayObject));
3088 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayBoolean));
3089 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayLong));
3090 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayInt));
3091 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayShort));
3092 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayChar));
3093 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayByte));
3094 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayDouble));
3095 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayFloat));
3096 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayObject));
3097 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayBoolean));
3098 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayLong));
3099 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayInt));
3100 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayShort));
3101 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayChar));
3102 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayByte));
3103 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayDouble));
3104 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayFloat));
3105 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayObject));
3106 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayBoolean));
3107 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayLong));
3108 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayInt));
3109 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayShort));
3110 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayChar));
3111 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayByte));
3112 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayDouble));
3113 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayFloat));
3114 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayObject));
3115 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayBoolean));
3116 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayLong));
3117 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayInt));
3118 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayShort));
3119 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayChar));
3120 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayByte));
3121 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayDouble));
3122 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayFloat));
3123 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayObject));
3124 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayBoolean));
3125 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayLong));
3126 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayInt));
3127 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayShort));
3128 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayChar));
3129 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayByte));
3130 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayDouble));
3131 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayFloat));
3132 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayObject));
3133 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayBoolean));
3134 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayLong));
3135 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayInt));
3136 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayShort));
3137 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayChar));
3138 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayByte));
3139 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayDouble));
3140 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayFloat));
3141 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayObject));
3142 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayBoolean));
3143 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayLong));
3144 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayInt));
3145 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayShort));
3146 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayChar));
3147 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayByte));
3148 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayDouble));
3149 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayFloat));
3150 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayObject));
3151 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayBoolean));
3152 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayLong));
3153 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayInt));
3154 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayShort));
3155 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayChar));
3156 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayByte));
3157 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayDouble));
3158 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayFloat));
3159 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayObject));
3160 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayBoolean));
3161 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayLong));
3162 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayInt));
3163 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayShort));
3164 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayChar));
3165 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayByte));
3166 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayDouble));
3167 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayFloat));
3168 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayObject));
3169 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayBoolean));
3170 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayLong));
3171 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayInt));
3172 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayShort));
3173 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayChar));
3174 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayByte));
3175 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayDouble));
3176 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayFloat));
3177 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayObject));
3178 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayBoolean));
3179 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayLong));
3180 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayInt));
3181 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayShort));
3182 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayChar));
3183 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayByte));
3184 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayDouble));
3185 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayFloat));
3186 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayObject));
3187 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayBoolean));
3188 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayLong));
3189 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayInt));
3190 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayShort));
3191 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayChar));
3192 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayByte));
3193 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayDouble));
3194 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayFloat));
3195 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayObject));
3196 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayBoolean));
3197 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayLong));
3198 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayInt));
3199 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayShort));
3200 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayChar));
3201 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayByte));
3202 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayDouble));
3203 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayFloat));
3204 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayObject));
3205 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayBoolean));
3206 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayLong));
3207 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayInt));
3208 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayShort));
3209 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayChar));
3210 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayByte));
3211 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayDouble));
3212 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayFloat));
3213 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayObject));
3214 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayBoolean));
3215 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayLong));
3216 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayInt));
3217 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayShort));
3218 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayChar));
3219 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayByte));
3220 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayDouble));
3221 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayFloat));
3222 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayObject));
3223 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayBoolean));
3224 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayLong));
3225 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayInt));
3226 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayShort));
3227 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayChar));
3228 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayByte));
3229 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayDouble));
3230 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayFloat));
3231 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayObject));
3232 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayBoolean));
3233 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayLong));
3234 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayInt));
3235 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayShort));
3236 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayChar));
3237 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayByte));
3238 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayDouble));
3239 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayFloat));
3240 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayObject));
3241 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayBoolean));
3242 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayLong));
3243 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayInt));
3244 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayShort));
3245 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayChar));
3246 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayByte));
3247 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayDouble));
3248 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayFloat));
3249 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayObject));
3250 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayBoolean));
3251 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayLong));
3252 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayInt));
3253 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayShort));
3254 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayChar));
3255 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayByte));
3256 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayDouble));
3257 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayFloat));
3258 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayObject));
3259 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayBoolean));
3260 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayLong));
3261 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayInt));
3262 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayShort));
3263 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayChar));
3264 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayByte));
3265 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayDouble));
3266 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayFloat));
3267 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayObject));
3268 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayBoolean));
3269 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayLong));
3270 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayInt));
3271 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayShort));
3272 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayChar));
3273 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayByte));
3274 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayDouble));
3275 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayFloat));
3276 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayObject));
3277 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayBoolean));
3278 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayLong));
3279 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayInt));
3280 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayShort));
3281 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayChar));
3282 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayByte));
3283 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayDouble));
3284 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayFloat));
3285 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayObject));
3286 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayBoolean));
3287 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayLong));
3288 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayInt));
3289 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayShort));
3290 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayChar));
3291 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayByte));
3292 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayDouble));
3293 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayFloat));
3294 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayObject));
3295 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayBoolean));
3296 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayLong));
3297 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayInt));
3298 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayShort));
3299 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayChar));
3300 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayByte));
3301 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayDouble));
3302 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayFloat));
3303 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayObject));
3304 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayBoolean));
3305 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayLong));
3306 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayInt));
3307 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayShort));
3308 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayChar));
3309 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayByte));
3310 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayDouble));
3311 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayFloat));
3312 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayObject));
3313 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayBoolean));
3314 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayLong));
3315 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayInt));
3316 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayShort));
3317 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayChar));
3318 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayByte));
3319 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayDouble));
3320 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayFloat));
3321 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayObject));
3322 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayBoolean));
3323 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayLong));
3324 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayInt));
3325 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayShort));
3326 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayChar));
3327 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayByte));
3328 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayDouble));
3329 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayFloat));
3330 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayObject));
3331 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayBoolean));
3332 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayLong));
3333 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayInt));
3334 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayShort));
3335 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayChar));
3336 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayByte));
3337 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayDouble));
3338 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayFloat));
3339 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayObject));
3340 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayBoolean));
3341 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayLong));
3342 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayInt));
3343 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayShort));
3344 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayChar));
3345 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayByte));
3346 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayDouble));
3347 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayFloat));
3348 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayObject));
3349 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayBoolean));
3350 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayLong));
3351 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayInt));
3352 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayShort));
3353 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayChar));
3354 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayByte));
3355 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayDouble));
3356 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayFloat));
3357 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayObject));
3358 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayBoolean));
3359 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayLong));
3360 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayInt));
3361 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayShort));
3362 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayChar));
3363 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayByte));
3364 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayDouble));
3365 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayFloat));
3366 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayObject));
3367 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayBoolean));
3368 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayLong));
3369 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayInt));
3370 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayShort));
3371 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayChar));
3372 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayByte));
3373 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayDouble));
3374 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayFloat));
3375 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayObject));
3376 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayBoolean));
3377 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayLong));
3378 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayInt));
3379 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayShort));
3380 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayChar));
3381 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayByte));
3382 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayDouble));
3383 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayFloat));
3384 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayObject));
3385 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayBoolean));
3386 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayLong));
3387 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayInt));
3388 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayShort));
3389 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayChar));
3390 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayByte));
3391 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayDouble));
3392 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayFloat));
3393 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayObject));
3394 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayBoolean));
3395 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayLong));
3396 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayInt));
3397 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayShort));
3398 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayChar));
3399 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayByte));
3400 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayDouble));
3401 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayFloat));
3402 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayObject));
3403 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayBoolean));
3404 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayLong));
3405 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayInt));
3406 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayShort));
3407 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayChar));
3408 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayByte));
3409 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayDouble));
3410 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayFloat));
3411 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayObject));
3412 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayBoolean));
3413 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayLong));
3414 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayInt));
3415 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayShort));
3416 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayChar));
3417 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayByte));
3418 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayDouble));
3419 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayFloat));
3420 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayObject));
3421 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayBoolean));
3422 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayLong));
3423 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayInt));
3424 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayShort));
3425 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayChar));
3426 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayByte));
3427 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayDouble));
3428 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayFloat));
3429 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayObject));
3430 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayBoolean));
3431 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayLong));
3432 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayInt));
3433 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayShort));
3434 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayChar));
3435 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayByte));
3436 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayDouble));
3437 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayFloat));
3438 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayObject));
3439 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayBoolean));
3440 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayLong));
3441 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayInt));
3442 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayShort));
3443 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayChar));
3444 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayByte));
3445 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayDouble));
3446 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayFloat));
3447 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayObject));
3448 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayBoolean));
3449 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayLong));
3450 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayInt));
3451 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayShort));
3452 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayChar));
3453 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayByte));
3454 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayDouble));
3455 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayFloat));
3456 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayObject));
3457 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayBoolean));
3458 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayLong));
3459 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayInt));
3460 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayShort));
3461 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayChar));
3462 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayByte));
3463 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayDouble));
3464 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayFloat));
3465 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayObject));
3466 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayBoolean));
3467 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayLong));
3468 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayInt));
3469 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayShort));
3470 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayChar));
3471 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayByte));
3472 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayDouble));
3473 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayFloat));
3474 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayObject));
3475 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayBoolean));
3476 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayLong));
3477 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayInt));
3478 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayShort));
3479 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayChar));
3480 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayByte));
3481 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayDouble));
3482 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayFloat));
3483 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayObject));
3484 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayBoolean));
3485 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayLong));
3486 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayInt));
3487 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayShort));
3488 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayChar));
3489 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayByte));
3490 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayDouble));
3491 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayFloat));
3492 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayObject));
3493 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayBoolean));
3494 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayLong));
3495 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayInt));
3496 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayShort));
3497 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayChar));
3498 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayByte));
3499 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayDouble));
3500 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayFloat));
3501 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayObject));
3502 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayBoolean));
3503 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayLong));
3504 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayInt));
3505 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayShort));
3506 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayChar));
3507 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayByte));
3508 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayDouble));
3509 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayFloat));
3510 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayObject));
3511 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayBoolean));
3512 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayLong));
3513 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayInt));
3514 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayShort));
3515 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayChar));
3516 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayByte));
3517 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayDouble));
3518 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayFloat));
3519 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayObject));
3520 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayBoolean));
3521 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayLong));
3522 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayInt));
3523 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayShort));
3524 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayChar));
3525 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayByte));
3526 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayDouble));
3527 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayFloat));
3528 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayObject));
3529 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayBoolean));
3530 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayLong));
3531 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayInt));
3532 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayShort));
3533 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayChar));
3534 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayByte));
3535 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayDouble));
3536 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayFloat));
3537 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayObject));
3538 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayBoolean));
3539 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayLong));
3540 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayInt));
3541 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayShort));
3542 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayChar));
3543 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayByte));
3544 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayDouble));
3545 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayFloat));
3546 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayObject));
3547 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayBoolean));
3548 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayLong));
3549 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayInt));
3550 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayShort));
3551 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayChar));
3552 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayByte));
3553 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayDouble));
3554 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayFloat));
3555 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayObject));
3556 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayBoolean));
3557 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayLong));
3558 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayInt));
3559 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayShort));
3560 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayChar));
3561 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayByte));
3562 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayDouble));
3563 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayFloat));
3564 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayObject));
3565 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayBoolean));
3566 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayLong));
3567 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayInt));
3568 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayShort));
3569 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayChar));
3570 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayByte));
3571 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayDouble));
3572 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayFloat));
3573 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayObject));
3574 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayBoolean));
3575 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayLong));
3576 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayInt));
3577 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayShort));
3578 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayChar));
3579 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayByte));
3580 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayDouble));
3581 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayFloat));
3582 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayObject));
3583 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayBoolean));
3584 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayLong));
3585 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayInt));
3586 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayShort));
3587 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayChar));
3588 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayByte));
3589 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayDouble));
3590 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayFloat));
3591 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayObject));
3592 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayBoolean));
3593 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayLong));
3594 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayInt));
3595 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayShort));
3596 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayChar));
3597 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayByte));
3598 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayDouble));
3599 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayFloat));
3600 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayObject));
3601 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayBoolean));
3602 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayLong));
3603 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayInt));
3604 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayShort));
3605 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayChar));
3606 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayByte));
3607 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayDouble));
3608 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayFloat));
3609 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayObject));
3610 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayBoolean));
3611 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayLong));
3612 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayInt));
3613 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayShort));
3614 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayChar));
3615 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayByte));
3616 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayDouble));
3617 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayFloat));
3618 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayObject));
3619 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayBoolean));
3620 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayLong));
3621 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayInt));
3622 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayShort));
3623 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayChar));
3624 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayByte));
3625 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayDouble));
3626 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayFloat));
3627 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayObject));
3628 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayBoolean));
3629 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayLong));
3630 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayInt));
3631 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayShort));
3632 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayChar));
3633 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayByte));
3634 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayDouble));
3635 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayFloat));
3636 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayObject));
3637 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayBoolean));
3638 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayLong));
3639 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayInt));
3640 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayShort));
3641 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayChar));
3642 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayByte));
3643 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayDouble));
3644 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayFloat));
3645 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayObject));
3646 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayBoolean));
3647 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayLong));
3648 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayInt));
3649 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayShort));
3650 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayChar));
3651 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayByte));
3652 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayDouble));
3653 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayFloat));
3654 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayObject));
3655 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayBoolean));
3656 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayLong));
3657 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayInt));
3658 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayShort));
3659 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayChar));
3660 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayByte));
3661 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayDouble));
3662 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayFloat));
3663 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayObject));
3664 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayBoolean));
3665 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayLong));
3666 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayInt));
3667 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayShort));
3668 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayChar));
3669 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayByte));
3670 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayDouble));
3671 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayFloat));
3672 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayObject));
3673 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayBoolean));
3674 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayLong));
3675 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayInt));
3676 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayShort));
3677 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayChar));
3678 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayByte));
3679 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayDouble));
3680 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayFloat));
3681 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayObject));
3682 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayBoolean));
3683 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayLong));
3684 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayInt));
3685 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayShort));
3686 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayChar));
3687 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayByte));
3688 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayDouble));
3689 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayFloat));
3690 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayObject));
3691 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayBoolean));
3692 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayLong));
3693 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayInt));
3694 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayShort));
3695 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayChar));
3696 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayByte));
3697 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayDouble));
3698 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayFloat));
3699 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayObject));
3700 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayBoolean));
3701 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayLong));
3702 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayInt));
3703 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayShort));
3704 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayChar));
3705 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayByte));
3706 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayDouble));
3707 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayFloat));
3708 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayObject));
3709 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayBoolean));
3710 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayLong));
3711 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayInt));
3712 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayShort));
3713 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayChar));
3714 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayByte));
3715 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayDouble));
3716 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayFloat));
3717 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayObject));
3718 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayBoolean));
3719 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayLong));
3720 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayInt));
3721 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayShort));
3722 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayChar));
3723 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayByte));
3724 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayDouble));
3725 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayFloat));
3726 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayObject));
3727 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayBoolean));
3728 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayLong));
3729 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayInt));
3730 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayShort));
3731 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayChar));
3732 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayByte));
3733 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayDouble));
3734 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayFloat));
3735 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayObject));
3736 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayBoolean));
3737 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayLong));
3738 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayInt));
3739 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayShort));
3740 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayChar));
3741 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayByte));
3742 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayDouble));
3743 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayFloat));
3744 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayObject));
3745 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayBoolean));
3746 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayLong));
3747 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayInt));
3748 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayShort));
3749 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayChar));
3750 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayByte));
3751 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayDouble));
3752 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayFloat));
3753 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayObject));
3754 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayBoolean));
3755 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayLong));
3756 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayInt));
3757 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayShort));
3758 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayChar));
3759 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayByte));
3760 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayDouble));
3761 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayFloat));
3762 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayObject));
3763 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayBoolean));
3764 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayLong));
3765 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayInt));
3766 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayShort));
3767 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayChar));
3768 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayByte));
3769 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayDouble));
3770 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayFloat));
3771 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayObject));
3772 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayBoolean));
3773 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayLong));
3774 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayInt));
3775 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayShort));
3776 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayChar));
3777 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayByte));
3778 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayDouble));
3779 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayFloat));
3780 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayObject));
3781 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayBoolean));
3782 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayLong));
3783 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayInt));
3784 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayShort));
3785 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayChar));
3786 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayByte));
3787 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayDouble));
3788 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayFloat));
3789 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayObject));
3790 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayBoolean));
3791 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayLong));
3792 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayInt));
3793 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayShort));
3794 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayChar));
3795 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayByte));
3796 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayDouble));
3797 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayFloat));
3798 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayObject));
3799 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayBoolean));
3800 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayLong));
3801 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayInt));
3802 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayShort));
3803 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayChar));
3804 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayByte));
3805 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayDouble));
3806 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayFloat));
3807 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayObject));
3808 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayBoolean));
3809 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayLong));
3810 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayInt));
3811 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayShort));
3812 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayChar));
3813 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayByte));
3814 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayDouble));
3815 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayFloat));
3816 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayObject));
3817 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayBoolean));
3818 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayLong));
3819 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayInt));
3820 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayShort));
3821 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayChar));
3822 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayByte));
3823 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayDouble));
3824 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayFloat));
3825 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayObject));
3826 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayBoolean));
3827 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayLong));
3828 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayInt));
3829 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayShort));
3830 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayChar));
3831 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayByte));
3832 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayDouble));
3833 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayFloat));
3834 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayObject));
3835 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayBoolean));
3836 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayLong));
3837 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayInt));
3838 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayShort));
3839 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayChar));
3840 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayByte));
3841 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayDouble));
3842 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayFloat));
3843 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayObject));
3844 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayBoolean));
3845 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayLong));
3846 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayInt));
3847 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayShort));
3848 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayChar));
3849 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayByte));
3850 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayDouble));
3851 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayFloat));
3852 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayObject));
3853 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayBoolean));
3854 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayLong));
3855 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayInt));
3856 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayShort));
3857 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayChar));
3858 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayByte));
3859 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayDouble));
3860 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayFloat));
3861 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayObject));
3862 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayBoolean));
3863 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayLong));
3864 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayInt));
3865 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayShort));
3866 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayChar));
3867 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayByte));
3868 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayDouble));
3869 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayFloat));
3870 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayObject));
3871 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayBoolean));
3872 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayLong));
3873 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayInt));
3874 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayShort));
3875 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayChar));
3876 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayByte));
3877 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayDouble));
3878 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayFloat));
3879 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayObject));
3880 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayBoolean));
3881 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayLong));
3882 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayInt));
3883 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayShort));
3884 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayChar));
3885 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayByte));
3886 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayDouble));
3887 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayFloat));
3888 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayObject));
3889 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayBoolean));
3890 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayLong));
3891 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayInt));
3892 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayShort));
3893 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayChar));
3894 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayByte));
3895 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayDouble));
3896 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayFloat));
3897 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayObject));
3898 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayBoolean));
3899 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayLong));
3900 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayInt));
3901 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayShort));
3902 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayChar));
3903 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayByte));
3904 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayDouble));
3905 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayFloat));
3906 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayObject));
3907 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayBoolean));
3908 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayLong));
3909 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayInt));
3910 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayShort));
3911 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayChar));
3912 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayByte));
3913 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayDouble));
3914 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayFloat));
3915 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayObject));
3916 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayBoolean));
3917 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayLong));
3918 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayInt));
3919 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayShort));
3920 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayChar));
3921 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayByte));
3922 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayDouble));
3923 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayFloat));
3924 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayObject));
3925 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayBoolean));
3926 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayLong));
3927 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayInt));
3928 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayShort));
3929 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayChar));
3930 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayByte));
3931 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayDouble));
3932 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayFloat));
3933 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayObject));
3934 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayBoolean));
3935 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayLong));
3936 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayInt));
3937 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayShort));
3938 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayChar));
3939 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayByte));
3940 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayDouble));
3941 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayFloat));
3942 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayObject));
3943 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayBoolean));
3944 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayLong));
3945 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayInt));
3946 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayShort));
3947 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayChar));
3948 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayByte));
3949 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayDouble));
3950 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayFloat));
3951 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayObject));
3952 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayBoolean));
3953 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayLong));
3954 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayInt));
3955 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayShort));
3956 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayChar));
3957 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayByte));
3958 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayDouble));
3959 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayFloat));
3960 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayObject));
3961 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayBoolean));
3962 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayLong));
3963 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayInt));
3964 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayShort));
3965 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayChar));
3966 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayByte));
3967 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayDouble));
3968 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayFloat));
3969 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayObject));
3970 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayBoolean));
3971 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayLong));
3972 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayInt));
3973 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayShort));
3974 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayChar));
3975 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayByte));
3976 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayDouble));
3977 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayFloat));
3978 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayObject));
3979 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayBoolean));
3980 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayLong));
3981 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayInt));
3982 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayShort));
3983 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayChar));
3984 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayByte));
3985 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayDouble));
3986 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayFloat));
3987 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayObject));
3988 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayBoolean));
3989 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayLong));
3990 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayInt));
3991 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayShort));
3992 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayChar));
3993 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayByte));
3994 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayDouble));
3995 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayFloat));
3996 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayObject));
3997 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayBoolean));
3998 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayLong));
3999 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayInt));
4000 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayShort));
4001 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayChar));
4002 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayByte));
4003 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayDouble));
4004 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayFloat));
4005 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayObject));
4006 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayBoolean));
4007 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayLong));
4008 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayInt));
4009 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayShort));
4010 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayChar));
4011 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayByte));
4012 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayDouble));
4013 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayFloat));
4014 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayObject));
4015 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayBoolean));
4016 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayLong));
4017 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayInt));
4018 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayShort));
4019 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayChar));
4020 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayByte));
4021 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayDouble));
4022 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayFloat));
4023 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayObject));
4024 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayBoolean));
4025 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayLong));
4026 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayInt));
4027 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayShort));
4028 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayChar));
4029 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayByte));
4030 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayDouble));
4031 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayFloat));
4032 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayObject));
4033 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayBoolean));
4034 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayLong));
4035 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayInt));
4036 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayShort));
4037 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayChar));
4038 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayByte));
4039 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayDouble));
4040 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayFloat));
4041 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayObject));
4042 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayBoolean));
4043 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayLong));
4044 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayInt));
4045 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayShort));
4046 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayChar));
4047 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayByte));
4048 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayDouble));
4049 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayFloat));
4050 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayObject));
4051 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayBoolean));
4052 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayLong));
4053 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayInt));
4054 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayShort));
4055 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayChar));
4056 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayByte));
4057 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayDouble));
4058 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayFloat));
4059 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayObject));
4060 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayBoolean));
4061 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayLong));
4062 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayInt));
4063 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayShort));
4064 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayChar));
4065 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayByte));
4066 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayDouble));
4067 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayFloat));
4068 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayObject));
4069 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayBoolean));
4070 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayLong));
4071 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayInt));
4072 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayShort));
4073 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayChar));
4074 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayByte));
4075 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayDouble));
4076 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayFloat));
4077 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayObject));
4078 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayBoolean));
4079 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayLong));
4080 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayInt));
4081 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayShort));
4082 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayChar));
4083 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayByte));
4084 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayDouble));
4085 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayFloat));
4086 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayObject));
4087 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayBoolean));
4088 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayLong));
4089 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayInt));
4090 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayShort));
4091 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayChar));
4092 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayByte));
4093 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayDouble));
4094 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayFloat));
4095 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayObject));
4096 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayBoolean));
4097 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayLong));
4098 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayInt));
4099 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayShort));
4100 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayChar));
4101 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayByte));
4102 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayDouble));
4103 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayFloat));
4104 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayObject));
4105 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayBoolean));
4106 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayLong));
4107 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayInt));
4108 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayShort));
4109 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayChar));
4110 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayByte));
4111 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayDouble));
4112 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayFloat));
4113 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayObject));
4114 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayBoolean));
4115 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayLong));
4116 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayInt));
4117 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayShort));
4118 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayChar));
4119 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayByte));
4120 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayDouble));
4121 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayFloat));
4122 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayObject));
4123 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayBoolean));
4124 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayLong));
4125 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayInt));
4126 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayShort));
4127 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayChar));
4128 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayByte));
4129 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayDouble));
4130 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayFloat));
4131 }
4132
4133 @Test
4134 public void testSameLengthBoolean() {
4135 final boolean[] nullArray = null;
4136 final boolean[] emptyArray = {};
4137 final boolean[] oneArray = {true};
4138 final boolean[] twoArray = {true, false};
4139
4140 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4141 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4142 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4143 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4144
4145 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4146 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4147 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4148 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4149
4150 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4151 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4152 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4153 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4154
4155 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4156 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4157 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4158 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4159 }
4160
4161 @Test
4162 public void testSameLengthByte() {
4163 final byte[] nullArray = null;
4164 final byte[] emptyArray = {};
4165 final byte[] oneArray = {3};
4166 final byte[] twoArray = {4, 6};
4167
4168 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4169 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4170 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4171 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4172
4173 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4174 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4175 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4176 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4177
4178 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4179 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4180 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4181 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4182
4183 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4184 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4185 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4186 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4187 }
4188
4189 @Test
4190 public void testSameLengthChar() {
4191 final char[] nullArray = null;
4192 final char[] emptyArray = {};
4193 final char[] oneArray = {'f'};
4194 final char[] twoArray = {'d', 't'};
4195
4196 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4197 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4198 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4199 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4200
4201 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4202 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4203 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4204 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4205
4206 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4207 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4208 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4209 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4210
4211 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4212 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4213 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4214 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4215 }
4216
4217 @Test
4218 public void testSameLengthDouble() {
4219 final double[] nullArray = null;
4220 final double[] emptyArray = {};
4221 final double[] oneArray = {1.3d};
4222 final double[] twoArray = {4.5d, 6.3d};
4223
4224 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4225 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4226 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4227 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4228
4229 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4230 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4231 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4232 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4233
4234 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4235 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4236 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4237 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4238
4239 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4240 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4241 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4242 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4243 }
4244
4245 @Test
4246 public void testSameLengthFloat() {
4247 final float[] nullArray = null;
4248 final float[] emptyArray = {};
4249 final float[] oneArray = {2.5f};
4250 final float[] twoArray = {6.4f, 5.8f};
4251
4252 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4253 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4254 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4255 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4256
4257 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4258 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4259 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4260 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4261
4262 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4263 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4264 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4265 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4266
4267 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4268 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4269 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4270 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4271 }
4272
4273 @Test
4274 public void testSameLengthInt() {
4275 final int[] nullArray = null;
4276 final int[] emptyArray = {};
4277 final int[] oneArray = {4};
4278 final int[] twoArray = {5, 7};
4279
4280 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4281 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4282 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4283 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4284
4285 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4286 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4287 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4288 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4289
4290 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4291 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4292 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4293 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4294
4295 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4296 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4297 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4298 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4299 }
4300
4301 @Test
4302 public void testSameLengthLong() {
4303 final long[] nullArray = null;
4304 final long[] emptyArray = {};
4305 final long[] oneArray = {0L};
4306 final long[] twoArray = {0L, 76L};
4307
4308 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4309 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4310 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4311 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4312
4313 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4314 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4315 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4316 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4317
4318 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4319 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4320 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4321 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4322
4323 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4324 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4325 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4326 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4327 }
4328
4329 @Test
4330 public void testSameLengthShort() {
4331 final short[] nullArray = null;
4332 final short[] emptyArray = {};
4333 final short[] oneArray = {4};
4334 final short[] twoArray = {6, 8};
4335
4336 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4337 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4338 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4339 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4340
4341 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4342 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4343 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4344 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4345
4346 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4347 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4348 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4349 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4350
4351 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4352 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4353 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4354 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4355 }
4356
4357 @Test
4358 public void testSameType() {
4359 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.isSameType(null, null));
4360 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.isSameType(null, new Object[0]));
4361 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.isSameType(new Object[0], null));
4362
4363 assertTrue(ArrayUtils.isSameType(new Object[0], new Object[0]));
4364 assertFalse(ArrayUtils.isSameType(new String[0], new Object[0]));
4365 assertTrue(ArrayUtils.isSameType(new String[0][0], new String[0][0]));
4366 assertFalse(ArrayUtils.isSameType(new String[0], new String[0][0]));
4367 assertFalse(ArrayUtils.isSameType(new String[0][0], new String[0]));
4368 }
4369
4370 @Test
4371 public void testShiftAllByte() {
4372 final byte[] array = {1, 2, 3, 4};
4373 ArrayUtils.shift(array, 4);
4374 assertEquals(1, array[0]);
4375 assertEquals(2, array[1]);
4376 assertEquals(3, array[2]);
4377 assertEquals(4, array[3]);
4378 ArrayUtils.shift(array, -4);
4379 assertEquals(1, array[0]);
4380 assertEquals(2, array[1]);
4381 assertEquals(3, array[2]);
4382 assertEquals(4, array[3]);
4383 }
4384
4385 @Test
4386 public void testShiftAllChar() {
4387 final char[] array = {1, 2, 3, 4};
4388 ArrayUtils.shift(array, 4);
4389 assertEquals(1, array[0]);
4390 assertEquals(2, array[1]);
4391 assertEquals(3, array[2]);
4392 assertEquals(4, array[3]);
4393 ArrayUtils.shift(array, -4);
4394 assertEquals(1, array[0]);
4395 assertEquals(2, array[1]);
4396 assertEquals(3, array[2]);
4397 assertEquals(4, array[3]);
4398 }
4399
4400 @Test
4401 public void testShiftAllDouble() {
4402 final double[] array = {1, 2, 3, 4};
4403 ArrayUtils.shift(array, 4);
4404 assertEquals(1, array[0]);
4405 assertEquals(2, array[1]);
4406 assertEquals(3, array[2]);
4407 assertEquals(4, array[3]);
4408 ArrayUtils.shift(array, -4);
4409 assertEquals(1, array[0]);
4410 assertEquals(2, array[1]);
4411 assertEquals(3, array[2]);
4412 assertEquals(4, array[3]);
4413 }
4414
4415 @Test
4416 public void testShiftAllFloat() {
4417 final float[] array = {1, 2, 3, 4};
4418 ArrayUtils.shift(array, 4);
4419 assertEquals(1, array[0]);
4420 assertEquals(2, array[1]);
4421 assertEquals(3, array[2]);
4422 assertEquals(4, array[3]);
4423 ArrayUtils.shift(array, -4);
4424 assertEquals(1, array[0]);
4425 assertEquals(2, array[1]);
4426 assertEquals(3, array[2]);
4427 assertEquals(4, array[3]);
4428 }
4429
4430 @Test
4431 public void testShiftAllInt() {
4432 final int[] array = {1, 2, 3, 4};
4433 ArrayUtils.shift(array, 4);
4434 assertEquals(1, array[0]);
4435 assertEquals(2, array[1]);
4436 assertEquals(3, array[2]);
4437 assertEquals(4, array[3]);
4438 ArrayUtils.shift(array, -4);
4439 assertEquals(1, array[0]);
4440 assertEquals(2, array[1]);
4441 assertEquals(3, array[2]);
4442 assertEquals(4, array[3]);
4443 }
4444
4445 @Test
4446 public void testShiftAllLong() {
4447 final long[] array = {1, 2, 3, 4};
4448 ArrayUtils.shift(array, 4);
4449 assertEquals(1, array[0]);
4450 assertEquals(2, array[1]);
4451 assertEquals(3, array[2]);
4452 assertEquals(4, array[3]);
4453 ArrayUtils.shift(array, -4);
4454 assertEquals(1, array[0]);
4455 assertEquals(2, array[1]);
4456 assertEquals(3, array[2]);
4457 assertEquals(4, array[3]);
4458 }
4459
4460 @Test
4461 public void testShiftAllObject() {
4462 final String[] array = {"1", "2", "3", "4"};
4463 ArrayUtils.shift(array, 4);
4464 assertEquals("1", array[0]);
4465 assertEquals("2", array[1]);
4466 assertEquals("3", array[2]);
4467 assertEquals("4", array[3]);
4468 ArrayUtils.shift(array, -4);
4469 assertEquals("1", array[0]);
4470 assertEquals("2", array[1]);
4471 assertEquals("3", array[2]);
4472 assertEquals("4", array[3]);
4473 }
4474
4475 @Test
4476 public void testShiftAllShort() {
4477 final short[] array = {1, 2, 3, 4};
4478 ArrayUtils.shift(array, 4);
4479 assertEquals(1, array[0]);
4480 assertEquals(2, array[1]);
4481 assertEquals(3, array[2]);
4482 assertEquals(4, array[3]);
4483 ArrayUtils.shift(array, -4);
4484 assertEquals(1, array[0]);
4485 assertEquals(2, array[1]);
4486 assertEquals(3, array[2]);
4487 assertEquals(4, array[3]);
4488 }
4489
4490 @Test
4491 public void testShiftBoolean() {
4492 final boolean[] array = {true, true, false, false};
4493
4494 ArrayUtils.shift(array, 1);
4495 assertFalse(array[0]);
4496 assertTrue(array[1]);
4497 assertTrue(array[2]);
4498 assertFalse(array[3]);
4499
4500 ArrayUtils.shift(array, -1);
4501 assertTrue(array[0]);
4502 assertTrue(array[1]);
4503 assertFalse(array[2]);
4504 assertFalse(array[3]);
4505
4506 ArrayUtils.shift(array, 5);
4507 assertFalse(array[0]);
4508 assertTrue(array[1]);
4509 assertTrue(array[2]);
4510 assertFalse(array[3]);
4511
4512 ArrayUtils.shift(array, -3);
4513 assertFalse(array[0]);
4514 assertFalse(array[1]);
4515 assertTrue(array[2]);
4516 assertTrue(array[3]);
4517 }
4518
4519 @Test
4520 public void testShiftByte() {
4521 final byte[] array = {1, 2, 3, 4};
4522 ArrayUtils.shift(array, 1);
4523 assertEquals(4, array[0]);
4524 assertEquals(1, array[1]);
4525 assertEquals(2, array[2]);
4526 assertEquals(3, array[3]);
4527 ArrayUtils.shift(array, -1);
4528 assertEquals(1, array[0]);
4529 assertEquals(2, array[1]);
4530 assertEquals(3, array[2]);
4531 assertEquals(4, array[3]);
4532 ArrayUtils.shift(array, 5);
4533 assertEquals(4, array[0]);
4534 assertEquals(1, array[1]);
4535 assertEquals(2, array[2]);
4536 assertEquals(3, array[3]);
4537 ArrayUtils.shift(array, -3);
4538 assertEquals(3, array[0]);
4539 assertEquals(4, array[1]);
4540 assertEquals(1, array[2]);
4541 assertEquals(2, array[3]);
4542 }
4543
4544 @Test
4545 public void testShiftChar() {
4546 final char[] array = {1, 2, 3, 4};
4547 ArrayUtils.shift(array, 1);
4548 assertEquals(4, array[0]);
4549 assertEquals(1, array[1]);
4550 assertEquals(2, array[2]);
4551 assertEquals(3, array[3]);
4552 ArrayUtils.shift(array, -1);
4553 assertEquals(1, array[0]);
4554 assertEquals(2, array[1]);
4555 assertEquals(3, array[2]);
4556 assertEquals(4, array[3]);
4557 ArrayUtils.shift(array, 5);
4558 assertEquals(4, array[0]);
4559 assertEquals(1, array[1]);
4560 assertEquals(2, array[2]);
4561 assertEquals(3, array[3]);
4562 ArrayUtils.shift(array, -3);
4563 assertEquals(3, array[0]);
4564 assertEquals(4, array[1]);
4565 assertEquals(1, array[2]);
4566 assertEquals(2, array[3]);
4567 }
4568
4569 @Test
4570 public void testShiftDouble() {
4571 final double[] array = {1, 2, 3, 4};
4572 ArrayUtils.shift(array, 1);
4573 assertEquals(4, array[0]);
4574 assertEquals(1, array[1]);
4575 assertEquals(2, array[2]);
4576 assertEquals(3, array[3]);
4577 ArrayUtils.shift(array, -1);
4578 assertEquals(1, array[0]);
4579 assertEquals(2, array[1]);
4580 assertEquals(3, array[2]);
4581 assertEquals(4, array[3]);
4582 ArrayUtils.shift(array, 5);
4583 assertEquals(4, array[0]);
4584 assertEquals(1, array[1]);
4585 assertEquals(2, array[2]);
4586 assertEquals(3, array[3]);
4587 ArrayUtils.shift(array, -3);
4588 assertEquals(3, array[0]);
4589 assertEquals(4, array[1]);
4590 assertEquals(1, array[2]);
4591 assertEquals(2, array[3]);
4592 }
4593
4594 @Test
4595 public void testShiftFloat() {
4596 final float[] array = {1, 2, 3, 4};
4597 ArrayUtils.shift(array, 1);
4598 assertEquals(4, array[0]);
4599 assertEquals(1, array[1]);
4600 assertEquals(2, array[2]);
4601 assertEquals(3, array[3]);
4602 ArrayUtils.shift(array, -1);
4603 assertEquals(1, array[0]);
4604 assertEquals(2, array[1]);
4605 assertEquals(3, array[2]);
4606 assertEquals(4, array[3]);
4607 ArrayUtils.shift(array, 5);
4608 assertEquals(4, array[0]);
4609 assertEquals(1, array[1]);
4610 assertEquals(2, array[2]);
4611 assertEquals(3, array[3]);
4612 ArrayUtils.shift(array, -3);
4613 assertEquals(3, array[0]);
4614 assertEquals(4, array[1]);
4615 assertEquals(1, array[2]);
4616 assertEquals(2, array[3]);
4617 }
4618
4619 @Test
4620 public void testShiftInt() {
4621 final int[] array = {1, 2, 3, 4};
4622 ArrayUtils.shift(array, 1);
4623 assertEquals(4, array[0]);
4624 assertEquals(1, array[1]);
4625 assertEquals(2, array[2]);
4626 assertEquals(3, array[3]);
4627 ArrayUtils.shift(array, -1);
4628 assertEquals(1, array[0]);
4629 assertEquals(2, array[1]);
4630 assertEquals(3, array[2]);
4631 assertEquals(4, array[3]);
4632 ArrayUtils.shift(array, 5);
4633 assertEquals(4, array[0]);
4634 assertEquals(1, array[1]);
4635 assertEquals(2, array[2]);
4636 assertEquals(3, array[3]);
4637 ArrayUtils.shift(array, -3);
4638 assertEquals(3, array[0]);
4639 assertEquals(4, array[1]);
4640 assertEquals(1, array[2]);
4641 assertEquals(2, array[3]);
4642 }
4643
4644 @Test
4645 public void testShiftLong() {
4646 final long[] array = {1, 2, 3, 4};
4647 ArrayUtils.shift(array, 1);
4648 assertEquals(4, array[0]);
4649 assertEquals(1, array[1]);
4650 assertEquals(2, array[2]);
4651 assertEquals(3, array[3]);
4652 ArrayUtils.shift(array, -1);
4653 assertEquals(1, array[0]);
4654 assertEquals(2, array[1]);
4655 assertEquals(3, array[2]);
4656 assertEquals(4, array[3]);
4657 ArrayUtils.shift(array, 5);
4658 assertEquals(4, array[0]);
4659 assertEquals(1, array[1]);
4660 assertEquals(2, array[2]);
4661 assertEquals(3, array[3]);
4662 ArrayUtils.shift(array, -3);
4663 assertEquals(3, array[0]);
4664 assertEquals(4, array[1]);
4665 assertEquals(1, array[2]);
4666 assertEquals(2, array[3]);
4667 }
4668
4669 @Test
4670 public void testShiftNullBoolean() {
4671 final boolean[] array = null;
4672
4673 ArrayUtils.shift(array, 1);
4674 assertNull(array);
4675 }
4676
4677 @Test
4678 public void testShiftNullDouble() {
4679 final double[] array = null;
4680
4681 ArrayUtils.shift(array, 1);
4682 assertNull(array);
4683 }
4684
4685 @Test
4686 public void testShiftNullFloat() {
4687 final float[] array = null;
4688
4689 ArrayUtils.shift(array, 1);
4690 assertNull(array);
4691 }
4692
4693 @Test
4694 public void testShiftNullInt() {
4695 final int[] array = null;
4696
4697 ArrayUtils.shift(array, 1);
4698 assertNull(array);
4699 }
4700
4701 @Test
4702 public void testShiftNullLong() {
4703 final long[] array = null;
4704
4705 ArrayUtils.shift(array, 1);
4706 assertNull(array);
4707 }
4708
4709 @Test
4710 public void testShiftNullObject() {
4711 final String[] array = null;
4712
4713 ArrayUtils.shift(array, 1);
4714 assertNull(array);
4715 }
4716
4717 @Test
4718 public void testShiftNullShort() {
4719 final short[] array = null;
4720
4721 ArrayUtils.shift(array, 1);
4722 assertNull(array);
4723 }
4724
4725 @Test
4726 public void testShiftObject() {
4727 final String[] array = {"1", "2", "3", "4"};
4728 ArrayUtils.shift(array, 1);
4729 assertEquals("4", array[0]);
4730 assertEquals("1", array[1]);
4731 assertEquals("2", array[2]);
4732 assertEquals("3", array[3]);
4733 ArrayUtils.shift(array, -1);
4734 assertEquals("1", array[0]);
4735 assertEquals("2", array[1]);
4736 assertEquals("3", array[2]);
4737 assertEquals("4", array[3]);
4738 ArrayUtils.shift(array, 5);
4739 assertEquals("4", array[0]);
4740 assertEquals("1", array[1]);
4741 assertEquals("2", array[2]);
4742 assertEquals("3", array[3]);
4743 ArrayUtils.shift(array, -3);
4744 assertEquals("3", array[0]);
4745 assertEquals("4", array[1]);
4746 assertEquals("1", array[2]);
4747 assertEquals("2", array[3]);
4748 }
4749
4750 @Test
4751 public void testShiftRangeByte() {
4752 final byte[] array = {1, 2, 3, 4, 5};
4753 ArrayUtils.shift(array, 1, 3, 1);
4754 assertEquals(1, array[0]);
4755 assertEquals(3, array[1]);
4756 assertEquals(2, array[2]);
4757 assertEquals(4, array[3]);
4758 assertEquals(5, array[4]);
4759 ArrayUtils.shift(array, 1, 4, 2);
4760 assertEquals(1, array[0]);
4761 assertEquals(2, array[1]);
4762 assertEquals(4, array[2]);
4763 assertEquals(3, array[3]);
4764 assertEquals(5, array[4]);
4765 }
4766
4767 @Test
4768 public void testShiftRangeChar() {
4769 final char[] array = {1, 2, 3, 4, 5};
4770 ArrayUtils.shift(array, 1, 3, 1);
4771 assertEquals(1, array[0]);
4772 assertEquals(3, array[1]);
4773 assertEquals(2, array[2]);
4774 assertEquals(4, array[3]);
4775 assertEquals(5, array[4]);
4776 ArrayUtils.shift(array, 1, 4, 2);
4777 assertEquals(1, array[0]);
4778 assertEquals(2, array[1]);
4779 assertEquals(4, array[2]);
4780 assertEquals(3, array[3]);
4781 assertEquals(5, array[4]);
4782 }
4783
4784 @Test
4785 public void testShiftRangeDouble() {
4786 final double[] array = {1, 2, 3, 4, 5};
4787 ArrayUtils.shift(array, 1, 3, 1);
4788 assertEquals(1, array[0]);
4789 assertEquals(3, array[1]);
4790 assertEquals(2, array[2]);
4791 assertEquals(4, array[3]);
4792 assertEquals(5, array[4]);
4793 ArrayUtils.shift(array, 1, 4, 2);
4794 assertEquals(1, array[0]);
4795 assertEquals(2, array[1]);
4796 assertEquals(4, array[2]);
4797 assertEquals(3, array[3]);
4798 assertEquals(5, array[4]);
4799 }
4800
4801 @Test
4802 public void testShiftRangeFloat() {
4803 final float[] array = {1, 2, 3, 4, 5};
4804 ArrayUtils.shift(array, 1, 3, 1);
4805 assertEquals(1, array[0]);
4806 assertEquals(3, array[1]);
4807 assertEquals(2, array[2]);
4808 assertEquals(4, array[3]);
4809 assertEquals(5, array[4]);
4810 ArrayUtils.shift(array, 1, 4, 2);
4811 assertEquals(1, array[0]);
4812 assertEquals(2, array[1]);
4813 assertEquals(4, array[2]);
4814 assertEquals(3, array[3]);
4815 assertEquals(5, array[4]);
4816 }
4817
4818 @Test
4819 public void testShiftRangeInt() {
4820 final int[] array = {1, 2, 3, 4, 5};
4821 ArrayUtils.shift(array, 1, 3, 1);
4822 assertEquals(1, array[0]);
4823 assertEquals(3, array[1]);
4824 assertEquals(2, array[2]);
4825 assertEquals(4, array[3]);
4826 assertEquals(5, array[4]);
4827 ArrayUtils.shift(array, 1, 4, 2);
4828 assertEquals(1, array[0]);
4829 assertEquals(2, array[1]);
4830 assertEquals(4, array[2]);
4831 assertEquals(3, array[3]);
4832 assertEquals(5, array[4]);
4833 }
4834
4835 @Test
4836 public void testShiftRangeLong() {
4837 final long[] array = {1, 2, 3, 4, 5};
4838 ArrayUtils.shift(array, 1, 3, 1);
4839 assertEquals(1, array[0]);
4840 assertEquals(3, array[1]);
4841 assertEquals(2, array[2]);
4842 assertEquals(4, array[3]);
4843 assertEquals(5, array[4]);
4844 ArrayUtils.shift(array, 1, 4, 2);
4845 assertEquals(1, array[0]);
4846 assertEquals(2, array[1]);
4847 assertEquals(4, array[2]);
4848 assertEquals(3, array[3]);
4849 assertEquals(5, array[4]);
4850 }
4851
4852 @Test
4853 public void testShiftRangeNoElemByte() {
4854 final byte[] array = {1, 2, 3, 4};
4855 ArrayUtils.shift(array, 1, 1, 1);
4856 assertEquals(1, array[0]);
4857 assertEquals(2, array[1]);
4858 assertEquals(3, array[2]);
4859 assertEquals(4, array[3]);
4860 }
4861
4862 @Test
4863 public void testShiftRangeNoElemChar() {
4864 final char[] array = {1, 2, 3, 4};
4865 ArrayUtils.shift(array, 1, 1, 1);
4866 assertEquals(1, array[0]);
4867 assertEquals(2, array[1]);
4868 assertEquals(3, array[2]);
4869 assertEquals(4, array[3]);
4870 }
4871
4872 @Test
4873 public void testShiftRangeNoElemDouble() {
4874 final double[] array = {1, 2, 3, 4};
4875 ArrayUtils.shift(array, 1, 1, 1);
4876 assertEquals(1, array[0]);
4877 assertEquals(2, array[1]);
4878 assertEquals(3, array[2]);
4879 assertEquals(4, array[3]);
4880 }
4881
4882 @Test
4883 public void testShiftRangeNoElemFloat() {
4884 final float[] array = {1, 2, 3, 4};
4885 ArrayUtils.shift(array, 1, 1, 1);
4886 assertEquals(1, array[0]);
4887 assertEquals(2, array[1]);
4888 assertEquals(3, array[2]);
4889 assertEquals(4, array[3]);
4890 }
4891
4892 @Test
4893 public void testShiftRangeNoElemInt() {
4894 final int[] array = {1, 2, 3, 4};
4895 ArrayUtils.shift(array, 1, 1, 1);
4896 assertEquals(1, array[0]);
4897 assertEquals(2, array[1]);
4898 assertEquals(3, array[2]);
4899 assertEquals(4, array[3]);
4900 }
4901
4902 @Test
4903 public void testShiftRangeNoElemLong() {
4904 final long[] array = {1, 2, 3, 4};
4905 ArrayUtils.shift(array, 1, 1, 1);
4906 assertEquals(1, array[0]);
4907 assertEquals(2, array[1]);
4908 assertEquals(3, array[2]);
4909 assertEquals(4, array[3]);
4910 }
4911
4912 @Test
4913 public void testShiftRangeNoElemObject() {
4914 final String[] array = {"1", "2", "3", "4"};
4915 ArrayUtils.shift(array, 1, 1, 1);
4916 assertEquals("1", array[0]);
4917 assertEquals("2", array[1]);
4918 assertEquals("3", array[2]);
4919 assertEquals("4", array[3]);
4920 }
4921
4922 @Test
4923 public void testShiftRangeNoElemShort() {
4924 final short[] array = {1, 2, 3, 4};
4925 ArrayUtils.shift(array, 1, 1, 1);
4926 assertEquals(1, array[0]);
4927 assertEquals(2, array[1]);
4928 assertEquals(3, array[2]);
4929 assertEquals(4, array[3]);
4930 }
4931
4932 @Test
4933 public void testShiftRangeNullByte() {
4934 final byte[] array = null;
4935 ArrayUtils.shift(array, 1, 1, 1);
4936 assertNull(array);
4937 }
4938
4939 @Test
4940 public void testShiftRangeNullChar() {
4941 final char[] array = null;
4942 ArrayUtils.shift(array, 1, 1, 1);
4943 assertNull(array);
4944 }
4945
4946 @Test
4947 public void testShiftRangeNullDouble() {
4948 final double[] array = null;
4949 ArrayUtils.shift(array, 1, 1, 1);
4950 assertNull(array);
4951 }
4952
4953 @Test
4954 public void testShiftRangeNullFloat() {
4955 final float[] array = null;
4956 ArrayUtils.shift(array, 1, 1, 1);
4957 assertNull(array);
4958 }
4959
4960 @Test
4961 public void testShiftRangeNullInt() {
4962 final int[] array = null;
4963 ArrayUtils.shift(array, 1, 1, 1);
4964 assertNull(array);
4965 }
4966
4967 @Test
4968 public void testShiftRangeNullLong() {
4969 final long[] array = null;
4970 ArrayUtils.shift(array, 1, 1, 1);
4971 assertNull(array);
4972 }
4973
4974 @Test
4975 public void testShiftRangeNullObject() {
4976 final String[] array = null;
4977 ArrayUtils.shift(array, 1, 1, 1);
4978 assertNull(array);
4979 }
4980
4981 @Test
4982 public void testShiftRangeNullShort() {
4983 final short[] array = null;
4984
4985 ArrayUtils.shift(array, 1, 1, 1);
4986 assertNull(array);
4987 }
4988
4989 @Test
4990 public void testShiftRangeObject() {
4991 final String[] array = {"1", "2", "3", "4", "5"};
4992 ArrayUtils.shift(array, 1, 3, 1);
4993 assertEquals("1", array[0]);
4994 assertEquals("3", array[1]);
4995 assertEquals("2", array[2]);
4996 assertEquals("4", array[3]);
4997 assertEquals("5", array[4]);
4998 ArrayUtils.shift(array, 1, 4, 2);
4999 assertEquals("1", array[0]);
5000 assertEquals("2", array[1]);
5001 assertEquals("4", array[2]);
5002 assertEquals("3", array[3]);
5003 assertEquals("5", array[4]);
5004 }
5005
5006 @Test
5007 public void testShiftRangeShort() {
5008 final short[] array = {1, 2, 3, 4, 5};
5009 ArrayUtils.shift(array, 1, 3, 1);
5010 assertEquals(1, array[0]);
5011 assertEquals(3, array[1]);
5012 assertEquals(2, array[2]);
5013 assertEquals(4, array[3]);
5014 assertEquals(5, array[4]);
5015 ArrayUtils.shift(array, 1, 4, 2);
5016 assertEquals(1, array[0]);
5017 assertEquals(2, array[1]);
5018 assertEquals(4, array[2]);
5019 assertEquals(3, array[3]);
5020 assertEquals(5, array[4]);
5021 }
5022
5023 @Test
5024 public void testShiftShort() {
5025 short[] array = {1, 2, 3, 4};
5026 ArrayUtils.shift(array, 1);
5027 assertEquals(4, array[0]);
5028 assertEquals(1, array[1]);
5029 assertEquals(2, array[2]);
5030 assertEquals(3, array[3]);
5031 ArrayUtils.shift(array, -1);
5032 assertEquals(1, array[0]);
5033 assertEquals(2, array[1]);
5034 assertEquals(3, array[2]);
5035 assertEquals(4, array[3]);
5036 ArrayUtils.shift(array, 5);
5037 assertEquals(4, array[0]);
5038 assertEquals(1, array[1]);
5039 assertEquals(2, array[2]);
5040 assertEquals(3, array[3]);
5041 ArrayUtils.shift(array, -3);
5042 assertEquals(3, array[0]);
5043 assertEquals(4, array[1]);
5044 assertEquals(1, array[2]);
5045 assertEquals(2, array[3]);
5046 array = new short[]{1, 2, 3, 4, 5};
5047 ArrayUtils.shift(array, 2);
5048 assertEquals(4, array[0]);
5049 assertEquals(5, array[1]);
5050 assertEquals(1, array[2]);
5051 assertEquals(2, array[3]);
5052 assertEquals(3, array[4]);
5053 }
5054
5055 @Test
5056 public void testShuffle() {
5057 final String[] array1 = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
5058 final String[] array2 = ArrayUtils.clone(array1);
5059
5060 ArrayUtils.shuffle(array1, new Random(SEED));
5061 assertFalse(Arrays.equals(array1, array2));
5062 for (final String element : array2) {
5063 assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found");
5064 }
5065 }
5066
5067 @Test
5068 public void testShuffleBoolean() {
5069 final boolean[] array1 = {true, false, true, true, false, false, true, false, false, true};
5070 final boolean[] array2 = ArrayUtils.clone(array1);
5071
5072 ArrayUtils.shuffle(array1, new Random(SEED));
5073 assertFalse(Arrays.equals(array1, array2));
5074 assertEquals(5, ArrayUtils.removeAllOccurrences(array1, true).length);
5075 }
5076
5077 @Test
5078 public void testShuffleByte() {
5079 final byte[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
5080 final byte[] array2 = ArrayUtils.clone(array1);
5081
5082 ArrayUtils.shuffle(array1, new Random(SEED));
5083 assertFalse(Arrays.equals(array1, array2));
5084 for (final byte element : array2) {
5085 assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found");
5086 }
5087 }
5088
5089 @Test
5090 public void testShuffleChar() {
5091 final char[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
5092 final char[] array2 = ArrayUtils.clone(array1);
5093
5094 ArrayUtils.shuffle(array1, new Random(SEED));
5095 assertFalse(Arrays.equals(array1, array2));
5096 for (final char element : array2) {
5097 assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found");
5098 }
5099 }
5100
5101 @Test
5102 public void testShuffleDouble() {
5103 final double[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
5104 final double[] array2 = ArrayUtils.clone(array1);
5105
5106 ArrayUtils.shuffle(array1, new Random(SEED));
5107 assertFalse(Arrays.equals(array1, array2));
5108 for (final double element : array2) {
5109 assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found");
5110 }
5111 }
5112
5113 @Test
5114 public void testShuffleFloat() {
5115 final float[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
5116 final float[] array2 = ArrayUtils.clone(array1);
5117
5118 ArrayUtils.shuffle(array1, new Random(SEED));
5119 assertFalse(Arrays.equals(array1, array2));
5120 for (final float element : array2) {
5121 assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found");
5122 }
5123 }
5124
5125 @Test
5126 public void testShuffleInt() {
5127 final int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
5128 final int[] array2 = ArrayUtils.clone(array1);
5129
5130 ArrayUtils.shuffle(array1, new Random(SEED));
5131 assertFalse(Arrays.equals(array1, array2));
5132 for (final int element : array2) {
5133 assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found");
5134 }
5135 }
5136
5137 @Test
5138 public void testShuffleLong() {
5139 final long[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
5140 final long[] array2 = ArrayUtils.clone(array1);
5141
5142 ArrayUtils.shuffle(array1, new Random(SEED));
5143 assertFalse(Arrays.equals(array1, array2));
5144 for (final long element : array2) {
5145 assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found");
5146 }
5147 }
5148
5149 @Test
5150 public void testShuffleShort() {
5151 final short[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
5152 final short[] array2 = ArrayUtils.clone(array1);
5153
5154 ArrayUtils.shuffle(array1, new Random(SEED));
5155 assertFalse(Arrays.equals(array1, array2));
5156 for (final short element : array2) {
5157 assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found");
5158 }
5159 }
5160
5161 @Test
5162 public void testSubarrayBoolean() {
5163 final boolean[] nullArray = null;
5164 final boolean[] array = {true, true, false, true, false, true};
5165 final boolean[] leftSubarray = {true, true, false, true};
5166 final boolean[] midSubarray = {true, false, true, false};
5167 final boolean[] rightSubarray = {false, true, false, true};
5168
5169 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5170 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5171 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5172 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5173 "mid start, length end");
5174
5175 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5176 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2),
5177 "empty array");
5178 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5179 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5180 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5181 "start undershoot, normal end");
5182 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5183 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5184 "normal start, end overshoot");
5185 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5186
5187
5188
5189 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2),
5190 "empty array, object test");
5191 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5192 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5193 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5194 "start overshoot, any end, object test");
5195
5196
5197
5198 assertSame(boolean.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "boolean type");
5199 }
5200
5201 @Test
5202 public void testSubarrayByte() {
5203 final byte[] nullArray = null;
5204 final byte[] array = {10, 11, 12, 13, 14, 15};
5205 final byte[] leftSubarray = {10, 11, 12, 13};
5206 final byte[] midSubarray = {11, 12, 13, 14};
5207 final byte[] rightSubarray = {12, 13, 14, 15};
5208
5209 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5210 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5211 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5212 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5213 "mid start, length end");
5214
5215 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5216 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2),
5217 "empty array");
5218 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5219 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5220 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5221 "start undershoot, normal end");
5222 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5223 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5224 "normal start, end overshoot");
5225 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5226
5227
5228
5229 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2),
5230 "empty array, object test");
5231 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5232 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5233 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5234 "start overshoot, any end, object test");
5235
5236
5237
5238 assertSame(byte.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "byte type");
5239 }
5240
5241 @Test
5242 public void testSubarrayDouble() {
5243 final double[] nullArray = null;
5244 final double[] array = {10.123, 11.234, 12.345, 13.456, 14.567, 15.678};
5245 final double[] leftSubarray = {10.123, 11.234, 12.345, 13.456};
5246 final double[] midSubarray = {11.234, 12.345, 13.456, 14.567};
5247 final double[] rightSubarray = {12.345, 13.456, 14.567, 15.678};
5248
5249 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5250 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5251 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5252 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5253 "mid start, length end");
5254
5255 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5256 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2),
5257 "empty array");
5258 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5259 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5260 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5261 "start undershoot, normal end");
5262 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5263 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5264 "normal start, end overshoot");
5265 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5266
5267
5268
5269 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2),
5270 "empty array, object test");
5271 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5272 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5273 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5274 "start overshoot, any end, object test");
5275
5276
5277
5278 assertSame(double.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "double type");
5279 }
5280
5281 @Test
5282 public void testSubarrayFloat() {
5283 final float[] nullArray = null;
5284 final float[] array = {10, 11, 12, 13, 14, 15};
5285 final float[] leftSubarray = {10, 11, 12, 13};
5286 final float[] midSubarray = {11, 12, 13, 14};
5287 final float[] rightSubarray = {12, 13, 14, 15};
5288
5289 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5290 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5291 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5292 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5293 "mid start, length end");
5294
5295 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5296 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2),
5297 "empty array");
5298 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5299 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5300 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5301 "start undershoot, normal end");
5302 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5303 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5304 "normal start, end overshoot");
5305 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5306
5307
5308
5309 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2),
5310 "empty array, object test");
5311 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5312 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5313 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5314 "start overshoot, any end, object test");
5315
5316
5317
5318 assertSame(float.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "float type");
5319 }
5320
5321 @Test
5322 public void testSubarrayInt() {
5323 final int[] nullArray = null;
5324 final int[] array = {10, 11, 12, 13, 14, 15};
5325 final int[] leftSubarray = {10, 11, 12, 13};
5326 final int[] midSubarray = {11, 12, 13, 14};
5327 final int[] rightSubarray = {12, 13, 14, 15};
5328
5329 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5330
5331 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5332
5333 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5334
5335 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5336 "mid start, length end");
5337
5338 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5339
5340 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), "empty array");
5341
5342 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5343
5344 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5345
5346 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5347 "start undershoot, normal end");
5348
5349 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5350
5351 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5352 "normal start, end overshoot");
5353
5354 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5355
5356
5357
5358 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2),
5359 "empty array, object test");
5360
5361 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5362
5363 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5364
5365 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5366 "start overshoot, any end, object test");
5367
5368
5369
5370 assertSame(int.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "int type");
5371 }
5372
5373 @Test
5374 public void testSubarrayLong() {
5375 final long[] nullArray = null;
5376 final long[] array = {999910, 999911, 999912, 999913, 999914, 999915};
5377 final long[] leftSubarray = {999910, 999911, 999912, 999913};
5378 final long[] midSubarray = {999911, 999912, 999913, 999914};
5379 final long[] rightSubarray = {999912, 999913, 999914, 999915};
5380
5381 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5382
5383 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5384
5385 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5386
5387 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5388 "mid start, length end");
5389
5390 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5391
5392 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2),
5393 "empty array");
5394
5395 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5396
5397 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5398
5399 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5400 "start undershoot, normal end");
5401
5402 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5403
5404 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5405 "normal start, end overshoot");
5406
5407 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5408
5409
5410
5411 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2),
5412 "empty array, object test");
5413
5414 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5415
5416 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5417
5418 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5419 "start overshoot, any end, object test");
5420
5421
5422
5423 assertSame(long.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "long type");
5424
5425 }
5426
5427 @Test
5428 public void testSubarrayObject() {
5429 final Object[] nullArray = null;
5430 final Object[] objectArray = {"a", "b", "c", "d", "e", "f"};
5431
5432 assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4)), "0 start, mid end");
5433 assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length)),
5434 "0 start, length end");
5435 assertEquals("bcd", StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4)), "mid start, mid end");
5436 assertEquals("bcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length)),
5437 "mid start, length end");
5438
5439 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5440 assertEquals("", StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2)), "empty array");
5441 assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2)), "start > end");
5442 assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3)), "start == end");
5443 assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4)), "start undershoot, normal end");
5444 assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4)), "start overshoot, any end");
5445 assertEquals("cdef", StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33)), "normal start, end overshoot");
5446 assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12)),
5447 "start undershoot, end overshoot");
5448
5449
5450 final Date[] dateArray = {new java.sql.Date(new Date().getTime()),
5451 new Date(), new Date(), new Date(), new Date()};
5452
5453 assertSame(Object.class, ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType(), "Object type");
5454 assertSame(Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(),
5455 "java.util.Date type");
5456 assertNotSame(java.sql.Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(),
5457 "java.sql.Date type");
5458 assertThrows(ClassCastException.class,
5459 () -> java.sql.Date[].class.cast(ArrayUtils.subarray(dateArray, 1, 3)),
5460 "Invalid downcast");
5461 }
5462
5463 @Test
5464 public void testSubarrayShort() {
5465 final short[] nullArray = null;
5466 final short[] array = {10, 11, 12, 13, 14, 15};
5467 final short[] leftSubarray = {10, 11, 12, 13};
5468 final short[] midSubarray = {11, 12, 13, 14};
5469 final short[] rightSubarray = {12, 13, 14, 15};
5470
5471 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5472 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5473 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5474 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5475 "mid start, length end");
5476
5477 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5478 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2),
5479 "empty array");
5480 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5481 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5482 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5483 "start undershoot, normal end");
5484 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5485 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5486 "normal start, end overshoot");
5487 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5488
5489
5490
5491 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2),
5492 "empty array, object test");
5493 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5494 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5495 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5496 "start overshoot, any end, object test");
5497
5498
5499
5500 assertSame(short.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "short type");
5501 }
5502
5503 @Test
5504 public void testSubarrChar() {
5505 final char[] nullArray = null;
5506 final char[] array = { 'a', 'b', 'c', 'd', 'e', 'f' };
5507 final char[] leftSubarray = { 'a', 'b', 'c', 'd' };
5508 final char[] midSubarray = { 'b', 'c', 'd', 'e' };
5509 final char[] rightSubarray = { 'c', 'd', 'e', 'f' };
5510
5511 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5512 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5513 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5514 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
5515
5516 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5517 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), "empty array");
5518 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5519 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5520 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
5521 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5522 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
5523 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5524
5525
5526
5527 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), "empty array, object test");
5528 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5529 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5530 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
5531
5532
5533
5534 assertSame(char.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "char type");
5535 }
5536
5537 @Test
5538 public void testSwapBoolean() {
5539 final boolean[] array = { true, false, false };
5540 ArrayUtils.swap(array, 0, 2);
5541 assertFalse(array[0]);
5542 assertFalse(array[1]);
5543 assertTrue(array[2]);
5544 }
5545
5546 @Test
5547 public void testSwapBooleanRange() {
5548 boolean[] array = { false, false, true, true };
5549 ArrayUtils.swap(array, 0, 2, 2);
5550 assertTrue(array[0]);
5551 assertTrue(array[1]);
5552 assertFalse(array[2]);
5553 assertFalse(array[3]);
5554
5555 array = new boolean[] { false, true, false };
5556 ArrayUtils.swap(array, 0, 3);
5557 assertFalse(array[0]);
5558 assertTrue(array[1]);
5559 assertFalse(array[2]);
5560
5561 array = new boolean[] { true, true, false };
5562 ArrayUtils.swap(array, 0, 2, 2);
5563 assertFalse(array[0]);
5564 assertTrue(array[1]);
5565 assertTrue(array[2]);
5566
5567 array = new boolean[] { true, true, false };
5568 ArrayUtils.swap(array, -1, 2, 2);
5569 assertFalse(array[0]);
5570 assertTrue(array[1]);
5571 assertTrue(array[2]);
5572
5573 array = new boolean[] { true, true, false };
5574 ArrayUtils.swap(array, 0, -1, 2);
5575 assertTrue(array[0]);
5576 assertTrue(array[1]);
5577 assertFalse(array[2]);
5578
5579 array = new boolean[] { true, true, false };
5580 ArrayUtils.swap(array, -1, -1, 2);
5581 assertTrue(array[0]);
5582 assertTrue(array[1]);
5583 assertFalse(array[2]);
5584 }
5585
5586 @Test
5587 public void testSwapByte() {
5588 final byte[] array = { 1, 2, 3 };
5589 ArrayUtils.swap(array, 0, 2);
5590 assertEquals(3, array[0]);
5591 assertEquals(2, array[1]);
5592 assertEquals(1, array[2]);
5593 }
5594
5595 @Test
5596 public void testSwapByteRange() {
5597 byte[] array = { 1, 2, 3, 4 };
5598 ArrayUtils.swap(array, 0, 2, 2);
5599 assertEquals(3, array[0]);
5600 assertEquals(4, array[1]);
5601 assertEquals(1, array[2]);
5602 assertEquals(2, array[3]);
5603
5604 array = new byte[] { 1, 2, 3 };
5605 ArrayUtils.swap(array, 0, 3);
5606 assertEquals(1, array[0]);
5607 assertEquals(2, array[1]);
5608 assertEquals(3, array[2]);
5609
5610 array = new byte[] { 1, 2, 3 };
5611 ArrayUtils.swap(array, 0, 2, 2);
5612 assertEquals(3, array[0]);
5613 assertEquals(2, array[1]);
5614 assertEquals(1, array[2]);
5615
5616 array = new byte[] { 1, 2, 3 };
5617 ArrayUtils.swap(array, -1, 2, 2);
5618 assertEquals(3, array[0]);
5619 assertEquals(2, array[1]);
5620 assertEquals(1, array[2]);
5621
5622 array = new byte[] { 1, 2, 3 };
5623 ArrayUtils.swap(array, 0, -1, 2);
5624 assertEquals(1, array[0]);
5625 assertEquals(2, array[1]);
5626 assertEquals(3, array[2]);
5627
5628 array = new byte[] { 1, 2, 3 };
5629 ArrayUtils.swap(array, -1, -1, 2);
5630 assertEquals(1, array[0]);
5631 assertEquals(2, array[1]);
5632 assertEquals(3, array[2]);
5633 }
5634
5635 @Test
5636 public void testSwapChar() {
5637 char[] array = { 1, 2, 3 };
5638 ArrayUtils.swap(array, 0, 2);
5639 assertArrayEquals(new char[] { 3, 2, 1 }, array);
5640
5641 array = new char[] { 1, 2, 3 };
5642 ArrayUtils.swap(array, 0, 0);
5643 assertArrayEquals(new char[] { 1, 2, 3 }, array);
5644
5645 array = new char[] { 1, 2, 3 };
5646 ArrayUtils.swap(array, 1, 0);
5647 assertArrayEquals(new char[] { 2, 1, 3 }, array);
5648 }
5649
5650 @Test
5651 public void testSwapCharRange() {
5652 char[] array = { 1, 2, 3, 4 };
5653 ArrayUtils.swap(array, 0, 2, 2);
5654 assertEquals(3, array[0]);
5655 assertEquals(4, array[1]);
5656 assertEquals(1, array[2]);
5657 assertEquals(2, array[3]);
5658
5659 array = new char[] { 1, 2, 3 };
5660 ArrayUtils.swap(array, 0, 3);
5661 assertEquals(1, array[0]);
5662 assertEquals(2, array[1]);
5663 assertEquals(3, array[2]);
5664
5665 array = new char[] { 1, 2, 3 };
5666 ArrayUtils.swap(array, 0, 2, 2);
5667 assertEquals(3, array[0]);
5668 assertEquals(2, array[1]);
5669 assertEquals(1, array[2]);
5670
5671 array = new char[] { 1, 2, 3 };
5672 ArrayUtils.swap(array, -1, 2, 2);
5673 assertEquals(3, array[0]);
5674 assertEquals(2, array[1]);
5675 assertEquals(1, array[2]);
5676
5677 array = new char[] { 1, 2, 3 };
5678 ArrayUtils.swap(array, 0, -1, 2);
5679 assertEquals(1, array[0]);
5680 assertEquals(2, array[1]);
5681 assertEquals(3, array[2]);
5682
5683 array = new char[] { 1, 2, 3 };
5684 ArrayUtils.swap(array, -1, -1, 2);
5685 assertEquals(1, array[0]);
5686 assertEquals(2, array[1]);
5687 assertEquals(3, array[2]);
5688 }
5689
5690 @Test
5691 public void testSwapDouble() {
5692 final double[] array = { 1, 2, 3 };
5693 ArrayUtils.swap(array, 0, 2);
5694 assertEquals(3, array[0]);
5695 assertEquals(2, array[1]);
5696 assertEquals(1, array[2]);
5697 }
5698
5699 @Test
5700 public void testSwapDoubleRange() {
5701 double[] array = { 1, 2, 3, 4 };
5702 ArrayUtils.swap(array, 0, 2, 2);
5703 assertEquals(3, array[0]);
5704 assertEquals(4, array[1]);
5705 assertEquals(1, array[2]);
5706 assertEquals(2, array[3]);
5707
5708 array = new double[] { 1, 2, 3 };
5709 ArrayUtils.swap(array, 0, 3);
5710 assertEquals(1, array[0]);
5711 assertEquals(2, array[1]);
5712 assertEquals(3, array[2]);
5713
5714 array = new double[] { 1, 2, 3 };
5715 ArrayUtils.swap(array, 0, 2, 2);
5716 assertEquals(3, array[0]);
5717 assertEquals(2, array[1]);
5718 assertEquals(1, array[2]);
5719
5720 array = new double[] { 1, 2, 3 };
5721 ArrayUtils.swap(array, -1, 2, 2);
5722 assertEquals(3, array[0]);
5723 assertEquals(2, array[1]);
5724 assertEquals(1, array[2]);
5725
5726 array = new double[] { 1, 2, 3 };
5727 ArrayUtils.swap(array, 0, -1, 2);
5728 assertEquals(1, array[0]);
5729 assertEquals(2, array[1]);
5730 assertEquals(3, array[2]);
5731
5732 array = new double[] { 1, 2, 3 };
5733 ArrayUtils.swap(array, -1, -1, 2);
5734 assertEquals(1, array[0]);
5735 assertEquals(2, array[1]);
5736 assertEquals(3, array[2]);
5737 }
5738
5739 @Test
5740 public void testSwapEmptyBooleanArray() {
5741 final boolean[] array = {};
5742 ArrayUtils.swap(array, 0, 2);
5743 assertEquals(0, array.length);
5744 }
5745
5746 @Test
5747 public void testSwapEmptyByteArray() {
5748 final byte[] array = {};
5749 ArrayUtils.swap(array, 0, 2);
5750 assertEquals(0, array.length);
5751 }
5752
5753 @Test
5754 public void testSwapEmptyCharArray() {
5755 final char[] array = {};
5756 ArrayUtils.swap(array, 0, 2);
5757 assertEquals(0, array.length);
5758 }
5759
5760 @Test
5761 public void testSwapEmptyDoubleArray() {
5762 final double[] array = {};
5763 ArrayUtils.swap(array, 0, 2);
5764 assertEquals(0, array.length);
5765 }
5766
5767 @Test
5768 public void testSwapEmptyFloatArray() {
5769 final float[] array = {};
5770 ArrayUtils.swap(array, 0, 2);
5771 assertEquals(0, array.length);
5772 }
5773
5774 @Test
5775 public void testSwapEmptyIntArray() {
5776 final int[] array = {};
5777 ArrayUtils.swap(array, 0, 2);
5778 assertEquals(0, array.length);
5779 }
5780
5781 @Test
5782 public void testSwapEmptyLongArray() {
5783 final long[] array = {};
5784 ArrayUtils.swap(array, 0, 2);
5785 assertEquals(0, array.length);
5786 }
5787
5788 @Test
5789 public void testSwapEmptyObjectArray() {
5790 final String[] array = {};
5791 ArrayUtils.swap(array, 0, 2);
5792 assertEquals(0, array.length);
5793 }
5794
5795 @Test
5796 public void testSwapEmptyShortArray() {
5797 final short[] array = {};
5798 ArrayUtils.swap(array, 0, 2);
5799 assertEquals(0, array.length);
5800 }
5801
5802 @Test
5803 public void testSwapFloat() {
5804 final float[] array = { 1, 2, 3 };
5805 ArrayUtils.swap(array, 0, 2);
5806 assertEquals(3, array[0]);
5807 assertEquals(2, array[1]);
5808 assertEquals(1, array[2]);
5809 }
5810
5811 @Test
5812 public void testSwapFloatRange() {
5813 float[] array = { 1, 2, 3, 4 };
5814 ArrayUtils.swap(array, 0, 2, 2);
5815 assertEquals(3, array[0]);
5816 assertEquals(4, array[1]);
5817 assertEquals(1, array[2]);
5818 assertEquals(2, array[3]);
5819
5820 array = new float[] { 1, 2, 3 };
5821 ArrayUtils.swap(array, 0, 3);
5822 assertEquals(1, array[0]);
5823 assertEquals(2, array[1]);
5824 assertEquals(3, array[2]);
5825
5826 array = new float[] { 1, 2, 3 };
5827 ArrayUtils.swap(array, 0, 2, 2);
5828 assertEquals(3, array[0]);
5829 assertEquals(2, array[1]);
5830 assertEquals(1, array[2]);
5831
5832 array = new float[] { 1, 2, 3 };
5833 ArrayUtils.swap(array, -1, 2, 2);
5834 assertEquals(3, array[0]);
5835 assertEquals(2, array[1]);
5836 assertEquals(1, array[2]);
5837
5838 array = new float[] { 1, 2, 3 };
5839 ArrayUtils.swap(array, 0, -1, 2);
5840 assertEquals(1, array[0]);
5841 assertEquals(2, array[1]);
5842 assertEquals(3, array[2]);
5843
5844 array = new float[] { 1, 2, 3 };
5845 ArrayUtils.swap(array, -1, -1, 2);
5846 assertEquals(1, array[0]);
5847 assertEquals(2, array[1]);
5848 assertEquals(3, array[2]);
5849 }
5850
5851 @Test
5852 public void testSwapInt() {
5853 final int[] array = { 1, 2, 3 };
5854 ArrayUtils.swap(array, 0, 2);
5855 assertEquals(3, array[0]);
5856 assertEquals(2, array[1]);
5857 assertEquals(1, array[2]);
5858 }
5859
5860 @Test
5861 public void testSwapIntExchangedOffsets() {
5862 int[] array;
5863 array = new int[] { 1, 2, 3 };
5864 ArrayUtils.swap(array, 0, 1, 2);
5865 assertArrayEquals(new int[] { 2, 3, 1 }, array);
5866
5867 array = new int[] { 1, 2, 3 };
5868 ArrayUtils.swap(array, 1, 0, 2);
5869 assertArrayEquals(new int[] { 2, 3, 1 }, array);
5870 }
5871
5872 @Test
5873 public void testSwapIntRange() {
5874 int[] array = { 1, 2, 3, 4 };
5875 ArrayUtils.swap(array, 0, 2, 2);
5876 assertEquals(3, array[0]);
5877 assertEquals(4, array[1]);
5878 assertEquals(1, array[2]);
5879 assertEquals(2, array[3]);
5880
5881 array = new int[] { 1, 2, 3 };
5882 ArrayUtils.swap(array, 3, 0);
5883 assertEquals(1, array[0]);
5884 assertEquals(2, array[1]);
5885 assertEquals(3, array[2]);
5886
5887 array = new int[] { 1, 2, 3 };
5888 ArrayUtils.swap(array, 0, 2, 2);
5889 assertEquals(3, array[0]);
5890 assertEquals(2, array[1]);
5891 assertEquals(1, array[2]);
5892
5893 array = new int[] { 1, 2, 3 };
5894 ArrayUtils.swap(array, -1, 2, 2);
5895 assertEquals(3, array[0]);
5896 assertEquals(2, array[1]);
5897 assertEquals(1, array[2]);
5898
5899 array = new int[] { 1, 2, 3 };
5900 ArrayUtils.swap(array, 0, -1, 2);
5901 assertEquals(1, array[0]);
5902 assertEquals(2, array[1]);
5903 assertEquals(3, array[2]);
5904
5905 array = new int[] { 1, 2, 3 };
5906 ArrayUtils.swap(array, -1, -1, 2);
5907 assertEquals(1, array[0]);
5908 assertEquals(2, array[1]);
5909 assertEquals(3, array[2]);
5910 }
5911
5912 @Test
5913 public void testSwapLong() {
5914 final long[] array = { 1, 2, 3 };
5915 ArrayUtils.swap(array, 0, 2);
5916 assertEquals(3, array[0]);
5917 assertEquals(2, array[1]);
5918 assertEquals(1, array[2]);
5919 }
5920
5921 @Test
5922 public void testSwapLongRange() {
5923 long[] array = { 1, 2, 3, 4 };
5924 ArrayUtils.swap(array, 0, 2, 2);
5925 assertEquals(3, array[0]);
5926 assertEquals(4, array[1]);
5927 assertEquals(1, array[2]);
5928 assertEquals(2, array[3]);
5929
5930 array = new long[] { 1, 2, 3 };
5931 ArrayUtils.swap(array, 0, 3);
5932 assertEquals(1, array[0]);
5933 assertEquals(2, array[1]);
5934 assertEquals(3, array[2]);
5935
5936 array = new long[] { 1, 2, 3 };
5937 ArrayUtils.swap(array, 0, 2, 2);
5938 assertEquals(3, array[0]);
5939 assertEquals(2, array[1]);
5940 assertEquals(1, array[2]);
5941
5942 array = new long[] { 1, 2, 3 };
5943 ArrayUtils.swap(array, -1, 2, 2);
5944 assertEquals(3, array[0]);
5945 assertEquals(2, array[1]);
5946 assertEquals(1, array[2]);
5947
5948 array = new long[] { 1, 2, 3 };
5949 ArrayUtils.swap(array, 0, -1, 2);
5950 assertEquals(1, array[0]);
5951 assertEquals(2, array[1]);
5952 assertEquals(3, array[2]);
5953
5954 array = new long[] { 1, 2, 3 };
5955 ArrayUtils.swap(array, -1, -1, 2);
5956 assertEquals(1, array[0]);
5957 assertEquals(2, array[1]);
5958 assertEquals(3, array[2]);
5959 }
5960
5961 @Test
5962 public void testSwapNullBooleanArray() {
5963 final boolean[] array = null;
5964 ArrayUtils.swap(array, 0, 2);
5965 assertNull(array);
5966 }
5967
5968 @Test
5969 public void testSwapNullByteArray() {
5970 final byte[] array = null;
5971 ArrayUtils.swap(array, 0, 2);
5972 assertNull(array);
5973 }
5974
5975 @Test
5976 public void testSwapNullCharArray() {
5977 final char[] array = null;
5978 ArrayUtils.swap(array, 0, 2);
5979 assertNull(array);
5980 }
5981
5982 @Test
5983 public void testSwapNullDoubleArray() {
5984 final double[] array = null;
5985 ArrayUtils.swap(array, 0, 2);
5986 assertNull(array);
5987 }
5988
5989 @Test
5990 public void testSwapNullFloatArray() {
5991 final float[] array = null;
5992 ArrayUtils.swap(array, 0, 2);
5993 assertNull(array);
5994 }
5995
5996 @Test
5997 public void testSwapNullIntArray() {
5998 final int[] array = null;
5999 ArrayUtils.swap(array, 0, 2);
6000 assertNull(array);
6001 }
6002
6003 @Test
6004 public void testSwapNullLongArray() {
6005 final long[] array = null;
6006 ArrayUtils.swap(array, 0, 2);
6007 assertNull(array);
6008 }
6009
6010 @Test
6011 public void testSwapNullObjectArray() {
6012 final String[] array = null;
6013 ArrayUtils.swap(array, 0, 2);
6014 assertNull(array);
6015 }
6016
6017 @Test
6018 public void testSwapNullShortArray() {
6019 final short[] array = null;
6020 ArrayUtils.swap(array, 0, 2);
6021 assertNull(array);
6022 }
6023
6024 @Test
6025 public void testSwapObject() {
6026 final String[] array = { "1", "2", "3" };
6027 ArrayUtils.swap(array, 0, 2);
6028 assertEquals("3", array[0]);
6029 assertEquals("2", array[1]);
6030 assertEquals("1", array[2]);
6031 }
6032
6033 @Test
6034 public void testSwapObjectRange() {
6035 String[] array = { "1", "2", "3", "4" };
6036 ArrayUtils.swap(array, 0, 2, 2);
6037 assertEquals("3", array[0]);
6038 assertEquals("4", array[1]);
6039 assertEquals("1", array[2]);
6040 assertEquals("2", array[3]);
6041
6042 array = new String[] { "1", "2", "3", "4" };
6043 ArrayUtils.swap(array, -1, 2, 3);
6044 assertEquals("3", array[0]);
6045 assertEquals("4", array[1]);
6046 assertEquals("1", array[2]);
6047 assertEquals("2", array[3]);
6048
6049 array = new String[] { "1", "2", "3", "4", "5" };
6050 ArrayUtils.swap(array, -3, 2, 3);
6051 assertEquals("3", array[0]);
6052 assertEquals("4", array[1]);
6053 assertEquals("5", array[2]);
6054 assertEquals("2", array[3]);
6055 assertEquals("1", array[4]);
6056
6057 array = new String[] { "1", "2", "3", "4", "5" };
6058 ArrayUtils.swap(array, 2, -2, 3);
6059 assertEquals("3", array[0]);
6060 assertEquals("4", array[1]);
6061 assertEquals("5", array[2]);
6062 assertEquals("2", array[3]);
6063 assertEquals("1", array[4]);
6064
6065 array = new String[0];
6066 ArrayUtils.swap(array, 0, 2, 2);
6067 assertEquals(0, array.length);
6068
6069 array = null;
6070 ArrayUtils.swap(array, 0, 2, 2);
6071 assertNull(array);
6072 }
6073
6074 @Test
6075 public void testSwapShort() {
6076 final short[] array = { 1, 2, 3 };
6077 ArrayUtils.swap(array, 0, 2);
6078 assertEquals(3, array[0]);
6079 assertEquals(2, array[1]);
6080 assertEquals(1, array[2]);
6081 }
6082
6083 @Test
6084 public void testSwapShortRange() {
6085 short[] array = { 1, 2, 3, 4 };
6086 ArrayUtils.swap(array, 0, 2, 2);
6087 assertEquals(3, array[0]);
6088 assertEquals(4, array[1]);
6089 assertEquals(1, array[2]);
6090 assertEquals(2, array[3]);
6091
6092 array = new short[] { 1, 2, 3 };
6093 ArrayUtils.swap(array, 3, 0);
6094 assertEquals(1, array[0]);
6095 assertEquals(2, array[1]);
6096 assertEquals(3, array[2]);
6097
6098 array = new short[] { 1, 2, 3 };
6099 ArrayUtils.swap(array, 0, 2, 2);
6100 assertEquals(3, array[0]);
6101 assertEquals(2, array[1]);
6102 assertEquals(1, array[2]);
6103
6104 array = new short[] { 1, 2, 3 };
6105 ArrayUtils.swap(array, -1, 2, 2);
6106 assertEquals(3, array[0]);
6107 assertEquals(2, array[1]);
6108 assertEquals(1, array[2]);
6109
6110 array = new short[] { 1, 2, 3 };
6111 ArrayUtils.swap(array, 0, -1, 2);
6112 assertEquals(1, array[0]);
6113 assertEquals(2, array[1]);
6114 assertEquals(3, array[2]);
6115
6116 array = new short[] { 1, 2, 3 };
6117 ArrayUtils.swap(array, -1, -1, 2);
6118 assertEquals(1, array[0]);
6119 assertEquals(2, array[1]);
6120 assertEquals(3, array[2]);
6121 }
6122
6123 @Test
6124 public void testTextIndexesOfInt() {
6125 int[] array = null;
6126 final BitSet emptySet = new BitSet();
6127 final BitSet testSet = new BitSet();
6128 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0));
6129 array = new int[] { 0, 1, 2, 3, 0 };
6130 testSet.set(0);
6131 testSet.set(4);
6132 assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
6133 testSet.clear();
6134 testSet.set(1);
6135 assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
6136 testSet.clear();
6137 testSet.set(2);
6138 assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
6139 testSet.clear();
6140 testSet.set(3);
6141 assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
6142 assertEquals(emptySet, ArrayUtils.indexesOf(array, 99));
6143 }
6144
6145 @Test
6146 public void testToMap() {
6147 Map<?, ?> map = ArrayUtils.toMap(new String[][] { { "foo", "bar" }, { "hello", "world" } });
6148
6149 assertEquals("bar", map.get("foo"));
6150 assertEquals("world", map.get("hello"));
6151
6152 assertNull(ArrayUtils.toMap(null));
6153 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.toMap(new String[][] { { "foo", "bar" }, { "short" } }));
6154 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.toMap(new Object[] { new Object[] { "foo", "bar" }, "illegal type" }));
6155 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.toMap(new Object[] { new Object[] { "foo", "bar" }, null }));
6156
6157 map = ArrayUtils.toMap(new Object[] { new Map.Entry<Object, Object>() {
6158 @Override
6159 public boolean equals(final Object o) {
6160 throw new UnsupportedOperationException();
6161 }
6162
6163 @Override
6164 public Object getKey() {
6165 return "foo";
6166 }
6167
6168 @Override
6169 public Object getValue() {
6170 return "bar";
6171 }
6172
6173 @Override
6174 public int hashCode() {
6175 throw new UnsupportedOperationException();
6176 }
6177
6178 @Override
6179 public Object setValue(final Object value) {
6180 throw new UnsupportedOperationException();
6181 }
6182 } });
6183 assertEquals("bar", map.get("foo"));
6184
6185
6186 assertEquals(Collections.emptyMap(), ArrayUtils.toMap(new Object[0]));
6187
6188
6189 map = ArrayUtils.toMap(new Object[][] { { null, null }, { null, null } });
6190 assertEquals(Collections.singletonMap(null, null), map);
6191
6192
6193 map = ArrayUtils.toMap(new Object[][] { { "key", "value2" }, { "key", "value1" } });
6194 assertEquals(Collections.singletonMap("key", "value1"), map);
6195 }
6196
6197 @Test
6198 public void testToObject_boolean() {
6199 final boolean[] b = null;
6200 assertArrayEquals(null, ArrayUtils.toObject(b));
6201 assertSame(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.toObject(new boolean[0]));
6202 assertArrayEquals(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, ArrayUtils.toObject(new boolean[]{true, false, true}));
6203 }
6204
6205 @Test
6206 public void testToObject_byte() {
6207 final byte[] b = null;
6208 assertArrayEquals(null, ArrayUtils.toObject(b));
6209
6210 assertSame(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY,
6211 ArrayUtils.toObject(new byte[0]));
6212
6213 assertArrayEquals(new Byte[]{Byte.valueOf(Byte.MIN_VALUE),
6214 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)}, ArrayUtils.toObject(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE,
6215 (byte) 9999999}));
6216 }
6217
6218 @Test
6219 public void testToObject_char() {
6220 final char[] b = null;
6221 assertArrayEquals(null, ArrayUtils.toObject(b));
6222
6223 assertSame(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY,
6224 ArrayUtils.toObject(new char[0]));
6225
6226 assertArrayEquals(new Character[]{Character.valueOf(Character.MIN_VALUE),
6227 Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')}, ArrayUtils.toObject(new char[]{Character.MIN_VALUE, Character.MAX_VALUE,
6228 '0'}));
6229 }
6230
6231 @Test
6232 public void testToObject_double() {
6233 final double[] b = null;
6234 assertArrayEquals(null, ArrayUtils.toObject(b));
6235
6236 assertSame(
6237 ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY,
6238 ArrayUtils.toObject(new double[0]));
6239
6240 assertArrayEquals(new Double[]{
6241 Double.valueOf(Double.MIN_VALUE),
6242 Double.valueOf(Double.MAX_VALUE),
6243 Double.valueOf(9999999)}, ArrayUtils.toObject(
6244 new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}));
6245 }
6246
6247 @Test
6248 public void testToObject_float() {
6249 final float[] b = null;
6250 assertArrayEquals(null, ArrayUtils.toObject(b));
6251
6252 assertSame(
6253 ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY,
6254 ArrayUtils.toObject(new float[0]));
6255
6256 assertArrayEquals(new Float[]{
6257 Float.valueOf(Float.MIN_VALUE),
6258 Float.valueOf(Float.MAX_VALUE),
6259 Float.valueOf(9999999)}, ArrayUtils.toObject(
6260 new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}));
6261 }
6262
6263 @Test
6264 public void testToObject_int() {
6265 final int[] b = null;
6266 assertArrayEquals(null, ArrayUtils.toObject(b));
6267
6268 assertSame(
6269 ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY,
6270 ArrayUtils.toObject(new int[0]));
6271
6272 assertArrayEquals(new Integer[]{
6273 Integer.valueOf(Integer.MIN_VALUE),
6274 Integer.valueOf(Integer.MAX_VALUE),
6275 Integer.valueOf(9999999)}, ArrayUtils.toObject(
6276 new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}));
6277 }
6278
6279 @Test
6280 public void testToObject_long() {
6281 final long[] b = null;
6282 assertArrayEquals(null, ArrayUtils.toObject(b));
6283
6284 assertSame(
6285 ArrayUtils.EMPTY_LONG_OBJECT_ARRAY,
6286 ArrayUtils.toObject(new long[0]));
6287
6288 assertArrayEquals(new Long[]{
6289 Long.valueOf(Long.MIN_VALUE),
6290 Long.valueOf(Long.MAX_VALUE),
6291 Long.valueOf(9999999)}, ArrayUtils.toObject(
6292 new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}));
6293 }
6294
6295 @Test
6296 public void testToObject_short() {
6297 final short[] b = null;
6298 assertArrayEquals(null, ArrayUtils.toObject(b));
6299
6300 assertSame(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY,
6301 ArrayUtils.toObject(new short[0]));
6302
6303 assertArrayEquals(new Short[]{Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE),
6304 Short.valueOf((short) 9999999)}, ArrayUtils.toObject(new short[]{Short.MIN_VALUE, Short.MAX_VALUE,
6305 (short) 9999999}));
6306 }
6307
6308
6309 @Test
6310 public void testToPrimitive_boolean() {
6311 final Boolean[] b = null;
6312 assertNull(ArrayUtils.toPrimitive(b));
6313 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0]));
6314 assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}));
6315 assertArrayEquals(new boolean[]{true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null}));
6316 }
6317
6318 @Test
6319 public void testToPrimitive_boolean_boolean() {
6320 assertNull(ArrayUtils.toPrimitive(null, false));
6321 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0], false));
6322 assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, false));
6323 assertArrayEquals(new boolean[]{true, false, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, false));
6324 assertArrayEquals(new boolean[]{true, true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, true));
6325 }
6326
6327
6328 @Test
6329 public void testToPrimitive_byte() {
6330 final Byte[] b = null;
6331 assertNull(ArrayUtils.toPrimitive(b));
6332
6333 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new Byte[0]));
6334
6335 assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE),
6336 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)}));
6337
6338 assertThrows(NullPointerException.class,
6339 () -> ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), null}));
6340 }
6341
6342 @Test
6343 public void testToPrimitive_byte_byte() {
6344 final Byte[] b = null;
6345 assertNull(ArrayUtils.toPrimitive(b, Byte.MIN_VALUE));
6346
6347 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY,
6348 ArrayUtils.toPrimitive(new Byte[0], (byte) 1));
6349
6350 assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE),
6351 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)},
6352 Byte.MIN_VALUE));
6353
6354 assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), null,
6355 Byte.valueOf((byte) 9999999)}, Byte.MAX_VALUE));
6356 }
6357
6358
6359 @Test
6360 public void testToPrimitive_char() {
6361 final Character[] b = null;
6362 assertNull(ArrayUtils.toPrimitive(b));
6363
6364 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0]));
6365
6366 assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE),
6367 Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')}));
6368
6369 assertThrows(NullPointerException.class,
6370 () -> ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), null}));
6371 }
6372
6373 @Test
6374 public void testToPrimitive_char_char() {
6375 final Character[] b = null;
6376 assertNull(ArrayUtils.toPrimitive(b, Character.MIN_VALUE));
6377
6378 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY,
6379 ArrayUtils.toPrimitive(new Character[0], (char) 0));
6380
6381 assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE),
6382 Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')},
6383 Character.MIN_VALUE));
6384
6385 assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), null,
6386 Character.valueOf('0')}, Character.MAX_VALUE));
6387 }
6388
6389
6390 @Test
6391 public void testToPrimitive_double() {
6392 final Double[] b = null;
6393 assertNull(ArrayUtils.toPrimitive(b));
6394
6395 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY,
6396 ArrayUtils.toPrimitive(new Double[0]));
6397
6398 assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE),
6399 Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999)}));
6400
6401 assertThrows(NullPointerException.class,
6402 () -> ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), null}));
6403 }
6404
6405 @Test
6406 public void testToPrimitive_double_double() {
6407 final Double[] l = null;
6408 assertNull(ArrayUtils.toPrimitive(l, Double.MIN_VALUE));
6409
6410 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY,
6411 ArrayUtils.toPrimitive(new Double[0], 1));
6412
6413 assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE),
6414 Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999)}, 1));
6415
6416 assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE),
6417 null, Double.valueOf(9999999)}, Double.MAX_VALUE));
6418 }
6419
6420
6421 @Test
6422 public void testToPrimitive_float() {
6423 final Float[] b = null;
6424 assertNull(ArrayUtils.toPrimitive(b));
6425
6426 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY,
6427 ArrayUtils.toPrimitive(new Float[0]));
6428
6429 assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE),
6430 Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999)}));
6431
6432 assertThrows(NullPointerException.class,
6433 () -> ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), null}));
6434 }
6435
6436 @Test
6437 public void testToPrimitive_float_float() {
6438 final Float[] l = null;
6439 assertNull(ArrayUtils.toPrimitive(l, Float.MIN_VALUE));
6440
6441 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY,
6442 ArrayUtils.toPrimitive(new Float[0], 1));
6443
6444 assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE),
6445 Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999)}, 1));
6446
6447 assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE),
6448 null, Float.valueOf(9999999)}, Float.MAX_VALUE));
6449 }
6450
6451
6452 @Test
6453 public void testToPrimitive_int() {
6454 final Integer[] b = null;
6455 assertNull(ArrayUtils.toPrimitive(b));
6456 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new Integer[0]));
6457 assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE),
6458 Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999)}));
6459
6460 assertThrows(NullPointerException.class,
6461 () -> ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), null}));
6462 }
6463
6464 @Test
6465 public void testToPrimitive_int_int() {
6466 final Long[] l = null;
6467 assertNull(ArrayUtils.toPrimitive(l, Integer.MIN_VALUE));
6468 assertSame(ArrayUtils.EMPTY_INT_ARRAY,
6469 ArrayUtils.toPrimitive(new Integer[0], 1));
6470 assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE),
6471 Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999)}, 1));
6472 assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE),
6473 null, Integer.valueOf(9999999)}, Integer.MAX_VALUE));
6474 }
6475
6476 @Test
6477 public void testToPrimitive_intNull() {
6478 final Integer[] iArray = null;
6479 assertNull(ArrayUtils.toPrimitive(iArray, Integer.MIN_VALUE));
6480 }
6481
6482
6483 @Test
6484 public void testToPrimitive_long() {
6485 final Long[] b = null;
6486 assertNull(ArrayUtils.toPrimitive(b));
6487
6488 assertSame(ArrayUtils.EMPTY_LONG_ARRAY,
6489 ArrayUtils.toPrimitive(new Long[0]));
6490
6491 assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE),
6492 Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999)}));
6493
6494 assertThrows(NullPointerException.class,
6495 () -> ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), null}));
6496 }
6497
6498 @Test
6499 public void testToPrimitive_long_long() {
6500 final Long[] l = null;
6501 assertNull(ArrayUtils.toPrimitive(l, Long.MIN_VALUE));
6502
6503 assertSame(ArrayUtils.EMPTY_LONG_ARRAY,
6504 ArrayUtils.toPrimitive(new Long[0], 1));
6505
6506 assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE),
6507 Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999)}, 1));
6508
6509 assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE),
6510 null, Long.valueOf(9999999)}, Long.MAX_VALUE));
6511 }
6512
6513
6514 @Test
6515 public void testToPrimitive_short() {
6516 final Short[] b = null;
6517 assertNull(ArrayUtils.toPrimitive(b));
6518
6519 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0]));
6520
6521 assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE),
6522 Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999)}));
6523
6524 assertThrows(NullPointerException.class,
6525 () -> ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), null}));
6526 }
6527
6528 @Test
6529 public void testToPrimitive_short_short() {
6530 final Short[] s = null;
6531 assertNull(ArrayUtils.toPrimitive(s, Short.MIN_VALUE));
6532
6533 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0],
6534 Short.MIN_VALUE));
6535
6536 assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE),
6537 Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999)}, Short.MIN_VALUE));
6538
6539 assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), null,
6540 Short.valueOf((short) 9999999)}, Short.MAX_VALUE));
6541 }
6542
6543 @Test
6544 public void testToString() {
6545 assertEquals("{}", ArrayUtils.toString(null));
6546 assertEquals("{}", ArrayUtils.toString(new Object[0]));
6547 assertEquals("{}", ArrayUtils.toString(new String[0]));
6548 assertEquals("{<null>}", ArrayUtils.toString(new String[]{null}));
6549 assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"}));
6550
6551 assertEquals("<empty>", ArrayUtils.toString(null, "<empty>"));
6552 assertEquals("{}", ArrayUtils.toString(new Object[0], "<empty>"));
6553 assertEquals("{}", ArrayUtils.toString(new String[0], "<empty>"));
6554 assertEquals("{<null>}", ArrayUtils.toString(new String[]{null}, "<empty>"));
6555 assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"}, "<empty>"));
6556 }
6557
6558 @Test
6559 public void testToStringArray_array() {
6560 assertNull(ArrayUtils.toStringArray(null));
6561
6562 assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0]));
6563
6564 final Object[] array = {1, 2, 3, "array", "test"};
6565 assertArrayEquals(new String[]{"1", "2", "3", "array", "test"}, ArrayUtils.toStringArray(array));
6566
6567 assertThrows(NullPointerException.class, () -> ArrayUtils.toStringArray(new Object[]{null}));
6568 }
6569
6570 @Test
6571 public void testToStringArray_array_string() {
6572 assertNull(ArrayUtils.toStringArray(null, ""));
6573
6574 assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0], ""));
6575
6576 final Object[] array = {1, null, "test"};
6577 assertArrayEquals(new String[]{"1", "valueForNullElements", "test"},
6578 ArrayUtils.toStringArray(array, "valueForNullElements"));
6579 }
6580 }