/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.rng;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Spliterator;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.IntConsumer;
import java.util.function.LongConsumer;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;

/**
 * Tests for split method implementations in
 * {@link SplittableUniformRandomProvider}.
 *
 * <p>This class verifies all exception conditions for the split methods and the
 * arguments to the methods to stream RNGs. Exception conditions and sequential
 * (default) output from the primitive stream methods are tested in
 * {@link SplittableUniformRandomProviderStreamTest}.
 *
 * <p>Parallel streams (RNGs and primitives) are tested using a splittable
 * generator that outputs a unique sequence using an atomic counter that is
 * thread-safe.
 */
class SplittableUniformRandomProviderTest {
    private static final long STREAM_SIZE_ONE = 1;
    /** The expected characteristics for the spliterator from the splittable stream. */
    private static final int SPLITERATOR_CHARACTERISTICS =
        Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.NONNULL | Spliterator.IMMUTABLE;

    /**
     * Dummy class for checking the behavior of the SplittableUniformRandomProvider.
     * All generation and split methods throw an exception. This can be used to test
     * exception conditions for arguments to default stream functions.
     */
    private static class DummyGenerator implements SplittableUniformRandomProvider {
        /** An instance. */
        static final DummyGenerator INSTANCE = new DummyGenerator();

        @Override
        public long nextLong() {
            throw new UnsupportedOperationException("The nextLong method should not be invoked");
        }

        @Override
        public SplittableUniformRandomProvider split(UniformRandomProvider source) {
            throw new UnsupportedOperationException("The split(source) method should not be invoked");
        }
    }

    /**
     * Class for outputting a unique sequence from the nextLong() method even under
     * recursive splitting. Splitting creates a new instance.
     */
    private static class SequenceGenerator implements SplittableUniformRandomProvider {
        /** The value for nextLong. */
        private final AtomicLong value;

        /**
         * @param seed Sequence seed value.
         */
        SequenceGenerator(long seed) {
            value = new AtomicLong(seed);
        }

        /**
         * @param value The value for nextLong.
         */
        SequenceGenerator(AtomicLong value) {
            this.value = value;
        }

        @Override
        public long nextLong() {
            return value.getAndIncrement();
        }

        @Override
        public SplittableUniformRandomProvider split(UniformRandomProvider source) {
            // Ignore the source (use of the source is optional)
            return new SequenceGenerator(value);
        }
    }

    /**
     * Class for outputting a fixed value from the nextLong() method even under
     * recursive splitting. Splitting creates a new instance seeded with the nextLong value
     * from the source of randomness. This can be used to distinguish self-seeding from
     * seeding with an alternative source.
     */
    private class FixedGenerator implements SplittableUniformRandomProvider {
        /** The value for nextLong. */
        private final long value;

        /**
         * @param value Fixed value.
         */
        FixedGenerator(long value) {
            this.value = value;
        }

        @Override
        public long nextLong() {
            return value;
        }

        @Override
        public SplittableUniformRandomProvider split(UniformRandomProvider source) {
            return new FixedGenerator(source.nextLong());
        }
    }

    /**
     * Class to track recursive splitting and iterating over a fixed set of values.
     * Splitting without a source of randomness returns the same instance; with a
     * source of randomness will throw an exception. All generation methods throw an
     * exception.
     *
     * <p>An atomic counter is maintained to allow concurrent return of unique
     * values from a fixed array. The values are expected to be maintained in child
     * classes. Any generation methods that are overridden for tests should
     * be thread-safe, e.g. returning {@code values[count.getAndIncrement()]}.
     *
     * <p>A count of the number of splits is maintained. This is not used for assertions
     * to avoid test failures that may occur when streams are split differently, or not
     * at all, by the current JVM. The count can be used to debug splitting behavior
     * on JVM implementations.
     */
    private static class CountingGenerator extends DummyGenerator {
        /** The split count. Incrementded when the generator is split. */
        protected final AtomicInteger splitCount = new AtomicInteger();
        /** The count of returned values. */
        protected final AtomicInteger count = new AtomicInteger();

        @Override
        public SplittableUniformRandomProvider split() {
            splitCount.getAndIncrement();
            return this;
        }
    }

    /**
     * Class to return the same instance when splitting without a source of randomness;
     * with a source of randomness will throw an exception. All generation methods
     * throw an exception. Any generation methods that are overridden for tests should
     * be thread-safe.
     */
    private abstract static class SingleInstanceGenerator extends DummyGenerator {
        @Override
        public SplittableUniformRandomProvider split() {
            return this;
        }
    }

    /**
     * Thread and stream sizes used to test parallel streams.
     *
     * @return the arguments
     */
    static Stream<Arguments> threadAndStreamSizes() {
        return Stream.of(
            Arguments.of(1, 16),
            Arguments.of(2, 16),
            Arguments.of(4, 16),
            Arguments.of(8, 16),
            Arguments.of(4, 2),
            Arguments.of(8, 4)
        );
    }

    /**
     * Execute the task in a ForkJoinPool with the specified level of parallelism. Any
     * parallel stream executing in the task should be limited to the specified level of
     * parallelism.
     *
     * <p><b>Note</b>
     *
     * <p>This is a JDK undocumented feature of streams to use the enclosing ForkJoinPool
     * in-place of {@link ForkJoinPool#commonPool()}; this behaviour may be subject to
     * change.
     *
     * <p>Here the intention is to force the parallel stream to execute with a varying
     * number of threads. Note that debugging using the {@link CountingGenerator}
     * indicates that the number of splits is not influenced by the enclosing pool
     * parallelism but rather the number of stream elements and possibly the
     * <em>standard</em> number of available processors. Further testing on Linux using
     * {@code numactl -C 1} to limit the number of processors returns 1 for
     * {@link ForkJoinPool#getCommonPoolParallelism()} and
     * {@link Runtime#availableProcessors()} with no change in the number of splits
     * performed by parallel streams. This indicates the splitting of parallel streams may
     * not respect the limits imposed on the executing JVM. However this does mean that
     * tests using this method do test the splitting of the stream, irrespective of
     * configured parallelism when executed on a machine that has multiple CPU cores, i.e.
     * the <em>potential</em> for parallelism.
     *
     * <p>It is unknown if the parallel streams will split when executed on a true single-core
     * JVM such as that provided by a continuous integration build environment running for
     * example in a virtual machine.
     *
     * @param <T> Return type of the task.
     * @param parallelism Level of parallelism.
     * @param task Task.
     * @return the task result
     * @throws InterruptedException the interrupted exception
     * @throws ExecutionException the execution exception
     */
    private static <T> T execute(int parallelism, Callable<T> task) throws InterruptedException, ExecutionException {
        final ForkJoinPool threadPool = new ForkJoinPool(parallelism);
        try {
            return threadPool.submit(task).get();
        } finally {
            threadPool.shutdown();
        }
    }

    /**
     * Helper method to raise an assertion error inside an action passed to a Spliterator
     * when the action should not be invoked.
     *
     * @see Spliterator#tryAdvance(Consumer)
     * @see Spliterator#forEachRemaining(Consumer)
     */
    private static void failSpliteratorShouldBeEmpty() {
        Assertions.fail("Spliterator should not have any remaining elements");
    }

    @Test
    void testDefaultSplit() {
        // Create the split result so we can check the return value
        final SplittableUniformRandomProvider expected = new DummyGenerator();
        // Implement split(UniformRandomProvider)
        final SplittableUniformRandomProvider rng = new DummyGenerator() {
            @Override
            public SplittableUniformRandomProvider split(UniformRandomProvider source) {
                Assertions.assertSame(this, source, "default split should use itself as the source");
                return expected;
            }
        };
        // Test the default split()
        Assertions.assertSame(expected, rng.split());
    }

    // Tests for splitting the stream of splittable RNGs

    @ParameterizedTest
    @ValueSource(longs = {-1, -2, Long.MIN_VALUE})
    void testSplitsInvalidStreamSizeThrows(long size) {
        final SplittableUniformRandomProvider rng = DummyGenerator.INSTANCE;
        Assertions.assertThrows(IllegalArgumentException.class, () -> rng.splits(size), "splits(size)");
        final SplittableUniformRandomProvider source = new SequenceGenerator(42);
        Assertions.assertThrows(IllegalArgumentException.class, () -> rng.splits(size, source), "splits(size, source)");
    }

    @Test
    void testSplitsUnlimitedStreamSize() {
        final SplittableUniformRandomProvider rng = DummyGenerator.INSTANCE;
        assertUnlimitedSpliterator(rng.splits().spliterator(), "splits()");
        final SplittableUniformRandomProvider source = new SequenceGenerator(42);
        assertUnlimitedSpliterator(rng.splits(source).spliterator(), "splits(source)");
    }

    /**
     * Assert the spliterator has an unlimited expected size and the characteristics for a sized
     * non-null immutable stream.
     *
     * @param spliterator Spliterator.
     * @param msg Error message.
     */
    private static void assertUnlimitedSpliterator(Spliterator<?> spliterator, String msg) {
        BaseRandomProviderStreamTest.assertSpliterator(spliterator, Long.MAX_VALUE, SPLITERATOR_CHARACTERISTICS, msg);
    }

    @Test
    void testSplitsNullSourceThrows() {
        final SplittableUniformRandomProvider rng = DummyGenerator.INSTANCE;
        final SplittableUniformRandomProvider source = null;
        Assertions.assertThrows(NullPointerException.class, () -> rng.splits(source));
        Assertions.assertThrows(NullPointerException.class, () -> rng.splits(STREAM_SIZE_ONE, source));
    }

    /**
     * Test the splits method. The test asserts that a parallel stream of RNGs output a
     * sequence using a specialised sequence generator that maintains the sequence output
     * under recursive splitting.
     */
    @ParameterizedTest
    @MethodSource(value = {"threadAndStreamSizes"})
    void testSplitsParallel(int threads, long streamSize) throws InterruptedException, ExecutionException {
        final long start = Integer.toUnsignedLong(ThreadLocalRandom.current().nextInt());
        final long[] actual = execute(threads, (Callable<long[]>) () -> {
            // The splits method will use itself as the source and the output should be the sequence
            final SplittableUniformRandomProvider rng = new SequenceGenerator(start);
            final SplittableUniformRandomProvider[] rngs =
                    rng.splits(streamSize).parallel().toArray(SplittableUniformRandomProvider[]::new);
            // Check the instance is a new object of the same type.
            // These will be hashed using the system identity hash code.
            final HashSet<SplittableUniformRandomProvider> observed = new HashSet<>();
            observed.add(rng);
            Arrays.stream(rngs).forEach(r -> {
                Assertions.assertTrue(observed.add(r), "Instance should be unique");
                Assertions.assertEquals(SequenceGenerator.class, r.getClass());
            });
            // Get output from the unique RNGs: these return from the same atomic sequence
            return Arrays.stream(rngs).mapToLong(UniformRandomProvider::nextLong).toArray();
        });
        // Required to reorder the sequence to ascending
        Arrays.sort(actual);
        final long[] expected = LongStream.range(start, start + streamSize).toArray();
        Assertions.assertArrayEquals(expected, actual);
    }

    /**
     * Test the splits method. The test asserts that a parallel stream of RNGs output a
     * sequence using a specialised sequence generator that maintains the sequence output
     * under recursive splitting. The sequence is used to seed a fixed generator. The stream
     * instances are verified to be the correct class type.
     */
    @ParameterizedTest
    @MethodSource(value = {"threadAndStreamSizes"})
    void testSplitsParallelWithSource(int threads, long streamSize) throws InterruptedException, ExecutionException {
        final long start = Integer.toUnsignedLong(ThreadLocalRandom.current().nextInt());
        final long[] actual = execute(threads, (Callable<long[]>) () -> {
            // This generator defines the instances created.
            // It should not be split without a source.
            // Seed with something not the start value.
            final SplittableUniformRandomProvider rng = new FixedGenerator(~start) {
                @Override
                public SplittableUniformRandomProvider split() {
                    throw new UnsupportedOperationException("The split method should not be invoked");
                }
            };
            // The splits method will use this to seed each instance.
            // This generator is split within the spliterator.
            final SplittableUniformRandomProvider source = new SequenceGenerator(start);
            final SplittableUniformRandomProvider[] rngs =
                rng.splits(streamSize, source).parallel().toArray(SplittableUniformRandomProvider[]::new);
            // Check the instance is a new object of the same type.
            // These will be hashed using the system identity hash code.
            final HashSet<SplittableUniformRandomProvider> observed = new HashSet<>();
            observed.add(rng);
            Arrays.stream(rngs).forEach(r -> {
                Assertions.assertTrue(observed.add(r), "Instance should be unique");
                Assertions.assertEquals(FixedGenerator.class, r.getClass());
            });
            // Get output from the unique RNGs: these return from the same atomic sequence
            return Arrays.stream(rngs).mapToLong(UniformRandomProvider::nextLong).toArray();
        });
        // Required to reorder the sequence to ascending
        Arrays.sort(actual);
        final long[] expected = LongStream.range(start, start + streamSize).toArray();
        Assertions.assertArrayEquals(expected, actual);
    }

    @Test
    void testSplitsSpliterator() {
        final int start = 42;
        final SplittableUniformRandomProvider rng = new SequenceGenerator(start);

        // Split a large spliterator into four smaller ones;
        // each is used to test different functionality
        final long size = 41;
        Spliterator<SplittableUniformRandomProvider> s1 = rng.splits(size).spliterator();
        Assertions.assertEquals(size, s1.estimateSize());
        final Spliterator<SplittableUniformRandomProvider> s2 = s1.trySplit();
        final Spliterator<SplittableUniformRandomProvider> s3 = s1.trySplit();
        final Spliterator<SplittableUniformRandomProvider> s4 = s2.trySplit();
        Assertions.assertEquals(size, s1.estimateSize() + s2.estimateSize() + s3.estimateSize() + s4.estimateSize());

        // s1. Test cannot split indefinitely
        while (s1.estimateSize() > 1) {
            final long currentSize = s1.estimateSize();
            final Spliterator<SplittableUniformRandomProvider> other = s1.trySplit();
            Assertions.assertEquals(currentSize, s1.estimateSize() + other.estimateSize());
            s1 = other;
        }
        Assertions.assertNull(s1.trySplit(), "Cannot split when size <= 1");

        // The expected value is incremented for each generation call
        final long[] expected = {start};

        // s2. Test advance
        for (long newSize = s2.estimateSize(); newSize-- > 0;) {
            Assertions.assertTrue(s2.tryAdvance(r -> Assertions.assertEquals(expected[0]++, r.nextLong())));
            Assertions.assertEquals(newSize, s2.estimateSize(), "s2 size estimate");
        }
        Assertions.assertFalse(s2.tryAdvance(r -> failSpliteratorShouldBeEmpty()));
        s2.forEachRemaining(r -> failSpliteratorShouldBeEmpty());

        // s3. Test forEachRemaining
        s3.forEachRemaining(r -> Assertions.assertEquals(expected[0]++, r.nextLong()));
        Assertions.assertEquals(0, s3.estimateSize());
        s3.forEachRemaining(r -> failSpliteratorShouldBeEmpty());

        // s4. Test tryAdvance and forEachRemaining when the action throws an exception
        final IllegalStateException ex = new IllegalStateException();
        final Consumer<SplittableUniformRandomProvider> badAction = r -> {
            throw ex;
        };
        final long currentSize = s4.estimateSize();
        Assertions.assertTrue(currentSize > 1, "Spliterator requires more elements to test advance");
        Assertions.assertSame(ex, Assertions.assertThrows(IllegalStateException.class, () -> s4.tryAdvance(badAction)));
        Assertions.assertEquals(currentSize - 1, s4.estimateSize(), "Spliterator should be advanced even when action throws");

        Assertions.assertSame(ex, Assertions.assertThrows(IllegalStateException.class, () -> s4.forEachRemaining(badAction)));
        Assertions.assertEquals(0, s4.estimateSize(), "Spliterator should be finished even when action throws");
        s4.forEachRemaining(r -> failSpliteratorShouldBeEmpty());
    }

    // Tests for splitting the primitive streams to test support for parallel execution

    @ParameterizedTest
    @MethodSource(value = {"threadAndStreamSizes"})
    void testIntsParallelWithSize(int threads, long streamSize) throws InterruptedException, ExecutionException {
        final int[] values = ThreadLocalRandom.current().ints(streamSize).toArray();
        final CountingGenerator rng = new CountingGenerator() {
            @Override
            public int nextInt() {
                return values[count.getAndIncrement()];
            }
        };
        final int[] actual = execute(threads, (Callable<int[]>) () ->
            rng.ints(streamSize).parallel().toArray()
        );
        Arrays.sort(values);
        Arrays.sort(actual);
        Assertions.assertArrayEquals(values, actual);
    }

    @ParameterizedTest
    @MethodSource(value = {"threadAndStreamSizes"})
    void testIntsParallelOriginBoundWithSize(int threads, long streamSize) throws InterruptedException, ExecutionException {
        final int origin = 13;
        final int bound = 42;
        final int[] values = ThreadLocalRandom.current().ints(streamSize, origin, bound).toArray();
        final CountingGenerator rng = new CountingGenerator() {
            @Override
            public int nextInt(int o, int b) {
                Assertions.assertEquals(origin, o, "origin");
                Assertions.assertEquals(bound, b, "bound");
                return values[count.getAndIncrement()];
            }
        };
        final int[] actual = execute(threads, (Callable<int[]>) () ->
            rng.ints(streamSize, origin, bound).parallel().toArray()
        );
        Arrays.sort(values);
        Arrays.sort(actual);
        Assertions.assertArrayEquals(values, actual);
    }

    @Test
    void testIntsSpliterator() {
        final int start = 42;
        final SplittableUniformRandomProvider rng = new SingleInstanceGenerator() {
            private final AtomicInteger value = new AtomicInteger(start);

            @Override
            public int nextInt() {
                return value.getAndIncrement();
            }
        };

        // Split a large spliterator into four smaller ones;
        // each is used to test different functionality
        final long size = 41;
        Spliterator.OfInt s1 = rng.ints(size).spliterator();
        Assertions.assertEquals(size, s1.estimateSize());
        final Spliterator.OfInt s2 = s1.trySplit();
        final Spliterator.OfInt s3 = s1.trySplit();
        final Spliterator.OfInt s4 = s2.trySplit();
        Assertions.assertEquals(size, s1.estimateSize() + s2.estimateSize() + s3.estimateSize() + s4.estimateSize());

        // s1. Test cannot split indefinitely
        while (s1.estimateSize() > 1) {
            final long currentSize = s1.estimateSize();
            final Spliterator.OfInt other = s1.trySplit();
            Assertions.assertEquals(currentSize, s1.estimateSize() + other.estimateSize());
            s1 = other;
        }
        Assertions.assertNull(s1.trySplit(), "Cannot split when size <= 1");

        // The expected value is incremented for each generation call
        final int[] expected = {start};

        // s2. Test advance
        for (long newSize = s2.estimateSize(); newSize-- > 0;) {
            Assertions.assertTrue(s2.tryAdvance((IntConsumer) i -> Assertions.assertEquals(expected[0]++, i)));
            Assertions.assertEquals(newSize, s2.estimateSize(), "s2 size estimate");
        }
        Assertions.assertFalse(s2.tryAdvance((IntConsumer) i -> failSpliteratorShouldBeEmpty()));
        s2.forEachRemaining((IntConsumer) i -> failSpliteratorShouldBeEmpty());

        // s3. Test forEachRemaining
        s3.forEachRemaining((IntConsumer) i -> Assertions.assertEquals(expected[0]++, i));
        Assertions.assertEquals(0, s3.estimateSize());
        s3.forEachRemaining((IntConsumer) i -> failSpliteratorShouldBeEmpty());

        // s4. Test tryAdvance and forEachRemaining when the action throws an exception
        final IllegalStateException ex = new IllegalStateException();
        final IntConsumer badAction = i -> {
            throw ex;
        };
        final long currentSize = s4.estimateSize();
        Assertions.assertTrue(currentSize > 1, "Spliterator requires more elements to test advance");
        Assertions.assertSame(ex, Assertions.assertThrows(IllegalStateException.class, () -> s4.tryAdvance(badAction)));
        Assertions.assertEquals(currentSize - 1, s4.estimateSize(), "Spliterator should be advanced even when action throws");

        Assertions.assertSame(ex, Assertions.assertThrows(IllegalStateException.class, () -> s4.forEachRemaining(badAction)));
        Assertions.assertEquals(0, s4.estimateSize(), "Spliterator should be finished even when action throws");
        s4.forEachRemaining((IntConsumer) i -> failSpliteratorShouldBeEmpty());
    }

    @ParameterizedTest
    @MethodSource(value = {"threadAndStreamSizes"})
    void testLongsParallelWithSize(int threads, long streamSize) throws InterruptedException, ExecutionException {
        final long[] values = ThreadLocalRandom.current().longs(streamSize).toArray();
        final CountingGenerator rng = new CountingGenerator() {
            @Override
            public long nextLong() {
                return values[count.getAndIncrement()];
            }
        };
        final long[] actual = execute(threads, (Callable<long[]>) () ->
            rng.longs(streamSize).parallel().toArray()
        );
        Arrays.sort(values);
        Arrays.sort(actual);
        Assertions.assertArrayEquals(values, actual);
    }

    @ParameterizedTest
    @MethodSource(value = {"threadAndStreamSizes"})
    void testLongsParallelOriginBoundWithSize(int threads, long streamSize) throws InterruptedException, ExecutionException {
        final long origin = 195267376168313L;
        final long bound = 421268681268318L;
        final long[] values = ThreadLocalRandom.current().longs(streamSize, origin, bound).toArray();
        final CountingGenerator rng = new CountingGenerator() {
            @Override
            public long nextLong(long o, long b) {
                Assertions.assertEquals(origin, o, "origin");
                Assertions.assertEquals(bound, b, "bound");
                return values[count.getAndIncrement()];
            }
        };
        final long[] actual = execute(threads, (Callable<long[]>) () ->
            rng.longs(streamSize, origin, bound).parallel().toArray()
        );
        Arrays.sort(values);
        Arrays.sort(actual);
        Assertions.assertArrayEquals(values, actual);
    }

    @Test
    void testLongsSpliterator() {
        final long start = 42;
        final SplittableUniformRandomProvider rng = new SingleInstanceGenerator() {
            private final AtomicLong value = new AtomicLong(start);

            @Override
            public long nextLong() {
                return value.getAndIncrement();
            }
        };

        // Split a large spliterator into four smaller ones;
        // each is used to test different functionality
        final long size = 41;
        Spliterator.OfLong s1 = rng.longs(size).spliterator();
        Assertions.assertEquals(size, s1.estimateSize());
        final Spliterator.OfLong s2 = s1.trySplit();
        final Spliterator.OfLong s3 = s1.trySplit();
        final Spliterator.OfLong s4 = s2.trySplit();
        Assertions.assertEquals(size, s1.estimateSize() + s2.estimateSize() + s3.estimateSize() + s4.estimateSize());

        // s1. Test cannot split indefinitely
        while (s1.estimateSize() > 1) {
            final long currentSize = s1.estimateSize();
            final Spliterator.OfLong other = s1.trySplit();
            Assertions.assertEquals(currentSize, s1.estimateSize() + other.estimateSize());
            s1 = other;
        }
        Assertions.assertNull(s1.trySplit(), "Cannot split when size <= 1");

        // The expected value is incremented for each generation call
        final long[] expected = {start};

        // s2. Test advance
        for (long newSize = s2.estimateSize(); newSize-- > 0;) {
            Assertions.assertTrue(s2.tryAdvance((LongConsumer) i -> Assertions.assertEquals(expected[0]++, i)));
            Assertions.assertEquals(newSize, s2.estimateSize(), "s2 size estimate");
        }
        Assertions.assertFalse(s2.tryAdvance((LongConsumer) i -> failSpliteratorShouldBeEmpty()));
        s2.forEachRemaining((LongConsumer) i -> failSpliteratorShouldBeEmpty());

        // s3. Test forEachRemaining
        s3.forEachRemaining((LongConsumer) i -> Assertions.assertEquals(expected[0]++, i));
        Assertions.assertEquals(0, s3.estimateSize());
        s3.forEachRemaining((LongConsumer) i -> failSpliteratorShouldBeEmpty());

        // s4. Test tryAdvance and forEachRemaining when the action throws an exception
        final IllegalStateException ex = new IllegalStateException();
        final LongConsumer badAction = i -> {
            throw ex;
        };
        final long currentSize = s4.estimateSize();
        Assertions.assertTrue(currentSize > 1, "Spliterator requires more elements to test advance");
        Assertions.assertSame(ex, Assertions.assertThrows(IllegalStateException.class, () -> s4.tryAdvance(badAction)));
        Assertions.assertEquals(currentSize - 1, s4.estimateSize(), "Spliterator should be advanced even when action throws");

        Assertions.assertSame(ex, Assertions.assertThrows(IllegalStateException.class, () -> s4.forEachRemaining(badAction)));
        Assertions.assertEquals(0, s4.estimateSize(), "Spliterator should be finished even when action throws");
        s4.forEachRemaining((LongConsumer) i -> failSpliteratorShouldBeEmpty());
    }

    @ParameterizedTest
    @MethodSource(value = {"threadAndStreamSizes"})
    void testDoublesParallelWithSize(int threads, long streamSize) throws InterruptedException, ExecutionException {
        final double[] values = ThreadLocalRandom.current().doubles(streamSize).toArray();
        final CountingGenerator rng = new CountingGenerator() {
            @Override
            public double nextDouble() {
                return values[count.getAndIncrement()];
            }
        };
        final double[] actual = execute(threads, (Callable<double[]>) () ->
            rng.doubles(streamSize).parallel().toArray()
        );
        Arrays.sort(values);
        Arrays.sort(actual);
        Assertions.assertArrayEquals(values, actual);
    }

    @ParameterizedTest
    @MethodSource(value = {"threadAndStreamSizes"})
    void testDoublesParallelOriginBoundWithSize(int threads, long streamSize) throws InterruptedException, ExecutionException {
        final double origin = 0.123;
        final double bound = 0.789;
        final double[] values = ThreadLocalRandom.current().doubles(streamSize, origin, bound).toArray();
        final CountingGenerator rng = new CountingGenerator() {
            @Override
            public double nextDouble(double o, double b) {
                Assertions.assertEquals(origin, o, "origin");
                Assertions.assertEquals(bound, b, "bound");
                return values[count.getAndIncrement()];
            }
        };
        final double[] actual = execute(threads, (Callable<double[]>) () ->
            rng.doubles(streamSize, origin, bound).parallel().toArray()
        );
        Arrays.sort(values);
        Arrays.sort(actual);
        Assertions.assertArrayEquals(values, actual);
    }

    @Test
    void testDoublesSpliterator() {
        // Due to lack of an AtomicDouble this uses an AtomicInteger. Any int value can be
        // represented as a double and the increment operator functions without loss of
        // precision (the same is not true if using an AtomicLong with >53 bits of precision).
        final int start = 42;
        final SplittableUniformRandomProvider rng = new SingleInstanceGenerator() {
            private final AtomicInteger value = new AtomicInteger(start);

            @Override
            public double nextDouble() {
                return value.getAndIncrement();
            }
        };

        // Split a large spliterator into four smaller ones;
        // each is used to test different functionality
        final long size = 41;
        Spliterator.OfDouble s1 = rng.doubles(size).spliterator();
        Assertions.assertEquals(size, s1.estimateSize());
        final Spliterator.OfDouble s2 = s1.trySplit();
        final Spliterator.OfDouble s3 = s1.trySplit();
        final Spliterator.OfDouble s4 = s2.trySplit();
        Assertions.assertEquals(size, s1.estimateSize() + s2.estimateSize() + s3.estimateSize() + s4.estimateSize());

        // s1. Test cannot split indefinitely
        while (s1.estimateSize() > 1) {
            final double currentSize = s1.estimateSize();
            final Spliterator.OfDouble other = s1.trySplit();
            Assertions.assertEquals(currentSize, s1.estimateSize() + other.estimateSize());
            s1 = other;
        }
        Assertions.assertNull(s1.trySplit(), "Cannot split when size <= 1");

        // The expected value is incremented for each generation call
        final double[] expected = {start};

        // s2. Test advance
        for (long newSize = s2.estimateSize(); newSize-- > 0;) {
            Assertions.assertTrue(s2.tryAdvance((DoubleConsumer) i -> Assertions.assertEquals(expected[0]++, i)));
            Assertions.assertEquals(newSize, s2.estimateSize(), "s2 size estimate");
        }
        Assertions.assertFalse(s2.tryAdvance((DoubleConsumer) i -> failSpliteratorShouldBeEmpty()));
        s2.forEachRemaining((DoubleConsumer) i -> failSpliteratorShouldBeEmpty());

        // s3. Test forEachRemaining
        s3.forEachRemaining((DoubleConsumer) i -> Assertions.assertEquals(expected[0]++, i));
        Assertions.assertEquals(0, s3.estimateSize());
        s3.forEachRemaining((DoubleConsumer) i -> failSpliteratorShouldBeEmpty());

        // s4. Test tryAdvance and forEachRemaining when the action throws an exception
        final IllegalStateException ex = new IllegalStateException();
        final DoubleConsumer badAction = i -> {
            throw ex;
        };
        final double currentSize = s4.estimateSize();
        Assertions.assertTrue(currentSize > 1, "Spliterator requires more elements to test advance");
        Assertions.assertSame(ex, Assertions.assertThrows(IllegalStateException.class, () -> s4.tryAdvance(badAction)));
        Assertions.assertEquals(currentSize - 1, s4.estimateSize(), "Spliterator should be advanced even when action throws");

        Assertions.assertSame(ex, Assertions.assertThrows(IllegalStateException.class, () -> s4.forEachRemaining(badAction)));
        Assertions.assertEquals(0, s4.estimateSize(), "Spliterator should be finished even when action throws");
        s4.forEachRemaining((DoubleConsumer) i -> failSpliteratorShouldBeEmpty());
    }
}
