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