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 org.apache.harmony.tests.java.util;
18
19import libcore.java.util.SpliteratorTester;
20import tests.support.Support_UnmodifiableCollectionTest;
21import java.lang.reflect.Method;
22import java.util.ArrayList;
23import java.util.Arrays;
24import java.util.Collections;
25import java.util.Comparator;
26import java.util.Date;
27import java.util.LinkedList;
28import java.util.List;
29import java.util.Random;
30import java.util.Spliterator;
31import java.util.function.Consumer;
32import java.util.function.DoubleConsumer;
33import java.util.function.IntConsumer;
34import java.util.function.LongConsumer;
35import java.util.HashMap;
36import java.util.Map;
37import java.util.concurrent.ForkJoinPool;
38
39public class ArraysTest extends junit.framework.TestCase {
40
41    public static class ReversedIntegerComparator implements Comparator {
42        public int compare(Object o1, Object o2) {
43            return -(((Integer) o1).compareTo((Integer) o2));
44        }
45
46        public boolean equals(Object o1, Object o2) {
47            return ((Integer) o1).compareTo((Integer) o2) == 0;
48        }
49    }
50
51    static class MockComparable implements Comparable {
52        public int compareTo(Object o) {
53            return 0;
54        }
55    }
56
57    final static int arraySize = 100;
58
59    Object[] objArray;
60
61    boolean[] booleanArray;
62
63    byte[] byteArray;
64
65    char[] charArray;
66
67    double[] doubleArray;
68
69    float[] floatArray;
70
71    int[] intArray;
72
73    long[] longArray;
74
75    Object[] objectArray;
76
77    short[] shortArray;
78
79    /**
80     * java.util.Arrays#asList(java.lang.Object[])
81     */
82    public void test_asList$Ljava_lang_Object() {
83        // Test for method java.util.List
84        // java.util.Arrays.asList(java.lang.Object [])
85        List convertedList = Arrays.asList(objectArray);
86        for (int counter = 0; counter < arraySize; counter++) {
87            assertTrue(
88                    "Array and List converted from array do not contain identical elements",
89                    convertedList.get(counter) == objectArray[counter]);
90        }
91        convertedList.set(50, new Integer(1000));
92        assertTrue("set/get did not work on coverted list", convertedList.get(
93                50).equals(new Integer(1000)));
94        convertedList.set(50, new Integer(50));
95        new Support_UnmodifiableCollectionTest("", convertedList).runTest();
96
97        Object[] myArray = (Object[]) (objectArray.clone());
98        myArray[30] = null;
99        myArray[60] = null;
100        convertedList = Arrays.asList(myArray);
101        for (int counter = 0; counter < arraySize; counter++) {
102            assertTrue(
103                    "Array and List converted from array do not contain identical elements",
104                    convertedList.get(counter) == myArray[counter]);
105        }
106
107        try {
108            Arrays.asList((Object[]) null);
109            fail("asList with null arg didn't throw NPE");
110        } catch (NullPointerException e) {
111            // Expected
112        }
113    }
114
115    /**
116     * java.util.Arrays#binarySearch(byte[], byte)
117     */
118    public void test_binarySearch$BB() {
119        // Test for method int java.util.Arrays.binarySearch(byte [], byte)
120        for (byte counter = 0; counter < arraySize; counter++)
121            assertTrue("Binary search on byte[] answered incorrect position",
122                    Arrays.binarySearch(byteArray, counter) == counter);
123        assertEquals("Binary search succeeded for value not present in array 1",
124                -1, Arrays.binarySearch(intArray, (byte) -1));
125        assertTrue(
126                "Binary search succeeded for value not present in array 2",
127                Arrays.binarySearch(intArray, (byte) arraySize) == -(arraySize + 1));
128        for (byte counter = 0; counter < arraySize; counter++)
129            byteArray[counter] -= 50;
130        for (byte counter = 0; counter < arraySize; counter++)
131            assertTrue(
132                    "Binary search on byte[] involving negative numbers answered incorrect position",
133                    Arrays.binarySearch(byteArray, (byte) (counter - 50)) == counter);
134    }
135
136    /**
137     * java.util.Arrays#binarySearch(char[], char)
138     */
139    public void test_binarySearch$CC() {
140        // Test for method int java.util.Arrays.binarySearch(char [], char)
141        for (char counter = 0; counter < arraySize; counter++)
142            assertTrue(
143                    "Binary search on char[] answered incorrect position",
144                    Arrays.binarySearch(charArray, (char) (counter + 1)) == counter);
145        assertEquals("Binary search succeeded for value not present in array 1",
146                -1, Arrays.binarySearch(charArray, '\u0000'));
147        assertTrue(
148                "Binary search succeeded for value not present in array 2",
149                Arrays.binarySearch(charArray, (char) (arraySize + 1)) == -(arraySize + 1));
150    }
151
152    /**
153     * java.util.Arrays#binarySearch(double[], double)
154     */
155    public void test_binarySearch$DD() {
156        // Test for method int java.util.Arrays.binarySearch(double [], double)
157        for (int counter = 0; counter < arraySize; counter++)
158            assertTrue(
159                    "Binary search on double[] answered incorrect position",
160                    Arrays.binarySearch(doubleArray, (double) counter) == (double) counter);
161        assertEquals("Binary search succeeded for value not present in array 1",
162                -1, Arrays.binarySearch(doubleArray, (double) -1));
163        assertTrue(
164                "Binary search succeeded for value not present in array 2",
165                Arrays.binarySearch(doubleArray, (double) arraySize) == -(arraySize + 1));
166        for (int counter = 0; counter < arraySize; counter++)
167            doubleArray[counter] -= (double) 50;
168        for (int counter = 0; counter < arraySize; counter++)
169            assertTrue(
170                    "Binary search on double[] involving negative numbers answered incorrect position",
171                    Arrays.binarySearch(doubleArray, (double) (counter - 50)) == (double) counter);
172
173        double[] specials = new double[] { Double.NEGATIVE_INFINITY,
174                -Double.MAX_VALUE, -2d, -Double.MIN_VALUE, -0d, 0d,
175                Double.MIN_VALUE, 2d, Double.MAX_VALUE,
176                Double.POSITIVE_INFINITY, Double.NaN };
177        for (int i = 0; i < specials.length; i++) {
178            int result = Arrays.binarySearch(specials, specials[i]);
179            assertTrue(specials[i] + " invalid: " + result, result == i);
180        }
181        assertEquals("-1d", -4, Arrays.binarySearch(specials, -1d));
182        assertEquals("1d", -8, Arrays.binarySearch(specials, 1d));
183
184    }
185
186    /**
187     * java.util.Arrays#binarySearch(float[], float)
188     */
189    public void test_binarySearch$FF() {
190        // Test for method int java.util.Arrays.binarySearch(float [], float)
191        for (int counter = 0; counter < arraySize; counter++)
192            assertTrue(
193                    "Binary search on float[] answered incorrect position",
194                    Arrays.binarySearch(floatArray, (float) counter) == (float) counter);
195        assertEquals("Binary search succeeded for value not present in array 1",
196                -1, Arrays.binarySearch(floatArray, (float) -1));
197        assertTrue(
198                "Binary search succeeded for value not present in array 2",
199                Arrays.binarySearch(floatArray, (float) arraySize) == -(arraySize + 1));
200        for (int counter = 0; counter < arraySize; counter++)
201            floatArray[counter] -= (float) 50;
202        for (int counter = 0; counter < arraySize; counter++)
203            assertTrue(
204                    "Binary search on float[] involving negative numbers answered incorrect position",
205                    Arrays.binarySearch(floatArray, (float) counter - 50) == (float) counter);
206
207        float[] specials = new float[] { Float.NEGATIVE_INFINITY,
208                -Float.MAX_VALUE, -2f, -Float.MIN_VALUE, -0f, 0f,
209                Float.MIN_VALUE, 2f, Float.MAX_VALUE, Float.POSITIVE_INFINITY,
210                Float.NaN };
211        for (int i = 0; i < specials.length; i++) {
212            int result = Arrays.binarySearch(specials, specials[i]);
213            assertTrue(specials[i] + " invalid: " + result, result == i);
214        }
215        assertEquals("-1f", -4, Arrays.binarySearch(specials, -1f));
216        assertEquals("1f", -8, Arrays.binarySearch(specials, 1f));
217    }
218
219    /**
220     * java.util.Arrays#binarySearch(int[], int)
221     */
222    public void test_binarySearch$II() {
223        // Test for method int java.util.Arrays.binarySearch(int [], int)
224        for (int counter = 0; counter < arraySize; counter++)
225            assertTrue("Binary search on int[] answered incorrect position",
226                    Arrays.binarySearch(intArray, counter) == counter);
227        assertEquals("Binary search succeeded for value not present in array 1",
228                -1, Arrays.binarySearch(intArray, -1));
229        assertTrue("Binary search succeeded for value not present in array 2",
230                Arrays.binarySearch(intArray, arraySize) == -(arraySize + 1));
231        for (int counter = 0; counter < arraySize; counter++)
232            intArray[counter] -= 50;
233        for (int counter = 0; counter < arraySize; counter++)
234            assertTrue(
235                    "Binary search on int[] involving negative numbers answered incorrect position",
236                    Arrays.binarySearch(intArray, counter - 50) == counter);
237    }
238
239    /**
240     * java.util.Arrays#binarySearch(long[], long)
241     */
242    public void test_binarySearch$JJ() {
243        // Test for method int java.util.Arrays.binarySearch(long [], long)
244        for (long counter = 0; counter < arraySize; counter++)
245            assertTrue("Binary search on long[] answered incorrect position",
246                    Arrays.binarySearch(longArray, counter) == counter);
247        assertEquals("Binary search succeeded for value not present in array 1",
248                -1, Arrays.binarySearch(longArray, (long) -1));
249        assertTrue(
250                "Binary search succeeded for value not present in array 2",
251                Arrays.binarySearch(longArray, (long) arraySize) == -(arraySize + 1));
252        for (long counter = 0; counter < arraySize; counter++)
253            longArray[(int) counter] -= (long) 50;
254        for (long counter = 0; counter < arraySize; counter++)
255            assertTrue(
256                    "Binary search on long[] involving negative numbers answered incorrect position",
257                    Arrays.binarySearch(longArray, counter - (long) 50) == counter);
258    }
259
260    /**
261     * java.util.Arrays#binarySearch(java.lang.Object[],
262     *        java.lang.Object)
263     */
264    public void test_binarySearch$Ljava_lang_ObjectLjava_lang_Object() {
265        // Test for method int java.util.Arrays.binarySearch(java.lang.Object
266        // [], java.lang.Object)
267        assertEquals(
268                "Binary search succeeded for non-comparable value in empty array",
269                -1, Arrays.binarySearch(new Object[] {}, new Object()));
270        assertEquals(
271                "Binary search succeeded for comparable value in empty array",
272                -1, Arrays.binarySearch(new Object[] {}, new Integer(-1)));
273        for (int counter = 0; counter < arraySize; counter++)
274            assertTrue(
275                    "Binary search on Object[] answered incorrect position",
276                    Arrays.binarySearch(objectArray, objArray[counter]) == counter);
277        assertEquals("Binary search succeeded for value not present in array 1",
278                -1, Arrays.binarySearch(objectArray, new Integer(-1)));
279        assertTrue(
280                "Binary search succeeded for value not present in array 2",
281                Arrays.binarySearch(objectArray, new Integer(arraySize)) == -(arraySize + 1));
282
283        Object object = new Object();
284        Object[] objects = new MockComparable[] { new MockComparable() };
285        assertEquals("Should always return 0", 0, Arrays.binarySearch(objects, object));
286
287        Object[] string_objects = new String[] { "one" };
288        try {
289            Arrays.binarySearch(string_objects, object);
290            fail("No expected ClassCastException");
291        } catch (ClassCastException e) {
292            // Expected
293        }
294    }
295
296    /**
297     * java.util.Arrays#binarySearch(java.lang.Object[],
298     *        java.lang.Object, java.util.Comparator)
299     */
300    public void test_binarySearch$Ljava_lang_ObjectLjava_lang_ObjectLjava_util_Comparator() {
301        // Test for method int java.util.Arrays.binarySearch(java.lang.Object
302        // [], java.lang.Object, java.util.Comparator)
303        Comparator comp = new ReversedIntegerComparator();
304        for (int counter = 0; counter < arraySize; counter++)
305            objectArray[counter] = objArray[arraySize - counter - 1];
306        assertTrue(
307                "Binary search succeeded for value not present in array 1",
308                Arrays.binarySearch(objectArray, new Integer(-1), comp) == -(arraySize + 1));
309        assertEquals("Binary search succeeded for value not present in array 2",
310                -1, Arrays.binarySearch(objectArray, new Integer(arraySize), comp));
311        for (int counter = 0; counter < arraySize; counter++)
312            assertTrue(
313                    "Binary search on Object[] with custom comparator answered incorrect position",
314                    Arrays.binarySearch(objectArray, objArray[counter], comp) == arraySize
315                            - counter - 1);
316    }
317
318    /**
319     * java.util.Arrays#binarySearch(short[], short)
320     */
321    public void test_binarySearch$SS() {
322        // Test for method int java.util.Arrays.binarySearch(short [], short)
323        for (short counter = 0; counter < arraySize; counter++)
324            assertTrue("Binary search on short[] answered incorrect position",
325                    Arrays.binarySearch(shortArray, counter) == counter);
326        assertEquals("Binary search succeeded for value not present in array 1",
327                -1, Arrays.binarySearch(intArray, (short) -1));
328        assertTrue(
329                "Binary search succeeded for value not present in array 2",
330                Arrays.binarySearch(intArray, (short) arraySize) == -(arraySize + 1));
331        for (short counter = 0; counter < arraySize; counter++)
332            shortArray[counter] -= 50;
333        for (short counter = 0; counter < arraySize; counter++)
334            assertTrue(
335                    "Binary search on short[] involving negative numbers answered incorrect position",
336                    Arrays.binarySearch(shortArray, (short) (counter - 50)) == counter);
337    }
338
339    public void test_Arrays_binaraySearch_byte() {
340        assertEquals(-1, Arrays.binarySearch(new byte[] { '0' }, 0, 0,
341                (byte) '1'));
342        assertEquals(-2, Arrays.binarySearch(new byte[] { '0' }, 1, 1,
343                (byte) '1'));
344        assertEquals(-2, Arrays.binarySearch(new byte[] { '0', '1' }, 1, 1,
345                (byte) '2'));
346        assertEquals(-3, Arrays.binarySearch(new byte[] { '0', '1' }, 2, 2,
347                (byte) '2'));
348    }
349
350    public void test_Arrays_binaraySearch_char() {
351        assertEquals(-1, Arrays.binarySearch(new char[] { '0' }, 0, 0, '1'));
352        assertEquals(-2, Arrays.binarySearch(new char[] { '0' }, 1, 1, '1'));
353        assertEquals(-2, Arrays
354                .binarySearch(new char[] { '0', '1' }, 1, 1, '2'));
355        assertEquals(-3, Arrays
356                .binarySearch(new char[] { '0', '1' }, 2, 2, '2'));
357    }
358
359    public void test_Arrays_binaraySearch_float() {
360        assertEquals(-1, Arrays.binarySearch(new float[] { -1.0f }, 0, 0, 0.0f));
361        assertEquals(-2, Arrays.binarySearch(new float[] { -1.0f }, 1, 1, 0.0f));
362        assertEquals(-2, Arrays.binarySearch(new float[] { -1.0f, 0f }, 1, 1,
363                1f));
364        assertEquals(-3, Arrays.binarySearch(new float[] { -1.0f, 0f }, 2, 2,
365                1f));
366    }
367
368    public void test_Arrays_binaraySearch_double() {
369        assertEquals(-1, Arrays.binarySearch(new double[] { -1.0 }, 0, 0, 0.0));
370        assertEquals(-2, Arrays.binarySearch(new double[] { -1.0 }, 1, 1, 0.0));
371        assertEquals(-2, Arrays.binarySearch(new double[] { -1.0, 0 }, 1, 1, 1));
372        assertEquals(-3, Arrays.binarySearch(new double[] { -1.0, 0 }, 2, 2, 1));
373    }
374
375    public void test_Arrays_binaraySearch_int() {
376        assertEquals(-1, Arrays.binarySearch(new int[] { -1 }, 0, 0, 0));
377        assertEquals(-2, Arrays.binarySearch(new int[] { -1 }, 1, 1, 0));
378        assertEquals(-2, Arrays.binarySearch(new int[] { -1, 0 }, 1, 1, 1));
379        assertEquals(-3, Arrays.binarySearch(new int[] { -1, 0 }, 2, 2, 1));
380    }
381
382    public void test_Arrays_binaraySearch_long() {
383        assertEquals(-1, Arrays.binarySearch(new long[] { -1l }, 0, 0, 0l));
384        assertEquals(-2, Arrays.binarySearch(new long[] { -1l }, 1, 1, 0l));
385        assertEquals(-2, Arrays.binarySearch(new long[] { -1l, 0l }, 1, 1, 1l));
386        assertEquals(-3, Arrays.binarySearch(new long[] { -1l, 0l }, 2, 2, 1l));
387    }
388
389    public void test_Arrays_binaraySearch_short() {
390        assertEquals(-1, Arrays.binarySearch(new short[] { (short) -1 }, 0, 0,
391                (short) 0));
392        assertEquals(-2, Arrays.binarySearch(new short[] { (short) -1 }, 1, 1,
393                (short) 0));
394        assertEquals(-2, Arrays.binarySearch(new short[] { (short) -1,
395                (short) 0 }, 1, 1, (short) 1));
396        assertEquals(-3, Arrays.binarySearch(new short[] { (short) -1,
397                (short) 0 }, 2, 2, (short) 1));
398    }
399
400    public void test_Arrays_binaraySearch_Object() {
401        assertEquals(-1, Arrays.binarySearch(new Object[] { new Integer(-1) },
402                0, 0, new Integer(0)));
403        assertEquals(-2, Arrays.binarySearch(new Object[] { new Integer(-1) },
404                1, 1, new Integer(0)));
405        assertEquals(-2, Arrays.binarySearch(new Object[] { new Integer(-1),
406                new Integer(0) }, 1, 1, new Integer(1)));
407        assertEquals(-3, Arrays.binarySearch(new Object[] { new Integer(-1),
408                new Integer(0) }, 2, 2, new Integer(1)));
409    }
410
411    public void test_Arrays_binaraySearch_T() {
412        ReversedIntegerComparator reversedComparator = new ReversedIntegerComparator();
413        assertEquals(-1, Arrays.binarySearch(new Integer[] { new Integer(-1) },
414                0, 0, new Integer(0), reversedComparator));
415        assertEquals(-2, Arrays.binarySearch(new Integer[] { new Integer(-1) },
416                1, 1, new Integer(0), reversedComparator));
417        assertEquals(-2, Arrays.binarySearch(new Integer[] { new Integer(-1),
418                new Integer(0) }, 1, 1, new Integer(1), reversedComparator));
419        assertEquals(-3, Arrays.binarySearch(new Integer[] { new Integer(-1),
420                new Integer(0) }, 2, 2, new Integer(1), reversedComparator));
421    }
422
423    /**
424     * java.util.Arrays#fill(byte[], byte)
425     */
426    public void test_fill$BB() {
427        // Test for method void java.util.Arrays.fill(byte [], byte)
428
429        byte d[] = new byte[1000];
430        Arrays.fill(d, Byte.MAX_VALUE);
431        for (int i = 0; i < d.length; i++)
432            assertTrue("Failed to fill byte array correctly",
433                    d[i] == Byte.MAX_VALUE);
434    }
435
436    /**
437     * java.util.Arrays#fill(byte[], int, int, byte)
438     */
439    public void test_fill$BIIB() {
440        // Test for method void java.util.Arrays.fill(byte [], int, int, byte)
441        byte val = Byte.MAX_VALUE;
442        byte d[] = new byte[1000];
443        Arrays.fill(d, 400, d.length, val);
444        for (int i = 0; i < 400; i++)
445            assertTrue("Filled elements not in range", !(d[i] == val));
446        for (int i = 400; i < d.length; i++)
447            assertTrue("Failed to fill byte array correctly", d[i] == val);
448
449        int result;
450        try {
451            Arrays.fill(new byte[2], 2, 1, (byte) 27);
452            result = 0;
453        } catch (ArrayIndexOutOfBoundsException e) {
454            result = 1;
455        } catch (IllegalArgumentException e) {
456            result = 2;
457        }
458        assertEquals("Wrong exception1", 2, result);
459        try {
460            Arrays.fill(new byte[2], -1, 1, (byte) 27);
461            result = 0;
462        } catch (ArrayIndexOutOfBoundsException e) {
463            result = 1;
464        } catch (IllegalArgumentException e) {
465            result = 2;
466        }
467        assertEquals("Wrong exception2", 1, result);
468        try {
469            Arrays.fill(new byte[2], 1, 4, (byte) 27);
470            result = 0;
471        } catch (ArrayIndexOutOfBoundsException e) {
472            result = 1;
473        } catch (IllegalArgumentException e) {
474            result = 2;
475        }
476        assertEquals("Wrong exception", 1, result);
477    }
478
479    /**
480     * java.util.Arrays#fill(short[], short)
481     */
482    public void test_fill$SS() {
483        // Test for method void java.util.Arrays.fill(short [], short)
484
485        short d[] = new short[1000];
486        Arrays.fill(d, Short.MAX_VALUE);
487        for (int i = 0; i < d.length; i++)
488            assertTrue("Failed to fill short array correctly",
489                    d[i] == Short.MAX_VALUE);
490    }
491
492    /**
493     * java.util.Arrays#fill(short[], int, int, short)
494     */
495    public void test_fill$SIIS() {
496        // Test for method void java.util.Arrays.fill(short [], int, int, short)
497        short val = Short.MAX_VALUE;
498        short d[] = new short[1000];
499        Arrays.fill(d, 400, d.length, val);
500        for (int i = 0; i < 400; i++)
501            assertTrue("Filled elements not in range", !(d[i] == val));
502        for (int i = 400; i < d.length; i++)
503            assertTrue("Failed to fill short array correctly", d[i] == val);
504
505        try {
506            Arrays.fill(d, 10, 0, val);
507            fail("IllegalArgumentException expected");
508        } catch (IllegalArgumentException e) {
509            //expected
510        }
511
512        try {
513            Arrays.fill(d, -10, 0, val);
514            fail("ArrayIndexOutOfBoundsException expected");
515        } catch (ArrayIndexOutOfBoundsException e) {
516            //expected
517        }
518
519        try {
520            Arrays.fill(d, 10, d.length+1, val);
521            fail("ArrayIndexOutOfBoundsException expected");
522        } catch (ArrayIndexOutOfBoundsException e) {
523            //expected
524        }
525    }
526
527    /**
528     * java.util.Arrays#fill(char[], char)
529     */
530    public void test_fill$CC() {
531        // Test for method void java.util.Arrays.fill(char [], char)
532
533        char d[] = new char[1000];
534        Arrays.fill(d, 'V');
535        for (int i = 0; i < d.length; i++)
536            assertEquals("Failed to fill char array correctly", 'V', d[i]);
537    }
538
539    /**
540     * java.util.Arrays#fill(char[], int, int, char)
541     */
542    public void test_fill$CIIC() {
543        // Test for method void java.util.Arrays.fill(char [], int, int, char)
544        char val = 'T';
545        char d[] = new char[1000];
546        Arrays.fill(d, 400, d.length, val);
547        for (int i = 0; i < 400; i++)
548            assertTrue("Filled elements not in range", !(d[i] == val));
549        for (int i = 400; i < d.length; i++)
550            assertTrue("Failed to fill char array correctly", d[i] == val);
551
552        try {
553            Arrays.fill(d, 10, 0, val);
554            fail("IllegalArgumentException expected");
555        } catch (IllegalArgumentException e) {
556            //expected
557        }
558
559        try {
560            Arrays.fill(d, -10, 0, val);
561            fail("ArrayIndexOutOfBoundsException expected");
562        } catch (ArrayIndexOutOfBoundsException e) {
563            //expected
564        }
565
566        try {
567            Arrays.fill(d, 10, d.length+1, val);
568            fail("ArrayIndexOutOfBoundsException expected");
569        } catch (ArrayIndexOutOfBoundsException e) {
570            //expected
571        }
572    }
573
574    /**
575     * java.util.Arrays#fill(int[], int)
576     */
577    public void test_fill$II() {
578        // Test for method void java.util.Arrays.fill(int [], int)
579
580        int d[] = new int[1000];
581        Arrays.fill(d, Integer.MAX_VALUE);
582        for (int i = 0; i < d.length; i++)
583            assertTrue("Failed to fill int array correctly",
584                    d[i] == Integer.MAX_VALUE);
585    }
586
587    /**
588     * java.util.Arrays#fill(int[], int, int, int)
589     */
590    public void test_fill$IIII() {
591        // Test for method void java.util.Arrays.fill(int [], int, int, int)
592        int val = Integer.MAX_VALUE;
593        int d[] = new int[1000];
594        Arrays.fill(d, 400, d.length, val);
595        for (int i = 0; i < 400; i++)
596            assertTrue("Filled elements not in range", !(d[i] == val));
597        for (int i = 400; i < d.length; i++)
598            assertTrue("Failed to fill int array correctly", d[i] == val);
599
600        try {
601            Arrays.fill(d, 10, 0, val);
602            fail("IllegalArgumentException expected");
603        } catch (IllegalArgumentException e) {
604            //expected
605        }
606
607        try {
608            Arrays.fill(d, -10, 0, val);
609            fail("ArrayIndexOutOfBoundsException expected");
610        } catch (ArrayIndexOutOfBoundsException e) {
611            //expected
612        }
613
614        try {
615            Arrays.fill(d, 10, d.length+1, val);
616            fail("ArrayIndexOutOfBoundsException expected");
617        } catch (ArrayIndexOutOfBoundsException e) {
618            //expected
619        }
620    }
621
622    /**
623     * java.util.Arrays#fill(long[], long)
624     */
625    public void test_fill$JJ() {
626        // Test for method void java.util.Arrays.fill(long [], long)
627
628        long d[] = new long[1000];
629        Arrays.fill(d, Long.MAX_VALUE);
630        for (int i = 0; i < d.length; i++)
631            assertTrue("Failed to fill long array correctly",
632                    d[i] == Long.MAX_VALUE);
633    }
634
635    /**
636     * java.util.Arrays#fill(long[], int, int, long)
637     */
638    public void test_fill$JIIJ() {
639        // Test for method void java.util.Arrays.fill(long [], int, int, long)
640        long d[] = new long[1000];
641        Arrays.fill(d, 400, d.length, Long.MAX_VALUE);
642        for (int i = 0; i < 400; i++)
643            assertTrue("Filled elements not in range", !(d[i] == Long.MAX_VALUE));
644        for (int i = 400; i < d.length; i++)
645            assertTrue("Failed to fill long array correctly",
646                    d[i] == Long.MAX_VALUE);
647
648        try {
649            Arrays.fill(d, 10, 0, Long.MIN_VALUE);
650            fail("IllegalArgumentException expected");
651        } catch (IllegalArgumentException e) {
652            //expected
653        }
654
655        try {
656            Arrays.fill(d, -10, 0, Long.MAX_VALUE);
657            fail("ArrayIndexOutOfBoundsException expected");
658        } catch (ArrayIndexOutOfBoundsException e) {
659            //expected
660        }
661
662        try {
663            Arrays.fill(d, 10, d.length+1, Long.MAX_VALUE);
664            fail("ArrayIndexOutOfBoundsException expected");
665        } catch (ArrayIndexOutOfBoundsException e) {
666            //expected
667        }
668    }
669
670    /**
671     * java.util.Arrays#fill(float[], float)
672     */
673    public void test_fill$FF() {
674        // Test for method void java.util.Arrays.fill(float [], float)
675        float d[] = new float[1000];
676        Arrays.fill(d, Float.MAX_VALUE);
677        for (int i = 0; i < d.length; i++)
678            assertTrue("Failed to fill float array correctly",
679                    d[i] == Float.MAX_VALUE);
680    }
681
682    /**
683     * java.util.Arrays#fill(float[], int, int, float)
684     */
685    public void test_fill$FIIF() {
686        // Test for method void java.util.Arrays.fill(float [], int, int, float)
687        float val = Float.MAX_VALUE;
688        float d[] = new float[1000];
689        Arrays.fill(d, 400, d.length, val);
690        for (int i = 0; i < 400; i++)
691            assertTrue("Filled elements not in range", !(d[i] == val));
692        for (int i = 400; i < d.length; i++)
693            assertTrue("Failed to fill float array correctly", d[i] == val);
694
695        try {
696            Arrays.fill(d, 10, 0, val);
697            fail("IllegalArgumentException expected");
698        } catch (IllegalArgumentException e) {
699            //expected
700        }
701
702        try {
703            Arrays.fill(d, -10, 0, val);
704            fail("ArrayIndexOutOfBoundsException expected");
705        } catch (ArrayIndexOutOfBoundsException e) {
706            //expected
707        }
708
709        try {
710            Arrays.fill(d, 10, d.length+1, val);
711            fail("ArrayIndexOutOfBoundsException expected");
712        } catch (ArrayIndexOutOfBoundsException e) {
713            //expected
714        }
715    }
716
717    /**
718     * java.util.Arrays#fill(double[], double)
719     */
720    public void test_fill$DD() {
721        // Test for method void java.util.Arrays.fill(double [], double)
722
723        double d[] = new double[1000];
724        Arrays.fill(d, Double.MAX_VALUE);
725        for (int i = 0; i < d.length; i++)
726            assertTrue("Failed to fill double array correctly",
727                    d[i] == Double.MAX_VALUE);
728    }
729
730    /**
731     * java.util.Arrays#fill(double[], int, int, double)
732     */
733    public void test_fill$DIID() {
734        // Test for method void java.util.Arrays.fill(double [], int, int,
735        // double)
736        double val = Double.MAX_VALUE;
737        double d[] = new double[1000];
738        Arrays.fill(d, 400, d.length, val);
739        for (int i = 0; i < 400; i++)
740            assertTrue("Filled elements not in range", !(d[i] == val));
741        for (int i = 400; i < d.length; i++)
742            assertTrue("Failed to fill double array correctly", d[i] == val);
743
744        try {
745            Arrays.fill(d, 10, 0, val);
746            fail("IllegalArgumentException expected");
747        } catch (IllegalArgumentException e) {
748            //expected
749        }
750
751        try {
752            Arrays.fill(d, -10, 0, val);
753            fail("ArrayIndexOutOfBoundsException expected");
754        } catch (ArrayIndexOutOfBoundsException e) {
755            //expected
756        }
757
758        try {
759            Arrays.fill(d, 10, d.length+1, val);
760            fail("ArrayIndexOutOfBoundsException expected");
761        } catch (ArrayIndexOutOfBoundsException e) {
762            //expected
763        }
764    }
765
766    /**
767     * java.util.Arrays#fill(boolean[], boolean)
768     */
769    public void test_fill$ZZ() {
770        // Test for method void java.util.Arrays.fill(boolean [], boolean)
771
772        boolean d[] = new boolean[1000];
773        Arrays.fill(d, true);
774        for (int i = 0; i < d.length; i++)
775            assertTrue("Failed to fill boolean array correctly", d[i]);
776    }
777
778    /**
779     * java.util.Arrays#fill(boolean[], int, int, boolean)
780     */
781    public void test_fill$ZIIZ() {
782        // Test for method void java.util.Arrays.fill(boolean [], int, int,
783        // boolean)
784        boolean val = true;
785        boolean d[] = new boolean[1000];
786        Arrays.fill(d, 400, d.length, val);
787        for (int i = 0; i < 400; i++)
788            assertTrue("Filled elements not in range", !(d[i] == val));
789        for (int i = 400; i < d.length; i++)
790            assertTrue("Failed to fill boolean array correctly", d[i] == val);
791
792        try {
793            Arrays.fill(d, 10, 0, val);
794            fail("IllegalArgumentException expected");
795        } catch (IllegalArgumentException e) {
796            //expected
797        }
798
799        try {
800            Arrays.fill(d, -10, 0, val);
801            fail("ArrayIndexOutOfBoundsException expected");
802        } catch (ArrayIndexOutOfBoundsException e) {
803            //expected
804        }
805
806        try {
807            Arrays.fill(d, 10, d.length+1, val);
808            fail("ArrayIndexOutOfBoundsException expected");
809        } catch (ArrayIndexOutOfBoundsException e) {
810            //expected
811        }
812    }
813
814    /**
815     * java.util.Arrays#fill(java.lang.Object[], java.lang.Object)
816     */
817    public void test_fill$Ljava_lang_ObjectLjava_lang_Object() {
818        // Test for method void java.util.Arrays.fill(java.lang.Object [],
819        // java.lang.Object)
820        Object val = new Object();
821        Object d[] = new Object[1000];
822        Arrays.fill(d, 0, d.length, val);
823        for (int i = 0; i < d.length; i++)
824            assertTrue("Failed to fill Object array correctly", d[i] == val);
825    }
826
827    /**
828     * java.util.Arrays#fill(java.lang.Object[], int, int,
829     *        java.lang.Object)
830     */
831    public void test_fill$Ljava_lang_ObjectIILjava_lang_Object() {
832        // Test for method void java.util.Arrays.fill(java.lang.Object [], int,
833        // int, java.lang.Object)
834        Object val = new Object();
835        Object d[] = new Object[1000];
836        Arrays.fill(d, 400, d.length, val);
837        for (int i = 0; i < 400; i++)
838            assertTrue("Filled elements not in range", !(d[i] == val));
839        for (int i = 400; i < d.length; i++)
840            assertTrue("Failed to fill Object array correctly", d[i] == val);
841
842        Arrays.fill(d, 400, d.length, null);
843        for (int i = 400; i < d.length; i++)
844            assertNull("Failed to fill Object array correctly with nulls",
845                    d[i]);
846
847        try {
848            Arrays.fill(d, 10, 0, val);
849            fail("IllegalArgumentException expected");
850        } catch (IllegalArgumentException e) {
851            //expected
852        }
853
854        try {
855            Arrays.fill(d, -10, 0, val);
856            fail("ArrayIndexOutOfBoundsException expected");
857        } catch (ArrayIndexOutOfBoundsException e) {
858            //expected
859        }
860
861        try {
862            Arrays.fill(d, 10, d.length+1, val);
863            fail("ArrayIndexOutOfBoundsException expected");
864        } catch (ArrayIndexOutOfBoundsException e) {
865            //expected
866        }
867    }
868
869    /**
870     * java.util.Arrays#equals(byte[], byte[])
871     */
872    public void test_equals$B$B() {
873        // Test for method boolean java.util.Arrays.equals(byte [], byte [])
874        byte d[] = new byte[1000];
875        byte x[] = new byte[1000];
876        Arrays.fill(d, Byte.MAX_VALUE);
877        Arrays.fill(x, Byte.MIN_VALUE);
878        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
879        Arrays.fill(x, Byte.MAX_VALUE);
880        assertTrue("equal arrays returned false", Arrays.equals(d, x));
881    }
882
883    /**
884     * java.util.Arrays#equals(short[], short[])
885     */
886    public void test_equals$S$S() {
887        // Test for method boolean java.util.Arrays.equals(short [], short [])
888        short d[] = new short[1000];
889        short x[] = new short[1000];
890        Arrays.fill(d, Short.MAX_VALUE);
891        Arrays.fill(x, Short.MIN_VALUE);
892        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
893        Arrays.fill(x, Short.MAX_VALUE);
894        assertTrue("equal arrays returned false", Arrays.equals(d, x));
895    }
896
897    /**
898     * java.util.Arrays#equals(char[], char[])
899     */
900    public void test_equals$C$C() {
901        // Test for method boolean java.util.Arrays.equals(char [], char [])
902        char d[] = new char[1000];
903        char x[] = new char[1000];
904        char c = 'T';
905        Arrays.fill(d, c);
906        Arrays.fill(x, 'L');
907        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
908        Arrays.fill(x, c);
909        assertTrue("equal arrays returned false", Arrays.equals(d, x));
910    }
911
912    /**
913     * java.util.Arrays#equals(int[], int[])
914     */
915    public void test_equals$I$I() {
916        // Test for method boolean java.util.Arrays.equals(int [], int [])
917        int d[] = new int[1000];
918        int x[] = new int[1000];
919        Arrays.fill(d, Integer.MAX_VALUE);
920        Arrays.fill(x, Integer.MIN_VALUE);
921        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
922        Arrays.fill(x, Integer.MAX_VALUE);
923        assertTrue("equal arrays returned false", Arrays.equals(d, x));
924
925        assertTrue("wrong result for null array1", !Arrays.equals(new int[2],
926                null));
927        assertTrue("wrong result for null array2", !Arrays.equals(null,
928                new int[2]));
929    }
930
931    /**
932     * java.util.Arrays#equals(long[], long[])
933     */
934    public void test_equals$J$J() {
935        // Test for method boolean java.util.Arrays.equals(long [], long [])
936        long d[] = new long[1000];
937        long x[] = new long[1000];
938        Arrays.fill(d, Long.MAX_VALUE);
939        Arrays.fill(x, Long.MIN_VALUE);
940        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
941        Arrays.fill(x, Long.MAX_VALUE);
942        assertTrue("equal arrays returned false", Arrays.equals(d, x));
943
944        assertTrue("should be false", !Arrays.equals(
945                new long[] { 0x100000000L }, new long[] { 0x200000000L }));
946
947    }
948
949    /**
950     * java.util.Arrays#equals(float[], float[])
951     */
952    public void test_equals$F$F() {
953        // Test for method boolean java.util.Arrays.equals(float [], float [])
954        float d[] = new float[1000];
955        float x[] = new float[1000];
956        Arrays.fill(d, Float.MAX_VALUE);
957        Arrays.fill(x, Float.MIN_VALUE);
958        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
959        Arrays.fill(x, Float.MAX_VALUE);
960        assertTrue("equal arrays returned false", Arrays.equals(d, x));
961
962        assertTrue("NaN not equals", Arrays.equals(new float[] { Float.NaN },
963                new float[] { Float.NaN }));
964        assertTrue("0f equals -0f", !Arrays.equals(new float[] { 0f },
965                new float[] { -0f }));
966    }
967
968    /**
969     * java.util.Arrays#equals(double[], double[])
970     */
971    public void test_equals$D$D() {
972        // Test for method boolean java.util.Arrays.equals(double [], double [])
973        double d[] = new double[1000];
974        double x[] = new double[1000];
975        Arrays.fill(d, Double.MAX_VALUE);
976        Arrays.fill(x, Double.MIN_VALUE);
977        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
978        Arrays.fill(x, Double.MAX_VALUE);
979        assertTrue("equal arrays returned false", Arrays.equals(d, x));
980
981        assertTrue("should be false", !Arrays.equals(new double[] { 1.0 },
982                new double[] { 2.0 }));
983
984        assertTrue("NaN not equals", Arrays.equals(new double[] { Double.NaN },
985                new double[] { Double.NaN }));
986        assertTrue("0d equals -0d", !Arrays.equals(new double[] { 0d },
987                new double[] { -0d }));
988    }
989
990    /**
991     * java.util.Arrays#equals(boolean[], boolean[])
992     */
993    public void test_equals$Z$Z() {
994        // Test for method boolean java.util.Arrays.equals(boolean [], boolean
995        // [])
996        boolean d[] = new boolean[1000];
997        boolean x[] = new boolean[1000];
998        Arrays.fill(d, true);
999        Arrays.fill(x, false);
1000        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
1001        Arrays.fill(x, true);
1002        assertTrue("equal arrays returned false", Arrays.equals(d, x));
1003    }
1004
1005    /**
1006     * java.util.Arrays#equals(java.lang.Object[], java.lang.Object[])
1007     */
1008    public void test_equals$Ljava_lang_Object$Ljava_lang_Object() {
1009        // Test for method boolean java.util.Arrays.equals(java.lang.Object [],
1010        // java.lang.Object [])
1011        Object d[] = new Object[1000];
1012        Object x[] = new Object[1000];
1013        Object o = new Object();
1014        Arrays.fill(d, o);
1015        Arrays.fill(x, new Object());
1016        assertTrue("Inequal arrays returned true", !Arrays.equals(d, x));
1017        Arrays.fill(x, o);
1018        d[50] = null;
1019        x[50] = null;
1020        assertTrue("equal arrays returned false", Arrays.equals(d, x));
1021    }
1022
1023    /**
1024     * java.util.Arrays#sort(byte[])
1025     */
1026    public void test_sort$B() {
1027        // Test for method void java.util.Arrays.sort(byte [])
1028        byte[] reversedArray = new byte[arraySize];
1029        for (int counter = 0; counter < arraySize; counter++)
1030            reversedArray[counter] = (byte) (arraySize - counter - 1);
1031        Arrays.sort(reversedArray);
1032        for (int counter = 0; counter < arraySize; counter++)
1033            assertTrue("Resulting array not sorted",
1034                    reversedArray[counter] == (byte) counter);
1035    }
1036
1037    /**
1038     * java.util.Arrays#sort(byte[], int, int)
1039     */
1040    public void test_sort$BII() {
1041        // Test for method void java.util.Arrays.sort(byte [], int, int)
1042        int startIndex = arraySize / 4;
1043        int endIndex = 3 * arraySize / 4;
1044        byte[] reversedArray = new byte[arraySize];
1045        byte[] originalReversedArray = new byte[arraySize];
1046        for (int counter = 0; counter < arraySize; counter++) {
1047            reversedArray[counter] = (byte) (arraySize - counter - 1);
1048            originalReversedArray[counter] = reversedArray[counter];
1049        }
1050        Arrays.sort(reversedArray, startIndex, endIndex);
1051        for (int counter = 0; counter < startIndex; counter++)
1052            assertTrue("Array modified outside of bounds",
1053                    reversedArray[counter] == originalReversedArray[counter]);
1054        for (int counter = startIndex; counter < endIndex - 1; counter++)
1055            assertTrue("Array not sorted within bounds",
1056                    reversedArray[counter] <= reversedArray[counter + 1]);
1057        for (int counter = endIndex; counter < arraySize; counter++)
1058            assertTrue("Array modified outside of bounds",
1059                    reversedArray[counter] == originalReversedArray[counter]);
1060
1061        //exception testing
1062        try {
1063            Arrays.sort(reversedArray, startIndex + 1, startIndex);
1064            fail("IllegalArgumentException expected");
1065        } catch (IllegalArgumentException ignore) {
1066        }
1067
1068        try {
1069            Arrays.sort(reversedArray, -1, startIndex);
1070            fail("ArrayIndexOutOfBoundsException expected (1)");
1071        } catch (ArrayIndexOutOfBoundsException ignore) {
1072        }
1073
1074        try {
1075            Arrays.sort(reversedArray, startIndex, reversedArray.length + 1);
1076            fail("ArrayIndexOutOfBoundsException expected (2)");
1077        } catch (ArrayIndexOutOfBoundsException ignore) {
1078        }
1079    }
1080
1081    /**
1082     * java.util.Arrays#sort(char[])
1083     */
1084    public void test_sort$C() {
1085        // Test for method void java.util.Arrays.sort(char [])
1086        char[] reversedArray = new char[arraySize];
1087        for (int counter = 0; counter < arraySize; counter++)
1088            reversedArray[counter] = (char) (arraySize - counter - 1);
1089        Arrays.sort(reversedArray);
1090        for (int counter = 0; counter < arraySize; counter++)
1091            assertTrue("Resulting array not sorted",
1092                    reversedArray[counter] == (char) counter);
1093
1094    }
1095
1096    /**
1097     * java.util.Arrays#sort(char[], int, int)
1098     */
1099    public void test_sort$CII() {
1100        // Test for method void java.util.Arrays.sort(char [], int, int)
1101        int startIndex = arraySize / 4;
1102        int endIndex = 3 * arraySize / 4;
1103        char[] reversedArray = new char[arraySize];
1104        char[] originalReversedArray = new char[arraySize];
1105        for (int counter = 0; counter < arraySize; counter++) {
1106            reversedArray[counter] = (char) (arraySize - counter - 1);
1107            originalReversedArray[counter] = reversedArray[counter];
1108        }
1109        Arrays.sort(reversedArray, startIndex, endIndex);
1110        for (int counter = 0; counter < startIndex; counter++)
1111            assertTrue("Array modified outside of bounds",
1112                    reversedArray[counter] == originalReversedArray[counter]);
1113        for (int counter = startIndex; counter < endIndex - 1; counter++)
1114            assertTrue("Array not sorted within bounds",
1115                    reversedArray[counter] <= reversedArray[counter + 1]);
1116        for (int counter = endIndex; counter < arraySize; counter++)
1117            assertTrue("Array modified outside of bounds",
1118                    reversedArray[counter] == originalReversedArray[counter]);
1119
1120        //exception testing
1121        try {
1122            Arrays.sort(reversedArray, startIndex + 1, startIndex);
1123            fail("IllegalArgumentException expected");
1124        } catch (IllegalArgumentException ignore) {
1125        }
1126
1127        try {
1128            Arrays.sort(reversedArray, -1, startIndex);
1129            fail("ArrayIndexOutOfBoundsException expected (1)");
1130        } catch (ArrayIndexOutOfBoundsException ignore) {
1131        }
1132
1133        try {
1134            Arrays.sort(reversedArray, startIndex, reversedArray.length + 1);
1135            fail("ArrayIndexOutOfBoundsException expected (2)");
1136        } catch (ArrayIndexOutOfBoundsException ignore) {
1137        }
1138    }
1139
1140    /**
1141     * java.util.Arrays#sort(double[])
1142     */
1143    public void test_sort$D() {
1144        // Test for method void java.util.Arrays.sort(double [])
1145        double[] reversedArray = new double[arraySize];
1146        for (int counter = 0; counter < arraySize; counter++)
1147            reversedArray[counter] = (double) (arraySize - counter - 1);
1148        Arrays.sort(reversedArray);
1149        for (int counter = 0; counter < arraySize; counter++)
1150            assertTrue("Resulting array not sorted",
1151                    reversedArray[counter] == (double) counter);
1152
1153        double[] specials1 = new double[] { Double.NaN, Double.MAX_VALUE,
1154                Double.MIN_VALUE, 0d, -0d, Double.POSITIVE_INFINITY,
1155                Double.NEGATIVE_INFINITY };
1156        double[] specials2 = new double[] { 0d, Double.POSITIVE_INFINITY, -0d,
1157                Double.NEGATIVE_INFINITY, Double.MIN_VALUE, Double.NaN,
1158                Double.MAX_VALUE };
1159        double[] specials3 = new double[] { 0.0, Double.NaN, 1.0, 2.0, Double.NaN,
1160                Double.NaN, 1.0, 3.0, -0.0 };
1161        double[] answer = new double[] { Double.NEGATIVE_INFINITY, -0d, 0d,
1162                Double.MIN_VALUE, Double.MAX_VALUE, Double.POSITIVE_INFINITY,
1163                Double.NaN };
1164        double[] answer3 = new double[] { -0.0, 0.0, 1.0, 1.0, 2.0, 3.0, Double.NaN,
1165                Double.NaN, Double.NaN };
1166
1167        Arrays.sort(specials1);
1168        Object[] print1 = new Object[specials1.length];
1169        for (int i = 0; i < specials1.length; i++)
1170            print1[i] = new Double(specials1[i]);
1171        assertTrue("specials sort incorrectly 1: " + Arrays.asList(print1),
1172                Arrays.equals(specials1, answer));
1173
1174        Arrays.sort(specials2);
1175        Object[] print2 = new Object[specials2.length];
1176        for (int i = 0; i < specials2.length; i++)
1177            print2[i] = new Double(specials2[i]);
1178        assertTrue("specials sort incorrectly 2: " + Arrays.asList(print2),
1179                Arrays.equals(specials2, answer));
1180
1181        Arrays.sort(specials3);
1182        Object[] print3 = new Object[specials3.length];
1183        for (int i = 0; i < specials3.length; i++)
1184            print3[i] = new Double(specials3[i]);
1185        assertTrue("specials sort incorrectly 3: " + Arrays.asList(print3),
1186                Arrays.equals(specials3, answer3));
1187    }
1188
1189    /**
1190     * java.util.Arrays#sort(double[], int, int)
1191     */
1192    public void test_sort$DII() {
1193        // Test for method void java.util.Arrays.sort(double [], int, int)
1194        int startIndex = arraySize / 4;
1195        int endIndex = 3 * arraySize / 4;
1196        double[] reversedArray = new double[arraySize];
1197        double[] originalReversedArray = new double[arraySize];
1198        for (int counter = 0; counter < arraySize; counter++) {
1199            reversedArray[counter] = (double) (arraySize - counter - 1);
1200            originalReversedArray[counter] = reversedArray[counter];
1201        }
1202        Arrays.sort(reversedArray, startIndex, endIndex);
1203        for (int counter = 0; counter < startIndex; counter++)
1204            assertTrue("Array modified outside of bounds",
1205                    reversedArray[counter] == originalReversedArray[counter]);
1206        for (int counter = startIndex; counter < endIndex - 1; counter++)
1207            assertTrue("Array not sorted within bounds",
1208                    reversedArray[counter] <= reversedArray[counter + 1]);
1209        for (int counter = endIndex; counter < arraySize; counter++)
1210            assertTrue("Array modified outside of bounds",
1211                    reversedArray[counter] == originalReversedArray[counter]);
1212
1213        //exception testing
1214        try {
1215            Arrays.sort(reversedArray, startIndex + 1, startIndex);
1216            fail("IllegalArgumentException expected");
1217        } catch (IllegalArgumentException ignore) {
1218        }
1219
1220        try {
1221            Arrays.sort(reversedArray, -1, startIndex);
1222            fail("ArrayIndexOutOfBoundsException expected (1)");
1223        } catch (ArrayIndexOutOfBoundsException ignore) {
1224        }
1225
1226        try {
1227            Arrays.sort(reversedArray, startIndex, reversedArray.length + 1);
1228            fail("ArrayIndexOutOfBoundsException expected (2)");
1229        } catch (ArrayIndexOutOfBoundsException ignore) {
1230        }
1231    }
1232
1233    /**
1234     * java.util.Arrays#sort(float[])
1235     */
1236    public void test_sort$F() {
1237        // Test for method void java.util.Arrays.sort(float [])
1238        float[] reversedArray = new float[arraySize];
1239        for (int counter = 0; counter < arraySize; counter++)
1240            reversedArray[counter] = (float) (arraySize - counter - 1);
1241        Arrays.sort(reversedArray);
1242        for (int counter = 0; counter < arraySize; counter++)
1243            assertTrue("Resulting array not sorted",
1244                    reversedArray[counter] == (float) counter);
1245
1246        float[] specials1 = new float[] { Float.NaN, Float.MAX_VALUE,
1247                Float.MIN_VALUE, 0f, -0f, Float.POSITIVE_INFINITY,
1248                Float.NEGATIVE_INFINITY };
1249        float[] specials2 = new float[] { 0f, Float.POSITIVE_INFINITY, -0f,
1250                Float.NEGATIVE_INFINITY, Float.MIN_VALUE, Float.NaN,
1251                Float.MAX_VALUE };
1252        float[] answer = new float[] { Float.NEGATIVE_INFINITY, -0f, 0f,
1253                Float.MIN_VALUE, Float.MAX_VALUE, Float.POSITIVE_INFINITY,
1254                Float.NaN };
1255
1256        Arrays.sort(specials1);
1257        Object[] print1 = new Object[specials1.length];
1258        for (int i = 0; i < specials1.length; i++)
1259            print1[i] = new Float(specials1[i]);
1260        assertTrue("specials sort incorrectly 1: " + Arrays.asList(print1),
1261                Arrays.equals(specials1, answer));
1262
1263        Arrays.sort(specials2);
1264        Object[] print2 = new Object[specials2.length];
1265        for (int i = 0; i < specials2.length; i++)
1266            print2[i] = new Float(specials2[i]);
1267        assertTrue("specials sort incorrectly 2: " + Arrays.asList(print2),
1268                Arrays.equals(specials2, answer));
1269    }
1270
1271    /**
1272     * java.util.Arrays#sort(float[], int, int)
1273     */
1274    public void test_sort$FII() {
1275        // Test for method void java.util.Arrays.sort(float [], int, int)
1276        int startIndex = arraySize / 4;
1277        int endIndex = 3 * arraySize / 4;
1278        float[] reversedArray = new float[arraySize];
1279        float[] originalReversedArray = new float[arraySize];
1280        for (int counter = 0; counter < arraySize; counter++) {
1281            reversedArray[counter] = (float) (arraySize - counter - 1);
1282            originalReversedArray[counter] = reversedArray[counter];
1283        }
1284        Arrays.sort(reversedArray, startIndex, endIndex);
1285        for (int counter = 0; counter < startIndex; counter++)
1286            assertTrue("Array modified outside of bounds",
1287                    reversedArray[counter] == originalReversedArray[counter]);
1288        for (int counter = startIndex; counter < endIndex - 1; counter++)
1289            assertTrue("Array not sorted within bounds",
1290                    reversedArray[counter] <= reversedArray[counter + 1]);
1291        for (int counter = endIndex; counter < arraySize; counter++)
1292            assertTrue("Array modified outside of bounds",
1293                    reversedArray[counter] == originalReversedArray[counter]);
1294
1295        //exception testing
1296        try {
1297            Arrays.sort(reversedArray, startIndex + 1, startIndex);
1298            fail("IllegalArgumentException expected");
1299        } catch (IllegalArgumentException ignore) {
1300        }
1301
1302        try {
1303            Arrays.sort(reversedArray, -1, startIndex);
1304            fail("ArrayIndexOutOfBoundsException expected (1)");
1305        } catch (ArrayIndexOutOfBoundsException ignore) {
1306        }
1307
1308        try {
1309            Arrays.sort(reversedArray, startIndex, reversedArray.length + 1);
1310            fail("ArrayIndexOutOfBoundsException expected (2)");
1311        } catch (ArrayIndexOutOfBoundsException ignore) {
1312        }
1313    }
1314
1315    /**
1316     * java.util.Arrays#sort(int[])
1317     */
1318    public void test_sort$I() {
1319        // Test for method void java.util.Arrays.sort(int [])
1320        int[] reversedArray = new int[arraySize];
1321        for (int counter = 0; counter < arraySize; counter++)
1322            reversedArray[counter] = arraySize - counter - 1;
1323        Arrays.sort(reversedArray);
1324        for (int counter = 0; counter < arraySize; counter++)
1325            assertTrue("Resulting array not sorted",
1326                    reversedArray[counter] == counter);
1327    }
1328
1329    /**
1330     * java.util.Arrays#sort(int[], int, int)
1331     */
1332    public void test_sort$III() {
1333        // Test for method void java.util.Arrays.sort(int [], int, int)
1334        int startIndex = arraySize / 4;
1335        int endIndex = 3 * arraySize / 4;
1336        int[] reversedArray = new int[arraySize];
1337        int[] originalReversedArray = new int[arraySize];
1338        for (int counter = 0; counter < arraySize; counter++) {
1339            reversedArray[counter] = arraySize - counter - 1;
1340            originalReversedArray[counter] = reversedArray[counter];
1341        }
1342        Arrays.sort(reversedArray, startIndex, endIndex);
1343        for (int counter = 0; counter < startIndex; counter++)
1344            assertTrue("Array modified outside of bounds",
1345                    reversedArray[counter] == originalReversedArray[counter]);
1346        for (int counter = startIndex; counter < endIndex - 1; counter++)
1347            assertTrue("Array not sorted within bounds",
1348                    reversedArray[counter] <= reversedArray[counter + 1]);
1349        for (int counter = endIndex; counter < arraySize; counter++)
1350            assertTrue("Array modified outside of bounds",
1351                    reversedArray[counter] == originalReversedArray[counter]);
1352
1353        //exception testing
1354        try {
1355            Arrays.sort(reversedArray, startIndex + 1, startIndex);
1356            fail("IllegalArgumentException expected");
1357        } catch (IllegalArgumentException ignore) {
1358        }
1359
1360        try {
1361            Arrays.sort(reversedArray, -1, startIndex);
1362            fail("ArrayIndexOutOfBoundsException expected (1)");
1363        } catch (ArrayIndexOutOfBoundsException ignore) {
1364        }
1365
1366        try {
1367            Arrays.sort(reversedArray, startIndex, reversedArray.length + 1);
1368            fail("ArrayIndexOutOfBoundsException expected (2)");
1369        } catch (ArrayIndexOutOfBoundsException ignore) {
1370        }
1371    }
1372
1373    /**
1374     * java.util.Arrays#sort(long[])
1375     */
1376    public void test_sort$J() {
1377        // Test for method void java.util.Arrays.sort(long [])
1378        long[] reversedArray = new long[arraySize];
1379        for (int counter = 0; counter < arraySize; counter++)
1380            reversedArray[counter] = (long) (arraySize - counter - 1);
1381        Arrays.sort(reversedArray);
1382        for (int counter = 0; counter < arraySize; counter++)
1383            assertTrue("Resulting array not sorted",
1384                    reversedArray[counter] == (long) counter);
1385
1386    }
1387
1388    /**
1389     * java.util.Arrays#sort(long[], int, int)
1390     */
1391    public void test_sort$JII() {
1392        // Test for method void java.util.Arrays.sort(long [], int, int)
1393        int startIndex = arraySize / 4;
1394        int endIndex = 3 * arraySize / 4;
1395        long[] reversedArray = new long[arraySize];
1396        long[] originalReversedArray = new long[arraySize];
1397        for (int counter = 0; counter < arraySize; counter++) {
1398            reversedArray[counter] = (long) (arraySize - counter - 1);
1399            originalReversedArray[counter] = reversedArray[counter];
1400        }
1401        Arrays.sort(reversedArray, startIndex, endIndex);
1402        for (int counter = 0; counter < startIndex; counter++)
1403            assertTrue("Array modified outside of bounds",
1404                    reversedArray[counter] == originalReversedArray[counter]);
1405        for (int counter = startIndex; counter < endIndex - 1; counter++)
1406            assertTrue("Array not sorted within bounds",
1407                    reversedArray[counter] <= reversedArray[counter + 1]);
1408        for (int counter = endIndex; counter < arraySize; counter++)
1409            assertTrue("Array modified outside of bounds",
1410                    reversedArray[counter] == originalReversedArray[counter]);
1411
1412        //exception testing
1413        try {
1414            Arrays.sort(reversedArray, startIndex + 1, startIndex);
1415            fail("IllegalArgumentException expected");
1416        } catch (IllegalArgumentException ignore) {
1417        }
1418
1419        try {
1420            Arrays.sort(reversedArray, -1, startIndex);
1421            fail("ArrayIndexOutOfBoundsException expected (1)");
1422        } catch (ArrayIndexOutOfBoundsException ignore) {
1423        }
1424
1425        try {
1426            Arrays.sort(reversedArray, startIndex, reversedArray.length + 1);
1427            fail("ArrayIndexOutOfBoundsException expected (2)");
1428        } catch (ArrayIndexOutOfBoundsException ignore) {
1429        }
1430    }
1431
1432    /**
1433     * java.util.Arrays#sort(java.lang.Object[])
1434     */
1435    public void test_sort$Ljava_lang_Object() {
1436        // Test for method void java.util.Arrays.sort(java.lang.Object [])
1437        Object[] reversedArray = new Object[arraySize];
1438        for (int counter = 0; counter < arraySize; counter++)
1439            reversedArray[counter] = objectArray[arraySize - counter - 1];
1440        Arrays.sort(reversedArray);
1441        for (int counter = 0; counter < arraySize; counter++)
1442            assertTrue("Resulting array not sorted",
1443                    reversedArray[counter] == objectArray[counter]);
1444
1445        Arrays.fill(reversedArray, 0, reversedArray.length/2, "String");
1446        Arrays.fill(reversedArray, reversedArray.length/2, reversedArray.length, new Integer(1));
1447
1448        try {
1449            Arrays.sort(reversedArray);
1450            fail("ClassCastException expected");
1451        } catch (ClassCastException e) {
1452            //expected
1453        }
1454    }
1455
1456    /**
1457     * java.util.Arrays#sort(java.lang.Object[], int, int)
1458     */
1459    public void test_sort$Ljava_lang_ObjectII() {
1460        // Test for method void java.util.Arrays.sort(java.lang.Object [], int,
1461        // int)
1462        int startIndex = arraySize / 4;
1463        int endIndex = 3 * arraySize / 4;
1464        Object[] reversedArray = new Object[arraySize];
1465        Object[] originalReversedArray = new Object[arraySize];
1466        for (int counter = 0; counter < arraySize; counter++) {
1467            reversedArray[counter] = objectArray[arraySize - counter - 1];
1468            originalReversedArray[counter] = reversedArray[counter];
1469        }
1470        Arrays.sort(reversedArray, startIndex, endIndex);
1471        for (int counter = 0; counter < startIndex; counter++)
1472            assertTrue("Array modified outside of bounds",
1473                    reversedArray[counter] == originalReversedArray[counter]);
1474        for (int counter = startIndex; counter < endIndex - 1; counter++)
1475            assertTrue("Array not sorted within bounds",
1476                    ((Comparable) reversedArray[counter])
1477                            .compareTo(reversedArray[counter + 1]) <= 0);
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        Arrays.fill(reversedArray, 0, reversedArray.length/2, "String");
1502        Arrays.fill(reversedArray, reversedArray.length/2, reversedArray.length, new Integer(1));
1503
1504        try {
1505            Arrays.sort(reversedArray, reversedArray.length/4, 3*reversedArray.length/4);
1506            fail("ClassCastException expected");
1507        } catch (ClassCastException e) {
1508            //expected
1509        }
1510
1511        Arrays.sort(reversedArray, 0, reversedArray.length/4);
1512        Arrays.sort(reversedArray, 3*reversedArray.length/4, reversedArray.length);
1513    }
1514
1515    /**
1516     * java.util.Arrays#sort(java.lang.Object[], int, int,
1517     *        java.util.Comparator)
1518     */
1519    public void test_sort$Ljava_lang_ObjectIILjava_util_Comparator() {
1520        // Test for method void java.util.Arrays.sort(java.lang.Object [], int,
1521        // int, java.util.Comparator)
1522        int startIndex = arraySize / 4;
1523        int endIndex = 3 * arraySize / 4;
1524        ReversedIntegerComparator comp = new ReversedIntegerComparator();
1525        Object[] originalArray = new Object[arraySize];
1526        for (int counter = 0; counter < arraySize; counter++)
1527            originalArray[counter] = objectArray[counter];
1528        Arrays.sort(objectArray, startIndex, endIndex, comp);
1529        for (int counter = 0; counter < startIndex; counter++)
1530            assertTrue("Array modified outside of bounds",
1531                    objectArray[counter] == originalArray[counter]);
1532        for (int counter = startIndex; counter < endIndex - 1; counter++)
1533            assertTrue("Array not sorted within bounds", comp.compare(
1534                    objectArray[counter], objectArray[counter + 1]) <= 0);
1535        for (int counter = endIndex; counter < arraySize; counter++)
1536            assertTrue("Array modified outside of bounds",
1537                    objectArray[counter] == originalArray[counter]);
1538
1539        Arrays.fill(originalArray, 0, originalArray.length/2, "String");
1540        Arrays.fill(originalArray, originalArray.length/2, originalArray.length, new Integer(1));
1541
1542        try {
1543            Arrays.sort(originalArray, startIndex, endIndex, comp);
1544            fail("ClassCastException expected");
1545        } catch (ClassCastException e) {
1546            //expected
1547        }
1548
1549        Arrays.sort(originalArray, endIndex, originalArray.length, comp);
1550
1551        try {
1552            Arrays.sort(originalArray, endIndex, originalArray.length + 1, comp);
1553            fail("ArrayIndexOutOfBoundsException expected");
1554        } catch(ArrayIndexOutOfBoundsException e) {
1555            //expected
1556        }
1557
1558        try {
1559            Arrays.sort(originalArray, -1, startIndex, comp);
1560            fail("ArrayIndexOutOfBoundsException expected");
1561        } catch(ArrayIndexOutOfBoundsException e) {
1562            //expected
1563        }
1564
1565        try {
1566            Arrays.sort(originalArray, originalArray.length, endIndex, comp);
1567            fail("IllegalArgumentException expected");
1568        } catch(IllegalArgumentException e) {
1569            //expected
1570        }
1571    }
1572
1573    /**
1574     * java.util.Arrays#sort(java.lang.Object[], java.util.Comparator)
1575     */
1576    public void test_sort$Ljava_lang_ObjectLjava_util_Comparator() {
1577        // Test for method void java.util.Arrays.sort(java.lang.Object [],
1578        // java.util.Comparator)
1579        ReversedIntegerComparator comp = new ReversedIntegerComparator();
1580        Arrays.sort(objectArray, comp);
1581        for (int counter = 0; counter < arraySize - 1; counter++)
1582            assertTrue("Array not sorted correctly with custom comparator",
1583                    comp
1584                            .compare(objectArray[counter],
1585                                    objectArray[counter + 1]) <= 0);
1586
1587        Arrays.fill(objectArray, 0, objectArray.length/2, "String");
1588        Arrays.fill(objectArray, objectArray.length/2, objectArray.length, new Integer(1));
1589
1590        try {
1591            Arrays.sort(objectArray, comp);
1592            fail("ClassCastException expected");
1593        } catch (ClassCastException e) {
1594            //expected
1595        }
1596    }
1597
1598    // Regression HARMONY-6076
1599    public void test_sort$Ljava_lang_ObjectLjava_util_Comparator_stable() {
1600        Element[] array = new Element[11];
1601        array[0] = new Element(122);
1602        array[1] = new Element(146);
1603        array[2] = new Element(178);
1604        array[3] = new Element(208);
1605        array[4] = new Element(117);
1606        array[5] = new Element(146);
1607        array[6] = new Element(173);
1608        array[7] = new Element(203);
1609        array[8] = new Element(56);
1610        array[9] = new Element(208);
1611        array[10] = new Element(96);
1612
1613        Comparator<Element> comparator = new Comparator<Element>() {
1614            public int compare(Element object1, Element object2) {
1615                return object1.value - object2.value;
1616            }
1617        };
1618
1619        Arrays.sort(array, comparator);
1620
1621        for (int i = 1; i < array.length; i++) {
1622            assertTrue(comparator.compare(array[i - 1], array[i]) <= 0);
1623            if (comparator.compare(array[i - 1], array[i]) == 0) {
1624                assertTrue(array[i - 1].index < array[i].index);
1625            }
1626        }
1627    }
1628
1629    public static class Element {
1630        public int value;
1631
1632        public int index;
1633
1634        private static int count = 0;
1635
1636        public Element(int value) {
1637            this.value = value;
1638            index = count++;
1639        }
1640    }
1641
1642    /**
1643     * java.util.Arrays#sort(short[])
1644     */
1645    public void test_sort$S() {
1646        // Test for method void java.util.Arrays.sort(short [])
1647        short[] reversedArray = new short[arraySize];
1648        for (int counter = 0; counter < arraySize; counter++)
1649            reversedArray[counter] = (short) (arraySize - counter - 1);
1650        Arrays.sort(reversedArray);
1651        for (int counter = 0; counter < arraySize; counter++)
1652            assertTrue("Resulting array not sorted",
1653                    reversedArray[counter] == (short) counter);
1654    }
1655
1656    /**
1657     * java.util.Arrays#sort(short[], int, int)
1658     */
1659    public void test_sort$SII() {
1660        // Test for method void java.util.Arrays.sort(short [], int, int)
1661        int startIndex = arraySize / 4;
1662        int endIndex = 3 * arraySize / 4;
1663        short[] reversedArray = new short[arraySize];
1664        short[] originalReversedArray = new short[arraySize];
1665        for (int counter = 0; counter < arraySize; counter++) {
1666            reversedArray[counter] = (short) (arraySize - counter - 1);
1667            originalReversedArray[counter] = reversedArray[counter];
1668        }
1669        Arrays.sort(reversedArray, startIndex, endIndex);
1670        for (int counter = 0; counter < startIndex; counter++)
1671            assertTrue("Array modified outside of bounds",
1672                    reversedArray[counter] == originalReversedArray[counter]);
1673        for (int counter = startIndex; counter < endIndex - 1; counter++)
1674            assertTrue("Array not sorted within bounds",
1675                    reversedArray[counter] <= reversedArray[counter + 1]);
1676        for (int counter = endIndex; counter < arraySize; counter++)
1677            assertTrue("Array modified outside of bounds",
1678                    reversedArray[counter] == originalReversedArray[counter]);
1679
1680        //exception testing
1681        try {
1682            Arrays.sort(reversedArray, startIndex + 1, startIndex);
1683            fail("IllegalArgumentException expected");
1684        } catch (IllegalArgumentException ignore) {
1685        }
1686
1687        try {
1688            Arrays.sort(reversedArray, -1, startIndex);
1689            fail("ArrayIndexOutOfBoundsException expected (1)");
1690        } catch (ArrayIndexOutOfBoundsException ignore) {
1691        }
1692
1693        try {
1694            Arrays.sort(reversedArray, startIndex, reversedArray.length + 1);
1695            fail("ArrayIndexOutOfBoundsException expected (2)");
1696        } catch (ArrayIndexOutOfBoundsException ignore) {
1697        }
1698    }
1699
1700    /**
1701     * java.util.Arrays#sort(byte[], int, int)
1702     */
1703    public void test_java_util_Arrays_sort_byte_array_NPE() {
1704        byte[] byte_array_null = null;
1705        try {
1706            java.util.Arrays.sort(byte_array_null);
1707            fail("Should throw java.lang.NullPointerException");
1708        } catch (NullPointerException e) {
1709            // Expected
1710        }
1711        try {
1712            // Regression for HARMONY-378
1713            java.util.Arrays.sort(byte_array_null, (int) -1, (int) 1);
1714            fail("Should throw java.lang.NullPointerException");
1715        } catch (NullPointerException e) {
1716            // Expected
1717        }
1718    }
1719
1720    /**
1721     * java.util.Arrays#sort(char[], int, int)
1722     */
1723    public void test_java_util_Arrays_sort_char_array_NPE() {
1724        char[] char_array_null = null;
1725        try {
1726            java.util.Arrays.sort(char_array_null);
1727            fail("Should throw java.lang.NullPointerException");
1728        } catch (NullPointerException e) {
1729            // Expected
1730        }
1731        try {
1732            // Regression for HARMONY-378
1733            java.util.Arrays.sort(char_array_null, (int) -1, (int) 1);
1734            fail("Should throw java.lang.NullPointerException");
1735        } catch (NullPointerException e) {
1736            // Expected
1737        }
1738    }
1739
1740    /**
1741     * java.util.Arrays#sort(double[], int, int)
1742     */
1743    public void test_java_util_Arrays_sort_double_array_NPE() {
1744        double[] double_array_null = null;
1745        try {
1746            java.util.Arrays.sort(double_array_null);
1747            fail("Should throw java.lang.NullPointerException");
1748        } catch (NullPointerException e) {
1749            // Expected
1750        }
1751        try {
1752            // Regression for HARMONY-378
1753            java.util.Arrays.sort(double_array_null, (int) -1, (int) 1);
1754            fail("Should throw java.lang.NullPointerException");
1755        } catch (NullPointerException e) {
1756            // Expected
1757        }
1758    }
1759
1760    /**
1761     * java.util.Arrays#sort(float[], int, int)
1762     */
1763    public void test_java_util_Arrays_sort_float_array_NPE() {
1764        float[] float_array_null = null;
1765        try {
1766            java.util.Arrays.sort(float_array_null);
1767            fail("Should throw java.lang.NullPointerException");
1768        } catch (NullPointerException e) {
1769            // Expected
1770        }
1771        try {
1772            // Regression for HARMONY-378
1773            java.util.Arrays.sort(float_array_null, (int) -1, (int) 1);
1774            fail("Should throw java.lang.NullPointerException");
1775        } catch (NullPointerException e) {
1776            // Expected
1777        }
1778    }
1779
1780    /**
1781     * java.util.Arrays#sort(int[], int, int)
1782     */
1783    public void test_java_util_Arrays_sort_int_array_NPE() {
1784        int[] int_array_null = null;
1785        try {
1786            java.util.Arrays.sort(int_array_null);
1787            fail("Should throw java.lang.NullPointerException");
1788        } catch (NullPointerException e) {
1789            // Expected
1790        }
1791        try {
1792            // Regression for HARMONY-378
1793            java.util.Arrays.sort(int_array_null, (int) -1, (int) 1);
1794            fail("Should throw java.lang.NullPointerException");
1795        } catch (NullPointerException e) {
1796            // Expected
1797        }
1798    }
1799
1800    /**
1801     * java.util.Arrays#sort(Object[], int, int)
1802     */
1803    public void test_java_util_Arrays_sort_object_array_NPE() {
1804        Object[] object_array_null = null;
1805        try {
1806            java.util.Arrays.sort(object_array_null);
1807            fail("Should throw java.lang.NullPointerException");
1808        } catch (NullPointerException e) {
1809            // Expected
1810        }
1811        try {
1812            // Regression for HARMONY-378
1813            java.util.Arrays.sort(object_array_null, (int) -1, (int) 1);
1814            fail("Should throw java.lang.NullPointerException");
1815        } catch (NullPointerException e) {
1816            // Expected
1817        }
1818        try {
1819            // Regression for HARMONY-378
1820            java.util.Arrays.sort(object_array_null, (int) -1, (int) 1, null);
1821            fail("Should throw java.lang.NullPointerException");
1822        } catch (NullPointerException e) {
1823            // Expected
1824        }
1825    }
1826
1827    /**
1828     * java.util.Arrays#sort(long[], int, int)
1829     */
1830    public void test_java_util_Arrays_sort_long_array_NPE() {
1831        long[] long_array_null = null;
1832        try {
1833            java.util.Arrays.sort(long_array_null);
1834            fail("Should throw java.lang.NullPointerException");
1835        } catch (NullPointerException e) {
1836            // Expected
1837        }
1838        try {
1839            // Regression for HARMONY-378
1840            java.util.Arrays.sort(long_array_null, (int) -1, (int) 1);
1841            fail("Should throw java.lang.NullPointerException");
1842        } catch (NullPointerException e) {
1843            // Expected
1844        }
1845    }
1846
1847    /**
1848     * java.util.Arrays#sort(short[], int, int)
1849     */
1850    public void test_java_util_Arrays_sort_short_array_NPE() {
1851        short[] short_array_null = null;
1852        try {
1853            java.util.Arrays.sort(short_array_null);
1854            fail("Should throw java.lang.NullPointerException");
1855        } catch (NullPointerException e) {
1856            // Expected
1857        }
1858        try {
1859            // Regression for HARMONY-378
1860            java.util.Arrays.sort(short_array_null, (int) -1, (int) 1);
1861            fail("Should throw java.lang.NullPointerException");
1862        } catch (NullPointerException e) {
1863            // Expected
1864        }
1865    }
1866
1867    // Lenghts of arrays to test in test_sort;
1868    private static final int[] LENGTHS = { 0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 100, 1000, 10000 };
1869
1870    /**
1871     * java.util.Arrays#sort()
1872     */
1873    public void test_sort() {
1874        for (int len : LENGTHS) {
1875            PrimitiveTypeArrayBuilder.reset();
1876            int[] golden = new int[len];
1877            for (int m = 1; m < 2 * len; m *= 2) {
1878                for (PrimitiveTypeArrayBuilder builder : PrimitiveTypeArrayBuilder.values()) {
1879                    builder.build(golden, m);
1880                    int[] test = golden.clone();
1881
1882                    for (PrimitiveTypeConverter converter : PrimitiveTypeConverter.values()) {
1883                        Object convertedGolden = converter.convert(golden);
1884                        Object convertedTest = converter.convert(test);
1885                        sort(convertedTest);
1886                        checkSorted(convertedTest);
1887                        assertEquals(checkSum(convertedGolden), checkSum(convertedTest));
1888                    }
1889                }
1890            }
1891        }
1892    }
1893
1894    private void sort(Object array) {
1895        if (array instanceof int[]) {
1896            Arrays.sort((int[]) array);
1897        }
1898        else if (array instanceof long[]) {
1899            Arrays.sort((long[]) array);
1900        } else if (array instanceof short[]) {
1901            Arrays.sort((short[]) array);
1902        } else if (array instanceof byte[]) {
1903            Arrays.sort((byte[]) array);
1904        } else if (array instanceof char[]) {
1905            Arrays.sort((char[]) array);
1906        } else if (array instanceof float[]) {
1907            Arrays.sort((float[]) array);
1908        } else if (array instanceof double[]) {
1909            Arrays.sort((double[]) array);
1910        } else {
1911            fail("Unknow type of array: " + array.getClass());
1912        }
1913    }
1914
1915    private void checkSorted(Object array) {
1916        if (array instanceof int[]) {
1917            checkSorted((int[]) array);
1918        } else if (array instanceof long[]) {
1919            checkSorted((long[]) array);
1920        } else if (array instanceof short[]) {
1921            checkSorted((short[]) array);
1922        } else if (array instanceof byte[]) {
1923            checkSorted((byte[]) array);
1924        } else if (array instanceof char[]) {
1925            checkSorted((char[]) array);
1926        } else if (array instanceof float[]) {
1927            checkSorted((float[]) array);
1928        } else if (array instanceof double[]) {
1929            checkSorted((double[]) array);
1930        } else {
1931            fail("Unknow type of array: " + array.getClass());
1932        }
1933    }
1934
1935    private void checkSorted(int[] a) {
1936        for (int i = 0; i < a.length - 1; i++) {
1937            if (a[i] > a[i + 1]) {
1938                orderFail(i, "" + a[i], "" + a[i + 1]);
1939            }
1940        }
1941    }
1942
1943    private void checkSorted(long[] a) {
1944        for (int i = 0; i < a.length - 1; i++) {
1945            if (a[i] > a[i + 1]) {
1946                orderFail(i, "" + a[i], "" + a[i + 1]);
1947            }
1948        }
1949    }
1950
1951    private void checkSorted(short[] a) {
1952        for (int i = 0; i < a.length - 1; i++) {
1953            if (a[i] > a[i + 1]) {
1954                orderFail(i, "" + a[i], "" + a[i + 1]);
1955            }
1956        }
1957    }
1958
1959    private void checkSorted(byte[] a) {
1960        for (int i = 0; i < a.length - 1; i++) {
1961            if (a[i] > a[i + 1]) {
1962                orderFail(i, "" + a[i], "" + a[i + 1]);
1963            }
1964        }
1965    }
1966
1967    private void checkSorted(char[] a) {
1968        for (int i = 0; i < a.length - 1; i++) {
1969            if (a[i] > a[i + 1]) {
1970                orderFail(i, "" + a[i], "" + a[i + 1]);
1971            }
1972        }
1973    }
1974
1975    private void checkSorted(float[] a) {
1976        for (int i = 0; i < a.length - 1; i++) {
1977            if (a[i] > a[i + 1]) {
1978                orderFail(i, "" + a[i], "" + a[i + 1]);
1979            }
1980        }
1981    }
1982
1983    private void checkSorted(double[] a) {
1984        for (int i = 0; i < a.length - 1; i++) {
1985            if (a[i] > a[i + 1]) {
1986                orderFail(i, "" + a[i], "" + a[i + 1]);
1987            }
1988        }
1989    }
1990
1991
1992    private void orderFail(int index, String value1, String value2) {
1993        fail("Array is not sorted at " + index + "-th position: " + value1 + " and " + value2);
1994    }
1995
1996    private int checkSum(Object array) {
1997        if (array instanceof int[]) {
1998            return checkSum((int[]) array);
1999        } else if (array instanceof long[]) {
2000            return checkSum((long[]) array);
2001        } else if (array instanceof short[]) {
2002            return checkSum((short[]) array);
2003        } else if (array instanceof byte[]) {
2004            return checkSum((byte[]) array);
2005        } else if (array instanceof char[]) {
2006            return checkSum((char[]) array);
2007        } else if (array instanceof float[]) {
2008            return checkSum((float[]) array);
2009        } else if (array instanceof double[]) {
2010            return checkSum((double[]) array);
2011        } else {
2012            fail("Unknow type of array: " + array.getClass());
2013        }
2014        throw new AssertionError(); // Needed to shut up compiler
2015    }
2016
2017    private int checkSum(int[] a) {
2018        int checkSum = 0;
2019
2020        for (int e : a) {
2021            checkSum ^= e; // xor
2022        }
2023        return checkSum;
2024    }
2025
2026    private int checkSum(long[] a) {
2027        long checkSum = 0;
2028
2029        for (long e : a) {
2030            checkSum ^= e; // xor
2031        }
2032        return (int) checkSum;
2033    }
2034
2035    private int checkSum(short[] a) {
2036        short checkSum = 0;
2037
2038        for (short e : a) {
2039            checkSum ^= e; // xor
2040        }
2041        return (int) checkSum;
2042    }
2043
2044    private int checkSum(byte[] a) {
2045        byte checkSum = 0;
2046
2047        for (byte e : a) {
2048            checkSum ^= e; // xor
2049        }
2050        return (int) checkSum;
2051    }
2052
2053    private int checkSum(char[] a) {
2054        char checkSum = 0;
2055
2056        for (char e : a) {
2057            checkSum ^= e; // xor
2058        }
2059        return (int) checkSum;
2060    }
2061
2062    private int checkSum(float[] a) {
2063        int checkSum = 0;
2064
2065        for (float e : a) {
2066            checkSum ^= (int) e; // xor
2067        }
2068        return checkSum;
2069    }
2070
2071    private int checkSum(double[] a) {
2072        int checkSum = 0;
2073
2074        for (double e : a) {
2075            checkSum ^= (int) e; // xor
2076        }
2077        return checkSum;
2078    }
2079
2080    private enum PrimitiveTypeArrayBuilder {
2081
2082        RANDOM {
2083            void build(int[] a, int m) {
2084                for (int i = 0; i < a.length; i++) {
2085                    a[i] = ourRandom.nextInt();
2086                }
2087            }
2088        },
2089
2090        ASCENDING {
2091            void build(int[] a, int m) {
2092                for (int i = 0; i < a.length; i++) {
2093                    a[i] = m + i;
2094                }
2095            }
2096        },
2097
2098        DESCENDING {
2099            void build(int[] a, int m) {
2100                for (int i = 0; i < a.length; i++) {
2101                    a[i] = a.length - m - i;
2102                }
2103            }
2104        },
2105
2106        ALL_EQUAL {
2107            void build(int[] a, int m) {
2108                for (int i = 0; i < a.length; i++) {
2109                    a[i] = m;
2110                }
2111            }
2112        },
2113
2114        SAW {
2115            void build(int[] a, int m) {
2116                int incCount = 1;
2117                int decCount = a.length;
2118                int i = 0;
2119                int period = m;
2120                m--;
2121
2122                while (true) {
2123                    for (int k = 1; k <= period; k++) {
2124                        if (i >= a.length) {
2125                            return;
2126                        }
2127                        a[i++] = incCount++;
2128                    }
2129                    period += m;
2130
2131                    for (int k = 1; k <= period; k++) {
2132                        if (i >= a.length) {
2133                            return;
2134                        }
2135                        a[i++] = decCount--;
2136                    }
2137                    period += m;
2138                }
2139            }
2140        },
2141
2142        REPEATED {
2143            void build(int[] a, int m) {
2144                for (int i = 0; i < a.length; i++) {
2145                    a[i] = i % m;
2146                }
2147            }
2148        },
2149
2150        DUPLICATED {
2151            void build(int[] a, int m) {
2152                for (int i = 0; i < a.length; i++) {
2153                    a[i] = ourRandom.nextInt(m);
2154                }
2155            }
2156        },
2157
2158        ORGAN_PIPES {
2159            void build(int[] a, int m) {
2160                int middle = a.length / (m + 1);
2161
2162                for (int i = 0; i < middle; i++) {
2163                    a[i] = i;
2164                }
2165                for (int i = middle; i < a.length ; i++) {
2166                    a[i] = a.length - i - 1;
2167                }
2168            }
2169        },
2170
2171        STAGGER {
2172            void build(int[] a, int m) {
2173                for (int i = 0; i < a.length; i++) {
2174                    a[i] = (i * m + i) % a.length;
2175                }
2176            }
2177        },
2178
2179        PLATEAU {
2180            void build(int[] a, int m) {
2181                for (int i = 0; i < a.length; i++) {
2182                    a[i] =  Math.min(i, m);
2183                }
2184            }
2185        },
2186
2187        SHUFFLE {
2188            void build(int[] a, int m) {
2189                for (int i = 0; i < a.length; i++) {
2190                    a[i] = ourRandom.nextBoolean() ? (ourFirst += 2) : (ourSecond += 2);
2191                }
2192            }
2193        };
2194
2195        abstract void build(int[] a, int m);
2196
2197        static void reset() {
2198            ourRandom = new Random(666);
2199            ourFirst = 0;
2200            ourSecond = 0;
2201        }
2202
2203        @Override
2204        public String toString() {
2205            String name = name();
2206
2207            for (int i = name.length(); i < 12; i++) {
2208                name += " " ;
2209            }
2210            return name;
2211        }
2212
2213        private static int ourFirst;
2214        private static int ourSecond;
2215        private static Random ourRandom = new Random(666);
2216    }
2217
2218    private enum PrimitiveTypeConverter {
2219
2220        INT {
2221            Object convert(int[] a) {
2222                return a;
2223            }
2224        },
2225
2226        LONG {
2227            Object convert(int[] a) {
2228                long[] b = new long[a.length];
2229
2230                for (int i = 0; i < a.length; i++) {
2231                    b[i] = (long) a[i];
2232                }
2233                return b;
2234            }
2235        },
2236
2237        BYTE {
2238            Object convert(int[] a) {
2239                byte[] b = new byte[a.length];
2240
2241                for (int i = 0; i < a.length; i++) {
2242                    b[i] = (byte) a[i];
2243                }
2244                return b;
2245            }
2246        },
2247
2248        SHORT {
2249            Object convert(int[] a) {
2250                short[] b = new short[a.length];
2251
2252                for (int i = 0; i < a.length; i++) {
2253                    b[i] = (short) a[i];
2254                }
2255                return b;
2256            }
2257        },
2258
2259        CHAR {
2260            Object convert(int[] a) {
2261                char[] b = new char[a.length];
2262
2263                for (int i = 0; i < a.length; i++) {
2264                    b[i] = (char) a[i];
2265                }
2266                return b;
2267            }
2268        },
2269
2270        FLOAT {
2271            Object convert(int[] a) {
2272                float[] b = new float[a.length];
2273
2274                for (int i = 0; i < a.length; i++) {
2275                    b[i] = (float) a[i];
2276                }
2277                return b;
2278            }
2279        },
2280
2281        DOUBLE {
2282            Object convert(int[] a) {
2283                double[] b = new double[a.length];
2284
2285                for (int i = 0; i < a.length; i++) {
2286                    b[i] = (double) a[i];
2287                }
2288                return b;
2289            }
2290        };
2291
2292        abstract Object convert(int[] a);
2293
2294        public String toString() {
2295            String name = name();
2296
2297            for (int i = name.length(); i < 9; i++) {
2298                name += " " ;
2299            }
2300            return name;
2301        }
2302    }
2303
2304
2305    /**
2306     * java.util.Arrays#deepEquals(Object[], Object[])
2307     */
2308    public void test_deepEquals$Ljava_lang_ObjectLjava_lang_Object() {
2309        int[] a1 = { 1, 2, 3 };
2310        short[] a2 = { 0, 1 };
2311        Object[] a3 = { new Integer(1), a2 };
2312        int[] a4 = { 6, 5, 4 };
2313
2314        int[] b1 = { 1, 2, 3 };
2315        short[] b2 = { 0, 1 };
2316        Object[] b3 = { new Integer(1), b2 };
2317
2318        Object a[] = { a1, a2, a3 };
2319        Object b[] = { b1, b2, b3 };
2320
2321        assertFalse(Arrays.equals(a, b));
2322        assertTrue(Arrays.deepEquals(a, b));
2323
2324        a[2] = a4;
2325
2326        assertFalse(Arrays.deepEquals(a, b));
2327    }
2328
2329    /**
2330     * java.util.Arrays#deepHashCode(Object[])
2331     */
2332    public void test_deepHashCode$Ljava_lang_Object() {
2333        int[] a1 = { 1, 2, 3 };
2334        short[] a2 = { 0, 1 };
2335        Object[] a3 = { new Integer(1), a2 };
2336
2337        int[] b1 = { 1, 2, 3 };
2338        short[] b2 = { 0, 1 };
2339        Object[] b3 = { new Integer(1), b2 };
2340
2341        Object a[] = { a1, a2, a3 };
2342        Object b[] = { b1, b2, b3 };
2343
2344        int deep_hash_a = Arrays.deepHashCode(a);
2345        int deep_hash_b = Arrays.deepHashCode(b);
2346
2347        assertEquals(deep_hash_a, deep_hash_b);
2348    }
2349
2350    /**
2351     * java.util.Arrays#hashCode(boolean[] a)
2352     */
2353    public void test_hashCode$LZ() {
2354        int listHashCode;
2355        int arrayHashCode;
2356
2357        boolean[] boolArr = { true, false, false, true, false };
2358        List listOfBoolean = new LinkedList();
2359        for (int i = 0; i < boolArr.length; i++) {
2360            listOfBoolean.add(new Boolean(boolArr[i]));
2361        }
2362        listHashCode = listOfBoolean.hashCode();
2363        arrayHashCode = Arrays.hashCode(boolArr);
2364        assertEquals(listHashCode, arrayHashCode);
2365    }
2366
2367    /**
2368     * java.util.Arrays#hashCode(int[] a)
2369     */
2370    public void test_hashCode$LI() {
2371        int listHashCode;
2372        int arrayHashCode;
2373
2374        int[] intArr = { 10, 5, 134, 7, 19 };
2375        List listOfInteger = new LinkedList();
2376
2377        for (int i = 0; i < intArr.length; i++) {
2378            listOfInteger.add(new Integer(intArr[i]));
2379        }
2380        listHashCode = listOfInteger.hashCode();
2381        arrayHashCode = Arrays.hashCode(intArr);
2382        assertEquals(listHashCode, arrayHashCode);
2383
2384        int[] intArr2 = { 10, 5, 134, 7, 19 };
2385        assertEquals(Arrays.hashCode(intArr2), Arrays.hashCode(intArr));
2386    }
2387
2388    /**
2389     * java.util.Arrays#hashCode(char[] a)
2390     */
2391    public void test_hashCode$LC() {
2392        int listHashCode;
2393        int arrayHashCode;
2394
2395        char[] charArr = { 'a', 'g', 'x', 'c', 'm' };
2396        List listOfCharacter = new LinkedList();
2397        for (int i = 0; i < charArr.length; i++) {
2398            listOfCharacter.add(new Character(charArr[i]));
2399        }
2400        listHashCode = listOfCharacter.hashCode();
2401        arrayHashCode = Arrays.hashCode(charArr);
2402        assertEquals(listHashCode, arrayHashCode);
2403    }
2404
2405    /**
2406     * java.util.Arrays#hashCode(byte[] a)
2407     */
2408    public void test_hashCode$LB() {
2409        int listHashCode;
2410        int arrayHashCode;
2411
2412        byte[] byteArr = { 5, 9, 7, 6, 17 };
2413        List listOfByte = new LinkedList();
2414        for (int i = 0; i < byteArr.length; i++) {
2415            listOfByte.add(new Byte(byteArr[i]));
2416        }
2417        listHashCode = listOfByte.hashCode();
2418        arrayHashCode = Arrays.hashCode(byteArr);
2419        assertEquals(listHashCode, arrayHashCode);
2420    }
2421
2422    /**
2423     * java.util.Arrays#hashCode(long[] a)
2424     */
2425    public void test_hashCode$LJ() {
2426        int listHashCode;
2427        int arrayHashCode;
2428
2429        long[] longArr = { 67890234512l, 97587236923425l, 257421912912l,
2430                6754268100l, 5 };
2431        List listOfLong = new LinkedList();
2432        for (int i = 0; i < longArr.length; i++) {
2433            listOfLong.add(new Long(longArr[i]));
2434        }
2435        listHashCode = listOfLong.hashCode();
2436        arrayHashCode = Arrays.hashCode(longArr);
2437        assertEquals(listHashCode, arrayHashCode);
2438    }
2439
2440    /**
2441     * java.util.Arrays#hashCode(float[] a)
2442     */
2443    public void test_hashCode$LF() {
2444        int listHashCode;
2445        int arrayHashCode;
2446
2447        float[] floatArr = { 0.13497f, 0.268934f, 12e-5f, -3e+2f, 10e-4f };
2448        List listOfFloat = new LinkedList();
2449        for (int i = 0; i < floatArr.length; i++) {
2450            listOfFloat.add(new Float(floatArr[i]));
2451        }
2452        listHashCode = listOfFloat.hashCode();
2453        arrayHashCode = Arrays.hashCode(floatArr);
2454        assertEquals(listHashCode, arrayHashCode);
2455
2456        float[] floatArr2 = { 0.13497f, 0.268934f, 12e-5f, -3e+2f, 10e-4f };
2457        assertEquals(Arrays.hashCode(floatArr2), Arrays.hashCode(floatArr));
2458    }
2459
2460    /**
2461     * java.util.Arrays#hashCode(double[] a)
2462     */
2463    public void test_hashCode$LD() {
2464        int listHashCode;
2465        int arrayHashCode;
2466
2467        double[] doubleArr = { 0.134945657, 0.0038754, 11e-150, -30e-300, 10e-4 };
2468        List listOfDouble = new LinkedList();
2469        for (int i = 0; i < doubleArr.length; i++) {
2470            listOfDouble.add(new Double(doubleArr[i]));
2471        }
2472        listHashCode = listOfDouble.hashCode();
2473        arrayHashCode = Arrays.hashCode(doubleArr);
2474        assertEquals(listHashCode, arrayHashCode);
2475    }
2476
2477    /**
2478     * java.util.Arrays#hashCode(short[] a)
2479     */
2480    public void test_hashCode$LS() {
2481        int listHashCode;
2482        int arrayHashCode;
2483
2484        short[] shortArr = { 35, 13, 45, 2, 91 };
2485        List listOfShort = new LinkedList();
2486        for (int i = 0; i < shortArr.length; i++) {
2487            listOfShort.add(new Short(shortArr[i]));
2488        }
2489        listHashCode = listOfShort.hashCode();
2490        arrayHashCode = Arrays.hashCode(shortArr);
2491        assertEquals(listHashCode, arrayHashCode);
2492    }
2493
2494    /**
2495     * java.util.Arrays#hashCode(Object[] a)
2496     */
2497    public void test_hashCode$Ljava_lang_Object() {
2498        int listHashCode;
2499        int arrayHashCode;
2500
2501        Object[] objectArr = { new Integer(1), new Float(10e-12f), null };
2502        List listOfObject = new LinkedList();
2503        for (int i = 0; i < objectArr.length; i++) {
2504            listOfObject.add(objectArr[i]);
2505        }
2506        listHashCode = listOfObject.hashCode();
2507        arrayHashCode = Arrays.hashCode(objectArr);
2508        assertEquals(listHashCode, arrayHashCode);
2509    }
2510
2511    /**
2512     * Sets up the fixture, for example, open a network connection. This method
2513     * is called before a test is executed.
2514     */
2515    protected void setUp() {
2516        objArray = new Object[arraySize];
2517        for (int i = 0; i < objArray.length; i++)
2518            objArray[i] = new Integer(i);
2519
2520        booleanArray = new boolean[arraySize];
2521        byteArray = new byte[arraySize];
2522        charArray = new char[arraySize];
2523        doubleArray = new double[arraySize];
2524        floatArray = new float[arraySize];
2525        intArray = new int[arraySize];
2526        longArray = new long[arraySize];
2527        objectArray = new Object[arraySize];
2528        shortArray = new short[arraySize];
2529
2530        for (int counter = 0; counter < arraySize; counter++) {
2531            byteArray[counter] = (byte) counter;
2532            charArray[counter] = (char) (counter + 1);
2533            doubleArray[counter] = counter;
2534            floatArray[counter] = counter;
2535            intArray[counter] = counter;
2536            longArray[counter] = counter;
2537            objectArray[counter] = objArray[counter];
2538            shortArray[counter] = (short) counter;
2539        }
2540        for (int counter = 0; counter < arraySize; counter += 2) {
2541            booleanArray[counter] = false;
2542            booleanArray[counter + 1] = true;
2543        }
2544    }
2545
2546    /**
2547     * java.util.Arrays#binarySearch(byte[], int, int, byte)
2548     */
2549    public void test_binarySearch$BIIB() {
2550        for (byte counter = 0; counter < arraySize; counter++) {
2551            assertTrue(
2552                    "Binary search on byte[] answered incorrect position",
2553                    Arrays.binarySearch(byteArray, counter, arraySize, counter) == counter);
2554        }
2555        assertEquals(
2556                "Binary search succeeded for value not present in array 1", -1,
2557                Arrays.binarySearch(byteArray, 0, arraySize, (byte) -1));
2558        assertTrue(
2559                "Binary search succeeded for value not present in array 2",
2560                Arrays.binarySearch(byteArray, (byte) arraySize) == -(arraySize + 1));
2561        for (byte counter = 0; counter < arraySize; counter++) {
2562            byteArray[counter] -= 50;
2563        }
2564        for (byte counter = 0; counter < arraySize; counter++) {
2565            assertTrue(
2566                    "Binary search on byte[] involving negative numbers answered incorrect position",
2567                    Arrays.binarySearch(byteArray, counter, arraySize,
2568                            (byte) (counter - 50)) == counter);
2569        }
2570        try {
2571            Arrays.binarySearch((byte[]) null, 2, 1, (byte) arraySize);
2572            fail("should throw NullPointerException");
2573        } catch (NullPointerException e) {
2574            // expected
2575        }
2576        try {
2577            Arrays.binarySearch((byte[]) null, -1, 0, (byte) arraySize);
2578            fail("should throw NullPointerException");
2579        } catch (NullPointerException e) {
2580            // expected
2581        }
2582        try {
2583            Arrays.binarySearch((byte[]) null, -1, -2, (byte) arraySize);
2584            fail("should throw NullPointerException");
2585        } catch (NullPointerException e) {
2586            // expected
2587        }
2588        try {
2589            Arrays.binarySearch(byteArray, 2, 1, (byte) arraySize);
2590            fail("should throw IllegalArgumentException");
2591        } catch (IllegalArgumentException e) {
2592            // expected
2593        }
2594        assertEquals(-1, Arrays.binarySearch(byteArray, 0, 0, (byte) arraySize));
2595        try {
2596            Arrays.binarySearch(byteArray, -1, -2, (byte) arraySize);
2597            fail("should throw IllegalArgumentException");
2598        } catch (IllegalArgumentException e) {
2599            // expected
2600        }
2601        try {
2602            Arrays.binarySearch(byteArray, arraySize + 2, arraySize + 1,
2603                    (byte) arraySize);
2604            fail("should throw IllegalArgumentException");
2605        } catch (IllegalArgumentException e) {
2606            // expected
2607        }
2608        try {
2609            Arrays.binarySearch(byteArray, -1, 0, (byte) arraySize);
2610            fail("should throw ArrayIndexOutOfBoundsException");
2611        } catch (ArrayIndexOutOfBoundsException e) {
2612            // expected
2613        }
2614        try {
2615            Arrays.binarySearch(byteArray, 0, arraySize + 1, (byte) arraySize);
2616            fail("should throw ArrayIndexOutOfBoundsException");
2617        } catch (ArrayIndexOutOfBoundsException e) {
2618            // expected
2619        }
2620    }
2621
2622    /**
2623     * java.util.Arrays#binarySearch(char[], char)
2624     */
2625    public void test_binarySearch$CIIC() {
2626        for (char counter = 0; counter < arraySize; counter++) {
2627            assertTrue("Binary search on char[] answered incorrect position",
2628                    Arrays.binarySearch(charArray, counter, arraySize,
2629                            (char) (counter + 1)) == counter);
2630        }
2631        assertEquals(
2632                "Binary search succeeded for value not present in array 1", -1,
2633                Arrays.binarySearch(charArray, 0, arraySize, '\u0000'));
2634        assertTrue("Binary search succeeded for value not present in array 2",
2635                Arrays.binarySearch(charArray, 0, arraySize,
2636                        (char) (arraySize + 1)) == -(arraySize + 1));
2637        try {
2638            Arrays.binarySearch(charArray, 2, 1, (char) arraySize);
2639            fail("should throw IllegalArgumentException");
2640        } catch (IllegalArgumentException e) {
2641            // expected
2642        }
2643        try {
2644            Arrays.binarySearch((char[]) null, 2, 1, (char) arraySize);
2645            fail("should throw NullPointerException");
2646        } catch (NullPointerException e) {
2647            // expected
2648        }
2649        try {
2650            Arrays.binarySearch((char[]) null, -1, 0, (char) arraySize);
2651            fail("should throw NullPointerException");
2652        } catch (NullPointerException e) {
2653            // expected
2654        }
2655        try {
2656            Arrays.binarySearch((char[]) null, -1, -2, (char) arraySize);
2657            fail("should throw NullPointerException");
2658        } catch (NullPointerException e) {
2659            // expected
2660        }
2661        assertEquals(-1, Arrays.binarySearch(charArray, 0, 0, (char) arraySize));
2662        try {
2663            Arrays.binarySearch(charArray, -1, -2, (char) arraySize);
2664            fail("should throw IllegalArgumentException");
2665        } catch (IllegalArgumentException e) {
2666            // expected
2667        }
2668        try {
2669            Arrays.binarySearch(charArray, arraySize + 2, arraySize + 1,
2670                    (char) arraySize);
2671            fail("should throw IllegalArgumentException");
2672        } catch (IllegalArgumentException e) {
2673            // expected
2674        }
2675        try {
2676            Arrays.binarySearch(charArray, -1, 0, (char) arraySize);
2677            fail("should throw ArrayIndexOutOfBoundsException");
2678        } catch (ArrayIndexOutOfBoundsException e) {
2679            // expected
2680        }
2681        try {
2682            Arrays.binarySearch(charArray, 0, arraySize + 1, (char) arraySize);
2683            fail("should throw ArrayIndexOutOfBoundsException");
2684        } catch (ArrayIndexOutOfBoundsException e) {
2685            // expected
2686        }
2687    }
2688
2689    /**
2690     * java.util.Arrays#binarySearch(double[], double)
2691     */
2692    public void test_binarySearch$DIID() {
2693        for (int counter = 0; counter < arraySize; counter++) {
2694            assertTrue("Binary search on double[] answered incorrect position",
2695                    Arrays.binarySearch(doubleArray, counter, arraySize,
2696                            (double) counter) == (double) counter);
2697        }
2698        assertEquals(
2699                "Binary search succeeded for value not present in array 1", -1,
2700                Arrays.binarySearch(doubleArray, 0, arraySize, (double) -1));
2701        assertTrue("Binary search succeeded for value not present in array 2",
2702                Arrays.binarySearch(doubleArray, 0, arraySize,
2703                        (double) arraySize) == -(arraySize + 1));
2704        for (int counter = 0; counter < arraySize; counter++) {
2705            doubleArray[counter] -= (double) 50;
2706        }
2707        for (int counter = 0; counter < arraySize; counter++) {
2708            assertTrue(
2709                    "Binary search on double[] involving negative numbers answered incorrect position",
2710                    Arrays.binarySearch(doubleArray, counter, arraySize, (double) (counter - 50)) == (double) counter);
2711        }
2712        double[] specials = new double[] { Double.NEGATIVE_INFINITY,
2713                -Double.MAX_VALUE, -2d, -Double.MIN_VALUE, -0d, 0d,
2714                Double.MIN_VALUE, 2d, Double.MAX_VALUE,
2715                Double.POSITIVE_INFINITY, Double.NaN };
2716        for (int i = 0; i < specials.length; i++) {
2717            int result = Arrays.binarySearch(specials, i, specials.length, specials[i]);
2718            assertTrue(specials[i] + " invalid: " + result, result == i);
2719        }
2720        assertEquals("-1d", -4, Arrays.binarySearch(specials, 0, specials.length, -1d));
2721        assertEquals("1d", -8, Arrays.binarySearch(specials, 0, specials.length, 1d));
2722        try {
2723            Arrays.binarySearch((double[]) null, 2, 1, (double) arraySize);
2724            fail("should throw NullPointerException");
2725        } catch (NullPointerException e) {
2726            // expected
2727        }
2728        try {
2729            Arrays.binarySearch((double[]) null, -1, 0, (double) arraySize);
2730            fail("should throw NullPointerException");
2731        } catch (NullPointerException e) {
2732            // expected
2733        }
2734        try {
2735            Arrays.binarySearch((double[]) null, -1, -2, (double) arraySize);
2736            fail("should throw NullPointerException");
2737        } catch (NullPointerException e) {
2738            // expected
2739        }
2740        try {
2741            Arrays.binarySearch(doubleArray, 2, 1, (char) arraySize);
2742            fail("should throw IllegalArgumentException");
2743        } catch (IllegalArgumentException e) {
2744            // expected
2745        }
2746        assertEquals(-1, Arrays.binarySearch(doubleArray, 0, 0, (char) arraySize));
2747        try {
2748            Arrays.binarySearch(doubleArray, -1, -2, (char) arraySize);
2749            fail("should throw IllegalArgumentException");
2750        } catch (IllegalArgumentException e) {
2751            // expected
2752        }
2753        try {
2754            Arrays.binarySearch(doubleArray, arraySize + 2, arraySize + 1,
2755                    (char) arraySize);
2756            fail("should throw IllegalArgumentException");
2757        } catch (IllegalArgumentException e) {
2758            // expected
2759        }
2760        try {
2761            Arrays.binarySearch(doubleArray, -1, 0, (char) arraySize);
2762            fail("should throw ArrayIndexOutOfBoundsException");
2763        } catch (ArrayIndexOutOfBoundsException e) {
2764            // expected
2765        }
2766        try {
2767            Arrays.binarySearch(doubleArray, 0, arraySize + 1, (char) arraySize);
2768            fail("should throw ArrayIndexOutOfBoundsException");
2769        } catch (ArrayIndexOutOfBoundsException e) {
2770            // expected
2771        }
2772    }
2773
2774    /**
2775     * java.util.Arrays#binarySearch(float[], float)
2776     */
2777    public void test_binarySearch$FIIF() {
2778        for (int counter = 0; counter < arraySize; counter++) {
2779            assertTrue("Binary search on float[] answered incorrect position",
2780                    Arrays.binarySearch(floatArray, counter, arraySize,
2781                            (float) counter) == (float) counter);
2782        }
2783        assertEquals(
2784                "Binary search succeeded for value not present in array 1", -1,
2785                Arrays.binarySearch(floatArray, 0, arraySize, (float) -1));
2786        assertTrue("Binary search succeeded for value not present in array 2",
2787                Arrays
2788                        .binarySearch(floatArray, 0, arraySize,
2789                                (float) arraySize) == -(arraySize + 1));
2790        for (int counter = 0; counter < arraySize; counter++) {
2791            floatArray[counter] -= (float) 50;
2792        }
2793        for (int counter = 0; counter < arraySize; counter++) {
2794            assertTrue(
2795                    "Binary search on float[] involving negative numbers answered incorrect position",
2796                    Arrays.binarySearch(floatArray, 0, arraySize,
2797                            (float) counter - 50) == (float) counter);
2798        }
2799        float[] specials = new float[] { Float.NEGATIVE_INFINITY,
2800                -Float.MAX_VALUE, -2f, -Float.MIN_VALUE, -0f, 0f,
2801                Float.MIN_VALUE, 2f, Float.MAX_VALUE, Float.POSITIVE_INFINITY,
2802                Float.NaN };
2803        for (int i = 0; i < specials.length; i++) {
2804            int result = Arrays.binarySearch(specials, i, specials.length, specials[i]);
2805            assertTrue(specials[i] + " invalid: " + result, result == i);
2806        }
2807        assertEquals("-1f", -4, Arrays.binarySearch(specials, 0, specials.length, -1f));
2808        assertEquals("1f", -8, Arrays.binarySearch(specials, 0, specials.length, 1f));
2809        try {
2810            Arrays.binarySearch((float[]) null, 2, 1, (float) arraySize);
2811            fail("should throw NullPointerException");
2812        } catch (NullPointerException e) {
2813            // expected
2814        }
2815        try {
2816            Arrays.binarySearch((float[]) null, -1, 0, (float) arraySize);
2817            fail("should throw NullPointerException");
2818        } catch (NullPointerException e) {
2819            // expected
2820        }
2821        try {
2822            Arrays.binarySearch((float[]) null, -1, -2, (float) arraySize);
2823            fail("should throw NullPointerException");
2824        } catch (NullPointerException e) {
2825            // expected
2826        }
2827        try {
2828            Arrays.binarySearch(floatArray, 2, 1, (char) arraySize);
2829            fail("should throw IllegalArgumentException");
2830        } catch (IllegalArgumentException e) {
2831            // expected
2832        }
2833        assertEquals(-1, Arrays.binarySearch(floatArray, 0, 0,
2834                (char) arraySize));
2835        try {
2836            Arrays.binarySearch(floatArray, -1, -2, (char) arraySize);
2837            fail("should throw IllegalArgumentException");
2838        } catch (IllegalArgumentException e) {
2839            // expected
2840        }
2841        try {
2842            Arrays.binarySearch(floatArray, arraySize + 2, arraySize + 1,
2843                    (char) arraySize);
2844            fail("should throw IllegalArgumentException");
2845        } catch (IllegalArgumentException e) {
2846            // expected
2847        }
2848        try {
2849            Arrays.binarySearch(floatArray, -1, 0, (char) arraySize);
2850            fail("should throw ArrayIndexOutOfBoundsException");
2851        } catch (ArrayIndexOutOfBoundsException e) {
2852            // expected
2853        }
2854        try {
2855            Arrays
2856                    .binarySearch(floatArray, 0, arraySize + 1,
2857                            (char) arraySize);
2858            fail("should throw ArrayIndexOutOfBoundsException");
2859        } catch (ArrayIndexOutOfBoundsException e) {
2860            // expected
2861        }
2862    }
2863
2864    /**
2865     * java.util.Arrays#binarySearch(int[], int)
2866     */
2867    public void test_binarySearch$IIII() {
2868        for (int counter = 0; counter < arraySize; counter++) {
2869            assertTrue(
2870                    "Binary search on int[] answered incorrect position",
2871                    Arrays.binarySearch(intArray, counter, arraySize, counter) == counter);
2872        }
2873        assertEquals(
2874                "Binary search succeeded for value not present in array 1", -1,
2875                Arrays.binarySearch(intArray, 0, arraySize, -1));
2876        assertTrue("Binary search succeeded for value not present in array 2",
2877                Arrays.binarySearch(intArray, 0, arraySize, arraySize) == -(arraySize + 1));
2878        for (int counter = 0; counter < arraySize; counter++) {
2879            intArray[counter] -= 50;
2880        }
2881        for (int counter = 0; counter < arraySize; counter++) {
2882            assertTrue(
2883                    "Binary search on int[] involving negative numbers answered incorrect position",
2884                    Arrays.binarySearch(intArray, 0, arraySize, counter - 50) == counter);
2885        }
2886        try {
2887            Arrays.binarySearch((int[]) null, 2, 1, (int) arraySize);
2888            fail("should throw NullPointerException");
2889        } catch (NullPointerException e) {
2890            // expected
2891        }
2892        try {
2893            Arrays.binarySearch((int[]) null, -1, 0, (int) arraySize);
2894            fail("should throw NullPointerException");
2895        } catch (NullPointerException e) {
2896            // expected
2897        }
2898        try {
2899            Arrays.binarySearch((int[]) null, -1, -2, (int) arraySize);
2900            fail("should throw NullPointerException");
2901        } catch (NullPointerException e) {
2902            // expected
2903        }
2904        try {
2905            Arrays.binarySearch(intArray, 2, 1, (char) arraySize);
2906            fail("should throw IllegalArgumentException");
2907        } catch (IllegalArgumentException e) {
2908            // expected
2909        }
2910        assertEquals(-1, Arrays
2911                .binarySearch(intArray, 0, 0, (char) arraySize));
2912        try {
2913            Arrays.binarySearch(intArray, -1, -2, (char) arraySize);
2914            fail("should throw IllegalArgumentException");
2915        } catch (IllegalArgumentException e) {
2916            // expected
2917        }
2918        try {
2919            Arrays.binarySearch(intArray, arraySize + 2, arraySize + 1,
2920                    (char) arraySize);
2921            fail("should throw IllegalArgumentException");
2922        } catch (IllegalArgumentException e) {
2923            // expected
2924        }
2925        try {
2926            Arrays.binarySearch(intArray, -1, 0, (char) arraySize);
2927            fail("should throw ArrayIndexOutOfBoundsException");
2928        } catch (ArrayIndexOutOfBoundsException e) {
2929            // expected
2930        }
2931        try {
2932            Arrays.binarySearch(intArray, 0, arraySize + 1, (char) arraySize);
2933            fail("should throw ArrayIndexOutOfBoundsException");
2934        } catch (ArrayIndexOutOfBoundsException e) {
2935            // expected
2936        }
2937    }
2938
2939    /**
2940     * java.util.Arrays#binarySearch(long[], long)
2941     */
2942    public void test_binarySearch$JIIJ() {
2943        for (long counter = 0; counter < arraySize; counter++) {
2944            assertTrue("Binary search on long[] answered incorrect position",
2945                    Arrays.binarySearch(longArray, 0, arraySize, counter) == counter);
2946        }
2947        assertEquals("Binary search succeeded for value not present in array 1",
2948                -1, Arrays.binarySearch(longArray, 0, arraySize, (long) -1));
2949        assertTrue(
2950                "Binary search succeeded for value not present in array 2",
2951                Arrays.binarySearch(longArray, 0, arraySize, (long) arraySize) == -(arraySize + 1));
2952        for (long counter = 0; counter < arraySize; counter++) {
2953            longArray[(int) counter] -= (long) 50;
2954        }
2955        for (long counter = 0; counter < arraySize; counter++) {
2956            assertTrue(
2957                    "Binary search on long[] involving negative numbers answered incorrect position",
2958                    Arrays.binarySearch(longArray, 0, arraySize, counter - (long) 50) == counter);
2959        }
2960        try {
2961            Arrays.binarySearch((long[]) null, 2, 1, (long) arraySize);
2962            fail("should throw NullPointerException");
2963        } catch (NullPointerException e) {
2964            // expected
2965        }
2966        try {
2967            Arrays.binarySearch((long[]) null, -1, 0, (long) arraySize);
2968            fail("should throw NullPointerException");
2969        } catch (NullPointerException e) {
2970            // expected
2971        }
2972        try {
2973            Arrays.binarySearch((long[]) null, -1, -2, (long) arraySize);
2974            fail("should throw NullPointerException");
2975        } catch (NullPointerException e) {
2976            // expected
2977        }
2978        try {
2979            Arrays.binarySearch(longArray, 2, 1, (char) arraySize);
2980            fail("should throw IllegalArgumentException");
2981        } catch (IllegalArgumentException e) {
2982            // expected
2983        }
2984        assertEquals(-1, Arrays
2985                .binarySearch(longArray, 0, 0, (char) arraySize));
2986        try {
2987            Arrays.binarySearch(longArray, -1, -2, (char) arraySize);
2988            fail("should throw IllegalArgumentException");
2989        } catch (IllegalArgumentException e) {
2990            // expected
2991        }
2992        try {
2993            Arrays.binarySearch(longArray, arraySize + 2, arraySize + 1,
2994                    (char) arraySize);
2995            fail("should throw IllegalArgumentException");
2996        } catch (IllegalArgumentException e) {
2997            // expected
2998        }
2999        try {
3000            Arrays.binarySearch(longArray, -1, 0, (char) arraySize);
3001            fail("should throw ArrayIndexOutOfBoundsException");
3002        } catch (ArrayIndexOutOfBoundsException e) {
3003            // expected
3004        }
3005        try {
3006            Arrays.binarySearch(longArray, 0, arraySize + 1, (char) arraySize);
3007            fail("should throw ArrayIndexOutOfBoundsException");
3008        } catch (ArrayIndexOutOfBoundsException e) {
3009            // expected
3010        }
3011    }
3012
3013    /**
3014     * java.util.Arrays#binarySearch(java.lang.Object[],
3015     *java.lang.Object)
3016     */
3017    public void test_binarySearch$Ljava_lang_ObjectIILjava_lang_Object() {
3018        assertEquals(
3019                "Binary search succeeded for non-comparable value in empty array",
3020                -1, Arrays.binarySearch(new Object[] { }, 0, 0, new Object()));
3021        assertEquals(
3022                "Binary search succeeded for comparable value in empty array",
3023                -1, Arrays.binarySearch(new Object[] { }, 0, 0, new Integer(-1)));
3024        for (int counter = 0; counter < arraySize; counter++) {
3025            assertTrue(
3026                    "Binary search on Object[] answered incorrect position",
3027                    Arrays.binarySearch(objectArray, counter, arraySize, objArray[counter]) == counter);
3028        }
3029        assertEquals("Binary search succeeded for value not present in array 1",
3030                -1, Arrays.binarySearch(objectArray, 0, arraySize, new Integer(-1)));
3031        assertTrue(
3032                "Binary search succeeded for value not present in array 2",
3033                Arrays.binarySearch(objectArray, 0, arraySize, new Integer(arraySize)) == -(arraySize + 1));
3034        try {
3035            Arrays.binarySearch((Object[]) null, 2, 1, (byte) arraySize);
3036            fail("should throw NullPointerException");
3037        } catch (NullPointerException e) {
3038            // expected
3039        }
3040        try {
3041            Arrays.binarySearch((Object[]) null, -1, 0, (byte) arraySize);
3042            fail("should throw NullPointerException");
3043        } catch (NullPointerException e) {
3044            // expected
3045        }
3046        try {
3047            Arrays.binarySearch((Object[]) null, -1, -2, (byte) arraySize);
3048            fail("should throw NullPointerException");
3049        } catch (NullPointerException e) {
3050            // expected
3051        }
3052        try {
3053            Arrays.binarySearch(objectArray, 2, 1, (char) arraySize);
3054            fail("should throw IllegalArgumentException");
3055        } catch (IllegalArgumentException e) {
3056            // expected
3057        }
3058        assertEquals(-1, Arrays
3059                .binarySearch(objectArray, 0, 0, (char) arraySize));
3060        try {
3061            Arrays.binarySearch(objectArray, -1, -2, (char) arraySize);
3062            fail("should throw IllegalArgumentException");
3063        } catch (IllegalArgumentException e) {
3064            // expected
3065        }
3066        try {
3067            Arrays.binarySearch(objectArray, arraySize + 2, arraySize + 1,
3068                    (char) arraySize);
3069            fail("should throw IllegalArgumentException");
3070        } catch (IllegalArgumentException e) {
3071            // expected
3072        }
3073        try {
3074            Arrays.binarySearch(objectArray, -1, 0, (char) arraySize);
3075            fail("should throw ArrayIndexOutOfBoundsException");
3076        } catch (ArrayIndexOutOfBoundsException e) {
3077            // expected
3078        }
3079        try {
3080            Arrays.binarySearch(objectArray, 0, arraySize + 1, (char) arraySize);
3081            fail("should throw ArrayIndexOutOfBoundsException");
3082        } catch (ArrayIndexOutOfBoundsException e) {
3083            // expected
3084        }
3085    }
3086
3087    /**
3088     * java.util.Arrays#binarySearch(java.lang.Object[],
3089     *java.lang.Object, java.util.Comparator)
3090     */
3091    public void test_binarySearch$Ljava_lang_ObjectIILjava_lang_ObjectLjava_util_Comparator() {
3092        Comparator comp = new ReversedIntegerComparator();
3093        for (int counter = 0; counter < arraySize; counter++) {
3094            objectArray[counter] = objArray[arraySize - counter - 1];
3095        }
3096        assertTrue("Binary search succeeded for value not present in array 1",
3097                Arrays.binarySearch(objectArray, 0, arraySize, new Integer(-1),
3098                        comp) == -(arraySize + 1));
3099        assertEquals(
3100                "Binary search succeeded for value not present in array 2", -1,
3101                Arrays.binarySearch(objectArray, 0, arraySize, new Integer(
3102                        arraySize), comp));
3103        for (int counter = 0; counter < arraySize; counter++) {
3104            assertTrue(
3105                    "Binary search on Object[] with custom comparator answered incorrect position",
3106                    Arrays.binarySearch(objectArray, objArray[counter], comp) == arraySize
3107                            - counter - 1);
3108        }
3109        try {
3110            Arrays.binarySearch((Object[]) null, 2, 1, (byte) arraySize);
3111            fail("should throw NullPointerException");
3112        } catch (NullPointerException e) {
3113            // expected
3114        }
3115        try {
3116            Arrays.binarySearch((Object[]) null, -1, 0, (byte) arraySize);
3117            fail("should throw NullPointerException");
3118        } catch (NullPointerException e) {
3119            // expected
3120        }
3121        try {
3122            Arrays.binarySearch((Object[]) null, -1, -2, (byte) arraySize);
3123            fail("should throw NullPointerException");
3124        } catch (NullPointerException e) {
3125            // expected
3126        }
3127        try {
3128            Arrays.binarySearch(objectArray, 2, 1, (char) arraySize, comp);
3129            fail("should throw IllegalArgumentException");
3130        } catch (IllegalArgumentException e) {
3131            // expected
3132        }
3133        assertEquals(-1, Arrays.binarySearch(objectArray, 0, 0,
3134                (char) arraySize, comp));
3135        try {
3136            Arrays.binarySearch(objectArray, -1, -2, (char) arraySize, comp);
3137            fail("should throw IllegalArgumentException");
3138        } catch (IllegalArgumentException e) {
3139            // expected
3140        }
3141        try {
3142            Arrays.binarySearch(objectArray, arraySize + 2, arraySize + 1,
3143                    (char) arraySize, comp);
3144            fail("should throw IllegalArgumentException");
3145        } catch (IllegalArgumentException e) {
3146            // expected
3147        }
3148        try {
3149            Arrays.binarySearch(objectArray, -1, 0, (char) arraySize, comp);
3150            fail("should throw ArrayIndexOutOfBoundsException");
3151        } catch (ArrayIndexOutOfBoundsException e) {
3152            // expected
3153        }
3154        try {
3155            Arrays.binarySearch(objectArray, 0, arraySize + 1,
3156                    (char) arraySize, comp);
3157            fail("should throw ArrayIndexOutOfBoundsException");
3158        } catch (ArrayIndexOutOfBoundsException e) {
3159            // expected
3160        }
3161        try {
3162            Arrays.binarySearch(objectArray, 0, arraySize,
3163                    new LinkedList(), comp);
3164            fail("should throw ClassCastException");
3165        } catch (ClassCastException e) {
3166            // expected
3167        }
3168    }
3169
3170    /**
3171     * java.util.Arrays#binarySearch(short[], short)
3172     */
3173    public void test_binarySearch$SIIS() {
3174        for (short counter = 0; counter < arraySize; counter++) {
3175            assertTrue("Binary search on short[] answered incorrect position",
3176                    Arrays.binarySearch(shortArray, counter, arraySize, counter) == counter);
3177        }
3178        assertEquals("Binary search succeeded for value not present in array 1",
3179                -1, Arrays.binarySearch(shortArray, 0, arraySize, (short) -1));
3180        assertTrue(
3181                "Binary search succeeded for value not present in array 2",
3182                Arrays.binarySearch(shortArray, 0, arraySize, (short) arraySize) == -(arraySize + 1));
3183        for (short counter = 0; counter < arraySize; counter++) {
3184            shortArray[counter] -= 50;
3185        }
3186        for (short counter = 0; counter < arraySize; counter++) {
3187            assertTrue(
3188                    "Binary search on short[] involving negative numbers answered incorrect position",
3189                    Arrays.binarySearch(shortArray, counter, arraySize, (short) (counter - 50)) == counter);
3190        }
3191        try {
3192            Arrays.binarySearch((String[]) null, 2, 1, (byte) arraySize);
3193            fail("should throw NullPointerException");
3194        } catch (NullPointerException e) {
3195            // expected
3196        }
3197        try {
3198            Arrays.binarySearch((String[]) null, -1, 0, (byte) arraySize);
3199            fail("should throw NullPointerException");
3200        } catch (NullPointerException e) {
3201            // expected
3202        }
3203        try {
3204            Arrays.binarySearch((String[]) null, -1, -2, (byte) arraySize);
3205            fail("should throw NullPointerException");
3206        } catch (NullPointerException e) {
3207            // expected
3208        }
3209        try {
3210            Arrays.binarySearch(shortArray, 2, 1, (short) arraySize);
3211            fail("should throw IllegalArgumentException");
3212        } catch (IllegalArgumentException e) {
3213            // expected
3214        }
3215        assertEquals(-1, Arrays
3216                .binarySearch(shortArray, 0, 0, (short) arraySize));
3217        try {
3218            Arrays.binarySearch(shortArray, -1, -2, (short) arraySize);
3219            fail("should throw IllegalArgumentException");
3220        } catch (IllegalArgumentException e) {
3221            // expected
3222        }
3223        try {
3224            Arrays.binarySearch(shortArray, arraySize + 2, arraySize + 1,
3225                    (short) arraySize);
3226            fail("should throw IllegalArgumentException");
3227        } catch (IllegalArgumentException e) {
3228            // expected
3229        }
3230        try {
3231            Arrays.binarySearch(shortArray, -1, 0, (short) arraySize);
3232            fail("should throw ArrayIndexOutOfBoundsException");
3233        } catch (ArrayIndexOutOfBoundsException e) {
3234            // expected
3235        }
3236        try {
3237            Arrays.binarySearch(shortArray, 0, arraySize + 1, (short) arraySize);
3238            fail("should throw ArrayIndexOutOfBoundsException");
3239        } catch (ArrayIndexOutOfBoundsException e) {
3240            // expected
3241        }
3242        String[] array = { "a", "b", "c" };
3243        assertEquals(-2, Arrays.binarySearch(array, 1, 2, "a", null));
3244    }
3245
3246    /**
3247     * {@link java.util.Arrays#copyOf(byte[], int)
3248     */
3249    public void test_copyOf_$BI() throws Exception {
3250        byte[] result = Arrays.copyOf(byteArray, arraySize * 2);
3251        int i = 0;
3252        for (; i < arraySize; i++) {
3253            assertEquals(i, result[i]);
3254        }
3255        for (; i < result.length; i++) {
3256            assertEquals(0, result[i]);
3257        }
3258        result = Arrays.copyOf(byteArray, arraySize / 2);
3259        i = 0;
3260        for (; i < result.length; i++) {
3261            assertEquals(i, result[i]);
3262        }
3263        try {
3264            Arrays.copyOf((byte[]) null, arraySize);
3265            fail("should throw NullPointerException");
3266        } catch (NullPointerException e) {
3267            // expected
3268        }
3269        try {
3270            Arrays.copyOf(byteArray, -1);
3271            fail("should throw NegativeArraySizeException");
3272        } catch (NegativeArraySizeException e) {
3273            // expected
3274        }
3275        try {
3276            Arrays.copyOf((byte[]) null, -1);
3277            fail("should throw NegativeArraySizeException");
3278        } catch (NegativeArraySizeException e) {
3279            // expected
3280        }
3281    }
3282
3283    /**
3284     * {@link java.util.Arrays#copyOf(short[], int)
3285     */
3286    public void test_copyOf_$SI() throws Exception {
3287        short[] result = Arrays.copyOf(shortArray, arraySize * 2);
3288        int i = 0;
3289        for (; i < arraySize; i++) {
3290            assertEquals(i, result[i]);
3291        }
3292        for (; i < result.length; i++) {
3293            assertEquals(0, result[i]);
3294        }
3295        result = Arrays.copyOf(shortArray, arraySize / 2);
3296        i = 0;
3297        for (; i < result.length; i++) {
3298            assertEquals(i, result[i]);
3299        }
3300        try {
3301            Arrays.copyOf((short[]) null, arraySize);
3302            fail("should throw NullPointerException");
3303        } catch (NullPointerException e) {
3304            // expected
3305        }
3306        try {
3307            Arrays.copyOf(shortArray, -1);
3308            fail("should throw NegativeArraySizeException");
3309        } catch (NegativeArraySizeException e) {
3310            // expected
3311        }
3312        try {
3313            Arrays.copyOf((short[]) null, -1);
3314            fail("should throw NegativeArraySizeException");
3315        } catch (NegativeArraySizeException e) {
3316            // expected
3317        }
3318    }
3319
3320    /**
3321     * {@link java.util.Arrays#copyOf(int[], int)
3322     */
3323    public void test_copyOf_$II() throws Exception {
3324        int[] result = Arrays.copyOf(intArray, arraySize * 2);
3325        int i = 0;
3326        for (; i < arraySize; i++) {
3327            assertEquals(i, result[i]);
3328        }
3329        for (; i < result.length; i++) {
3330            assertEquals(0, result[i]);
3331        }
3332        result = Arrays.copyOf(intArray, arraySize / 2);
3333        i = 0;
3334        for (; i < result.length; i++) {
3335            assertEquals(i, result[i]);
3336        }
3337        try {
3338            Arrays.copyOf((int[]) null, arraySize);
3339            fail("should throw NullPointerException");
3340        } catch (NullPointerException e) {
3341            // expected
3342        }
3343        try {
3344            Arrays.copyOf(intArray, -1);
3345            fail("should throw NegativeArraySizeException");
3346        } catch (NegativeArraySizeException e) {
3347            // expected
3348        }
3349        try {
3350            Arrays.copyOf((int[]) null, -1);
3351            fail("should throw NegativeArraySizeException");
3352        } catch (NegativeArraySizeException e) {
3353            // expected
3354        }
3355    }
3356
3357    /**
3358     * {@link java.util.Arrays#copyOf(boolean[], int)
3359     */
3360    public void test_copyOf_$ZI() throws Exception {
3361        boolean[] result = Arrays.copyOf(booleanArray, arraySize * 2);
3362        int i = 0;
3363        for (; i < arraySize; i++) {
3364            assertEquals(booleanArray[i], result[i]);
3365        }
3366        for (; i < result.length; i++) {
3367            assertEquals(false, result[i]);
3368        }
3369        result = Arrays.copyOf(booleanArray, arraySize / 2);
3370        i = 0;
3371        for (; i < result.length; i++) {
3372            assertEquals(booleanArray[i], result[i]);
3373        }
3374        try {
3375            Arrays.copyOf((boolean[]) null, arraySize);
3376            fail("should throw NullPointerException");
3377        } catch (NullPointerException e) {
3378            // expected
3379        }
3380        try {
3381            Arrays.copyOf(booleanArray, -1);
3382            fail("should throw NegativeArraySizeException");
3383        } catch (NegativeArraySizeException e) {
3384            // expected
3385        }
3386        try {
3387            Arrays.copyOf((boolean[]) null, -1);
3388            fail("should throw NegativeArraySizeException");
3389        } catch (NegativeArraySizeException e) {
3390            // expected
3391        }
3392    }
3393
3394    /**
3395     * {@link java.util.Arrays#copyOf(char[], int)
3396     */
3397    public void test_copyOf_$CI() throws Exception {
3398        char[] result = Arrays.copyOf(charArray, arraySize * 2);
3399        int i = 0;
3400        for (; i < arraySize; i++) {
3401            assertEquals(i + 1, result[i]);
3402        }
3403        for (; i < result.length; i++) {
3404            assertEquals(0, result[i]);
3405        }
3406        result = Arrays.copyOf(charArray, arraySize / 2);
3407        i = 0;
3408        for (; i < result.length; i++) {
3409            assertEquals(i + 1, result[i]);
3410        }
3411        try {
3412            Arrays.copyOf((char[]) null, arraySize);
3413            fail("should throw NullPointerException");
3414        } catch (NullPointerException e) {
3415            // expected
3416        }
3417        try {
3418            Arrays.copyOf(charArray, -1);
3419            fail("should throw NegativeArraySizeException");
3420        } catch (NegativeArraySizeException e) {
3421            // expected
3422        }
3423        try {
3424            Arrays.copyOf((char[]) null, -1);
3425            fail("should throw NegativeArraySizeException");
3426        } catch (NegativeArraySizeException e) {
3427            // expected
3428        }
3429    }
3430
3431    /**
3432     * {@link java.util.Arrays#copyOf(float[], int)
3433     */
3434    public void test_copyOf_$FI() throws Exception {
3435        float[] result = Arrays.copyOf(floatArray, arraySize * 2);
3436        int i = 0;
3437        for (; i < arraySize; i++) {
3438            assertEquals(floatArray[i], result[i]);
3439        }
3440        for (; i < result.length; i++) {
3441            assertEquals(0.0f, result[i]);
3442        }
3443        result = Arrays.copyOf(floatArray, arraySize / 2);
3444        i = 0;
3445        for (; i < result.length; i++) {
3446            assertEquals(floatArray[i], result[i]);
3447        }
3448        try {
3449            Arrays.copyOf((float[]) null, arraySize);
3450            fail("should throw NullPointerException");
3451        } catch (NullPointerException e) {
3452            // expected
3453        }
3454        try {
3455            Arrays.copyOf(floatArray, -1);
3456            fail("should throw NegativeArraySizeException");
3457        } catch (NegativeArraySizeException e) {
3458            // expected
3459        }
3460        try {
3461            Arrays.copyOf((float[]) null, -1);
3462            fail("should throw NegativeArraySizeException");
3463        } catch (NegativeArraySizeException e) {
3464            // expected
3465        }
3466    }
3467
3468    /**
3469     * {@link java.util.Arrays#copyOf(double[], int)
3470     */
3471    public void test_copyOf_$DI() throws Exception {
3472        double[] result = Arrays.copyOf(doubleArray, arraySize * 2);
3473        int i = 0;
3474        for (; i < arraySize; i++) {
3475            assertEquals(doubleArray[i], result[i]);
3476        }
3477        for (; i < result.length; i++) {
3478            assertEquals(0.0, result[i]);
3479        }
3480        result = Arrays.copyOf(doubleArray, arraySize / 2);
3481        i = 0;
3482        for (; i < result.length; i++) {
3483            assertEquals(doubleArray[i], result[i]);
3484        }
3485        try {
3486            Arrays.copyOf((double[]) null, arraySize);
3487            fail("should throw NullPointerException");
3488        } catch (NullPointerException e) {
3489            // expected
3490        }
3491        try {
3492            Arrays.copyOf(doubleArray, -1);
3493            fail("should throw NegativeArraySizeException");
3494        } catch (NegativeArraySizeException e) {
3495            // expected
3496        }
3497        try {
3498            Arrays.copyOf((double[]) null, -1);
3499            fail("should throw NegativeArraySizeException");
3500        } catch (NegativeArraySizeException e) {
3501            // expected
3502        }
3503    }
3504
3505    /**
3506     * {@link java.util.Arrays#copyOf(long[], int)
3507     */
3508    public void test_copyOf_$JI() throws Exception {
3509        long[] result = Arrays.copyOf(longArray, arraySize * 2);
3510        int i = 0;
3511        for (; i < arraySize; i++) {
3512            assertEquals(longArray[i], result[i]);
3513        }
3514        for (; i < result.length; i++) {
3515            assertEquals(0, result[i]);
3516        }
3517        result = Arrays.copyOf(longArray, arraySize / 2);
3518        i = 0;
3519        for (; i < result.length; i++) {
3520            assertEquals(longArray[i], result[i]);
3521        }
3522        try {
3523            Arrays.copyOf((long[]) null, arraySize);
3524            fail("should throw NullPointerException");
3525        } catch (NullPointerException e) {
3526            // expected
3527        }
3528        try {
3529            Arrays.copyOf(longArray, -1);
3530            fail("should throw NegativeArraySizeException");
3531        } catch (NegativeArraySizeException e) {
3532            // expected
3533        }
3534        try {
3535            Arrays.copyOf((long[]) null, -1);
3536            fail("should throw NegativeArraySizeException");
3537        } catch (NegativeArraySizeException e) {
3538            // expected
3539        }
3540    }
3541
3542    /**
3543     * {@link java.util.Arrays#copyOf(T[], int)
3544     */
3545    public void test_copyOf_$TI() throws Exception {
3546        Object[] result = Arrays.copyOf(objArray, arraySize * 2);
3547        int i = 0;
3548        for (; i < arraySize; i++) {
3549            assertEquals(objArray[i], result[i]);
3550        }
3551        for (; i < result.length; i++) {
3552            assertNull(result[i]);
3553        }
3554        result = Arrays.copyOf(objArray, arraySize / 2);
3555        i = 0;
3556        for (; i < result.length; i++) {
3557            assertEquals(objArray[i], result[i]);
3558        }
3559        try {
3560            Arrays.copyOf((String[]) null, arraySize);
3561            fail("should throw NullPointerException");
3562        } catch (NullPointerException e) {
3563            // expected
3564        }
3565        try {
3566            Arrays.copyOf(objArray, -1);
3567            fail("should throw NegativeArraySizeException");
3568        } catch (NegativeArraySizeException e) {
3569            // expected
3570        }
3571        try {
3572            Arrays.copyOf((String[]) null, -1);
3573            fail("should throw NullPointerException");
3574        } catch (NullPointerException e) {
3575            // expected
3576        }
3577
3578        Date[] component = new Date[0];
3579        Object object[] = new Date[0];
3580
3581        object = Arrays.copyOf(component, 2);
3582        assertNotNull(object);
3583        component = Arrays.copyOf(component, 2);
3584        assertNotNull(component);
3585        assertEquals(2, component.length);
3586    }
3587
3588    /**
3589     * {@link java.util.Arrays#copyOf(T[], int, Class<? extends Object[]>))
3590     */
3591    public void test_copyOf_$TILClass() throws Exception {
3592        Object[] result = Arrays.copyOf(objArray, arraySize * 2, Object[].class);
3593        int i = 0;
3594        for (; i < arraySize; i++) {
3595            assertEquals(objArray[i], result[i]);
3596        }
3597        for (; i < result.length; i++) {
3598            assertNull(result[i]);
3599        }
3600        result = Arrays.copyOf(objArray, arraySize / 2, Object[].class);
3601        i = 0;
3602        for (; i < result.length; i++) {
3603            assertEquals(objArray[i], result[i]);
3604        }
3605        result = Arrays.copyOf(objArray, arraySize / 2, Integer[].class);
3606        i = 0;
3607        for (; i < result.length; i++) {
3608            assertEquals(objArray[i], result[i]);
3609        }
3610        try {
3611            Arrays.copyOf((Object[]) null, arraySize, LinkedList[].class);
3612            fail("should throw NullPointerException");
3613        } catch (NullPointerException e) {
3614            // expected
3615        }
3616        try {
3617            Arrays.copyOf(objArray, arraySize, LinkedList[].class);
3618            fail("should throw ArrayStoreException ");
3619        } catch (ArrayStoreException e) {
3620            // expected
3621        }
3622        try {
3623            Arrays.copyOf((Object[]) null, arraySize, Object[].class);
3624            fail("should throw NullPointerException");
3625        } catch (NullPointerException e) {
3626            // expected
3627        }
3628        try {
3629            Arrays.copyOf(objArray, -1, Object[].class);
3630            fail("should throw NegativeArraySizeException");
3631        } catch (NegativeArraySizeException e) {
3632            // expected
3633        }
3634        try {
3635            Arrays.copyOf((Object[]) null, -1, Object[].class);
3636            fail("should throw NegativeArraySizeException");
3637        } catch (NegativeArraySizeException e) {
3638            // expected
3639        }
3640        try {
3641            Arrays.copyOf((Object[]) null, -1, LinkedList[].class);
3642            fail("should throw NegativeArraySizeException");
3643        } catch (NegativeArraySizeException e) {
3644            // expected
3645        }
3646        try {
3647            Arrays.copyOf((Object[]) null, 0, LinkedList[].class);
3648            fail("should throw NullPointerException");
3649        } catch (NullPointerException e) {
3650            // expected
3651        }
3652        assertEquals(0, Arrays.copyOf(objArray, 0, LinkedList[].class).length);
3653    }
3654
3655    /**
3656     * {@link java.util.Arrays#copyOfRange(byte[], int, int)
3657     */
3658    public void test_copyOfRange_$BII() throws Exception {
3659        byte[] result = Arrays.copyOfRange(byteArray, 0, arraySize * 2);
3660        int i = 0;
3661        for (; i < arraySize; i++) {
3662            assertEquals(i, result[i]);
3663        }
3664        for (; i < result.length; i++) {
3665            assertEquals(0, result[i]);
3666        }
3667        result = Arrays.copyOfRange(byteArray, 0, arraySize / 2);
3668        i = 0;
3669        for (; i < result.length; i++) {
3670            assertEquals(i, result[i]);
3671        }
3672        result = Arrays.copyOfRange(byteArray, 0, 0);
3673        assertEquals(0, result.length);
3674        try {
3675            Arrays.copyOfRange((byte[]) null, 0, arraySize);
3676            fail("should throw NullPointerException");
3677        } catch (NullPointerException e) {
3678            // expected
3679        }
3680        try {
3681            Arrays.copyOfRange((byte[]) null, -1, arraySize);
3682            fail("should throw NullPointerException");
3683        } catch (NullPointerException e) {
3684            // expected
3685        }
3686        try {
3687            Arrays.copyOfRange((byte[]) null, 0, -1);
3688            fail("should throw IllegalArgumentException");
3689        } catch (IllegalArgumentException e) {
3690            // expected
3691        }
3692        try {
3693            Arrays.copyOfRange(byteArray, -1, arraySize);
3694            fail("should throw ArrayIndexOutOfBoundsException");
3695        } catch (ArrayIndexOutOfBoundsException e) {
3696            // expected
3697        }
3698        try {
3699            Arrays.copyOfRange(byteArray, 0, -1);
3700            fail("should throw IllegalArgumentException");
3701        } catch (IllegalArgumentException e) {
3702            // expected
3703        }
3704        assertEquals(byteArray.length + 1, Arrays.copyOfRange(byteArray, 0,
3705                byteArray.length + 1).length);
3706    }
3707
3708    /**
3709     * {@link java.util.Arrays#copyOfRange(short[], int, int)
3710     */
3711    public void test_copyOfRange_$SII() throws Exception {
3712        short[] result = Arrays.copyOfRange(shortArray, 0, arraySize * 2);
3713        int i = 0;
3714        for (; i < arraySize; i++) {
3715            assertEquals(i, result[i]);
3716        }
3717        for (; i < result.length; i++) {
3718            assertEquals(0, result[i]);
3719        }
3720        result = Arrays.copyOfRange(shortArray, 0, arraySize / 2);
3721        i = 0;
3722        for (; i < result.length; i++) {
3723            assertEquals(i, result[i]);
3724        }
3725        result = Arrays.copyOfRange(shortArray, 0, 0);
3726        assertEquals(0, result.length);
3727        try {
3728            Arrays.copyOfRange((short[]) null, 0, arraySize);
3729            fail("should throw NullPointerException");
3730        } catch (NullPointerException e) {
3731            // expected
3732        }
3733        try {
3734            Arrays.copyOfRange((short[]) null, -1, arraySize);
3735            fail("should throw NullPointerException");
3736        } catch (NullPointerException e) {
3737            // expected
3738        }
3739        try {
3740            Arrays.copyOfRange((short[]) null, 0, -1);
3741            fail("should throw IllegalArgumentException");
3742        } catch (IllegalArgumentException e) {
3743            // expected
3744        }
3745        try {
3746            Arrays.copyOfRange(shortArray, -1, arraySize);
3747            fail("should throw ArrayIndexOutOfBoundsException");
3748        } catch (ArrayIndexOutOfBoundsException e) {
3749            // expected
3750        }
3751        try {
3752            Arrays.copyOfRange(shortArray, 0, -1);
3753            fail("should throw IllegalArgumentException");
3754        } catch (IllegalArgumentException e) {
3755            // expected
3756        }
3757        assertEquals(shortArray.length + 1, Arrays.copyOfRange(shortArray, 0,
3758                shortArray.length + 1).length);
3759    }
3760
3761    /**
3762     * {@link java.util.Arrays#copyOfRange(int[], int, int)
3763     */
3764    public void test_copyOfRange_$III() throws Exception {
3765        int[] result = Arrays.copyOfRange(intArray, 0, arraySize * 2);
3766        int i = 0;
3767        for (; i < arraySize; i++) {
3768            assertEquals(i, result[i]);
3769        }
3770        for (; i < result.length; i++) {
3771            assertEquals(0, result[i]);
3772        }
3773        result = Arrays.copyOfRange(intArray, 0, arraySize / 2);
3774        i = 0;
3775        for (; i < result.length; i++) {
3776            assertEquals(i, result[i]);
3777        }
3778        result = Arrays.copyOfRange(intArray, 0, 0);
3779        assertEquals(0, result.length);
3780        try {
3781            Arrays.copyOfRange((int[]) null, 0, arraySize);
3782            fail("should throw NullPointerException");
3783        } catch (NullPointerException e) {
3784            // expected
3785        }
3786        try {
3787            Arrays.copyOfRange((int[]) null, -1, arraySize);
3788            fail("should throw NullPointerException");
3789        } catch (NullPointerException e) {
3790            // expected
3791        }
3792        try {
3793            Arrays.copyOfRange((int[]) null, 0, -1);
3794            fail("should throw IllegalArgumentException");
3795        } catch (IllegalArgumentException e) {
3796            // expected
3797        }
3798        try {
3799            Arrays.copyOfRange(intArray, -1, arraySize);
3800            fail("should throw ArrayIndexOutOfBoundsException");
3801        } catch (ArrayIndexOutOfBoundsException e) {
3802            // expected
3803        }
3804        try {
3805            Arrays.copyOfRange(intArray, 0, -1);
3806            fail("should throw IllegalArgumentException");
3807        } catch (IllegalArgumentException e) {
3808            // expected
3809        }
3810        assertEquals(intArray.length + 1, Arrays.copyOfRange(intArray, 0,
3811                intArray.length + 1).length);
3812    }
3813
3814    /**
3815     * {@link java.util.Arrays#copyOfRange(long[], int, int)
3816     */
3817    public void test_copyOfRange_$JII() throws Exception {
3818        long[] result = Arrays.copyOfRange(longArray, 0, arraySize * 2);
3819        int i = 0;
3820        for (; i < arraySize; i++) {
3821            assertEquals(i, result[i]);
3822        }
3823        for (; i < result.length; i++) {
3824            assertEquals(0, result[i]);
3825        }
3826        result = Arrays.copyOfRange(longArray, 0, arraySize / 2);
3827        i = 0;
3828        for (; i < result.length; i++) {
3829            assertEquals(i, result[i]);
3830        }
3831        result = Arrays.copyOfRange(longArray, 0, 0);
3832        assertEquals(0, result.length);
3833        try {
3834            Arrays.copyOfRange((long[]) null, 0, arraySize);
3835            fail("should throw NullPointerException");
3836        } catch (NullPointerException e) {
3837            // expected
3838        }
3839        try {
3840            Arrays.copyOfRange((long[]) null, -1, arraySize);
3841            fail("should throw NullPointerException");
3842        } catch (NullPointerException e) {
3843            // expected
3844        }
3845        try {
3846            Arrays.copyOfRange((long[]) null, 0, -1);
3847            fail("should throw IllegalArgumentException");
3848        } catch (IllegalArgumentException e) {
3849            // expected
3850        }
3851        try {
3852            Arrays.copyOfRange(longArray, -1, arraySize);
3853            fail("should throw ArrayIndexOutOfBoundsException");
3854        } catch (ArrayIndexOutOfBoundsException e) {
3855            // expected
3856        }
3857        try {
3858            Arrays.copyOfRange(longArray, 0, -1);
3859            fail("should throw IllegalArgumentException");
3860        } catch (IllegalArgumentException e) {
3861            // expected
3862        }
3863        assertEquals(longArray.length + 1, Arrays.copyOfRange(longArray, 0,
3864                longArray.length + 1).length);
3865    }
3866
3867    /**
3868     * {@link java.util.Arrays#copyOfRange(char[], int, int)
3869     */
3870    public void test_copyOfRange_$CII() throws Exception {
3871        char[] result = Arrays.copyOfRange(charArray, 0, arraySize * 2);
3872        int i = 0;
3873        for (; i < arraySize; i++) {
3874            assertEquals(i + 1, result[i]);
3875        }
3876        for (; i < result.length; i++) {
3877            assertEquals(0, result[i]);
3878        }
3879        result = Arrays.copyOfRange(charArray, 0, arraySize / 2);
3880        i = 0;
3881        for (; i < result.length; i++) {
3882            assertEquals(i + 1, result[i]);
3883        }
3884        result = Arrays.copyOfRange(charArray, 0, 0);
3885        assertEquals(0, result.length);
3886        try {
3887            Arrays.copyOfRange((char[]) null, 0, arraySize);
3888            fail("should throw NullPointerException");
3889        } catch (NullPointerException e) {
3890            // expected
3891        }
3892        try {
3893            Arrays.copyOfRange((char[]) null, -1, arraySize);
3894            fail("should throw NullPointerException");
3895        } catch (NullPointerException e) {
3896            // expected
3897        }
3898        try {
3899            Arrays.copyOfRange((char[]) null, 0, -1);
3900            fail("should throw IllegalArgumentException");
3901        } catch (IllegalArgumentException e) {
3902            // expected
3903        }
3904        try {
3905            Arrays.copyOfRange(charArray, -1, arraySize);
3906            fail("should throw ArrayIndexOutOfBoundsException");
3907        } catch (ArrayIndexOutOfBoundsException e) {
3908            // expected
3909        }
3910        try {
3911            Arrays.copyOfRange(charArray, 0, -1);
3912            fail("should throw IllegalArgumentException");
3913        } catch (IllegalArgumentException e) {
3914            // expected
3915        }
3916        assertEquals(charArray.length + 1, Arrays.copyOfRange(charArray, 0,
3917                charArray.length + 1).length);
3918    }
3919
3920    public void test_copyOfRange_$FII() throws Exception {
3921        float[] result = Arrays.copyOfRange(floatArray, 0, arraySize * 2);
3922        int i = 0;
3923        for (; i < arraySize; i++) {
3924            assertEquals((float) i, result[i]);
3925        }
3926        for (; i < result.length; i++) {
3927            assertEquals(0.0f, result[i]);
3928        }
3929        result = Arrays.copyOfRange(floatArray, 0, arraySize / 2);
3930        i = 0;
3931        for (; i < result.length; i++) {
3932            assertEquals((float) i, result[i]);
3933        }
3934        result = Arrays.copyOfRange(floatArray, 0, 0);
3935        assertEquals(0, result.length);
3936        try {
3937            Arrays.copyOfRange((float[]) null, 0, arraySize);
3938            fail("should throw NullPointerException");
3939        } catch (NullPointerException e) {
3940            // expected
3941        }
3942        try {
3943            Arrays.copyOfRange((float[]) null, -1, arraySize);
3944            fail("should throw NullPointerException");
3945        } catch (NullPointerException e) {
3946            // expected
3947        }
3948        try {
3949            Arrays.copyOfRange((float[]) null, 0, -1);
3950            fail("should throw IllegalArgumentException");
3951        } catch (IllegalArgumentException e) {
3952            // expected
3953        }
3954        try {
3955            Arrays.copyOfRange(floatArray, -1, arraySize);
3956            fail("should throw ArrayIndexOutOfBoundsException");
3957        } catch (ArrayIndexOutOfBoundsException e) {
3958            // expected
3959        }
3960        try {
3961            Arrays.copyOfRange(floatArray, 0, -1);
3962            fail("should throw IllegalArgumentException");
3963        } catch (IllegalArgumentException e) {
3964            // expected
3965        }
3966        assertEquals(floatArray.length + 1, Arrays.copyOfRange(floatArray, 0,
3967                floatArray.length + 1).length);
3968    }
3969
3970    /**
3971     * {@link java.util.Arrays#copyOfRange(double[], int, int)
3972     */
3973    public void test_copyOfRange_$DII() throws Exception {
3974        double[] result = Arrays.copyOfRange(doubleArray, 0, arraySize * 2);
3975        int i = 0;
3976        for (; i < arraySize; i++) {
3977            assertEquals((double) i, result[i]);
3978        }
3979        for (; i < result.length; i++) {
3980            assertEquals(0.0, result[i]);
3981        }
3982        result = Arrays.copyOfRange(doubleArray, 0, arraySize / 2);
3983        i = 0;
3984        for (; i < result.length; i++) {
3985            assertEquals((double) i, result[i]);
3986        }
3987        result = Arrays.copyOfRange(doubleArray, 0, 0);
3988        assertEquals(0, result.length);
3989        try {
3990            Arrays.copyOfRange((double[]) null, 0, arraySize);
3991            fail("should throw NullPointerException");
3992        } catch (NullPointerException e) {
3993            // expected
3994        }
3995        try {
3996            Arrays.copyOfRange((double[]) null, -1, arraySize);
3997            fail("should throw NullPointerException");
3998        } catch (NullPointerException e) {
3999            // expected
4000        }
4001        try {
4002            Arrays.copyOfRange((double[]) null, 0, -1);
4003            fail("should throw IllegalArgumentException");
4004        } catch (IllegalArgumentException e) {
4005            // expected
4006        }
4007        try {
4008            Arrays.copyOfRange(doubleArray, -1, arraySize);
4009            fail("should throw ArrayIndexOutOfBoundsException");
4010        } catch (ArrayIndexOutOfBoundsException e) {
4011            // expected
4012        }
4013        try {
4014            Arrays.copyOfRange(doubleArray, 0, -1);
4015            fail("should throw IllegalArgumentException");
4016        } catch (IllegalArgumentException e) {
4017            // expected
4018        }
4019        assertEquals(doubleArray.length + 1, Arrays.copyOfRange(doubleArray, 0,
4020                doubleArray.length + 1).length);
4021    }
4022
4023    /**
4024     * {@link java.util.Arrays#copyOfRange(boolean[], int, int)
4025     */
4026    public void test_copyOfRange_$ZII() throws Exception {
4027        boolean[] result = Arrays.copyOfRange(booleanArray, 0, arraySize * 2);
4028        int i = 0;
4029        for (; i < arraySize; i++) {
4030            assertEquals(booleanArray[i], result[i]);
4031        }
4032        for (; i < result.length; i++) {
4033            assertEquals(false, result[i]);
4034        }
4035        result = Arrays.copyOfRange(booleanArray, 0, arraySize / 2);
4036        i = 0;
4037        for (; i < result.length; i++) {
4038            assertEquals(booleanArray[i], result[i]);
4039        }
4040        result = Arrays.copyOfRange(booleanArray, 0, 0);
4041        assertEquals(0, result.length);
4042        try {
4043            Arrays.copyOfRange((boolean[]) null, 0, arraySize);
4044            fail("should throw NullPointerException");
4045        } catch (NullPointerException e) {
4046            // expected
4047        }
4048        try {
4049            Arrays.copyOfRange((boolean[]) null, -1, arraySize);
4050            fail("should throw NullPointerException");
4051        } catch (NullPointerException e) {
4052            // expected
4053        }
4054        try {
4055            Arrays.copyOfRange((boolean[]) null, 0, -1);
4056            fail("should throw IllegalArgumentException");
4057        } catch (IllegalArgumentException e) {
4058            // expected
4059        }
4060        try {
4061            Arrays.copyOfRange(booleanArray, -1, arraySize);
4062            fail("should throw ArrayIndexOutOfBoundsException");
4063        } catch (ArrayIndexOutOfBoundsException e) {
4064            // expected
4065        }
4066        try {
4067            Arrays.copyOfRange(booleanArray, 0, -1);
4068            fail("should throw IllegalArgumentException");
4069        } catch (IllegalArgumentException e) {
4070            // expected
4071        }
4072        assertEquals(booleanArray.length + 1, Arrays.copyOfRange(booleanArray, 0,
4073                booleanArray.length + 1).length);
4074    }
4075
4076    /**
4077     * {@link java.util.Arrays#copyOfRange(Object[], int, int)
4078     */
4079    public void test_copyOfRange_$TII() throws Exception {
4080        Object[] result = Arrays.copyOfRange(objArray, 0, arraySize * 2);
4081        int i = 0;
4082        for (; i < arraySize; i++) {
4083            assertEquals(objArray[i], result[i]);
4084        }
4085        for (; i < result.length; i++) {
4086            assertEquals(null, result[i]);
4087        }
4088        result = Arrays.copyOfRange(objArray, 0, arraySize / 2);
4089        i = 0;
4090        for (; i < result.length; i++) {
4091            assertEquals(objArray[i], result[i]);
4092        }
4093        result = Arrays.copyOfRange(objArray, 0, 0);
4094        assertEquals(0, result.length);
4095        try {
4096            Arrays.copyOfRange((Object[]) null, 0, arraySize);
4097            fail("should throw NullPointerException");
4098        } catch (NullPointerException e) {
4099            // expected
4100        }
4101        try {
4102            Arrays.copyOfRange((Object[]) null, -1, arraySize);
4103            fail("should throw NullPointerException");
4104        } catch (NullPointerException e) {
4105            // expected
4106        }
4107        try {
4108            Arrays.copyOfRange((Object[]) null, 0, -1);
4109            fail("should throw NullPointerException");
4110        } catch (NullPointerException e) {
4111            // expected
4112        }
4113        try {
4114            Arrays.copyOfRange((Object[]) objArray, -1, arraySize);
4115            fail("should throw ArrayIndexOutOfBoundsException");
4116        } catch (ArrayIndexOutOfBoundsException e) {
4117            // expected
4118        }
4119        try {
4120            Arrays.copyOfRange((Object[]) objArray, 0, -1);
4121            fail("should throw IllegalArgumentException");
4122        } catch (IllegalArgumentException e) {
4123            // expected
4124        }
4125        assertEquals(objArray.length + 1, Arrays.copyOfRange(objArray, 0,
4126                objArray.length + 1).length);
4127    }
4128
4129    public void test_copyOfRange_$TIILClass() throws Exception {
4130        Object[] result = Arrays.copyOfRange(objArray, 0, arraySize * 2, Integer[].class);
4131        int i = 0;
4132        for (; i < arraySize; i++) {
4133            assertEquals(objArray[i], result[i]);
4134        }
4135        for (; i < result.length; i++) {
4136            assertEquals(null, result[i]);
4137        }
4138        result = Arrays.copyOfRange(objArray, 0, arraySize / 2, Integer[].class);
4139        i = 0;
4140        for (; i < result.length; i++) {
4141            assertEquals(objArray[i], result[i]);
4142        }
4143        result = Arrays.copyOfRange(objArray, 0, 0, Integer[].class);
4144        assertEquals(0, result.length);
4145        try {
4146            Arrays.copyOfRange(null, 0, arraySize, Integer[].class);
4147            fail("should throw NullPointerException");
4148        } catch (NullPointerException e) {
4149            // expected
4150        }
4151        try {
4152            Arrays.copyOfRange(null, -1, arraySize, Integer[].class);
4153            fail("should throw NullPointerException");
4154        } catch (NullPointerException e) {
4155            // expected
4156        }
4157        try {
4158            Arrays.copyOfRange(null, 0, -1, Integer[].class);
4159            fail("should throw IllegalArgumentException");
4160        } catch (IllegalArgumentException e) {
4161            // expected
4162        }
4163        try {
4164            Arrays.copyOfRange(objArray, -1, arraySize, Integer[].class);
4165            fail("should throw ArrayIndexOutOfBoundsException");
4166        } catch (ArrayIndexOutOfBoundsException e) {
4167            // expected
4168        }
4169        try {
4170            Arrays.copyOfRange(objArray, 0, -1, Integer[].class);
4171            fail("should throw IllegalArgumentException");
4172        } catch (IllegalArgumentException e) {
4173            // expected
4174        }
4175        try {
4176            Arrays.copyOfRange(objArray, 0, -1, LinkedList[].class);
4177            fail("should throw IllegalArgumentException");
4178        } catch (IllegalArgumentException e) {
4179            // expected
4180        }
4181        try {
4182            Arrays.copyOfRange(objArray, 0, 1, LinkedList[].class);
4183            fail("should throw ArrayStoreException");
4184        } catch (ArrayStoreException e) {
4185            // expected
4186        }
4187        try {
4188            Arrays.copyOfRange(null, 0, 1, LinkedList[].class);
4189            fail("should throw NullPointerException");
4190        } catch (NullPointerException e) {
4191            // expected
4192        }
4193        try {
4194            assertEquals(objArray.length + 1, Arrays.copyOfRange(objArray, 0,
4195                    objArray.length + 1, LinkedList[].class).length);
4196            fail("should throw ArrayStoreException");
4197        } catch (ArrayStoreException e) {
4198            // expected
4199        }
4200        assertEquals(0,
4201                Arrays.copyOfRange(objArray, 0, 0, LinkedList[].class).length);
4202    }
4203
4204    public void test_asList_spliterator() {
4205        List<String> list = Arrays.asList(
4206                "a", "b", "c", "d", "e", "f", "g", "h",
4207                "i", "j", "k", "l", "m", "n", "o", "p");
4208        ArrayList<String> expected = new ArrayList<>(list);
4209
4210        SpliteratorTester.runBasicIterationTests(list.spliterator(), expected);
4211        SpliteratorTester.runBasicSplitTests(list, expected);
4212        SpliteratorTester.testSpliteratorNPE(list.spliterator());
4213
4214        assertTrue(list.spliterator().hasCharacteristics(Spliterator.ORDERED));
4215
4216        SpliteratorTester.runOrderedTests(list);
4217        SpliteratorTester.assertSupportsTrySplit(list);
4218    }
4219
4220    public void test_spliterator_ref() {
4221        String[] elements = {
4222                "a", "b", "c", "d", "e", "f", "g", "h",
4223                "i", "j", "k", "l", "m", "n", "o", "p" };
4224
4225        ArrayList<String> expected = new ArrayList<>(Arrays.asList(elements));
4226
4227        SpliteratorTester.runBasicIterationTests(Arrays.spliterator(elements), expected);
4228        SpliteratorTester.testSpliteratorNPE(Arrays.spliterator(elements));
4229        assertNotNull(Arrays.spliterator(elements).trySplit());
4230
4231        Spliterator<String> sp = Arrays.spliterator(elements);
4232        assertTrue(sp.hasCharacteristics(Spliterator.ORDERED));
4233
4234        // Basic split tests.
4235        Spliterator<String> sp1 =  sp.trySplit();
4236        assertNotNull(sp1);
4237
4238        ArrayList<String> recorder = new ArrayList<>();
4239        sp1.forEachRemaining(value -> recorder.add(value));
4240        sp.forEachRemaining(value -> recorder.add(value));
4241        Collections.sort(recorder);
4242        assertEquals(expected, recorder);
4243    }
4244
4245    public void test_spliterator_ref_bounds() {
4246        String[] elements = { "BAD", "EVIL", "a", "b", "c", "d", "e", "f", "g", "h",
4247                "i", "j", "k", "l", "m", "n", "o", "p", "DO", "NOT", "INCLUDE" };
4248
4249        ArrayList<String> expected = new ArrayList<>(
4250                Arrays.asList(Arrays.copyOfRange(elements, 2, 16)));
4251
4252        SpliteratorTester.runBasicIterationTests(Arrays.spliterator(elements, 2, 16), expected);
4253        SpliteratorTester.testSpliteratorNPE(Arrays.spliterator(elements, 2, 16));
4254        assertNotNull(Arrays.spliterator(elements, 2, 16).trySplit());
4255
4256        Spliterator<String> sp = Arrays.spliterator(elements, 2, 16);
4257        assertTrue(sp.hasCharacteristics(Spliterator.ORDERED));
4258
4259        // Basic split tests.
4260        Spliterator<String> sp1 =  sp.trySplit();
4261        assertNotNull(sp1);
4262
4263        ArrayList<String> recorder = new ArrayList<>();
4264        sp1.forEachRemaining(value -> recorder.add(value));
4265        sp.forEachRemaining(value -> recorder.add(value));
4266        Collections.sort(recorder);
4267        assertEquals(expected, recorder);
4268    }
4269
4270    private static class PrimitiveIntArrayList {
4271        final int[] array;
4272        int idx;
4273
4274        PrimitiveIntArrayList(int size) {
4275            array = new int[size];
4276        }
4277
4278        public void add(int element) {
4279            array[idx++] = element;
4280        }
4281
4282        public int[] toSortedArray() {
4283            Arrays.sort(array);
4284            return array;
4285        }
4286    }
4287
4288    private static class PrimitiveLongArrayList {
4289        final long[] array;
4290        int idx;
4291
4292        PrimitiveLongArrayList(int size) {
4293            array = new long[size];
4294        }
4295
4296        public void add(long element) {
4297            array[idx++] = element;
4298        }
4299
4300        public long[] toSortedArray() {
4301            Arrays.sort(array);
4302            return array;
4303        }
4304    }
4305
4306    private static class PrimitiveDoubleArrayList {
4307        final double[] array;
4308        int idx;
4309
4310        PrimitiveDoubleArrayList(int size) {
4311            array = new double[size];
4312        }
4313
4314        public void add(double element) {
4315            array[idx++] = element;
4316        }
4317
4318        public double[] toSortedArray() {
4319            Arrays.sort(array);
4320            return array;
4321        }
4322    }
4323
4324    public void test_spliterator_int() {
4325        int[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
4326
4327        Spliterator.OfInt intSp = Arrays.spliterator(elements);
4328
4329        assertEquals(16, intSp.estimateSize());
4330        assertEquals(16, intSp.getExactSizeIfKnown());
4331        assertTrue(intSp.hasCharacteristics(Spliterator.ORDERED));
4332
4333        assertTrue(intSp.tryAdvance((Integer value) -> assertEquals(1, (int) value)));
4334        assertTrue(intSp.tryAdvance((int value) -> assertEquals(2, (int) value)));
4335
4336        PrimitiveIntArrayList recorder = new PrimitiveIntArrayList(16);
4337        // Record elements observed by previous tests.
4338        recorder.add(1);
4339        recorder.add(2);
4340
4341        Spliterator.OfInt split1 = intSp.trySplit();
4342        assertNotNull(split1);
4343        assertTrue(split1.tryAdvance((int value) -> recorder.add(value)));
4344        assertTrue(split1.tryAdvance((Integer value) -> recorder.add(value)));
4345
4346        // Assert that splits can themselves resplit.
4347        Spliterator.OfInt split2 = split1.trySplit();
4348        assertNotNull(split2);
4349        split2.forEachRemaining((int value) -> recorder.add(value));
4350        assertFalse(split2.tryAdvance((int value) -> fail()));
4351        assertFalse(split2.tryAdvance((Integer value) -> fail()));
4352
4353        // Iterate over the remaning elements so we can make sure we've looked at
4354        // everything.
4355        split1.forEachRemaining((int value) -> recorder.add(value));
4356        intSp.forEachRemaining((int value) -> recorder.add(value));
4357
4358        int[] recorded = recorder.toSortedArray();
4359        assertEquals(Arrays.toString(elements), Arrays.toString(recorded));
4360    }
4361
4362    public void test_spliterator_intOffsetBasic() {
4363        int[] elements = { 123123, 131321312, 1, 2, 3, 4, 32323232, 45454};
4364        Spliterator.OfInt sp = Arrays.spliterator(elements, 2, 6);
4365
4366        PrimitiveIntArrayList recorder = new PrimitiveIntArrayList(4);
4367        sp.tryAdvance((Integer value) -> recorder.add((int) value));
4368        sp.tryAdvance((int value) -> recorder.add(value));
4369        sp.forEachRemaining((int value) -> recorder.add(value));
4370
4371        int[] recorded = recorder.toSortedArray();
4372        assertEquals(Arrays.toString(new int[] { 1, 2, 3, 4 }), Arrays.toString(recorded));
4373    }
4374
4375    public void test_spliterator_longOffsetBasic() {
4376        long[] elements = { 123123, 131321312, 1, 2, 3, 4, 32323232, 45454};
4377        Spliterator.OfLong sp = Arrays.spliterator(elements, 2, 6);
4378
4379        PrimitiveLongArrayList recorder = new PrimitiveLongArrayList(4);
4380        sp.tryAdvance((Long value) -> recorder.add((long) value));
4381        sp.tryAdvance((long value) -> recorder.add(value));
4382        sp.forEachRemaining((long value) -> recorder.add(value));
4383
4384        long[] recorded = recorder.toSortedArray();
4385        assertEquals(Arrays.toString(new long[] { 1, 2, 3, 4 }), Arrays.toString(recorded));
4386    }
4387
4388    public void test_spliterator_doubleOffsetBasic() {
4389        double[] elements = { 123123, 131321312, 1, 2, 3, 4, 32323232, 45454};
4390        Spliterator.OfDouble sp = Arrays.spliterator(elements, 2, 6);
4391
4392        PrimitiveDoubleArrayList recorder = new PrimitiveDoubleArrayList(4);
4393        sp.tryAdvance((Double value) -> recorder.add((double) value));
4394        sp.tryAdvance((double value) -> recorder.add(value));
4395        sp.forEachRemaining((double value) -> recorder.add(value));
4396
4397        double[] recorded = recorder.toSortedArray();
4398        assertEquals(Arrays.toString(new double[] { 1, 2, 3, 4 }), Arrays.toString(recorded));
4399    }
4400
4401    public void test_spliterator_long() {
4402        long[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
4403
4404        Spliterator.OfLong longSp = Arrays.spliterator(elements);
4405
4406        assertEquals(16, longSp.estimateSize());
4407        assertEquals(16, longSp.getExactSizeIfKnown());
4408        assertTrue(longSp.hasCharacteristics(Spliterator.ORDERED));
4409
4410        assertTrue(longSp.tryAdvance((Long value) -> assertEquals(1, (long) value)));
4411        assertTrue(longSp.tryAdvance((long value) -> assertEquals(2, (long) value)));
4412
4413        PrimitiveLongArrayList recorder = new PrimitiveLongArrayList(16);
4414        // Record elements observed by previous tests.
4415        recorder.add(1);
4416        recorder.add(2);
4417
4418        Spliterator.OfLong split1 = longSp.trySplit();
4419        assertNotNull(split1);
4420        assertTrue(split1.tryAdvance((long value) -> recorder.add(value)));
4421        assertTrue(split1.tryAdvance((Long value) -> recorder.add(value)));
4422
4423        // Assert that splits can themselves resplit.
4424        Spliterator.OfLong split2 = split1.trySplit();
4425        assertNotNull(split2);
4426        split2.forEachRemaining((long value) -> recorder.add(value));
4427        assertFalse(split2.tryAdvance((long value) -> fail()));
4428        assertFalse(split2.tryAdvance((Long value) -> fail()));
4429
4430        // Iterate over the remaning elements so we can make sure we've looked at
4431        // everything.
4432        split1.forEachRemaining((long value) -> recorder.add(value));
4433        longSp.forEachRemaining((long value) -> recorder.add(value));
4434
4435        long[] recorded = recorder.toSortedArray();
4436        assertEquals(Arrays.toString(elements), Arrays.toString(recorded));
4437    }
4438
4439
4440    public void test_spliterator_double() {
4441        double[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
4442
4443        Spliterator.OfDouble doubleSp = Arrays.spliterator(elements);
4444
4445        assertEquals(16, doubleSp.estimateSize());
4446        assertEquals(16, doubleSp.getExactSizeIfKnown());
4447        assertTrue(doubleSp.hasCharacteristics(Spliterator.ORDERED));
4448
4449        assertTrue(doubleSp.tryAdvance((Double value) -> assertEquals(1.0, (double) value)));
4450        assertTrue(doubleSp.tryAdvance((double value) -> assertEquals(2.0, (double) value)));
4451
4452        PrimitiveDoubleArrayList recorder = new PrimitiveDoubleArrayList(16);
4453        // Record elements observed by previous tests.
4454        recorder.add(1);
4455        recorder.add(2);
4456
4457        Spliterator.OfDouble split1 = doubleSp.trySplit();
4458        assertNotNull(split1);
4459        assertTrue(split1.tryAdvance((double value) -> recorder.add(value)));
4460        assertTrue(split1.tryAdvance((Double value) -> recorder.add(value)));
4461
4462        // Assert that splits can themselves resplit.
4463        Spliterator.OfDouble split2 = split1.trySplit();
4464        assertNotNull(split2);
4465        split2.forEachRemaining((double value) -> recorder.add(value));
4466        assertFalse(split2.tryAdvance((double value) -> fail()));
4467        assertFalse(split2.tryAdvance((Double value) -> fail()));
4468
4469        // Iterate over the remaining elements so we can make sure we've looked at
4470        // everything.
4471        split1.forEachRemaining((double value) -> recorder.add(value));
4472        doubleSp.forEachRemaining((double value) -> recorder.add(value));
4473
4474        double[] recorded = recorder.toSortedArray();
4475        assertEquals(Arrays.toString(elements), Arrays.toString(recorded));
4476    }
4477
4478    public void test_primitive_spliterators_NPE() {
4479        final int[] elements = { 1, 2, 3, 4, 5, 6};
4480        Spliterator.OfInt intSp = Arrays.spliterator(elements);
4481        try {
4482            intSp.forEachRemaining((Consumer<Integer>) null);
4483            fail();
4484        } catch (NullPointerException expected) {
4485        }
4486
4487        try {
4488            intSp.tryAdvance((Consumer<Integer>) null);
4489            fail();
4490        } catch (NullPointerException expected) {
4491        }
4492
4493        try {
4494            intSp.forEachRemaining((IntConsumer) null);
4495            fail();
4496        } catch (NullPointerException expected) {
4497        }
4498
4499        try {
4500            intSp.tryAdvance((IntConsumer) null);
4501            fail();
4502        } catch (NullPointerException expected) {
4503        }
4504
4505        final long[] longElements = { 1, 2, 3, 4, 5, 6};
4506        Spliterator.OfLong longSp = Arrays.spliterator(longElements);
4507        try {
4508            longSp.forEachRemaining((Consumer<Long>) null);
4509            fail();
4510        } catch (NullPointerException expected) {
4511        }
4512
4513        try {
4514            longSp.tryAdvance((Consumer<Long>) null);
4515            fail();
4516        } catch (NullPointerException expected) {
4517        }
4518
4519        try {
4520            longSp.forEachRemaining((LongConsumer) null);
4521            fail();
4522        } catch (NullPointerException expected) {
4523        }
4524
4525        try {
4526            longSp.tryAdvance((LongConsumer) null);
4527            fail();
4528        } catch (NullPointerException expected) {
4529        }
4530
4531        final double[] doubleElements = { 1, 2, 3, 4, 5, 6};
4532        Spliterator.OfDouble doubleSp = Arrays.spliterator(doubleElements);
4533        try {
4534            doubleSp.forEachRemaining((Consumer<Double>) null);
4535            fail();
4536        } catch (NullPointerException expected) {
4537        }
4538
4539        try {
4540            doubleSp.tryAdvance((Consumer<Double>) null);
4541            fail();
4542        } catch (NullPointerException expected) {
4543        }
4544
4545        try {
4546            doubleSp.forEachRemaining((DoubleConsumer) null);
4547            fail();
4548        } catch (NullPointerException expected) {
4549        }
4550
4551        try {
4552            doubleSp.tryAdvance((DoubleConsumer) null);
4553            fail();
4554        } catch (NullPointerException expected) {
4555        }
4556    }
4557
4558    private void test_parallelSort$B(int size) {
4559        if (size % 256 != 0) {
4560            fail("test_parallelSort$B size needs to be dividable by 256");
4561        }
4562        int mul256Count = size / 256;
4563        byte[] sortedArray = new byte[size];
4564        byte curentValue = Byte.MIN_VALUE;
4565        for (int counter = 0; counter < size; counter++) {
4566            sortedArray[counter] = curentValue;
4567            if (counter != 0 && counter % mul256Count == 0) {
4568                curentValue++;
4569            }
4570        }
4571        byte[] reversedArray = new byte[size];
4572        for (int counter = 0; counter < size; counter++) {
4573            reversedArray[counter] = sortedArray[size - counter - 1];
4574        }
4575
4576        Arrays.parallelSort(reversedArray);
4577        assertTrue(Arrays.equals(sortedArray, reversedArray));
4578    }
4579
4580    /**
4581     * java.util.Arrays#parallelSort(byte[])
4582     */
4583    public void test_parallelSort$B() {
4584        // This will result in single thread sort
4585        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4586        test_parallelSort$B(256);
4587        // This should trigger true parallel sort
4588        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4589            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4590            test_parallelSort$B(256 * 64);
4591        }
4592    }
4593
4594    private void test_parallelSort$BII(int size) {
4595        int startIndex = 100;
4596        int endIndex = size - 100;
4597        byte[] reversedArray = new byte[size];
4598        byte[] originalReversedArray = new byte[size];
4599        Arrays.fill(reversedArray, 0 , startIndex, (byte)100);
4600        Arrays.fill(reversedArray, endIndex, size, (byte)100);
4601        for (int counter = startIndex; counter < endIndex; counter++) {
4602            reversedArray[counter] = (byte) (size - counter - startIndex - 1);
4603        }
4604        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
4605
4606        Arrays.parallelSort(reversedArray, startIndex, endIndex);
4607        for (int counter = 0; counter < startIndex; counter++)
4608            assertTrue("Array modified outside of bounds",
4609                 reversedArray[counter] == originalReversedArray[counter]);
4610        for (int counter = startIndex; counter < endIndex - 1; counter++)
4611            assertTrue("Array not sorted within bounds",
4612                       reversedArray[counter] <= reversedArray[counter + 1]);
4613        for (int counter = endIndex; counter < arraySize; counter++)
4614            assertTrue("Array modified outside of bounds",
4615                       reversedArray[counter] == originalReversedArray[counter]);
4616
4617        //exception testing
4618        try {
4619            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex);
4620            fail("IllegalArgumentException expected");
4621        } catch (IllegalArgumentException ignore) {
4622        }
4623
4624        try {
4625            Arrays.parallelSort(reversedArray, -1, startIndex);
4626            fail("ArrayIndexOutOfBoundsException expected (1)");
4627        } catch (ArrayIndexOutOfBoundsException ignore) {
4628        }
4629
4630        try {
4631            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1);
4632            fail("ArrayIndexOutOfBoundsException expected (2)");
4633        } catch (ArrayIndexOutOfBoundsException ignore) {
4634        }
4635    }
4636
4637    /**
4638     * java.util.Arrays#parallelSort(byte[], int, int)
4639     */
4640    public void test_parallelSort$BII() {
4641        // This will result in single thread sort
4642        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4643        test_parallelSort$BII(256);
4644        // This should trigger true parallel sort
4645        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4646            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4647            test_parallelSort$BII(256 * 64);
4648        }
4649    }
4650
4651    /**
4652     * java.util.Arrays#parallelSort(byte[]) & (byte[], int, int) NPE
4653     */
4654    public void test_parallelSort$B_NPE() {
4655        byte[] byte_array_null = null;
4656        try {
4657            java.util.Arrays.parallelSort(byte_array_null);
4658            fail("Should throw java.lang.NullPointerException");
4659        } catch (NullPointerException expected) {
4660        }
4661        try {
4662            java.util.Arrays.parallelSort(byte_array_null, (int) -1, (int) 1);
4663            fail("Should throw java.lang.NullPointerException");
4664        } catch (NullPointerException expected) {
4665        }
4666    }
4667
4668    private void test_parallelSort$C(int size) {
4669        char[] sortedArray = new char[size];
4670        for (int counter = 0; counter < size; counter++)
4671            sortedArray[counter] = (char)(Short.MIN_VALUE + counter);
4672        char[] reversedArray = new char[size];
4673        for (int counter = 0; counter < size; counter++) {
4674            reversedArray[counter] = sortedArray[size - counter - 1];
4675        }
4676        Arrays.parallelSort(reversedArray);
4677        assertTrue(Arrays.equals(sortedArray, reversedArray));
4678    }
4679
4680    /**
4681     * java.util.Arrays#parallelSort(char[])
4682     */
4683    public void test_parallelSort$C() {
4684        // This will result in single thread sort
4685        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4686        test_parallelSort$C(256);
4687        // This should trigger true parallel sort
4688        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4689            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4690            test_parallelSort$C(256 * 64);
4691        }
4692    }
4693
4694    private void test_parallelSort$CII(int size) {
4695        int startIndex = 100;
4696        int endIndex = size - 100;
4697        char[] reversedArray = new char[size];
4698        char[] originalReversedArray = new char[size];
4699
4700        Arrays.fill(reversedArray, 0 , startIndex, (char)100);
4701        Arrays.fill(reversedArray, endIndex, size, (char)100);
4702        for (int counter = startIndex; counter < endIndex; counter++) {
4703            reversedArray[counter] = (char)(size - counter - startIndex - 1);
4704        }
4705        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
4706
4707        Arrays.parallelSort(reversedArray, startIndex, endIndex);
4708        for (int counter = 0; counter < startIndex; counter++)
4709            assertTrue("Array modified outside of bounds",
4710                 reversedArray[counter] == originalReversedArray[counter]);
4711        for (int counter = startIndex; counter < endIndex - 1; counter++)
4712            assertTrue("Array not sorted within bounds",
4713                       reversedArray[counter] <= reversedArray[counter + 1]);
4714        for (int counter = endIndex; counter < arraySize; counter++)
4715            assertTrue("Array modified outside of bounds",
4716                       reversedArray[counter] == originalReversedArray[counter]);
4717
4718        //exception testing
4719        try {
4720            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex);
4721            fail("IllegalArgumentException expected");
4722        } catch (IllegalArgumentException ignore) {
4723        }
4724
4725        try {
4726            Arrays.parallelSort(reversedArray, -1, startIndex);
4727            fail("ArrayIndexOutOfBoundsException expected (1)");
4728        } catch (ArrayIndexOutOfBoundsException ignore) {
4729        }
4730
4731        try {
4732            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1);
4733            fail("ArrayIndexOutOfBoundsException expected (2)");
4734        } catch (ArrayIndexOutOfBoundsException ignore) {
4735        }
4736    }
4737
4738    /**
4739     * java.util.Arrays#parallelSort(char[], int, int)
4740     */
4741    public void test_parallelSort$CII() {
4742        // This will result in single thread sort
4743        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4744        test_parallelSort$CII(256);
4745        // This should trigger true parallel sort
4746        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4747            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4748            test_parallelSort$CII(256 * 64);
4749        }
4750    }
4751
4752    /**
4753     * java.util.Arrays#parallelSort(char[]) & (char[], int, int) NPE
4754     */
4755    public void test_parallelSort$C_NPE() {
4756        char[] char_array_null = null;
4757        try {
4758            java.util.Arrays.parallelSort(char_array_null);
4759            fail("Should throw java.lang.NullPointerException");
4760        } catch (NullPointerException expected) {
4761        }
4762        try {
4763            java.util.Arrays.parallelSort(char_array_null, (int) -1, (int) 1);
4764            fail("Should throw java.lang.NullPointerException");
4765        } catch (NullPointerException expected) {
4766        }
4767    }
4768
4769    private void test_parallelSort$S(int size) {
4770        short[] sortedArray = new short[size];
4771        for (int counter = 0; counter < size; counter++)
4772            sortedArray[counter] = (short)(Short.MIN_VALUE + counter);
4773        short[] reversedArray = new short[size];
4774        for (int counter = 0; counter < size; counter++) {
4775            reversedArray[counter] = sortedArray[size - counter - 1];
4776        }
4777        Arrays.parallelSort(reversedArray);
4778        assertTrue(Arrays.equals(sortedArray, reversedArray));
4779    }
4780
4781    /**
4782     * java.util.Arrays#parallelSort(short[])
4783     */
4784    public void test_parallelSort$S() {
4785        // This will result in single thread sort
4786        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4787        test_parallelSort$S(256);
4788        // This should trigger true parallel sort
4789        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4790            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4791            test_parallelSort$S(256 * 64);
4792        }
4793    }
4794
4795    private void test_parallelSort$SII(int size) {
4796        int startIndex = 100;
4797        int endIndex = size - 100;
4798        short[] reversedArray = new short[size];
4799        short[] originalReversedArray = new short[size];
4800
4801        Arrays.fill(reversedArray, 0 , startIndex, (short)100);
4802        Arrays.fill(reversedArray, endIndex, size, (short)100);
4803        for (int counter = startIndex; counter < endIndex; counter++) {
4804            reversedArray[counter] = (short)(size - counter - startIndex - 1);
4805        }
4806        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
4807
4808        Arrays.parallelSort(reversedArray, startIndex, endIndex);
4809        for (int counter = 0; counter < startIndex; counter++)
4810            assertTrue("Array modified outside of bounds",
4811                 reversedArray[counter] == originalReversedArray[counter]);
4812        for (int counter = startIndex; counter < endIndex - 1; counter++)
4813            assertTrue("Array not sorted within bounds",
4814                       reversedArray[counter] <= reversedArray[counter + 1]);
4815        for (int counter = endIndex; counter < arraySize; counter++)
4816            assertTrue("Array modified outside of bounds",
4817                       reversedArray[counter] == originalReversedArray[counter]);
4818
4819        //exception testing
4820        try {
4821            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex);
4822            fail("IllegalArgumentException expected");
4823        } catch (IllegalArgumentException ignore) {
4824        }
4825
4826        try {
4827            Arrays.parallelSort(reversedArray, -1, startIndex);
4828            fail("ArrayIndexOutOfBoundsException expected (1)");
4829        } catch (ArrayIndexOutOfBoundsException ignore) {
4830        }
4831
4832        try {
4833            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1);
4834            fail("ArrayIndexOutOfBoundsException expected (2)");
4835        } catch (ArrayIndexOutOfBoundsException ignore) {
4836        }
4837    }
4838
4839    /**
4840     * java.util.Arrays#parallelSort(short[], int, int)
4841     */
4842    public void test_parallelSort$SII() {
4843        // This will result in single thread sort
4844        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4845        test_parallelSort$SII(256);
4846        // This should trigger true parallel sort
4847        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4848            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4849            test_parallelSort$SII(256 * 64);
4850        }
4851    }
4852
4853    /**
4854     * java.util.Arrays#parallelSort(short[]) & (short[], int, int) NPE
4855     */
4856    public void test_parallelSort$S_NPE() {
4857        short[] array_null = null;
4858        try {
4859            java.util.Arrays.parallelSort(array_null);
4860            fail("Should throw java.lang.NullPointerException");
4861        } catch (NullPointerException expected) {
4862        }
4863        try {
4864            java.util.Arrays.parallelSort(array_null, (int) -1, (int) 1);
4865            fail("Should throw java.lang.NullPointerException");
4866        } catch (NullPointerException expected) {
4867        }
4868    }
4869
4870    private void test_parallelSort$I(int size) {
4871        int[] sortedArray = new int[size];
4872        for (int counter = 0; counter < size; counter++)
4873            sortedArray[counter] = (int)(Integer.MIN_VALUE + counter);
4874        int[] reversedArray = new int[size];
4875        for (int counter = 0; counter < size; counter++) {
4876            reversedArray[counter] = sortedArray[size - counter - 1];
4877        }
4878        Arrays.parallelSort(reversedArray);
4879        assertTrue(Arrays.equals(sortedArray, reversedArray));
4880    }
4881
4882    /**
4883     * java.util.Arrays#parallelSort(int[])
4884     */
4885    public void test_parallelSort$I() {
4886        // This will result in single thread sort
4887        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4888        test_parallelSort$I(256);
4889        // This should trigger true parallel sort
4890        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4891            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4892            test_parallelSort$I(256 * 64);
4893        }
4894    }
4895
4896    private void test_parallelSort$III(int size) {
4897        int startIndex = 100;
4898        int endIndex = size - 100;
4899        int[] reversedArray = new int[size];
4900        int[] originalReversedArray = new int[size];
4901
4902        Arrays.fill(reversedArray, 0 , startIndex, (int)100);
4903        Arrays.fill(reversedArray, endIndex, size, (int)100);
4904        for (int counter = startIndex; counter < endIndex; counter++) {
4905            reversedArray[counter] = (int)(size - counter - startIndex - 1);
4906        }
4907        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
4908
4909        Arrays.parallelSort(reversedArray, startIndex, endIndex);
4910        for (int counter = 0; counter < startIndex; counter++)
4911            assertTrue("Array modified outside of bounds",
4912                 reversedArray[counter] == originalReversedArray[counter]);
4913        for (int counter = startIndex; counter < endIndex - 1; counter++)
4914            assertTrue("Array not sorted within bounds",
4915                       reversedArray[counter] <= reversedArray[counter + 1]);
4916        for (int counter = endIndex; counter < arraySize; counter++)
4917            assertTrue("Array modified outside of bounds",
4918                       reversedArray[counter] == originalReversedArray[counter]);
4919
4920        //exception testing
4921        try {
4922            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex);
4923            fail("IllegalArgumentException expected");
4924        } catch (IllegalArgumentException ignore) {
4925        }
4926
4927        try {
4928            Arrays.parallelSort(reversedArray, -1, startIndex);
4929            fail("ArrayIndexOutOfBoundsException expected (1)");
4930        } catch (ArrayIndexOutOfBoundsException ignore) {
4931        }
4932
4933        try {
4934            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1);
4935            fail("ArrayIndexOutOfBoundsException expected (2)");
4936        } catch (ArrayIndexOutOfBoundsException ignore) {
4937        }
4938    }
4939
4940    /**
4941     * java.util.Arrays#parallelSort(int[], int, int)
4942     */
4943    public void test_parallelSort$III() {
4944        // This will result in single thread sort
4945        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4946        test_parallelSort$III(256);
4947        // This should trigger true parallel sort
4948        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4949            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4950            test_parallelSort$III(256 * 64);
4951        }
4952    }
4953
4954    /**
4955     * java.util.Arrays#parallelSort(int[]) & (int[], int, int) NPE
4956     */
4957    public void test_parallelSort$I_NPE() {
4958        int[] array_null = null;
4959        try {
4960            java.util.Arrays.parallelSort(array_null);
4961            fail("Should throw java.lang.NullPointerException");
4962        } catch (NullPointerException expected) {
4963        }
4964        try {
4965            java.util.Arrays.parallelSort(array_null, (int) -1, (int) 1);
4966            fail("Should throw java.lang.NullPointerException");
4967        } catch (NullPointerException expected) {
4968        }
4969    }
4970
4971    private void test_parallelSort$J(int size) {
4972        long[] reversedArray = new long[size];
4973        for (int counter = 0; counter < size; counter++)
4974            reversedArray[counter] = (long)(size - counter - 1);
4975        Arrays.parallelSort(reversedArray);
4976
4977        for (int counter = 0; counter < size; counter++)
4978            assertTrue("Resulting array not sorted",
4979                    reversedArray[counter] == (long) counter);
4980    }
4981
4982    /**
4983     * java.util.Arrays#parallelSort(long[])
4984     */
4985    public void test_parallelSort$J() {
4986        // This will result in single thread sort
4987        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
4988        test_parallelSort$J(256);
4989        // This should trigger true parallel sort
4990        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
4991            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
4992            test_parallelSort$J(256 * 64);
4993        }
4994    }
4995
4996    private void test_parallelSort$JII(int size) {
4997        int startIndex = 100;
4998        int endIndex = size - 100;
4999        long[] reversedArray = new long[size];
5000        long[] originalReversedArray = new long[size];
5001
5002        Arrays.fill(reversedArray, 0 , startIndex, (long)100);
5003        Arrays.fill(reversedArray, endIndex, size, (long)100);
5004        for (int counter = startIndex; counter < endIndex; counter++) {
5005            reversedArray[counter] = (long)(size - counter - startIndex - 1);
5006        }
5007        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
5008
5009        Arrays.parallelSort(reversedArray, startIndex, endIndex);
5010        for (int counter = 0; counter < startIndex; counter++)
5011            assertTrue("Array modified outside of bounds",
5012                 reversedArray[counter] == originalReversedArray[counter]);
5013        for (int counter = startIndex; counter < endIndex - 1; counter++)
5014            assertTrue("Array not sorted within bounds",
5015                       reversedArray[counter] <= reversedArray[counter + 1]);
5016        for (int counter = endIndex; counter < arraySize; counter++)
5017            assertTrue("Array modified outside of bounds",
5018                       reversedArray[counter] == originalReversedArray[counter]);
5019
5020        //exception testing
5021        try {
5022            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex);
5023            fail("IllegalArgumentException expected");
5024        } catch (IllegalArgumentException ignore) {
5025        }
5026
5027        try {
5028            Arrays.parallelSort(reversedArray, -1, startIndex);
5029            fail("ArrayIndexOutOfBoundsException expected (1)");
5030        } catch (ArrayIndexOutOfBoundsException ignore) {
5031        }
5032
5033        try {
5034            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1);
5035            fail("ArrayIndexOutOfBoundsException expected (2)");
5036        } catch (ArrayIndexOutOfBoundsException ignore) {
5037        }
5038    }
5039
5040    /**
5041     * java.util.Arrays#parallelSort(long[], int, int)
5042     */
5043    public void test_parallelSort$JII() {
5044        // This will result in single thread sort
5045        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5046        test_parallelSort$JII(256);
5047        // This should trigger true parallel sort
5048        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5049            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5050            test_parallelSort$JII(256 * 64);
5051        }
5052    }
5053
5054    /**
5055     * java.util.Arrays#parallelSort(long[]) & (long[], int, int) NPE
5056     */
5057    public void test_parallelSort$J_NPE() {
5058        long[] array_null = null;
5059        try {
5060            java.util.Arrays.parallelSort(array_null);
5061            fail("Should throw java.lang.NullPointerException");
5062        } catch (NullPointerException expected) {
5063        }
5064        try {
5065            java.util.Arrays.parallelSort(array_null, (int) -1, (int) 1);
5066            fail("Should throw java.lang.NullPointerException");
5067        } catch (NullPointerException expected) {
5068        }
5069    }
5070
5071    private void test_parallelSort$D(int size) {
5072        double[] sortedArray = new double[size];
5073        for (int counter = 0; counter < size; counter++)
5074            sortedArray[counter] = (double)(counter);
5075        double[] reversedArray = new double[size];
5076        for (int counter = 0; counter < size; counter++) {
5077            reversedArray[counter] = sortedArray[size - counter - 1];
5078        }
5079        Arrays.parallelSort(reversedArray);
5080        assertTrue(Arrays.equals(sortedArray, reversedArray));
5081    }
5082
5083    /**
5084     * java.util.Arrays#parallelSort(double[])
5085     */
5086    public void test_parallelSort$D() {
5087        // This will result in single thread sort
5088        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5089        test_parallelSort$D(256);
5090        // This should trigger true parallel sort
5091        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5092            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5093            test_parallelSort$D(256 * 64);
5094        }
5095    }
5096
5097    private void test_parallelSort$DII(int size) {
5098        int startIndex = 100;
5099        int endIndex = size-100;
5100        double[] reversedArray = new double[size];
5101        double[] originalReversedArray = new double[size];
5102
5103        Arrays.fill(reversedArray, 0 , startIndex, (double)100);
5104        Arrays.fill(reversedArray, endIndex, size, (double)100);
5105        for (int counter = startIndex; counter < endIndex; counter++) {
5106            reversedArray[counter] = (double) (size - counter - startIndex - 1);
5107        }
5108        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
5109
5110        Arrays.parallelSort(reversedArray, startIndex, endIndex);
5111        for (int counter = 0; counter < startIndex; counter++)
5112            assertTrue("Array modified outside of bounds",
5113                 reversedArray[counter] == originalReversedArray[counter]);
5114        for (int counter = startIndex; counter < endIndex - 1; counter++)
5115            assertTrue("Array not sorted within bounds",
5116                       reversedArray[counter] <= reversedArray[counter + 1]);
5117        for (int counter = endIndex; counter < arraySize; counter++)
5118            assertTrue("Array modified outside of bounds",
5119                       reversedArray[counter] == originalReversedArray[counter]);
5120
5121        //exception testing
5122        try {
5123            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex);
5124            fail("IllegalArgumentException expected");
5125        } catch (IllegalArgumentException ignore) {
5126        }
5127
5128        try {
5129            Arrays.parallelSort(reversedArray, -1, startIndex);
5130            fail("ArrayIndexOutOfBoundsException expected (1)");
5131        } catch (ArrayIndexOutOfBoundsException ignore) {
5132        }
5133
5134        try {
5135            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1);
5136            fail("ArrayIndexOutOfBoundsException expected (2)");
5137        } catch (ArrayIndexOutOfBoundsException ignore) {
5138        }
5139    }
5140
5141    /**
5142     * java.util.Arrays#parallelSort(double[], int, int)
5143     */
5144    public void test_parallelSort$DII() {
5145        // This will result in single thread sort
5146        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5147        test_parallelSort$DII(256);
5148        // This should trigger true parallel sort
5149        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5150            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5151            test_parallelSort$DII(64*256);
5152        }
5153    }
5154
5155    /**
5156     * java.util.Arrays#parallelSort(double[]) & (double[], int, int) NPE
5157     */
5158    public void test_parallelSort$D_NPE() {
5159        double[] array_null = null;
5160        try {
5161            java.util.Arrays.parallelSort(array_null);
5162            fail("Should throw java.lang.NullPointerException");
5163        } catch (NullPointerException expected) {
5164        }
5165        try {
5166            java.util.Arrays.parallelSort(array_null, (int) -1, (int) 1);
5167            fail("Should throw java.lang.NullPointerException");
5168        } catch (NullPointerException expected) {
5169        }
5170    }
5171
5172    private void test_parallelSort$F(int size) {
5173        float[] sortedArray = new float[size];
5174        for (int counter = 0; counter < size; counter++)
5175            sortedArray[counter] = (float)(counter);
5176        float[] reversedArray = new float[size];
5177        for (int counter = 0; counter < size; counter++) {
5178            reversedArray[counter] = sortedArray[size - counter - 1];
5179        }
5180        Arrays.parallelSort(reversedArray);
5181        assertTrue(Arrays.equals(sortedArray, reversedArray));
5182    }
5183
5184    /**
5185     * java.util.Arrays#parallelSort(float[])
5186     */
5187    public void test_parallelSort$F() {
5188        // This will result in single thread sort
5189        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5190        test_parallelSort$F(256);
5191        // This should trigger true parallel sort
5192        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5193            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5194            test_parallelSort$F(256 * 64);
5195        }
5196    }
5197
5198    private void test_parallelSort$FII(int size) {
5199        int startIndex = 100;
5200        int endIndex = size-100;
5201        float[] reversedArray = new float[size];
5202        float[] originalReversedArray = new float[size];
5203
5204        Arrays.fill(reversedArray, 0 , startIndex, (float)100);
5205        Arrays.fill(reversedArray, endIndex, size, (float)100);
5206        for (int counter = startIndex; counter < endIndex; counter++) {
5207            reversedArray[counter] = (float) (size - counter - startIndex - 1);
5208        }
5209        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
5210
5211        Arrays.parallelSort(reversedArray, startIndex, endIndex);
5212        for (int counter = 0; counter < startIndex; counter++)
5213            assertTrue("Array modified outside of bounds",
5214                 reversedArray[counter] == originalReversedArray[counter]);
5215        for (int counter = startIndex; counter < endIndex - 1; counter++)
5216            assertTrue("Array not sorted within bounds",
5217                       reversedArray[counter] <= reversedArray[counter + 1]);
5218        for (int counter = endIndex; counter < arraySize; counter++)
5219            assertTrue("Array modified outside of bounds",
5220                       reversedArray[counter] == originalReversedArray[counter]);
5221
5222        //exception testing
5223        try {
5224            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex);
5225            fail("IllegalArgumentException expected");
5226        } catch (IllegalArgumentException ignore) {
5227        }
5228
5229        try {
5230            Arrays.parallelSort(reversedArray, -1, startIndex);
5231            fail("ArrayIndexOutOfBoundsException expected (1)");
5232        } catch (ArrayIndexOutOfBoundsException ignore) {
5233        }
5234
5235        try {
5236            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1);
5237            fail("ArrayIndexOutOfBoundsException expected (2)");
5238        } catch (ArrayIndexOutOfBoundsException ignore) {
5239        }
5240    }
5241
5242    /**
5243     * java.util.Arrays#parallelSort(float[], int, int)
5244     */
5245    public void test_parallelSort$FII() {
5246        // This will result in single thread sort
5247        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5248        test_parallelSort$FII(256);
5249        // This should trigger true parallel sort
5250        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5251            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5252            test_parallelSort$FII(64*256);
5253        }
5254    }
5255
5256    /**
5257     * java.util.Arrays#parallelSort(float[]) & (float[], int, int) NPE
5258     */
5259    public void test_parallelSort$F_NPE() {
5260        float[] array_null = null;
5261        try {
5262            java.util.Arrays.parallelSort(array_null);
5263            fail("Should throw java.lang.NullPointerException");
5264        } catch (NullPointerException expected) {
5265
5266        }
5267        try {
5268            java.util.Arrays.parallelSort(array_null, (int) -1, (int) 1);
5269            fail("Should throw java.lang.NullPointerException");
5270        } catch (NullPointerException expected) {
5271        }
5272    }
5273
5274    private void test_parallelSort$Ljava_lang_Comparable(int size) {
5275        Comparable[] sortedArray = new Comparable[size];
5276        for (int counter = 0; counter < size; counter++)
5277            sortedArray[counter] = new Integer(counter);
5278        Comparable[] reversedArray = new Comparable[size];
5279        for (int counter = 0; counter < size; counter++) {
5280            reversedArray[counter] = sortedArray[size - counter - 1];
5281        }
5282        Arrays.parallelSort(reversedArray);
5283        assertTrue(Arrays.equals(sortedArray, reversedArray));
5284
5285        Arrays.fill(reversedArray, 0, reversedArray.length/2, "String");
5286        Arrays.fill(reversedArray, reversedArray.length/2, reversedArray.length, new Integer(1));
5287
5288        try {
5289            Arrays.sort(reversedArray);
5290            fail("ClassCastException expected");
5291        } catch (ClassCastException expected) {
5292        }
5293    }
5294
5295    /**
5296     * java.util.Arrays#parallelSort(java.lang.Comparable[])
5297     */
5298    public void test_parallelSort$Ljava_lang_Comparable() {
5299        // This will result in single thread sort
5300        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5301        test_parallelSort$Ljava_lang_Comparable(256);
5302        // This should trigger true parallel sort
5303        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5304            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5305            test_parallelSort$Ljava_lang_Comparable(256 * 64);
5306        }
5307    }
5308
5309    private void test_parallelSort$Ljava_lang_ComparableII(int size) {
5310        int startIndex = 100;
5311        int endIndex = size-100;
5312        Comparable[] reversedArray = new Comparable[size];
5313        Comparable[] originalReversedArray = new Comparable[size];
5314        Arrays.fill(reversedArray, 0 , startIndex, new Integer(100));
5315        Arrays.fill(reversedArray, endIndex, size, new Integer(100));
5316        for (int counter = startIndex; counter < endIndex; counter++) {
5317            reversedArray[counter] = new Integer(size - counter - startIndex - 1);
5318        }
5319        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
5320
5321        Arrays.parallelSort(reversedArray, startIndex, endIndex);
5322        for (int counter = 0; counter < startIndex; counter++)
5323            assertTrue("Array modified outside of bounds",
5324                 reversedArray[counter] == originalReversedArray[counter]);
5325        for (int counter = startIndex; counter < endIndex - 1; counter++)
5326            assertTrue("Array not sorted within bounds",
5327                       (int)(Integer)reversedArray[counter] <= (int)reversedArray[counter + 1]);
5328        for (int counter = endIndex; counter < arraySize; counter++)
5329            assertTrue("Array modified outside of bounds",
5330                       reversedArray[counter] == originalReversedArray[counter]);
5331
5332        //exception testing
5333        try {
5334            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex);
5335            fail("IllegalArgumentException expected");
5336        } catch (IllegalArgumentException ignore) {
5337        }
5338
5339        try {
5340            Arrays.parallelSort(reversedArray, -1, startIndex);
5341            fail("ArrayIndexOutOfBoundsException expected (1)");
5342        } catch (ArrayIndexOutOfBoundsException ignore) {
5343        }
5344
5345        try {
5346            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1);
5347            fail("ArrayIndexOutOfBoundsException expected (2)");
5348        } catch (ArrayIndexOutOfBoundsException ignore) {
5349        }
5350    }
5351
5352    /**
5353     * java.util.Arrays#parallelSort(java.lang.Comparable[], int, int)
5354     */
5355    public void test_parallelSort$Ljava_lang_ComparableII() {
5356        // This will result in single thread sort
5357        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5358        test_parallelSort$Ljava_lang_ComparableII(256);
5359        // This should trigger true parallel sort
5360        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5361            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5362            test_parallelSort$Ljava_lang_ComparableII(64*256);
5363        }
5364    }
5365
5366
5367    /**
5368     * java.util.Arrays#parallelSort(java_lang_Comparable[]) & (java_lang_Comparable[], int, int) NPE
5369     */
5370    public void test_parallelSort$Ljava_lang_Comparable_NPE() {
5371        Comparable[] array_null = null;
5372        try {
5373            java.util.Arrays.parallelSort(array_null);
5374            fail("Should throw java.lang.NullPointerException");
5375        } catch (NullPointerException expected) {
5376
5377        }
5378        try {
5379            java.util.Arrays.parallelSort(array_null, (int) -1, (int) 1);
5380            fail("Should throw java.lang.NullPointerException");
5381        } catch (NullPointerException expected) {
5382        }
5383    }
5384
5385    private void test_parallelSort$Ljava_lang_ObjectLjava_util_Comparator(int size) {
5386        Object[] reversedArray = new Object[size];
5387        for (int counter = 0; counter < size; counter++)
5388            reversedArray[counter] = new Integer(counter);
5389        Comparator comparator = new ReversedIntegerComparator();
5390        Arrays.parallelSort(reversedArray, comparator);
5391
5392        for (int counter = 0; counter < size; counter++)
5393            assertTrue("Resulting array not sorted",
5394                       (int)(reversedArray[counter]) == (size - counter -1 ));
5395
5396        Arrays.fill(reversedArray, 0, reversedArray.length/2, "String");
5397        Arrays.fill(reversedArray, reversedArray.length/2, reversedArray.length, new Integer(1));
5398
5399        try {
5400            Arrays.sort(reversedArray, comparator);
5401            fail("ClassCastException expected");
5402        } catch (ClassCastException expected) {
5403        }
5404    }
5405
5406    /**
5407     * java.util.Arrays#parallelSort(java.lang.Object[], java.util.Comparator)
5408     */
5409    public void test_parallelSort$Ljava_lang_Objectjava_util_Comparator() {
5410        // This will result in single thread sort
5411        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5412        test_parallelSort$Ljava_lang_ObjectLjava_util_Comparator(256);
5413        // This should trigger true parallel sort
5414        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5415            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5416            test_parallelSort$Ljava_lang_ObjectLjava_util_Comparator(256 * 64);
5417        }
5418    }
5419
5420    private void test_parallelSort$Ljava_lang_ObjectLjava_util_ComparatorII(int size) {
5421        int startIndex = 100;
5422        int endIndex = size-100;
5423        Integer[] reversedArray = new Integer[size];
5424        Integer[] originalReversedArray = new Integer[size];
5425        Arrays.fill(reversedArray, 0 , startIndex, new Integer(100));
5426        Arrays.fill(reversedArray, endIndex, size, new Integer(100));
5427        for (int counter = startIndex; counter < endIndex; counter++) {
5428            reversedArray[counter] = new Integer(counter - startIndex);
5429        }
5430        System.arraycopy(reversedArray, 0, originalReversedArray, 0, size);
5431
5432        Comparator comparator = new ReversedIntegerComparator();
5433        Arrays.parallelSort(reversedArray, startIndex, endIndex, comparator);
5434        for (int counter = 0; counter < startIndex; counter++)
5435            assertTrue("Array modified outside of bounds",
5436                 reversedArray[counter] == originalReversedArray[counter]);
5437        for (int counter = startIndex; counter < endIndex - 1; counter++)
5438            assertTrue("Array not sorted within bounds",
5439                       (int)(Integer)reversedArray[counter] >= (int)reversedArray[counter + 1]);
5440        for (int counter = endIndex; counter < arraySize; counter++)
5441            assertTrue("Array modified outside of bounds",
5442                       reversedArray[counter] == originalReversedArray[counter]);
5443
5444        //exception testing
5445        try {
5446            Arrays.parallelSort(reversedArray, startIndex + 1, startIndex, comparator);
5447            fail("IllegalArgumentException expected");
5448        } catch (IllegalArgumentException ignore) {
5449        }
5450
5451        try {
5452            Arrays.parallelSort(reversedArray, -1, startIndex, comparator);
5453            fail("ArrayIndexOutOfBoundsException expected (1)");
5454        } catch (ArrayIndexOutOfBoundsException ignore) {
5455        }
5456
5457        try {
5458            Arrays.parallelSort(reversedArray, startIndex, reversedArray.length + 1, comparator);
5459            fail("ArrayIndexOutOfBoundsException expected (2)");
5460        } catch (ArrayIndexOutOfBoundsException ignore) {
5461        }
5462    }
5463
5464    /**
5465     * java.util.Arrays#parallelSort(java.lang.Object[], int, int, java.util.Comparator)
5466     */
5467    public void test_parallelSort$Ljava_lang_ObjectLjava_util_ComparatorII() {
5468        // This will result in single thread sort
5469        assertTrue(256 <= Arrays.MIN_ARRAY_SORT_GRAN);
5470        test_parallelSort$Ljava_lang_ObjectLjava_util_ComparatorII(256);
5471        // This should trigger true parallel sort
5472        if (ForkJoinPool.getCommonPoolParallelism() > 1) {
5473            assertTrue(256 * 64 > Arrays.MIN_ARRAY_SORT_GRAN);
5474            test_parallelSort$Ljava_lang_ObjectLjava_util_ComparatorII(64*256);
5475        }
5476    }
5477
5478    /**
5479     * java.util.Arrays#parallelSort(Object[],Comparator) & (Object[], int, int, Comparator) NPE
5480     */
5481    public void test_parallelSort$Ljava_lang_ObjectLjava_util_Comparator_NPE() {
5482        Object[] array_null = null;
5483        Comparator comparator = new ReversedIntegerComparator();
5484        try {
5485            java.util.Arrays.parallelSort(array_null, comparator);
5486            fail("Should throw java.lang.NullPointerException");
5487        } catch (NullPointerException expected) {
5488
5489        }
5490        try {
5491            java.util.Arrays.parallelSort(array_null, (int) -1, (int) 1, comparator);
5492            fail("Should throw java.lang.NullPointerException");
5493        } catch (NullPointerException expected) {
5494        }
5495    }
5496
5497
5498    /**
5499     * Tears down the fixture, for example, close a network connection. This
5500     * method is called after a test is executed.
5501     */
5502    protected void tearDown() {
5503        objArray = null;
5504        booleanArray = null;
5505        byteArray = null;
5506        charArray = null;
5507        doubleArray = null;
5508        floatArray = null;
5509        intArray = null;
5510        longArray = null;
5511        objectArray = null;
5512        shortArray = null;
5513    }
5514}
5515