ArraysTest.java revision 89c1feb0a69a7707b271086e749975b3f7acacf7
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, WITHOUT 13 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 14 * License for the specific language governing permissions and limitations under 15 * the License. 16 */ 17 18package org.apache.harmony.luni.tests.java.util; 19 20import dalvik.annotation.TestInfo; 21import dalvik.annotation.TestLevel; 22import dalvik.annotation.TestTarget; 23import dalvik.annotation.TestTargetClass; 24 25import junit.framework.TestCase; 26 27import java.io.Serializable; 28import java.util.Arrays; 29import java.util.Comparator; 30import java.util.List; 31import java.util.RandomAccess; 32 33import org.apache.harmony.testframework.serialization.SerializationTest; 34 35@TestTargetClass(Arrays.class) 36public class ArraysTest extends TestCase { 37 38 /** 39 * @tests java.util.Arrays#binarySearch(double[], double) 40 */ 41 @TestInfo( 42 level = TestLevel.COMPLETE, 43 purpose = "", 44 targets = { 45 @TestTarget( 46 methodName = "binarySearch", 47 methodArgs = {double[].class, double.class} 48 ) 49 }) 50 public void test_binarySearch$DD() { 51 double[] specials = new double[] { Double.NEGATIVE_INFINITY, 52 -Double.MAX_VALUE, -2d, -Double.MIN_VALUE, -0d, 0d, 53 Double.MIN_VALUE, 2d, Double.MAX_VALUE, 54 Double.POSITIVE_INFINITY, Double.NaN }; 55 56 for (int i = 0; i < specials.length; i++) { 57 int result = Arrays.binarySearch(specials, specials[i]); 58 assertTrue("Assert 0: " + specials[i] + " invalid: " + result, 59 result == i); 60 } 61 assertEquals("Assert 1: Invalid search index for -1d", 62 -4, Arrays.binarySearch(specials, -1d)); 63 assertEquals("Assert 2: Invalid search index for 1d", 64 -8, Arrays.binarySearch(specials, 1d)); 65 } 66 67 /** 68 * @tests java.util.Arrays#binarySearch(float[], float) 69 */ 70 @TestInfo( 71 level = TestLevel.COMPLETE, 72 purpose = "", 73 targets = { 74 @TestTarget( 75 methodName = "binarySearch", 76 methodArgs = {float[].class, float.class} 77 ) 78 }) 79 public void test_binarySearch$FF() { 80 float[] specials = new float[] { Float.NEGATIVE_INFINITY, 81 -Float.MAX_VALUE, -2f, -Float.MIN_VALUE, -0f, 0f, 82 Float.MIN_VALUE, 2f, Float.MAX_VALUE, Float.POSITIVE_INFINITY, 83 Float.NaN }; 84 85 for (int i = 0; i < specials.length; i++) { 86 int result = Arrays.binarySearch(specials, specials[i]); 87 assertTrue("Assert 0: " + specials[i] + " invalid: " + result, 88 result == i); 89 } 90 assertEquals("Assert 1: Invalid search index for -1f", 91 -4, Arrays.binarySearch(specials, -1f)); 92 assertEquals("Assert 2: Invalid search index for 1f", 93 -8, Arrays.binarySearch(specials, 1f)); 94 } 95 96 /** 97 * @tests java.util.Arrays#equals(double[], double[]) 98 */ 99 @TestInfo( 100 level = TestLevel.COMPLETE, 101 purpose = "", 102 targets = { 103 @TestTarget( 104 methodName = "equals", 105 methodArgs = {double[].class, double[].class} 106 ) 107 }) 108 public void test_equals$D$D() { 109 double d[] = new double[100]; 110 double x[] = new double[100]; 111 Arrays.fill(d, Double.MAX_VALUE); 112 Arrays.fill(x, Double.MIN_VALUE); 113 114 assertTrue("Assert 0: Inequal arrays returned true", !Arrays.equals(d, x)); 115 116 Arrays.fill(x, Double.MAX_VALUE); 117 assertTrue("Assert 1: equal arrays returned false", Arrays.equals(d, x)); 118 119 assertTrue("Assert 2: should be false", 120 !Arrays.equals(new double[] { 1.0 }, new double[] { 2.0 })); 121 122 assertTrue("Assert 3: NaN not equals", 123 Arrays.equals(new double[] { Double.NaN }, new double[] { Double.NaN })); 124 assertTrue("Assert 4: 0d equals -0d", 125 !Arrays.equals(new double[] { 0d }, new double[] { -0d })); 126 } 127 128 /** 129 * @tests java.util.Arrays#equals(float[], float[]) 130 */ 131 @TestInfo( 132 level = TestLevel.COMPLETE, 133 purpose = "", 134 targets = { 135 @TestTarget( 136 methodName = "equals", 137 methodArgs = {float[].class, float[].class} 138 ) 139 }) 140 public void test_equals$F$F() { 141 float d[] = new float[100]; 142 float x[] = new float[100]; 143 Arrays.fill(d, Float.MAX_VALUE); 144 Arrays.fill(x, Float.MIN_VALUE); 145 146 assertTrue("Assert 0: Inequal arrays returned true", !Arrays.equals(d, x)); 147 148 Arrays.fill(x, Float.MAX_VALUE); 149 assertTrue("Assert 1: equal arrays returned false", Arrays.equals(d, x)); 150 151 assertTrue("Assert 2: NaN not equals", 152 Arrays.equals(new float[] { Float.NaN }, new float[] { Float.NaN })); 153 assertTrue("Assert 3: 0f equals -0f", 154 !Arrays.equals(new float[] { 0f }, new float[] { -0f })); 155 } 156 157 /** 158 * @tests java.util.Arrays#sort(double[]) 159 */ 160 @TestInfo( 161 level = TestLevel.COMPLETE, 162 purpose = "", 163 targets = { 164 @TestTarget( 165 methodName = "sort", 166 methodArgs = {double[].class} 167 ) 168 }) 169 public void test_sort$D() { 170 // Test a basic sort 171 double[] reversedArray = new double[100]; 172 for (int counter = 0; counter < reversedArray.length; counter ++) { 173 reversedArray[counter] = (reversedArray.length - counter - 1); 174 } 175 Arrays.sort(reversedArray); 176 for (int counter = 0; counter < reversedArray.length; counter ++) { 177 assertTrue("Assert 0: Resulting array not sorted", 178 reversedArray[counter] == counter); 179 } 180 181 // These have to sort as per the Double compare ordering 182 double[] specials1 = new double[]{Double.NaN, Double.MAX_VALUE, Double.MIN_VALUE, 0d, -0d, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY}; 183 double[] specials2 = new double[]{0d, Double.POSITIVE_INFINITY, -0d, Double.NEGATIVE_INFINITY, Double.MIN_VALUE, Double.NaN, Double.MAX_VALUE}; 184 double[] answer = new double[]{Double.NEGATIVE_INFINITY, -0d, 0d, Double.MIN_VALUE, Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NaN}; 185 186 Arrays.sort(specials1); 187 Object[] print1 = new Object[specials1.length]; 188 for (int i = 0; i < specials1.length; i++) { 189 print1[i] = new Double(specials1[i]); 190 } 191 assertTrue("Assert 1: specials sort incorrectly" + Arrays.asList(print1), 192 Arrays.equals(specials1, answer)); 193 194 Arrays.sort(specials2); 195 Object[] print2 = new Object[specials2.length]; 196 for (int i = 0; i < specials2.length; i++) { 197 print2[i] = new Double(specials2[i]); 198 } 199 assertTrue("Assert 2: specials sort incorrectly " + Arrays.asList(print2), 200 Arrays.equals(specials2, answer)); 201 } 202 203 /** 204 * @tests java.util.Arrays#sort(float[]) 205 */ 206 @TestInfo( 207 level = TestLevel.COMPLETE, 208 purpose = "", 209 targets = { 210 @TestTarget( 211 methodName = "sort", 212 methodArgs = {float[].class} 213 ) 214 }) 215 public void test_sort$F() { 216 // Test a basic sort 217 float[] reversedArray = new float[100]; 218 for (int counter = 0; counter < reversedArray.length; counter ++) { 219 reversedArray[counter] = (reversedArray.length - counter - 1); 220 } 221 Arrays.sort(reversedArray); 222 for (int counter = 0; counter < reversedArray.length; counter ++) { 223 assertTrue("Assert 0: Resulting array not sorted", 224 reversedArray[counter] == counter); 225 } 226 227 float[] specials1 = new float[]{Float.NaN, Float.MAX_VALUE, Float.MIN_VALUE, 0f, -0f, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY}; 228 float[] specials2 = new float[]{0f, Float.POSITIVE_INFINITY, -0f, Float.NEGATIVE_INFINITY, Float.MIN_VALUE, Float.NaN, Float.MAX_VALUE}; 229 float[] answer = new float[]{Float.NEGATIVE_INFINITY, -0f, 0f, Float.MIN_VALUE, Float.MAX_VALUE, Float.POSITIVE_INFINITY, Float.NaN}; 230 231 Arrays.sort(specials1); 232 Object[] print1 = new Object[specials1.length]; 233 for (int i = 0; i < specials1.length; i++) { 234 print1[i] = new Float(specials1[i]); 235 } 236 assertTrue("Assert 1: specials sort incorrectly" + Arrays.asList(print1), 237 Arrays.equals(specials1, answer)); 238 239 Arrays.sort(specials2); 240 Object[] print2 = new Object[specials2.length]; 241 for (int i = 0; i < specials2.length; i++) { 242 print2[i] = new Float(specials2[i]); 243 } 244 assertTrue("Assert 2: specials sort incorrectly" + Arrays.asList(print2), 245 Arrays.equals(specials2, answer)); 246 } 247 248 /** 249 * @tests java.util.Arrays#toString(boolean[]) 250 */ 251 @TestInfo( 252 level = TestLevel.COMPLETE, 253 purpose = "", 254 targets = { 255 @TestTarget( 256 methodName = "toString", 257 methodArgs = {boolean[].class} 258 ) 259 }) 260 public void test_toString$Z() { 261 assertEquals("null", Arrays.toString((boolean[])null)); 262 assertEquals("[]", Arrays.toString(new boolean[] {})); 263 assertEquals("[true]", Arrays.toString(new boolean[] {true})); 264 assertEquals("[true, false]", Arrays.toString(new boolean[] {true,false})); 265 assertEquals("[true, false, true]", Arrays.toString(new boolean[] {true,false,true})); 266 } 267 268 /** 269 * @tests java.util.Arrays#toString(byte[]) 270 */ 271 @TestInfo( 272 level = TestLevel.COMPLETE, 273 purpose = "", 274 targets = { 275 @TestTarget( 276 methodName = "toString", 277 methodArgs = {byte[].class} 278 ) 279 }) 280 public void test_toString$B() { 281 assertEquals("null", Arrays.toString((byte[])null)); 282 assertEquals("[]", Arrays.toString(new byte[] {})); 283 assertEquals("[0]", Arrays.toString(new byte[] {0})); 284 assertEquals("[-1, 0]", Arrays.toString(new byte[] {-1,0})); 285 assertEquals("[-1, 0, 1]", Arrays.toString(new byte[] {-1,0,1})); 286 } 287 288 /** 289 * @tests java.util.Arrays#toString(char[]) 290 */ 291 @TestInfo( 292 level = TestLevel.COMPLETE, 293 purpose = "", 294 targets = { 295 @TestTarget( 296 methodName = "toString", 297 methodArgs = {char[].class} 298 ) 299 }) 300 public void test_toString$C() { 301 assertEquals("null", Arrays.toString((char[])null)); 302 assertEquals("[]", Arrays.toString(new char[] {})); 303 assertEquals("[a]", Arrays.toString(new char[] {'a'})); 304 assertEquals("[a, b]", Arrays.toString(new char[] {'a','b'})); 305 assertEquals("[a, b, c]", Arrays.toString(new char[] {'a','b','c'})); 306 } 307 308 /** 309 * @tests java.util.Arrays#toString(double[]) 310 */ 311 @TestInfo( 312 level = TestLevel.COMPLETE, 313 purpose = "", 314 targets = { 315 @TestTarget( 316 methodName = "toString", 317 methodArgs = {double[].class} 318 ) 319 }) 320 public void test_toString$D() { 321 assertEquals("null", Arrays.toString((double[])null)); 322 assertEquals("[]", Arrays.toString(new double[] {})); 323 assertEquals("[0.0]", Arrays.toString(new double[] {0.0D})); 324 assertEquals("[-1.0, 0.0]", Arrays.toString(new double[] {-1.0D, 0.0D})); 325 assertEquals("[-1.0, 0.0, 1.0]", Arrays.toString(new double[] {-1.0D, 0.0D, 1.0D})); 326 } 327 328 /** 329 * @tests java.util.Arrays#toString(float[]) 330 */ 331 @TestInfo( 332 level = TestLevel.COMPLETE, 333 purpose = "", 334 targets = { 335 @TestTarget( 336 methodName = "toString", 337 methodArgs = {float[].class} 338 ) 339 }) 340 public void test_toString$F() { 341 assertEquals("null", Arrays.toString((float[])null)); 342 assertEquals("[]", Arrays.toString(new float[] {})); 343 assertEquals("[0.0]", Arrays.toString(new float[] {0.0F})); 344 assertEquals("[-1.0, 0.0]", Arrays.toString(new float[] {-1.0F, 0.0F})); 345 assertEquals("[-1.0, 0.0, 1.0]", Arrays.toString(new float[] {-1.0F, 0.0F, 1.0F})); 346 } 347 348 /** 349 * @tests java.util.Arrays#toString(int[]) 350 */ 351 @TestInfo( 352 level = TestLevel.COMPLETE, 353 purpose = "", 354 targets = { 355 @TestTarget( 356 methodName = "toString", 357 methodArgs = {int[].class} 358 ) 359 }) 360 public void test_toString$I() { 361 assertEquals("null", Arrays.toString((int[])null)); 362 assertEquals("[]", Arrays.toString(new int[] {})); 363 assertEquals("[0]", Arrays.toString(new int[] {0})); 364 assertEquals("[-1, 0]", Arrays.toString(new int[] {-1, 0})); 365 assertEquals("[-1, 0, 1]", Arrays.toString(new int[] {-1, 0, 1})); 366 } 367 368 /** 369 * @tests java.util.Arrays#toString(long[]) 370 */ 371 @TestInfo( 372 level = TestLevel.COMPLETE, 373 purpose = "", 374 targets = { 375 @TestTarget( 376 methodName = "toString", 377 methodArgs = {long[].class} 378 ) 379 }) 380 public void test_toString$J() { 381 assertEquals("null", Arrays.toString((long[])null)); 382 assertEquals("[]", Arrays.toString(new long[] {})); 383 assertEquals("[0]", Arrays.toString(new long[] {0})); 384 assertEquals("[-1, 0]", Arrays.toString(new long[] {-1, 0})); 385 assertEquals("[-1, 0, 1]", Arrays.toString(new long[] {-1, 0, 1})); 386 } 387 388 /** 389 * @tests java.util.Arrays#toString(short[]) 390 */ 391 @TestInfo( 392 level = TestLevel.COMPLETE, 393 purpose = "", 394 targets = { 395 @TestTarget( 396 methodName = "toString", 397 methodArgs = {short[].class} 398 ) 399 }) 400 public void test_toString$S() { 401 assertEquals("null", Arrays.toString((short[])null)); 402 assertEquals("[]", Arrays.toString(new short[] {})); 403 assertEquals("[0]", Arrays.toString(new short[] {0})); 404 assertEquals("[-1, 0]", Arrays.toString(new short[] {-1, 0})); 405 assertEquals("[-1, 0, 1]", Arrays.toString(new short[] {-1, 0, 1})); 406 } 407 408 /** 409 * @tests java.util.Arrays#toString(Object[]) 410 */ 411 @TestInfo( 412 level = TestLevel.COMPLETE, 413 purpose = "", 414 targets = { 415 @TestTarget( 416 methodName = "toString", 417 methodArgs = {java.lang.Object[].class} 418 ) 419 }) 420 public void test_toString$Ljava_lang_Object() { 421 assertEquals("null", Arrays.toString((Object[])null)); 422 assertEquals("[]", Arrays.toString(new Object[] {})); 423 assertEquals("[fixture]", Arrays.toString(new Object[] {"fixture"})); 424 assertEquals("[fixture, null]", Arrays.toString(new Object[] {"fixture", null})); 425 assertEquals("[fixture, null, fixture]", Arrays.toString(new Object[] {"fixture", null, "fixture"})); 426 } 427 428 /** 429 * @tests java.util.Arrays#deepToString(Object[]) 430 */ 431 @TestInfo( 432 level = TestLevel.COMPLETE, 433 purpose = "", 434 targets = { 435 @TestTarget( 436 methodName = "deepToString", 437 methodArgs = {java.lang.Object[].class} 438 ) 439 }) 440 public void test_deepToString$java_lang_Object() { 441 assertEquals("null", Arrays.deepToString((Object[])null)); 442 assertEquals("[]", Arrays.deepToString(new Object[] {})); 443 assertEquals("[fixture]", Arrays.deepToString(new Object[] {"fixture"})); 444 assertEquals("[fixture, null]", Arrays.deepToString(new Object[] {"fixture", null})); 445 assertEquals("[fixture, null, fixture]", Arrays.deepToString(new Object[] {"fixture", null, "fixture"})); 446 447 Object[] fixture = new Object[1]; 448 fixture[0] = fixture; 449 assertEquals("[[...]]", Arrays.deepToString(fixture)); 450 451 fixture = new Object[2]; 452 fixture[0] = "fixture"; 453 fixture[1] = fixture; 454 assertEquals("[fixture, [...]]", Arrays.deepToString(fixture)); 455 456 fixture = new Object[10]; 457 fixture[0] = new boolean[] {true, false}; 458 fixture[1] = new byte[] {0, 1}; 459 fixture[2] = new char[] {'a', 'b'}; 460 fixture[3] = new double[] {0.0D, 1.0D}; 461 fixture[4] = new float[] {0.0F, 1.0F}; 462 fixture[5] = new int[] {0, 1}; 463 fixture[6] = new long[] {0L, 1L}; 464 fixture[7] = new short[] {0, 1}; 465 fixture[8] = fixture[0]; 466 fixture[9] = new Object[9]; 467 ((Object[])fixture[9])[0] = fixture; 468 ((Object[])fixture[9])[1] = fixture[1]; 469 ((Object[])fixture[9])[2] = fixture[2]; 470 ((Object[])fixture[9])[3] = fixture[3]; 471 ((Object[])fixture[9])[4] = fixture[4]; 472 ((Object[])fixture[9])[5] = fixture[5]; 473 ((Object[])fixture[9])[6] = fixture[6]; 474 ((Object[])fixture[9])[7] = fixture[7]; 475 Object[] innerFixture = new Object[4]; 476 innerFixture[0] = "innerFixture0"; 477 innerFixture[1] = innerFixture; 478 innerFixture[2] = fixture; 479 innerFixture[3] = "innerFixture3"; 480 ((Object[])fixture[9])[8] = innerFixture; 481 482 String expected = "[[true, false], [0, 1], [a, b], [0.0, 1.0], [0.0, 1.0], [0, 1], [0, 1], [0, 1], [true, false], [[...], [0, 1], [a, b], [0.0, 1.0], [0.0, 1.0], [0, 1], [0, 1], [0, 1], [innerFixture0, [...], [...], innerFixture3]]]"; 483 484 assertEquals(expected, Arrays.deepToString(fixture)); 485 } 486 @TestInfo( 487 level = TestLevel.COMPLETE, 488 purpose = "", 489 targets = { 490 @TestTarget( 491 methodName = "asList", 492 methodArgs = {Object[].class} 493 ) 494 }) 495 public void test_asListTvararg() throws Exception { 496 List<String> stringsList = Arrays.asList("0", "1"); 497 assertEquals(2, stringsList.size()); 498 assertEquals("0", stringsList.get(0)); 499 assertEquals("1", stringsList.get(1)); 500 assertTrue(stringsList instanceof RandomAccess); 501 assertTrue(stringsList instanceof Serializable); 502 503 assertEquals(stringsList, SerializationTest 504 .copySerializable((Serializable) stringsList)); 505 506 //test from javadoc 507 List<String> stooges = Arrays.asList("Larry", "Moe", "Curly"); 508 assertEquals(3, stooges.size()); 509 assertEquals("Larry", stooges.get(0)); 510 assertEquals("Moe", stooges.get(1)); 511 assertEquals("Curly", stooges.get(2)); 512 513 stringsList = Arrays.asList((String)null); 514 assertEquals(1, stringsList.size()); 515 assertEquals((String)null, stringsList.get(0)); 516 517 try { 518 Arrays.asList((Object[])null); 519 fail("No NPE"); 520 } catch (NullPointerException e) {} 521 } 522 @TestInfo( 523 level = TestLevel.COMPLETE, 524 purpose = "", 525 targets = { 526 @TestTarget( 527 methodName = "binarySearch", 528 methodArgs = {java.lang.Object[].class, java.lang.Object.class, java.util.Comparator.class} 529 ) 530 }) 531 public void test_binarySearch$TTLjava_util_ComparatorsuperT() { 532 String[] strings = new String[] { "a", "B", "c", "D" }; 533 Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER); 534 assertEquals(0, Arrays.binarySearch(strings, "a", 535 String.CASE_INSENSITIVE_ORDER)); 536 assertEquals(0, Arrays.binarySearch(strings, "A", 537 String.CASE_INSENSITIVE_ORDER)); 538 assertEquals(1, Arrays.binarySearch(strings, "b", 539 String.CASE_INSENSITIVE_ORDER)); 540 assertEquals(1, Arrays.binarySearch(strings, "B", 541 String.CASE_INSENSITIVE_ORDER)); 542 assertEquals(2, Arrays.binarySearch(strings, "c", 543 String.CASE_INSENSITIVE_ORDER)); 544 assertEquals(2, Arrays.binarySearch(strings, "C", 545 String.CASE_INSENSITIVE_ORDER)); 546 assertEquals(3, Arrays.binarySearch(strings, "d", 547 String.CASE_INSENSITIVE_ORDER)); 548 assertEquals(3, Arrays.binarySearch(strings, "D", 549 String.CASE_INSENSITIVE_ORDER)); 550 551 552 assertTrue(Arrays.binarySearch(strings, "e", 553 String.CASE_INSENSITIVE_ORDER) < 0); 554 assertTrue(Arrays.binarySearch(strings, "" + ('A' - 1), 555 String.CASE_INSENSITIVE_ORDER) < 0); 556 557 //test with null comparator, which switches back to Comparable 558 Arrays.sort(strings, null); 559 //B, D, a, c 560 assertEquals(2, Arrays.binarySearch(strings, "a", (Comparator<String>)null)); 561 assertEquals(-1, Arrays.binarySearch(strings, "A", (Comparator<String>)null)); 562 assertEquals(-4, Arrays.binarySearch(strings, "b", (Comparator<String>)null)); 563 assertEquals(0, Arrays.binarySearch(strings, "B", (Comparator<String>)null)); 564 assertEquals(3, Arrays.binarySearch(strings, "c", (Comparator<String>)null)); 565 assertEquals(-2, Arrays.binarySearch(strings, "C", (Comparator<String>)null)); 566 assertEquals(-5, Arrays.binarySearch(strings, "d", (Comparator<String>)null)); 567 assertEquals(1, Arrays.binarySearch(strings, "D", (Comparator<String>)null)); 568 569 assertTrue(Arrays.binarySearch(strings, "e", null) < 0); 570 assertTrue(Arrays.binarySearch(strings, "" + ('A' - 1), null) < 0); 571 572 try { 573 Arrays.binarySearch((String[])null, "A", String.CASE_INSENSITIVE_ORDER); 574 fail("No NPE"); 575 } catch (NullPointerException e) {} 576 577 try { 578 Arrays.binarySearch(strings, (String)null, String.CASE_INSENSITIVE_ORDER); 579 fail("No NPE"); 580 } catch (NullPointerException e) {} 581 582 try { 583 Arrays.binarySearch(strings, (String)null, (Comparator<String>)null); 584 fail("No NPE"); 585 } catch (NullPointerException e) {} 586 587 } 588 @TestInfo( 589 level = TestLevel.PARTIAL, 590 purpose = "Doesn't verify ClassCastException.", 591 targets = { 592 @TestTarget( 593 methodName = "sort", 594 methodArgs = {Object[].class, java.util.Comparator.class} 595 ) 596 }) 597 public void test_sort$TLjava_lang_ComparatorsuperT() { 598 String[] strings = new String[] { "a", "B", "c", "D" }; 599 Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER); 600 assertEquals("a", strings[0]); 601 assertEquals("B", strings[1]); 602 assertEquals("c", strings[2]); 603 assertEquals("D", strings[3]); 604 605 //test with null comparator, which switches back to Comparable 606 Arrays.sort(strings, null); 607 //B, D, a, c 608 assertEquals("B", strings[0]); 609 assertEquals("D", strings[1]); 610 assertEquals("a", strings[2]); 611 assertEquals("c", strings[3]); 612 613 try { 614 Arrays.sort((String[])null, String.CASE_INSENSITIVE_ORDER); 615 fail("No NPE"); 616 } catch (NullPointerException e) {} 617 } 618 @TestInfo( 619 level = TestLevel.PARTIAL, 620 purpose = "Doesn't verify IllegalArgumentException, " + 621 "ArrayIndexOutOfBoundsException, ClassCastException.", 622 targets = { 623 @TestTarget( 624 methodName = "sort", 625 methodArgs = {java.lang.Object[].class, int.class, int.class} 626 ) 627 }) 628 public void test_sort$TIILjava_lang_ComparatorsuperT() { 629 String[] strings = new String[] { "a", "B", "c", "D" }; 630 Arrays.sort(strings, 0, strings.length, String.CASE_INSENSITIVE_ORDER); 631 assertEquals("a", strings[0]); 632 assertEquals("B", strings[1]); 633 assertEquals("c", strings[2]); 634 assertEquals("D", strings[3]); 635 636 //test with null comparator, which switches back to Comparable 637 Arrays.sort(strings, 0, strings.length, null); 638 //B, D, a, c 639 assertEquals("B", strings[0]); 640 assertEquals("D", strings[1]); 641 assertEquals("a", strings[2]); 642 assertEquals("c", strings[3]); 643 644 try { 645 Arrays.sort((String[])null, String.CASE_INSENSITIVE_ORDER); 646 fail("No NPE"); 647 } catch (NullPointerException e) {} 648 } 649} 650