1 /*
   2  * Copyright (c) 2012, 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 import org.testng.annotations.DataProvider;
  25 import org.testng.annotations.Test;
  26 
  27 import java.security.SecureRandom;
  28 import java.util.Arrays;
  29 import java.util.List;
  30 import java.util.ArrayList;
  31 import java.util.Random;
  32 
  33 import java.util.concurrent.Executors;
  34 import java.util.concurrent.ExecutorService;
  35 import java.util.concurrent.ThreadLocalRandom;
  36 import java.util.concurrent.TimeUnit;
  37 import java.util.stream.IntStream;
  38 import java.util.stream.LongStream;
  39 import java.util.stream.DoubleStream;
  40 import java.util.stream.Stream;
  41 
  42 import static org.testng.Assert.assertEquals;
  43 import static org.testng.Assert.assertFalse;
  44 import static org.testng.Assert.assertTrue;
  45 
  46 /**
  47  * @test
  48  * @run testng RandomStreamTest
  49  * @summary test stream methods on Random
  50  * @author Brian Goetz
  51  */
  52 public class RandomStreamTest {
  53 
  54     private static final int SIZE = 1000;
  55 
  56     @DataProvider(name = "suppliers")
  57     public Object[][] randomSuppliers() {
  58         return new Object[][] {
  59             {new Random(), SIZE},
  60             {new SecureRandom(), SIZE}
  61         };
  62     }
  63 
  64     @Test(dataProvider = "suppliers")
  65     public void testRandomIntStream(final Random random, final int count) {
  66         final List<Integer> destination = new ArrayList<>(count);
  67         random.ints().limit(count).forEach(destination::add);
  68         assertEquals(destination.size(), count);
  69     }
  70 
  71     @Test(dataProvider = "suppliers")
  72     public void testRandomLongStream(final Random random, final int count) {
  73         final List<Long> destination = new ArrayList<>(count);
  74         random.longs().limit(count).forEach(destination::add);
  75         assertEquals(destination.size(), count);
  76     }
  77 
  78     @Test(dataProvider = "suppliers")
  79     public void testRandomDoubleStream(final Random random, final int count) {
  80         final List<Double> destination = new ArrayList<>(count);
  81         random.doubles().limit(count).forEach(destination::add);
  82         random.doubles().limit(count).forEach(d -> assertTrue(d >= 0.0 && d < 1.0));
  83         assertEquals(destination.size(), count);
  84     }
  85 
  86     @Test(dataProvider = "suppliers")
  87     public void testRandomGaussianStream(final Random random, final int count) {
  88         final List<Double> destination = new ArrayList<>(count);
  89         random.gaussians().limit(count).forEach(destination::add);
  90         assertEquals(destination.size(), count);
  91     }
  92 
  93     @Test
  94     public void testIntStream() {
  95         final long seed = System.currentTimeMillis();
  96         final Random r1 = new Random(seed);
  97         final int[] a = new int[SIZE];
  98         for (int i=0; i < SIZE; i++) {
  99             a[i] = r1.nextInt();
 100         }
 101 
 102         final Random r2 = new Random(seed); // same seed
 103         final int[] b = r2.ints().limit(SIZE).toArray();
 104         assertEquals(a, b);
 105     }
 106 
 107     @Test
 108     public void testLongStream() {
 109         final long seed = System.currentTimeMillis();
 110         final Random r1 = new Random(seed);
 111         final long[] a = new long[SIZE];
 112         for (int i=0; i < SIZE; i++) {
 113             a[i] = r1.nextLong();
 114         }
 115 
 116         final Random r2 = new Random(seed); // same seed
 117         final long[] b = r2.longs().limit(SIZE).toArray();
 118         assertEquals(a, b);
 119     }
 120 
 121     @Test
 122     public void testDoubleStream() {
 123         final long seed = System.currentTimeMillis();
 124         final Random r1 = new Random(seed);
 125         final double[] a = new double[SIZE];
 126         for (int i=0; i < SIZE; i++) {
 127             a[i] = r1.nextDouble();
 128         }
 129 
 130         final Random r2 = new Random(seed); // same seed
 131         final double[] b = r2.doubles().limit(SIZE).toArray();
 132         assertEquals(a, b);
 133     }
 134 
 135     @Test
 136     public void testGaussianStream() {
 137         final long seed = System.currentTimeMillis();
 138         final Random r1 = new Random(seed);
 139         final double[] a = new double[SIZE];
 140         for (int i=0; i < SIZE; i++) {
 141             a[i] = r1.nextGaussian();
 142         }
 143 
 144         final Random r2 = new Random(seed); // same seed
 145         final double[] b = r2.gaussians().limit(SIZE).toArray();
 146         assertEquals(a, b);
 147     }
 148 
 149     @Test
 150     public void testThreadLocalIntStream() throws InterruptedException {
 151         final ExecutorService e = Executors.newFixedThreadPool(10);
 152         final ThreadLocalRandom tlr = ThreadLocalRandom.current();
 153 
 154         final class RandomTask implements Runnable {
 155             int[] randoms;
 156 
 157             @Override
 158             public void run() {
 159                 randoms = tlr.ints().limit(SIZE).toArray();
 160             }
 161         }
 162         final RandomTask[] tasks = new RandomTask[10];
 163         for (int i=0; i < tasks.length; i++) {
 164             tasks[i] = new RandomTask();
 165         }
 166         for (int i=0; i < tasks.length; i++) {
 167             e.submit(tasks[i]);
 168         }
 169         e.shutdown();
 170         e.awaitTermination(3, TimeUnit.SECONDS);
 171         for (int i=1; i < tasks.length; i++) {
 172             assertFalse(Arrays.equals(tasks[0].randoms, tasks[i].randoms));
 173         }
 174     }
 175 
 176     @Test
 177     public void testThreadLocalLongStream() throws InterruptedException {
 178         final ExecutorService e = Executors.newFixedThreadPool(10);
 179         final ThreadLocalRandom tlr = ThreadLocalRandom.current();
 180 
 181         final class RandomTask implements Runnable {
 182             long[] randoms;
 183 
 184             @Override
 185             public void run() {
 186                 randoms = tlr.longs().limit(SIZE).toArray();
 187             }
 188         }
 189         final RandomTask[] tasks = new RandomTask[10];
 190         for (int i=0; i < tasks.length; i++) {
 191             tasks[i] = new RandomTask();
 192         }
 193         for (int i=0; i < tasks.length; i++) {
 194             e.submit(tasks[i]);
 195         }
 196         e.shutdown();
 197         e.awaitTermination(3, TimeUnit.SECONDS);
 198         for (int i=1; i < tasks.length; i++) {
 199             assertFalse(Arrays.equals(tasks[0].randoms, tasks[i].randoms));
 200         }
 201     }
 202 
 203     @Test
 204     public void testThreadLocalDoubleStream() throws InterruptedException {
 205         final ExecutorService e = Executors.newFixedThreadPool(10);
 206         final ThreadLocalRandom tlr = ThreadLocalRandom.current();
 207 
 208         final class RandomTask implements Runnable {
 209             double[] randoms;
 210 
 211             @Override
 212             public void run() {
 213                 randoms = tlr.doubles().limit(SIZE).toArray();
 214             }
 215         }
 216         final RandomTask[] tasks = new RandomTask[10];
 217         for (int i=0; i < tasks.length; i++) {
 218             tasks[i] = new RandomTask();
 219         }
 220         for (int i=0; i < tasks.length; i++) {
 221             e.submit(tasks[i]);
 222         }
 223         e.shutdown();
 224         e.awaitTermination(3, TimeUnit.SECONDS);
 225         for (int i=1; i < tasks.length; i++) {
 226             assertFalse(Arrays.equals(tasks[0].randoms, tasks[i].randoms));
 227         }
 228     }
 229 
 230     @Test
 231     public void testThreadLocalGaussianStream() throws InterruptedException {
 232         final ExecutorService e = Executors.newFixedThreadPool(10);
 233         final ThreadLocalRandom tlr = ThreadLocalRandom.current();
 234 
 235         final class RandomTask implements Runnable {
 236             double[] randoms;
 237 
 238             @Override
 239             public void run() {
 240                 randoms = tlr.gaussians().limit(SIZE).toArray();
 241             }
 242         }
 243         final RandomTask[] tasks = new RandomTask[10];
 244         for (int i=0; i < tasks.length; i++) {
 245             tasks[i] = new RandomTask();
 246         }
 247         for (int i=0; i < tasks.length; i++) {
 248             e.submit(tasks[i]);
 249         }
 250         e.shutdown();
 251         e.awaitTermination(3, TimeUnit.SECONDS);
 252         for (int i=1; i < tasks.length; i++) {
 253             assertFalse(Arrays.equals(tasks[0].randoms, tasks[i].randoms));
 254         }
 255     }
 256 
 257 }