1 /*

     2  * Copyright (c) 2013, 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  * @run testng SetAllTest

    29  */

    30 

    31 import org.testng.annotations.DataProvider;

    32 import org.testng.annotations.Test;

    33 

    34 import java.util.Arrays;

    35 import java.util.function.IntFunction;

    36 import java.util.function.IntToDoubleFunction;

    37 import java.util.function.IntToLongFunction;

    38 import java.util.function.IntUnaryOperator;

    39 

    40 import static org.testng.Assert.assertEquals;

    41 import static org.testng.Assert.assertTrue;

    42 import static org.testng.Assert.assertSame;

    43 import static org.testng.Assert.fail;

    44 

    45 @Test

    46 public class SetAllTest {

    47     private static final IntFunction<String> toString = i -> "N" + Integer.valueOf(i);

    48     private static final IntFunction<String> fillString = i -> "X";

    49     private static final String[] r0 = {};

    50     private static final String[] r1 = { "N0" };

    51     private static final String[] r10 = { "N0", "N1", "N2", "N3", "N4", "N5", "N6", "N7", "N8", "N9" };

    52 

    53     private Object[][] stringData = new Object[][] {

    54         { "empty", 0, toString, r0 },

    55         { "one", 1, toString, r1 },

    56         { "ten", 10, toString, r10 },

    57         { "fill", 3, fillString, new String[] { "X", "X", "X" }}

    58     };

    59 

    60     private static final IntUnaryOperator toInt = i -> i << 1;

    61     private static final IntUnaryOperator fillInt = i -> 99;

    62     private static final int[] ir0 = {};

    63     private static final int[] ir1 = { 0 };

    64     private static final int[] ir10 = { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 };

    65     private Object[][] intData = new Object[][] {

    66         { "empty", 0, toInt, ir0 },

    67         { "one", 1, toInt, ir1 },

    68         { "ten", 10, toInt, ir10 },

    69         { "fill", 3, fillInt, new int[] { 99, 99, 99 }}

    70     };

    71 

    72     private static final IntToLongFunction toLong = i -> i << 1;

    73     private static final IntToLongFunction fillLong = i -> 9999L;

    74     private static final long[] lr0 = {};

    75     private static final long[] lr1 = { 0L };

    76     private static final long[] lr10 = { 0L, 2L, 4L, 6L, 8L, 10L, 12L, 14L, 16L, 18L };

    77     private Object[][] longData = new Object[][] {

    78         { "empty", 0, toLong, lr0 },

    79         { "one", 1, toLong, lr1 },

    80         { "ten", 10, toLong, lr10 },

    81         { "fill", 3, fillLong, new long[] { 9999L, 9999L, 9999L }}

    82     };

    83 

    84     private static final IntToDoubleFunction toDouble = i -> i * 1.1;

    85     private static final IntToDoubleFunction fillDouble = i -> 3.14;

    86     private static final double[] dr0 = {};

    87     private static final double[] dr1 = { 0.0 };

    88     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 };

    89     private Object[][] doubleData = new Object[][] {

    90         { "empty", 0, toDouble, dr0 },

    91         { "one", 1, toDouble, dr1 },

    92         { "ten", 10, toDouble, dr10 },

    93         { "fill", 3, fillDouble, new double[] { 3.14, 3.14, 3.14 }}

    94     };

    95 

    96     @DataProvider(name="string")

    97     public Object[][] stringTests() { return stringData; }

    98 

    99     @DataProvider(name="int")

   100     public Object[][] intTests() { return intData; }

   101 

   102     @DataProvider(name="long")

   103     public Object[][] longTests() { return longData; }

   104 

   105     @DataProvider(name="double")

   106     public Object[][] doubleTests() { return doubleData; }

   107 

   108     @Test(dataProvider = "string")

   109     public void testSetAllString(String name, int size, IntFunction<String> generator, String[] expected) {

   110         String[] result = new String[size];

   111         Arrays.setAll(result, generator);

   112         assertEquals(result, expected, "setAll(String[], IntFunction<String>) case " + name + " failed.");

   113 

   114         // ensure fresh array

   115         result = new String[size];

   116         Arrays.parallelSetAll(result, generator);

   117         assertEquals(result, expected, "parallelSetAll(String[], IntFunction<String>) case " + name + " failed.");

   118     }

   119 

   120     @Test(dataProvider = "int")

   121     public void testSetAllInt(String name, int size, IntUnaryOperator generator, int[] expected) {

   122         int[] result = new int[size];

   123         Arrays.setAll(result, generator);

   124         assertEquals(result, expected, "setAll(int[], IntUnaryOperator) case " + name + " failed.");

   125 

   126         // ensure fresh array

   127         result = new int[size];

   128         Arrays.parallelSetAll(result, generator);

   129         assertEquals(result, expected, "parallelSetAll(int[], IntUnaryOperator) case " + name + " failed.");

   130     }

   131 

   132     @Test(dataProvider = "long")

   133     public void testSetAllLong(String name, int size, IntToLongFunction generator, long[] expected) {

   134         long[] result = new long[size];

   135         Arrays.setAll(result, generator);

   136         assertEquals(result, expected, "setAll(long[], IntToLongFunction) case " + name + " failed.");

   137 

   138         // ensure fresh array

   139         result = new long[size];

   140         Arrays.parallelSetAll(result, generator);

   141         assertEquals(result, expected, "parallelSetAll(long[], IntToLongFunction) case " + name + " failed.");

   142     }

   143 

   144     private void assertDoubleArrayEquals(double[] actual, double[] expected, double delta, String msg) {

   145         if (actual.length != expected.length) {

   146             fail(msg + ": length mismatch, expected " + expected.length + ", got " + actual.length);

   147         }

   148 

   149         for (int i = 0; i < actual.length; i++) {

   150             assertEquals(actual[i], expected[i], delta, msg + "(mismatch at index " + i + ")");

   151         }

   152     }

   153 

   154     @Test(dataProvider = "double")

   155     public void testSetAllDouble(String name, int size, IntToDoubleFunction generator, double[] expected) {

   156         double[] result = new double[size];

   157         Arrays.setAll(result, generator);

   158         assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");

   159 

   160         // ensure fresh array

   161         result = new double[size];

   162         Arrays.parallelSetAll(result, generator);

   163         assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");

   164     }

   165 

   166     @Test

   167     public void testStringSetNulls() {

   168         String[] ar = new String[2];

   169         try {

   170             Arrays.setAll(null, (IntFunction<String>) i -> "X");

   171             fail("Arrays.setAll(null, foo) should throw NPE");

   172         } catch (NullPointerException npe) {

   173             // expected

   174         }

   175         try {

   176             Arrays.parallelSetAll(null, (IntFunction<String>) i -> "X");

   177             fail("Arrays.parallelSetAll(null, foo) should throw NPE");

   178         } catch (NullPointerException npe) {

   179             // expected

   180         }

   181         try {

   182             Arrays.setAll(ar, null);

   183             fail("Arrays.setAll(array, null) should throw NPE");

   184         } catch (NullPointerException npe) {

   185             // expected

   186         }

   187         try {

   188             Arrays.parallelSetAll(ar, null);

   189             fail("Arrays.parallelSetAll(array, null) should throw NPE");

   190         } catch (NullPointerException npe) {

   191             // expected

   192         }

   193     }

   194 

   195     @Test

   196     public void testIntSetNulls() {

   197         int[] ar = new int[2];

   198         try {

   199             Arrays.setAll(null, (IntUnaryOperator) i -> i);

   200             fail("Arrays.setAll(null, foo) should throw NPE");

   201         } catch (NullPointerException npe) {

   202             // expected

   203         }

   204         try {

   205             Arrays.parallelSetAll(null, (IntUnaryOperator) i -> i);

   206             fail("Arrays.parallelSetAll(null, foo) should throw NPE");

   207         } catch (NullPointerException npe) {

   208             // expected

   209         }

   210         try {

   211             Arrays.setAll(ar, null);

   212             fail("Arrays.setAll(array, null) should throw NPE");

   213         } catch (NullPointerException npe) {

   214             // expected

   215         }

   216         try {

   217             Arrays.parallelSetAll(ar, null);

   218             fail("Arrays.parallelSetAll(array, null) should throw NPE");

   219         } catch (NullPointerException npe) {

   220             // expected

   221         }

   222     }

   223 

   224     @Test

   225     public void testLongSetNulls() {

   226         long[] ar = new long[2];

   227         try {

   228             Arrays.setAll(null, (IntToLongFunction) i -> Long.MAX_VALUE);

   229             fail("Arrays.setAll(null, foo) should throw NPE");

   230         } catch (NullPointerException npe) {

   231             // expected

   232         }

   233         try {

   234             Arrays.parallelSetAll(null, (IntToLongFunction) i -> Long.MAX_VALUE);

   235             fail("Arrays.parallelSetAll(null, foo) should throw NPE");

   236         } catch (NullPointerException npe) {

   237             // expected

   238         }

   239         try {

   240             Arrays.setAll(ar, null);

   241             fail("Arrays.setAll(array, null) should throw NPE");

   242         } catch (NullPointerException npe) {

   243             // expected

   244         }

   245         try {

   246             Arrays.parallelSetAll(ar, null);

   247             fail("Arrays.parallelSetAll(array, null) should throw NPE");

   248         } catch (NullPointerException npe) {

   249             // expected

   250         }

   251     }

   252 

   253     @Test

   254     public void testDoubleSetNulls() {

   255         double[] ar = new double[2];

   256         try {

   257             Arrays.setAll(null, (IntToDoubleFunction) i -> Math.E);

   258             fail("Arrays.setAll(null, foo) should throw NPE");

   259         } catch (NullPointerException npe) {

   260             // expected

   261         }

   262         try {

   263             Arrays.parallelSetAll(null, (IntToDoubleFunction) i -> Math.E);

   264             fail("Arrays.parallelSetAll(null, foo) should throw NPE");

   265         } catch (NullPointerException npe) {

   266             // expected

   267         }

   268         try {

   269             Arrays.setAll(ar, null);

   270             fail("Arrays.setAll(array, null) should throw NPE");

   271         } catch (NullPointerException npe) {

   272             // expected

   273         }

   274         try {

   275             Arrays.parallelSetAll(ar, null);

   276             fail("Arrays.parallelSetAll(array, null) should throw NPE");

   277         } catch (NullPointerException npe) {

   278             // expected

   279         }

   280     }

   281 }