1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package libcore.java.util;
18
19import java.util.Arrays;
20import java.util.Random;
21
22public class ArraysTest extends junit.framework.TestCase {
23
24    /**
25     * java.util.Arrays#setAll(int[], java.util.function.IntUnaryOperator)
26     */
27    public void test_setAll$I() {
28        int[] list = new int[3];
29        list[0] = 0;
30        list[1] = 1;
31        list[2] = 2;
32
33        Arrays.setAll(list, x -> x + 1);
34        assertEquals(1, list[0]);
35        assertEquals(2, list[1]);
36        assertEquals(3, list[2]);
37
38        try {
39            Arrays.setAll(list, null);
40            fail();
41        } catch (NullPointerException expected) {
42        }
43
44        try {
45            Arrays.setAll((int[]) null, (x -> x + 1));
46            fail();
47        } catch (NullPointerException expected) {
48        }
49    }
50
51    /**
52     * java.util.Arrays#parallelSetAll(int[], java.util.function.IntUnaryOperator)
53     */
54    public void test_parallelSetAll$I() {
55        int[] list = new int[3];
56        list[0] = 0;
57        list[1] = 1;
58        list[2] = 2;
59
60        Arrays.parallelSetAll(list, x -> x + 1);
61        assertEquals(1, list[0]);
62        assertEquals(2, list[1]);
63        assertEquals(3, list[2]);
64
65        try {
66            Arrays.parallelSetAll(list, null);
67            fail();
68        } catch (NullPointerException expected) {
69        }
70
71        try {
72            Arrays.parallelSetAll((int[]) null, (x -> x + 1));
73            fail();
74        } catch (NullPointerException expected) {
75        }
76    }
77
78    /**
79     * java.util.Arrays#setAll(long[], java.util.function.IntToLongFunction)
80     */
81    public void test_setAll$L() {
82        long[] list = new long[3];
83        list[0] = 0;
84        list[1] = 1;
85        list[2] = 2;
86
87        Arrays.setAll(list, x -> x + 1);
88        assertEquals(1, list[0]);
89        assertEquals(2, list[1]);
90        assertEquals(3, list[2]);
91
92        try {
93            Arrays.setAll(list, null);
94            fail();
95        } catch (NullPointerException expected) {
96        }
97
98        try {
99            Arrays.setAll((long[]) null, (x -> x + 1));
100            fail();
101        } catch (NullPointerException expected) {
102        }
103    }
104
105    /**
106     * java.util.Arrays#parallelSetAll(long[], java.util.function.IntToLongFunction)
107     */
108    public void test_parallelSetAll$L() {
109        long[] list = new long[3];
110        list[0] = 0;
111        list[1] = 1;
112        list[2] = 2;
113
114        Arrays.parallelSetAll(list, x -> x + 1);
115        assertEquals(1, list[0]);
116        assertEquals(2, list[1]);
117        assertEquals(3, list[2]);
118
119        try {
120            Arrays.parallelSetAll(list, null);
121            fail();
122        } catch (NullPointerException expected) {
123        }
124
125        try {
126            Arrays.parallelSetAll((long[]) null, (x -> x + 1));
127            fail();
128        } catch (NullPointerException expected) {
129        }
130    }
131
132    /**
133     * java.util.Arrays#setAll(double[], java.util.function.IntToDoubleFunction)
134     */
135    public void test_setAll$D() {
136        double[] list = new double[3];
137        list[0] = 0.0d;
138        list[1] = 1.0d;
139        list[2] = 2.0d;
140
141        Arrays.setAll(list, x -> x + 0.5);
142        assertEquals(0.5d, list[0]);
143        assertEquals(1.5d, list[1]);
144        assertEquals(2.5d, list[2]);
145
146        try {
147            Arrays.setAll(list, null);
148            fail();
149        } catch (NullPointerException expected) {
150        }
151
152        try {
153            Arrays.setAll((double[]) null, x -> x + 0.5);
154            fail();
155        } catch (NullPointerException expected) {
156        }
157    }
158
159    /**
160     * java.util.Arrays#parallelSetAll(double[], java.util.function.IntToDoubleFunction)
161     */
162    public void test_parallelSetAll$D() {
163        double[] list = new double[3];
164        list[0] = 0.0d;
165        list[1] = 1.0d;
166        list[2] = 2.0d;
167
168        Arrays.parallelSetAll(list, x -> x + 0.5);
169        assertEquals(0.5d, list[0]);
170        assertEquals(1.5d, list[1]);
171        assertEquals(2.5d, list[2]);
172
173        try {
174            Arrays.parallelSetAll(list, null);
175            fail();
176        } catch (NullPointerException expected) {
177        }
178
179        try {
180            Arrays.parallelSetAll((double[]) null, x -> x + 0.5);
181            fail();
182        } catch (NullPointerException expected) {
183        }
184    }
185
186    /**
187     * java.util.Array#setAll(T[], java.util.function.IntFunction<\? extends T>)
188     */
189    public void test_setAll$T() {
190        String[] strings = new String[3];
191        strings[0] = "a";
192        strings[0] = "b";
193        strings[0] = "c";
194
195        Arrays.setAll(strings, x -> "a" + x);
196        assertEquals("a0", strings[0]);
197        assertEquals("a1", strings[1]);
198        assertEquals("a2", strings[2]);
199
200        try {
201            Arrays.setAll(strings, null);
202            fail();
203        } catch (NullPointerException expected) {
204        }
205
206        try {
207            Arrays.setAll((String[]) null, x -> "a" + x);
208            fail();
209        } catch (NullPointerException expected) {
210        }
211    }
212
213    /**
214     * java.util.Array#parallelSetAll(T[], java.util.function.IntFunction<\? extends T>)
215     */
216    public void test_parallelSetAll$T() {
217        String[] strings = new String[3];
218        strings[0] = "a";
219        strings[0] = "b";
220        strings[0] = "c";
221
222        Arrays.parallelSetAll(strings, x -> "a" + x);
223        assertEquals("a0", strings[0]);
224        assertEquals("a1", strings[1]);
225        assertEquals("a2", strings[2]);
226
227        try {
228            Arrays.parallelSetAll(strings, null);
229            fail();
230        } catch (NullPointerException expected) {
231        }
232
233        try {
234            Arrays.parallelSetAll((String[]) null, x -> "a" + x);
235            fail();
236        } catch (NullPointerException expected) {
237        }
238    }
239
240    /**
241     * java.util.Array#parallelPrefix(int[], java.util.function.IntBinaryOperator)
242     */
243    public void test_parallelPrefix$I() {
244        // Get an arbitrary array of ints.
245        Random rand = new Random(0);
246        int[] list = new int[1000];
247        for(int i = 0; i < list.length; ++i) {
248            list[i] = rand.nextInt() % 1000; // Prevent overflow
249        }
250
251        int[] seqResult = list.clone();
252
253        // Sequential solution
254        for(int i = 0; i < seqResult.length - 1; ++i) {
255            seqResult[i + 1] += seqResult[i];
256        }
257
258        Arrays.parallelPrefix(list, (x, y) -> x + y);
259        assertTrue(Arrays.equals(seqResult, list));
260
261        try {
262            Arrays.parallelPrefix(list, null);
263            fail();
264        } catch (NullPointerException expected) {
265        }
266
267        try {
268            Arrays.parallelPrefix((int[]) null, (x, y) -> x + y);
269            fail();
270        } catch (NullPointerException expected) {
271        }
272    }
273
274    /**
275     * java.util.Array#parallelPrefix(int[], int, int, java.util.function.IntBinaryOperator)
276     */
277    public void test_parallelPrefix$III() {
278        // Get an arbitrary array of ints.
279        Random rand = new Random(0);
280        int[] list = new int[1000];
281        for(int i = 0; i < list.length; ++i) {
282            list[i] = rand.nextInt() % 1000; // Prevent overflow
283        }
284
285        int begin = 100, end = 500;
286        int[] seqResult = list.clone();
287
288        // Sequential solution
289        for(int i = begin; i < end - 1; ++i) {
290            seqResult[i + 1] += seqResult[i];
291        }
292
293        Arrays.parallelPrefix(list, begin, end, (x, y) -> x + y);
294        assertTrue(Arrays.equals(seqResult, list));
295
296        try {
297            Arrays.parallelPrefix(list, begin, end, null);
298            fail();
299        } catch (NullPointerException expected) {
300        }
301
302        try {
303            Arrays.parallelPrefix((int[]) null, begin, end, (x, y) -> x + y);
304            fail();
305        } catch (NullPointerException expected) {
306        }
307
308        try {
309            Arrays.parallelPrefix(list, end, begin, (x, y) -> x + y);
310            fail();
311        } catch (IllegalArgumentException expected) {
312        }
313    }
314
315    /**
316     * java.util.Array#parallelPrefix(long[], java.util.function.LongBinaryOperator)
317     */
318    public void test_parallelPrefix$L() {
319        // Get an arbitrary array of ints.
320        Random rand = new Random(0);
321        long[] list = new long[1000];
322        for(int i = 0; i < list.length; ++i) {
323            list[i] = rand.nextLong() % 1000000; // Prevent overflow
324        }
325
326        long[] seqResult = list.clone();
327
328        // Sequential solution
329        for(int i = 0; i < seqResult.length - 1; ++i) {
330            seqResult[i + 1] += seqResult[i];
331        }
332
333        Arrays.parallelPrefix(list, (x, y) -> x + y);
334        assertTrue(Arrays.equals(seqResult, list));
335
336        try {
337            Arrays.parallelPrefix(list, null);
338            fail();
339        } catch (NullPointerException expected) {
340        }
341
342        try {
343            Arrays.parallelPrefix((long[]) null, (x, y) -> x + y);
344            fail();
345        } catch (NullPointerException expected) {
346        }
347    }
348
349    /**
350     * java.util.Array#parallelPrefix(long[], int, int, java.util.function.LongBinaryOperator)
351     */
352    public void test_parallelPrefix$LII() {
353        // Get an arbitrary array of ints.
354        Random rand = new Random(0);
355        long[] list = new long[1000];
356        for(int i = 0; i < list.length; ++i) {
357            list[i] = rand.nextLong() % 1000000; // Prevent overflow
358        }
359
360        int begin = 100, end = 500;
361        long[] seqResult = list.clone();
362
363        // Sequential solution
364        for(int i = begin; i < end - 1; ++i) {
365            seqResult[i + 1] += seqResult[i];
366        }
367
368        Arrays.parallelPrefix(list, begin, end, (x, y) -> x + y);
369        assertTrue(Arrays.equals(seqResult, list));
370
371        try {
372            Arrays.parallelPrefix(list, begin, end, null);
373            fail();
374        } catch (NullPointerException expected) {
375        }
376
377        try {
378            Arrays.parallelPrefix((long[]) null, begin, end, (x, y) -> x + y);
379            fail();
380        } catch (NullPointerException expected) {
381        }
382
383        try {
384            Arrays.parallelPrefix(list, end, begin, (x, y) -> x + y);
385            fail();
386        } catch (IllegalArgumentException expected) {
387        }
388    }
389
390    /**
391     * java.util.Array#parallelPrefix(double[], java.util.function.DoubleBinaryOperator)
392     */
393    public void test_parallelPrefix$D() {
394        // Get an arbitrary array of ints.
395        Random rand = new Random(0);
396        double[] list = new double[1000];
397        for(int i = 0; i < list.length; ++i) {
398            list[i] = rand.nextDouble() * 1000;
399        }
400
401        double[] seqResult = list.clone();
402
403        // Sequential solution
404        for(int i = 0; i < seqResult.length - 1; ++i) {
405            seqResult[i + 1] += seqResult[i];
406        }
407
408        Arrays.parallelPrefix(list, (x, y) -> x + y);
409
410        // Parallel double arithmetic contains error, reduce to integer for comparison.
411        int[] listInInt = Arrays.stream(list).mapToInt(x -> (int) x).toArray();
412        int[] seqResultInInt = Arrays.stream(seqResult).mapToInt(x -> (int) x).toArray();
413        assertTrue(Arrays.equals(seqResultInInt, listInInt));
414
415        try {
416            Arrays.parallelPrefix(list, null);
417            fail();
418        } catch (NullPointerException expected) {
419        }
420
421        try {
422            Arrays.parallelPrefix((double[]) null, (x, y) -> x + y);
423            fail();
424        } catch (NullPointerException expected) {
425        }
426    }
427
428    /**
429     * java.util.Array#parallelPrefix(double[], int, int, java.util.function.DoubleBinaryOperator)
430     */
431    public void test_parallelPrefix$DII() {
432        // Get an arbitrary array of ints.
433        Random rand = new Random(0);
434        double[] list = new double[1000];
435        for(int i = 0; i < list.length; ++i) {
436            list[i] = rand.nextDouble() * 1000;
437        }
438
439        int begin = 100, end = 500;
440        double[] seqResult = list.clone();
441
442        // Sequential solution
443        for(int i = begin; i < end - 1; ++i) {
444            seqResult[i + 1] += seqResult[i];
445        }
446
447        Arrays.parallelPrefix(list, begin, end, (x, y) -> x + y);
448
449        // Parallel double arithmetic contains error, reduce to integer for comparison.
450        int[] listInInt = Arrays.stream(list).mapToInt(x -> (int) x).toArray();
451        int[] seqResultInInt = Arrays.stream(seqResult).mapToInt(x -> (int) x).toArray();
452        assertTrue(Arrays.equals(seqResultInInt, listInInt));
453
454        try {
455            Arrays.parallelPrefix(list, begin, end, null);
456            fail();
457        } catch (NullPointerException expected) {
458        }
459
460        try {
461            Arrays.parallelPrefix((double[]) null, begin, end, (x, y) -> x + y);
462            fail();
463        } catch (NullPointerException expected) {
464        }
465
466        try {
467            Arrays.parallelPrefix(list, end, begin, (x, y) -> x + y);
468            fail();
469        } catch (IllegalArgumentException expected) {
470        }
471    }
472
473    /**
474     * java.util.Array#parallelPrefix(T[], java.util.function.BinaryOperator<T>)
475     */
476    public void test_parallelPrefix$T() {
477        String[] strings = new String[3];
478        strings[0] = "a";
479        strings[1] = "b";
480        strings[2] = "c";
481
482        Arrays.parallelPrefix(strings, (x, y) -> x + y);
483        assertEquals("a", strings[0]);
484        assertEquals("ab", strings[1]);
485        assertEquals("abc", strings[2]);
486
487        try {
488            Arrays.parallelPrefix(strings, null);
489            fail();
490        } catch (NullPointerException expected) {
491        }
492
493        try {
494            Arrays.parallelPrefix((String[]) null, (x, y) -> x + y);
495            fail();
496        } catch (NullPointerException expected) {
497        }
498    }
499
500    /**
501     * java.util.Array#parallelPrefix(T[], int, int, java.util.function.BinaryOperator<T>)
502     */
503    public void test_parallelPrefix$TII() {
504        String[] strings = new String[5];
505        strings[0] = "a";
506        strings[1] = "b";
507        strings[2] = "c";
508        strings[3] = "d";
509        strings[4] = "e";
510        int begin = 1, end = 4;
511
512        Arrays.parallelPrefix(strings, begin, end, (x, y) -> x + y);
513        assertEquals("a", strings[0]);
514        assertEquals("b", strings[1]);
515        assertEquals("bc", strings[2]);
516        assertEquals("bcd", strings[3]);
517        assertEquals("e", strings[4]);
518
519        try {
520            Arrays.parallelPrefix(strings, begin, end, null);
521            fail();
522        } catch (NullPointerException expected) {
523        }
524
525        try {
526            Arrays.parallelPrefix((String[]) null, begin, end, (x, y) -> x + y);
527            fail();
528        } catch (NullPointerException expected) {
529        }
530
531        try {
532            Arrays.parallelPrefix(strings, end, begin, (x, y) -> x + y);
533            fail();
534        } catch (IllegalArgumentException expected) {
535        }
536    }
537}
538