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