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