1 /*
  2  * Copyright (c) 2013, 2026, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  */
 23 
 24 /*
 25  * @test
 26  * @bug 8012650
 27  * @summary Unit test for setAll, parallelSetAll variants
 28  * @library /test/lib
 29  * @run junit SetAllTest
 30  */
 31 

 32 import java.util.Arrays;
 33 import java.util.function.IntFunction;
 34 import java.util.function.IntToDoubleFunction;
 35 import java.util.function.IntToLongFunction;
 36 import java.util.function.IntUnaryOperator;
 37 
 38 import jdk.test.lib.valueclass.AsValueClass;
 39 
 40 import org.junit.jupiter.api.Assertions;
 41 import static org.junit.jupiter.api.Assertions.assertThrows;
 42 import static org.junit.jupiter.api.Assertions.assertEquals;
 43 import static org.junit.jupiter.api.Assertions.fail;
 44 import org.junit.jupiter.api.Test;
 45 import org.junit.jupiter.api.TestInstance;
 46 import org.junit.jupiter.params.ParameterizedTest;
 47 import org.junit.jupiter.params.provider.MethodSource;
 48 
 49 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 50 public class SetAllTest {
 51     private static final IntFunction<String> toString = i -> "N" + Integer.valueOf(i);
 52     private static final IntFunction<String> fillString = i -> "X";
 53     private static final String[] r0 = {};
 54     private static final String[] r1 = { "N0" };
 55     private static final String[] r10 = { "N0", "N1", "N2", "N3", "N4", "N5", "N6", "N7", "N8", "N9" };
 56 
 57     private Object[][] stringData = new Object[][] {
 58         { "empty", 0, toString, r0 },
 59         { "one", 1, toString, r1 },
 60         { "ten", 10, toString, r10 },
 61         { "fill", 3, fillString, new String[] { "X", "X", "X" }}
 62     };
 63 
 64     private static final IntUnaryOperator toInt = i -> i << 1;
 65     private static final IntUnaryOperator fillInt = i -> 99;
 66     private static final int[] ir0 = {};
 67     private static final int[] ir1 = { 0 };
 68     private static final int[] ir10 = { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 };
 69     private Object[][] intData = new Object[][] {
 70         { "empty", 0, toInt, ir0 },
 71         { "one", 1, toInt, ir1 },
 72         { "ten", 10, toInt, ir10 },
 73         { "fill", 3, fillInt, new int[] { 99, 99, 99 }}
 74     };
 75 
 76     private static final IntToLongFunction toLong = i -> i << 1;
 77     private static final IntToLongFunction fillLong = i -> 9999L;
 78     private static final long[] lr0 = {};
 79     private static final long[] lr1 = { 0L };
 80     private static final long[] lr10 = { 0L, 2L, 4L, 6L, 8L, 10L, 12L, 14L, 16L, 18L };
 81     private Object[][] longData = new Object[][] {
 82         { "empty", 0, toLong, lr0 },
 83         { "one", 1, toLong, lr1 },
 84         { "ten", 10, toLong, lr10 },
 85         { "fill", 3, fillLong, new long[] { 9999L, 9999L, 9999L }}
 86     };
 87 
 88     private static final IntToDoubleFunction toDouble = i -> i * 1.1;
 89     private static final IntToDoubleFunction fillDouble = i -> 3.14;
 90     private static final double[] dr0 = {};
 91     private static final double[] dr1 = { 0.0 };
 92     private static final double[] dr10 = { 0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9 };
 93     private Object[][] doubleData = new Object[][] {
 94         { "empty", 0, toDouble, dr0 },
 95         { "one", 1, toDouble, dr1 },
 96         { "ten", 10, toDouble, dr10 },
 97         { "fill", 3, fillDouble, new double[] { 3.14, 3.14, 3.14 }}
 98     };
 99 
100     @AsValueClass
101     record Point(int x, int y) { }
102 
103     private static final IntFunction<Point> toPoint = i -> new Point(i, i * 2);
104     private static final IntFunction<Point> fillPoint = i -> new Point(0, 0);
105     private static final Point[] pr0  = {};
106     private static final Point[] pr1  = { new Point(0, 0) };
107     private static final Point[] pr10 = { new Point(0,0), new Point(1, 2), new Point(2, 4),
108             new Point(3, 6), new Point(4, 8), new Point(5, 10), new Point(6, 12),
109             new Point(7, 14), new Point(8, 16), new Point(9, 18) };
110 
111     private Object[][] pointData = new Object[][] {
112             { "empty", 0, toPoint, pr0 },
113             { "one",   1, toPoint, pr1 },
114             { "ten",  10, toPoint, pr10 },
115             { "fill",  3, fillPoint, new Point[] { new Point(0,0), new Point(0,0), new Point(0,0) }}
116     };
117 
118     public Object[][] stringTests() { return stringData; }
119 
120     public Object[][] intTests() { return intData; }
121 
122     public Object[][] longTests() { return longData; }
123 
124     public Object[][] doubleTests() { return doubleData; }
125 
126     public Object[][] pointTests() { return pointData; }
127 
128     @ParameterizedTest(name = "{0}, size={1}, data={3}")
129     @MethodSource("stringTests")
130     public void testSetAllString(String name, int size, IntFunction<String> generator, String[] expected) {
131         String[] result = new String[size];
132         Arrays.setAll(result, generator);
133         Assertions.assertArrayEquals(expected, result, "setAll(String[], IntFunction<String>) case " + name + " failed.");
134 
135         // ensure fresh array
136         result = new String[size];
137         Arrays.parallelSetAll(result, generator);
138         Assertions.assertArrayEquals(expected, result, "parallelSetAll(String[], IntFunction<String>) case " + name + " failed.");
139     }
140 
141     @ParameterizedTest(name = "{0}, size={1}, data={3}")
142     @MethodSource("intTests")
143     public void testSetAllInt(String name, int size, IntUnaryOperator generator, int[] expected) {
144         int[] result = new int[size];
145         Arrays.setAll(result, generator);
146         Assertions.assertArrayEquals(expected, result, "setAll(int[], IntUnaryOperator) case " + name + " failed.");
147 
148         // ensure fresh array
149         result = new int[size];
150         Arrays.parallelSetAll(result, generator);
151         Assertions.assertArrayEquals(expected, result, "parallelSetAll(int[], IntUnaryOperator) case " + name + " failed.");
152     }
153 
154     @ParameterizedTest(name = "{0}, size={1}, data={3}")
155     @MethodSource("longTests")
156     public void testSetAllLong(String name, int size, IntToLongFunction generator, long[] expected) {
157         long[] result = new long[size];
158         Arrays.setAll(result, generator);
159         Assertions.assertArrayEquals(expected, result, "setAll(long[], IntToLongFunction) case " + name + " failed.");
160 
161         // ensure fresh array
162         result = new long[size];
163         Arrays.parallelSetAll(result, generator);
164         Assertions.assertArrayEquals(expected, result, "parallelSetAll(long[], IntToLongFunction) case " + name + " failed.");
165     }
166 
167     private void assertDoubleArrayEquals(double[] actual, double[] expected, double delta, String msg) {
168         if (actual.length != expected.length) {
169             fail(msg + ": length mismatch, expected " + expected.length + ", got " + actual.length);
170         }
171 
172         for (int i = 0; i < actual.length; i++) {
173             assertEquals(actual[i], expected[i], delta, msg + "(mismatch at index " + i + ")");
174         }
175     }
176 
177     @ParameterizedTest(name = "{0}, size={1}, data={3}")
178     @MethodSource("doubleTests")
179     public void testSetAllDouble(String name, int size, IntToDoubleFunction generator, double[] expected) {
180         double[] result = new double[size];
181         Arrays.setAll(result, generator);
182         assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");
183 
184         // ensure fresh array
185         result = new double[size];
186         Arrays.parallelSetAll(result, generator);
187         assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");
188     }
189 
190     @ParameterizedTest(name = "{0}, size={1}, data={3}")
191     @MethodSource("pointTests")
192     public void testSetAllPoint(String name, int size, IntFunction<Point> generator, Point[] expected) {
193         Point[] result = new Point[size];
194         Arrays.setAll(result, generator);
195         Assertions.assertArrayEquals(expected, result, "setAll(Point[], IntFunction<Point>) case " + name + " failed.");
196 
197         result = new Point[size];
198         Arrays.parallelSetAll(result, generator);
199         Assertions.assertArrayEquals(expected, result, "parallelSetAll(Point[], IntFunction<Point>) case " + name + " failed.");
200     }
201 
202     @Test
203     public void testStringSetNulls() {
204         String[] ar = new String[2];
205         try {
206             Arrays.setAll(null, (IntFunction<String>) i -> "X");
207             fail("Arrays.setAll(null, foo) should throw NPE");
208         } catch (NullPointerException npe) {
209             // expected
210         }
211         try {
212             Arrays.parallelSetAll(null, (IntFunction<String>) i -> "X");
213             fail("Arrays.parallelSetAll(null, foo) should throw NPE");
214         } catch (NullPointerException npe) {
215             // expected
216         }
217         try {
218             Arrays.setAll(ar, null);
219             fail("Arrays.setAll(array, null) should throw NPE");
220         } catch (NullPointerException npe) {
221             // expected
222         }
223         try {
224             Arrays.parallelSetAll(ar, null);
225             fail("Arrays.parallelSetAll(array, null) should throw NPE");
226         } catch (NullPointerException npe) {
227             // expected
228         }
229     }
230 
231     @Test
232     public void testIntSetNulls() {
233         int[] ar = new int[2];
234         try {
235             Arrays.setAll(null, (IntUnaryOperator) i -> i);
236             fail("Arrays.setAll(null, foo) should throw NPE");
237         } catch (NullPointerException npe) {
238             // expected
239         }
240         try {
241             Arrays.parallelSetAll(null, (IntUnaryOperator) i -> i);
242             fail("Arrays.parallelSetAll(null, foo) should throw NPE");
243         } catch (NullPointerException npe) {
244             // expected
245         }
246         try {
247             Arrays.setAll(ar, null);
248             fail("Arrays.setAll(array, null) should throw NPE");
249         } catch (NullPointerException npe) {
250             // expected
251         }
252         try {
253             Arrays.parallelSetAll(ar, null);
254             fail("Arrays.parallelSetAll(array, null) should throw NPE");
255         } catch (NullPointerException npe) {
256             // expected
257         }
258     }
259 
260     @Test
261     public void testLongSetNulls() {
262         long[] ar = new long[2];
263         try {
264             Arrays.setAll(null, (IntToLongFunction) i -> Long.MAX_VALUE);
265             fail("Arrays.setAll(null, foo) should throw NPE");
266         } catch (NullPointerException npe) {
267             // expected
268         }
269         try {
270             Arrays.parallelSetAll(null, (IntToLongFunction) i -> Long.MAX_VALUE);
271             fail("Arrays.parallelSetAll(null, foo) should throw NPE");
272         } catch (NullPointerException npe) {
273             // expected
274         }
275         try {
276             Arrays.setAll(ar, null);
277             fail("Arrays.setAll(array, null) should throw NPE");
278         } catch (NullPointerException npe) {
279             // expected
280         }
281         try {
282             Arrays.parallelSetAll(ar, null);
283             fail("Arrays.parallelSetAll(array, null) should throw NPE");
284         } catch (NullPointerException npe) {
285             // expected
286         }
287     }
288 
289     @Test
290     public void testDoubleSetNulls() {
291         double[] ar = new double[2];
292         try {
293             Arrays.setAll(null, (IntToDoubleFunction) i -> Math.E);
294             fail("Arrays.setAll(null, foo) should throw NPE");
295         } catch (NullPointerException npe) {
296             // expected
297         }
298         try {
299             Arrays.parallelSetAll(null, (IntToDoubleFunction) i -> Math.E);
300             fail("Arrays.parallelSetAll(null, foo) should throw NPE");
301         } catch (NullPointerException npe) {
302             // expected
303         }
304         try {
305             Arrays.setAll(ar, null);
306             fail("Arrays.setAll(array, null) should throw NPE");
307         } catch (NullPointerException npe) {
308             // expected
309         }
310         try {
311             Arrays.parallelSetAll(ar, null);
312             fail("Arrays.parallelSetAll(array, null) should throw NPE");
313         } catch (NullPointerException npe) {
314             // expected
315         }
316     }
317 
318     @Test
319     public void testPointSetNulls() {
320         Point[] ar = new Point[2];
321 
322         assertThrows(NullPointerException.class, () -> Arrays.setAll(
323             (Point[]) null, (IntFunction<Point>) i -> new Point(i, i)));
324         assertThrows(NullPointerException.class, () -> Arrays.parallelSetAll(
325             (Point[]) null, (IntFunction<Point>) i -> new Point(i, i)));
326         assertThrows(NullPointerException.class, () -> Arrays.setAll(
327             ar, (IntFunction<Point>) null));
328         assertThrows(NullPointerException.class, () -> Arrays.parallelSetAll(
329             ar, (IntFunction<Point>) null));
330     }
331 }
--- EOF ---