Home | History | Annotate | Download | only in stream
      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 package java.util.stream;
     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 long-valued streams */
     32 public class LongStreamTestDataProvider {
     33     private static final long[] to0 = new long[0];
     34     private static final long[] to1 = new long[1];
     35     private static final long[] to10 = new long[10];
     36     private static final long[] to100 = new long[100];
     37     private static final long[] to1000 = new long[1000];
     38     private static final long[] reversed = new long[100];
     39     private static final long[] ones = new long[100];
     40     private static final long[] twice = new long[200];
     41     private static final long[] pseudoRandom;
     42 
     43     private static final Object[][] testData;
     44     private static final Object[][] spliteratorTestData;
     45 
     46     static {
     47         long[][] arrays = {to0, to1, to10, to100, to1000};
     48         for (long[] 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 long[LambdaTestHelpers.LONG_STRING.length()];
     62         for (int i = 0; i < LambdaTestHelpers.LONG_STRING.length(); i++) {
     63             pseudoRandom[i] = (long) 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 long[] longs = (long[]) data[1];
     85 
     86                 list.add(new Object[]{"array:" + name,
     87                         TestData.Factory.ofArray("array:" + name, longs)});
     88 
     89                 SpinedBuffer.OfLong isl = new SpinedBuffer.OfLong();
     90                 for (long i : longs) {
     91                     isl.accept(i);
     92                 }
     93                 list.add(new Object[]{"SpinedList:" + name,
     94                         TestData.Factory.ofSpinedBuffer("SpinedList:" + name, isl)});
     95 
     96                 list.add(streamDataDescr("LongStream.longRange(0,l): " + longs.length,
     97                                          () -> LongStream.range(0, longs.length)));
     98                 list.add(streamDataDescr("LongStream.longRangeClosed(0,l): " + longs.length,
     99                                          () -> LongStream.rangeClosed(0, longs.length)));
    100             }
    101             testData = list.toArray(new Object[0][]);
    102         }
    103 
    104         {
    105             List<Object[]> spliterators = new ArrayList<>();
    106             for (Object[] data : arrays) {
    107                 final Object name = data[0];
    108                 final long[] longs = (long[]) data[1];
    109 
    110                 SpinedBuffer.OfLong isl = new SpinedBuffer.OfLong();
    111                 for (long i : longs) {
    112                     isl.accept(i);
    113                 }
    114 
    115                 spliterators.add(splitDescr("Arrays.s(array):" + name,
    116                                             () -> Arrays.spliterator(longs)));
    117                 spliterators.add(splitDescr("Arrays.s(array,o,l):" + name,
    118                                             () -> Arrays.spliterator(longs, 0, longs.length / 2)));
    119 
    120                 spliterators.add(splitDescr("SpinedBuffer.s():" + name,
    121                                             () -> isl.spliterator()));
    122 
    123                 spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator(), size):" + name,
    124                                             () -> Spliterators.spliterator(isl.iterator(), longs.length, 0)));
    125                 spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator()):" + name,
    126                                             () -> Spliterators.spliteratorUnknownSize(isl.iterator(), 0)));
    127 
    128                 spliterators.add(splitDescr("LongStream.longRange(0,l):" + name,
    129                                             () -> LongStream.range(0, longs.length).spliterator()));
    130                 spliterators.add(splitDescr("LongStream.longRangeClosed(0,l):" + name,
    131                                             () -> LongStream.rangeClosed(0, longs.length).spliterator()));
    132                 // Need more!
    133             }
    134             spliteratorTestData = spliterators.toArray(new Object[0][]);
    135         }
    136 
    137     }
    138 
    139     static <T> Object[] streamDataDescr(String description, Supplier<LongStream> s) {
    140         return new Object[] { description, TestData.Factory.ofLongSupplier(description, s) };
    141     }
    142 
    143     static <T> Object[] splitDescr(String description, Supplier<Spliterator.OfLong> s) {
    144         return new Object[] { description, s };
    145     }
    146 
    147     // Return an array of ( String name, LongStreamTestData )
    148     @DataProvider(name = "LongStreamTestData")
    149     public static Object[][] makeLongStreamTestData() {
    150         return testData;
    151     }
    152 
    153     // returns an array of (String name, Supplier<PrimitiveSpliterator<Long>>)
    154     @DataProvider(name = "LongSpliterator")
    155     public static Object[][] spliteratorProvider() {
    156         return spliteratorTestData;
    157     }
    158 }
    159