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