1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 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 * Unit tests {@link org.apache.commons.lang3.ArrayUtils}. 44 */ 45 @SuppressWarnings("deprecation") // deliberate use of deprecated code 46 public class ArrayUtilsTest extends AbstractLangTest { 47 48 private class TestClass { 49 // empty 50 } 51 52 /** A predefined seed used to initialize {@link Random} in order to get predictable results */ 53 private static final long SEED = 16111981L; 54 55 @SafeVarargs toArrayPropagatingType(final T... items)56 private static <T> T[] toArrayPropagatingType(final T... items) { 57 return ArrayUtils.toArray(items); 58 } 59 assertIsEquals(final Object array1, final Object array2, final Object array3)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 * Tests generic array creation with parameters of same type. 74 */ 75 @Test testArrayCreation()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 * Tests generic array creation with parameters of common base type. 84 */ 85 @Test testArrayCreationWithDifferentTypes()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 * Tests generic array creation with general return type. 95 */ 96 @Test testArrayCreationWithGeneralReturnType()97 public void testArrayCreationWithGeneralReturnType() { 98 final Object obj = ArrayUtils.toArray("foo", "bar"); 99 assertTrue(obj instanceof String[]); 100 } 101 102 @Test testClone()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 testCloneBoolean()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 testCloneByte()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 testCloneChar()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 testCloneDouble()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 testCloneFloat()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 testCloneInt()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 testCloneLong()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 testCloneShort()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 testConstructor()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 testContains()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 testContainsAny()216 public void testContainsAny() { 217 final Object[] array = {"0", "1", "2", "3", null, "0"}; 218 assertFalse(ArrayUtils.containsAny(null, null)); 219 assertFalse(ArrayUtils.containsAny(null, "1")); 220 assertTrue(ArrayUtils.containsAny(array, "0")); 221 assertTrue(ArrayUtils.containsAny(array, "1")); 222 assertTrue(ArrayUtils.containsAny(array, "2")); 223 assertTrue(ArrayUtils.containsAny(array, "3")); 224 assertFalse(ArrayUtils.containsAny(array, "notInArray")); 225 assertTrue(ArrayUtils.containsAny(array, new String[] {null})); 226 } 227 228 @Test testContains_LANG_1261()229 public void testContains_LANG_1261() { 230 231 class LANG1261ParentObject { 232 @Override 233 public boolean equals(final Object o) { 234 return true; 235 } 236 } 237 238 class LANG1261ChildObject extends LANG1261ParentObject { 239 // empty. 240 } 241 242 final Object[] array = new LANG1261ChildObject[]{new LANG1261ChildObject()}; 243 244 assertTrue(ArrayUtils.contains(array, new LANG1261ParentObject())); 245 } 246 247 @Test testContainsBoolean()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 testContainsByte()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 testContainsChar()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 testContainsDouble()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 testContainsDoubleNaN()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 testContainsDoubleTolerance()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 testContainsFloat()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 testContainsFloatNaN()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 testContainsInt()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 testContainsLong()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 testContainsShort()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 testCreatePrimitiveArray()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 testCreatePrimitiveArrayViaObjectArray()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 * Tests generic empty array creation with generic type. 401 */ 402 @Test testEmptyArrayCreation()403 public void testEmptyArrayCreation() { 404 final String[] array = ArrayUtils.<String>toArray(); 405 assertEquals(0, array.length); 406 } 407 408 @Test testGet()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 testGetComponentType()424 public void testGetComponentType() { 425 final TestClass[] newArray = {}; 426 // No type-cast required. 427 final Class<TestClass> componentType = ArrayUtils.getComponentType(newArray); 428 assertEquals(TestClass.class, componentType); 429 assertNull(ArrayUtils.getComponentType(null)); 430 } 431 432 @Test testGetDefault()433 public void testGetDefault() { 434 // null default 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 // non-null default 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 testGetLength()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 testHashCode()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 testIndexesOf()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 testIndexesOfBoolean()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 testIndexesOfBooleanWithStartIndex()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 testIndexesOfByte()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 testIndexesOfByteWithStartIndex()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 testIndexesOfChar()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 testIndexesOfCharWithStartIndex()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 testIndexesOfDouble()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 testIndexesOfDoubleTolerance()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 testIndexesOfDoubleWithStartIndex()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 testIndexesOfDoubleWithStartIndexTolerance()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 testIndexesOfFloat()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 testIndexesOfFloatWithStartIndex()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 testIndexesOfIntWithStartIndex()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 testIndexesOfLong()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 testIndexesOfLongWithStartIndex()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 testIndexesOfShort()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 testIndexesOfShortWithStartIndex()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 testIndexesOfWithStartIndex()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 testIndexOf()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 testIndexOfBoolean()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 testIndexOfBooleanWithStartIndex()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 testIndexOfByte()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 testIndexOfByteWithStartIndex()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 testIndexOfChar()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 testIndexOfCharWithStartIndex()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 testIndexOfDouble()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 testIndexOfDoubleNaN()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 testIndexOfDoubleTolerance()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 testIndexOfDoubleWithStartIndex()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 testIndexOfDoubleWithStartIndexTolerance()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 testIndexOfFloat()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 testIndexOfFloatNaN()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 testIndexOfFloatWithStartIndex()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 testIndexOfInt()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 testIndexOfIntWithStartIndex()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 testIndexOfLong()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 testIndexOfLongWithStartIndex()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 testIndexOfShort()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 testIndexOfShortWithStartIndex()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 testIndexOfWithStartIndex()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 * Tests generic array creation with generic type. 1280 */ 1281 @Test testIndirectArrayCreation()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 * Tests indirect generic empty array creation with generic type. 1291 */ 1292 @Test testIndirectEmptyArrayCreation()1293 public void testIndirectEmptyArrayCreation() { 1294 final String[] array = ArrayUtilsTest.<String>toArrayPropagatingType(); 1295 assertEquals(0, array.length); 1296 } 1297 1298 @Test testIsArrayIndexValid()1299 public void testIsArrayIndexValid() { 1300 assertFalse(ArrayUtils.isArrayIndexValid(null, 0)); 1301 final String[] array = new String[1]; 1302 1303 //too big 1304 assertFalse(ArrayUtils.isArrayIndexValid(array, 1)); 1305 1306 //negative index 1307 assertFalse(ArrayUtils.isArrayIndexValid(array, -1)); 1308 1309 //good to go 1310 assertTrue(ArrayUtils.isArrayIndexValid(array, 0)); 1311 } 1312 1313 /** 1314 * Test for {@link ArrayUtils#isEmpty(java.lang.Object[])}. 1315 */ 1316 @Test testIsEmptyObject()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 * Tests for {@link ArrayUtils#isEmpty(long[])}, 1327 * {@link ArrayUtils#isEmpty(int[])}, 1328 * {@link ArrayUtils#isEmpty(short[])}, 1329 * {@link ArrayUtils#isEmpty(char[])}, 1330 * {@link ArrayUtils#isEmpty(byte[])}, 1331 * {@link ArrayUtils#isEmpty(double[])}, 1332 * {@link ArrayUtils#isEmpty(float[])} and 1333 * {@link ArrayUtils#isEmpty(boolean[])}. 1334 */ 1335 @Test testIsEmptyPrimitives()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 testIsEquals()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 * Test for {@link ArrayUtils#isNotEmpty(java.lang.Object[])}. 1439 */ 1440 @Test testIsNotEmptyObject()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 * Tests for {@link ArrayUtils#isNotEmpty(long[])}, 1451 * {@link ArrayUtils#isNotEmpty(int[])}, 1452 * {@link ArrayUtils#isNotEmpty(short[])}, 1453 * {@link ArrayUtils#isNotEmpty(char[])}, 1454 * {@link ArrayUtils#isNotEmpty(byte[])}, 1455 * {@link ArrayUtils#isNotEmpty(double[])}, 1456 * {@link ArrayUtils#isNotEmpty(float[])} and 1457 * {@link ArrayUtils#isNotEmpty(boolean[])}. 1458 */ 1459 @Test testIsNotEmptyPrimitives()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 testIsSorted()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 testIsSortedBool()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 testIsSortedByte()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 testIsSortedChar()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 testIsSortedComparator()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 testIsSortedDouble()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 testIsSortedFloat()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 testIsSortedInt()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 testIsSortedLong()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 testIsSortedNullComparator()1648 public void testIsSortedNullComparator() { 1649 assertThrows(NullPointerException.class, () -> ArrayUtils.isSorted(null, null)); 1650 } 1651 1652 @Test testIsSortedShort()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 testLastIndexOf()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 testLastIndexOfBoolean()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 testLastIndexOfBooleanWithStartIndex()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 testLastIndexOfByte()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 testLastIndexOfByteWithStartIndex()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 testLastIndexOfChar()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 testLastIndexOfCharWithStartIndex()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 testLastIndexOfDouble()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 testLastIndexOfDoubleTolerance()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 testLastIndexOfDoubleWithStartIndex()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 testLastIndexOfDoubleWithStartIndexTolerance()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 testLastIndexOfFloat()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 testLastIndexOfFloatWithStartIndex()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 testLastIndexOfInt()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 testLastIndexOfIntWithStartIndex()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 testLastIndexOfLong()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 testLastIndexOfLongWithStartIndex()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 testLastIndexOfShort()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 testLastIndexOfShortWithStartIndex()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 testLastIndexOfWithStartIndex()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 testNullToEmptyBoolean()1954 public void testNullToEmptyBoolean() { 1955 final boolean[] original = {true, false}; 1956 assertEquals(original, ArrayUtils.nullToEmpty(original)); 1957 } 1958 1959 @Test testNullToEmptyBooleanEmptyArray()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 testNullToEmptyBooleanNull()1968 public void testNullToEmptyBooleanNull() { 1969 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.nullToEmpty((boolean[]) null)); 1970 } 1971 1972 @Test testNullToEmptyBooleanObject()1973 public void testNullToEmptyBooleanObject() { 1974 final Boolean[] original = {Boolean.TRUE, Boolean.FALSE}; 1975 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 1976 } 1977 1978 @Test testNullToEmptyBooleanObjectEmptyArray()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 testNullToEmptyBooleanObjectNull()1987 public void testNullToEmptyBooleanObjectNull() { 1988 assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Boolean[]) null)); 1989 } 1990 1991 @Test testNullToEmptyByte()1992 public void testNullToEmptyByte() { 1993 final byte[] original = {0x0F, 0x0E}; 1994 assertEquals(original, ArrayUtils.nullToEmpty(original)); 1995 } 1996 1997 @Test testNullToEmptyByteEmptyArray()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 testNullToEmptyByteNull()2006 public void testNullToEmptyByteNull() { 2007 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.nullToEmpty((byte[]) null)); 2008 } 2009 2010 @Test testNullToEmptyByteObject()2011 public void testNullToEmptyByteObject() { 2012 final Byte[] original = {0x0F, 0x0E}; 2013 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2014 } 2015 2016 @Test testNullToEmptyByteObjectEmptyArray()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 testNullToEmptyByteObjectNull()2025 public void testNullToEmptyByteObjectNull() { 2026 assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Byte[]) null)); 2027 } 2028 2029 @Test testNullToEmptyChar()2030 public void testNullToEmptyChar() { 2031 final char[] original = {'a', 'b'}; 2032 assertEquals(original, ArrayUtils.nullToEmpty(original)); 2033 } 2034 2035 @Test testNullToEmptyCharEmptyArray()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 testNullToEmptyCharNull()2044 public void testNullToEmptyCharNull() { 2045 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.nullToEmpty((char[]) null)); 2046 } 2047 2048 @Test testNullToEmptyCharObject()2049 public void testNullToEmptyCharObject() { 2050 final Character[] original = {'a', 'b'}; 2051 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2052 } 2053 2054 @Test testNullToEmptyCharObjectEmptyArray()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 testNUllToEmptyCharObjectNull()2063 public void testNUllToEmptyCharObjectNull() { 2064 assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Character[]) null)); 2065 } 2066 2067 @Test testNullToEmptyClass()2068 public void testNullToEmptyClass() { 2069 final Class<?>[] original = {Object.class, String.class}; 2070 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2071 } 2072 2073 @Test testNullToEmptyClassEmptyArray()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 testNullToEmptyClassNull()2082 public void testNullToEmptyClassNull() { 2083 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ArrayUtils.nullToEmpty((Class<?>[]) null)); 2084 } 2085 2086 @Test testNullToEmptyDouble()2087 public void testNullToEmptyDouble() { 2088 final double[] original = {1L, 2L}; 2089 assertEquals(original, ArrayUtils.nullToEmpty(original)); 2090 } 2091 2092 @Test testNullToEmptyDoubleEmptyArray()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 testNullToEmptyDoubleNull()2101 public void testNullToEmptyDoubleNull() { 2102 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.nullToEmpty((double[]) null)); 2103 } 2104 2105 @Test testNullToEmptyDoubleObject()2106 public void testNullToEmptyDoubleObject() { 2107 final Double[] original = {1D, 2D}; 2108 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2109 } 2110 2111 @Test testNullToEmptyDoubleObjectEmptyArray()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 testNullToEmptyDoubleObjectNull()2120 public void testNullToEmptyDoubleObjectNull() { 2121 assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Double[]) null)); 2122 } 2123 2124 @Test testNullToEmptyFloat()2125 public void testNullToEmptyFloat() { 2126 final float[] original = {2.6f, 3.8f}; 2127 assertEquals(original, ArrayUtils.nullToEmpty(original)); 2128 } 2129 2130 @Test testNullToEmptyFloatEmptyArray()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 testNullToEmptyFloatNull()2139 public void testNullToEmptyFloatNull() { 2140 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.nullToEmpty((float[]) null)); 2141 } 2142 2143 @Test testNullToEmptyFloatObject()2144 public void testNullToEmptyFloatObject() { 2145 final Float[] original = {2.6f, 3.8f}; 2146 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2147 } 2148 2149 @Test testNullToEmptyFloatObjectEmptyArray()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 testNullToEmptyFloatObjectNull()2158 public void testNullToEmptyFloatObjectNull() { 2159 assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Float[]) null)); 2160 } 2161 2162 @Test testNullToEmptyGeneric()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 testNullToEmptyGenericEmpty()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 testNullToEmptyGenericNull()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 testNullToEmptyGenericNullType()2187 public void testNullToEmptyGenericNullType() { 2188 final TestClass[] input = {}; 2189 assertThrows(IllegalArgumentException.class, () -> ArrayUtils.nullToEmpty(input, null)); 2190 } 2191 2192 @Test testNullToEmptyInt()2193 public void testNullToEmptyInt() { 2194 final int[] original = {1, 2}; 2195 assertEquals(original, ArrayUtils.nullToEmpty(original)); 2196 } 2197 2198 @Test testNullToEmptyIntEmptyArray()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 testNullToEmptyIntNull()2207 public void testNullToEmptyIntNull() { 2208 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.nullToEmpty((int[]) null)); 2209 } 2210 2211 @Test testNullToEmptyIntObject()2212 public void testNullToEmptyIntObject() { 2213 final Integer[] original = {1, 2}; 2214 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2215 } 2216 2217 @Test testNullToEmptyIntObjectEmptyArray()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 testNullToEmptyIntObjectNull()2226 public void testNullToEmptyIntObjectNull() { 2227 assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Integer[]) null)); 2228 } 2229 2230 @Test testNullToEmptyLong()2231 public void testNullToEmptyLong() { 2232 final long[] original = {1L, 2L}; 2233 assertEquals(original, ArrayUtils.nullToEmpty(original)); 2234 } 2235 2236 @Test testNullToEmptyLongEmptyArray()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 testNullToEmptyLongNull()2245 public void testNullToEmptyLongNull() { 2246 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.nullToEmpty((long[]) null)); 2247 } 2248 2249 @Test testNullToEmptyLongObject()2250 public void testNullToEmptyLongObject() { 2251 @SuppressWarnings("boxing") final Long[] original = {1L, 2L}; 2252 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2253 } 2254 2255 @Test testNullToEmptyLongObjectEmptyArray()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 testNullToEmptyLongObjectNull()2264 public void testNullToEmptyLongObjectNull() { 2265 assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Long[]) null)); 2266 } 2267 2268 @Test testNullToEmptyObject()2269 public void testNullToEmptyObject() { 2270 final Object[] original = {Boolean.TRUE, Boolean.FALSE}; 2271 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2272 } 2273 2274 @Test testNullToEmptyObjectEmptyArray()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 testNullToEmptyObjectNull()2283 public void testNullToEmptyObjectNull() { 2284 assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Object[]) null)); 2285 } 2286 2287 @Test testNullToEmptyShort()2288 public void testNullToEmptyShort() { 2289 final short[] original = {1, 2}; 2290 assertEquals(original, ArrayUtils.nullToEmpty(original)); 2291 } 2292 2293 @Test testNullToEmptyShortEmptyArray()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 testNullToEmptyShortNull()2302 public void testNullToEmptyShortNull() { 2303 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.nullToEmpty((short[]) null)); 2304 } 2305 2306 @Test testNullToEmptyShortObject()2307 public void testNullToEmptyShortObject() { 2308 @SuppressWarnings("boxing") final Short[] original = {1, 2}; 2309 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2310 } 2311 2312 @Test testNullToEmptyShortObjectEmptyArray()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 testNullToEmptyShortObjectNull()2321 public void testNullToEmptyShortObjectNull() { 2322 assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Short[]) null)); 2323 } 2324 2325 @Test testNullToEmptyString()2326 public void testNullToEmptyString() { 2327 final String[] original = {"abc", "def"}; 2328 assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); 2329 } 2330 2331 @Test testNullToEmptyStringEmptyArray()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 testNullToEmptyStringNull()2340 public void testNullToEmptyStringNull() { 2341 assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, ArrayUtils.nullToEmpty((String[]) null)); 2342 } 2343 2344 @Test testReverse()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 testReverseBoolean()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 testReverseBooleanRange()2383 public void testReverseBooleanRange() { 2384 boolean[] array = {false, false, true}; 2385 // The whole array 2386 ArrayUtils.reverse(array, 0, 3); 2387 assertTrue(array[0]); 2388 assertFalse(array[1]); 2389 assertFalse(array[2]); 2390 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2409 array = null; 2410 ArrayUtils.reverse(array, 0, 3); 2411 assertNull(array); 2412 } 2413 2414 @Test testReverseByte()2415 public void testReverseByte() { 2416 byte[] array = {2, 3, 4}; 2417 ArrayUtils.reverse(array); 2418 assertEquals(array[0], 4); 2419 assertEquals(array[1], 3); 2420 assertEquals(array[2], 2); 2421 2422 array = null; 2423 ArrayUtils.reverse(array); 2424 assertNull(array); 2425 } 2426 2427 @Test testReverseByteRange()2428 public void testReverseByteRange() { 2429 byte[] array = {1, 2, 3}; 2430 // The whole array 2431 ArrayUtils.reverse(array, 0, 3); 2432 assertEquals(3, array[0]); 2433 assertEquals(2, array[1]); 2434 assertEquals(1, array[2]); 2435 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2454 array = null; 2455 ArrayUtils.reverse(array, 0, 3); 2456 assertNull(array); 2457 } 2458 2459 @Test testReverseChar()2460 public void testReverseChar() { 2461 char[] array = {'a', 'f', 'C'}; 2462 ArrayUtils.reverse(array); 2463 assertEquals(array[0], 'C'); 2464 assertEquals(array[1], 'f'); 2465 assertEquals(array[2], 'a'); 2466 2467 array = null; 2468 ArrayUtils.reverse(array); 2469 assertNull(array); 2470 } 2471 2472 @Test testReverseCharRange()2473 public void testReverseCharRange() { 2474 char[] array = {1, 2, 3}; 2475 // The whole array 2476 ArrayUtils.reverse(array, 0, 3); 2477 assertEquals(3, array[0]); 2478 assertEquals(2, array[1]); 2479 assertEquals(1, array[2]); 2480 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2499 array = null; 2500 ArrayUtils.reverse(array, 0, 3); 2501 assertNull(array); 2502 } 2503 2504 @Test testReverseDouble()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 testReverseDoubleRange()2518 public void testReverseDoubleRange() { 2519 double[] array = {1, 2, 3}; 2520 // The whole array 2521 ArrayUtils.reverse(array, 0, 3); 2522 assertEquals(3, array[0]); 2523 assertEquals(2, array[1]); 2524 assertEquals(1, array[2]); 2525 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2544 array = null; 2545 ArrayUtils.reverse(array, 0, 3); 2546 assertNull(array); 2547 } 2548 2549 @Test testReverseFloat()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 testReverseFloatRange()2563 public void testReverseFloatRange() { 2564 float[] array = {1, 2, 3}; 2565 // The whole array 2566 ArrayUtils.reverse(array, 0, 3); 2567 assertEquals(3, array[0]); 2568 assertEquals(2, array[1]); 2569 assertEquals(1, array[2]); 2570 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2589 array = null; 2590 ArrayUtils.reverse(array, 0, 3); 2591 assertNull(array); 2592 } 2593 2594 @Test testReverseInt()2595 public void testReverseInt() { 2596 int[] array = {1, 2, 3}; 2597 ArrayUtils.reverse(array); 2598 assertEquals(array[0], 3); 2599 assertEquals(array[1], 2); 2600 assertEquals(array[2], 1); 2601 2602 array = null; 2603 ArrayUtils.reverse(array); 2604 assertNull(array); 2605 } 2606 2607 @Test testReverseIntRange()2608 public void testReverseIntRange() { 2609 int[] array = {1, 2, 3}; 2610 // The whole array 2611 ArrayUtils.reverse(array, 0, 3); 2612 assertEquals(3, array[0]); 2613 assertEquals(2, array[1]); 2614 assertEquals(1, array[2]); 2615 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2634 array = null; 2635 ArrayUtils.reverse(array, 0, 3); 2636 assertNull(array); 2637 } 2638 2639 @Test testReverseLong()2640 public void testReverseLong() { 2641 long[] array = {1L, 2L, 3L}; 2642 ArrayUtils.reverse(array); 2643 assertEquals(array[0], 3L); 2644 assertEquals(array[1], 2L); 2645 assertEquals(array[2], 1L); 2646 2647 array = null; 2648 ArrayUtils.reverse(array); 2649 assertNull(array); 2650 } 2651 2652 @Test testReverseLongRange()2653 public void testReverseLongRange() { 2654 long[] array = {1, 2, 3}; 2655 // The whole array 2656 ArrayUtils.reverse(array, 0, 3); 2657 assertEquals(3, array[0]); 2658 assertEquals(2, array[1]); 2659 assertEquals(1, array[2]); 2660 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2679 array = null; 2680 ArrayUtils.reverse(array, 0, 3); 2681 assertNull(array); 2682 } 2683 2684 @Test testReverseObjectRange()2685 public void testReverseObjectRange() { 2686 String[] array = {"1", "2", "3"}; 2687 // The whole array 2688 ArrayUtils.reverse(array, 0, 3); 2689 assertEquals("3", array[0]); 2690 assertEquals("2", array[1]); 2691 assertEquals("1", array[2]); 2692 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2711 array = null; 2712 ArrayUtils.reverse(array, 0, 3); 2713 assertNull(array); 2714 } 2715 2716 @Test testReverseShort()2717 public void testReverseShort() { 2718 short[] array = {1, 2, 3}; 2719 ArrayUtils.reverse(array); 2720 assertEquals(array[0], 3); 2721 assertEquals(array[1], 2); 2722 assertEquals(array[2], 1); 2723 2724 array = null; 2725 ArrayUtils.reverse(array); 2726 assertNull(array); 2727 } 2728 2729 @Test testReverseShortRange()2730 public void testReverseShortRange() { 2731 short[] array = {1, 2, 3}; 2732 // The whole array 2733 ArrayUtils.reverse(array, 0, 3); 2734 assertEquals(3, array[0]); 2735 assertEquals(2, array[1]); 2736 assertEquals(1, array[2]); 2737 // a range 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 // a range with a negative start 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 // a range with a large stop index 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 // null 2756 array = null; 2757 ArrayUtils.reverse(array, 0, 3); 2758 assertNull(array); 2759 } 2760 2761 @Test testSameLength()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 testSameLengthAll()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 testSameLengthBoolean()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 testSameLengthByte()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 testSameLengthChar()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 testSameLengthDouble()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 testSameLengthFloat()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 testSameLengthInt()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 testSameLengthLong()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 testSameLengthShort()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 testSameType()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 testShiftAllByte()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 testShiftAllChar()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 testShiftAllDouble()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 testShiftAllFloat()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 testShiftAllInt()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 testShiftAllLong()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 testShiftAllObject()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 testShiftAllShort()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 testShiftBoolean()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 testShiftByte()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 testShiftChar()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 testShiftDouble()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 testShiftFloat()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 testShiftInt()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 testShiftLong()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 testShiftNullBoolean()4663 public void testShiftNullBoolean() { 4664 final boolean[] array = null; 4665 4666 ArrayUtils.shift(array, 1); 4667 assertNull(array); 4668 } 4669 4670 @Test testShiftNullDouble()4671 public void testShiftNullDouble() { 4672 final double[] array = null; 4673 4674 ArrayUtils.shift(array, 1); 4675 assertNull(array); 4676 } 4677 4678 @Test testShiftNullFloat()4679 public void testShiftNullFloat() { 4680 final float[] array = null; 4681 4682 ArrayUtils.shift(array, 1); 4683 assertNull(array); 4684 } 4685 4686 @Test testShiftNullInt()4687 public void testShiftNullInt() { 4688 final int[] array = null; 4689 4690 ArrayUtils.shift(array, 1); 4691 assertNull(array); 4692 } 4693 4694 @Test testShiftNullLong()4695 public void testShiftNullLong() { 4696 final long[] array = null; 4697 4698 ArrayUtils.shift(array, 1); 4699 assertNull(array); 4700 } 4701 4702 @Test testShiftNullObject()4703 public void testShiftNullObject() { 4704 final String[] array = null; 4705 4706 ArrayUtils.shift(array, 1); 4707 assertNull(array); 4708 } 4709 4710 @Test testShiftNullShort()4711 public void testShiftNullShort() { 4712 final short[] array = null; 4713 4714 ArrayUtils.shift(array, 1); 4715 assertNull(array); 4716 } 4717 4718 @Test testShiftObject()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 testShiftRangeByte()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 testShiftRangeChar()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 testShiftRangeDouble()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 testShiftRangeFloat()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 testShiftRangeInt()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 testShiftRangeLong()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 testShiftRangeNoElemByte()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 testShiftRangeNoElemChar()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 testShiftRangeNoElemDouble()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 testShiftRangeNoElemFloat()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 testShiftRangeNoElemInt()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 testShiftRangeNoElemLong()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 testShiftRangeNoElemObject()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 testShiftRangeNoElemShort()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 testShiftRangeNullByte()4926 public void testShiftRangeNullByte() { 4927 final byte[] array = null; 4928 ArrayUtils.shift(array, 1, 1, 1); 4929 assertNull(array); 4930 } 4931 4932 @Test testShiftRangeNullChar()4933 public void testShiftRangeNullChar() { 4934 final char[] array = null; 4935 ArrayUtils.shift(array, 1, 1, 1); 4936 assertNull(array); 4937 } 4938 4939 @Test testShiftRangeNullDouble()4940 public void testShiftRangeNullDouble() { 4941 final double[] array = null; 4942 ArrayUtils.shift(array, 1, 1, 1); 4943 assertNull(array); 4944 } 4945 4946 @Test testShiftRangeNullFloat()4947 public void testShiftRangeNullFloat() { 4948 final float[] array = null; 4949 ArrayUtils.shift(array, 1, 1, 1); 4950 assertNull(array); 4951 } 4952 4953 @Test testShiftRangeNullInt()4954 public void testShiftRangeNullInt() { 4955 final int[] array = null; 4956 ArrayUtils.shift(array, 1, 1, 1); 4957 assertNull(array); 4958 } 4959 4960 @Test testShiftRangeNullLong()4961 public void testShiftRangeNullLong() { 4962 final long[] array = null; 4963 ArrayUtils.shift(array, 1, 1, 1); 4964 assertNull(array); 4965 } 4966 4967 @Test testShiftRangeNullObject()4968 public void testShiftRangeNullObject() { 4969 final String[] array = null; 4970 ArrayUtils.shift(array, 1, 1, 1); 4971 assertNull(array); 4972 } 4973 4974 @Test testShiftRangeNullShort()4975 public void testShiftRangeNullShort() { 4976 final short[] array = null; 4977 4978 ArrayUtils.shift(array, 1, 1, 1); 4979 assertNull(array); 4980 } 4981 4982 @Test testShiftRangeObject()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 testShiftRangeShort()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 testShiftShort()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 testShuffle()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 testShuffleBoolean()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 testShuffleByte()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 testShuffleChar()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 testShuffleDouble()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 testShuffleFloat()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 testShuffleInt()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 testShuffleLong()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 testShuffleShort()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 testSubarrayBoolean()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 // empty-return tests 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 // array type tests 5190 5191 assertSame(boolean.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "boolean type"); 5192 } 5193 5194 @Test testSubarrayByte()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 // empty-return tests 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 // array type tests 5230 5231 assertSame(byte.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "byte type"); 5232 } 5233 5234 @Test testSubarrayDouble()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 // empty-return tests 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 // array type tests 5270 5271 assertSame(double.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "double type"); 5272 } 5273 5274 @Test testSubarrayFloat()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 // empty-return tests 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 // array type tests 5310 5311 assertSame(float.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "float type"); 5312 } 5313 5314 @Test testSubarrayInt()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 // empty-return tests 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 // array type tests 5364 5365 assertSame(int.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "int type"); 5366 } 5367 5368 @Test testSubarrayLong()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 // empty-return tests 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 // array type tests 5417 5418 assertSame(long.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "long type"); 5419 5420 } 5421 5422 @Test testSubarrayObject()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 // array type tests 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 testSubarrayShort()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 // empty-return tests 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 // array type tests 5494 5495 assertSame(short.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "short type"); 5496 } 5497 5498 @Test testSubarrChar()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 // empty-return tests 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 // array type tests 5534 5535 assertSame(char.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "char type"); 5536 } 5537 5538 @Test testSwapBoolean()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 testSwapBooleanRange()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 testSwapByte()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 testSwapByteRange()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 testSwapChar()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 testSwapCharRange()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 testSwapDouble()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 testSwapDoubleRange()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 testSwapEmptyBooleanArray()5741 public void testSwapEmptyBooleanArray() { 5742 final boolean[] array = {}; 5743 ArrayUtils.swap(array, 0, 2); 5744 assertEquals(0, array.length); 5745 } 5746 5747 @Test testSwapEmptyByteArray()5748 public void testSwapEmptyByteArray() { 5749 final byte[] array = {}; 5750 ArrayUtils.swap(array, 0, 2); 5751 assertEquals(0, array.length); 5752 } 5753 5754 @Test testSwapEmptyCharArray()5755 public void testSwapEmptyCharArray() { 5756 final char[] array = {}; 5757 ArrayUtils.swap(array, 0, 2); 5758 assertEquals(0, array.length); 5759 } 5760 5761 @Test testSwapEmptyDoubleArray()5762 public void testSwapEmptyDoubleArray() { 5763 final double[] array = {}; 5764 ArrayUtils.swap(array, 0, 2); 5765 assertEquals(0, array.length); 5766 } 5767 5768 @Test testSwapEmptyFloatArray()5769 public void testSwapEmptyFloatArray() { 5770 final float[] array = {}; 5771 ArrayUtils.swap(array, 0, 2); 5772 assertEquals(0, array.length); 5773 } 5774 5775 @Test testSwapEmptyIntArray()5776 public void testSwapEmptyIntArray() { 5777 final int[] array = {}; 5778 ArrayUtils.swap(array, 0, 2); 5779 assertEquals(0, array.length); 5780 } 5781 5782 @Test testSwapEmptyLongArray()5783 public void testSwapEmptyLongArray() { 5784 final long[] array = {}; 5785 ArrayUtils.swap(array, 0, 2); 5786 assertEquals(0, array.length); 5787 } 5788 5789 @Test testSwapEmptyObjectArray()5790 public void testSwapEmptyObjectArray() { 5791 final String[] array = {}; 5792 ArrayUtils.swap(array, 0, 2); 5793 assertEquals(0, array.length); 5794 } 5795 5796 @Test testSwapEmptyShortArray()5797 public void testSwapEmptyShortArray() { 5798 final short[] array = {}; 5799 ArrayUtils.swap(array, 0, 2); 5800 assertEquals(0, array.length); 5801 } 5802 5803 @Test testSwapFloat()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 testSwapFloatRange()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 testSwapInt()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 testSwapIntExchangedOffsets()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 testSwapIntRange()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 testSwapLong()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 testSwapLongRange()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 testSwapNullBooleanArray()5963 public void testSwapNullBooleanArray() { 5964 final boolean[] array = null; 5965 ArrayUtils.swap(array, 0, 2); 5966 assertNull(array); 5967 } 5968 5969 @Test testSwapNullByteArray()5970 public void testSwapNullByteArray() { 5971 final byte[] array = null; 5972 ArrayUtils.swap(array, 0, 2); 5973 assertNull(array); 5974 } 5975 5976 @Test testSwapNullCharArray()5977 public void testSwapNullCharArray() { 5978 final char[] array = null; 5979 ArrayUtils.swap(array, 0, 2); 5980 assertNull(array); 5981 } 5982 5983 @Test testSwapNullDoubleArray()5984 public void testSwapNullDoubleArray() { 5985 final double[] array = null; 5986 ArrayUtils.swap(array, 0, 2); 5987 assertNull(array); 5988 } 5989 5990 @Test testSwapNullFloatArray()5991 public void testSwapNullFloatArray() { 5992 final float[] array = null; 5993 ArrayUtils.swap(array, 0, 2); 5994 assertNull(array); 5995 } 5996 5997 @Test testSwapNullIntArray()5998 public void testSwapNullIntArray() { 5999 final int[] array = null; 6000 ArrayUtils.swap(array, 0, 2); 6001 assertNull(array); 6002 } 6003 6004 @Test testSwapNullLongArray()6005 public void testSwapNullLongArray() { 6006 final long[] array = null; 6007 ArrayUtils.swap(array, 0, 2); 6008 assertNull(array); 6009 } 6010 6011 @Test testSwapNullObjectArray()6012 public void testSwapNullObjectArray() { 6013 final String[] array = null; 6014 ArrayUtils.swap(array, 0, 2); 6015 assertNull(array); 6016 } 6017 6018 @Test testSwapNullShortArray()6019 public void testSwapNullShortArray() { 6020 final short[] array = null; 6021 ArrayUtils.swap(array, 0, 2); 6022 assertNull(array); 6023 } 6024 6025 @Test testSwapObject()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 testSwapObjectRange()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 testSwapShort()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 testSwapShortRange()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 testToMap()6125 public void testToMap() { 6126 Map<?, ?> map = ArrayUtils.toMap(new String[][]{{"foo", "bar"}, {"hello", "world"}}); 6127 6128 assertEquals("bar", map.get("foo")); 6129 assertEquals("world", map.get("hello")); 6130 6131 assertNull(ArrayUtils.toMap(null)); 6132 assertThrows(IllegalArgumentException.class, () -> 6133 ArrayUtils.toMap(new String[][]{{"foo", "bar"}, {"short"}})); 6134 assertThrows(IllegalArgumentException.class, () -> 6135 ArrayUtils.toMap(new Object[]{new Object[]{"foo", "bar"}, "illegal type"})); 6136 assertThrows(IllegalArgumentException.class, () -> 6137 ArrayUtils.toMap(new Object[]{new Object[]{"foo", "bar"}, null})); 6138 6139 map = ArrayUtils.toMap(new Object[]{new Map.Entry<Object, Object>() { 6140 @Override 6141 public boolean equals(final Object o) { 6142 throw new UnsupportedOperationException(); 6143 } 6144 6145 @Override 6146 public Object getKey() { 6147 return "foo"; 6148 } 6149 6150 @Override 6151 public Object getValue() { 6152 return "bar"; 6153 } 6154 6155 @Override 6156 public int hashCode() { 6157 throw new UnsupportedOperationException(); 6158 } 6159 6160 @Override 6161 public Object setValue(final Object value) { 6162 throw new UnsupportedOperationException(); 6163 } 6164 }}); 6165 assertEquals("bar", map.get("foo")); 6166 6167 // Return empty map when got input array with length = 0 6168 assertEquals(Collections.emptyMap(), ArrayUtils.toMap(new Object[0])); 6169 6170 // Test all null values 6171 map = ArrayUtils.toMap(new Object[][] { {null, null}, {null, null} }); 6172 assertEquals(Collections.singletonMap(null, null), map); 6173 6174 // Test duplicate keys 6175 map = ArrayUtils.toMap(new Object[][] { {"key", "value2"}, {"key", "value1"} }); 6176 assertEquals(Collections.singletonMap("key", "value1"), map); 6177 } 6178 6179 @Test testToObject_boolean()6180 public void testToObject_boolean() { 6181 final boolean[] b = null; 6182 assertArrayEquals(null, ArrayUtils.toObject(b)); 6183 assertSame(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.toObject(new boolean[0])); 6184 assertArrayEquals(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, ArrayUtils.toObject(new boolean[]{true, false, true})); 6185 } 6186 6187 @Test testToObject_byte()6188 public void testToObject_byte() { 6189 final byte[] b = null; 6190 assertArrayEquals(null, ArrayUtils.toObject(b)); 6191 6192 assertSame(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, 6193 ArrayUtils.toObject(new byte[0])); 6194 6195 assertArrayEquals(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), 6196 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)}, ArrayUtils.toObject(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, 6197 (byte) 9999999})); 6198 } 6199 6200 @Test testToObject_char()6201 public void testToObject_char() { 6202 final char[] b = null; 6203 assertArrayEquals(null, ArrayUtils.toObject(b)); 6204 6205 assertSame(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, 6206 ArrayUtils.toObject(new char[0])); 6207 6208 assertArrayEquals(new Character[]{Character.valueOf(Character.MIN_VALUE), 6209 Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')}, ArrayUtils.toObject(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, 6210 '0'})); 6211 } 6212 6213 @Test testToObject_double()6214 public void testToObject_double() { 6215 final double[] b = null; 6216 assertArrayEquals(null, ArrayUtils.toObject(b)); 6217 6218 assertSame( 6219 ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, 6220 ArrayUtils.toObject(new double[0])); 6221 6222 assertArrayEquals(new Double[]{ 6223 Double.valueOf(Double.MIN_VALUE), 6224 Double.valueOf(Double.MAX_VALUE), 6225 Double.valueOf(9999999)}, ArrayUtils.toObject( 6226 new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999})); 6227 } 6228 6229 @Test testToObject_float()6230 public void testToObject_float() { 6231 final float[] b = null; 6232 assertArrayEquals(null, ArrayUtils.toObject(b)); 6233 6234 assertSame( 6235 ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, 6236 ArrayUtils.toObject(new float[0])); 6237 6238 assertArrayEquals(new Float[]{ 6239 Float.valueOf(Float.MIN_VALUE), 6240 Float.valueOf(Float.MAX_VALUE), 6241 Float.valueOf(9999999)}, ArrayUtils.toObject( 6242 new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999})); 6243 } 6244 6245 @Test testToObject_int()6246 public void testToObject_int() { 6247 final int[] b = null; 6248 assertArrayEquals(null, ArrayUtils.toObject(b)); 6249 6250 assertSame( 6251 ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, 6252 ArrayUtils.toObject(new int[0])); 6253 6254 assertArrayEquals(new Integer[]{ 6255 Integer.valueOf(Integer.MIN_VALUE), 6256 Integer.valueOf(Integer.MAX_VALUE), 6257 Integer.valueOf(9999999)}, ArrayUtils.toObject( 6258 new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999})); 6259 } 6260 6261 @Test testToObject_long()6262 public void testToObject_long() { 6263 final long[] b = null; 6264 assertArrayEquals(null, ArrayUtils.toObject(b)); 6265 6266 assertSame( 6267 ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, 6268 ArrayUtils.toObject(new long[0])); 6269 6270 assertArrayEquals(new Long[]{ 6271 Long.valueOf(Long.MIN_VALUE), 6272 Long.valueOf(Long.MAX_VALUE), 6273 Long.valueOf(9999999)}, ArrayUtils.toObject( 6274 new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999})); 6275 } 6276 6277 @Test testToObject_short()6278 public void testToObject_short() { 6279 final short[] b = null; 6280 assertArrayEquals(null, ArrayUtils.toObject(b)); 6281 6282 assertSame(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, 6283 ArrayUtils.toObject(new short[0])); 6284 6285 assertArrayEquals(new Short[]{Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE), 6286 Short.valueOf((short) 9999999)}, ArrayUtils.toObject(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, 6287 (short) 9999999})); 6288 } 6289 6290 /** testToPrimitive/Object for boolean */ 6291 @Test testToPrimitive_boolean()6292 public void testToPrimitive_boolean() { 6293 final Boolean[] b = null; 6294 assertNull(ArrayUtils.toPrimitive(b)); 6295 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0])); 6296 assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE})); 6297 assertArrayEquals(new boolean[]{true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null})); 6298 } 6299 6300 @Test testToPrimitive_boolean_boolean()6301 public void testToPrimitive_boolean_boolean() { 6302 assertNull(ArrayUtils.toPrimitive(null, false)); 6303 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0], false)); 6304 assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, false)); 6305 assertArrayEquals(new boolean[]{true, false, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, false)); 6306 assertArrayEquals(new boolean[]{true, true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, true)); 6307 } 6308 6309 /** testToPrimitive/Object for byte */ 6310 @Test testToPrimitive_byte()6311 public void testToPrimitive_byte() { 6312 final Byte[] b = null; 6313 assertNull(ArrayUtils.toPrimitive(b)); 6314 6315 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new Byte[0])); 6316 6317 assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), 6318 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)})); 6319 6320 assertThrows(NullPointerException.class, 6321 () -> ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), null})); 6322 } 6323 6324 @Test testToPrimitive_byte_byte()6325 public void testToPrimitive_byte_byte() { 6326 final Byte[] b = null; 6327 assertNull(ArrayUtils.toPrimitive(b, Byte.MIN_VALUE)); 6328 6329 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, 6330 ArrayUtils.toPrimitive(new Byte[0], (byte) 1)); 6331 6332 assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), 6333 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)}, 6334 Byte.MIN_VALUE)); 6335 6336 assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), null, 6337 Byte.valueOf((byte) 9999999)}, Byte.MAX_VALUE)); 6338 } 6339 6340 /** testToPrimitive/Object for byte */ 6341 @Test testToPrimitive_char()6342 public void testToPrimitive_char() { 6343 final Character[] b = null; 6344 assertNull(ArrayUtils.toPrimitive(b)); 6345 6346 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0])); 6347 6348 assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), 6349 Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')})); 6350 6351 assertThrows(NullPointerException.class, 6352 () -> ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), null})); 6353 } 6354 6355 @Test testToPrimitive_char_char()6356 public void testToPrimitive_char_char() { 6357 final Character[] b = null; 6358 assertNull(ArrayUtils.toPrimitive(b, Character.MIN_VALUE)); 6359 6360 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, 6361 ArrayUtils.toPrimitive(new Character[0], (char) 0)); 6362 6363 assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), 6364 Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')}, 6365 Character.MIN_VALUE)); 6366 6367 assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), null, 6368 Character.valueOf('0')}, Character.MAX_VALUE)); 6369 } 6370 6371 /** testToPrimitive/Object for double */ 6372 @Test testToPrimitive_double()6373 public void testToPrimitive_double() { 6374 final Double[] b = null; 6375 assertNull(ArrayUtils.toPrimitive(b)); 6376 6377 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, 6378 ArrayUtils.toPrimitive(new Double[0])); 6379 6380 assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE), 6381 Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999)})); 6382 6383 assertThrows(NullPointerException.class, 6384 () -> ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), null})); 6385 } 6386 6387 @Test testToPrimitive_double_double()6388 public void testToPrimitive_double_double() { 6389 final Double[] l = null; 6390 assertNull(ArrayUtils.toPrimitive(l, Double.MIN_VALUE)); 6391 6392 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, 6393 ArrayUtils.toPrimitive(new Double[0], 1)); 6394 6395 assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE), 6396 Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999)}, 1)); 6397 6398 assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE), 6399 null, Double.valueOf(9999999)}, Double.MAX_VALUE)); 6400 } 6401 6402 /** testToPrimitive/Object for float */ 6403 @Test testToPrimitive_float()6404 public void testToPrimitive_float() { 6405 final Float[] b = null; 6406 assertNull(ArrayUtils.toPrimitive(b)); 6407 6408 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, 6409 ArrayUtils.toPrimitive(new Float[0])); 6410 6411 assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), 6412 Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999)})); 6413 6414 assertThrows(NullPointerException.class, 6415 () -> ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), null})); 6416 } 6417 6418 @Test testToPrimitive_float_float()6419 public void testToPrimitive_float_float() { 6420 final Float[] l = null; 6421 assertNull(ArrayUtils.toPrimitive(l, Float.MIN_VALUE)); 6422 6423 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, 6424 ArrayUtils.toPrimitive(new Float[0], 1)); 6425 6426 assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), 6427 Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999)}, 1)); 6428 6429 assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), 6430 null, Float.valueOf(9999999)}, Float.MAX_VALUE)); 6431 } 6432 6433 /** testToPrimitive/Object for int */ 6434 @Test testToPrimitive_int()6435 public void testToPrimitive_int() { 6436 final Integer[] b = null; 6437 assertNull(ArrayUtils.toPrimitive(b)); 6438 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new Integer[0])); 6439 assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), 6440 Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999)})); 6441 6442 assertThrows(NullPointerException.class, 6443 () -> ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), null})); 6444 } 6445 6446 @Test testToPrimitive_int_int()6447 public void testToPrimitive_int_int() { 6448 final Long[] l = null; 6449 assertNull(ArrayUtils.toPrimitive(l, Integer.MIN_VALUE)); 6450 assertSame(ArrayUtils.EMPTY_INT_ARRAY, 6451 ArrayUtils.toPrimitive(new Integer[0], 1)); 6452 assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), 6453 Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999)}, 1)); 6454 assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), 6455 null, Integer.valueOf(9999999)}, Integer.MAX_VALUE)); 6456 } 6457 6458 @Test testToPrimitive_intNull()6459 public void testToPrimitive_intNull() { 6460 final Integer[] iArray = null; 6461 assertNull(ArrayUtils.toPrimitive(iArray, Integer.MIN_VALUE)); 6462 } 6463 6464 /** testToPrimitive/Object for long */ 6465 @Test testToPrimitive_long()6466 public void testToPrimitive_long() { 6467 final Long[] b = null; 6468 assertNull(ArrayUtils.toPrimitive(b)); 6469 6470 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, 6471 ArrayUtils.toPrimitive(new Long[0])); 6472 6473 assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), 6474 Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999)})); 6475 6476 assertThrows(NullPointerException.class, 6477 () -> ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), null})); 6478 } 6479 6480 @Test testToPrimitive_long_long()6481 public void testToPrimitive_long_long() { 6482 final Long[] l = null; 6483 assertNull(ArrayUtils.toPrimitive(l, Long.MIN_VALUE)); 6484 6485 assertSame(ArrayUtils.EMPTY_LONG_ARRAY, 6486 ArrayUtils.toPrimitive(new Long[0], 1)); 6487 6488 assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), 6489 Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999)}, 1)); 6490 6491 assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), 6492 null, Long.valueOf(9999999)}, Long.MAX_VALUE)); 6493 } 6494 6495 /** testToPrimitive/Object for short */ 6496 @Test testToPrimitive_short()6497 public void testToPrimitive_short() { 6498 final Short[] b = null; 6499 assertNull(ArrayUtils.toPrimitive(b)); 6500 6501 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0])); 6502 6503 assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), 6504 Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999)})); 6505 6506 assertThrows(NullPointerException.class, 6507 () -> ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), null})); 6508 } 6509 6510 @Test testToPrimitive_short_short()6511 public void testToPrimitive_short_short() { 6512 final Short[] s = null; 6513 assertNull(ArrayUtils.toPrimitive(s, Short.MIN_VALUE)); 6514 6515 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0], 6516 Short.MIN_VALUE)); 6517 6518 assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), 6519 Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999)}, Short.MIN_VALUE)); 6520 6521 assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), null, 6522 Short.valueOf((short) 9999999)}, Short.MAX_VALUE)); 6523 } 6524 6525 @Test testToString()6526 public void testToString() { 6527 assertEquals("{}", ArrayUtils.toString(null)); 6528 assertEquals("{}", ArrayUtils.toString(new Object[0])); 6529 assertEquals("{}", ArrayUtils.toString(new String[0])); 6530 assertEquals("{<null>}", ArrayUtils.toString(new String[]{null})); 6531 assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"})); 6532 6533 assertEquals("<empty>", ArrayUtils.toString(null, "<empty>")); 6534 assertEquals("{}", ArrayUtils.toString(new Object[0], "<empty>")); 6535 assertEquals("{}", ArrayUtils.toString(new String[0], "<empty>")); 6536 assertEquals("{<null>}", ArrayUtils.toString(new String[]{null}, "<empty>")); 6537 assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"}, "<empty>")); 6538 } 6539 6540 @Test testToStringArray_array()6541 public void testToStringArray_array() { 6542 assertNull(ArrayUtils.toStringArray(null)); 6543 6544 assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0])); 6545 6546 final Object[] array = {1, 2, 3, "array", "test"}; 6547 assertArrayEquals(new String[]{"1", "2", "3", "array", "test"}, ArrayUtils.toStringArray(array)); 6548 6549 assertThrows(NullPointerException.class, () -> ArrayUtils.toStringArray(new Object[]{null})); 6550 } 6551 6552 @Test testToStringArray_array_string()6553 public void testToStringArray_array_string() { 6554 assertNull(ArrayUtils.toStringArray(null, "")); 6555 6556 assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0], "")); 6557 6558 final Object[] array = {1, null, "test"}; 6559 assertArrayEquals(new String[]{"1", "valueForNullElements", "test"}, 6560 ArrayUtils.toStringArray(array, "valueForNullElements")); 6561 } 6562 6563 @Test textIndexesOfInt()6564 public void textIndexesOfInt() { 6565 int[] array = null; 6566 final BitSet emptySet = new BitSet(); 6567 final BitSet testSet = new BitSet(); 6568 assertEquals(emptySet, ArrayUtils.indexesOf(array, 0)); 6569 array = new int[]{0, 1, 2, 3, 0}; 6570 testSet.set(0); 6571 testSet.set(4); 6572 assertEquals(testSet, ArrayUtils.indexesOf(array, 0)); 6573 testSet.clear(); 6574 testSet.set(1); 6575 assertEquals(testSet, ArrayUtils.indexesOf(array, 1)); 6576 testSet.clear(); 6577 testSet.set(2); 6578 assertEquals(testSet, ArrayUtils.indexesOf(array, 2)); 6579 testSet.clear(); 6580 testSet.set(3); 6581 assertEquals(testSet, ArrayUtils.indexesOf(array, 3)); 6582 assertEquals(emptySet, ArrayUtils.indexesOf(array, 99)); 6583 } 6584 } 6585