< prev index next >

test/java/util/stream/bootlib/java.base/java/util/stream/DoubleStreamTestDataProvider.java

Print this page


   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  */


  24 
  25 import org.testng.annotations.DataProvider;
  26 
  27 import java.util.*;
  28 import java.util.Spliterators;
  29 import java.util.function.Supplier;
  30 
  31 /** TestNG DataProvider for double-valued streams */
  32 public class DoubleStreamTestDataProvider {
  33     private static final double[] to0 = new double[0];
  34     private static final double[] to1 = new double[1];
  35     private static final double[] to10 = new double[10];
  36     private static final double[] to100 = new double[100];
  37     private static final double[] to1000 = new double[1000];
  38     private static final double[] reversed = new double[100];
  39     private static final double[] ones = new double[100];
  40     private static final double[] twice = new double[200];
  41     private static final double[] pseudoRandom;
  42 
  43     private static final Object[][] testData;

  44     private static final Object[][] spliteratorTestData;
  45 
  46     static {
  47         double[][] arrays = {to0, to1, to10, to100, to1000};
  48         for (double[] arr : arrays) {
  49             for (int i = 0; i < arr.length; i++) {
  50                 arr[i] = i;
  51             }
  52         }
  53         for (int i = 0; i < reversed.length; i++) {
  54             reversed[i] = reversed.length - i;
  55         }
  56         for (int i = 0; i < ones.length; i++) {
  57             ones[i] = 1;
  58         }
  59         System.arraycopy(to100, 0, twice, 0, to100.length);
  60         System.arraycopy(to100, 0, twice, to100.length, to100.length);
  61         pseudoRandom = new double[LambdaTestHelpers.LONG_STRING.length()];
  62         for (int i = 0; i < LambdaTestHelpers.LONG_STRING.length(); i++) {
  63             pseudoRandom[i] = (double) LambdaTestHelpers.LONG_STRING.charAt(i);
  64         }
  65     }
  66 
  67     static final Object[][] arrays = {
  68             {"empty", to0},
  69             {"0..1", to1},
  70             {"0..10", to10},
  71             {"0..100", to100},
  72             {"0..1000", to1000},
  73             {"100x[1]", ones},
  74             {"2x[0..100]", twice},
  75             {"reverse 0..100", reversed},
  76             {"pseudorandom", pseudoRandom}
  77     };
  78 
  79     static {
  80         {
  81             List<Object[]> list = new ArrayList<>();


  82             for (Object[] data : arrays) {
  83                 final Object name = data[0];
  84                 final double[] doubles = (double[]) data[1];
  85 


  86                 list.add(new Object[]{"array:" + name,
  87                         TestData.Factory.ofArray("array:" + name, doubles)});
  88 
  89                 SpinedBuffer.OfDouble isl = new SpinedBuffer.OfDouble();
  90                 for (double i : doubles) {
  91                     isl.accept(i);
  92                 }
  93                 list.add(new Object[]{"SpinedList:" + name,
  94                         TestData.Factory.ofSpinedBuffer("SpinedList:" + name, isl)});
  95             }
  96             testData = list.toArray(new Object[0][]);


  97         }
  98 
  99         {
 100             List<Object[]> spliterators = new ArrayList<>();
 101             for (Object[] data : arrays) {
 102                 final Object name = data[0];
 103                 final double[] doubles = (double[]) data[1];
 104 
 105                 SpinedBuffer.OfDouble isl = new SpinedBuffer.OfDouble();
 106                 for (double i : doubles) {
 107                     isl.accept(i);
 108                 }
 109 
 110                 spliterators.add(splitDescr("Arrays.s(array):" + name,
 111                                             () -> Arrays.spliterator(doubles)));
 112                 spliterators.add(splitDescr("Arrays.s(array,o,l):" + name,
 113                                             () -> Arrays.spliterator(doubles, 0, doubles.length / 2)));
 114 
 115                 spliterators.add(splitDescr("SpinedBuffer.s():" + name,
 116                                             () -> isl.spliterator()));


 119                                             () -> Spliterators.spliterator(isl.iterator(), doubles.length, 0)));
 120                 spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator()):" + name,
 121                                             () -> Spliterators.spliteratorUnknownSize(isl.iterator(), 0)));
 122                 // Need more!
 123             }
 124             spliteratorTestData = spliterators.toArray(new Object[0][]);
 125         }
 126 
 127     }
 128 
 129     static <T> Object[] splitDescr(String description, Supplier<Spliterator.OfDouble> s) {
 130         return new Object[] { description, s };
 131     }
 132 
 133     // Return an array of ( String name, DoubleStreamTestData )
 134     @DataProvider(name = "DoubleStreamTestData")
 135     public static Object[][] makeDoubleStreamTestData() {
 136         return testData;
 137     }
 138 





 139     // returns an array of (String name, Supplier<PrimitiveSpliterator<Double>>)
 140     @DataProvider(name = "DoubleSpliterator")
 141     public static Object[][] spliteratorProvider() {
 142         return spliteratorTestData;
 143     }
 144 }
   1 /*
   2  * Copyright (c) 2013, 2016, 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  */


  24 
  25 import org.testng.annotations.DataProvider;
  26 
  27 import java.util.*;
  28 import java.util.Spliterators;
  29 import java.util.function.Supplier;
  30 
  31 /** TestNG DataProvider for double-valued streams */
  32 public class DoubleStreamTestDataProvider {
  33     private static final double[] to0 = new double[0];
  34     private static final double[] to1 = new double[1];
  35     private static final double[] to10 = new double[10];
  36     private static final double[] to100 = new double[100];
  37     private static final double[] to1000 = new double[1000];
  38     private static final double[] reversed = new double[100];
  39     private static final double[] ones = new double[100];
  40     private static final double[] twice = new double[200];
  41     private static final double[] pseudoRandom;
  42 
  43     private static final Object[][] testData;
  44     private static final Object[][] testSmallData;
  45     private static final Object[][] spliteratorTestData;
  46 
  47     static {
  48         double[][] arrays = {to0, to1, to10, to100, to1000};
  49         for (double[] arr : arrays) {
  50             for (int i = 0; i < arr.length; i++) {
  51                 arr[i] = i;
  52             }
  53         }
  54         for (int i = 0; i < reversed.length; i++) {
  55             reversed[i] = reversed.length - i;
  56         }
  57         for (int i = 0; i < ones.length; i++) {
  58             ones[i] = 1;
  59         }
  60         System.arraycopy(to100, 0, twice, 0, to100.length);
  61         System.arraycopy(to100, 0, twice, to100.length, to100.length);
  62         pseudoRandom = new double[LambdaTestHelpers.LONG_STRING.length()];
  63         for (int i = 0; i < LambdaTestHelpers.LONG_STRING.length(); i++) {
  64             pseudoRandom[i] = (double) LambdaTestHelpers.LONG_STRING.charAt(i);
  65         }
  66     }
  67 
  68     static final Object[][] arrays = {
  69             {"empty", to0},
  70             {"0..1", to1},
  71             {"0..10", to10},
  72             {"0..100", to100},
  73             {"0..1000", to1000},
  74             {"100x[1]", ones},
  75             {"2x[0..100]", twice},
  76             {"reverse 0..100", reversed},
  77             {"pseudorandom", pseudoRandom}
  78     };
  79 
  80     static {
  81         {
  82             List<Object[]> listSmall = new ArrayList<>();
  83             List<Object[]> list1000 = new ArrayList<>();
  84             List<Object[]> list = null;
  85             for (Object[] data : arrays) {
  86                 final Object name = data[0];
  87                 final double[] doubles = (double[]) data[1];
  88 
  89                 list = doubles.length >= 1000 ? list1000 : listSmall;
  90 
  91                 list.add(new Object[]{"array:" + name,
  92                         TestData.Factory.ofArray("array:" + name, doubles)});
  93 
  94                 SpinedBuffer.OfDouble isl = new SpinedBuffer.OfDouble();
  95                 for (double i : doubles) {
  96                     isl.accept(i);
  97                 }
  98                 list.add(new Object[]{"SpinedList:" + name,
  99                         TestData.Factory.ofSpinedBuffer("SpinedList:" + name, isl)});
 100             }
 101             testSmallData = listSmall.toArray(new Object[0][]);
 102             list1000.addAll(listSmall);
 103             testData = list1000.toArray(new Object[0][]);
 104         }
 105 
 106         {
 107             List<Object[]> spliterators = new ArrayList<>();
 108             for (Object[] data : arrays) {
 109                 final Object name = data[0];
 110                 final double[] doubles = (double[]) data[1];
 111 
 112                 SpinedBuffer.OfDouble isl = new SpinedBuffer.OfDouble();
 113                 for (double i : doubles) {
 114                     isl.accept(i);
 115                 }
 116 
 117                 spliterators.add(splitDescr("Arrays.s(array):" + name,
 118                                             () -> Arrays.spliterator(doubles)));
 119                 spliterators.add(splitDescr("Arrays.s(array,o,l):" + name,
 120                                             () -> Arrays.spliterator(doubles, 0, doubles.length / 2)));
 121 
 122                 spliterators.add(splitDescr("SpinedBuffer.s():" + name,
 123                                             () -> isl.spliterator()));


 126                                             () -> Spliterators.spliterator(isl.iterator(), doubles.length, 0)));
 127                 spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator()):" + name,
 128                                             () -> Spliterators.spliteratorUnknownSize(isl.iterator(), 0)));
 129                 // Need more!
 130             }
 131             spliteratorTestData = spliterators.toArray(new Object[0][]);
 132         }
 133 
 134     }
 135 
 136     static <T> Object[] splitDescr(String description, Supplier<Spliterator.OfDouble> s) {
 137         return new Object[] { description, s };
 138     }
 139 
 140     // Return an array of ( String name, DoubleStreamTestData )
 141     @DataProvider(name = "DoubleStreamTestData")
 142     public static Object[][] makeDoubleStreamTestData() {
 143         return testData;
 144     }
 145 
 146     @DataProvider(name = "DoubleStreamTestData.small")
 147     public static Object[][] makeSmallDoubleStreamTestData() {
 148         return testSmallData;
 149     }
 150 
 151     // returns an array of (String name, Supplier<PrimitiveSpliterator<Double>>)
 152     @DataProvider(name = "DoubleSpliterator")
 153     public static Object[][] spliteratorProvider() {
 154         return spliteratorTestData;
 155     }
 156 }
< prev index next >