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 testLastIndexOfDoubleInfinity() {
1829 final double[] array = { Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY };
1830 assertEquals(2, ArrayUtils.lastIndexOf(array, Double.POSITIVE_INFINITY));
1831 assertEquals(3, ArrayUtils.lastIndexOf(array, Double.NEGATIVE_INFINITY));
1832 assertEquals(0, ArrayUtils.lastIndexOf(array, Double.POSITIVE_INFINITY, 1));
1833 assertEquals(1, ArrayUtils.lastIndexOf(array, Double.NEGATIVE_INFINITY, 2));
1834 assertEquals(2, ArrayUtils.lastIndexOf(array, Double.POSITIVE_INFINITY, array.length, (double) 0));
1835 assertEquals(1, ArrayUtils.lastIndexOf(array, Double.NEGATIVE_INFINITY, 2, (double) 0));
1836 }
1837
1838 @Test
1839 void testLastIndexOfDoubleNaN() {
1840 final double[] array = { Double.NaN, Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY };
1841 assertEquals(2, ArrayUtils.lastIndexOf(array, Double.NaN));
1842 assertEquals(2, ArrayUtils.lastIndexOf(array, Double.NaN, (double) 0));
1843 assertEquals(0, ArrayUtils.lastIndexOf(array, Double.NaN, 1));
1844 assertEquals(0, ArrayUtils.lastIndexOf(array, Double.NaN, 1, (double) 0));
1845 assertEquals(-1, ArrayUtils.lastIndexOf(array, Double.NaN, -1));
1846 }
1847
1848 @Test
1849 void testLastIndexOfDoubleTolerance() {
1850 double[] array = null;
1851 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
1852 array = new double[0];
1853 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
1854 array = new double[]{0, 1, 2, 3, 0};
1855 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 0.3));
1856 assertEquals(2, ArrayUtils.lastIndexOf(array, 2.2, 0.35));
1857 assertEquals(3, ArrayUtils.lastIndexOf(array, 4.15, 2.0));
1858 assertEquals(1, ArrayUtils.lastIndexOf(array, 1.00001324, 0.0001));
1859 }
1860
1861 @Test
1862 void testLastIndexOfDoubleWithStartIndex() {
1863 double[] array = null;
1864 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1865 array = new double[0];
1866 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1867 array = new double[]{0, 1, 2, 3, 0};
1868 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
1869 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
1870 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
1871 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
1872 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
1873 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1874 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
1875 }
1876
1877 @Test
1878 void testLastIndexOfDoubleWithStartIndexTolerance() {
1879 double[] array = null;
1880 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2, 0));
1881 array = new double[0];
1882 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2, 0));
1883 array = new double[]{3};
1884 assertEquals(-1, ArrayUtils.lastIndexOf(array, 1, 0, 0));
1885 array = new double[]{0, 1, 2, 3, 0};
1886 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 99, 0.3));
1887 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 3, 0.3));
1888 assertEquals(2, ArrayUtils.lastIndexOf(array, 2.2, 3, 0.35));
1889 assertEquals(3, ArrayUtils.lastIndexOf(array, 4.15, array.length, 2.0));
1890 assertEquals(1, ArrayUtils.lastIndexOf(array, 1.00001324, array.length, 0.0001));
1891 assertEquals(-1, ArrayUtils.lastIndexOf(array, 4.15, -200, 2.0));
1892 }
1893
1894 @Test
1895 void testLastIndexOfFloat() {
1896 float[] array = null;
1897 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1898 array = new float[0];
1899 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1900 array = new float[]{0, 1, 2, 3, 0};
1901 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
1902 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
1903 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
1904 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
1905 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1906 }
1907
1908 @Test
1909 void testLastIndexOfFloatInfinity() {
1910 final float[] array = { Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY };
1911 assertEquals(2, ArrayUtils.lastIndexOf(array, Float.POSITIVE_INFINITY));
1912 assertEquals(3, ArrayUtils.lastIndexOf(array, Float.NEGATIVE_INFINITY));
1913 assertEquals(0, ArrayUtils.lastIndexOf(array, Float.POSITIVE_INFINITY, 1));
1914 assertEquals(1, ArrayUtils.lastIndexOf(array, Float.NEGATIVE_INFINITY, 2));
1915 }
1916
1917 @Test
1918 void testLastIndexOfFloatNaN() {
1919 final float[] array = { Float.NaN, Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY };
1920 assertEquals(2, ArrayUtils.lastIndexOf(array, Float.NaN));
1921 assertEquals(0, ArrayUtils.lastIndexOf(array, Float.NaN, 1));
1922 assertEquals(-1, ArrayUtils.lastIndexOf(array, Float.NaN, -1));
1923 }
1924
1925 @Test
1926 void testLastIndexOfFloatWithStartIndex() {
1927 float[] array = null;
1928 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1929 array = new float[0];
1930 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1931 array = new float[]{0, 1, 2, 3, 0};
1932 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
1933 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
1934 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
1935 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
1936 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
1937 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1938 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
1939 }
1940
1941 @Test
1942 void testLastIndexOfInt() {
1943 int[] array = null;
1944 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1945 array = new int[]{0, 1, 2, 3, 0};
1946 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
1947 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
1948 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
1949 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
1950 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1951 }
1952
1953 @Test
1954 void testLastIndexOfIntWithStartIndex() {
1955 int[] array = null;
1956 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1957 array = new int[]{0, 1, 2, 3, 0};
1958 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
1959 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
1960 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
1961 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
1962 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
1963 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1964 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
1965 }
1966
1967 @Test
1968 void testLastIndexOfLong() {
1969 long[] array = null;
1970 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
1971 array = new long[]{0, 1, 2, 3, 0};
1972 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
1973 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
1974 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
1975 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
1976 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
1977 }
1978
1979 @Test
1980 void testLastIndexOfLongWithStartIndex() {
1981 long[] array = null;
1982 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
1983 array = new long[]{0, 1, 2, 3, 0};
1984 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
1985 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
1986 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
1987 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
1988 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
1989 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99, 4));
1990 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
1991 }
1992
1993 @Test
1994 void testLastIndexOfShort() {
1995 short[] array = null;
1996 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0));
1997 array = new short[]{0, 1, 2, 3, 0};
1998 assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0));
1999 assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1));
2000 assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2));
2001 assertEquals(3, ArrayUtils.lastIndexOf(array, (short) 3));
2002 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
2003 }
2004
2005 @Test
2006 void testLastIndexOfShortWithStartIndex() {
2007 short[] array = null;
2008 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0, 2));
2009 array = new short[]{0, 1, 2, 3, 0};
2010 assertEquals(0, ArrayUtils.lastIndexOf(array, (short) 0, 2));
2011 assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1, 2));
2012 assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2, 2));
2013 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, 2));
2014 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, -1));
2015 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
2016 assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0, 88));
2017 }
2018
2019 @Test
2020 void testLastIndexOfWithStartIndex() {
2021 final Object[] array = {"0", "1", "2", "3", null, "0"};
2022 assertEquals(-1, ArrayUtils.lastIndexOf(null, null, 2));
2023 assertEquals(-1, ArrayUtils.lastIndexOf(null, "0", 2));
2024 assertEquals(0, ArrayUtils.lastIndexOf(array, "0", 2));
2025 assertEquals(1, ArrayUtils.lastIndexOf(array, "1", 2));
2026 assertEquals(2, ArrayUtils.lastIndexOf(array, "2", 2));
2027 assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", 2));
2028 assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", -1));
2029 assertEquals(4, ArrayUtils.lastIndexOf(array, null, 5));
2030 assertEquals(-1, ArrayUtils.lastIndexOf(array, null, 2));
2031 assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray", 5));
2032
2033 assertEquals(-1, ArrayUtils.lastIndexOf(array, null, -1));
2034 assertEquals(5, ArrayUtils.lastIndexOf(array, "0", 88));
2035 }
2036
2037 @Test
2038 void testMaxArrayLength() {
2039 assertEquals(Integer.MAX_VALUE - 8, ArrayUtils.SAFE_MAX_ARRAY_LENGTH);
2040 assertEquals(Integer.MAX_VALUE - 8, ArrayUtils.SOFT_MAX_ARRAY_LENGTH);
2041 }
2042
2043 @Test
2044 void testNullToEmptyBoolean() {
2045 final boolean[] original = {true, false};
2046 assertEquals(original, ArrayUtils.nullToEmpty(original));
2047 }
2048
2049 @Test
2050 void testNullToEmptyBooleanEmptyArray() {
2051 final boolean[] empty = {};
2052 final boolean[] result = ArrayUtils.nullToEmpty(empty);
2053 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, result);
2054 assertNotSame(empty, result);
2055 }
2056
2057 @Test
2058 void testNullToEmptyBooleanNull() {
2059 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.nullToEmpty((boolean[]) null));
2060 }
2061
2062 @Test
2063 void testNullToEmptyBooleanObject() {
2064 final Boolean[] original = {Boolean.TRUE, Boolean.FALSE};
2065 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2066 }
2067
2068 @Test
2069 void testNullToEmptyBooleanObjectEmptyArray() {
2070 final Boolean[] empty = {};
2071 final Boolean[] result = ArrayUtils.nullToEmpty(empty);
2072 assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, result);
2073 assertNotSame(empty, result);
2074 }
2075
2076 @Test
2077 void testNullToEmptyBooleanObjectNull() {
2078 assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Boolean[]) null));
2079 }
2080
2081 @Test
2082 void testNullToEmptyByte() {
2083 final byte[] original = {0x0F, 0x0E};
2084 assertEquals(original, ArrayUtils.nullToEmpty(original));
2085 }
2086
2087 @Test
2088 void testNullToEmptyByteEmptyArray() {
2089 final byte[] empty = {};
2090 final byte[] result = ArrayUtils.nullToEmpty(empty);
2091 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, result);
2092 assertNotSame(empty, result);
2093 }
2094
2095 @Test
2096 void testNullToEmptyByteNull() {
2097 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.nullToEmpty((byte[]) null));
2098 }
2099
2100 @Test
2101 void testNullToEmptyByteObject() {
2102 final Byte[] original = {0x0F, 0x0E};
2103 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2104 }
2105
2106 @Test
2107 void testNullToEmptyByteObjectEmptyArray() {
2108 final Byte[] empty = {};
2109 final Byte[] result = ArrayUtils.nullToEmpty(empty);
2110 assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, result);
2111 assertNotSame(empty, result);
2112 }
2113
2114 @Test
2115 void testNullToEmptyByteObjectNull() {
2116 assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Byte[]) null));
2117 }
2118
2119 @Test
2120 void testNullToEmptyChar() {
2121 final char[] original = {'a', 'b'};
2122 assertEquals(original, ArrayUtils.nullToEmpty(original));
2123 }
2124
2125 @Test
2126 void testNullToEmptyCharEmptyArray() {
2127 final char[] empty = {};
2128 final char[] result = ArrayUtils.nullToEmpty(empty);
2129 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, result);
2130 assertNotSame(empty, result);
2131 }
2132
2133 @Test
2134 void testNullToEmptyCharNull() {
2135 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.nullToEmpty((char[]) null));
2136 }
2137
2138 @Test
2139 void testNullToEmptyCharObject() {
2140 final Character[] original = {'a', 'b'};
2141 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2142 }
2143
2144 @Test
2145 void testNullToEmptyCharObjectEmptyArray() {
2146 final Character[] empty = {};
2147 final Character[] result = ArrayUtils.nullToEmpty(empty);
2148 assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, result);
2149 assertNotSame(empty, result);
2150 }
2151
2152 @Test
2153 void testNUllToEmptyCharObjectNull() {
2154 assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Character[]) null));
2155 }
2156
2157 @Test
2158 void testNullToEmptyClass() {
2159 final Class<?>[] original = {Object.class, String.class};
2160 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2161 }
2162
2163 @Test
2164 void testNullToEmptyClassEmptyArray() {
2165 final Class<?>[] empty = {};
2166 final Class<?>[] result = ArrayUtils.nullToEmpty(empty);
2167 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, result);
2168 assertNotSame(empty, result);
2169 }
2170
2171 @Test
2172 void testNullToEmptyClassNull() {
2173 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ArrayUtils.nullToEmpty((Class<?>[]) null));
2174 }
2175
2176 @Test
2177 void testNullToEmptyDouble() {
2178 final double[] original = {1L, 2L};
2179 assertEquals(original, ArrayUtils.nullToEmpty(original));
2180 }
2181
2182 @Test
2183 void testNullToEmptyDoubleEmptyArray() {
2184 final double[] empty = {};
2185 final double[] result = ArrayUtils.nullToEmpty(empty);
2186 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, result);
2187 assertNotSame(empty, result);
2188 }
2189
2190 @Test
2191 void testNullToEmptyDoubleNull() {
2192 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.nullToEmpty((double[]) null));
2193 }
2194
2195 @Test
2196 void testNullToEmptyDoubleObject() {
2197 final Double[] original = {1D, 2D};
2198 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2199 }
2200
2201 @Test
2202 void testNullToEmptyDoubleObjectEmptyArray() {
2203 final Double[] empty = {};
2204 final Double[] result = ArrayUtils.nullToEmpty(empty);
2205 assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, result);
2206 assertNotSame(empty, result);
2207 }
2208
2209 @Test
2210 void testNullToEmptyDoubleObjectNull() {
2211 assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Double[]) null));
2212 }
2213
2214 @Test
2215 void testNullToEmptyFloat() {
2216 final float[] original = {2.6f, 3.8f};
2217 assertEquals(original, ArrayUtils.nullToEmpty(original));
2218 }
2219
2220 @Test
2221 void testNullToEmptyFloatEmptyArray() {
2222 final float[] empty = {};
2223 final float[] result = ArrayUtils.nullToEmpty(empty);
2224 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, result);
2225 assertNotSame(empty, result);
2226 }
2227
2228 @Test
2229 void testNullToEmptyFloatNull() {
2230 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.nullToEmpty((float[]) null));
2231 }
2232
2233 @Test
2234 void testNullToEmptyFloatObject() {
2235 final Float[] original = {2.6f, 3.8f};
2236 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2237 }
2238
2239 @Test
2240 void testNullToEmptyFloatObjectEmptyArray() {
2241 final Float[] empty = {};
2242 final Float[] result = ArrayUtils.nullToEmpty(empty);
2243 assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, result);
2244 assertNotSame(empty, result);
2245 }
2246
2247 @Test
2248 void testNullToEmptyFloatObjectNull() {
2249 assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Float[]) null));
2250 }
2251
2252 @Test
2253 void testNullToEmptyGeneric() {
2254 final TestClass[] input = {new TestClass(), new TestClass()};
2255 final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class);
2256
2257 assertSame(input, output);
2258 }
2259
2260 @Test
2261 void testNullToEmptyGenericEmpty() {
2262 final TestClass[] input = {};
2263 final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class);
2264
2265 assertSame(input, output);
2266 }
2267
2268 @Test
2269 void testNullToEmptyGenericNull() {
2270 final TestClass[] output = ArrayUtils.nullToEmpty(null, TestClass[].class);
2271
2272 assertNotNull(output);
2273 assertEquals(0, output.length);
2274 }
2275
2276 @Test
2277 void testNullToEmptyGenericNullType() {
2278 final TestClass[] input = {};
2279 assertIllegalArgumentException(() -> ArrayUtils.nullToEmpty(input, null));
2280 }
2281
2282 @Test
2283 void testNullToEmptyInt() {
2284 final int[] original = {1, 2};
2285 assertEquals(original, ArrayUtils.nullToEmpty(original));
2286 }
2287
2288 @Test
2289 void testNullToEmptyIntEmptyArray() {
2290 final int[] empty = {};
2291 final int[] result = ArrayUtils.nullToEmpty(empty);
2292 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, result);
2293 assertNotSame(empty, result);
2294 }
2295
2296 @Test
2297 void testNullToEmptyIntNull() {
2298 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.nullToEmpty((int[]) null));
2299 }
2300
2301 @Test
2302 void testNullToEmptyIntObject() {
2303 final Integer[] original = {1, 2};
2304 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2305 }
2306
2307 @Test
2308 void testNullToEmptyIntObjectEmptyArray() {
2309 final Integer[] empty = {};
2310 final Integer[] result = ArrayUtils.nullToEmpty(empty);
2311 assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, result);
2312 assertNotSame(empty, result);
2313 }
2314
2315 @Test
2316 void testNullToEmptyIntObjectNull() {
2317 assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Integer[]) null));
2318 }
2319
2320 @Test
2321 void testNullToEmptyLong() {
2322 final long[] original = {1L, 2L};
2323 assertEquals(original, ArrayUtils.nullToEmpty(original));
2324 }
2325
2326 @Test
2327 void testNullToEmptyLongEmptyArray() {
2328 final long[] empty = {};
2329 final long[] result = ArrayUtils.nullToEmpty(empty);
2330 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, result);
2331 assertNotSame(empty, result);
2332 }
2333
2334 @Test
2335 void testNullToEmptyLongNull() {
2336 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.nullToEmpty((long[]) null));
2337 }
2338
2339 @Test
2340 void testNullToEmptyLongObject() {
2341 @SuppressWarnings("boxing") final Long[] original = {1L, 2L};
2342 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2343 }
2344
2345 @Test
2346 void testNullToEmptyLongObjectEmptyArray() {
2347 final Long[] empty = {};
2348 final Long[] result = ArrayUtils.nullToEmpty(empty);
2349 assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, result);
2350 assertNotSame(empty, result);
2351 }
2352
2353 @Test
2354 void testNullToEmptyLongObjectNull() {
2355 assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Long[]) null));
2356 }
2357
2358 @Test
2359 void testNullToEmptyObject() {
2360 final Object[] original = {Boolean.TRUE, Boolean.FALSE};
2361 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2362 }
2363
2364 @Test
2365 void testNullToEmptyObjectEmptyArray() {
2366 final Object[] empty = {};
2367 final Object[] result = ArrayUtils.nullToEmpty(empty);
2368 assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, result);
2369 assertNotSame(empty, result);
2370 }
2371
2372 @Test
2373 void testNullToEmptyObjectNull() {
2374 assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Object[]) null));
2375 }
2376
2377 @Test
2378 void testNullToEmptyShort() {
2379 final short[] original = {1, 2};
2380 assertEquals(original, ArrayUtils.nullToEmpty(original));
2381 }
2382
2383 @Test
2384 void testNullToEmptyShortEmptyArray() {
2385 final short[] empty = {};
2386 final short[] result = ArrayUtils.nullToEmpty(empty);
2387 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, result);
2388 assertNotSame(empty, result);
2389 }
2390
2391 @Test
2392 void testNullToEmptyShortNull() {
2393 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.nullToEmpty((short[]) null));
2394 }
2395
2396 @Test
2397 void testNullToEmptyShortObject() {
2398 @SuppressWarnings("boxing") final Short[] original = {1, 2};
2399 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2400 }
2401
2402 @Test
2403 void testNullToEmptyShortObjectEmptyArray() {
2404 final Short[] empty = {};
2405 final Short[] result = ArrayUtils.nullToEmpty(empty);
2406 assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, result);
2407 assertNotSame(empty, result);
2408 }
2409
2410 @Test
2411 void testNullToEmptyShortObjectNull() {
2412 assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Short[]) null));
2413 }
2414
2415 @Test
2416 void testNullToEmptyString() {
2417 final String[] original = {"abc", "def"};
2418 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
2419 }
2420
2421 @Test
2422 void testNullToEmptyStringEmptyArray() {
2423 final String[] empty = {};
2424 final String[] result = ArrayUtils.nullToEmpty(empty);
2425 assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, result);
2426 assertNotSame(empty, result);
2427 }
2428
2429 @Test
2430 void testNullToEmptyStringNull() {
2431 assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, ArrayUtils.nullToEmpty((String[]) null));
2432 }
2433
2434 @Test
2435 void testNullToShortObject() {
2436 @SuppressWarnings("boxing") final Short[] original = {1, 2};
2437 assertArrayEquals(original, ArrayUtils.nullTo(original, ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY));
2438 }
2439
2440 @Test
2441 void testReverse() {
2442 final StringBuffer str1 = new StringBuffer("pick");
2443 final String str2 = "a";
2444 final String[] str3 = {"stick"};
2445 final String str4 = "up";
2446
2447 Object[] array = {str1, str2, str3};
2448 ArrayUtils.reverse(array);
2449 assertEquals(array[0], str3);
2450 assertEquals(array[1], str2);
2451 assertEquals(array[2], str1);
2452
2453 array = new Object[]{str1, str2, str3, str4};
2454 ArrayUtils.reverse(array);
2455 assertEquals(array[0], str4);
2456 assertEquals(array[1], str3);
2457 assertEquals(array[2], str2);
2458 assertEquals(array[3], str1);
2459
2460 array = null;
2461 ArrayUtils.reverse(array);
2462 assertArrayEquals(null, array);
2463 }
2464
2465 @Test
2466 void testReverseBoolean() {
2467 boolean[] array = {false, false, true};
2468 ArrayUtils.reverse(array);
2469 assertTrue(array[0]);
2470 assertFalse(array[1]);
2471 assertFalse(array[2]);
2472
2473 array = null;
2474 ArrayUtils.reverse(array);
2475 assertNull(array);
2476 }
2477
2478 @Test
2479 void testReverseBooleanRange() {
2480 boolean[] array = {false, false, true};
2481
2482 ArrayUtils.reverse(array, 0, 3);
2483 assertTrue(array[0]);
2484 assertFalse(array[1]);
2485 assertFalse(array[2]);
2486
2487 array = new boolean[]{false, false, true};
2488 ArrayUtils.reverse(array, 0, 2);
2489 assertFalse(array[0]);
2490 assertFalse(array[1]);
2491 assertTrue(array[2]);
2492
2493 array = new boolean[]{false, false, true};
2494 ArrayUtils.reverse(array, -1, 3);
2495 assertTrue(array[0]);
2496 assertFalse(array[1]);
2497 assertFalse(array[2]);
2498
2499 array = new boolean[]{false, false, true};
2500 ArrayUtils.reverse(array, -1, array.length + 1000);
2501 assertTrue(array[0]);
2502 assertFalse(array[1]);
2503 assertFalse(array[2]);
2504
2505 array = null;
2506 ArrayUtils.reverse(array, 0, 3);
2507 assertNull(array);
2508 }
2509
2510 @Test
2511 void testReverseByte() {
2512 byte[] array = {2, 3, 4};
2513 ArrayUtils.reverse(array);
2514 assertEquals(4, array[0]);
2515 assertEquals(3, array[1]);
2516 assertEquals(2, array[2]);
2517
2518 array = null;
2519 ArrayUtils.reverse(array);
2520 assertNull(array);
2521 }
2522
2523 @Test
2524 void testReverseByteRange() {
2525 byte[] array = {1, 2, 3};
2526
2527 ArrayUtils.reverse(array, 0, 3);
2528 assertEquals(3, array[0]);
2529 assertEquals(2, array[1]);
2530 assertEquals(1, array[2]);
2531
2532 array = new byte[]{1, 2, 3};
2533 ArrayUtils.reverse(array, 0, 2);
2534 assertEquals(2, array[0]);
2535 assertEquals(1, array[1]);
2536 assertEquals(3, array[2]);
2537
2538 array = new byte[]{1, 2, 3};
2539 ArrayUtils.reverse(array, -1, 3);
2540 assertEquals(3, array[0]);
2541 assertEquals(2, array[1]);
2542 assertEquals(1, array[2]);
2543
2544 array = new byte[]{1, 2, 3};
2545 ArrayUtils.reverse(array, -1, array.length + 1000);
2546 assertEquals(3, array[0]);
2547 assertEquals(2, array[1]);
2548 assertEquals(1, array[2]);
2549
2550 array = null;
2551 ArrayUtils.reverse(array, 0, 3);
2552 assertNull(array);
2553 }
2554
2555 @Test
2556 void testReverseChar() {
2557 char[] array = {'a', 'f', 'C'};
2558 ArrayUtils.reverse(array);
2559 assertEquals('C', array[0]);
2560 assertEquals('f', array[1]);
2561 assertEquals('a', array[2]);
2562
2563 array = null;
2564 ArrayUtils.reverse(array);
2565 assertNull(array);
2566 }
2567
2568 @Test
2569 void testReverseCharRange() {
2570 char[] array = {1, 2, 3};
2571
2572 ArrayUtils.reverse(array, 0, 3);
2573 assertEquals(3, array[0]);
2574 assertEquals(2, array[1]);
2575 assertEquals(1, array[2]);
2576
2577 array = new char[]{1, 2, 3};
2578 ArrayUtils.reverse(array, 0, 2);
2579 assertEquals(2, array[0]);
2580 assertEquals(1, array[1]);
2581 assertEquals(3, array[2]);
2582
2583 array = new char[]{1, 2, 3};
2584 ArrayUtils.reverse(array, -1, 3);
2585 assertEquals(3, array[0]);
2586 assertEquals(2, array[1]);
2587 assertEquals(1, array[2]);
2588
2589 array = new char[]{1, 2, 3};
2590 ArrayUtils.reverse(array, -1, array.length + 1000);
2591 assertEquals(3, array[0]);
2592 assertEquals(2, array[1]);
2593 assertEquals(1, array[2]);
2594
2595 array = null;
2596 ArrayUtils.reverse(array, 0, 3);
2597 assertNull(array);
2598 }
2599
2600 @Test
2601 void testReverseDouble() {
2602 double[] array = {0.3d, 0.4d, 0.5d};
2603 ArrayUtils.reverse(array);
2604 assertEquals(0.5d, array[0]);
2605 assertEquals(0.4d, array[1]);
2606 assertEquals(0.3d, array[2]);
2607
2608 array = null;
2609 ArrayUtils.reverse(array);
2610 assertNull(array);
2611 }
2612
2613 @Test
2614 void testReverseDoubleRange() {
2615 double[] array = {1, 2, 3};
2616
2617 ArrayUtils.reverse(array, 0, 3);
2618 assertEquals(3, array[0]);
2619 assertEquals(2, array[1]);
2620 assertEquals(1, array[2]);
2621
2622 array = new double[]{1, 2, 3};
2623 ArrayUtils.reverse(array, 0, 2);
2624 assertEquals(2, array[0]);
2625 assertEquals(1, array[1]);
2626 assertEquals(3, array[2]);
2627
2628 array = new double[]{1, 2, 3};
2629 ArrayUtils.reverse(array, -1, 3);
2630 assertEquals(3, array[0]);
2631 assertEquals(2, array[1]);
2632 assertEquals(1, array[2]);
2633
2634 array = new double[]{1, 2, 3};
2635 ArrayUtils.reverse(array, -1, array.length + 1000);
2636 assertEquals(3, array[0]);
2637 assertEquals(2, array[1]);
2638 assertEquals(1, array[2]);
2639
2640 array = null;
2641 ArrayUtils.reverse(array, 0, 3);
2642 assertNull(array);
2643 }
2644
2645 @Test
2646 void testReverseFloat() {
2647 float[] array = {0.3f, 0.4f, 0.5f};
2648 ArrayUtils.reverse(array);
2649 assertEquals(0.5f, array[0]);
2650 assertEquals(0.4f, array[1]);
2651 assertEquals(0.3f, array[2]);
2652
2653 array = null;
2654 ArrayUtils.reverse(array);
2655 assertNull(array);
2656 }
2657
2658 @Test
2659 void testReverseFloatRange() {
2660 float[] array = {1, 2, 3};
2661
2662 ArrayUtils.reverse(array, 0, 3);
2663 assertEquals(3, array[0]);
2664 assertEquals(2, array[1]);
2665 assertEquals(1, array[2]);
2666
2667 array = new float[]{1, 2, 3};
2668 ArrayUtils.reverse(array, 0, 2);
2669 assertEquals(2, array[0]);
2670 assertEquals(1, array[1]);
2671 assertEquals(3, array[2]);
2672
2673 array = new float[]{1, 2, 3};
2674 ArrayUtils.reverse(array, -1, 3);
2675 assertEquals(3, array[0]);
2676 assertEquals(2, array[1]);
2677 assertEquals(1, array[2]);
2678
2679 array = new float[]{1, 2, 3};
2680 ArrayUtils.reverse(array, -1, array.length + 1000);
2681 assertEquals(3, array[0]);
2682 assertEquals(2, array[1]);
2683 assertEquals(1, array[2]);
2684
2685 array = null;
2686 ArrayUtils.reverse(array, 0, 3);
2687 assertNull(array);
2688 }
2689
2690 @Test
2691 void testReverseInt() {
2692 int[] array = {1, 2, 3};
2693 ArrayUtils.reverse(array);
2694 assertEquals(3, array[0]);
2695 assertEquals(2, array[1]);
2696 assertEquals(1, array[2]);
2697
2698 array = null;
2699 ArrayUtils.reverse(array);
2700 assertNull(array);
2701 }
2702
2703 @Test
2704 void testReverseIntRange() {
2705 int[] array = {1, 2, 3};
2706
2707 ArrayUtils.reverse(array, 0, 3);
2708 assertEquals(3, array[0]);
2709 assertEquals(2, array[1]);
2710 assertEquals(1, array[2]);
2711
2712 array = new int[]{1, 2, 3};
2713 ArrayUtils.reverse(array, 0, 2);
2714 assertEquals(2, array[0]);
2715 assertEquals(1, array[1]);
2716 assertEquals(3, array[2]);
2717
2718 array = new int[]{1, 2, 3};
2719 ArrayUtils.reverse(array, -1, 3);
2720 assertEquals(3, array[0]);
2721 assertEquals(2, array[1]);
2722 assertEquals(1, array[2]);
2723
2724 array = new int[]{1, 2, 3};
2725 ArrayUtils.reverse(array, -1, array.length + 1000);
2726 assertEquals(3, array[0]);
2727 assertEquals(2, array[1]);
2728 assertEquals(1, array[2]);
2729
2730 array = null;
2731 ArrayUtils.reverse(array, 0, 3);
2732 assertNull(array);
2733 }
2734
2735 @Test
2736 void testReverseLong() {
2737 long[] array = {1L, 2L, 3L};
2738 ArrayUtils.reverse(array);
2739 assertEquals(3L, array[0]);
2740 assertEquals(2L, array[1]);
2741 assertEquals(1L, array[2]);
2742
2743 array = null;
2744 ArrayUtils.reverse(array);
2745 assertNull(array);
2746 }
2747
2748 @Test
2749 void testReverseLongRange() {
2750 long[] array = {1, 2, 3};
2751
2752 ArrayUtils.reverse(array, 0, 3);
2753 assertEquals(3, array[0]);
2754 assertEquals(2, array[1]);
2755 assertEquals(1, array[2]);
2756
2757 array = new long[]{1, 2, 3};
2758 ArrayUtils.reverse(array, 0, 2);
2759 assertEquals(2, array[0]);
2760 assertEquals(1, array[1]);
2761 assertEquals(3, array[2]);
2762
2763 array = new long[]{1, 2, 3};
2764 ArrayUtils.reverse(array, -1, 3);
2765 assertEquals(3, array[0]);
2766 assertEquals(2, array[1]);
2767 assertEquals(1, array[2]);
2768
2769 array = new long[]{1, 2, 3};
2770 ArrayUtils.reverse(array, -1, array.length + 1000);
2771 assertEquals(3, array[0]);
2772 assertEquals(2, array[1]);
2773 assertEquals(1, array[2]);
2774
2775 array = null;
2776 ArrayUtils.reverse(array, 0, 3);
2777 assertNull(array);
2778 }
2779
2780 @Test
2781 void testReverseObjectRange() {
2782 String[] array = {"1", "2", "3"};
2783
2784 ArrayUtils.reverse(array, 0, 3);
2785 assertEquals("3", array[0]);
2786 assertEquals("2", array[1]);
2787 assertEquals("1", array[2]);
2788
2789 array = new String[]{"1", "2", "3"};
2790 ArrayUtils.reverse(array, 0, 2);
2791 assertEquals("2", array[0]);
2792 assertEquals("1", array[1]);
2793 assertEquals("3", array[2]);
2794
2795 array = new String[]{"1", "2", "3"};
2796 ArrayUtils.reverse(array, -1, 3);
2797 assertEquals("3", array[0]);
2798 assertEquals("2", array[1]);
2799 assertEquals("1", array[2]);
2800
2801 array = new String[]{"1", "2", "3"};
2802 ArrayUtils.reverse(array, -1, array.length + 1000);
2803 assertEquals("3", array[0]);
2804 assertEquals("2", array[1]);
2805 assertEquals("1", array[2]);
2806
2807 array = null;
2808 ArrayUtils.reverse(array, 0, 3);
2809 assertNull(array);
2810 }
2811
2812 @Test
2813 void testReverseRangeEndIntMinValue() {
2814
2815
2816 final boolean[] booleans = {true, false, true};
2817 ArrayUtils.reverse(booleans, 0, Integer.MIN_VALUE);
2818 assertArrayEquals(new boolean[]{true, false, true}, booleans);
2819
2820 final byte[] bytes = {1, 2, 3};
2821 ArrayUtils.reverse(bytes, 0, Integer.MIN_VALUE);
2822 assertArrayEquals(new byte[]{1, 2, 3}, bytes);
2823
2824 final char[] chars = {'a', 'b', 'c'};
2825 ArrayUtils.reverse(chars, 0, Integer.MIN_VALUE);
2826 assertArrayEquals(new char[]{'a', 'b', 'c'}, chars);
2827
2828 final double[] doubles = {1, 2, 3};
2829 ArrayUtils.reverse(doubles, 0, Integer.MIN_VALUE);
2830 assertArrayEquals(new double[]{1, 2, 3}, doubles);
2831
2832 final float[] floats = {1, 2, 3};
2833 ArrayUtils.reverse(floats, 0, Integer.MIN_VALUE);
2834 assertArrayEquals(new float[]{1, 2, 3}, floats);
2835
2836 final int[] ints = {1, 2, 3};
2837 ArrayUtils.reverse(ints, 0, Integer.MIN_VALUE);
2838 assertArrayEquals(new int[]{1, 2, 3}, ints);
2839
2840 final long[] longs = {1, 2, 3};
2841 ArrayUtils.reverse(longs, 0, Integer.MIN_VALUE);
2842 assertArrayEquals(new long[]{1, 2, 3}, longs);
2843
2844 final Object[] objects = {"a", "b", "c"};
2845 ArrayUtils.reverse(objects, 0, Integer.MIN_VALUE);
2846 assertArrayEquals(new Object[]{"a", "b", "c"}, objects);
2847
2848 final short[] shorts = {1, 2, 3};
2849 ArrayUtils.reverse(shorts, 0, Integer.MIN_VALUE);
2850 assertArrayEquals(new short[]{1, 2, 3}, shorts);
2851 }
2852
2853 @Test
2854 void testReverseShort() {
2855 short[] array = {1, 2, 3};
2856 ArrayUtils.reverse(array);
2857 assertEquals(3, array[0]);
2858 assertEquals(2, array[1]);
2859 assertEquals(1, array[2]);
2860
2861 array = null;
2862 ArrayUtils.reverse(array);
2863 assertNull(array);
2864 }
2865
2866 @Test
2867 void testReverseShortRange() {
2868 short[] array = {1, 2, 3};
2869
2870 ArrayUtils.reverse(array, 0, 3);
2871 assertEquals(3, array[0]);
2872 assertEquals(2, array[1]);
2873 assertEquals(1, array[2]);
2874
2875 array = new short[]{1, 2, 3};
2876 ArrayUtils.reverse(array, 0, 2);
2877 assertEquals(2, array[0]);
2878 assertEquals(1, array[1]);
2879 assertEquals(3, array[2]);
2880
2881 array = new short[]{1, 2, 3};
2882 ArrayUtils.reverse(array, -1, 3);
2883 assertEquals(3, array[0]);
2884 assertEquals(2, array[1]);
2885 assertEquals(1, array[2]);
2886
2887 array = new short[]{1, 2, 3};
2888 ArrayUtils.reverse(array, -1, array.length + 1000);
2889 assertEquals(3, array[0]);
2890 assertEquals(2, array[1]);
2891 assertEquals(1, array[2]);
2892
2893 array = null;
2894 ArrayUtils.reverse(array, 0, 3);
2895 assertNull(array);
2896 }
2897
2898 @Test
2899 void testSameLength() {
2900 final Object[] nullArray = null;
2901 final Object[] emptyArray = {};
2902 final Object[] oneArray = {"pick"};
2903 final Object[] twoArray = {"pick", "stick"};
2904
2905 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
2906 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
2907 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
2908 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
2909
2910 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
2911 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
2912 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
2913 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
2914
2915 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
2916 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
2917 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
2918 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
2919
2920 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
2921 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
2922 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
2923 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
2924 }
2925
2926 @Test
2927 void testSameLengthAll() {
2928 final Object[] nullArrayObject = null;
2929 final Object[] emptyArrayObject = {};
2930 final Object[] oneArrayObject = {"pick"};
2931 final Object[] twoArrayObject = {"pick", "stick"};
2932 final boolean[] nullArrayBoolean = null;
2933 final boolean[] emptyArrayBoolean = {};
2934 final boolean[] oneArrayBoolean = {true};
2935 final boolean[] twoArrayBoolean = {true, false};
2936 final long[] nullArrayLong = null;
2937 final long[] emptyArrayLong = {};
2938 final long[] oneArrayLong = {0L};
2939 final long[] twoArrayLong = {0L, 76L};
2940 final int[] nullArrayInt = null;
2941 final int[] emptyArrayInt = {};
2942 final int[] oneArrayInt = {4};
2943 final int[] twoArrayInt = {5, 7};
2944 final short[] nullArrayShort = null;
2945 final short[] emptyArrayShort = {};
2946 final short[] oneArrayShort = {4};
2947 final short[] twoArrayShort = {6, 8};
2948 final char[] nullArrayChar = null;
2949 final char[] emptyArrayChar = {};
2950 final char[] oneArrayChar = {'f'};
2951 final char[] twoArrayChar = {'d', 't'};
2952 final byte[] nullArrayByte = null;
2953 final byte[] emptyArrayByte = {};
2954 final byte[] oneArrayByte = {3};
2955 final byte[] twoArrayByte = {4, 6};
2956 final double[] nullArrayDouble = null;
2957 final double[] emptyArrayDouble = {};
2958 final double[] oneArrayDouble = {1.3d};
2959 final double[] twoArrayDouble = {4.5d, 6.3d};
2960 final float[] nullArrayFloat = null;
2961 final float[] emptyArrayFloat = {};
2962 final float[] oneArrayFloat = {2.5f};
2963 final float[] twoArrayFloat = {6.4f, 5.8f};
2964 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayObject));
2965 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayBoolean));
2966 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayLong));
2967 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayInt));
2968 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayShort));
2969 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayChar));
2970 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayByte));
2971 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayDouble));
2972 assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayFloat));
2973 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayObject));
2974 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayBoolean));
2975 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayLong));
2976 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayInt));
2977 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayShort));
2978 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayChar));
2979 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayByte));
2980 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayDouble));
2981 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayFloat));
2982 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayObject));
2983 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayBoolean));
2984 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayLong));
2985 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayInt));
2986 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayShort));
2987 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayChar));
2988 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayByte));
2989 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayDouble));
2990 assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayFloat));
2991 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayObject));
2992 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayBoolean));
2993 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayLong));
2994 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayInt));
2995 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayShort));
2996 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayChar));
2997 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayByte));
2998 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayDouble));
2999 assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayFloat));
3000 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayObject));
3001 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayBoolean));
3002 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayLong));
3003 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayInt));
3004 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayShort));
3005 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayChar));
3006 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayByte));
3007 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayDouble));
3008 assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayFloat));
3009 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayObject));
3010 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayBoolean));
3011 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayLong));
3012 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayInt));
3013 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayShort));
3014 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayChar));
3015 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayByte));
3016 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayDouble));
3017 assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayFloat));
3018 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayObject));
3019 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayBoolean));
3020 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayLong));
3021 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayInt));
3022 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayShort));
3023 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayChar));
3024 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayByte));
3025 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayDouble));
3026 assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayFloat));
3027 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayObject));
3028 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayBoolean));
3029 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayLong));
3030 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayInt));
3031 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayShort));
3032 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayChar));
3033 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayByte));
3034 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayDouble));
3035 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayFloat));
3036 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayObject));
3037 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayBoolean));
3038 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayLong));
3039 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayInt));
3040 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayShort));
3041 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayChar));
3042 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayByte));
3043 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayDouble));
3044 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayFloat));
3045 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayObject));
3046 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayBoolean));
3047 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayLong));
3048 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayInt));
3049 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayShort));
3050 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayChar));
3051 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayByte));
3052 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayDouble));
3053 assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayFloat));
3054 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayObject));
3055 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayBoolean));
3056 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayLong));
3057 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayInt));
3058 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayShort));
3059 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayChar));
3060 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayByte));
3061 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayDouble));
3062 assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayFloat));
3063 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayObject));
3064 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayBoolean));
3065 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayLong));
3066 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayInt));
3067 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayShort));
3068 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayChar));
3069 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayByte));
3070 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayDouble));
3071 assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayFloat));
3072 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayObject));
3073 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayBoolean));
3074 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayLong));
3075 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayInt));
3076 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayShort));
3077 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayChar));
3078 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayByte));
3079 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayDouble));
3080 assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayFloat));
3081 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayObject));
3082 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayBoolean));
3083 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayLong));
3084 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayInt));
3085 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayShort));
3086 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayChar));
3087 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayByte));
3088 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayDouble));
3089 assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayFloat));
3090 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayObject));
3091 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayBoolean));
3092 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayLong));
3093 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayInt));
3094 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayShort));
3095 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayChar));
3096 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayByte));
3097 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayDouble));
3098 assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayFloat));
3099 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayObject));
3100 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayBoolean));
3101 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayLong));
3102 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayInt));
3103 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayShort));
3104 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayChar));
3105 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayByte));
3106 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayDouble));
3107 assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayFloat));
3108 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayObject));
3109 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayBoolean));
3110 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayLong));
3111 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayInt));
3112 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayShort));
3113 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayChar));
3114 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayByte));
3115 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayDouble));
3116 assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayFloat));
3117 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayObject));
3118 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayBoolean));
3119 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayLong));
3120 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayInt));
3121 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayShort));
3122 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayChar));
3123 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayByte));
3124 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayDouble));
3125 assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayFloat));
3126 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayObject));
3127 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayBoolean));
3128 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayLong));
3129 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayInt));
3130 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayShort));
3131 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayChar));
3132 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayByte));
3133 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayDouble));
3134 assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayFloat));
3135 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayObject));
3136 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayBoolean));
3137 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayLong));
3138 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayInt));
3139 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayShort));
3140 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayChar));
3141 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayByte));
3142 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayDouble));
3143 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayFloat));
3144 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayObject));
3145 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayBoolean));
3146 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayLong));
3147 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayInt));
3148 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayShort));
3149 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayChar));
3150 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayByte));
3151 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayDouble));
3152 assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayFloat));
3153 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayObject));
3154 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayBoolean));
3155 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayLong));
3156 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayInt));
3157 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayShort));
3158 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayChar));
3159 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayByte));
3160 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayDouble));
3161 assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayFloat));
3162 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayObject));
3163 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayBoolean));
3164 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayLong));
3165 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayInt));
3166 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayShort));
3167 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayChar));
3168 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayByte));
3169 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayDouble));
3170 assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayFloat));
3171 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayObject));
3172 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayBoolean));
3173 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayLong));
3174 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayInt));
3175 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayShort));
3176 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayChar));
3177 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayByte));
3178 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayDouble));
3179 assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayFloat));
3180 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayObject));
3181 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayBoolean));
3182 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayLong));
3183 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayInt));
3184 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayShort));
3185 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayChar));
3186 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayByte));
3187 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayDouble));
3188 assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayFloat));
3189 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayObject));
3190 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayBoolean));
3191 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayLong));
3192 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayInt));
3193 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayShort));
3194 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayChar));
3195 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayByte));
3196 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayDouble));
3197 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayFloat));
3198 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayObject));
3199 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayBoolean));
3200 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayLong));
3201 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayInt));
3202 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayShort));
3203 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayChar));
3204 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayByte));
3205 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayDouble));
3206 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayFloat));
3207 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayObject));
3208 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayBoolean));
3209 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayLong));
3210 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayInt));
3211 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayShort));
3212 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayChar));
3213 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayByte));
3214 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayDouble));
3215 assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayFloat));
3216 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayObject));
3217 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayBoolean));
3218 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayLong));
3219 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayInt));
3220 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayShort));
3221 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayChar));
3222 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayByte));
3223 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayDouble));
3224 assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayFloat));
3225 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayObject));
3226 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayBoolean));
3227 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayLong));
3228 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayInt));
3229 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayShort));
3230 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayChar));
3231 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayByte));
3232 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayDouble));
3233 assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayFloat));
3234 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayObject));
3235 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayBoolean));
3236 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayLong));
3237 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayInt));
3238 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayShort));
3239 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayChar));
3240 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayByte));
3241 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayDouble));
3242 assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayFloat));
3243 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayObject));
3244 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayBoolean));
3245 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayLong));
3246 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayInt));
3247 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayShort));
3248 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayChar));
3249 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayByte));
3250 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayDouble));
3251 assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayFloat));
3252 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayObject));
3253 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayBoolean));
3254 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayLong));
3255 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayInt));
3256 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayShort));
3257 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayChar));
3258 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayByte));
3259 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayDouble));
3260 assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayFloat));
3261 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayObject));
3262 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayBoolean));
3263 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayLong));
3264 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayInt));
3265 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayShort));
3266 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayChar));
3267 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayByte));
3268 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayDouble));
3269 assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayFloat));
3270 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayObject));
3271 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayBoolean));
3272 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayLong));
3273 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayInt));
3274 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayShort));
3275 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayChar));
3276 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayByte));
3277 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayDouble));
3278 assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayFloat));
3279 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayObject));
3280 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayBoolean));
3281 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayLong));
3282 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayInt));
3283 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayShort));
3284 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayChar));
3285 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayByte));
3286 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayDouble));
3287 assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayFloat));
3288 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayObject));
3289 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayBoolean));
3290 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayLong));
3291 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayInt));
3292 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayShort));
3293 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayChar));
3294 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayByte));
3295 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayDouble));
3296 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayFloat));
3297 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayObject));
3298 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayBoolean));
3299 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayLong));
3300 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayInt));
3301 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayShort));
3302 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayChar));
3303 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayByte));
3304 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayDouble));
3305 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayFloat));
3306 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayObject));
3307 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayBoolean));
3308 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayLong));
3309 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayInt));
3310 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayShort));
3311 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayChar));
3312 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayByte));
3313 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayDouble));
3314 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayFloat));
3315 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayObject));
3316 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayBoolean));
3317 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayLong));
3318 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayInt));
3319 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayShort));
3320 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayChar));
3321 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayByte));
3322 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayDouble));
3323 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayFloat));
3324 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayObject));
3325 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayBoolean));
3326 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayLong));
3327 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayInt));
3328 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayShort));
3329 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayChar));
3330 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayByte));
3331 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayDouble));
3332 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayFloat));
3333 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayObject));
3334 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayBoolean));
3335 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayLong));
3336 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayInt));
3337 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayShort));
3338 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayChar));
3339 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayByte));
3340 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayDouble));
3341 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayFloat));
3342 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayObject));
3343 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayBoolean));
3344 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayLong));
3345 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayInt));
3346 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayShort));
3347 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayChar));
3348 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayByte));
3349 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayDouble));
3350 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayFloat));
3351 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayObject));
3352 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayBoolean));
3353 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayLong));
3354 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayInt));
3355 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayShort));
3356 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayChar));
3357 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayByte));
3358 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayDouble));
3359 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayFloat));
3360 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayObject));
3361 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayBoolean));
3362 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayLong));
3363 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayInt));
3364 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayShort));
3365 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayChar));
3366 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayByte));
3367 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayDouble));
3368 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayFloat));
3369 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayObject));
3370 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayBoolean));
3371 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayLong));
3372 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayInt));
3373 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayShort));
3374 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayChar));
3375 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayByte));
3376 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayDouble));
3377 assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayFloat));
3378 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayObject));
3379 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayBoolean));
3380 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayLong));
3381 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayInt));
3382 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayShort));
3383 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayChar));
3384 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayByte));
3385 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayDouble));
3386 assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayFloat));
3387 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayObject));
3388 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayBoolean));
3389 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayLong));
3390 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayInt));
3391 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayShort));
3392 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayChar));
3393 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayByte));
3394 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayDouble));
3395 assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayFloat));
3396 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayObject));
3397 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayBoolean));
3398 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayLong));
3399 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayInt));
3400 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayShort));
3401 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayChar));
3402 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayByte));
3403 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayDouble));
3404 assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayFloat));
3405 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayObject));
3406 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayBoolean));
3407 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayLong));
3408 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayInt));
3409 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayShort));
3410 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayChar));
3411 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayByte));
3412 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayDouble));
3413 assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayFloat));
3414 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayObject));
3415 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayBoolean));
3416 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayLong));
3417 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayInt));
3418 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayShort));
3419 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayChar));
3420 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayByte));
3421 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayDouble));
3422 assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayFloat));
3423 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayObject));
3424 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayBoolean));
3425 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayLong));
3426 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayInt));
3427 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayShort));
3428 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayChar));
3429 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayByte));
3430 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayDouble));
3431 assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayFloat));
3432 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayObject));
3433 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayBoolean));
3434 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayLong));
3435 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayInt));
3436 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayShort));
3437 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayChar));
3438 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayByte));
3439 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayDouble));
3440 assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayFloat));
3441 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayObject));
3442 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayBoolean));
3443 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayLong));
3444 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayInt));
3445 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayShort));
3446 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayChar));
3447 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayByte));
3448 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayDouble));
3449 assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayFloat));
3450 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayObject));
3451 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayBoolean));
3452 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayLong));
3453 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayInt));
3454 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayShort));
3455 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayChar));
3456 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayByte));
3457 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayDouble));
3458 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayFloat));
3459 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayObject));
3460 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayBoolean));
3461 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayLong));
3462 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayInt));
3463 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayShort));
3464 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayChar));
3465 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayByte));
3466 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayDouble));
3467 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayFloat));
3468 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayObject));
3469 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayBoolean));
3470 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayLong));
3471 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayInt));
3472 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayShort));
3473 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayChar));
3474 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayByte));
3475 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayDouble));
3476 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayFloat));
3477 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayObject));
3478 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayBoolean));
3479 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayLong));
3480 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayInt));
3481 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayShort));
3482 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayChar));
3483 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayByte));
3484 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayDouble));
3485 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayFloat));
3486 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayObject));
3487 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayBoolean));
3488 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayLong));
3489 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayInt));
3490 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayShort));
3491 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayChar));
3492 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayByte));
3493 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayDouble));
3494 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayFloat));
3495 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayObject));
3496 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayBoolean));
3497 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayLong));
3498 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayInt));
3499 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayShort));
3500 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayChar));
3501 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayByte));
3502 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayDouble));
3503 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayFloat));
3504 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayObject));
3505 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayBoolean));
3506 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayLong));
3507 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayInt));
3508 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayShort));
3509 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayChar));
3510 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayByte));
3511 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayDouble));
3512 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayFloat));
3513 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayObject));
3514 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayBoolean));
3515 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayLong));
3516 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayInt));
3517 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayShort));
3518 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayChar));
3519 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayByte));
3520 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayDouble));
3521 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayFloat));
3522 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayObject));
3523 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayBoolean));
3524 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayLong));
3525 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayInt));
3526 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayShort));
3527 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayChar));
3528 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayByte));
3529 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayDouble));
3530 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayFloat));
3531 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayObject));
3532 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayBoolean));
3533 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayLong));
3534 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayInt));
3535 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayShort));
3536 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayChar));
3537 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayByte));
3538 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayDouble));
3539 assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayFloat));
3540 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayObject));
3541 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayBoolean));
3542 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayLong));
3543 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayInt));
3544 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayShort));
3545 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayChar));
3546 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayByte));
3547 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayDouble));
3548 assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayFloat));
3549 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayObject));
3550 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayBoolean));
3551 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayLong));
3552 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayInt));
3553 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayShort));
3554 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayChar));
3555 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayByte));
3556 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayDouble));
3557 assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayFloat));
3558 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayObject));
3559 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayBoolean));
3560 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayLong));
3561 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayInt));
3562 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayShort));
3563 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayChar));
3564 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayByte));
3565 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayDouble));
3566 assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayFloat));
3567 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayObject));
3568 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayBoolean));
3569 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayLong));
3570 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayInt));
3571 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayShort));
3572 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayChar));
3573 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayByte));
3574 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayDouble));
3575 assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayFloat));
3576 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayObject));
3577 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayBoolean));
3578 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayLong));
3579 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayInt));
3580 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayShort));
3581 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayChar));
3582 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayByte));
3583 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayDouble));
3584 assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayFloat));
3585 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayObject));
3586 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayBoolean));
3587 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayLong));
3588 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayInt));
3589 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayShort));
3590 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayChar));
3591 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayByte));
3592 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayDouble));
3593 assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayFloat));
3594 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayObject));
3595 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayBoolean));
3596 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayLong));
3597 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayInt));
3598 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayShort));
3599 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayChar));
3600 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayByte));
3601 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayDouble));
3602 assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayFloat));
3603 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayObject));
3604 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayBoolean));
3605 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayLong));
3606 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayInt));
3607 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayShort));
3608 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayChar));
3609 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayByte));
3610 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayDouble));
3611 assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayFloat));
3612 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayObject));
3613 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayBoolean));
3614 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayLong));
3615 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayInt));
3616 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayShort));
3617 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayChar));
3618 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayByte));
3619 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayDouble));
3620 assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayFloat));
3621 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayObject));
3622 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayBoolean));
3623 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayLong));
3624 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayInt));
3625 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayShort));
3626 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayChar));
3627 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayByte));
3628 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayDouble));
3629 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayFloat));
3630 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayObject));
3631 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayBoolean));
3632 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayLong));
3633 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayInt));
3634 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayShort));
3635 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayChar));
3636 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayByte));
3637 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayDouble));
3638 assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayFloat));
3639 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayObject));
3640 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayBoolean));
3641 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayLong));
3642 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayInt));
3643 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayShort));
3644 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayChar));
3645 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayByte));
3646 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayDouble));
3647 assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayFloat));
3648 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayObject));
3649 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayBoolean));
3650 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayLong));
3651 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayInt));
3652 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayShort));
3653 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayChar));
3654 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayByte));
3655 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayDouble));
3656 assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayFloat));
3657 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayObject));
3658 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayBoolean));
3659 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayLong));
3660 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayInt));
3661 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayShort));
3662 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayChar));
3663 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayByte));
3664 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayDouble));
3665 assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayFloat));
3666 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayObject));
3667 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayBoolean));
3668 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayLong));
3669 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayInt));
3670 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayShort));
3671 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayChar));
3672 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayByte));
3673 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayDouble));
3674 assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayFloat));
3675 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayObject));
3676 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayBoolean));
3677 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayLong));
3678 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayInt));
3679 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayShort));
3680 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayChar));
3681 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayByte));
3682 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayDouble));
3683 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayFloat));
3684 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayObject));
3685 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayBoolean));
3686 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayLong));
3687 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayInt));
3688 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayShort));
3689 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayChar));
3690 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayByte));
3691 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayDouble));
3692 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayFloat));
3693 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayObject));
3694 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayBoolean));
3695 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayLong));
3696 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayInt));
3697 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayShort));
3698 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayChar));
3699 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayByte));
3700 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayDouble));
3701 assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayFloat));
3702 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayObject));
3703 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayBoolean));
3704 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayLong));
3705 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayInt));
3706 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayShort));
3707 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayChar));
3708 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayByte));
3709 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayDouble));
3710 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayFloat));
3711 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayObject));
3712 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayBoolean));
3713 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayLong));
3714 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayInt));
3715 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayShort));
3716 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayChar));
3717 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayByte));
3718 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayDouble));
3719 assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayFloat));
3720 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayObject));
3721 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayBoolean));
3722 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayLong));
3723 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayInt));
3724 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayShort));
3725 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayChar));
3726 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayByte));
3727 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayDouble));
3728 assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayFloat));
3729 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayObject));
3730 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayBoolean));
3731 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayLong));
3732 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayInt));
3733 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayShort));
3734 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayChar));
3735 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayByte));
3736 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayDouble));
3737 assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayFloat));
3738 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayObject));
3739 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayBoolean));
3740 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayLong));
3741 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayInt));
3742 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayShort));
3743 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayChar));
3744 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayByte));
3745 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayDouble));
3746 assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayFloat));
3747 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayObject));
3748 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayBoolean));
3749 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayLong));
3750 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayInt));
3751 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayShort));
3752 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayChar));
3753 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayByte));
3754 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayDouble));
3755 assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayFloat));
3756 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayObject));
3757 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayBoolean));
3758 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayLong));
3759 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayInt));
3760 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayShort));
3761 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayChar));
3762 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayByte));
3763 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayDouble));
3764 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayFloat));
3765 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayObject));
3766 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayBoolean));
3767 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayLong));
3768 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayInt));
3769 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayShort));
3770 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayChar));
3771 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayByte));
3772 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayDouble));
3773 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayFloat));
3774 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayObject));
3775 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayBoolean));
3776 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayLong));
3777 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayInt));
3778 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayShort));
3779 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayChar));
3780 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayByte));
3781 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayDouble));
3782 assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayFloat));
3783 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayObject));
3784 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayBoolean));
3785 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayLong));
3786 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayInt));
3787 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayShort));
3788 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayChar));
3789 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayByte));
3790 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayDouble));
3791 assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayFloat));
3792 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayObject));
3793 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayBoolean));
3794 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayLong));
3795 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayInt));
3796 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayShort));
3797 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayChar));
3798 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayByte));
3799 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayDouble));
3800 assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayFloat));
3801 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayObject));
3802 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayBoolean));
3803 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayLong));
3804 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayInt));
3805 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayShort));
3806 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayChar));
3807 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayByte));
3808 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayDouble));
3809 assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayFloat));
3810 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayObject));
3811 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayBoolean));
3812 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayLong));
3813 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayInt));
3814 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayShort));
3815 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayChar));
3816 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayByte));
3817 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayDouble));
3818 assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayFloat));
3819 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayObject));
3820 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayBoolean));
3821 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayLong));
3822 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayInt));
3823 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayShort));
3824 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayChar));
3825 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayByte));
3826 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayDouble));
3827 assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayFloat));
3828 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayObject));
3829 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayBoolean));
3830 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayLong));
3831 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayInt));
3832 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayShort));
3833 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayChar));
3834 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayByte));
3835 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayDouble));
3836 assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayFloat));
3837 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayObject));
3838 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayBoolean));
3839 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayLong));
3840 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayInt));
3841 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayShort));
3842 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayChar));
3843 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayByte));
3844 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayDouble));
3845 assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayFloat));
3846 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayObject));
3847 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayBoolean));
3848 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayLong));
3849 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayInt));
3850 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayShort));
3851 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayChar));
3852 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayByte));
3853 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayDouble));
3854 assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayFloat));
3855 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayObject));
3856 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayBoolean));
3857 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayLong));
3858 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayInt));
3859 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayShort));
3860 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayChar));
3861 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayByte));
3862 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayDouble));
3863 assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayFloat));
3864 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayObject));
3865 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayBoolean));
3866 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayLong));
3867 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayInt));
3868 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayShort));
3869 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayChar));
3870 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayByte));
3871 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayDouble));
3872 assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayFloat));
3873 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayObject));
3874 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayBoolean));
3875 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayLong));
3876 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayInt));
3877 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayShort));
3878 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayChar));
3879 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayByte));
3880 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayDouble));
3881 assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayFloat));
3882 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayObject));
3883 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayBoolean));
3884 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayLong));
3885 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayInt));
3886 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayShort));
3887 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayChar));
3888 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayByte));
3889 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayDouble));
3890 assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayFloat));
3891 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayObject));
3892 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayBoolean));
3893 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayLong));
3894 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayInt));
3895 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayShort));
3896 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayChar));
3897 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayByte));
3898 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayDouble));
3899 assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayFloat));
3900 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayObject));
3901 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayBoolean));
3902 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayLong));
3903 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayInt));
3904 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayShort));
3905 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayChar));
3906 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayByte));
3907 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayDouble));
3908 assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayFloat));
3909 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayObject));
3910 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayBoolean));
3911 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayLong));
3912 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayInt));
3913 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayShort));
3914 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayChar));
3915 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayByte));
3916 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayDouble));
3917 assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayFloat));
3918 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayObject));
3919 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayBoolean));
3920 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayLong));
3921 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayInt));
3922 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayShort));
3923 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayChar));
3924 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayByte));
3925 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayDouble));
3926 assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayFloat));
3927 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayObject));
3928 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayBoolean));
3929 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayLong));
3930 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayInt));
3931 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayShort));
3932 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayChar));
3933 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayByte));
3934 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayDouble));
3935 assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayFloat));
3936 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayObject));
3937 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayBoolean));
3938 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayLong));
3939 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayInt));
3940 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayShort));
3941 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayChar));
3942 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayByte));
3943 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayDouble));
3944 assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayFloat));
3945 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayObject));
3946 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayBoolean));
3947 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayLong));
3948 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayInt));
3949 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayShort));
3950 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayChar));
3951 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayByte));
3952 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayDouble));
3953 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayFloat));
3954 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayObject));
3955 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayBoolean));
3956 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayLong));
3957 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayInt));
3958 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayShort));
3959 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayChar));
3960 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayByte));
3961 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayDouble));
3962 assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayFloat));
3963 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayObject));
3964 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayBoolean));
3965 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayLong));
3966 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayInt));
3967 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayShort));
3968 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayChar));
3969 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayByte));
3970 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayDouble));
3971 assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayFloat));
3972 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayObject));
3973 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayBoolean));
3974 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayLong));
3975 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayInt));
3976 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayShort));
3977 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayChar));
3978 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayByte));
3979 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayDouble));
3980 assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayFloat));
3981 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayObject));
3982 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayBoolean));
3983 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayLong));
3984 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayInt));
3985 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayShort));
3986 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayChar));
3987 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayByte));
3988 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayDouble));
3989 assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayFloat));
3990 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayObject));
3991 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayBoolean));
3992 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayLong));
3993 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayInt));
3994 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayShort));
3995 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayChar));
3996 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayByte));
3997 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayDouble));
3998 assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayFloat));
3999 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayObject));
4000 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayBoolean));
4001 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayLong));
4002 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayInt));
4003 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayShort));
4004 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayChar));
4005 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayByte));
4006 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayDouble));
4007 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayFloat));
4008 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayObject));
4009 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayBoolean));
4010 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayLong));
4011 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayInt));
4012 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayShort));
4013 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayChar));
4014 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayByte));
4015 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayDouble));
4016 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayFloat));
4017 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayObject));
4018 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayBoolean));
4019 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayLong));
4020 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayInt));
4021 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayShort));
4022 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayChar));
4023 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayByte));
4024 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayDouble));
4025 assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayFloat));
4026 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayObject));
4027 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayBoolean));
4028 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayLong));
4029 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayInt));
4030 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayShort));
4031 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayChar));
4032 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayByte));
4033 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayDouble));
4034 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayFloat));
4035 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayObject));
4036 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayBoolean));
4037 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayLong));
4038 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayInt));
4039 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayShort));
4040 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayChar));
4041 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayByte));
4042 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayDouble));
4043 assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayFloat));
4044 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayObject));
4045 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayBoolean));
4046 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayLong));
4047 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayInt));
4048 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayShort));
4049 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayChar));
4050 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayByte));
4051 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayDouble));
4052 assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayFloat));
4053 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayObject));
4054 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayBoolean));
4055 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayLong));
4056 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayInt));
4057 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayShort));
4058 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayChar));
4059 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayByte));
4060 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayDouble));
4061 assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayFloat));
4062 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayObject));
4063 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayBoolean));
4064 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayLong));
4065 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayInt));
4066 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayShort));
4067 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayChar));
4068 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayByte));
4069 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayDouble));
4070 assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayFloat));
4071 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayObject));
4072 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayBoolean));
4073 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayLong));
4074 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayInt));
4075 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayShort));
4076 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayChar));
4077 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayByte));
4078 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayDouble));
4079 assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayFloat));
4080 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayObject));
4081 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayBoolean));
4082 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayLong));
4083 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayInt));
4084 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayShort));
4085 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayChar));
4086 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayByte));
4087 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayDouble));
4088 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayFloat));
4089 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayObject));
4090 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayBoolean));
4091 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayLong));
4092 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayInt));
4093 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayShort));
4094 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayChar));
4095 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayByte));
4096 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayDouble));
4097 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayFloat));
4098 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayObject));
4099 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayBoolean));
4100 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayLong));
4101 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayInt));
4102 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayShort));
4103 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayChar));
4104 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayByte));
4105 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayDouble));
4106 assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayFloat));
4107 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayObject));
4108 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayBoolean));
4109 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayLong));
4110 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayInt));
4111 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayShort));
4112 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayChar));
4113 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayByte));
4114 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayDouble));
4115 assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayFloat));
4116 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayObject));
4117 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayBoolean));
4118 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayLong));
4119 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayInt));
4120 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayShort));
4121 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayChar));
4122 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayByte));
4123 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayDouble));
4124 assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayFloat));
4125 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayObject));
4126 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayBoolean));
4127 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayLong));
4128 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayInt));
4129 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayShort));
4130 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayChar));
4131 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayByte));
4132 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayDouble));
4133 assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayFloat));
4134 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayObject));
4135 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayBoolean));
4136 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayLong));
4137 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayInt));
4138 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayShort));
4139 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayChar));
4140 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayByte));
4141 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayDouble));
4142 assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayFloat));
4143 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayObject));
4144 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayBoolean));
4145 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayLong));
4146 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayInt));
4147 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayShort));
4148 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayChar));
4149 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayByte));
4150 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayDouble));
4151 assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayFloat));
4152 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayObject));
4153 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayBoolean));
4154 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayLong));
4155 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayInt));
4156 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayShort));
4157 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayChar));
4158 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayByte));
4159 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayDouble));
4160 assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayFloat));
4161 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayObject));
4162 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayBoolean));
4163 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayLong));
4164 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayInt));
4165 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayShort));
4166 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayChar));
4167 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayByte));
4168 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayDouble));
4169 assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayFloat));
4170 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayObject));
4171 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayBoolean));
4172 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayLong));
4173 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayInt));
4174 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayShort));
4175 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayChar));
4176 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayByte));
4177 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayDouble));
4178 assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayFloat));
4179 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayObject));
4180 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayBoolean));
4181 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayLong));
4182 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayInt));
4183 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayShort));
4184 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayChar));
4185 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayByte));
4186 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayDouble));
4187 assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayFloat));
4188 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayObject));
4189 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayBoolean));
4190 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayLong));
4191 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayInt));
4192 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayShort));
4193 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayChar));
4194 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayByte));
4195 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayDouble));
4196 assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayFloat));
4197 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayObject));
4198 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayBoolean));
4199 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayLong));
4200 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayInt));
4201 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayShort));
4202 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayChar));
4203 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayByte));
4204 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayDouble));
4205 assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayFloat));
4206 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayObject));
4207 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayBoolean));
4208 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayLong));
4209 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayInt));
4210 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayShort));
4211 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayChar));
4212 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayByte));
4213 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayDouble));
4214 assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayFloat));
4215 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayObject));
4216 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayBoolean));
4217 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayLong));
4218 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayInt));
4219 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayShort));
4220 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayChar));
4221 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayByte));
4222 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayDouble));
4223 assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayFloat));
4224 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayObject));
4225 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayBoolean));
4226 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayLong));
4227 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayInt));
4228 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayShort));
4229 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayChar));
4230 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayByte));
4231 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayDouble));
4232 assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayFloat));
4233 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayObject));
4234 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayBoolean));
4235 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayLong));
4236 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayInt));
4237 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayShort));
4238 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayChar));
4239 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayByte));
4240 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayDouble));
4241 assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayFloat));
4242 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayObject));
4243 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayBoolean));
4244 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayLong));
4245 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayInt));
4246 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayShort));
4247 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayChar));
4248 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayByte));
4249 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayDouble));
4250 assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayFloat));
4251 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayObject));
4252 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayBoolean));
4253 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayLong));
4254 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayInt));
4255 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayShort));
4256 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayChar));
4257 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayByte));
4258 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayDouble));
4259 assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayFloat));
4260 }
4261
4262 @Test
4263 void testSameLengthBoolean() {
4264 final boolean[] nullArray = null;
4265 final boolean[] emptyArray = {};
4266 final boolean[] oneArray = {true};
4267 final boolean[] twoArray = {true, false};
4268
4269 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4270 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4271 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4272 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4273
4274 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4275 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4276 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4277 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4278
4279 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4280 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4281 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4282 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4283
4284 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4285 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4286 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4287 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4288 }
4289
4290 @Test
4291 void testSameLengthByte() {
4292 final byte[] nullArray = null;
4293 final byte[] emptyArray = {};
4294 final byte[] oneArray = {3};
4295 final byte[] twoArray = {4, 6};
4296
4297 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4298 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4299 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4300 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4301
4302 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4303 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4304 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4305 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4306
4307 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4308 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4309 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4310 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4311
4312 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4313 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4314 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4315 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4316 }
4317
4318 @Test
4319 void testSameLengthChar() {
4320 final char[] nullArray = null;
4321 final char[] emptyArray = {};
4322 final char[] oneArray = {'f'};
4323 final char[] twoArray = {'d', 't'};
4324
4325 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4326 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4327 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4328 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4329
4330 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4331 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4332 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4333 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4334
4335 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4336 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4337 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4338 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4339
4340 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4341 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4342 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4343 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4344 }
4345
4346 @Test
4347 void testSameLengthDouble() {
4348 final double[] nullArray = null;
4349 final double[] emptyArray = {};
4350 final double[] oneArray = {1.3d};
4351 final double[] twoArray = {4.5d, 6.3d};
4352
4353 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4354 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4355 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4356 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4357
4358 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4359 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4360 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4361 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4362
4363 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4364 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4365 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4366 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4367
4368 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4369 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4370 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4371 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4372 }
4373
4374 @Test
4375 void testSameLengthFloat() {
4376 final float[] nullArray = null;
4377 final float[] emptyArray = {};
4378 final float[] oneArray = {2.5f};
4379 final float[] twoArray = {6.4f, 5.8f};
4380
4381 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4382 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4383 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4384 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4385
4386 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4387 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4388 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4389 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4390
4391 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4392 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4393 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4394 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4395
4396 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4397 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4398 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4399 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4400 }
4401
4402 @Test
4403 void testSameLengthInt() {
4404 final int[] nullArray = null;
4405 final int[] emptyArray = {};
4406 final int[] oneArray = {4};
4407 final int[] twoArray = {5, 7};
4408
4409 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4410 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4411 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4412 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4413
4414 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4415 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4416 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4417 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4418
4419 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4420 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4421 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4422 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4423
4424 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4425 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4426 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4427 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4428 }
4429
4430 @Test
4431 void testSameLengthLong() {
4432 final long[] nullArray = null;
4433 final long[] emptyArray = {};
4434 final long[] oneArray = {0L};
4435 final long[] twoArray = {0L, 76L};
4436
4437 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4438 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4439 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4440 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4441
4442 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4443 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4444 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4445 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4446
4447 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4448 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4449 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4450 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4451
4452 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4453 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4454 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4455 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4456 }
4457
4458 @Test
4459 void testSameLengthShort() {
4460 final short[] nullArray = null;
4461 final short[] emptyArray = {};
4462 final short[] oneArray = {4};
4463 final short[] twoArray = {6, 8};
4464
4465 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
4466 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
4467 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
4468 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
4469
4470 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
4471 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
4472 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
4473 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
4474
4475 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
4476 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
4477 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
4478 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
4479
4480 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
4481 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
4482 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
4483 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
4484 }
4485
4486 @Test
4487 void testSameType() {
4488 assertIllegalArgumentException(() -> ArrayUtils.isSameType(null, null));
4489 assertIllegalArgumentException(() -> ArrayUtils.isSameType(null, new Object[0]));
4490 assertIllegalArgumentException(() -> ArrayUtils.isSameType(new Object[0], null));
4491
4492 assertTrue(ArrayUtils.isSameType(new Object[0], new Object[0]));
4493 assertFalse(ArrayUtils.isSameType(new String[0], new Object[0]));
4494 assertTrue(ArrayUtils.isSameType(new String[0][0], new String[0][0]));
4495 assertFalse(ArrayUtils.isSameType(new String[0], new String[0][0]));
4496 assertFalse(ArrayUtils.isSameType(new String[0][0], new String[0]));
4497 }
4498
4499 @Test
4500 void testShiftAllByte() {
4501 final byte[] array = {1, 2, 3, 4};
4502 ArrayUtils.shift(array, 4);
4503 assertEquals(1, array[0]);
4504 assertEquals(2, array[1]);
4505 assertEquals(3, array[2]);
4506 assertEquals(4, array[3]);
4507 ArrayUtils.shift(array, -4);
4508 assertEquals(1, array[0]);
4509 assertEquals(2, array[1]);
4510 assertEquals(3, array[2]);
4511 assertEquals(4, array[3]);
4512 }
4513
4514 @Test
4515 void testShiftAllChar() {
4516 final char[] array = {1, 2, 3, 4};
4517 ArrayUtils.shift(array, 4);
4518 assertEquals(1, array[0]);
4519 assertEquals(2, array[1]);
4520 assertEquals(3, array[2]);
4521 assertEquals(4, array[3]);
4522 ArrayUtils.shift(array, -4);
4523 assertEquals(1, array[0]);
4524 assertEquals(2, array[1]);
4525 assertEquals(3, array[2]);
4526 assertEquals(4, array[3]);
4527 }
4528
4529 @Test
4530 void testShiftAllDouble() {
4531 final double[] array = {1, 2, 3, 4};
4532 ArrayUtils.shift(array, 4);
4533 assertEquals(1, array[0]);
4534 assertEquals(2, array[1]);
4535 assertEquals(3, array[2]);
4536 assertEquals(4, array[3]);
4537 ArrayUtils.shift(array, -4);
4538 assertEquals(1, array[0]);
4539 assertEquals(2, array[1]);
4540 assertEquals(3, array[2]);
4541 assertEquals(4, array[3]);
4542 }
4543
4544 @Test
4545 void testShiftAllFloat() {
4546 final float[] array = {1, 2, 3, 4};
4547 ArrayUtils.shift(array, 4);
4548 assertEquals(1, array[0]);
4549 assertEquals(2, array[1]);
4550 assertEquals(3, array[2]);
4551 assertEquals(4, array[3]);
4552 ArrayUtils.shift(array, -4);
4553 assertEquals(1, array[0]);
4554 assertEquals(2, array[1]);
4555 assertEquals(3, array[2]);
4556 assertEquals(4, array[3]);
4557 }
4558
4559 @Test
4560 void testShiftAllInt() {
4561 final int[] array = {1, 2, 3, 4};
4562 ArrayUtils.shift(array, 4);
4563 assertEquals(1, array[0]);
4564 assertEquals(2, array[1]);
4565 assertEquals(3, array[2]);
4566 assertEquals(4, array[3]);
4567 ArrayUtils.shift(array, -4);
4568 assertEquals(1, array[0]);
4569 assertEquals(2, array[1]);
4570 assertEquals(3, array[2]);
4571 assertEquals(4, array[3]);
4572 }
4573
4574 @Test
4575 void testShiftAllLong() {
4576 final long[] array = {1, 2, 3, 4};
4577 ArrayUtils.shift(array, 4);
4578 assertEquals(1, array[0]);
4579 assertEquals(2, array[1]);
4580 assertEquals(3, array[2]);
4581 assertEquals(4, array[3]);
4582 ArrayUtils.shift(array, -4);
4583 assertEquals(1, array[0]);
4584 assertEquals(2, array[1]);
4585 assertEquals(3, array[2]);
4586 assertEquals(4, array[3]);
4587 }
4588
4589 @Test
4590 void testShiftAllObject() {
4591 final String[] array = {"1", "2", "3", "4"};
4592 ArrayUtils.shift(array, 4);
4593 assertEquals("1", array[0]);
4594 assertEquals("2", array[1]);
4595 assertEquals("3", array[2]);
4596 assertEquals("4", array[3]);
4597 ArrayUtils.shift(array, -4);
4598 assertEquals("1", array[0]);
4599 assertEquals("2", array[1]);
4600 assertEquals("3", array[2]);
4601 assertEquals("4", array[3]);
4602 }
4603
4604 @Test
4605 void testShiftAllShort() {
4606 final short[] array = {1, 2, 3, 4};
4607 ArrayUtils.shift(array, 4);
4608 assertEquals(1, array[0]);
4609 assertEquals(2, array[1]);
4610 assertEquals(3, array[2]);
4611 assertEquals(4, array[3]);
4612 ArrayUtils.shift(array, -4);
4613 assertEquals(1, array[0]);
4614 assertEquals(2, array[1]);
4615 assertEquals(3, array[2]);
4616 assertEquals(4, array[3]);
4617 }
4618
4619 @Test
4620 void testShiftBoolean() {
4621 ArrayUtils.shift(new boolean[0], 1);
4622 final boolean[] array = { true, true, false, false };
4623 ArrayUtils.shift(array, 1);
4624 assertFalse(array[0]);
4625 assertTrue(array[1]);
4626 assertTrue(array[2]);
4627 assertFalse(array[3]);
4628 ArrayUtils.shift(array, -1);
4629 assertTrue(array[0]);
4630 assertTrue(array[1]);
4631 assertFalse(array[2]);
4632 assertFalse(array[3]);
4633 ArrayUtils.shift(array, 5);
4634 assertFalse(array[0]);
4635 assertTrue(array[1]);
4636 assertTrue(array[2]);
4637 assertFalse(array[3]);
4638 ArrayUtils.shift(array, -3);
4639 assertFalse(array[0]);
4640 assertFalse(array[1]);
4641 assertTrue(array[2]);
4642 assertTrue(array[3]);
4643 }
4644
4645 @Test
4646 void testShiftBooleanArrayNull() {
4647 final boolean[] array = null;
4648 ArrayUtils.shift(array, 1);
4649 assertNull(array);
4650 }
4651
4652 @Test
4653 void testShiftByte() {
4654 ArrayUtils.shift((byte[]) null, 1);
4655 ArrayUtils.shift(new byte[0], 1);
4656 final byte[] array = { 1, 2, 3, 4 };
4657 ArrayUtils.shift(array, 1);
4658 assertEquals(4, array[0]);
4659 assertEquals(1, array[1]);
4660 assertEquals(2, array[2]);
4661 assertEquals(3, array[3]);
4662 ArrayUtils.shift(array, -1);
4663 assertEquals(1, array[0]);
4664 assertEquals(2, array[1]);
4665 assertEquals(3, array[2]);
4666 assertEquals(4, array[3]);
4667 ArrayUtils.shift(array, 5);
4668 assertEquals(4, array[0]);
4669 assertEquals(1, array[1]);
4670 assertEquals(2, array[2]);
4671 assertEquals(3, array[3]);
4672 ArrayUtils.shift(array, -3);
4673 assertEquals(3, array[0]);
4674 assertEquals(4, array[1]);
4675 assertEquals(1, array[2]);
4676 assertEquals(2, array[3]);
4677 }
4678
4679 @Test
4680 void testShiftChar() {
4681 ArrayUtils.shift((char[]) null, 1);
4682 final char[] array = {1, 2, 3, 4};
4683 ArrayUtils.shift(array, 1);
4684 assertEquals(4, array[0]);
4685 assertEquals(1, array[1]);
4686 assertEquals(2, array[2]);
4687 assertEquals(3, array[3]);
4688 ArrayUtils.shift(array, -1);
4689 assertEquals(1, array[0]);
4690 assertEquals(2, array[1]);
4691 assertEquals(3, array[2]);
4692 assertEquals(4, array[3]);
4693 ArrayUtils.shift(array, 5);
4694 assertEquals(4, array[0]);
4695 assertEquals(1, array[1]);
4696 assertEquals(2, array[2]);
4697 assertEquals(3, array[3]);
4698 ArrayUtils.shift(array, -3);
4699 assertEquals(3, array[0]);
4700 assertEquals(4, array[1]);
4701 assertEquals(1, array[2]);
4702 assertEquals(2, array[3]);
4703 }
4704
4705 @Test
4706 void testShiftDouble() {
4707 ArrayUtils.shift((double[]) null, 1);
4708 final double[] array = {1, 2, 3, 4};
4709 ArrayUtils.shift(array, 1);
4710 assertEquals(4, array[0]);
4711 assertEquals(1, array[1]);
4712 assertEquals(2, array[2]);
4713 assertEquals(3, array[3]);
4714 ArrayUtils.shift(array, -1);
4715 assertEquals(1, array[0]);
4716 assertEquals(2, array[1]);
4717 assertEquals(3, array[2]);
4718 assertEquals(4, array[3]);
4719 ArrayUtils.shift(array, 5);
4720 assertEquals(4, array[0]);
4721 assertEquals(1, array[1]);
4722 assertEquals(2, array[2]);
4723 assertEquals(3, array[3]);
4724 ArrayUtils.shift(array, -3);
4725 assertEquals(3, array[0]);
4726 assertEquals(4, array[1]);
4727 assertEquals(1, array[2]);
4728 assertEquals(2, array[3]);
4729 }
4730
4731 @Test
4732 void testShiftDoubleArrayNull() {
4733 final double[] array = null;
4734 ArrayUtils.shift(array, 1);
4735 assertNull(array);
4736 }
4737
4738 @Test
4739 void testShiftFloat() {
4740 ArrayUtils.shift((float[]) null, 1);
4741 final float[] array = {1, 2, 3, 4};
4742 ArrayUtils.shift(array, 1);
4743 assertEquals(4, array[0]);
4744 assertEquals(1, array[1]);
4745 assertEquals(2, array[2]);
4746 assertEquals(3, array[3]);
4747 ArrayUtils.shift(array, -1);
4748 assertEquals(1, array[0]);
4749 assertEquals(2, array[1]);
4750 assertEquals(3, array[2]);
4751 assertEquals(4, array[3]);
4752 ArrayUtils.shift(array, 5);
4753 assertEquals(4, array[0]);
4754 assertEquals(1, array[1]);
4755 assertEquals(2, array[2]);
4756 assertEquals(3, array[3]);
4757 ArrayUtils.shift(array, -3);
4758 assertEquals(3, array[0]);
4759 assertEquals(4, array[1]);
4760 assertEquals(1, array[2]);
4761 assertEquals(2, array[3]);
4762 }
4763
4764 @Test
4765 void testShiftFloatArrayNull() {
4766 final float[] array = null;
4767 ArrayUtils.shift(array, 1);
4768 assertNull(array);
4769 }
4770
4771 @Test
4772 void testShiftInt() {
4773 ArrayUtils.shift((int[]) null, 1);
4774 final int[] array = {1, 2, 3, 4};
4775 ArrayUtils.shift(array, 1);
4776 assertEquals(4, array[0]);
4777 assertEquals(1, array[1]);
4778 assertEquals(2, array[2]);
4779 assertEquals(3, array[3]);
4780 ArrayUtils.shift(array, -1);
4781 assertEquals(1, array[0]);
4782 assertEquals(2, array[1]);
4783 assertEquals(3, array[2]);
4784 assertEquals(4, array[3]);
4785 ArrayUtils.shift(array, 5);
4786 assertEquals(4, array[0]);
4787 assertEquals(1, array[1]);
4788 assertEquals(2, array[2]);
4789 assertEquals(3, array[3]);
4790 ArrayUtils.shift(array, -3);
4791 assertEquals(3, array[0]);
4792 assertEquals(4, array[1]);
4793 assertEquals(1, array[2]);
4794 assertEquals(2, array[3]);
4795 }
4796
4797 @Test
4798 void testShiftIntArrayNull() {
4799 final int[] array = null;
4800 ArrayUtils.shift(array, 1);
4801 assertNull(array);
4802 }
4803
4804 @Test
4805 void testShiftLong() {
4806 ArrayUtils.shift((long[]) null, 1);
4807 final long[] array = {1, 2, 3, 4};
4808 ArrayUtils.shift(array, 1);
4809 assertEquals(4, array[0]);
4810 assertEquals(1, array[1]);
4811 assertEquals(2, array[2]);
4812 assertEquals(3, array[3]);
4813 ArrayUtils.shift(array, -1);
4814 assertEquals(1, array[0]);
4815 assertEquals(2, array[1]);
4816 assertEquals(3, array[2]);
4817 assertEquals(4, array[3]);
4818 ArrayUtils.shift(array, 5);
4819 assertEquals(4, array[0]);
4820 assertEquals(1, array[1]);
4821 assertEquals(2, array[2]);
4822 assertEquals(3, array[3]);
4823 ArrayUtils.shift(array, -3);
4824 assertEquals(3, array[0]);
4825 assertEquals(4, array[1]);
4826 assertEquals(1, array[2]);
4827 assertEquals(2, array[3]);
4828 }
4829
4830 @Test
4831 void testShiftLongArrayNull() {
4832 final long[] array = null;
4833 ArrayUtils.shift(array, 1);
4834 assertNull(array);
4835 }
4836
4837 @Test
4838 void testShiftObject() {
4839 ArrayUtils.shift((String[]) null, 1);
4840 final String[] array = {"1", "2", "3", "4"};
4841 ArrayUtils.shift(array, 1);
4842 assertEquals("4", array[0]);
4843 assertEquals("1", array[1]);
4844 assertEquals("2", array[2]);
4845 assertEquals("3", array[3]);
4846 ArrayUtils.shift(array, -1);
4847 assertEquals("1", array[0]);
4848 assertEquals("2", array[1]);
4849 assertEquals("3", array[2]);
4850 assertEquals("4", array[3]);
4851 ArrayUtils.shift(array, 5);
4852 assertEquals("4", array[0]);
4853 assertEquals("1", array[1]);
4854 assertEquals("2", array[2]);
4855 assertEquals("3", array[3]);
4856 ArrayUtils.shift(array, -3);
4857 assertEquals("3", array[0]);
4858 assertEquals("4", array[1]);
4859 assertEquals("1", array[2]);
4860 assertEquals("2", array[3]);
4861 }
4862
4863 @Test
4864 void testShiftObjectArrayNull() {
4865 final String[] array = null;
4866 ArrayUtils.shift(array, 1);
4867 assertNull(array);
4868 }
4869
4870 @Test
4871 void testShiftRangeBoolean() {
4872
4873
4874 ArrayUtils.shift((boolean[]) null, 0, 0, 0);
4875
4876 ArrayUtils.shift(new boolean[0], 100, 0, 0);
4877
4878 final boolean[] array1 = { true };
4879 ArrayUtils.shift(array1, -1, 0, 0);
4880 assertArrayEquals(new boolean[] { true }, array1);
4881
4882 final boolean[] array2 = { true, false, true };
4883 ArrayUtils.shift(array2, 1, 1, 0);
4884 assertArrayEquals(new boolean[] { true, false, true }, array2);
4885
4886 final boolean[] array = {true, false, false, false, true};
4887 ArrayUtils.shift(array, 1, 3, 1);
4888 assertEquals(true, array[0]);
4889 assertEquals(false, array[1]);
4890 assertEquals(false, array[2]);
4891 assertEquals(false, array[3]);
4892 assertEquals(true, array[4]);
4893 ArrayUtils.shift(array, 1, 4, 2);
4894 assertEquals(true, array[0]);
4895 assertEquals(false, array[1]);
4896 assertEquals(false, array[2]);
4897 assertEquals(false, array[3]);
4898 assertEquals(true, array[4]);
4899 }
4900
4901 @Test
4902 void testShiftRangeByte() {
4903
4904
4905 ArrayUtils.shift((byte[]) null, 0, 0, 0);
4906
4907 ArrayUtils.shift(new byte[0], 100, 0, 0);
4908
4909 final byte[] array1 = { 1 };
4910 ArrayUtils.shift(array1, -1, 0, 0);
4911 assertArrayEquals(new byte[] { 1 }, array1);
4912
4913 final byte[] array2 = { 1, 0, 1 };
4914 ArrayUtils.shift(array2, 1, 1, 0);
4915 assertArrayEquals(new byte[] { 1, 0, 1 }, array2);
4916
4917 final byte[] array = {1, 2, 3, 4, 5};
4918 ArrayUtils.shift(array, 1, 3, 1);
4919 assertEquals(1, array[0]);
4920 assertEquals(3, array[1]);
4921 assertEquals(2, array[2]);
4922 assertEquals(4, array[3]);
4923 assertEquals(5, array[4]);
4924 ArrayUtils.shift(array, 1, 4, 2);
4925 assertEquals(1, array[0]);
4926 assertEquals(2, array[1]);
4927 assertEquals(4, array[2]);
4928 assertEquals(3, array[3]);
4929 assertEquals(5, array[4]);
4930 }
4931
4932 @Test
4933 void testShiftRangeChar() {
4934
4935
4936 ArrayUtils.shift((char[]) null, 0, 0, 0);
4937
4938 ArrayUtils.shift(new char[0], 100, 0, 0);
4939
4940 final char[] array1 = { 1 };
4941 ArrayUtils.shift(array1, -1, 0, 0);
4942 assertArrayEquals(new char[] { 1 }, array1);
4943
4944 final char[] array2 = { 1, 0, 1 };
4945 ArrayUtils.shift(array2, 1, 1, 0);
4946 assertArrayEquals(new char[] { 1, 0, 1 }, array2);
4947
4948 final char[] array = {1, 2, 3, 4, 5};
4949 ArrayUtils.shift(array, 1, 3, 1);
4950 assertEquals(1, array[0]);
4951 assertEquals(3, array[1]);
4952 assertEquals(2, array[2]);
4953 assertEquals(4, array[3]);
4954 assertEquals(5, array[4]);
4955 ArrayUtils.shift(array, 1, 4, 2);
4956 assertEquals(1, array[0]);
4957 assertEquals(2, array[1]);
4958 assertEquals(4, array[2]);
4959 assertEquals(3, array[3]);
4960 assertEquals(5, array[4]);
4961 }
4962
4963 @Test
4964 void testShiftRangeDouble() {
4965
4966
4967 ArrayUtils.shift((double[]) null, 0, 0, 0);
4968
4969 ArrayUtils.shift(new double[0], 100, 0, 0);
4970
4971 final double[] array1 = { 1 };
4972 ArrayUtils.shift(array1, -1, 0, 0);
4973 assertArrayEquals(new double[] { 1 }, array1);
4974
4975 final double[] array2 = { 1, 0, 1 };
4976 ArrayUtils.shift(array2, 1, 1, 0);
4977 assertArrayEquals(new double[] { 1, 0, 1 }, array2);
4978
4979 final double[] array = {1, 2, 3, 4, 5};
4980 ArrayUtils.shift(array, 1, 3, 1);
4981 assertEquals(1, array[0]);
4982 assertEquals(3, array[1]);
4983 assertEquals(2, array[2]);
4984 assertEquals(4, array[3]);
4985 assertEquals(5, array[4]);
4986 ArrayUtils.shift(array, 1, 4, 2);
4987 assertEquals(1, array[0]);
4988 assertEquals(2, array[1]);
4989 assertEquals(4, array[2]);
4990 assertEquals(3, array[3]);
4991 assertEquals(5, array[4]);
4992 }
4993
4994 @Test
4995 void testShiftRangeFloat() {
4996
4997
4998 ArrayUtils.shift((float[]) null, 0, 0, 0);
4999
5000 ArrayUtils.shift(new float[0], 100, 0, 0);
5001
5002 final float[] array1 = { 1 };
5003 ArrayUtils.shift(array1, -1, 0, 0);
5004 assertArrayEquals(new float[] { 1 }, array1);
5005
5006 final float[] array2 = { 1, 0, 1 };
5007 ArrayUtils.shift(array2, 1, 1, 0);
5008 assertArrayEquals(new float[] { 1, 0, 1 }, array2);
5009
5010 final float[] array = {1, 2, 3, 4, 5};
5011 ArrayUtils.shift(array, 1, 3, 1);
5012 assertEquals(1, array[0]);
5013 assertEquals(3, array[1]);
5014 assertEquals(2, array[2]);
5015 assertEquals(4, array[3]);
5016 assertEquals(5, array[4]);
5017 ArrayUtils.shift(array, 1, 4, 2);
5018 assertEquals(1, array[0]);
5019 assertEquals(2, array[1]);
5020 assertEquals(4, array[2]);
5021 assertEquals(3, array[3]);
5022 assertEquals(5, array[4]);
5023 }
5024
5025 @Test
5026 void testShiftRangeInt() {
5027
5028
5029 ArrayUtils.shift((int[]) null, 0, 0, 0);
5030
5031 ArrayUtils.shift(new int[0], 100, 0, 0);
5032
5033 final int[] array1 = { 1 };
5034 ArrayUtils.shift(array1, -1, 0, 0);
5035 assertArrayEquals(new int[] { 1 }, array1);
5036
5037 final int[] array2 = { 1, 0, 1 };
5038 ArrayUtils.shift(array2, 1, 1, 0);
5039 assertArrayEquals(new int[] { 1, 0, 1 }, array2);
5040
5041 final int[] array = {1, 2, 3, 4, 5};
5042 ArrayUtils.shift(array, 1, 3, 1);
5043 assertEquals(1, array[0]);
5044 assertEquals(3, array[1]);
5045 assertEquals(2, array[2]);
5046 assertEquals(4, array[3]);
5047 assertEquals(5, array[4]);
5048 ArrayUtils.shift(array, 1, 4, 2);
5049 assertEquals(1, array[0]);
5050 assertEquals(2, array[1]);
5051 assertEquals(4, array[2]);
5052 assertEquals(3, array[3]);
5053 assertEquals(5, array[4]);
5054 }
5055
5056 @Test
5057 void testShiftRangeLong() {
5058
5059
5060 ArrayUtils.shift((long[]) null, 0, 0, 0);
5061
5062 ArrayUtils.shift(new long[0], 100, 0, 0);
5063
5064 final long[] array1 = { 1 };
5065 ArrayUtils.shift(array1, -1, 0, 0);
5066 assertArrayEquals(new long[] { 1 }, array1);
5067
5068 final long[] array2 = { 1, 0, 1 };
5069 ArrayUtils.shift(array2, 1, 1, 0);
5070 assertArrayEquals(new long[] { 1, 0, 1 }, array2);
5071
5072 final long[] array = {1, 2, 3, 4, 5};
5073 ArrayUtils.shift(array, 1, 3, 1);
5074 assertEquals(1, array[0]);
5075 assertEquals(3, array[1]);
5076 assertEquals(2, array[2]);
5077 assertEquals(4, array[3]);
5078 assertEquals(5, array[4]);
5079 ArrayUtils.shift(array, 1, 4, 2);
5080 assertEquals(1, array[0]);
5081 assertEquals(2, array[1]);
5082 assertEquals(4, array[2]);
5083 assertEquals(3, array[3]);
5084 assertEquals(5, array[4]);
5085 }
5086
5087 @Test
5088 void testShiftRangeNoElemByte() {
5089 final byte[] array = {1, 2, 3, 4};
5090 ArrayUtils.shift(array, 1, 1, 1);
5091 assertEquals(1, array[0]);
5092 assertEquals(2, array[1]);
5093 assertEquals(3, array[2]);
5094 assertEquals(4, array[3]);
5095 }
5096
5097 @Test
5098 void testShiftRangeNoElemChar() {
5099 final char[] array = {1, 2, 3, 4};
5100 ArrayUtils.shift(array, 1, 1, 1);
5101 assertEquals(1, array[0]);
5102 assertEquals(2, array[1]);
5103 assertEquals(3, array[2]);
5104 assertEquals(4, array[3]);
5105 }
5106
5107 @Test
5108 void testShiftRangeNoElemDouble() {
5109 final double[] array = {1, 2, 3, 4};
5110 ArrayUtils.shift(array, 1, 1, 1);
5111 assertEquals(1, array[0]);
5112 assertEquals(2, array[1]);
5113 assertEquals(3, array[2]);
5114 assertEquals(4, array[3]);
5115 }
5116
5117 @Test
5118 void testShiftRangeNoElemFloat() {
5119 final float[] array = {1, 2, 3, 4};
5120 ArrayUtils.shift(array, 1, 1, 1);
5121 assertEquals(1, array[0]);
5122 assertEquals(2, array[1]);
5123 assertEquals(3, array[2]);
5124 assertEquals(4, array[3]);
5125 }
5126
5127 @Test
5128 void testShiftRangeNoElemInt() {
5129 final int[] array = {1, 2, 3, 4};
5130 ArrayUtils.shift(array, 1, 1, 1);
5131 assertEquals(1, array[0]);
5132 assertEquals(2, array[1]);
5133 assertEquals(3, array[2]);
5134 assertEquals(4, array[3]);
5135 }
5136
5137 @Test
5138 void testShiftRangeNoElemLong() {
5139 final long[] array = {1, 2, 3, 4};
5140 ArrayUtils.shift(array, 1, 1, 1);
5141 assertEquals(1, array[0]);
5142 assertEquals(2, array[1]);
5143 assertEquals(3, array[2]);
5144 assertEquals(4, array[3]);
5145 }
5146
5147 @Test
5148 void testShiftRangeNoElemObject() {
5149 final String[] array = {"1", "2", "3", "4"};
5150 ArrayUtils.shift(array, 1, 1, 1);
5151 assertEquals("1", array[0]);
5152 assertEquals("2", array[1]);
5153 assertEquals("3", array[2]);
5154 assertEquals("4", array[3]);
5155 }
5156
5157 @Test
5158 void testShiftRangeNoElemShort() {
5159 final short[] array = {1, 2, 3, 4};
5160 ArrayUtils.shift(array, 1, 1, 1);
5161 assertEquals(1, array[0]);
5162 assertEquals(2, array[1]);
5163 assertEquals(3, array[2]);
5164 assertEquals(4, array[3]);
5165 }
5166
5167 @Test
5168 void testShiftRangeNullByte() {
5169 final byte[] array = null;
5170 ArrayUtils.shift(array, 1, 1, 1);
5171 assertNull(array);
5172 }
5173
5174 @Test
5175 void testShiftRangeNullChar() {
5176 final char[] array = null;
5177 ArrayUtils.shift(array, 1, 1, 1);
5178 assertNull(array);
5179 }
5180
5181 @Test
5182 void testShiftRangeNullDouble() {
5183 final double[] array = null;
5184 ArrayUtils.shift(array, 1, 1, 1);
5185 assertNull(array);
5186 }
5187
5188 @Test
5189 void testShiftRangeNullFloat() {
5190 final float[] array = null;
5191 ArrayUtils.shift(array, 1, 1, 1);
5192 assertNull(array);
5193 }
5194
5195 @Test
5196 void testShiftRangeNullInt() {
5197 final int[] array = null;
5198 ArrayUtils.shift(array, 1, 1, 1);
5199 assertNull(array);
5200 }
5201
5202 @Test
5203 void testShiftRangeNullLong() {
5204 final long[] array = null;
5205 ArrayUtils.shift(array, 1, 1, 1);
5206 assertNull(array);
5207 }
5208
5209 @Test
5210 void testShiftRangeNullObject() {
5211 final String[] array = null;
5212 ArrayUtils.shift(array, 1, 1, 1);
5213 assertNull(array);
5214 }
5215
5216 @Test
5217 void testShiftRangeNullShort() {
5218 final short[] array = null;
5219 ArrayUtils.shift(array, 1, 1, 1);
5220 assertNull(array);
5221 }
5222
5223 @Test
5224 void testShiftRangeObject() {
5225 final String[] array = {"1", "2", "3", "4", "5"};
5226 ArrayUtils.shift(array, 1, 3, 1);
5227 assertEquals("1", array[0]);
5228 assertEquals("3", array[1]);
5229 assertEquals("2", array[2]);
5230 assertEquals("4", array[3]);
5231 assertEquals("5", array[4]);
5232 ArrayUtils.shift(array, 1, 4, 2);
5233 assertEquals("1", array[0]);
5234 assertEquals("2", array[1]);
5235 assertEquals("4", array[2]);
5236 assertEquals("3", array[3]);
5237 assertEquals("5", array[4]);
5238 }
5239
5240 @Test
5241 void testShiftRangeShort() {
5242
5243
5244 ArrayUtils.shift((short[]) null, 0, 0, 0);
5245
5246 ArrayUtils.shift(new short[0], 100, 0, 0);
5247
5248 final short[] array1 = { 1 };
5249 ArrayUtils.shift(array1, -1, 0, 0);
5250 assertArrayEquals(new short[] { 1 }, array1);
5251
5252 final short[] array2 = { 1, 0, 1 };
5253 ArrayUtils.shift(array2, 1, 1, 0);
5254 assertArrayEquals(new short[] { 1, 0, 1 }, array2);
5255
5256 final short[] array = {1, 2, 3, 4, 5};
5257 ArrayUtils.shift(array, 1, 3, 1);
5258 assertEquals(1, array[0]);
5259 assertEquals(3, array[1]);
5260 assertEquals(2, array[2]);
5261 assertEquals(4, array[3]);
5262 assertEquals(5, array[4]);
5263 ArrayUtils.shift(array, 1, 4, 2);
5264 assertEquals(1, array[0]);
5265 assertEquals(2, array[1]);
5266 assertEquals(4, array[2]);
5267 assertEquals(3, array[3]);
5268 assertEquals(5, array[4]);
5269 }
5270
5271 @Test
5272 void testShiftShort() {
5273 ArrayUtils.shift((short[]) null, 1);
5274 short[] array = {1, 2, 3, 4};
5275 ArrayUtils.shift(array, 1);
5276 assertEquals(4, array[0]);
5277 assertEquals(1, array[1]);
5278 assertEquals(2, array[2]);
5279 assertEquals(3, array[3]);
5280 ArrayUtils.shift(array, -1);
5281 assertEquals(1, array[0]);
5282 assertEquals(2, array[1]);
5283 assertEquals(3, array[2]);
5284 assertEquals(4, array[3]);
5285 ArrayUtils.shift(array, 5);
5286 assertEquals(4, array[0]);
5287 assertEquals(1, array[1]);
5288 assertEquals(2, array[2]);
5289 assertEquals(3, array[3]);
5290 ArrayUtils.shift(array, -3);
5291 assertEquals(3, array[0]);
5292 assertEquals(4, array[1]);
5293 assertEquals(1, array[2]);
5294 assertEquals(2, array[3]);
5295 array = new short[]{1, 2, 3, 4, 5};
5296 ArrayUtils.shift(array, 2);
5297 assertEquals(4, array[0]);
5298 assertEquals(5, array[1]);
5299 assertEquals(1, array[2]);
5300 assertEquals(2, array[3]);
5301 assertEquals(3, array[4]);
5302 }
5303
5304 @Test
5305 void testShiftShortArrayNull() {
5306 final short[] array = null;
5307 ArrayUtils.shift(array, 1);
5308 assertNull(array);
5309 }
5310
5311 @Test
5312 void testShuffleBoolean() {
5313 ArrayUtils.shuffle((boolean[]) null);
5314 ArrayUtils.shuffle(ArrayUtils.EMPTY_BOOLEAN_ARRAY);
5315
5316 final boolean[] array1 = { true, false, true, true, false, false, true, false, false, true, true, false, true, true, false, false, true, false, false,
5317 true, true, false, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false, false,
5318 false, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false };
5319 final boolean[] array2 = ArrayUtils.clone(array1);
5320 ArrayUtils.shuffle(array1);
5321 assertFalse(Arrays.equals(array1, array2));
5322 }
5323
5324 @Test
5325 void testShuffleBooleanRandom() {
5326 ArrayUtils.shuffle((boolean[]) null, null);
5327 ArrayUtils.shuffle((boolean[]) null, seededRandom());
5328 ArrayUtils.shuffle(ArrayUtils.EMPTY_BOOLEAN_ARRAY, null);
5329 ArrayUtils.shuffle(ArrayUtils.EMPTY_BOOLEAN_ARRAY, seededRandom());
5330
5331 final boolean[] array1 = { true, false, true, true, false, false, true, false, false, true, true, false, true, true, false, false, true, false, false,
5332 true, true, false, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false, false,
5333 false, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false };
5334 final boolean[] array2 = ArrayUtils.clone(array1);
5335
5336 ArrayUtils.shuffle(array1, null);
5337 assertTrue(Arrays.equals(array1, array2));
5338
5339 ArrayUtils.shuffle(array1, seededRandom());
5340 assertFalse(Arrays.equals(array1, array2));
5341 }
5342
5343 @Test
5344 void testShuffleByte() {
5345 ArrayUtils.shuffle((byte[]) null);
5346 ArrayUtils.shuffle(ArrayUtils.EMPTY_BYTE_ARRAY);
5347
5348 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,
5349 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,
5350 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 };
5351 final byte[] array2 = ArrayUtils.clone(array1);
5352 ArrayUtils.shuffle(array1);
5353 assertFalse(Arrays.equals(array1, array2));
5354 for (final byte element : array2) {
5355 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5356 }
5357 }
5358
5359 @Test
5360 void testShuffleByteRandom() {
5361 ArrayUtils.shuffle((byte[]) null, null);
5362 ArrayUtils.shuffle((byte[]) null, seededRandom());
5363 ArrayUtils.shuffle(ArrayUtils.EMPTY_BYTE_ARRAY, null);
5364 ArrayUtils.shuffle(ArrayUtils.EMPTY_BYTE_ARRAY, seededRandom());
5365
5366 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,
5367 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,
5368 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 };
5369 final byte[] array2 = ArrayUtils.clone(array1);
5370
5371 ArrayUtils.shuffle(array1, null);
5372 assertTrue(Arrays.equals(array1, array2));
5373
5374 ArrayUtils.shuffle(array1, seededRandom());
5375 assertFalse(Arrays.equals(array1, array2));
5376 for (final byte element : array2) {
5377 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5378 }
5379 }
5380
5381 @Test
5382 void testShuffleChar() {
5383 ArrayUtils.shuffle((char[]) null);
5384 ArrayUtils.shuffle(ArrayUtils.EMPTY_CHAR_ARRAY);
5385
5386 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,
5387 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,
5388 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 };
5389 final char[] array2 = ArrayUtils.clone(array1);
5390 ArrayUtils.shuffle(array1);
5391 assertFalse(Arrays.equals(array1, array2));
5392 for (final char element : array2) {
5393 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5394 }
5395 }
5396
5397 @Test
5398 void testShuffleCharRandom() {
5399 ArrayUtils.shuffle((char[]) null, null);
5400 ArrayUtils.shuffle((char[]) null, seededRandom());
5401 ArrayUtils.shuffle(ArrayUtils.EMPTY_CHAR_ARRAY, null);
5402 ArrayUtils.shuffle(ArrayUtils.EMPTY_CHAR_ARRAY, seededRandom());
5403
5404 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,
5405 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,
5406 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 };
5407 final char[] array2 = ArrayUtils.clone(array1);
5408
5409 ArrayUtils.shuffle(array1, null);
5410 assertTrue(Arrays.equals(array1, array2));
5411
5412 ArrayUtils.shuffle(array1, seededRandom());
5413 assertFalse(Arrays.equals(array1, array2));
5414 for (final char element : array2) {
5415 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5416 }
5417 }
5418
5419 @Test
5420 void testShuffleDouble() {
5421 ArrayUtils.shuffle((double[]) null);
5422 ArrayUtils.shuffle(ArrayUtils.EMPTY_DOUBLE_ARRAY);
5423
5424 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,
5425 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,
5426 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 };
5427 final double[] array2 = ArrayUtils.clone(array1);
5428 ArrayUtils.shuffle(array1);
5429 assertFalse(Arrays.equals(array1, array2));
5430 for (final double element : array2) {
5431 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5432 }
5433 }
5434
5435 @Test
5436 void testShuffleDoubleRandom() {
5437 ArrayUtils.shuffle((double[]) null, null);
5438 ArrayUtils.shuffle((double[]) null, seededRandom());
5439 ArrayUtils.shuffle(ArrayUtils.EMPTY_DOUBLE_ARRAY, null);
5440 ArrayUtils.shuffle(ArrayUtils.EMPTY_DOUBLE_ARRAY, seededRandom());
5441
5442 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,
5443 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,
5444 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 };
5445 final double[] array2 = ArrayUtils.clone(array1);
5446
5447 ArrayUtils.shuffle(array1, null);
5448 assertTrue(Arrays.equals(array1, array2));
5449
5450 ArrayUtils.shuffle(array1, seededRandom());
5451 assertFalse(Arrays.equals(array1, array2));
5452 for (final double element : array2) {
5453 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5454 }
5455 }
5456
5457 @Test
5458 void testShuffleFloat() {
5459 ArrayUtils.shuffle((float[]) null);
5460 ArrayUtils.shuffle(ArrayUtils.EMPTY_FLOAT_ARRAY);
5461
5462 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,
5463 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,
5464 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 };
5465 final float[] array2 = ArrayUtils.clone(array1);
5466 ArrayUtils.shuffle(array1);
5467 assertFalse(Arrays.equals(array1, array2));
5468 for (final float element : array2) {
5469 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5470 }
5471 }
5472
5473 @Test
5474 void testShuffleFloatRandom() {
5475 ArrayUtils.shuffle((float[]) null, null);
5476 ArrayUtils.shuffle((float[]) null, seededRandom());
5477 ArrayUtils.shuffle(ArrayUtils.EMPTY_FLOAT_ARRAY, null);
5478 ArrayUtils.shuffle(ArrayUtils.EMPTY_FLOAT_ARRAY, seededRandom());
5479
5480 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,
5481 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,
5482 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 };
5483 final float[] array2 = ArrayUtils.clone(array1);
5484
5485 ArrayUtils.shuffle(array1, null);
5486 assertTrue(Arrays.equals(array1, array2));
5487
5488 ArrayUtils.shuffle(array1, seededRandom());
5489 assertFalse(Arrays.equals(array1, array2));
5490 for (final float element : array2) {
5491 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5492 }
5493 }
5494
5495 @Test
5496 void testShuffleInt() {
5497 ArrayUtils.shuffle((int[]) null);
5498 ArrayUtils.shuffle(ArrayUtils.EMPTY_INT_ARRAY);
5499
5500 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,
5501 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,
5502 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 };
5503 final int[] array2 = ArrayUtils.clone(array1);
5504 ArrayUtils.shuffle(array1, seededRandom());
5505 assertFalse(Arrays.equals(array1, array2));
5506 for (final int element : array2) {
5507 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5508 }
5509 }
5510
5511 @Test
5512 void testShuffleIntRandom() {
5513 ArrayUtils.shuffle((int[]) null, null);
5514 ArrayUtils.shuffle((int[]) null, seededRandom());
5515 ArrayUtils.shuffle(ArrayUtils.EMPTY_INT_ARRAY, null);
5516 ArrayUtils.shuffle(ArrayUtils.EMPTY_INT_ARRAY, seededRandom());
5517
5518 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,
5519 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,
5520 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 };
5521 final int[] array2 = ArrayUtils.clone(array1);
5522
5523 ArrayUtils.shuffle(array1, null);
5524 assertTrue(Arrays.equals(array1, array2));
5525
5526 ArrayUtils.shuffle(array1);
5527 assertFalse(Arrays.equals(array1, array2));
5528 for (final int element : array2) {
5529 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5530 }
5531 }
5532
5533 @Test
5534 void testShuffleLong() {
5535 ArrayUtils.shuffle((long[]) null);
5536 ArrayUtils.shuffle(ArrayUtils.EMPTY_LONG_ARRAY);
5537
5538 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,
5539 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,
5540 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 };
5541 final long[] array2 = ArrayUtils.clone(array1);
5542 ArrayUtils.shuffle(array1);
5543 assertFalse(Arrays.equals(array1, array2));
5544 for (final long element : array2) {
5545 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5546 }
5547 }
5548
5549 @Test
5550 void testShuffleLongRandom() {
5551 ArrayUtils.shuffle((long[]) null, null);
5552 ArrayUtils.shuffle((long[]) null, seededRandom());
5553 ArrayUtils.shuffle(ArrayUtils.EMPTY_LONG_ARRAY, null);
5554 ArrayUtils.shuffle(ArrayUtils.EMPTY_LONG_ARRAY, seededRandom());
5555
5556 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,
5557 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,
5558 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 };
5559 final long[] array2 = ArrayUtils.clone(array1);
5560
5561 ArrayUtils.shuffle(array1, null);
5562 assertTrue(Arrays.equals(array1, array2));
5563
5564 ArrayUtils.shuffle(array1, seededRandom());
5565 assertFalse(Arrays.equals(array1, array2));
5566 for (final long element : array2) {
5567 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5568 }
5569 }
5570
5571 @Test
5572 void testShuffleShort() {
5573 ArrayUtils.shuffle((short[]) null);
5574 ArrayUtils.shuffle(ArrayUtils.EMPTY_SHORT_ARRAY);
5575
5576 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,
5577 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,
5578 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 };
5579 final short[] array2 = ArrayUtils.clone(array1);
5580 ArrayUtils.shuffle(array1);
5581 assertFalse(Arrays.equals(array1, array2));
5582 for (final short element : array2) {
5583 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5584 }
5585 }
5586
5587 @Test
5588 void testShuffleShortRandom() {
5589 ArrayUtils.shuffle((short[]) null, null);
5590 ArrayUtils.shuffle((short[]) null, seededRandom());
5591 ArrayUtils.shuffle(ArrayUtils.EMPTY_SHORT_ARRAY, null);
5592 ArrayUtils.shuffle(ArrayUtils.EMPTY_SHORT_ARRAY, seededRandom());
5593
5594 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,
5595 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,
5596 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 };
5597 final short[] array2 = ArrayUtils.clone(array1);
5598
5599 ArrayUtils.shuffle(array1, null);
5600 assertTrue(Arrays.equals(array1, array2));
5601
5602 ArrayUtils.shuffle(array1, seededRandom());
5603 assertFalse(Arrays.equals(array1, array2));
5604 for (final short element : array2) {
5605 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5606 }
5607 }
5608
5609 @Test
5610 void testShuffleString() {
5611 ArrayUtils.shuffle((String[]) null);
5612 ArrayUtils.shuffle(ArrayUtils.EMPTY_STRING_ARRAY);
5613
5614 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",
5615 "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",
5616 "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
5617 final String[] array2 = ArrayUtils.clone(array1);
5618 ArrayUtils.shuffle(array1);
5619 assertFalse(Arrays.equals(array1, array2));
5620 for (final String element : array2) {
5621 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5622 }
5623 }
5624
5625 @Test
5626 void testShuffleStringRandom() {
5627 ArrayUtils.shuffle((String[]) null, null);
5628 ArrayUtils.shuffle((String[]) null, seededRandom());
5629 ArrayUtils.shuffle(ArrayUtils.EMPTY_STRING_ARRAY, null);
5630 ArrayUtils.shuffle(ArrayUtils.EMPTY_STRING_ARRAY, seededRandom());
5631
5632 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",
5633 "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",
5634 "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
5635 final String[] array2 = ArrayUtils.clone(array1);
5636
5637 ArrayUtils.shuffle(array1, null);
5638 assertTrue(Arrays.equals(array1, array2));
5639
5640 ArrayUtils.shuffle(array1, seededRandom());
5641 assertFalse(Arrays.equals(array1, array2));
5642 for (final String element : array2) {
5643 assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
5644 }
5645 }
5646
5647 @Test
5648 void testStartsWith() {
5649
5650 assertTrue(ArrayUtils.startsWith(null, null));
5651 assertFalse(ArrayUtils.startsWith(ArrayUtils.EMPTY_BYTE_ARRAY, null));
5652 assertFalse(ArrayUtils.startsWith(null, ArrayUtils.EMPTY_BYTE_ARRAY));
5653 assertTrue(ArrayUtils.startsWith(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.EMPTY_BYTE_ARRAY));
5654 assertTrue(ArrayUtils.startsWith(new byte[0], new byte[0]));
5655
5656 assertTrue(ArrayUtils.startsWith(new byte[10], new byte[10]));
5657 assertTrue(ArrayUtils.startsWith(new byte[10], new byte[9]));
5658 assertTrue(ArrayUtils.startsWith(new byte[10], new byte[1]));
5659 final byte[] sig = "Signature".getBytes(StandardCharsets.US_ASCII);
5660 final byte[] data = new byte[1024];
5661
5662 assertFalse(ArrayUtils.startsWith(data, sig));
5663
5664 System.arraycopy(sig, 0, data, 0, sig.length - 1);
5665 assertFalse(ArrayUtils.startsWith(data, sig));
5666
5667 System.arraycopy(sig, 0, data, 0, sig.length);
5668 data[0] = 0;
5669 assertFalse(ArrayUtils.startsWith(data, sig));
5670
5671 System.arraycopy(sig, 0, data, 0, sig.length);
5672 assertTrue(ArrayUtils.startsWith(data, sig));
5673
5674 assertFalse(ArrayUtils.startsWith(new byte[1], new byte[2]));
5675 }
5676
5677 @Test
5678 void testSubarrayBoolean() {
5679 final boolean[] nullArray = null;
5680 final boolean[] array = {true, true, false, true, false, true};
5681 final boolean[] leftSubarray = {true, true, false, true};
5682 final boolean[] midSubarray = {true, false, true, false};
5683 final boolean[] rightSubarray = {false, true, false, true};
5684
5685 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5686 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5687 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5688 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5689 "mid start, length end");
5690
5691 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5692 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2),
5693 "empty array");
5694 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5695 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5696 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5697 "start undershoot, normal end");
5698 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5699 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5700 "normal start, end overshoot");
5701 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5702
5703
5704
5705 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2),
5706 "empty array, object test");
5707 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5708 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 2147483647, -2147483648), "start > end, object test");
5709 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5710 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5711 "start overshoot, any end, object test");
5712
5713
5714
5715 assertSame(boolean.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "boolean type");
5716 }
5717
5718 @Test
5719 void testSubarrayByte() {
5720 final byte[] nullArray = null;
5721 final byte[] array = { 10, 11, 12, 13, 14, 15 };
5722 final byte[] leftSubarray = { 10, 11, 12, 13 };
5723 final byte[] midSubarray = { 11, 12, 13, 14 };
5724 final byte[] rightSubarray = { 12, 13, 14, 15 };
5725 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5726 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5727 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5728 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
5729 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5730 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2), "empty array");
5731 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5732 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5733 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
5734 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5735 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
5736 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5737
5738 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2), "empty array, object test");
5739 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5740 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 2147483647, -2147483648), "start > end, possible overflow");
5741 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5742 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
5743
5744 assertSame(byte.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "byte type");
5745 }
5746
5747 @Test
5748 void testSubarrayDouble() {
5749 final double[] nullArray = null;
5750 final double[] array = { 10.123, 11.234, 12.345, 13.456, 14.567, 15.678 };
5751 final double[] leftSubarray = { 10.123, 11.234, 12.345, 13.456 };
5752 final double[] midSubarray = { 11.234, 12.345, 13.456, 14.567 };
5753 final double[] rightSubarray = { 12.345, 13.456, 14.567, 15.678 };
5754 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5755 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5756 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5757 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
5758 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5759 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2), "empty array");
5760 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5761 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5762 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
5763 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5764 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
5765 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5766
5767 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2), "empty array, object test");
5768 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5769 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 2147483647, -2147483648), "start > end, possible overflow");
5770 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5771 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
5772
5773 assertSame(double.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "double type");
5774 }
5775
5776 @Test
5777 void testSubarrayFloat() {
5778 final float[] nullArray = null;
5779 final float[] array = { 10, 11, 12, 13, 14, 15 };
5780 final float[] leftSubarray = { 10, 11, 12, 13 };
5781 final float[] midSubarray = { 11, 12, 13, 14 };
5782 final float[] rightSubarray = { 12, 13, 14, 15 };
5783 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5784 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5785 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5786 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
5787 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5788 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2), "empty array");
5789 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5790 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5791 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
5792 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5793 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
5794 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5795
5796 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2), "empty array, object test");
5797 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5798 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 2147483647, -2147483648), "start > end, possible overflow");
5799 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5800 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
5801
5802 assertSame(float.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "float type");
5803 }
5804
5805 @Test
5806 void testSubarrayInt() {
5807 final int[] nullArray = null;
5808 final int[] array = { 10, 11, 12, 13, 14, 15 };
5809 final int[] leftSubarray = { 10, 11, 12, 13 };
5810 final int[] midSubarray = { 11, 12, 13, 14 };
5811 final int[] rightSubarray = { 12, 13, 14, 15 };
5812 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5813 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5814 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5815 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
5816 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5817 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), "empty array");
5818 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5819 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5820 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
5821 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5822 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
5823 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5824
5825 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), "empty array, object test");
5826 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5827 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 2147483647, -2147483648), "start > end, possible overflow");
5828 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5829 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
5830
5831 assertSame(int.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "int type");
5832 }
5833
5834 @Test
5835 void testSubarrayLong() {
5836 final long[] nullArray = null;
5837 final long[] array = {999910, 999911, 999912, 999913, 999914, 999915};
5838 final long[] leftSubarray = {999910, 999911, 999912, 999913};
5839 final long[] midSubarray = {999911, 999912, 999913, 999914};
5840 final long[] rightSubarray = {999912, 999913, 999914, 999915};
5841
5842 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5843
5844 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5845
5846 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5847
5848 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5849 "mid start, length end");
5850
5851 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5852
5853 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2),
5854 "empty array");
5855
5856 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5857
5858 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5859
5860 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5861 "start undershoot, normal end");
5862
5863 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5864
5865 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5866 "normal start, end overshoot");
5867
5868 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5869
5870
5871
5872 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2),
5873 "empty array, object test");
5874
5875 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5876 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 2147483647, -2147483648), "start > end, possible overflow");
5877
5878 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5879
5880 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5881 "start overshoot, any end, object test");
5882
5883
5884
5885 assertSame(long.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "long type");
5886
5887 }
5888
5889 @Test
5890 void testSubarrayObject() {
5891 final Object[] nullArray = null;
5892 final Object[] objectArray = {"a", "b", "c", "d", "e", "f"};
5893
5894 assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4)), "0 start, mid end");
5895 assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length)),
5896 "0 start, length end");
5897 assertEquals("bcd", StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4)), "mid start, mid end");
5898 assertEquals("bcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length)),
5899 "mid start, length end");
5900
5901 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5902 assertEquals("", StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2)), "empty array");
5903 assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2)), "start > end");
5904 assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 2147483647, -2147483648)), "start > end");
5905 assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3)), "start == end");
5906 assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4)), "start undershoot, normal end");
5907 assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4)), "start overshoot, any end");
5908 assertEquals("cdef", StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33)), "normal start, end overshoot");
5909 assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12)),
5910 "start undershoot, end overshoot");
5911
5912
5913 final Date[] dateArray = {new java.sql.Date(new Date().getTime()),
5914 new Date(), new Date(), new Date(), new Date()};
5915
5916 assertSame(Object.class, ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType(), "Object type");
5917 assertSame(Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(),
5918 "java.util.Date type");
5919 assertNotSame(java.sql.Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(),
5920 "java.sql.Date type");
5921 assertThrows(ClassCastException.class,
5922 () -> java.sql.Date[].class.cast(ArrayUtils.subarray(dateArray, 1, 3)),
5923 "Invalid downcast");
5924 }
5925
5926 @Test
5927 void testSubarrayShort() {
5928 final short[] nullArray = null;
5929 final short[] array = {10, 11, 12, 13, 14, 15};
5930 final short[] leftSubarray = {10, 11, 12, 13};
5931 final short[] midSubarray = {11, 12, 13, 14};
5932 final short[] rightSubarray = {12, 13, 14, 15};
5933
5934 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5935 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5936 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5937 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
5938 "mid start, length end");
5939
5940 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5941 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2),
5942 "empty array");
5943 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5944 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5945 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
5946 "start undershoot, normal end");
5947 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5948 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
5949 "normal start, end overshoot");
5950 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5951
5952
5953
5954 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2),
5955 "empty array, object test");
5956 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5957 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 2147483647, -2147483648), "start > end, possible overflow");
5958 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5959 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 8733, 4),
5960 "start overshoot, any end, object test");
5961
5962
5963
5964 assertSame(short.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "short type");
5965 }
5966
5967 @Test
5968 void testSubarrChar() {
5969 final char[] nullArray = null;
5970 final char[] array = { 'a', 'b', 'c', 'd', 'e', 'f' };
5971 final char[] leftSubarray = { 'a', 'b', 'c', 'd' };
5972 final char[] midSubarray = { 'b', 'c', 'd', 'e' };
5973 final char[] rightSubarray = { 'c', 'd', 'e', 'f' };
5974
5975 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
5976 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
5977 assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
5978 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
5979
5980 assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
5981 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), "empty array");
5982 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
5983 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
5984 assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
5985 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
5986 assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
5987 assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
5988
5989
5990
5991 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), "empty array, object test");
5992 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
5993 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 2147483647, -2147483648), "start > end, possible overflow");
5994 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
5995 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
5996
5997
5998
5999 assertSame(char.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "char type");
6000 }
6001
6002 @Test
6003 void testSwapBoolean() {
6004 final boolean[] array = { true, false, false };
6005 ArrayUtils.swap(array, 0, 2);
6006 assertFalse(array[0]);
6007 assertFalse(array[1]);
6008 assertTrue(array[2]);
6009 }
6010
6011 @Test
6012 void testSwapBooleanRange() {
6013
6014 ArrayUtils.swap((boolean[]) null, 0, 2, 1);
6015 ArrayUtils.swap(new boolean[0], 0, 2, 1);
6016 final boolean[] array3a = {true, false, true};
6017 final boolean[] array3b = array3a.clone();
6018
6019 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6020 assertArrayEquals(array3a, array3b);
6021
6022 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6023 assertArrayEquals(array3a, array3b);
6024
6025 boolean[] array = { false, false, true, true };
6026 ArrayUtils.swap(array, 0, 2, 2);
6027 assertTrue(array[0]);
6028 assertTrue(array[1]);
6029 assertFalse(array[2]);
6030 assertFalse(array[3]);
6031
6032 array = new boolean[] { false, true, false };
6033 ArrayUtils.swap(array, 0, 3);
6034 assertFalse(array[0]);
6035 assertTrue(array[1]);
6036 assertFalse(array[2]);
6037
6038 array = new boolean[] { true, true, false };
6039 ArrayUtils.swap(array, 0, 2, 2);
6040 assertFalse(array[0]);
6041 assertTrue(array[1]);
6042 assertTrue(array[2]);
6043
6044 array = new boolean[] { true, true, false };
6045 ArrayUtils.swap(array, -1, 2, 2);
6046 assertFalse(array[0]);
6047 assertTrue(array[1]);
6048 assertTrue(array[2]);
6049
6050 array = new boolean[] { true, true, false };
6051 ArrayUtils.swap(array, 0, -1, 2);
6052 assertTrue(array[0]);
6053 assertTrue(array[1]);
6054 assertFalse(array[2]);
6055
6056 array = new boolean[] { true, true, false };
6057 ArrayUtils.swap(array, -1, -1, 2);
6058 assertTrue(array[0]);
6059 assertTrue(array[1]);
6060 assertFalse(array[2]);
6061 }
6062
6063 @Test
6064 void testSwapByte() {
6065 final byte[] array = { 1, 2, 3 };
6066 ArrayUtils.swap(array, 0, 2);
6067 assertEquals(3, array[0]);
6068 assertEquals(2, array[1]);
6069 assertEquals(1, array[2]);
6070 }
6071
6072 @Test
6073 void testSwapByteRange() {
6074
6075 ArrayUtils.swap((byte[]) null, 0, 2, 1);
6076 ArrayUtils.swap(new byte[0], 0, 2, 1);
6077 final byte[] array3a = {1, 0, 1};
6078 final byte[] array3b = array3a.clone();
6079
6080 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6081 assertArrayEquals(array3a, array3b);
6082
6083 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6084 assertArrayEquals(array3a, array3b);
6085
6086 byte[] array = { 1, 2, 3, 4 };
6087 ArrayUtils.swap(array, 0, 2, 2);
6088 assertEquals(3, array[0]);
6089 assertEquals(4, array[1]);
6090 assertEquals(1, array[2]);
6091 assertEquals(2, array[3]);
6092
6093 array = new byte[] { 1, 2, 3 };
6094 ArrayUtils.swap(array, 0, 3);
6095 assertEquals(1, array[0]);
6096 assertEquals(2, array[1]);
6097 assertEquals(3, array[2]);
6098
6099 array = new byte[] { 1, 2, 3 };
6100 ArrayUtils.swap(array, 0, 2, 2);
6101 assertEquals(3, array[0]);
6102 assertEquals(2, array[1]);
6103 assertEquals(1, array[2]);
6104
6105 array = new byte[] { 1, 2, 3 };
6106 ArrayUtils.swap(array, -1, 2, 2);
6107 assertEquals(3, array[0]);
6108 assertEquals(2, array[1]);
6109 assertEquals(1, array[2]);
6110
6111 array = new byte[] { 1, 2, 3 };
6112 ArrayUtils.swap(array, 0, -1, 2);
6113 assertEquals(1, array[0]);
6114 assertEquals(2, array[1]);
6115 assertEquals(3, array[2]);
6116
6117 array = new byte[] { 1, 2, 3 };
6118 ArrayUtils.swap(array, -1, -1, 2);
6119 assertEquals(1, array[0]);
6120 assertEquals(2, array[1]);
6121 assertEquals(3, array[2]);
6122 }
6123
6124 @Test
6125 void testSwapChar() {
6126 char[] array = { 1, 2, 3 };
6127 ArrayUtils.swap(array, 0, 2);
6128 assertArrayEquals(new char[] { 3, 2, 1 }, array);
6129
6130 array = new char[] { 1, 2, 3 };
6131 ArrayUtils.swap(array, 0, 0);
6132 assertArrayEquals(new char[] { 1, 2, 3 }, array);
6133
6134 array = new char[] { 1, 2, 3 };
6135 ArrayUtils.swap(array, 1, 0);
6136 assertArrayEquals(new char[] { 2, 1, 3 }, array);
6137 }
6138
6139 @Test
6140 void testSwapCharRange() {
6141
6142 ArrayUtils.swap((char[]) null, 0, 2, 1);
6143 ArrayUtils.swap(new char[0], 0, 2, 1);
6144 final char[] array3a = {1, 0, 1};
6145 final char[] array3b = array3a.clone();
6146
6147 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6148 assertArrayEquals(array3a, array3b);
6149
6150 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6151 assertArrayEquals(array3a, array3b);
6152
6153 char[] array = { 1, 2, 3, 4 };
6154 ArrayUtils.swap(array, 0, 2, 2);
6155 assertEquals(3, array[0]);
6156 assertEquals(4, array[1]);
6157 assertEquals(1, array[2]);
6158 assertEquals(2, array[3]);
6159
6160 array = new char[] { 1, 2, 3 };
6161 ArrayUtils.swap(array, 0, 3);
6162 assertEquals(1, array[0]);
6163 assertEquals(2, array[1]);
6164 assertEquals(3, array[2]);
6165
6166 array = new char[] { 1, 2, 3 };
6167 ArrayUtils.swap(array, 0, 2, 2);
6168 assertEquals(3, array[0]);
6169 assertEquals(2, array[1]);
6170 assertEquals(1, array[2]);
6171
6172 array = new char[] { 1, 2, 3 };
6173 ArrayUtils.swap(array, -1, 2, 2);
6174 assertEquals(3, array[0]);
6175 assertEquals(2, array[1]);
6176 assertEquals(1, array[2]);
6177
6178 array = new char[] { 1, 2, 3 };
6179 ArrayUtils.swap(array, 0, -1, 2);
6180 assertEquals(1, array[0]);
6181 assertEquals(2, array[1]);
6182 assertEquals(3, array[2]);
6183
6184 array = new char[] { 1, 2, 3 };
6185 ArrayUtils.swap(array, -1, -1, 2);
6186 assertEquals(1, array[0]);
6187 assertEquals(2, array[1]);
6188 assertEquals(3, array[2]);
6189 }
6190
6191 @Test
6192 void testSwapDouble() {
6193 final double[] array = { 1, 2, 3 };
6194 ArrayUtils.swap(array, 0, 2);
6195 assertEquals(3, array[0]);
6196 assertEquals(2, array[1]);
6197 assertEquals(1, array[2]);
6198 }
6199
6200 @Test
6201 void testSwapDoubleRange() {
6202
6203 ArrayUtils.swap((double[]) null, 0, 2, 1);
6204 ArrayUtils.swap(new double[0], 0, 2, 1);
6205 final double[] array3a = {1, 0, 1};
6206 final double[] array3b = array3a.clone();
6207
6208 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6209 assertArrayEquals(array3a, array3b);
6210
6211 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6212 assertArrayEquals(array3a, array3b);
6213
6214 double[] array = { 1, 2, 3, 4 };
6215 ArrayUtils.swap(array, 0, 2, 2);
6216 assertEquals(3, array[0]);
6217 assertEquals(4, array[1]);
6218 assertEquals(1, array[2]);
6219 assertEquals(2, array[3]);
6220
6221 array = new double[] { 1, 2, 3 };
6222 ArrayUtils.swap(array, 0, 3);
6223 assertEquals(1, array[0]);
6224 assertEquals(2, array[1]);
6225 assertEquals(3, array[2]);
6226
6227 array = new double[] { 1, 2, 3 };
6228 ArrayUtils.swap(array, 0, 2, 2);
6229 assertEquals(3, array[0]);
6230 assertEquals(2, array[1]);
6231 assertEquals(1, array[2]);
6232
6233 array = new double[] { 1, 2, 3 };
6234 ArrayUtils.swap(array, -1, 2, 2);
6235 assertEquals(3, array[0]);
6236 assertEquals(2, array[1]);
6237 assertEquals(1, array[2]);
6238
6239 array = new double[] { 1, 2, 3 };
6240 ArrayUtils.swap(array, 0, -1, 2);
6241 assertEquals(1, array[0]);
6242 assertEquals(2, array[1]);
6243 assertEquals(3, array[2]);
6244
6245 array = new double[] { 1, 2, 3 };
6246 ArrayUtils.swap(array, -1, -1, 2);
6247 assertEquals(1, array[0]);
6248 assertEquals(2, array[1]);
6249 assertEquals(3, array[2]);
6250 }
6251
6252 @Test
6253 void testSwapEmptyBooleanArray() {
6254 final boolean[] array = {};
6255 ArrayUtils.swap(array, 0, 2);
6256 assertEquals(0, array.length);
6257 }
6258
6259 @Test
6260 void testSwapEmptyByteArray() {
6261 final byte[] array = {};
6262 ArrayUtils.swap(array, 0, 2);
6263 assertEquals(0, array.length);
6264 }
6265
6266 @Test
6267 void testSwapEmptyCharArray() {
6268 final char[] array = {};
6269 ArrayUtils.swap(array, 0, 2);
6270 assertEquals(0, array.length);
6271 }
6272
6273 @Test
6274 void testSwapEmptyDoubleArray() {
6275 final double[] array = {};
6276 ArrayUtils.swap(array, 0, 2);
6277 assertEquals(0, array.length);
6278 }
6279
6280 @Test
6281 void testSwapEmptyFloatArray() {
6282 final float[] array = {};
6283 ArrayUtils.swap(array, 0, 2);
6284 assertEquals(0, array.length);
6285 }
6286
6287 @Test
6288 void testSwapEmptyIntArray() {
6289 final int[] array = {};
6290 ArrayUtils.swap(array, 0, 2);
6291 assertEquals(0, array.length);
6292 }
6293
6294 @Test
6295 void testSwapEmptyLongArray() {
6296 final long[] array = {};
6297 ArrayUtils.swap(array, 0, 2);
6298 assertEquals(0, array.length);
6299 }
6300
6301 @Test
6302 void testSwapEmptyObjectArray() {
6303 final String[] array = {};
6304 ArrayUtils.swap(array, 0, 2);
6305 assertEquals(0, array.length);
6306 }
6307
6308 @Test
6309 void testSwapEmptyShortArray() {
6310 final short[] array = {};
6311 ArrayUtils.swap(array, 0, 2);
6312 assertEquals(0, array.length);
6313 }
6314
6315 @Test
6316 void testSwapFloat() {
6317 final float[] array = { 1, 2, 3 };
6318 ArrayUtils.swap(array, 0, 2);
6319 assertEquals(3, array[0]);
6320 assertEquals(2, array[1]);
6321 assertEquals(1, array[2]);
6322 }
6323
6324 @Test
6325 void testSwapFloatRange() {
6326
6327 ArrayUtils.swap((float[]) null, 0, 2, 1);
6328 ArrayUtils.swap(new float[0], 0, 2, 1);
6329 final float[] array3a = {1, 0, 1};
6330 final float[] array3b = array3a.clone();
6331
6332 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6333 assertArrayEquals(array3a, array3b);
6334
6335 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6336 assertArrayEquals(array3a, array3b);
6337
6338 float[] array = { 1, 2, 3, 4 };
6339 ArrayUtils.swap(array, 0, 2, 2);
6340 assertEquals(3, array[0]);
6341 assertEquals(4, array[1]);
6342 assertEquals(1, array[2]);
6343 assertEquals(2, array[3]);
6344
6345 array = new float[] { 1, 2, 3 };
6346 ArrayUtils.swap(array, 0, 3);
6347 assertEquals(1, array[0]);
6348 assertEquals(2, array[1]);
6349 assertEquals(3, array[2]);
6350
6351 array = new float[] { 1, 2, 3 };
6352 ArrayUtils.swap(array, 0, 2, 2);
6353 assertEquals(3, array[0]);
6354 assertEquals(2, array[1]);
6355 assertEquals(1, array[2]);
6356
6357 array = new float[] { 1, 2, 3 };
6358 ArrayUtils.swap(array, -1, 2, 2);
6359 assertEquals(3, array[0]);
6360 assertEquals(2, array[1]);
6361 assertEquals(1, array[2]);
6362
6363 array = new float[] { 1, 2, 3 };
6364 ArrayUtils.swap(array, 0, -1, 2);
6365 assertEquals(1, array[0]);
6366 assertEquals(2, array[1]);
6367 assertEquals(3, array[2]);
6368
6369 array = new float[] { 1, 2, 3 };
6370 ArrayUtils.swap(array, -1, -1, 2);
6371 assertEquals(1, array[0]);
6372 assertEquals(2, array[1]);
6373 assertEquals(3, array[2]);
6374 }
6375
6376 @Test
6377 void testSwapInt() {
6378 final int[] array = { 1, 2, 3 };
6379 ArrayUtils.swap(array, 0, 2);
6380 assertEquals(3, array[0]);
6381 assertEquals(2, array[1]);
6382 assertEquals(1, array[2]);
6383 }
6384
6385 @Test
6386 void testSwapIntExchangedOffsets() {
6387 int[] array;
6388 array = new int[] { 1, 2, 3 };
6389 ArrayUtils.swap(array, 0, 1, 2);
6390 assertArrayEquals(new int[] { 2, 3, 1 }, array);
6391
6392 array = new int[] { 1, 2, 3 };
6393 ArrayUtils.swap(array, 1, 0, 2);
6394 assertArrayEquals(new int[] { 2, 3, 1 }, array);
6395 }
6396
6397 @Test
6398 void testSwapIntRange() {
6399
6400 ArrayUtils.swap((int[]) null, 0, 2, 1);
6401 ArrayUtils.swap(new int[0], 0, 2, 1);
6402 final int[] array3a = {1, 0, 1};
6403 final int[] array3b = array3a.clone();
6404
6405 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6406 assertArrayEquals(array3a, array3b);
6407
6408 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6409 assertArrayEquals(array3a, array3b);
6410
6411 int[] array = { 1, 2, 3, 4 };
6412 ArrayUtils.swap(array, 0, 2, 2);
6413 assertEquals(3, array[0]);
6414 assertEquals(4, array[1]);
6415 assertEquals(1, array[2]);
6416 assertEquals(2, array[3]);
6417
6418 array = new int[] { 1, 2, 3 };
6419 ArrayUtils.swap(array, 3, 0);
6420 assertEquals(1, array[0]);
6421 assertEquals(2, array[1]);
6422 assertEquals(3, array[2]);
6423
6424 array = new int[] { 1, 2, 3 };
6425 ArrayUtils.swap(array, 0, 2, 2);
6426 assertEquals(3, array[0]);
6427 assertEquals(2, array[1]);
6428 assertEquals(1, array[2]);
6429
6430 array = new int[] { 1, 2, 3 };
6431 ArrayUtils.swap(array, -1, 2, 2);
6432 assertEquals(3, array[0]);
6433 assertEquals(2, array[1]);
6434 assertEquals(1, array[2]);
6435
6436 array = new int[] { 1, 2, 3 };
6437 ArrayUtils.swap(array, 0, -1, 2);
6438 assertEquals(1, array[0]);
6439 assertEquals(2, array[1]);
6440 assertEquals(3, array[2]);
6441
6442 array = new int[] { 1, 2, 3 };
6443 ArrayUtils.swap(array, -1, -1, 2);
6444 assertEquals(1, array[0]);
6445 assertEquals(2, array[1]);
6446 assertEquals(3, array[2]);
6447 }
6448
6449 @Test
6450 void testSwapLong() {
6451 final long[] array = { 1, 2, 3 };
6452 ArrayUtils.swap(array, 0, 2);
6453 assertEquals(3, array[0]);
6454 assertEquals(2, array[1]);
6455 assertEquals(1, array[2]);
6456 }
6457
6458 @Test
6459 void testSwapLongRange() {
6460
6461 ArrayUtils.swap((long[]) null, 0, 2, 1);
6462 ArrayUtils.swap(new long[0], 0, 2, 1);
6463 final long[] array3a = {1, 0, 1};
6464 final long[] array3b = array3a.clone();
6465
6466 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6467 assertArrayEquals(array3a, array3b);
6468
6469 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6470 assertArrayEquals(array3a, array3b);
6471
6472 long[] array = { 1, 2, 3, 4 };
6473 ArrayUtils.swap(array, 0, 2, 2);
6474 assertEquals(3, array[0]);
6475 assertEquals(4, array[1]);
6476 assertEquals(1, array[2]);
6477 assertEquals(2, array[3]);
6478
6479 array = new long[] { 1, 2, 3 };
6480 ArrayUtils.swap(array, 0, 3);
6481 assertEquals(1, array[0]);
6482 assertEquals(2, array[1]);
6483 assertEquals(3, array[2]);
6484
6485 array = new long[] { 1, 2, 3 };
6486 ArrayUtils.swap(array, 0, 2, 2);
6487 assertEquals(3, array[0]);
6488 assertEquals(2, array[1]);
6489 assertEquals(1, array[2]);
6490
6491 array = new long[] { 1, 2, 3 };
6492 ArrayUtils.swap(array, -1, 2, 2);
6493 assertEquals(3, array[0]);
6494 assertEquals(2, array[1]);
6495 assertEquals(1, array[2]);
6496
6497 array = new long[] { 1, 2, 3 };
6498 ArrayUtils.swap(array, 0, -1, 2);
6499 assertEquals(1, array[0]);
6500 assertEquals(2, array[1]);
6501 assertEquals(3, array[2]);
6502
6503 array = new long[] { 1, 2, 3 };
6504 ArrayUtils.swap(array, -1, -1, 2);
6505 assertEquals(1, array[0]);
6506 assertEquals(2, array[1]);
6507 assertEquals(3, array[2]);
6508 }
6509
6510 @Test
6511 void testSwapNullBooleanArray() {
6512 final boolean[] array = null;
6513 ArrayUtils.swap(array, 0, 2);
6514 assertNull(array);
6515 }
6516
6517 @Test
6518 void testSwapNullByteArray() {
6519 final byte[] array = null;
6520 ArrayUtils.swap(array, 0, 2);
6521 assertNull(array);
6522 }
6523
6524 @Test
6525 void testSwapNullCharArray() {
6526 final char[] array = null;
6527 ArrayUtils.swap(array, 0, 2);
6528 assertNull(array);
6529 }
6530
6531 @Test
6532 void testSwapNullDoubleArray() {
6533 final double[] array = null;
6534 ArrayUtils.swap(array, 0, 2);
6535 assertNull(array);
6536 }
6537
6538 @Test
6539 void testSwapNullFloatArray() {
6540 final float[] array = null;
6541 ArrayUtils.swap(array, 0, 2);
6542 assertNull(array);
6543 }
6544
6545 @Test
6546 void testSwapNullIntArray() {
6547 final int[] array = null;
6548 ArrayUtils.swap(array, 0, 2);
6549 assertNull(array);
6550 }
6551
6552 @Test
6553 void testSwapNullLongArray() {
6554 final long[] array = null;
6555 ArrayUtils.swap(array, 0, 2);
6556 assertNull(array);
6557 }
6558
6559 @Test
6560 void testSwapNullObjectArray() {
6561 final String[] array = null;
6562 ArrayUtils.swap(array, 0, 2);
6563 assertNull(array);
6564 }
6565
6566 @Test
6567 void testSwapNullShortArray() {
6568 final short[] array = null;
6569 ArrayUtils.swap(array, 0, 2);
6570 assertNull(array);
6571 }
6572
6573 @Test
6574 void testSwapObject() {
6575 final String[] array = { "1", "2", "3" };
6576 ArrayUtils.swap(array, 0, 2);
6577 assertEquals("3", array[0]);
6578 assertEquals("2", array[1]);
6579 assertEquals("1", array[2]);
6580 }
6581
6582 @Test
6583 void testSwapObjectRange() {
6584
6585 ArrayUtils.swap((Object[]) null, 0, 2, 1);
6586 ArrayUtils.swap(new Object[0], 0, 2, 1);
6587 final Object[] array3a = {1, 0, 1};
6588 final Object[] array3b = array3a.clone();
6589
6590 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6591 assertArrayEquals(array3a, array3b);
6592
6593 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6594 assertArrayEquals(array3a, array3b);
6595
6596 String[] array = { "1", "2", "3", "4" };
6597 ArrayUtils.swap(array, 0, 2, 2);
6598 assertEquals("3", array[0]);
6599 assertEquals("4", array[1]);
6600 assertEquals("1", array[2]);
6601 assertEquals("2", array[3]);
6602
6603 array = new String[] { "1", "2", "3", "4" };
6604 ArrayUtils.swap(array, -1, 2, 3);
6605 assertEquals("3", array[0]);
6606 assertEquals("4", array[1]);
6607 assertEquals("1", array[2]);
6608 assertEquals("2", array[3]);
6609
6610 array = new String[] { "1", "2", "3", "4", "5" };
6611 ArrayUtils.swap(array, -3, 2, 3);
6612 assertEquals("3", array[0]);
6613 assertEquals("4", array[1]);
6614 assertEquals("5", array[2]);
6615 assertEquals("2", array[3]);
6616 assertEquals("1", array[4]);
6617
6618 array = new String[] { "1", "2", "3", "4", "5" };
6619 ArrayUtils.swap(array, 2, -2, 3);
6620 assertEquals("3", array[0]);
6621 assertEquals("4", array[1]);
6622 assertEquals("5", array[2]);
6623 assertEquals("2", array[3]);
6624 assertEquals("1", array[4]);
6625
6626 array = new String[0];
6627 ArrayUtils.swap(array, 0, 2, 2);
6628 assertEquals(0, array.length);
6629
6630 array = null;
6631 ArrayUtils.swap(array, 0, 2, 2);
6632 assertNull(array);
6633 }
6634
6635 @Test
6636 void testSwapShort() {
6637 final short[] array = { 1, 2, 3 };
6638 ArrayUtils.swap(array, 0, 2);
6639 assertEquals(3, array[0]);
6640 assertEquals(2, array[1]);
6641 assertEquals(1, array[2]);
6642 }
6643
6644 @Test
6645 void testSwapShortRange() {
6646
6647 ArrayUtils.swap((short[]) null, 0, 2, 1);
6648 ArrayUtils.swap(new short[0], 0, 2, 1);
6649 final short[] array3a = {1, 0, 1};
6650 final short[] array3b = array3a.clone();
6651
6652 ArrayUtils.swap(array3b, array3b.length, 2, 1);
6653 assertArrayEquals(array3a, array3b);
6654
6655 ArrayUtils.swap(array3b, 0, array3b.length, 1);
6656 assertArrayEquals(array3a, array3b);
6657
6658 short[] array = { 1, 2, 3, 4 };
6659 ArrayUtils.swap(array, 0, 2, 2);
6660 assertEquals(3, array[0]);
6661 assertEquals(4, array[1]);
6662 assertEquals(1, array[2]);
6663 assertEquals(2, array[3]);
6664
6665 array = new short[] { 1, 2, 3 };
6666 ArrayUtils.swap(array, 3, 0);
6667 assertEquals(1, array[0]);
6668 assertEquals(2, array[1]);
6669 assertEquals(3, array[2]);
6670
6671 array = new short[] { 1, 2, 3 };
6672 ArrayUtils.swap(array, 0, 2, 2);
6673 assertEquals(3, array[0]);
6674 assertEquals(2, array[1]);
6675 assertEquals(1, array[2]);
6676
6677 array = new short[] { 1, 2, 3 };
6678 ArrayUtils.swap(array, -1, 2, 2);
6679 assertEquals(3, array[0]);
6680 assertEquals(2, array[1]);
6681 assertEquals(1, array[2]);
6682
6683 array = new short[] { 1, 2, 3 };
6684 ArrayUtils.swap(array, 0, -1, 2);
6685 assertEquals(1, array[0]);
6686 assertEquals(2, array[1]);
6687 assertEquals(3, array[2]);
6688
6689 array = new short[] { 1, 2, 3 };
6690 ArrayUtils.swap(array, -1, -1, 2);
6691 assertEquals(1, array[0]);
6692 assertEquals(2, array[1]);
6693 assertEquals(3, array[2]);
6694 }
6695
6696 @Test
6697 void testTextIndexesOfInt() {
6698 int[] array = null;
6699 final BitSet emptySet = new BitSet();
6700 final BitSet testSet = new BitSet();
6701 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0));
6702 array = new int[] { 0, 1, 2, 3, 0 };
6703 testSet.set(0);
6704 testSet.set(4);
6705 assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
6706 testSet.clear();
6707 testSet.set(1);
6708 assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
6709 testSet.clear();
6710 testSet.set(2);
6711 assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
6712 testSet.clear();
6713 testSet.set(3);
6714 assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
6715 assertEquals(emptySet, ArrayUtils.indexesOf(array, 99));
6716 }
6717
6718 @Test
6719 void testToMap() {
6720 Map<?, ?> map = ArrayUtils.toMap(new String[][] { { "foo", "bar" }, { "hello", "world" } });
6721 assertEquals("bar", map.get("foo"));
6722 assertEquals("world", map.get("hello"));
6723 assertNull(ArrayUtils.toMap(null));
6724 assertIllegalArgumentException(() -> ArrayUtils.toMap(new String[][] { { "foo", "bar" }, { "short" } }));
6725 assertIllegalArgumentException(() -> ArrayUtils.toMap(new Object[] { new Object[] { "foo", "bar" }, "illegal type" }));
6726 assertIllegalArgumentException(() -> ArrayUtils.toMap(new Object[] { new Object[] { "foo", "bar" }, null }));
6727 map = ArrayUtils.toMap(new Object[] { new Map.Entry<Object, Object>() {
6728
6729 @Override
6730 public boolean equals(final Object o) {
6731 throw new UnsupportedOperationException();
6732 }
6733
6734 @Override
6735 public Object getKey() {
6736 return "foo";
6737 }
6738
6739 @Override
6740 public Object getValue() {
6741 return "bar";
6742 }
6743
6744 @Override
6745 public int hashCode() {
6746 throw new UnsupportedOperationException();
6747 }
6748
6749 @Override
6750 public Object setValue(final Object value) {
6751 throw new UnsupportedOperationException();
6752 }
6753 } });
6754 assertEquals("bar", map.get("foo"));
6755
6756 assertEquals(Collections.emptyMap(), ArrayUtils.toMap(new Object[0]));
6757
6758 map = ArrayUtils.toMap(new Object[][] { { null, null }, { null, null } });
6759 assertEquals(Collections.singletonMap(null, null), map);
6760
6761 map = ArrayUtils.toMap(new Object[][] { { "key", "value2" }, { "key", "value1" } });
6762 assertEquals(Collections.singletonMap("key", "value1"), map);
6763 }
6764
6765 @Test
6766 void testToObject_boolean() {
6767 final boolean[] b = null;
6768 assertArrayEquals(null, ArrayUtils.toObject(b));
6769 assertSame(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.toObject(new boolean[0]));
6770 assertArrayEquals(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, ArrayUtils.toObject(new boolean[]{true, false, true}));
6771 }
6772
6773 @Test
6774 void testToObject_byte() {
6775 final byte[] b = null;
6776 assertArrayEquals(null, ArrayUtils.toObject(b));
6777 assertSame(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, ArrayUtils.toObject(new byte[0]));
6778 assertArrayEquals(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999) },
6779 ArrayUtils.toObject(new byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999 }));
6780 }
6781
6782 @Test
6783 void testToObject_char() {
6784 final char[] b = null;
6785 assertArrayEquals(null, ArrayUtils.toObject(b));
6786 assertSame(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, ArrayUtils.toObject(new char[0]));
6787 assertArrayEquals(new Character[] { Character.valueOf(Character.MIN_VALUE), Character.valueOf(Character.MAX_VALUE), Character.valueOf('0') },
6788 ArrayUtils.toObject(new char[] { Character.MIN_VALUE, Character.MAX_VALUE, '0' }));
6789 }
6790
6791 @Test
6792 void testToObject_double() {
6793 final double[] b = null;
6794 assertArrayEquals(null, ArrayUtils.toObject(b));
6795 assertSame(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, ArrayUtils.toObject(new double[0]));
6796 assertArrayEquals(new Double[] { Double.valueOf(Double.MIN_VALUE), Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999) },
6797 ArrayUtils.toObject(new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 }));
6798 }
6799
6800 @Test
6801 void testToObject_float() {
6802 final float[] b = null;
6803 assertArrayEquals(null, ArrayUtils.toObject(b));
6804 assertSame(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, ArrayUtils.toObject(new float[0]));
6805 assertArrayEquals(new Float[] { Float.valueOf(Float.MIN_VALUE), Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999) },
6806 ArrayUtils.toObject(new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 }));
6807 }
6808
6809 @Test
6810 void testToObject_int() {
6811 final int[] b = null;
6812 assertArrayEquals(null, ArrayUtils.toObject(b));
6813 assertSame(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, ArrayUtils.toObject(new int[0]));
6814 assertArrayEquals(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999) },
6815 ArrayUtils.toObject(new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 }));
6816 }
6817
6818 @Test
6819 void testToObject_long() {
6820 final long[] b = null;
6821 assertArrayEquals(null, ArrayUtils.toObject(b));
6822 assertSame(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, ArrayUtils.toObject(new long[0]));
6823 assertArrayEquals(new Long[] { Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999) },
6824 ArrayUtils.toObject(new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 }));
6825 }
6826
6827 @Test
6828 void testToObject_short() {
6829 final short[] b = null;
6830 assertArrayEquals(null, ArrayUtils.toObject(b));
6831 assertSame(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, ArrayUtils.toObject(new short[0]));
6832 assertArrayEquals(new Short[] { Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999) },
6833 ArrayUtils.toObject(new short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999 }));
6834 }
6835
6836
6837 @Test
6838 void testToPrimitive_boolean() {
6839 final Boolean[] b = null;
6840 assertNull(ArrayUtils.toPrimitive(b));
6841 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0]));
6842 assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}));
6843 assertArrayEquals(new boolean[]{true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null}));
6844 }
6845
6846 @Test
6847 void testToPrimitive_boolean_boolean() {
6848 assertNull(ArrayUtils.toPrimitive(null, false));
6849 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0], false));
6850 assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, false));
6851 assertArrayEquals(new boolean[]{true, false, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, false));
6852 assertArrayEquals(new boolean[]{true, true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, true));
6853 }
6854
6855
6856 @Test
6857 void testToPrimitive_byte() {
6858 final Byte[] b = null;
6859 assertNull(ArrayUtils.toPrimitive(b));
6860 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new Byte[0]));
6861 assertArrayEquals(new byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999 },
6862 ArrayUtils.toPrimitive(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999) }));
6863 assertNullPointerException(() -> ArrayUtils.toPrimitive(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), null }));
6864 }
6865
6866 @Test
6867 void testToPrimitive_byte_byte() {
6868 final Byte[] b = null;
6869 assertNull(ArrayUtils.toPrimitive(b, Byte.MIN_VALUE));
6870 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new Byte[0], (byte) 1));
6871 assertArrayEquals(new byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999 }, ArrayUtils
6872 .toPrimitive(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999) }, Byte.MIN_VALUE));
6873 assertArrayEquals(new byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999 },
6874 ArrayUtils.toPrimitive(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), null, Byte.valueOf((byte) 9999999) }, Byte.MAX_VALUE));
6875 }
6876
6877
6878 @Test
6879 void testToPrimitive_char() {
6880 final Character[] b = null;
6881 assertNull(ArrayUtils.toPrimitive(b));
6882 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0]));
6883 assertArrayEquals(new char[] { Character.MIN_VALUE, Character.MAX_VALUE, '0' }, ArrayUtils
6884 .toPrimitive(new Character[] { Character.valueOf(Character.MIN_VALUE), Character.valueOf(Character.MAX_VALUE), Character.valueOf('0') }));
6885 assertNullPointerException(() -> ArrayUtils.toPrimitive(new Character[] { Character.valueOf(Character.MIN_VALUE), null }));
6886 }
6887
6888 @Test
6889 void testToPrimitive_char_char() {
6890 final Character[] b = null;
6891 assertNull(ArrayUtils.toPrimitive(b, Character.MIN_VALUE));
6892 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0], (char) 0));
6893 assertArrayEquals(new char[] { Character.MIN_VALUE, Character.MAX_VALUE, '0' },
6894 ArrayUtils.toPrimitive(
6895 new Character[] { Character.valueOf(Character.MIN_VALUE), Character.valueOf(Character.MAX_VALUE), Character.valueOf('0') },
6896 Character.MIN_VALUE));
6897 assertArrayEquals(new char[] { Character.MIN_VALUE, Character.MAX_VALUE, '0' },
6898 ArrayUtils.toPrimitive(new Character[] { Character.valueOf(Character.MIN_VALUE), null, Character.valueOf('0') }, Character.MAX_VALUE));
6899 }
6900
6901
6902 @Test
6903 void testToPrimitive_double() {
6904 final Double[] b = null;
6905 assertNull(ArrayUtils.toPrimitive(b));
6906 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.toPrimitive(new Double[0]));
6907 assertArrayEquals(new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 },
6908 ArrayUtils.toPrimitive(new Double[] { Double.valueOf(Double.MIN_VALUE), Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999) }));
6909 assertNullPointerException(() -> ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), null }));
6910 }
6911
6912 @Test
6913 void testToPrimitive_double_double() {
6914 final Double[] l = null;
6915 assertNull(ArrayUtils.toPrimitive(l, Double.MIN_VALUE));
6916 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.toPrimitive(new Double[0], 1));
6917 assertArrayEquals(new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 },
6918 ArrayUtils.toPrimitive(new Double[] { Double.valueOf(Double.MIN_VALUE), Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999) }, 1));
6919 assertArrayEquals(new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 },
6920 ArrayUtils.toPrimitive(new Double[] { Double.valueOf(Double.MIN_VALUE), null, Double.valueOf(9999999) }, Double.MAX_VALUE));
6921 }
6922
6923
6924 @Test
6925 void testToPrimitive_float() {
6926 final Float[] b = null;
6927 assertNull(ArrayUtils.toPrimitive(b));
6928 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.toPrimitive(new Float[0]));
6929 assertArrayEquals(new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 },
6930 ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999) }));
6931 assertNullPointerException(() -> ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), null }));
6932 }
6933
6934 @Test
6935 void testToPrimitive_float_float() {
6936 final Float[] l = null;
6937 assertNull(ArrayUtils.toPrimitive(l, Float.MIN_VALUE));
6938 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.toPrimitive(new Float[0], 1));
6939 assertArrayEquals(new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 },
6940 ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999) }, 1));
6941 assertArrayEquals(new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 },
6942 ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), null, Float.valueOf(9999999) }, Float.MAX_VALUE));
6943 }
6944
6945
6946 @Test
6947 void testToPrimitive_int() {
6948 final Integer[] b = null;
6949 assertNull(ArrayUtils.toPrimitive(b));
6950 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new Integer[0]));
6951 assertArrayEquals(new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 },
6952 ArrayUtils.toPrimitive(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999) }));
6953 assertNullPointerException(() -> ArrayUtils.toPrimitive(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), null }));
6954 }
6955
6956 @Test
6957 void testToPrimitive_int_int() {
6958 final Long[] l = null;
6959 assertNull(ArrayUtils.toPrimitive(l, Integer.MIN_VALUE));
6960 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new Integer[0], 1));
6961 assertArrayEquals(new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 },
6962 ArrayUtils.toPrimitive(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999) }, 1));
6963 assertArrayEquals(new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 },
6964 ArrayUtils.toPrimitive(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), null, Integer.valueOf(9999999) }, Integer.MAX_VALUE));
6965 }
6966
6967 @Test
6968 void testToPrimitive_intNull() {
6969 final Integer[] iArray = null;
6970 assertNull(ArrayUtils.toPrimitive(iArray, Integer.MIN_VALUE));
6971 }
6972
6973
6974 @Test
6975 void testToPrimitive_long() {
6976 final Long[] b = null;
6977 assertNull(ArrayUtils.toPrimitive(b));
6978 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.toPrimitive(new Long[0]));
6979 assertArrayEquals(new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 },
6980 ArrayUtils.toPrimitive(new Long[] { Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999) }));
6981 assertNullPointerException(() -> ArrayUtils.toPrimitive(new Long[] { Long.valueOf(Long.MIN_VALUE), null }));
6982 }
6983
6984 @Test
6985 void testToPrimitive_long_long() {
6986 final Long[] l = null;
6987 assertNull(ArrayUtils.toPrimitive(l, Long.MIN_VALUE));
6988 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.toPrimitive(new Long[0], 1));
6989 assertArrayEquals(new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 },
6990 ArrayUtils.toPrimitive(new Long[] { Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999) }, 1));
6991 assertArrayEquals(new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 },
6992 ArrayUtils.toPrimitive(new Long[] { Long.valueOf(Long.MIN_VALUE), null, Long.valueOf(9999999) }, Long.MAX_VALUE));
6993 }
6994
6995
6996 @Test
6997 void testToPrimitive_short() {
6998 final Short[] b = null;
6999 assertNull(ArrayUtils.toPrimitive(b));
7000 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0]));
7001 assertArrayEquals(new short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999 },
7002 ArrayUtils.toPrimitive(new Short[] { Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999) }));
7003 assertNullPointerException(() -> ArrayUtils.toPrimitive(new Short[] { Short.valueOf(Short.MIN_VALUE), null }));
7004 }
7005
7006 @Test
7007 void testToPrimitive_short_short() {
7008 final Short[] s = null;
7009 assertNull(ArrayUtils.toPrimitive(s, Short.MIN_VALUE));
7010 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0], Short.MIN_VALUE));
7011 assertArrayEquals(new short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999 }, ArrayUtils
7012 .toPrimitive(new Short[] { Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999) }, Short.MIN_VALUE));
7013 assertArrayEquals(new short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999 },
7014 ArrayUtils.toPrimitive(new Short[] { Short.valueOf(Short.MIN_VALUE), null, Short.valueOf((short) 9999999) }, Short.MAX_VALUE));
7015 }
7016
7017 @Test
7018 void testToPrimitiveArray() {
7019 assertNull(ArrayUtils.toPrimitive((Object[]) null));
7020 assertArrayEquals(new boolean[] { true }, ArrayUtils.toPrimitive(new Boolean[] { true }));
7021 assertArrayEquals(new char[] { 'a' }, ArrayUtils.toPrimitive(new Character[] { 'a' }));
7022 assertArrayEquals(new byte[] { 1 }, ArrayUtils.toPrimitive(new Byte[] { 1 }));
7023 assertArrayEquals(new int[] {}, ArrayUtils.toPrimitive(new Integer[] {}));
7024 assertArrayEquals(new short[] { 2 }, ArrayUtils.toPrimitive(new Short[] { 2 }));
7025 assertArrayEquals(new long[] { 2, 3 }, ArrayUtils.toPrimitive(new Long[] { 2L, 3L }));
7026 assertArrayEquals(new float[] { 3.14f }, ArrayUtils.toPrimitive(new Float[] { 3.14f }), 0.1f);
7027 assertArrayEquals(new double[] { 2.718 }, ArrayUtils.toPrimitive(new Double[] { 2.718 }), 0.1);
7028 }
7029
7030 @Test
7031 void testToPrimitiveArrayViaObjectArray() {
7032 assertNull(ArrayUtils.toPrimitive((Object) null));
7033 assertArrayEquals(new boolean[] { true }, (boolean[]) ArrayUtils.toPrimitive((Object) new Boolean[] { true }));
7034 assertArrayEquals(new char[] { 'a' }, (char[]) ArrayUtils.toPrimitive((Object) new Character[] { 'a' }));
7035 assertArrayEquals(new byte[] { 1 }, (byte[]) ArrayUtils.toPrimitive((Object) new Byte[] { 1 }));
7036 assertArrayEquals(new int[] {}, (int[]) ArrayUtils.toPrimitive((Object) new Integer[] {}));
7037 assertArrayEquals(new short[] { 2 }, (short[]) ArrayUtils.toPrimitive((Object) new Short[] { 2 }));
7038 assertArrayEquals(new long[] { 2, 3 }, (long[]) ArrayUtils.toPrimitive((Object) new Long[] { 2L, 3L }));
7039 assertArrayEquals(new float[] { 3.14f }, (float[]) ArrayUtils.toPrimitive((Object) new Float[] { 3.14f }), 0.1f);
7040 assertArrayEquals(new double[] { 2.718 }, (double[]) ArrayUtils.toPrimitive((Object) new Double[] { 2.718 }), 0.1);
7041 assertArrayEquals(new String[] { "a" }, (String[]) ArrayUtils.toPrimitive(new String[] { "a" }));
7042 }
7043
7044 @Test
7045 void testToString() {
7046 assertEquals("{}", ArrayUtils.toString(null));
7047 assertEquals("{}", ArrayUtils.toString(new Object[0]));
7048 assertEquals("{}", ArrayUtils.toString(new String[0]));
7049 assertEquals("{<null>}", ArrayUtils.toString(new String[] { null }));
7050 assertEquals("{pink,blue}", ArrayUtils.toString(new String[] { "pink", "blue" }));
7051 assertEquals("{<null>,<null>}", ArrayUtils.toString(new String[] { null, null }));
7052 }
7053
7054 @Test
7055 void testToStringArray_array() {
7056 assertNull(ArrayUtils.toStringArray(null));
7057 assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0]));
7058 assertArrayEquals(new String[] { "1", "2", "3", "array", "test" }, ArrayUtils.toStringArray(new Object[] { 1, 2, 3, "array", "test" }));
7059 assertArrayEquals(new String[] { "null" }, ArrayUtils.toStringArray(new Object[] { null }));
7060 assertArrayEquals(new String[] { "1", "null", "3", "null", "test" }, ArrayUtils.toStringArray(new Object[] { 1, null, 3, null, "test" }));
7061 assertArrayEquals(new String[] { "null", "null", "null", "null", "null" }, ArrayUtils.toStringArray(new Object[] { null, null, null, null, null }));
7062 }
7063
7064 @Test
7065 void testToStringArray_array_string() {
7066 assertNull(ArrayUtils.toStringArray(null, ""));
7067 assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0], ""));
7068 assertArrayEquals(new String[] { "1", "MyNull", "test" }, ArrayUtils.toStringArray(new Object[] { 1, null, "test" }, "MyNull"));
7069 assertArrayEquals(new String[] { "MyNull" }, ArrayUtils.toStringArray(new Object[] { null }, "MyNull"));
7070 assertArrayEquals(new String[] { "MyNull", "MyNull" }, ArrayUtils.toStringArray(new Object[] { null, null }, "MyNull"));
7071 }
7072
7073 @Test
7074 void testToStringDefault() {
7075 assertEquals("<empty>", ArrayUtils.toString(null, "<empty>"));
7076 assertEquals("{}", ArrayUtils.toString(new Object[0], "<empty>"));
7077 assertEquals("{}", ArrayUtils.toString(new String[0], "<empty>"));
7078 assertEquals("{<null>}", ArrayUtils.toString(new String[]{null}, "<empty>"));
7079 assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"}, "<empty>"));
7080 }
7081 }