ArraysTest.java revision cc05ad238516f1303687aba4a978e24e57c0c07a
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 */ 17package tests.api.java.util; 18 19import dalvik.annotation.TestTargetNew; 20import dalvik.annotation.TestTargets; 21import dalvik.annotation.TestLevel; 22import dalvik.annotation.TestTargetClass; 23 24import java.lang.reflect.Method; 25import java.util.Arrays; 26import java.util.Comparator; 27import java.util.LinkedList; 28import java.util.List; 29 30import tests.support.Support_UnmodifiableCollectionTest; 31 32@TestTargetClass(Arrays.class) 33public class ArraysTest extends junit.framework.TestCase { 34 35 public static class ReversedIntegerComparator implements Comparator { 36 public int compare(Object o1, Object o2) { 37 return -(((Integer) o1).compareTo((Integer) o2)); 38 } 39 40 public boolean equals(Object o1, Object o2) { 41 return ((Integer) o1).compareTo((Integer) o2) == 0; 42 } 43 } 44 45 final static int arraySize = 100; 46 47 static Object[] objArray; 48 49 static boolean[] booleanArray; 50 51 static byte[] byteArray; 52 53 static char[] charArray; 54 55 static double[] doubleArray; 56 57 static float[] floatArray; 58 59 static int[] intArray; 60 61 static long[] longArray; 62 63 static Object[] objectArray; 64 65 static short[] shortArray; 66 { 67 objArray = new Object[arraySize]; 68 for (int i = 0; i < objArray.length; i++) 69 objArray[i] = new Integer(i); 70 } 71 72 /** 73 * @tests java.util.Arrays#asList(java.lang.Object[]) 74 */ 75 @TestTargetNew( 76 level = TestLevel.COMPLETE, 77 notes = "", 78 method = "asList", 79 args = {java.lang.Object[].class} 80 ) 81 public void test_asList$Ljava_lang_Object() { 82 // Test for method java.util.List 83 // java.util.Arrays.asList(java.lang.Object []) 84 List convertedList = Arrays.asList(objectArray); 85 for (int counter = 0; counter < arraySize; counter++) { 86 assertTrue( 87 "Array and List converted from array do not contain identical elements", 88 convertedList.get(counter) == objectArray[counter]); 89 } 90 convertedList.set(50, new Integer(1000)); 91 assertTrue("set/get did not work on coverted list", convertedList.get( 92 50).equals(new Integer(1000))); 93 convertedList.set(50, new Integer(50)); 94 new Support_UnmodifiableCollectionTest("", convertedList).runTest(); 95 96 Object[] myArray = (Object[]) (objectArray.clone()); 97 myArray[30] = null; 98 myArray[60] = null; 99 convertedList = Arrays.asList(myArray); 100 for (int counter = 0; counter < arraySize; counter++) { 101 assertTrue( 102 "Array and List converted from array do not contain identical elements", 103 convertedList.get(counter) == myArray[counter]); 104 } 105 106 try { 107 Arrays.asList((Object[])null); 108 fail("asList with null arg didn't throw NPE"); 109 } catch (NullPointerException e) { 110 // Expected 111 } 112 } 113 114 /** 115 * @tests java.util.Arrays#binarySearch(byte[], byte) 116 */ 117 @TestTargetNew( 118 level = TestLevel.COMPLETE, 119 notes = "", 120 method = "binarySearch", 121 args = {byte[].class, byte.class} 122 ) 123 public void test_binarySearch$BB() { 124 // Test for method int java.util.Arrays.binarySearch(byte [], byte) 125 for (byte counter = 0; counter < arraySize; counter++) 126 assertTrue("Binary search on byte[] answered incorrect position", 127 Arrays.binarySearch(byteArray, counter) == counter); 128 assertEquals("Binary search succeeded for value not present in array 1", 129 -1, Arrays.binarySearch(intArray, (byte) -1)); 130 assertTrue( 131 "Binary search succeeded for value not present in array 2", 132 Arrays.binarySearch(intArray, (byte) arraySize) == -(arraySize + 1)); 133 for (byte counter = 0; counter < arraySize; counter++) 134 byteArray[counter] -= 50; 135 for (byte counter = 0; counter < arraySize; counter++) 136 assertTrue( 137 "Binary search on byte[] involving negative numbers answered incorrect position", 138 Arrays.binarySearch(byteArray, (byte) (counter - 50)) == counter); 139 } 140 141 /** 142 * @tests java.util.Arrays#binarySearch(char[], char) 143 */ 144 @TestTargetNew( 145 level = TestLevel.COMPLETE, 146 notes = "", 147 method = "binarySearch", 148 args = {char[].class, char.class} 149 ) 150 public void test_binarySearch$CC() { 151 // Test for method int java.util.Arrays.binarySearch(char [], char) 152 for (char counter = 0; counter < arraySize; counter++) 153 assertTrue( 154 "Binary search on char[] answered incorrect position", 155 Arrays.binarySearch(charArray, (char) (counter + 1)) == counter); 156 assertEquals("Binary search succeeded for value not present in array 1", 157 -1, Arrays.binarySearch(charArray, '\u0000')); 158 assertTrue( 159 "Binary search succeeded for value not present in array 2", 160 Arrays.binarySearch(charArray, (char) (arraySize + 1)) == -(arraySize + 1)); 161 } 162 163 /** 164 * @tests java.util.Arrays#binarySearch(double[], double) 165 */ 166 @TestTargetNew( 167 level = TestLevel.COMPLETE, 168 notes = "", 169 method = "binarySearch", 170 args = {double[].class, double.class} 171 ) 172 public void test_binarySearch$DD() { 173 // Test for method int java.util.Arrays.binarySearch(double [], double) 174 for (int counter = 0; counter < arraySize; counter++) 175 assertTrue( 176 "Binary search on double[] answered incorrect position", 177 Arrays.binarySearch(doubleArray, (double) counter) == (double) counter); 178 assertEquals("Binary search succeeded for value not present in array 1", 179 -1, Arrays.binarySearch(doubleArray, (double) -1)); 180 assertTrue( 181 "Binary search succeeded for value not present in array 2", 182 Arrays.binarySearch(doubleArray, (double) arraySize) == -(arraySize + 1)); 183 for (int counter = 0; counter < arraySize; counter++) 184 doubleArray[counter] -= (double) 50; 185 for (int counter = 0; counter < arraySize; counter++) 186 assertTrue( 187 "Binary search on double[] involving negative numbers answered incorrect position", 188 Arrays.binarySearch(doubleArray, (double) (counter - 50)) == (double) counter); 189 190 double[] specials = new double[] { Double.NEGATIVE_INFINITY, 191 -Double.MAX_VALUE, -2d, -Double.MIN_VALUE, -0d, 0d, 192 Double.MIN_VALUE, 2d, Double.MAX_VALUE, 193 Double.POSITIVE_INFINITY, Double.NaN }; 194 for (int i = 0; i < specials.length; i++) { 195 int result = Arrays.binarySearch(specials, specials[i]); 196 assertTrue(specials[i] + " invalid: " + result, result == i); 197 } 198 assertEquals("-1d", -4, Arrays.binarySearch(specials, -1d)); 199 assertEquals("1d", -8, Arrays.binarySearch(specials, 1d)); 200 201 } 202 203 /** 204 * @tests java.util.Arrays#binarySearch(float[], float) 205 */ 206 @TestTargetNew( 207 level = TestLevel.COMPLETE, 208 notes = "", 209 method = "binarySearch", 210 args = {float[].class, float.class} 211 ) 212 public void test_binarySearch$FF() { 213 // Test for method int java.util.Arrays.binarySearch(float [], float) 214 for (int counter = 0; counter < arraySize; counter++) 215 assertTrue( 216 "Binary search on float[] answered incorrect position", 217 Arrays.binarySearch(floatArray, (float) counter) == (float) counter); 218 assertEquals("Binary search succeeded for value not present in array 1", 219 -1, Arrays.binarySearch(floatArray, (float) -1)); 220 assertTrue( 221 "Binary search succeeded for value not present in array 2", 222 Arrays.binarySearch(floatArray, (float) arraySize) == -(arraySize + 1)); 223 for (int counter = 0; counter < arraySize; counter++) 224 floatArray[counter] -= (float) 50; 225 for (int counter = 0; counter < arraySize; counter++) 226 assertTrue( 227 "Binary search on float[] involving negative numbers answered incorrect position", 228 Arrays.binarySearch(floatArray, (float) counter - 50) == (float) counter); 229 230 float[] specials = new float[] { Float.NEGATIVE_INFINITY, 231 -Float.MAX_VALUE, -2f, -Float.MIN_VALUE, -0f, 0f, 232 Float.MIN_VALUE, 2f, Float.MAX_VALUE, Float.POSITIVE_INFINITY, 233 Float.NaN }; 234 for (int i = 0; i < specials.length; i++) { 235 int result = Arrays.binarySearch(specials, specials[i]); 236 assertTrue(specials[i] + " invalid: " + result, result == i); 237 } 238 assertEquals("-1f", -4, Arrays.binarySearch(specials, -1f)); 239 assertEquals("1f", -8, Arrays.binarySearch(specials, 1f)); 240 } 241 242 /** 243 * @tests java.util.Arrays#binarySearch(int[], int) 244 */ 245 @TestTargetNew( 246 level = TestLevel.COMPLETE, 247 notes = "", 248 method = "binarySearch", 249 args = {int[].class, int.class} 250 ) 251 public void test_binarySearch$II() { 252 // Test for method int java.util.Arrays.binarySearch(int [], int) 253 for (int counter = 0; counter < arraySize; counter++) 254 assertTrue("Binary search on int[] answered incorrect position", 255 Arrays.binarySearch(intArray, counter) == counter); 256 assertEquals("Binary search succeeded for value not present in array 1", 257 -1, Arrays.binarySearch(intArray, -1)); 258 assertTrue("Binary search succeeded for value not present in array 2", 259 Arrays.binarySearch(intArray, arraySize) == -(arraySize + 1)); 260 for (int counter = 0; counter < arraySize; counter++) 261 intArray[counter] -= 50; 262 for (int counter = 0; counter < arraySize; counter++) 263 assertTrue( 264 "Binary search on int[] involving negative numbers answered incorrect position", 265 Arrays.binarySearch(intArray, counter - 50) == counter); 266 } 267 268 /** 269 * @tests java.util.Arrays#binarySearch(long[], long) 270 */ 271 @TestTargetNew( 272 level = TestLevel.COMPLETE, 273 notes = "", 274 method = "binarySearch", 275 args = {long[].class, long.class} 276 ) 277 public void test_binarySearch$JJ() { 278 // Test for method int java.util.Arrays.binarySearch(long [], long) 279 for (long counter = 0; counter < arraySize; counter++) 280 assertTrue("Binary search on long[] answered incorrect position", 281 Arrays.binarySearch(longArray, counter) == counter); 282 assertEquals("Binary search succeeded for value not present in array 1", 283 -1, Arrays.binarySearch(longArray, (long) -1)); 284 assertTrue( 285 "Binary search succeeded for value not present in array 2", 286 Arrays.binarySearch(longArray, (long) arraySize) == -(arraySize + 1)); 287 for (long counter = 0; counter < arraySize; counter++) 288 longArray[(int) counter] -= (long) 50; 289 for (long counter = 0; counter < arraySize; counter++) 290 assertTrue( 291 "Binary search on long[] involving negative numbers answered incorrect position", 292 Arrays.binarySearch(longArray, counter - (long) 50) == counter); 293 } 294 295 /** 296 * @tests java.util.Arrays#binarySearch(java.lang.Object[], 297 * java.lang.Object) 298 */ 299 @TestTargetNew( 300 level = TestLevel.COMPLETE, 301 notes = "", 302 method = "binarySearch", 303 args = {java.lang.Object[].class, java.lang.Object.class} 304 ) 305 public void test_binarySearch$Ljava_lang_ObjectLjava_lang_Object() { 306 // Test for method int java.util.Arrays.binarySearch(java.lang.Object 307 // [], java.lang.Object) 308 assertEquals( 309 "Binary search succeeded for non-comparable value in empty array", 310 -1, Arrays.binarySearch(new Object[] {}, new Object())); 311 assertEquals( 312 "Binary search succeeded for comparable value in empty array", 313 -1, Arrays.binarySearch(new Object[] {}, new Integer(-1))); 314 for (int counter = 0; counter < arraySize; counter++) 315 assertTrue( 316 "Binary search on Object[] answered incorrect position", 317 Arrays.binarySearch(objectArray, objArray[counter]) == counter); 318 assertEquals("Binary search succeeded for value not present in array 1", 319 -1, Arrays.binarySearch(objectArray, new Integer(-1))); 320 assertTrue( 321 "Binary search succeeded for value not present in array 2", 322 Arrays.binarySearch(objectArray, new Integer(arraySize)) == -(arraySize + 1)); 323 324 String[] sArray = new String[]{"1", "2", "3", "4", ""}; 325 Object[] oArray = sArray; 326 327 try { 328 Arrays.binarySearch(oArray, new Integer(10)); 329 fail("ClassCastException expected"); 330 } catch (ClassCastException e) { 331 //expected 332 } 333 } 334 335 /** 336 * @tests java.util.Arrays#binarySearch(java.lang.Object[], 337 * java.lang.Object, java.util.Comparator) 338 */ 339 @TestTargetNew( 340 level = TestLevel.PARTIAL_COMPLETE, 341 notes = "Doesn't verify ClassCastException.", 342 method = "binarySearch", 343 args = {java.lang.Object[].class, java.lang.Object.class, java.util.Comparator.class} 344 ) 345 public void test_binarySearch$Ljava_lang_ObjectLjava_lang_ObjectLjava_util_Comparator() { 346 // Test for method int java.util.Arrays.binarySearch(java.lang.Object 347 // [], java.lang.Object, java.util.Comparator) 348 Comparator comp = new ReversedIntegerComparator(); 349 for (int counter = 0; counter < arraySize; counter++) 350 objectArray[counter] = objArray[arraySize - counter - 1]; 351 assertTrue( 352 "Binary search succeeded for value not present in array 1", 353 Arrays.binarySearch(objectArray, new Integer(-1), comp) == -(arraySize + 1)); 354 assertEquals("Binary search succeeded for value not present in array 2", 355 -1, Arrays.binarySearch(objectArray, new Integer(arraySize), comp)); 356 for (int counter = 0; counter < arraySize; counter++) 357 assertTrue( 358 "Binary search on Object[] with custom comparator answered incorrect position", 359 Arrays.binarySearch(objectArray, objArray[counter], comp) == arraySize 360 - counter - 1); 361 } 362 363 /** 364 * @tests java.util.Arrays#binarySearch(short[], short) 365 */ 366 @TestTargetNew( 367 level = TestLevel.COMPLETE, 368 notes = "", 369 method = "binarySearch", 370 args = {short[].class, short.class} 371 ) 372 public void test_binarySearch$SS() { 373 // Test for method int java.util.Arrays.binarySearch(short [], short) 374 for (short counter = 0; counter < arraySize; counter++) 375 assertTrue("Binary search on short[] answered incorrect position", 376 Arrays.binarySearch(shortArray, counter) == counter); 377 assertEquals("Binary search succeeded for value not present in array 1", 378 -1, Arrays.binarySearch(intArray, (short) -1)); 379 assertTrue( 380 "Binary search succeeded for value not present in array 2", 381 Arrays.binarySearch(intArray, (short) arraySize) == -(arraySize + 1)); 382 for (short counter = 0; counter < arraySize; counter++) 383 shortArray[counter] -= 50; 384 for (short counter = 0; counter < arraySize; counter++) 385 assertTrue( 386 "Binary search on short[] involving negative numbers answered incorrect position", 387 Arrays.binarySearch(shortArray, (short) (counter - 50)) == counter); 388 } 389 390 /** 391 * @tests java.util.Arrays#fill(byte[], byte) 392 */ 393 @TestTargetNew( 394 level = TestLevel.COMPLETE, 395 notes = "", 396 method = "fill", 397 args = {byte[].class, byte.class} 398 ) 399 public void test_fill$BB() { 400 // Test for method void java.util.Arrays.fill(byte [], byte) 401 402 byte d[] = new byte[1000]; 403 Arrays.fill(d, Byte.MAX_VALUE); 404 for (int i = 0; i < d.length; i++) 405 assertTrue("Failed to fill byte array correctly", 406 d[i] == Byte.MAX_VALUE); 407 } 408 409 /** 410 * @tests java.util.Arrays#fill(byte[], int, int, byte) 411 */ 412 @TestTargetNew( 413 level = TestLevel.COMPLETE, 414 notes = "", 415 method = "fill", 416 args = {byte[].class, int.class, int.class, byte.class} 417 ) 418 public void test_fill$BIIB() { 419 // Test for method void java.util.Arrays.fill(byte [], int, int, byte) 420 byte val = Byte.MAX_VALUE; 421 byte d[] = new byte[1000]; 422 Arrays.fill(d, 400, d.length, val); 423 for (int i = 0; i < 400; i++) 424 assertTrue("Filled elements not in range", !(d[i] == val)); 425 for (int i = 400; i < d.length; i++) 426 assertTrue("Failed to fill byte array correctly", d[i] == val); 427 428 int result; 429 try { 430 Arrays.fill(new byte[2], 2, 1, (byte) 27); 431 result = 0; 432 } catch (ArrayIndexOutOfBoundsException e) { 433 result = 1; 434 } catch (IllegalArgumentException e) { 435 result = 2; 436 } 437 assertEquals("Wrong exception1", 2, result); 438 try { 439 Arrays.fill(new byte[2], -1, 1, (byte) 27); 440 result = 0; 441 } catch (ArrayIndexOutOfBoundsException e) { 442 result = 1; 443 } catch (IllegalArgumentException e) { 444 result = 2; 445 } 446 assertEquals("Wrong exception2", 1, result); 447 try { 448 Arrays.fill(new byte[2], 1, 4, (byte) 27); 449 result = 0; 450 } catch (ArrayIndexOutOfBoundsException e) { 451 result = 1; 452 } catch (IllegalArgumentException e) { 453 result = 2; 454 } 455 assertEquals("Wrong exception", 1, result); 456 } 457 458 /** 459 * @tests java.util.Arrays#fill(short[], short) 460 */ 461 @TestTargetNew( 462 level = TestLevel.COMPLETE, 463 notes = "", 464 method = "fill", 465 args = {short[].class, short.class} 466 ) 467 public void test_fill$SS() { 468 // Test for method void java.util.Arrays.fill(short [], short) 469 470 short d[] = new short[1000]; 471 Arrays.fill(d, Short.MAX_VALUE); 472 for (int i = 0; i < d.length; i++) 473 assertTrue("Failed to fill short array correctly", 474 d[i] == Short.MAX_VALUE); 475 } 476 477 /** 478 * @tests java.util.Arrays#fill(short[], int, int, short) 479 */ 480 @TestTargetNew( 481 level = TestLevel.COMPLETE, 482 notes = "", 483 method = "fill", 484 args = {short[].class, int.class, int.class, short.class} 485 ) 486 public void test_fill$SIIS() { 487 // Test for method void java.util.Arrays.fill(short [], int, int, short) 488 short val = Short.MAX_VALUE; 489 short d[] = new short[1000]; 490 Arrays.fill(d, 400, d.length, val); 491 for (int i = 0; i < 400; i++) 492 assertTrue("Filled elements not in range", !(d[i] == val)); 493 for (int i = 400; i < d.length; i++) 494 assertTrue("Failed to fill short array correctly", d[i] == val); 495 496 try { 497 Arrays.fill(d, 10, 0, val); 498 fail("IllegalArgumentException expected"); 499 } catch (IllegalArgumentException e) { 500 //expected 501 } 502 503 try { 504 Arrays.fill(d, -10, 0, val); 505 fail("ArrayIndexOutOfBoundsException expected"); 506 } catch (ArrayIndexOutOfBoundsException e) { 507 //expected 508 } 509 510 try { 511 Arrays.fill(d, 10, d.length+1, val); 512 fail("ArrayIndexOutOfBoundsException expected"); 513 } catch (ArrayIndexOutOfBoundsException e) { 514 //expected 515 } 516 } 517 518 /** 519 * @tests java.util.Arrays#fill(char[], char) 520 */ 521 @TestTargetNew( 522 level = TestLevel.COMPLETE, 523 notes = "", 524 method = "fill", 525 args = {char[].class, char.class} 526 ) 527 public void test_fill$CC() { 528 // Test for method void java.util.Arrays.fill(char [], char) 529 530 char d[] = new char[1000]; 531 Arrays.fill(d, 'V'); 532 for (int i = 0; i < d.length; i++) 533 assertEquals("Failed to fill char array correctly", 'V', d[i]); 534 } 535 536 /** 537 * @tests java.util.Arrays#fill(char[], int, int, char) 538 */ 539 @TestTargetNew( 540 level = TestLevel.COMPLETE, 541 notes = "", 542 method = "fill", 543 args = {char[].class, int.class, int.class, char.class} 544 ) 545 public void test_fill$CIIC() { 546 // Test for method void java.util.Arrays.fill(char [], int, int, char) 547 char val = 'T'; 548 char d[] = new char[1000]; 549 Arrays.fill(d, 400, d.length, val); 550 for (int i = 0; i < 400; i++) 551 assertTrue("Filled elements not in range", !(d[i] == val)); 552 for (int i = 400; i < d.length; i++) 553 assertTrue("Failed to fill char array correctly", d[i] == val); 554 555 try { 556 Arrays.fill(d, 10, 0, val); 557 fail("IllegalArgumentException expected"); 558 } catch (IllegalArgumentException e) { 559 //expected 560 } 561 562 try { 563 Arrays.fill(d, -10, 0, val); 564 fail("ArrayIndexOutOfBoundsException expected"); 565 } catch (ArrayIndexOutOfBoundsException e) { 566 //expected 567 } 568 569 try { 570 Arrays.fill(d, 10, d.length+1, val); 571 fail("ArrayIndexOutOfBoundsException expected"); 572 } catch (ArrayIndexOutOfBoundsException e) { 573 //expected 574 } 575 } 576 577 /** 578 * @tests java.util.Arrays#fill(int[], int) 579 */ 580 @TestTargetNew( 581 level = TestLevel.COMPLETE, 582 notes = "", 583 method = "fill", 584 args = {int[].class, int.class} 585 ) 586 public void test_fill$II() { 587 // Test for method void java.util.Arrays.fill(int [], int) 588 589 int d[] = new int[1000]; 590 Arrays.fill(d, Integer.MAX_VALUE); 591 for (int i = 0; i < d.length; i++) 592 assertTrue("Failed to fill int array correctly", 593 d[i] == Integer.MAX_VALUE); 594 } 595 596 /** 597 * @tests java.util.Arrays#fill(int[], int, int, int) 598 */ 599 @TestTargetNew( 600 level = TestLevel.COMPLETE, 601 notes = "", 602 method = "fill", 603 args = {int[].class, int.class, int.class, int.class} 604 ) 605 public void test_fill$IIII() { 606 // Test for method void java.util.Arrays.fill(int [], int, int, int) 607 int val = Integer.MAX_VALUE; 608 int d[] = new int[1000]; 609 Arrays.fill(d, 400, d.length, val); 610 for (int i = 0; i < 400; i++) 611 assertTrue("Filled elements not in range", !(d[i] == val)); 612 for (int i = 400; i < d.length; i++) 613 assertTrue("Failed to fill int array correctly", d[i] == val); 614 615 try { 616 Arrays.fill(d, 10, 0, val); 617 fail("IllegalArgumentException expected"); 618 } catch (IllegalArgumentException e) { 619 //expected 620 } 621 622 try { 623 Arrays.fill(d, -10, 0, val); 624 fail("ArrayIndexOutOfBoundsException expected"); 625 } catch (ArrayIndexOutOfBoundsException e) { 626 //expected 627 } 628 629 try { 630 Arrays.fill(d, 10, d.length+1, val); 631 fail("ArrayIndexOutOfBoundsException expected"); 632 } catch (ArrayIndexOutOfBoundsException e) { 633 //expected 634 } 635 } 636 637 /** 638 * @tests java.util.Arrays#fill(long[], long) 639 */ 640 @TestTargetNew( 641 level = TestLevel.COMPLETE, 642 notes = "", 643 method = "fill", 644 args = {long[].class, long.class} 645 ) 646 public void test_fill$JJ() { 647 // Test for method void java.util.Arrays.fill(long [], long) 648 649 long d[] = new long[1000]; 650 Arrays.fill(d, Long.MAX_VALUE); 651 for (int i = 0; i < d.length; i++) 652 assertTrue("Failed to fill long array correctly", 653 d[i] == Long.MAX_VALUE); 654 } 655 656 /** 657 * @tests java.util.Arrays#fill(long[], int, int, long) 658 */ 659 @TestTargetNew( 660 level = TestLevel.COMPLETE, 661 notes = "", 662 method = "fill", 663 args = {long[].class, int.class, int.class, long.class} 664 ) 665 public void test_fill$JIIJ() { 666 // Test for method void java.util.Arrays.fill(long [], int, int, long) 667 long d[] = new long[1000]; 668 Arrays.fill(d, 400, d.length, Long.MAX_VALUE); 669 for (int i = 0; i < 400; i++) 670 assertTrue("Filled elements not in range", !(d[i] == Long.MAX_VALUE)); 671 for (int i = 400; i < d.length; i++) 672 assertTrue("Failed to fill long array correctly", 673 d[i] == Long.MAX_VALUE); 674 675 try { 676 Arrays.fill(d, 10, 0, Long.MIN_VALUE); 677 fail("IllegalArgumentException expected"); 678 } catch (IllegalArgumentException e) { 679 //expected 680 } 681 682 try { 683 Arrays.fill(d, -10, 0, Long.MAX_VALUE); 684 fail("ArrayIndexOutOfBoundsException expected"); 685 } catch (ArrayIndexOutOfBoundsException e) { 686 //expected 687 } 688 689 try { 690 Arrays.fill(d, 10, d.length+1, Long.MAX_VALUE); 691 fail("ArrayIndexOutOfBoundsException expected"); 692 } catch (ArrayIndexOutOfBoundsException e) { 693 //expected 694 } 695 } 696 697 /** 698 * @tests java.util.Arrays#fill(float[], float) 699 */ 700 @TestTargetNew( 701 level = TestLevel.COMPLETE, 702 notes = "", 703 method = "fill", 704 args = {float[].class, float.class} 705 ) 706 public void test_fill$FF() { 707 // Test for method void java.util.Arrays.fill(float [], float) 708 float d[] = new float[1000]; 709 Arrays.fill(d, Float.MAX_VALUE); 710 for (int i = 0; i < d.length; i++) 711 assertTrue("Failed to fill float array correctly", 712 d[i] == Float.MAX_VALUE); 713 } 714 715 /** 716 * @tests java.util.Arrays#fill(float[], int, int, float) 717 */ 718 @TestTargetNew( 719 level = TestLevel.COMPLETE, 720 notes = "", 721 method = "fill", 722 args = {float[].class, int.class, int.class, float.class} 723 ) 724 public void test_fill$FIIF() { 725 // Test for method void java.util.Arrays.fill(float [], int, int, float) 726 float val = Float.MAX_VALUE; 727 float d[] = new float[1000]; 728 Arrays.fill(d, 400, d.length, val); 729 for (int i = 0; i < 400; i++) 730 assertTrue("Filled elements not in range", !(d[i] == val)); 731 for (int i = 400; i < d.length; i++) 732 assertTrue("Failed to fill float array correctly", d[i] == val); 733 734 try { 735 Arrays.fill(d, 10, 0, val); 736 fail("IllegalArgumentException expected"); 737 } catch (IllegalArgumentException e) { 738 //expected 739 } 740 741 try { 742 Arrays.fill(d, -10, 0, val); 743 fail("ArrayIndexOutOfBoundsException expected"); 744 } catch (ArrayIndexOutOfBoundsException e) { 745 //expected 746 } 747 748 try { 749 Arrays.fill(d, 10, d.length+1, val); 750 fail("ArrayIndexOutOfBoundsException expected"); 751 } catch (ArrayIndexOutOfBoundsException e) { 752 //expected 753 } 754 } 755 756 /** 757 * @tests java.util.Arrays#fill(double[], double) 758 */ 759 @TestTargetNew( 760 level = TestLevel.COMPLETE, 761 notes = "", 762 method = "fill", 763 args = {double[].class, double.class} 764 ) 765 public void test_fill$DD() { 766 // Test for method void java.util.Arrays.fill(double [], double) 767 768 double d[] = new double[1000]; 769 Arrays.fill(d, Double.MAX_VALUE); 770 for (int i = 0; i < d.length; i++) 771 assertTrue("Failed to fill double array correctly", 772 d[i] == Double.MAX_VALUE); 773 } 774 775 /** 776 * @tests java.util.Arrays#fill(double[], int, int, double) 777 */ 778 @TestTargetNew( 779 level = TestLevel.COMPLETE, 780 notes = "", 781 method = "fill", 782 args = {double[].class, int.class, int.class, double.class} 783 ) 784 public void test_fill$DIID() { 785 // Test for method void java.util.Arrays.fill(double [], int, int, 786 // double) 787 double val = Double.MAX_VALUE; 788 double d[] = new double[1000]; 789 Arrays.fill(d, 400, d.length, val); 790 for (int i = 0; i < 400; i++) 791 assertTrue("Filled elements not in range", !(d[i] == val)); 792 for (int i = 400; i < d.length; i++) 793 assertTrue("Failed to fill double array correctly", d[i] == val); 794 795 try { 796 Arrays.fill(d, 10, 0, val); 797 fail("IllegalArgumentException expected"); 798 } catch (IllegalArgumentException e) { 799 //expected 800 } 801 802 try { 803 Arrays.fill(d, -10, 0, val); 804 fail("ArrayIndexOutOfBoundsException expected"); 805 } catch (ArrayIndexOutOfBoundsException e) { 806 //expected 807 } 808 809 try { 810 Arrays.fill(d, 10, d.length+1, val); 811 fail("ArrayIndexOutOfBoundsException expected"); 812 } catch (ArrayIndexOutOfBoundsException e) { 813 //expected 814 } 815 } 816 817 /** 818 * @tests java.util.Arrays#fill(boolean[], boolean) 819 */ 820 @TestTargetNew( 821 level = TestLevel.COMPLETE, 822 notes = "", 823 method = "fill", 824 args = {boolean[].class, boolean.class} 825 ) 826 public void test_fill$ZZ() { 827 // Test for method void java.util.Arrays.fill(boolean [], boolean) 828 829 boolean d[] = new boolean[1000]; 830 Arrays.fill(d, true); 831 for (int i = 0; i < d.length; i++) 832 assertTrue("Failed to fill boolean array correctly", d[i]); 833 } 834 835 /** 836 * @tests java.util.Arrays#fill(boolean[], int, int, boolean) 837 */ 838 @TestTargetNew( 839 level = TestLevel.COMPLETE, 840 notes = "", 841 method = "fill", 842 args = {boolean[].class, int.class, int.class, boolean.class} 843 ) 844 public void test_fill$ZIIZ() { 845 // Test for method void java.util.Arrays.fill(boolean [], int, int, 846 // boolean) 847 boolean val = true; 848 boolean d[] = new boolean[1000]; 849 Arrays.fill(d, 400, d.length, val); 850 for (int i = 0; i < 400; i++) 851 assertTrue("Filled elements not in range", !(d[i] == val)); 852 for (int i = 400; i < d.length; i++) 853 assertTrue("Failed to fill boolean array correctly", d[i] == val); 854 855 try { 856 Arrays.fill(d, 10, 0, val); 857 fail("IllegalArgumentException expected"); 858 } catch (IllegalArgumentException e) { 859 //expected 860 } 861 862 try { 863 Arrays.fill(d, -10, 0, val); 864 fail("ArrayIndexOutOfBoundsException expected"); 865 } catch (ArrayIndexOutOfBoundsException e) { 866 //expected 867 } 868 869 try { 870 Arrays.fill(d, 10, d.length+1, val); 871 fail("ArrayIndexOutOfBoundsException expected"); 872 } catch (ArrayIndexOutOfBoundsException e) { 873 //expected 874 } 875 } 876 877 /** 878 * @tests java.util.Arrays#fill(java.lang.Object[], java.lang.Object) 879 */ 880 @TestTargetNew( 881 level = TestLevel.COMPLETE, 882 notes = "", 883 method = "fill", 884 args = {java.lang.Object[].class, java.lang.Object.class} 885 ) 886 public void test_fill$Ljava_lang_ObjectLjava_lang_Object() { 887 // Test for method void java.util.Arrays.fill(java.lang.Object [], 888 // java.lang.Object) 889 Object val = new Object(); 890 Object d[] = new Object[1000]; 891 Arrays.fill(d, 0, d.length, val); 892 for (int i = 0; i < d.length; i++) 893 assertTrue("Failed to fill Object array correctly", d[i] == val); 894 } 895 896 /** 897 * @tests java.util.Arrays#fill(java.lang.Object[], int, int, 898 * java.lang.Object) 899 */ 900 @TestTargetNew( 901 level = TestLevel.COMPLETE, 902 notes = "", 903 method = "fill", 904 args = {java.lang.Object[].class, int.class, int.class, java.lang.Object.class} 905 ) 906 public void test_fill$Ljava_lang_ObjectIILjava_lang_Object() { 907 // Test for method void java.util.Arrays.fill(java.lang.Object [], int, 908 // int, java.lang.Object) 909 Object val = new Object(); 910 Object d[] = new Object[1000]; 911 Arrays.fill(d, 400, d.length, val); 912 for (int i = 0; i < 400; i++) 913 assertTrue("Filled elements not in range", !(d[i] == val)); 914 for (int i = 400; i < d.length; i++) 915 assertTrue("Failed to fill Object array correctly", d[i] == val); 916 917 Arrays.fill(d, 400, d.length, null); 918 for (int i = 400; i < d.length; i++) 919 assertNull("Failed to fill Object array correctly with nulls", 920 d[i]); 921 922 try { 923 Arrays.fill(d, 10, 0, val); 924 fail("IllegalArgumentException expected"); 925 } catch (IllegalArgumentException e) { 926 //expected 927 } 928 929 try { 930 Arrays.fill(d, -10, 0, val); 931 fail("ArrayIndexOutOfBoundsException expected"); 932 } catch (ArrayIndexOutOfBoundsException e) { 933 //expected 934 } 935 936 try { 937 Arrays.fill(d, 10, d.length+1, val); 938 fail("ArrayIndexOutOfBoundsException expected"); 939 } catch (ArrayIndexOutOfBoundsException e) { 940 //expected 941 } 942 } 943 944 /** 945 * @tests java.util.Arrays#equals(byte[], byte[]) 946 */ 947 @TestTargetNew( 948 level = TestLevel.COMPLETE, 949 notes = "", 950 method = "equals", 951 args = {byte[].class, byte[].class} 952 ) 953 public void test_equals$B$B() { 954 // Test for method boolean java.util.Arrays.equals(byte [], byte []) 955 byte d[] = new byte[1000]; 956 byte x[] = new byte[1000]; 957 Arrays.fill(d, Byte.MAX_VALUE); 958 Arrays.fill(x, Byte.MIN_VALUE); 959 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 960 Arrays.fill(x, Byte.MAX_VALUE); 961 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 962 } 963 964 /** 965 * @tests java.util.Arrays#equals(short[], short[]) 966 */ 967 @TestTargetNew( 968 level = TestLevel.COMPLETE, 969 notes = "", 970 method = "equals", 971 args = {short[].class, short[].class} 972 ) 973 public void test_equals$S$S() { 974 // Test for method boolean java.util.Arrays.equals(short [], short []) 975 short d[] = new short[1000]; 976 short x[] = new short[1000]; 977 Arrays.fill(d, Short.MAX_VALUE); 978 Arrays.fill(x, Short.MIN_VALUE); 979 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 980 Arrays.fill(x, Short.MAX_VALUE); 981 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 982 } 983 984 /** 985 * @tests java.util.Arrays#equals(char[], char[]) 986 */ 987 @TestTargetNew( 988 level = TestLevel.COMPLETE, 989 notes = "", 990 method = "equals", 991 args = {char[].class, char[].class} 992 ) 993 public void test_equals$C$C() { 994 // Test for method boolean java.util.Arrays.equals(char [], char []) 995 char d[] = new char[1000]; 996 char x[] = new char[1000]; 997 char c = 'T'; 998 Arrays.fill(d, c); 999 Arrays.fill(x, 'L'); 1000 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 1001 Arrays.fill(x, c); 1002 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 1003 } 1004 1005 /** 1006 * @tests java.util.Arrays#equals(int[], int[]) 1007 */ 1008 @TestTargetNew( 1009 level = TestLevel.COMPLETE, 1010 notes = "", 1011 method = "equals", 1012 args = {int[].class, int[].class} 1013 ) 1014 public void test_equals$I$I() { 1015 // Test for method boolean java.util.Arrays.equals(int [], int []) 1016 int d[] = new int[1000]; 1017 int x[] = new int[1000]; 1018 Arrays.fill(d, Integer.MAX_VALUE); 1019 Arrays.fill(x, Integer.MIN_VALUE); 1020 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 1021 Arrays.fill(x, Integer.MAX_VALUE); 1022 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 1023 1024 assertTrue("wrong result for null array1", !Arrays.equals(new int[2], 1025 null)); 1026 assertTrue("wrong result for null array2", !Arrays.equals(null, 1027 new int[2])); 1028 } 1029 1030 /** 1031 * @tests java.util.Arrays#equals(long[], long[]) 1032 */ 1033 @TestTargetNew( 1034 level = TestLevel.COMPLETE, 1035 notes = "", 1036 method = "equals", 1037 args = {long[].class, long[].class} 1038 ) 1039 public void test_equals$J$J() { 1040 // Test for method boolean java.util.Arrays.equals(long [], long []) 1041 long d[] = new long[1000]; 1042 long x[] = new long[1000]; 1043 Arrays.fill(d, Long.MAX_VALUE); 1044 Arrays.fill(x, Long.MIN_VALUE); 1045 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 1046 Arrays.fill(x, Long.MAX_VALUE); 1047 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 1048 1049 assertTrue("should be false", !Arrays.equals( 1050 new long[] { 0x100000000L }, new long[] { 0x200000000L })); 1051 1052 } 1053 1054 /** 1055 * @tests java.util.Arrays#equals(float[], float[]) 1056 */ 1057 @TestTargetNew( 1058 level = TestLevel.COMPLETE, 1059 notes = "", 1060 method = "equals", 1061 args = {float[].class, float[].class} 1062 ) 1063 public void test_equals$F$F() { 1064 // Test for method boolean java.util.Arrays.equals(float [], float []) 1065 float d[] = new float[1000]; 1066 float x[] = new float[1000]; 1067 Arrays.fill(d, Float.MAX_VALUE); 1068 Arrays.fill(x, Float.MIN_VALUE); 1069 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 1070 Arrays.fill(x, Float.MAX_VALUE); 1071 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 1072 1073 assertTrue("NaN not equals", Arrays.equals(new float[] { Float.NaN }, 1074 new float[] { Float.NaN })); 1075 assertTrue("0f equals -0f", !Arrays.equals(new float[] { 0f }, 1076 new float[] { -0f })); 1077 } 1078 1079 /** 1080 * @tests java.util.Arrays#equals(double[], double[]) 1081 */ 1082 @TestTargetNew( 1083 level = TestLevel.COMPLETE, 1084 notes = "", 1085 method = "equals", 1086 args = {double[].class, double[].class} 1087 ) 1088 public void test_equals$D$D() { 1089 // Test for method boolean java.util.Arrays.equals(double [], double []) 1090 double d[] = new double[1000]; 1091 double x[] = new double[1000]; 1092 Arrays.fill(d, Double.MAX_VALUE); 1093 Arrays.fill(x, Double.MIN_VALUE); 1094 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 1095 Arrays.fill(x, Double.MAX_VALUE); 1096 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 1097 1098 assertTrue("should be false", !Arrays.equals(new double[] { 1.0 }, 1099 new double[] { 2.0 })); 1100 1101 assertTrue("NaN not equals", Arrays.equals(new double[] { Double.NaN }, 1102 new double[] { Double.NaN })); 1103 assertTrue("0d equals -0d", !Arrays.equals(new double[] { 0d }, 1104 new double[] { -0d })); 1105 } 1106 1107 /** 1108 * @tests java.util.Arrays#equals(boolean[], boolean[]) 1109 */ 1110 @TestTargetNew( 1111 level = TestLevel.COMPLETE, 1112 notes = "", 1113 method = "equals", 1114 args = {boolean[].class, boolean[].class} 1115 ) 1116 public void test_equals$Z$Z() { 1117 // Test for method boolean java.util.Arrays.equals(boolean [], boolean 1118 // []) 1119 boolean d[] = new boolean[1000]; 1120 boolean x[] = new boolean[1000]; 1121 Arrays.fill(d, true); 1122 Arrays.fill(x, false); 1123 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 1124 Arrays.fill(x, true); 1125 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 1126 } 1127 1128 /** 1129 * @tests java.util.Arrays#equals(java.lang.Object[], java.lang.Object[]) 1130 */ 1131 @TestTargetNew( 1132 level = TestLevel.COMPLETE, 1133 notes = "", 1134 method = "equals", 1135 args = {java.lang.Object[].class, java.lang.Object[].class} 1136 ) 1137 public void test_equals$Ljava_lang_Object$Ljava_lang_Object() { 1138 // Test for method boolean java.util.Arrays.equals(java.lang.Object [], 1139 // java.lang.Object []) 1140 Object d[] = new Object[1000]; 1141 Object x[] = new Object[1000]; 1142 Object o = new Object(); 1143 Arrays.fill(d, o); 1144 Arrays.fill(x, new Object()); 1145 assertTrue("Inequal arrays returned true", !Arrays.equals(d, x)); 1146 Arrays.fill(x, o); 1147 d[50] = null; 1148 x[50] = null; 1149 assertTrue("equal arrays returned false", Arrays.equals(d, x)); 1150 } 1151 1152 /** 1153 * @tests java.util.Arrays#sort(byte[]) 1154 */ 1155 @TestTargetNew( 1156 level = TestLevel.COMPLETE, 1157 notes = "", 1158 method = "sort", 1159 args = {byte[].class} 1160 ) 1161 public void test_sort$B() { 1162 // Test for method void java.util.Arrays.sort(byte []) 1163 byte[] reversedArray = new byte[arraySize]; 1164 for (int counter = 0; counter < arraySize; counter++) 1165 reversedArray[counter] = (byte) (arraySize - counter - 1); 1166 Arrays.sort(reversedArray); 1167 for (int counter = 0; counter < arraySize; counter++) 1168 assertTrue("Resulting array not sorted", 1169 reversedArray[counter] == (byte) counter); 1170 } 1171 1172 /** 1173 * @tests java.util.Arrays#sort(byte[], int, int) 1174 */ 1175 @TestTargetNew( 1176 level = TestLevel.COMPLETE, 1177 notes = "", 1178 method = "sort", 1179 args = {byte[].class, int.class, int.class} 1180 ) 1181 public void test_sort$BII() { 1182 // Test for method void java.util.Arrays.sort(byte [], int, int) 1183 int startIndex = arraySize / 4; 1184 int endIndex = 3 * arraySize / 4; 1185 byte[] reversedArray = new byte[arraySize]; 1186 byte[] originalReversedArray = new byte[arraySize]; 1187 for (int counter = 0; counter < arraySize; counter++) { 1188 reversedArray[counter] = (byte) (arraySize - counter - 1); 1189 originalReversedArray[counter] = reversedArray[counter]; 1190 } 1191 Arrays.sort(reversedArray, startIndex, endIndex); 1192 for (int counter = 0; counter < startIndex; counter++) 1193 assertTrue("Array modified outside of bounds", 1194 reversedArray[counter] == originalReversedArray[counter]); 1195 for (int counter = startIndex; counter < endIndex - 1; counter++) 1196 assertTrue("Array not sorted within bounds", 1197 reversedArray[counter] <= reversedArray[counter + 1]); 1198 for (int counter = endIndex; counter < arraySize; counter++) 1199 assertTrue("Array modified outside of bounds", 1200 reversedArray[counter] == originalReversedArray[counter]); 1201 1202 //exception testing 1203 try { 1204 Arrays.sort(reversedArray, startIndex + 1, startIndex); 1205 fail("IllegalArgumentException expected"); 1206 } catch (IllegalArgumentException ignore) { 1207 } 1208 1209 try { 1210 Arrays.sort(reversedArray, -1, startIndex); 1211 fail("ArrayIndexOutOfBoundsException expected (1)"); 1212 } catch (ArrayIndexOutOfBoundsException ignore) { 1213 } 1214 1215 try { 1216 Arrays.sort(reversedArray, startIndex, reversedArray.length + 1); 1217 fail("ArrayIndexOutOfBoundsException expected (2)"); 1218 } catch (ArrayIndexOutOfBoundsException ignore) { 1219 } 1220 1221 //exception order testing 1222 try { 1223 Arrays.sort(new byte[1], startIndex + 1, startIndex); 1224 fail("IllegalArgumentException expected"); 1225 } catch (IllegalArgumentException ignore) { 1226 } 1227 } 1228 1229 /** 1230 * @tests java.util.Arrays#sort(char[]) 1231 */ 1232 @TestTargetNew( 1233 level = TestLevel.COMPLETE, 1234 notes = "", 1235 method = "sort", 1236 args = {char[].class} 1237 ) 1238 public void test_sort$C() { 1239 // Test for method void java.util.Arrays.sort(char []) 1240 char[] reversedArray = new char[arraySize]; 1241 for (int counter = 0; counter < arraySize; counter++) 1242 reversedArray[counter] = (char) (arraySize - counter - 1); 1243 Arrays.sort(reversedArray); 1244 for (int counter = 0; counter < arraySize; counter++) 1245 assertTrue("Resulting array not sorted", 1246 reversedArray[counter] == (char) counter); 1247 1248 } 1249 1250 /** 1251 * @tests java.util.Arrays#sort(char[], int, int) 1252 */ 1253 @TestTargetNew( 1254 level = TestLevel.COMPLETE, 1255 notes = "", 1256 method = "sort", 1257 args = {char[].class, int.class, int.class} 1258 ) 1259 public void test_sort$CII() { 1260 // Test for method void java.util.Arrays.sort(char [], int, int) 1261 int startIndex = arraySize / 4; 1262 int endIndex = 3 * arraySize / 4; 1263 char[] reversedArray = new char[arraySize]; 1264 char[] originalReversedArray = new char[arraySize]; 1265 for (int counter = 0; counter < arraySize; counter++) { 1266 reversedArray[counter] = (char) (arraySize - counter - 1); 1267 originalReversedArray[counter] = reversedArray[counter]; 1268 } 1269 Arrays.sort(reversedArray, startIndex, endIndex); 1270 for (int counter = 0; counter < startIndex; counter++) 1271 assertTrue("Array modified outside of bounds", 1272 reversedArray[counter] == originalReversedArray[counter]); 1273 for (int counter = startIndex; counter < endIndex - 1; counter++) 1274 assertTrue("Array not sorted within bounds", 1275 reversedArray[counter] <= reversedArray[counter + 1]); 1276 for (int counter = endIndex; counter < arraySize; counter++) 1277 assertTrue("Array modified outside of bounds", 1278 reversedArray[counter] == originalReversedArray[counter]); 1279 1280 //exception testing 1281 try { 1282 Arrays.sort(reversedArray, startIndex + 1, startIndex); 1283 fail("IllegalArgumentException expected"); 1284 } catch (IllegalArgumentException ignore) { 1285 } 1286 1287 try { 1288 Arrays.sort(reversedArray, -1, startIndex); 1289 fail("ArrayIndexOutOfBoundsException expected (1)"); 1290 } catch (ArrayIndexOutOfBoundsException ignore) { 1291 } 1292 1293 try { 1294 Arrays.sort(reversedArray, startIndex, reversedArray.length + 1); 1295 fail("ArrayIndexOutOfBoundsException expected (2)"); 1296 } catch (ArrayIndexOutOfBoundsException ignore) { 1297 } 1298 1299 //exception order testing 1300 try { 1301 Arrays.sort(new char[1], startIndex + 1, startIndex); 1302 fail("IllegalArgumentException expected"); 1303 } catch (IllegalArgumentException ignore) { 1304 } 1305 } 1306 1307 /** 1308 * @tests java.util.Arrays#sort(double[]) 1309 */ 1310 @TestTargetNew( 1311 level = TestLevel.COMPLETE, 1312 notes = "", 1313 method = "sort", 1314 args = {double[].class} 1315 ) 1316 public void test_sort$D() { 1317 // Test for method void java.util.Arrays.sort(double []) 1318 double[] reversedArray = new double[arraySize]; 1319 for (int counter = 0; counter < arraySize; counter++) 1320 reversedArray[counter] = (double) (arraySize - counter - 1); 1321 Arrays.sort(reversedArray); 1322 for (int counter = 0; counter < arraySize; counter++) 1323 assertTrue("Resulting array not sorted", 1324 reversedArray[counter] == (double) counter); 1325 1326 double[] specials1 = new double[] { Double.NaN, Double.MAX_VALUE, 1327 Double.MIN_VALUE, 0d, -0d, Double.POSITIVE_INFINITY, 1328 Double.NEGATIVE_INFINITY }; 1329 double[] specials2 = new double[] { 0d, Double.POSITIVE_INFINITY, -0d, 1330 Double.NEGATIVE_INFINITY, Double.MIN_VALUE, Double.NaN, 1331 Double.MAX_VALUE }; 1332 double[] answer = new double[] { Double.NEGATIVE_INFINITY, -0d, 0d, 1333 Double.MIN_VALUE, Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1334 Double.NaN }; 1335 1336 Arrays.sort(specials1); 1337 Object[] print1 = new Object[specials1.length]; 1338 for (int i = 0; i < specials1.length; i++) 1339 print1[i] = new Double(specials1[i]); 1340 assertTrue("specials sort incorrectly 1: " + Arrays.asList(print1), 1341 Arrays.equals(specials1, answer)); 1342 1343 Arrays.sort(specials2); 1344 Object[] print2 = new Object[specials2.length]; 1345 for (int i = 0; i < specials2.length; i++) 1346 print2[i] = new Double(specials2[i]); 1347 assertTrue("specials sort incorrectly 2: " + Arrays.asList(print2), 1348 Arrays.equals(specials2, answer)); 1349 } 1350 1351 /** 1352 * @tests java.util.Arrays#sort(double[], int, int) 1353 */ 1354 @TestTargetNew( 1355 level = TestLevel.COMPLETE, 1356 notes = "", 1357 method = "sort", 1358 args = {double[].class, int.class, int.class} 1359 ) 1360 public void test_sort$DII() { 1361 // Test for method void java.util.Arrays.sort(double [], int, int) 1362 int startIndex = arraySize / 4; 1363 int endIndex = 3 * arraySize / 4; 1364 double[] reversedArray = new double[arraySize]; 1365 double[] originalReversedArray = new double[arraySize]; 1366 for (int counter = 0; counter < arraySize; counter++) { 1367 reversedArray[counter] = (double) (arraySize - counter - 1); 1368 originalReversedArray[counter] = reversedArray[counter]; 1369 } 1370 Arrays.sort(reversedArray, startIndex, endIndex); 1371 for (int counter = 0; counter < startIndex; counter++) 1372 assertTrue("Array modified outside of bounds", 1373 reversedArray[counter] == originalReversedArray[counter]); 1374 for (int counter = startIndex; counter < endIndex - 1; counter++) 1375 assertTrue("Array not sorted within bounds", 1376 reversedArray[counter] <= reversedArray[counter + 1]); 1377 for (int counter = endIndex; counter < arraySize; counter++) 1378 assertTrue("Array modified outside of bounds", 1379 reversedArray[counter] == originalReversedArray[counter]); 1380 1381 //exception testing 1382 try { 1383 Arrays.sort(reversedArray, startIndex + 1, startIndex); 1384 fail("IllegalArgumentException expected"); 1385 } catch (IllegalArgumentException ignore) { 1386 } 1387 1388 try { 1389 Arrays.sort(reversedArray, -1, startIndex); 1390 fail("ArrayIndexOutOfBoundsException expected (1)"); 1391 } catch (ArrayIndexOutOfBoundsException ignore) { 1392 } 1393 1394 try { 1395 Arrays.sort(reversedArray, startIndex, reversedArray.length + 1); 1396 fail("ArrayIndexOutOfBoundsException expected (2)"); 1397 } catch (ArrayIndexOutOfBoundsException ignore) { 1398 } 1399 1400 //exception order testing 1401 try { 1402 Arrays.sort(new double[1], startIndex + 1, startIndex); 1403 fail("IllegalArgumentException expected"); 1404 } catch (IllegalArgumentException ignore) { 1405 } 1406 } 1407 1408 /** 1409 * @tests java.util.Arrays#sort(float[]) 1410 */ 1411 @TestTargetNew( 1412 level = TestLevel.COMPLETE, 1413 notes = "", 1414 method = "sort", 1415 args = {float[].class} 1416 ) 1417 public void test_sort$F() { 1418 // Test for method void java.util.Arrays.sort(float []) 1419 float[] reversedArray = new float[arraySize]; 1420 for (int counter = 0; counter < arraySize; counter++) 1421 reversedArray[counter] = (float) (arraySize - counter - 1); 1422 Arrays.sort(reversedArray); 1423 for (int counter = 0; counter < arraySize; counter++) 1424 assertTrue("Resulting array not sorted", 1425 reversedArray[counter] == (float) counter); 1426 1427 float[] specials1 = new float[] { Float.NaN, Float.MAX_VALUE, 1428 Float.MIN_VALUE, 0f, -0f, Float.POSITIVE_INFINITY, 1429 Float.NEGATIVE_INFINITY }; 1430 float[] specials2 = new float[] { 0f, Float.POSITIVE_INFINITY, -0f, 1431 Float.NEGATIVE_INFINITY, Float.MIN_VALUE, Float.NaN, 1432 Float.MAX_VALUE }; 1433 float[] answer = new float[] { Float.NEGATIVE_INFINITY, -0f, 0f, 1434 Float.MIN_VALUE, Float.MAX_VALUE, Float.POSITIVE_INFINITY, 1435 Float.NaN }; 1436 1437 Arrays.sort(specials1); 1438 Object[] print1 = new Object[specials1.length]; 1439 for (int i = 0; i < specials1.length; i++) 1440 print1[i] = new Float(specials1[i]); 1441 assertTrue("specials sort incorrectly 1: " + Arrays.asList(print1), 1442 Arrays.equals(specials1, answer)); 1443 1444 Arrays.sort(specials2); 1445 Object[] print2 = new Object[specials2.length]; 1446 for (int i = 0; i < specials2.length; i++) 1447 print2[i] = new Float(specials2[i]); 1448 assertTrue("specials sort incorrectly 2: " + Arrays.asList(print2), 1449 Arrays.equals(specials2, answer)); 1450 } 1451 1452 /** 1453 * @tests java.util.Arrays#sort(float[], int, int) 1454 */ 1455 @TestTargetNew( 1456 level = TestLevel.COMPLETE, 1457 notes = "", 1458 method = "sort", 1459 args = {float[].class, int.class, int.class} 1460 ) 1461 public void test_sort$FII() { 1462 // Test for method void java.util.Arrays.sort(float [], int, int) 1463 int startIndex = arraySize / 4; 1464 int endIndex = 3 * arraySize / 4; 1465 float[] reversedArray = new float[arraySize]; 1466 float[] originalReversedArray = new float[arraySize]; 1467 for (int counter = 0; counter < arraySize; counter++) { 1468 reversedArray[counter] = (float) (arraySize - counter - 1); 1469 originalReversedArray[counter] = reversedArray[counter]; 1470 } 1471 Arrays.sort(reversedArray, startIndex, endIndex); 1472 for (int counter = 0; counter < startIndex; counter++) 1473 assertTrue("Array modified outside of bounds", 1474 reversedArray[counter] == originalReversedArray[counter]); 1475 for (int counter = startIndex; counter < endIndex - 1; counter++) 1476 assertTrue("Array not sorted within bounds", 1477 reversedArray[counter] <= reversedArray[counter + 1]); 1478 for (int counter = endIndex; counter < arraySize; counter++) 1479 assertTrue("Array modified outside of bounds", 1480 reversedArray[counter] == originalReversedArray[counter]); 1481 1482 //exception testing 1483 try { 1484 Arrays.sort(reversedArray, startIndex + 1, startIndex); 1485 fail("IllegalArgumentException expected"); 1486 } catch (IllegalArgumentException ignore) { 1487 } 1488 1489 try { 1490 Arrays.sort(reversedArray, -1, startIndex); 1491 fail("ArrayIndexOutOfBoundsException expected (1)"); 1492 } catch (ArrayIndexOutOfBoundsException ignore) { 1493 } 1494 1495 try { 1496 Arrays.sort(reversedArray, startIndex, reversedArray.length + 1); 1497 fail("ArrayIndexOutOfBoundsException expected (2)"); 1498 } catch (ArrayIndexOutOfBoundsException ignore) { 1499 } 1500 1501 //exception order testing 1502 try { 1503 Arrays.sort(new float[1], startIndex + 1, startIndex); 1504 fail("IllegalArgumentException expected"); 1505 } catch (IllegalArgumentException ignore) { 1506 } 1507 } 1508 1509 /** 1510 * @tests java.util.Arrays#sort(int[]) 1511 */ 1512 @TestTargetNew( 1513 level = TestLevel.COMPLETE, 1514 notes = "", 1515 method = "sort", 1516 args = {int[].class} 1517 ) 1518 public void test_sort$I() { 1519 // Test for method void java.util.Arrays.sort(int []) 1520 int[] reversedArray = new int[arraySize]; 1521 for (int counter = 0; counter < arraySize; counter++) 1522 reversedArray[counter] = arraySize - counter - 1; 1523 Arrays.sort(reversedArray); 1524 for (int counter = 0; counter < arraySize; counter++) 1525 assertTrue("Resulting array not sorted", 1526 reversedArray[counter] == counter); 1527 } 1528 1529 /** 1530 * @tests java.util.Arrays#sort(int[], int, int) 1531 */ 1532 @TestTargetNew( 1533 level = TestLevel.COMPLETE, 1534 notes = "", 1535 method = "sort", 1536 args = {int[].class, int.class, int.class} 1537 ) 1538 public void test_sort$III() { 1539 // Test for method void java.util.Arrays.sort(int [], int, int) 1540 int startIndex = arraySize / 4; 1541 int endIndex = 3 * arraySize / 4; 1542 int[] reversedArray = new int[arraySize]; 1543 int[] originalReversedArray = new int[arraySize]; 1544 for (int counter = 0; counter < arraySize; counter++) { 1545 reversedArray[counter] = arraySize - counter - 1; 1546 originalReversedArray[counter] = reversedArray[counter]; 1547 } 1548 Arrays.sort(reversedArray, startIndex, endIndex); 1549 for (int counter = 0; counter < startIndex; counter++) 1550 assertTrue("Array modified outside of bounds", 1551 reversedArray[counter] == originalReversedArray[counter]); 1552 for (int counter = startIndex; counter < endIndex - 1; counter++) 1553 assertTrue("Array not sorted within bounds", 1554 reversedArray[counter] <= reversedArray[counter + 1]); 1555 for (int counter = endIndex; counter < arraySize; counter++) 1556 assertTrue("Array modified outside of bounds", 1557 reversedArray[counter] == originalReversedArray[counter]); 1558 1559 //exception testing 1560 try { 1561 Arrays.sort(reversedArray, startIndex + 1, startIndex); 1562 fail("IllegalArgumentException expected"); 1563 } catch (IllegalArgumentException ignore) { 1564 } 1565 1566 try { 1567 Arrays.sort(reversedArray, -1, startIndex); 1568 fail("ArrayIndexOutOfBoundsException expected (1)"); 1569 } catch (ArrayIndexOutOfBoundsException ignore) { 1570 } 1571 1572 try { 1573 Arrays.sort(reversedArray, startIndex, reversedArray.length + 1); 1574 fail("ArrayIndexOutOfBoundsException expected (2)"); 1575 } catch (ArrayIndexOutOfBoundsException ignore) { 1576 } 1577 1578 //exception order testing 1579 try { 1580 Arrays.sort(new int[1], startIndex + 1, startIndex); 1581 fail("IllegalArgumentException expected"); 1582 } catch (IllegalArgumentException ignore) { 1583 } 1584 } 1585 1586 /** 1587 * @tests java.util.Arrays#sort(long[]) 1588 */ 1589 @TestTargetNew( 1590 level = TestLevel.COMPLETE, 1591 notes = "", 1592 method = "sort", 1593 args = {long[].class} 1594 ) 1595 public void test_sort$J() { 1596 // Test for method void java.util.Arrays.sort(long []) 1597 long[] reversedArray = new long[arraySize]; 1598 for (int counter = 0; counter < arraySize; counter++) 1599 reversedArray[counter] = (long) (arraySize - counter - 1); 1600 Arrays.sort(reversedArray); 1601 for (int counter = 0; counter < arraySize; counter++) 1602 assertTrue("Resulting array not sorted", 1603 reversedArray[counter] == (long) counter); 1604 1605 } 1606 1607 /** 1608 * @tests java.util.Arrays#sort(long[], int, int) 1609 */ 1610 @TestTargetNew( 1611 level = TestLevel.COMPLETE, 1612 notes = "", 1613 method = "sort", 1614 args = {long[].class, int.class, int.class} 1615 ) 1616 public void test_sort$JII() { 1617 // Test for method void java.util.Arrays.sort(long [], int, int) 1618 int startIndex = arraySize / 4; 1619 int endIndex = 3 * arraySize / 4; 1620 long[] reversedArray = new long[arraySize]; 1621 long[] originalReversedArray = new long[arraySize]; 1622 for (int counter = 0; counter < arraySize; counter++) { 1623 reversedArray[counter] = (long) (arraySize - counter - 1); 1624 originalReversedArray[counter] = reversedArray[counter]; 1625 } 1626 Arrays.sort(reversedArray, startIndex, endIndex); 1627 for (int counter = 0; counter < startIndex; counter++) 1628 assertTrue("Array modified outside of bounds", 1629 reversedArray[counter] == originalReversedArray[counter]); 1630 for (int counter = startIndex; counter < endIndex - 1; counter++) 1631 assertTrue("Array not sorted within bounds", 1632 reversedArray[counter] <= reversedArray[counter + 1]); 1633 for (int counter = endIndex; counter < arraySize; counter++) 1634 assertTrue("Array modified outside of bounds", 1635 reversedArray[counter] == originalReversedArray[counter]); 1636 1637 //exception testing 1638 try { 1639 Arrays.sort(reversedArray, startIndex + 1, startIndex); 1640 fail("IllegalArgumentException expected"); 1641 } catch (IllegalArgumentException ignore) { 1642 } 1643 1644 try { 1645 Arrays.sort(reversedArray, -1, startIndex); 1646 fail("ArrayIndexOutOfBoundsException expected (1)"); 1647 } catch (ArrayIndexOutOfBoundsException ignore) { 1648 } 1649 1650 try { 1651 Arrays.sort(reversedArray, startIndex, reversedArray.length + 1); 1652 fail("ArrayIndexOutOfBoundsException expected (2)"); 1653 } catch (ArrayIndexOutOfBoundsException ignore) { 1654 } 1655 1656 //exception order testing 1657 try { 1658 Arrays.sort(new long[1], startIndex + 1, startIndex); 1659 fail("IllegalArgumentException expected"); 1660 } catch (IllegalArgumentException ignore) { 1661 } 1662 } 1663 1664 /** 1665 * @tests java.util.Arrays#sort(java.lang.Object[]) 1666 */ 1667 @TestTargetNew( 1668 level = TestLevel.COMPLETE, 1669 notes = "", 1670 method = "sort", 1671 args = {java.lang.Object[].class} 1672 ) 1673 public void test_sort$Ljava_lang_Object() { 1674 // Test for method void java.util.Arrays.sort(java.lang.Object []) 1675 Object[] reversedArray = new Object[arraySize]; 1676 for (int counter = 0; counter < arraySize; counter++) 1677 reversedArray[counter] = objectArray[arraySize - counter - 1]; 1678 Arrays.sort(reversedArray); 1679 for (int counter = 0; counter < arraySize; counter++) 1680 assertTrue("Resulting array not sorted", 1681 reversedArray[counter] == objectArray[counter]); 1682 1683 Arrays.fill(reversedArray, 0, reversedArray.length/2, "String"); 1684 Arrays.fill(reversedArray, reversedArray.length/2, reversedArray.length, new Integer(1)); 1685 1686 try { 1687 Arrays.sort(reversedArray); 1688 fail("ClassCastException expected"); 1689 } catch (ClassCastException e) { 1690 //expected 1691 } 1692 } 1693 1694 /** 1695 * @tests java.util.Arrays#sort(java.lang.Object[], int, int) 1696 */ 1697 @TestTargetNew( 1698 level = TestLevel.COMPLETE, 1699 notes = "", 1700 method = "sort", 1701 args = {java.lang.Object[].class, int.class, int.class} 1702 ) 1703 public void test_sort$Ljava_lang_ObjectII() { 1704 // Test for method void java.util.Arrays.sort(java.lang.Object [], int, 1705 // int) 1706 int startIndex = arraySize / 4; 1707 int endIndex = 3 * arraySize / 4; 1708 Object[] reversedArray = new Object[arraySize]; 1709 Object[] originalReversedArray = new Object[arraySize]; 1710 for (int counter = 0; counter < arraySize; counter++) { 1711 reversedArray[counter] = objectArray[arraySize - counter - 1]; 1712 originalReversedArray[counter] = reversedArray[counter]; 1713 } 1714 Arrays.sort(reversedArray, startIndex, endIndex); 1715 for (int counter = 0; counter < startIndex; counter++) 1716 assertTrue("Array modified outside of bounds", 1717 reversedArray[counter] == originalReversedArray[counter]); 1718 for (int counter = startIndex; counter < endIndex - 1; counter++) 1719 assertTrue("Array not sorted within bounds", 1720 ((Comparable) reversedArray[counter]) 1721 .compareTo(reversedArray[counter + 1]) <= 0); 1722 for (int counter = endIndex; counter < arraySize; counter++) 1723 assertTrue("Array modified outside of bounds", 1724 reversedArray[counter] == originalReversedArray[counter]); 1725 1726 //exception testing 1727 try { 1728 Arrays.sort(reversedArray, startIndex + 1, startIndex); 1729 fail("IllegalArgumentException expected"); 1730 } catch (IllegalArgumentException ignore) { 1731 } 1732 1733 try { 1734 Arrays.sort(reversedArray, -1, startIndex); 1735 fail("ArrayIndexOutOfBoundsException expected (1)"); 1736 } catch (ArrayIndexOutOfBoundsException ignore) { 1737 } 1738 1739 try { 1740 Arrays.sort(reversedArray, startIndex, reversedArray.length + 1); 1741 fail("ArrayIndexOutOfBoundsException expected (2)"); 1742 } catch (ArrayIndexOutOfBoundsException ignore) { 1743 } 1744 1745 //exception order testing 1746 try { 1747 Arrays.sort(new Object[1], startIndex + 1, startIndex); 1748 fail("IllegalArgumentException expected"); 1749 } catch (IllegalArgumentException ignore) { 1750 } 1751 1752 Arrays.fill(reversedArray, 0, reversedArray.length/2, "String"); 1753 Arrays.fill(reversedArray, reversedArray.length/2, reversedArray.length, new Integer(1)); 1754 1755 try { 1756 Arrays.sort(reversedArray, reversedArray.length/4, 3*reversedArray.length/4); 1757 fail("ClassCastException expected"); 1758 } catch (ClassCastException e) { 1759 //expected 1760 } 1761 1762 Arrays.sort(reversedArray, 0, reversedArray.length/4); 1763 Arrays.sort(reversedArray, 3*reversedArray.length/4, reversedArray.length); 1764 } 1765 1766 /** 1767 * @tests java.util.Arrays#sort(java.lang.Object[], int, int, 1768 * java.util.Comparator) 1769 */ 1770 @TestTargetNew( 1771 level = TestLevel.COMPLETE, 1772 notes = "", 1773 method = "sort", 1774 args = {java.lang.Object[].class, int.class, int.class, java.util.Comparator.class} 1775 ) 1776 public void test_sort$Ljava_lang_ObjectIILjava_util_Comparator() { 1777 // Test for method void java.util.Arrays.sort(java.lang.Object [], int, 1778 // int, java.util.Comparator) 1779 int startIndex = arraySize / 4; 1780 int endIndex = 3 * arraySize / 4; 1781 ReversedIntegerComparator comp = new ReversedIntegerComparator(); 1782 Object[] originalArray = new Object[arraySize]; 1783 for (int counter = 0; counter < arraySize; counter++) 1784 originalArray[counter] = objectArray[counter]; 1785 Arrays.sort(objectArray, startIndex, endIndex, comp); 1786 for (int counter = 0; counter < startIndex; counter++) 1787 assertTrue("Array modified outside of bounds", 1788 objectArray[counter] == originalArray[counter]); 1789 for (int counter = startIndex; counter < endIndex - 1; counter++) 1790 assertTrue("Array not sorted within bounds", comp.compare( 1791 objectArray[counter], objectArray[counter + 1]) <= 0); 1792 for (int counter = endIndex; counter < arraySize; counter++) 1793 assertTrue("Array modified outside of bounds", 1794 objectArray[counter] == originalArray[counter]); 1795 1796 Arrays.fill(originalArray, 0, originalArray.length/2, "String"); 1797 Arrays.fill(originalArray, originalArray.length/2, originalArray.length, new Integer(1)); 1798 1799 try { 1800 Arrays.sort(originalArray, startIndex, endIndex, comp); 1801 fail("ClassCastException expected"); 1802 } catch (ClassCastException e) { 1803 //expected 1804 } 1805 1806 Arrays.sort(originalArray, endIndex, originalArray.length, comp); 1807 1808 try { 1809 Arrays.sort(originalArray, endIndex, originalArray.length + 1, comp); 1810 fail("ArrayIndexOutOfBoundsException expected"); 1811 } catch(ArrayIndexOutOfBoundsException e) { 1812 //expected 1813 } 1814 1815 try { 1816 Arrays.sort(originalArray, -1, startIndex, comp); 1817 fail("ArrayIndexOutOfBoundsException expected"); 1818 } catch(ArrayIndexOutOfBoundsException e) { 1819 //expected 1820 } 1821 1822 try { 1823 Arrays.sort(originalArray, originalArray.length, endIndex, comp); 1824 fail("IllegalArgumentException expected"); 1825 } catch(IllegalArgumentException e) { 1826 //expected 1827 } 1828 } 1829 1830 /** 1831 * @tests java.util.Arrays#sort(java.lang.Object[], java.util.Comparator) 1832 */ 1833 @TestTargetNew( 1834 level = TestLevel.COMPLETE, 1835 notes = "", 1836 method = "sort", 1837 args = {java.lang.Object[].class, java.util.Comparator.class} 1838 ) 1839 public void test_sort$Ljava_lang_ObjectLjava_util_Comparator() { 1840 // Test for method void java.util.Arrays.sort(java.lang.Object [], 1841 // java.util.Comparator) 1842 ReversedIntegerComparator comp = new ReversedIntegerComparator(); 1843 Arrays.sort(objectArray, comp); 1844 for (int counter = 0; counter < arraySize - 1; counter++) 1845 assertTrue("Array not sorted correctly with custom comparator", 1846 comp 1847 .compare(objectArray[counter], 1848 objectArray[counter + 1]) <= 0); 1849 1850 Arrays.fill(objectArray, 0, objectArray.length/2, "String"); 1851 Arrays.fill(objectArray, objectArray.length/2, objectArray.length, new Integer(1)); 1852 1853 try { 1854 Arrays.sort(objectArray, comp); 1855 fail("ClassCastException expected"); 1856 } catch (ClassCastException e) { 1857 //expected 1858 } 1859 } 1860 1861 /** 1862 * @tests java.util.Arrays#sort(short[]) 1863 */ 1864 @TestTargetNew( 1865 level = TestLevel.COMPLETE, 1866 notes = "", 1867 method = "sort", 1868 args = {short[].class} 1869 ) 1870 public void test_sort$S() { 1871 // Test for method void java.util.Arrays.sort(short []) 1872 short[] reversedArray = new short[arraySize]; 1873 for (int counter = 0; counter < arraySize; counter++) 1874 reversedArray[counter] = (short) (arraySize - counter - 1); 1875 Arrays.sort(reversedArray); 1876 for (int counter = 0; counter < arraySize; counter++) 1877 assertTrue("Resulting array not sorted", 1878 reversedArray[counter] == (short) counter); 1879 } 1880 1881 /** 1882 * @tests java.util.Arrays#sort(short[], int, int) 1883 */ 1884 @TestTargetNew( 1885 level = TestLevel.COMPLETE, 1886 notes = "", 1887 method = "sort", 1888 args = {short[].class, int.class, int.class} 1889 ) 1890 public void test_sort$SII() { 1891 // Test for method void java.util.Arrays.sort(short [], int, int) 1892 int startIndex = arraySize / 4; 1893 int endIndex = 3 * arraySize / 4; 1894 short[] reversedArray = new short[arraySize]; 1895 short[] originalReversedArray = new short[arraySize]; 1896 for (int counter = 0; counter < arraySize; counter++) { 1897 reversedArray[counter] = (short) (arraySize - counter - 1); 1898 originalReversedArray[counter] = reversedArray[counter]; 1899 } 1900 Arrays.sort(reversedArray, startIndex, endIndex); 1901 for (int counter = 0; counter < startIndex; counter++) 1902 assertTrue("Array modified outside of bounds", 1903 reversedArray[counter] == originalReversedArray[counter]); 1904 for (int counter = startIndex; counter < endIndex - 1; counter++) 1905 assertTrue("Array not sorted within bounds", 1906 reversedArray[counter] <= reversedArray[counter + 1]); 1907 for (int counter = endIndex; counter < arraySize; counter++) 1908 assertTrue("Array modified outside of bounds", 1909 reversedArray[counter] == originalReversedArray[counter]); 1910 1911 //exception testing 1912 try { 1913 Arrays.sort(reversedArray, startIndex + 1, startIndex); 1914 fail("IllegalArgumentException expected"); 1915 } catch (IllegalArgumentException ignore) { 1916 } 1917 1918 try { 1919 Arrays.sort(reversedArray, -1, startIndex); 1920 fail("ArrayIndexOutOfBoundsException expected (1)"); 1921 } catch (ArrayIndexOutOfBoundsException ignore) { 1922 } 1923 1924 try { 1925 Arrays.sort(reversedArray, startIndex, reversedArray.length + 1); 1926 fail("ArrayIndexOutOfBoundsException expected (2)"); 1927 } catch (ArrayIndexOutOfBoundsException ignore) { 1928 } 1929 1930 //exception order testing 1931 try { 1932 Arrays.sort(new short[1], startIndex + 1, startIndex); 1933 fail("IllegalArgumentException expected"); 1934 } catch (IllegalArgumentException ignore) { 1935 } 1936 } 1937 1938 /** 1939 * @tests java.util.Arrays#sort(byte[], int, int) 1940 */ 1941 @TestTargetNew( 1942 level = TestLevel.PARTIAL_COMPLETE, 1943 notes = "Verifies NullPointerException.", 1944 method = "sort", 1945 args = {byte[].class, int.class, int.class} 1946 ) 1947 public void test_java_util_Arrays_sort_byte_array_NPE() { 1948 byte[] byte_array_null = null; 1949 try { 1950 java.util.Arrays.sort(byte_array_null); 1951 fail("Should throw java.lang.NullPointerException"); 1952 } catch (NullPointerException e) { 1953 // Expected 1954 } 1955 try { 1956 // Regression for HARMONY-378 1957 java.util.Arrays.sort(byte_array_null, (int) -1, (int) 1); 1958 fail("Should throw java.lang.NullPointerException"); 1959 } catch (NullPointerException e) { 1960 // Expected 1961 } 1962 } 1963 1964 /** 1965 * @tests java.util.Arrays#sort(char[], int, int) 1966 */ 1967 @TestTargetNew( 1968 level = TestLevel.PARTIAL_COMPLETE, 1969 notes = "Verifies NullPointerException.", 1970 method = "sort", 1971 args = {char[].class, int.class, int.class} 1972 ) 1973 public void test_java_util_Arrays_sort_char_array_NPE() { 1974 char[] char_array_null = null; 1975 try { 1976 java.util.Arrays.sort(char_array_null); 1977 fail("Should throw java.lang.NullPointerException"); 1978 } catch (NullPointerException e) { 1979 // Expected 1980 } 1981 try { 1982 // Regression for HARMONY-378 1983 java.util.Arrays.sort(char_array_null, (int) -1, (int) 1); 1984 fail("Should throw java.lang.NullPointerException"); 1985 } catch (NullPointerException e) { 1986 // Expected 1987 } 1988 } 1989 1990 /** 1991 * @tests java.util.Arrays#sort(double[], int, int) 1992 */ 1993 @TestTargetNew( 1994 level = TestLevel.PARTIAL_COMPLETE, 1995 notes = "Verifies NullPointerException.", 1996 method = "sort", 1997 args = {double[].class, int.class, int.class} 1998 ) 1999 public void test_java_util_Arrays_sort_double_array_NPE() { 2000 double[] double_array_null = null; 2001 try { 2002 java.util.Arrays.sort(double_array_null); 2003 fail("Should throw java.lang.NullPointerException"); 2004 } catch (NullPointerException e) { 2005 // Expected 2006 } 2007 try { 2008 // Regression for HARMONY-378 2009 java.util.Arrays.sort(double_array_null, (int) -1, (int) 1); 2010 fail("Should throw java.lang.NullPointerException"); 2011 } catch (NullPointerException e) { 2012 // Expected 2013 } 2014 } 2015 2016 /** 2017 * @tests java.util.Arrays#sort(float[], int, int) 2018 */ 2019 @TestTargetNew( 2020 level = TestLevel.PARTIAL_COMPLETE, 2021 notes = "Verifies NullPointerException.", 2022 method = "sort", 2023 args = {float[].class, int.class, int.class} 2024 ) 2025 public void test_java_util_Arrays_sort_float_array_NPE() { 2026 float[] float_array_null = null; 2027 try { 2028 java.util.Arrays.sort(float_array_null); 2029 fail("Should throw java.lang.NullPointerException"); 2030 } catch (NullPointerException e) { 2031 // Expected 2032 } 2033 try { 2034 // Regression for HARMONY-378 2035 java.util.Arrays.sort(float_array_null, (int) -1, (int) 1); 2036 fail("Should throw java.lang.NullPointerException"); 2037 } catch (NullPointerException e) { 2038 // Expected 2039 } 2040 } 2041 2042 /** 2043 * @tests java.util.Arrays#sort(int[], int, int) 2044 */ 2045 @TestTargetNew( 2046 level = TestLevel.PARTIAL_COMPLETE, 2047 notes = "Verifies NullPointerException.", 2048 method = "sort", 2049 args = {int[].class, int.class, int.class} 2050 ) 2051 public void test_java_util_Arrays_sort_int_array_NPE() { 2052 int[] int_array_null = null; 2053 try { 2054 java.util.Arrays.sort(int_array_null); 2055 fail("Should throw java.lang.NullPointerException"); 2056 } catch (NullPointerException e) { 2057 // Expected 2058 } 2059 try { 2060 // Regression for HARMONY-378 2061 java.util.Arrays.sort(int_array_null, (int) -1, (int) 1); 2062 fail("Should throw java.lang.NullPointerException"); 2063 } catch (NullPointerException e) { 2064 // Expected 2065 } 2066 } 2067 2068 /** 2069 * @tests java.util.Arrays#sort(Object[], int, int) 2070 */ 2071 @TestTargetNew( 2072 level = TestLevel.PARTIAL_COMPLETE, 2073 notes = "Verifies NullPointerException.", 2074 method = "sort", 2075 args = {java.lang.Object[].class, int.class, int.class} 2076 ) 2077 public void test_java_util_Arrays_sort_object_array_NPE() { 2078 Object[] object_array_null = null; 2079 try { 2080 java.util.Arrays.sort(object_array_null); 2081 fail("Should throw java.lang.NullPointerException"); 2082 } catch (NullPointerException e) { 2083 // Expected 2084 } 2085 try { 2086 // Regression for HARMONY-378 2087 java.util.Arrays.sort(object_array_null, (int) -1, (int) 1); 2088 fail("Should throw java.lang.NullPointerException"); 2089 } catch (NullPointerException e) { 2090 // Expected 2091 } 2092 try { 2093 // Regression for HARMONY-378 2094 java.util.Arrays.sort(object_array_null, (int) -1, (int) 1, null); 2095 fail("Should throw java.lang.NullPointerException"); 2096 } catch (NullPointerException e) { 2097 // Expected 2098 } 2099 } 2100 2101 /** 2102 * @tests java.util.Arrays#sort(long[], int, int) 2103 */ 2104 @TestTargetNew( 2105 level = TestLevel.PARTIAL_COMPLETE, 2106 notes = "Verifies NullPointerException.", 2107 method = "sort", 2108 args = {long[].class, int.class, int.class} 2109 ) 2110 public void test_java_util_Arrays_sort_long_array_NPE() { 2111 long[] long_array_null = null; 2112 try { 2113 java.util.Arrays.sort(long_array_null); 2114 fail("Should throw java.lang.NullPointerException"); 2115 } catch (NullPointerException e) { 2116 // Expected 2117 } 2118 try { 2119 // Regression for HARMONY-378 2120 java.util.Arrays.sort(long_array_null, (int) -1, (int) 1); 2121 fail("Should throw java.lang.NullPointerException"); 2122 } catch (NullPointerException e) { 2123 // Expected 2124 } 2125 } 2126 2127 /** 2128 * @tests java.util.Arrays#sort(short[], int, int) 2129 */ 2130 @TestTargetNew( 2131 level = TestLevel.PARTIAL_COMPLETE, 2132 notes = "Verifies NullPointerException.", 2133 method = "sort", 2134 args = {short[].class, int.class, int.class} 2135 ) 2136 public void test_java_util_Arrays_sort_short_array_NPE() { 2137 short[] short_array_null = null; 2138 try { 2139 java.util.Arrays.sort(short_array_null); 2140 fail("Should throw java.lang.NullPointerException"); 2141 } catch (NullPointerException e) { 2142 // Expected 2143 } 2144 try { 2145 // Regression for HARMONY-378 2146 java.util.Arrays.sort(short_array_null, (int) -1, (int) 1); 2147 fail("Should throw java.lang.NullPointerException"); 2148 } catch (NullPointerException e) { 2149 // Expected 2150 } 2151 } 2152 2153 /** 2154 * @tests java.util.Arrays#deepEquals(Object[], Object[]) 2155 */ 2156 @TestTargetNew( 2157 level = TestLevel.COMPLETE, 2158 notes = "", 2159 method = "deepEquals", 2160 args = {java.lang.Object[].class, java.lang.Object[].class} 2161 ) 2162 public void test_deepEquals$Ljava_lang_ObjectLjava_lang_Object() { 2163 int [] a1 = {1, 2, 3}; 2164 short [] a2 = {0, 1}; 2165 Object [] a3 = {new Integer(1), a2}; 2166 int [] a4 = {6, 5, 4}; 2167 2168 int [] b1 = {1, 2, 3}; 2169 short [] b2 = {0, 1}; 2170 Object [] b3 = {new Integer(1), b2}; 2171 2172 Object a [] = {a1, a2, a3}; 2173 Object b [] = {b1, b2, b3}; 2174 2175 assertFalse(Arrays.equals(a, b)); 2176 assertTrue(Arrays.deepEquals(a,b)); 2177 2178 a[2] = a4; 2179 2180 assertFalse(Arrays.deepEquals(a, b)); 2181 } 2182 2183 /** 2184 * @tests java.util.Arrays#deepHashCode(Object[]) 2185 */ 2186 @TestTargetNew( 2187 level = TestLevel.COMPLETE, 2188 notes = "", 2189 method = "deepHashCode", 2190 args = {java.lang.Object[].class} 2191 ) 2192 public void test_deepHashCode$Ljava_lang_Object() { 2193 int [] a1 = {1, 2, 3}; 2194 short [] a2 = {0, 1}; 2195 Object [] a3 = {new Integer(1), a2}; 2196 2197 int [] b1 = {1, 2, 3}; 2198 short [] b2 = {0, 1}; 2199 Object [] b3 = {new Integer(1), b2}; 2200 2201 Object a [] = {a1, a2, a3}; 2202 Object b [] = {b1, b2, b3}; 2203 2204 int deep_hash_a = Arrays.deepHashCode(a); 2205 int deep_hash_b = Arrays.deepHashCode(b); 2206 2207 assertEquals(deep_hash_a, deep_hash_b); 2208 } 2209 2210 /** 2211 * @tests java.util.Arrays#hashCode(boolean[] a) 2212 */ 2213 @TestTargetNew( 2214 level = TestLevel.COMPLETE, 2215 notes = "", 2216 method = "hashCode", 2217 args = {boolean[].class} 2218 ) 2219 public void test_hashCode$LZ() { 2220 int listHashCode; 2221 int arrayHashCode; 2222 2223 boolean [] boolArr = {true, false, false, true, false}; 2224 List listOfBoolean = new LinkedList(); 2225 for (int i = 0; i < boolArr.length; i++) { 2226 listOfBoolean.add(new Boolean(boolArr[i])); 2227 } 2228 listHashCode = listOfBoolean.hashCode(); 2229 arrayHashCode = Arrays.hashCode(boolArr); 2230 assertEquals(listHashCode, arrayHashCode); 2231 } 2232 2233 /** 2234 * @tests java.util.Arrays#hashCode(int[] a) 2235 */ 2236 @TestTargetNew( 2237 level = TestLevel.COMPLETE, 2238 notes = "", 2239 method = "hashCode", 2240 args = {int[].class} 2241 ) 2242 public void test_hashCode$LI() { 2243 int listHashCode; 2244 int arrayHashCode; 2245 2246 int [] intArr = {10, 5, 134, 7, 19}; 2247 List listOfInteger = new LinkedList(); 2248 2249 for (int i = 0; i < intArr.length; i++) { 2250 listOfInteger.add(new Integer(intArr[i])); 2251 } 2252 listHashCode = listOfInteger.hashCode(); 2253 arrayHashCode = Arrays.hashCode(intArr); 2254 assertEquals(listHashCode, arrayHashCode); 2255 2256 int [] intArr2 = {10, 5, 134, 7, 19}; 2257 assertEquals(Arrays.hashCode(intArr2), Arrays.hashCode(intArr)); 2258 } 2259 2260 /** 2261 * @tests java.util.Arrays#hashCode(char[] a) 2262 */ 2263 @TestTargetNew( 2264 level = TestLevel.COMPLETE, 2265 notes = "", 2266 method = "hashCode", 2267 args = {char[].class} 2268 ) 2269 public void test_hashCode$LC() { 2270 int listHashCode; 2271 int arrayHashCode; 2272 2273 char [] charArr = {'a', 'g', 'x', 'c', 'm'}; 2274 List listOfCharacter = new LinkedList(); 2275 for (int i = 0; i < charArr.length; i++) { 2276 listOfCharacter.add(new Character(charArr[i])); 2277 } 2278 listHashCode = listOfCharacter.hashCode(); 2279 arrayHashCode = Arrays.hashCode(charArr); 2280 assertEquals(listHashCode, arrayHashCode); 2281 } 2282 2283 /** 2284 * @tests java.util.Arrays#hashCode(byte[] a) 2285 */ 2286 @TestTargetNew( 2287 level = TestLevel.COMPLETE, 2288 notes = "", 2289 method = "hashCode", 2290 args = {byte[].class} 2291 ) 2292 public void test_hashCode$LB() { 2293 int listHashCode; 2294 int arrayHashCode; 2295 2296 byte [] byteArr = {5, 9, 7, 6, 17}; 2297 List listOfByte = new LinkedList(); 2298 for (int i = 0; i < byteArr.length; i++) { 2299 listOfByte.add(new Byte(byteArr[i])); 2300 } 2301 listHashCode = listOfByte.hashCode(); 2302 arrayHashCode = Arrays.hashCode(byteArr); 2303 assertEquals(listHashCode, arrayHashCode); 2304 } 2305 2306 /** 2307 * @tests java.util.Arrays#hashCode(long[] a) 2308 */ 2309 @TestTargetNew( 2310 level = TestLevel.COMPLETE, 2311 notes = "", 2312 method = "hashCode", 2313 args = {long[].class} 2314 ) 2315 public void test_hashCode$LJ() { 2316 int listHashCode; 2317 int arrayHashCode; 2318 2319 long [] longArr = {67890234512l, 97587236923425l, 257421912912l, 2320 6754268100l, 5}; 2321 List listOfLong = new LinkedList(); 2322 for (int i = 0; i < longArr.length; i++) { 2323 listOfLong.add(new Long(longArr[i])); 2324 } 2325 listHashCode = listOfLong.hashCode(); 2326 arrayHashCode = Arrays.hashCode(longArr); 2327 assertEquals(listHashCode, arrayHashCode); 2328 } 2329 2330 /** 2331 * @tests java.util.Arrays#hashCode(float[] a) 2332 */ 2333 @TestTargetNew( 2334 level = TestLevel.COMPLETE, 2335 notes = "", 2336 method = "hashCode", 2337 args = {float[].class} 2338 ) 2339 public void test_hashCode$LF() { 2340 int listHashCode; 2341 int arrayHashCode; 2342 2343 float [] floatArr = {0.13497f, 0.268934f, 12e-5f, -3e+2f, 10e-4f}; 2344 List listOfFloat = new LinkedList(); 2345 for (int i = 0; i < floatArr.length; i++) { 2346 listOfFloat.add(new Float(floatArr[i])); 2347 } 2348 listHashCode = listOfFloat.hashCode(); 2349 arrayHashCode = Arrays.hashCode(floatArr); 2350 assertEquals(listHashCode, arrayHashCode); 2351 2352 float [] floatArr2 = {0.13497f, 0.268934f, 12e-5f, -3e+2f, 10e-4f}; 2353 assertEquals(Arrays.hashCode(floatArr2), Arrays.hashCode(floatArr)); 2354 } 2355 2356 /** 2357 * @tests java.util.Arrays#hashCode(double[] a) 2358 */ 2359 @TestTargetNew( 2360 level = TestLevel.COMPLETE, 2361 notes = "", 2362 method = "hashCode", 2363 args = {double[].class} 2364 ) 2365 public void test_hashCode$LD() { 2366 int listHashCode; 2367 int arrayHashCode; 2368 2369 double [] doubleArr = {0.134945657, 0.0038754, 11e-150, -30e-300, 10e-4}; 2370 List listOfDouble = new LinkedList(); 2371 for (int i = 0; i < doubleArr.length; i++) { 2372 listOfDouble.add(new Double(doubleArr[i])); 2373 } 2374 listHashCode = listOfDouble.hashCode(); 2375 arrayHashCode = Arrays.hashCode(doubleArr); 2376 assertEquals(listHashCode, arrayHashCode); 2377 } 2378 2379 /** 2380 * @tests java.util.Arrays#hashCode(short[] a) 2381 */ 2382 @TestTargetNew( 2383 level = TestLevel.COMPLETE, 2384 notes = "", 2385 method = "hashCode", 2386 args = {short[].class} 2387 ) 2388 public void test_hashCode$LS() { 2389 int listHashCode; 2390 int arrayHashCode; 2391 2392 short [] shortArr = {35, 13, 45, 2, 91}; 2393 List listOfShort = new LinkedList(); 2394 for (int i = 0; i < shortArr.length; i++) { 2395 listOfShort.add(new Short(shortArr[i])); 2396 } 2397 listHashCode = listOfShort.hashCode(); 2398 arrayHashCode = Arrays.hashCode(shortArr); 2399 assertEquals(listHashCode, arrayHashCode); 2400 } 2401 2402 /** 2403 * @tests java.util.Arrays#hashCode(Object[] a) 2404 */ 2405 @TestTargetNew( 2406 level = TestLevel.COMPLETE, 2407 notes = "", 2408 method = "hashCode", 2409 args = {java.lang.Object[].class} 2410 ) 2411 public void test_hashCode$Ljava_lang_Object() { 2412 int listHashCode; 2413 int arrayHashCode; 2414 2415 Object[] objectArr = {new Integer(1), new Float(10e-12f), null}; 2416 List listOfObject= new LinkedList(); 2417 for (int i = 0; i < objectArr.length; i++) { 2418 listOfObject.add(objectArr[i]); 2419 } 2420 listHashCode = listOfObject.hashCode(); 2421 arrayHashCode = Arrays.hashCode(objectArr); 2422 assertEquals(listHashCode, arrayHashCode); 2423 } 2424 2425 /** 2426 * Sets up the fixture, for example, open a network connection. This method 2427 * is called before a test is executed. 2428 */ 2429 protected void setUp() { 2430 booleanArray = new boolean[arraySize]; 2431 byteArray = new byte[arraySize]; 2432 charArray = new char[arraySize]; 2433 doubleArray = new double[arraySize]; 2434 floatArray = new float[arraySize]; 2435 intArray = new int[arraySize]; 2436 longArray = new long[arraySize]; 2437 objectArray = new Object[arraySize]; 2438 shortArray = new short[arraySize]; 2439 2440 for (int counter = 0; counter < arraySize; counter++) { 2441 byteArray[counter] = (byte) counter; 2442 charArray[counter] = (char) (counter + 1); 2443 doubleArray[counter] = counter; 2444 floatArray[counter] = counter; 2445 intArray[counter] = counter; 2446 longArray[counter] = counter; 2447 objectArray[counter] = objArray[counter]; 2448 shortArray[counter] = (short) counter; 2449 } 2450 for (int counter = 0; counter < arraySize; counter += 2) { 2451 booleanArray[counter] = false; 2452 booleanArray[counter + 1] = true; 2453 } 2454 } 2455 2456 /** 2457 * Tears down the fixture, for example, close a network connection. This 2458 * method is called after a test is executed. 2459 */ 2460 protected void tearDown() { 2461 } 2462} 2463