commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/ConversionsTest.java - commons-rng - Git at Google

 /*
  * 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.simple.internal;

 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.Arrays;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.IntStream;
 import java.util.stream.LongStream;
 import org.apache.commons.rng.core.source64.SplitMix64;
 import org.apache.commons.rng.core.util.NumberFactory;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;

 /**
  * Tests for {@link Conversions}.
  */
 class ConversionsTest {
     /**
      * The fractional part of the the golden ratio, phi, scaled to 64-bits and rounded to odd.
      * <pre>
      * phi = (sqrt(5) - 1) / 2) * 2^64
      * </pre>
      * @see <a href="https://en.wikipedia.org/wiki/Golden_ratio">Golden ratio</a>
      */
     private static final long GOLDEN_RATIO = 0x9e3779b97f4a7c15L;

     /**
      * Gets the lengths for the byte[] seeds to convert.
      *
      * @return the lengths
      */
     static IntStream getByteLengths() {
         return IntStream.rangeClosed(0, Long.BYTES * 2);
     }

     /**
      * Gets the lengths for the int[] seeds to convert.
      *
      * @return the lengths
      */
     static IntStream getIntLengths() {
         return IntStream.rangeClosed(0, (Long.BYTES / Integer.BYTES) * 2);
     }

     /**
      * Gets the lengths for the long[] seeds to convert.
      *
      * @return the lengths
      */
     static IntStream getLongLengths() {
         return IntStream.rangeClosed(0, 2);
     }

     @ParameterizedTest
     @ValueSource(ints = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE})
     void testIntSizeFromByteSize(int size) {
         Assertions.assertEquals((int) Math.ceil((double) size / Integer.BYTES), Conversions.intSizeFromByteSize(size));
     }

     @ParameterizedTest
     @ValueSource(ints = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, Integer.MAX_VALUE})
     void testLongSizeFromByteSize(int size) {
         Assertions.assertEquals((int) Math.ceil((double) size / Long.BYTES), Conversions.longSizeFromByteSize(size));
     }

     @ParameterizedTest
     @ValueSource(ints = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE})
     void testIntSizeFromLongSize(int size) {
         Assertions.assertEquals((int) Math.min(size * 2L, Integer.MAX_VALUE), Conversions.intSizeFromLongSize(size));
     }

     @ParameterizedTest
     @ValueSource(ints = {0, 1, 2, 3, 4, 5, Integer.MAX_VALUE})
     void testLongSizeFromIntSize(int size) {
         Assertions.assertEquals((int) Math.ceil((double) size / 2), Conversions.longSizeFromIntSize(size));
     }

     @RepeatedTest(value = 5)
     void testInt2Long() {
         final int v = ThreadLocalRandom.current().nextInt();
         Assertions.assertEquals(new SplitMix64(v).nextLong(), Conversions.int2Long(v));
     }

     @RepeatedTest(value = 5)
     void testInt2IntArray() {
         final int v = ThreadLocalRandom.current().nextInt();
         getIntLengths().forEach(len -> {
             Assertions.assertArrayEquals(Conversions.long2IntArray(v, len),
                                          Conversions.int2IntArray(v, len));
         });
     }

     @RepeatedTest(value = 5)
     void testInt2LongArray() {
         final int v = ThreadLocalRandom.current().nextInt();
         getIntLengths().forEach(len -> {
             final long[] a = Conversions.int2LongArray(v, len);
             Assertions.assertArrayEquals(Conversions.long2LongArray(v, len), a);
             if (len != 0) {
                 // Special case of expansion to length 1
                 // Expandion is done by mixing
                 Assertions.assertEquals(Conversions.int2Long(v), a[0]);
             }
         });
     }

     @RepeatedTest(value = 5)
     void testLong2Int() {
         final long v = ThreadLocalRandom.current().nextLong();
         Assertions.assertEquals(NumberFactory.makeInt(v), Conversions.long2Int(v));
     }

     @RepeatedTest(value = 5)
     void testLong2IntArray() {
         // Avoid seed == 0 - 0x9e3779b97f4a7c15L. See testLong2IntArrayLength2NotAllZero.
         long seed;
         do {
             seed = ThreadLocalRandom.current().nextLong();
         } while (seed == -GOLDEN_RATIO);
         final long v = seed;
         getIntLengths().forEach(len -> {
             final int longs = Conversions.longSizeFromIntSize(len);
             // Little-endian conversion
             final ByteBuffer bb = ByteBuffer.allocate(longs * Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
             LongStream.generate(new SplitMix64(v)::nextLong).limit(longs).forEach(bb::putLong);
             bb.clear();
             final int[] expected = new int[len];
             for (int i = 0; i < len; i++) {
                 expected[i] = bb.getInt();
             }
             Assertions.assertArrayEquals(expected,
                 Conversions.long2IntArray(v, len));

             // Note:
             // long -> int[] position[0] != long -> int
             // Reduction is done by folding upper and lower using xor
         });
     }

     /**
      * Test the long2IntArray conversion avoids an input that will generate a zero from the
      * SplitMix64-style RNG. This prevents creating an array of length 2 that is zero.
      *
      * <p>This special case avoids creating a small state Xor-based generator such as
      * XoRoShiRo64StarStar with a seed of all zeros.
      */
     @Test
     void testLong2IntArrayLength2NotAllZero() {
         // The first output from the SplitMix64 is mix(seed + GOLDEN_RATIO).
         // Create the seed to ensure a zero output from the mix function.
         final long seed = -GOLDEN_RATIO;
         Assertions.assertEquals(0, new SplitMix64(seed).nextLong());

         // Note: This cannot occur for int2IntArray as the SplitMix64 is seeded with the int.
         // This ignores the case of an output int[] of length 1 which could be zero.
         // An int -> int[1] conversion is nonsensical and should not be performed by the library.
         Assertions.assertNotEquals(0, new SplitMix64((int) seed).nextLong());

         // The conversion should detect this case and a zero seed of length 2 should not happen.
         final int[] actual = Conversions.long2IntArray(seed, 2);
         Assertions.assertFalse(Arrays.equals(new int[2], actual));

         // Longer arrays may be a partially zero as the generator state passes through
         // the zero-point.
         Assertions.assertArrayEquals(
             Arrays.copyOf(Conversions.long2IntArray(seed - GOLDEN_RATIO, 2), 4),
             Conversions.long2IntArray(seed - GOLDEN_RATIO, 4));
     }

     @RepeatedTest(value = 5)
     void testLong2LongArray() {
         final long v = ThreadLocalRandom.current().nextLong();
         getIntLengths().forEach(len -> {
             Assertions.assertArrayEquals(LongStream.generate(new SplitMix64(v)::nextLong).limit(len).toArray(),
                 Conversions.long2LongArray(v, len));
         });
     }

     @ParameterizedTest
     @MethodSource(value = {"getIntLengths"})
     void testIntArray2Int(int ints) {
         final int[] seed = ThreadLocalRandom.current().ints(ints).toArray();
         // xor all the bytes
         int expected = 0;
         for (final int i : seed) {
             expected ^= i;
         }
         Assertions.assertEquals(expected, Conversions.intArray2Int(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getIntLengths"})
     void testIntArray2Long(int ints) {
         final int[] seed = ThreadLocalRandom.current().ints(ints).toArray();

         // int[] -> long[] -> long
         // Concatenate all ints in little-endian order to bytes
         final int outLength = Conversions.longSizeFromIntSize(ints);
         final int[] filledSeed = Arrays.copyOf(seed, outLength * 2);
         final ByteBuffer bb = ByteBuffer.allocate(filledSeed.length * Integer.BYTES)
                 .order(ByteOrder.LITTLE_ENDIAN);
         Arrays.stream(filledSeed).forEach(bb::putInt);
         // xor all the bytes read as longs
         long expected = 0;
         bb.flip();
         for (int i = outLength; i-- != 0;) {
             final long l = bb.getLong();
             expected ^= l;
         }

         Assertions.assertEquals(expected, Conversions.intArray2Long(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getIntLengths"})
     void testIntArray2LongComposed(int ints) {
         final int[] seed = ThreadLocalRandom.current().ints(ints).toArray();
         final long expected = new LongArray2Long().convert(new IntArray2LongArray().convert(seed));
         Assertions.assertEquals(expected, Conversions.intArray2Long(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getIntLengths"})
     void testIntArray2LongArray(int ints) {
         final int[] seed = ThreadLocalRandom.current().ints(ints).toArray();

         // Concatenate all bytes in little-endian order to bytes
         final int outLength = Conversions.longSizeFromIntSize(ints);
         final ByteBuffer bb = ByteBuffer.allocate(outLength * Long.BYTES)
                 .order(ByteOrder.LITTLE_ENDIAN);
         Arrays.stream(seed).forEach(bb::putInt);
         bb.clear();
         final long[] expected = new long[outLength];
         for (int i = 0; i < outLength; i++) {
             expected[i] = bb.getLong();
         }

         Assertions.assertArrayEquals(expected, Conversions.intArray2LongArray(seed, outLength));
         // Zero fill
         Assertions.assertArrayEquals(Arrays.copyOf(expected, outLength * 2),
             Conversions.intArray2LongArray(seed, outLength * 2));
         // Truncation
         for (int i = 0; i < outLength; i++) {
             Assertions.assertArrayEquals(Arrays.copyOf(expected, i), Conversions.intArray2LongArray(seed, i));
         }
     }

     @ParameterizedTest
     @MethodSource(value = {"getLongLengths"})
     void testLongArray2Int(long longs) {
         final long[] seed = ThreadLocalRandom.current().longs(longs).toArray();
         // xor all the bytes
         long expected = 0;
         for (final long i : seed) {
             expected ^= i;
         }
         Assertions.assertEquals((int) (expected ^ expected >>> 32), Conversions.longArray2Int(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getLongLengths"})
     void testLongArray2Long(long longs) {
         final long[] seed = ThreadLocalRandom.current().longs(longs).toArray();
         // xor all the bytes
         long expected = 0;
         for (final long i : seed) {
             expected ^= i;
         }
         Assertions.assertEquals(expected, Conversions.longArray2Long(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getLongLengths"})
     void testLongArray2IntArray(int longs) {
         final long[] seed = ThreadLocalRandom.current().longs(longs).toArray();

         // Concatenate all bytes in little-endian order to bytes
         final int outLength = Conversions.intSizeFromLongSize(longs);
         final ByteBuffer bb = ByteBuffer.allocate(longs * Long.BYTES)
                 .order(ByteOrder.LITTLE_ENDIAN);
         Arrays.stream(seed).forEach(bb::putLong);
         bb.clear();
         final int[] expected = new int[outLength];
         for (int i = 0; i < outLength; i++) {
             expected[i] = bb.getInt();
         }

         Assertions.assertArrayEquals(expected, Conversions.longArray2IntArray(seed, outLength));
         // Zero fill
         Assertions.assertArrayEquals(Arrays.copyOf(expected, outLength * 2),
             Conversions.longArray2IntArray(seed, outLength * 2));
         // Truncation
         for (int i = 0; i < outLength; i++) {
             Assertions.assertArrayEquals(Arrays.copyOf(expected, i), Conversions.longArray2IntArray(seed, i));
         }
     }

     @ParameterizedTest
     @MethodSource(value = {"getByteLengths"})
     void testByteArray2Int(int bytes) {
         final byte[] seed = new byte[bytes];
         ThreadLocalRandom.current().nextBytes(seed);

         // byte[] -> int[] -> int
         // Concatenate all bytes in little-endian order to bytes
         final int outLength = Conversions.intSizeFromByteSize(bytes);
         final byte[] filledSeed = Arrays.copyOf(seed, outLength * Integer.BYTES);
         final ByteBuffer bb = ByteBuffer.wrap(filledSeed)
                 .order(ByteOrder.LITTLE_ENDIAN);
         // xor all the bytes read as ints
         int expected = 0;
         for (int i = outLength; i-- != 0;) {
             final long l = bb.getInt();
             expected ^= l;
         }

         Assertions.assertEquals(expected, Conversions.byteArray2Int(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getByteLengths"})
     void testByteArray2IntComposed(int bytes) {
         final byte[] seed = new byte[bytes];
         ThreadLocalRandom.current().nextBytes(seed);
         final int expected = new IntArray2Int().convert(new ByteArray2IntArray().convert(seed));
         Assertions.assertEquals(expected, Conversions.byteArray2Int(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getByteLengths"})
     void testByteArray2IntArray(int bytes) {
         final byte[] seed = new byte[bytes];
         ThreadLocalRandom.current().nextBytes(seed);

         // Concatenate all bytes in little-endian order to bytes
         final int outLength = Conversions.intSizeFromByteSize(bytes);
         final byte[] filledSeed = Arrays.copyOf(seed, outLength * Integer.BYTES);
         final ByteBuffer bb = ByteBuffer.wrap(filledSeed)
                 .order(ByteOrder.LITTLE_ENDIAN);
         final int[] expected = new int[outLength];
         for (int i = 0; i < outLength; i++) {
             expected[i] = bb.getInt();
         }

         Assertions.assertArrayEquals(expected, Conversions.byteArray2IntArray(seed, outLength));
         // Zero fill
         Assertions.assertArrayEquals(Arrays.copyOf(expected, outLength * 2),
             Conversions.byteArray2IntArray(seed, outLength * 2));
         // Truncation
         for (int i = 0; i < outLength; i++) {
             Assertions.assertArrayEquals(Arrays.copyOf(expected, i), Conversions.byteArray2IntArray(seed, i));
         }
     }

     @ParameterizedTest
     @MethodSource(value = {"getByteLengths"})
     void testByteArray2Long(int bytes) {
         final byte[] seed = new byte[bytes];
         ThreadLocalRandom.current().nextBytes(seed);

         // byte[] -> long[] -> long
         // Concatenate all bytes in little-endian order to bytes
         final int outLength = Conversions.longSizeFromByteSize(bytes);
         final byte[] filledSeed = Arrays.copyOf(seed, outLength * Long.BYTES);
         final ByteBuffer bb = ByteBuffer.wrap(filledSeed)
                 .order(ByteOrder.LITTLE_ENDIAN);
         // xor all the bytes read as longs
         long expected = 0;
         for (int i = outLength; i-- != 0;) {
             final long l = bb.getLong();
             expected ^= l;
         }

         Assertions.assertEquals(expected, Conversions.byteArray2Long(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getByteLengths"})
     void testByteArray2LongComposed(int bytes) {
         final byte[] seed = new byte[bytes];
         ThreadLocalRandom.current().nextBytes(seed);
         final long expected = new LongArray2Long().convert(new ByteArray2LongArray().convert(seed));
         Assertions.assertEquals(expected, Conversions.byteArray2Long(seed));
     }

     @ParameterizedTest
     @MethodSource(value = {"getByteLengths"})
     void testByteArray2LongArray(int bytes) {
         final byte[] seed = new byte[bytes];
         ThreadLocalRandom.current().nextBytes(seed);

         // Concatenate all bytes in little-endian order to bytes
         final int outLength = Conversions.longSizeFromByteSize(bytes);
         final byte[] filledSeed = Arrays.copyOf(seed, outLength * Long.BYTES);
         final ByteBuffer bb = ByteBuffer.wrap(filledSeed)
                 .order(ByteOrder.LITTLE_ENDIAN);
         final long[] expected = new long[outLength];
         for (int i = 0; i < outLength; i++) {
             expected[i] = bb.getLong();
         }

         Assertions.assertArrayEquals(expected, Conversions.byteArray2LongArray(seed, outLength));
         // Zero fill
         Assertions.assertArrayEquals(Arrays.copyOf(expected, outLength * 2),
             Conversions.byteArray2LongArray(seed, outLength * 2));
         // Truncation
         for (int i = 0; i < outLength; i++) {
             Assertions.assertArrayEquals(Arrays.copyOf(expected, i), Conversions.byteArray2LongArray(seed, i));
         }
     }
 }
	/*
	* 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.simple.internal;

	import java.nio.ByteBuffer;
	import java.nio.ByteOrder;
	import java.util.Arrays;
	import java.util.concurrent.ThreadLocalRandom;
	import java.util.stream.IntStream;
	import java.util.stream.LongStream;
	import org.apache.commons.rng.core.source64.SplitMix64;
	import org.apache.commons.rng.core.util.NumberFactory;
	import org.junit.jupiter.api.Assertions;
	import org.junit.jupiter.api.RepeatedTest;
	import org.junit.jupiter.api.Test;
	import org.junit.jupiter.params.ParameterizedTest;
	import org.junit.jupiter.params.provider.MethodSource;
	import org.junit.jupiter.params.provider.ValueSource;

	/**
	* Tests for {@link Conversions}.
	*/
	class ConversionsTest {
	/**
	* The fractional part of the the golden ratio, phi, scaled to 64-bits and rounded to odd.
	* <pre>
	* phi = (sqrt(5) - 1) / 2) * 2^64
	* </pre>
	* @see <a href="https://en.wikipedia.org/wiki/Golden_ratio">Golden ratio</a>
	*/
	private static final long GOLDEN_RATIO = 0x9e3779b97f4a7c15L;

	/**
	* Gets the lengths for the byte[] seeds to convert.
	*
	* @return the lengths
	*/
	static IntStream getByteLengths() {
	return IntStream.rangeClosed(0, Long.BYTES * 2);
	}

	/**
	* Gets the lengths for the int[] seeds to convert.
	*
	* @return the lengths
	*/
	static IntStream getIntLengths() {
	return IntStream.rangeClosed(0, (Long.BYTES / Integer.BYTES) * 2);
	}

	/**
	* Gets the lengths for the long[] seeds to convert.
	*
	* @return the lengths
	*/
	static IntStream getLongLengths() {
	return IntStream.rangeClosed(0, 2);
	}

	@ParameterizedTest
	@ValueSource(ints = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE})
	void testIntSizeFromByteSize(int size) {
	Assertions.assertEquals((int) Math.ceil((double) size / Integer.BYTES), Conversions.intSizeFromByteSize(size));
	}

	@ParameterizedTest
	@ValueSource(ints = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, Integer.MAX_VALUE})
	void testLongSizeFromByteSize(int size) {
	Assertions.assertEquals((int) Math.ceil((double) size / Long.BYTES), Conversions.longSizeFromByteSize(size));
	}

	@ParameterizedTest
	@ValueSource(ints = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE})
	void testIntSizeFromLongSize(int size) {
	Assertions.assertEquals((int) Math.min(size * 2L, Integer.MAX_VALUE), Conversions.intSizeFromLongSize(size));
	}

	@ParameterizedTest
	@ValueSource(ints = {0, 1, 2, 3, 4, 5, Integer.MAX_VALUE})
	void testLongSizeFromIntSize(int size) {
	Assertions.assertEquals((int) Math.ceil((double) size / 2), Conversions.longSizeFromIntSize(size));
	}

	@RepeatedTest(value = 5)
	void testInt2Long() {
	final int v = ThreadLocalRandom.current().nextInt();
	Assertions.assertEquals(new SplitMix64(v).nextLong(), Conversions.int2Long(v));
	}

	@RepeatedTest(value = 5)
	void testInt2IntArray() {
	final int v = ThreadLocalRandom.current().nextInt();
	getIntLengths().forEach(len -> {
	Assertions.assertArrayEquals(Conversions.long2IntArray(v, len),
	Conversions.int2IntArray(v, len));
	});
	}

	@RepeatedTest(value = 5)
	void testInt2LongArray() {
	final int v = ThreadLocalRandom.current().nextInt();
	getIntLengths().forEach(len -> {
	final long[] a = Conversions.int2LongArray(v, len);
	Assertions.assertArrayEquals(Conversions.long2LongArray(v, len), a);
	if (len != 0) {
	// Special case of expansion to length 1
	// Expandion is done by mixing
	Assertions.assertEquals(Conversions.int2Long(v), a[0]);
	}
	});
	}

	@RepeatedTest(value = 5)
	void testLong2Int() {
	final long v = ThreadLocalRandom.current().nextLong();
	Assertions.assertEquals(NumberFactory.makeInt(v), Conversions.long2Int(v));
	}

	@RepeatedTest(value = 5)
	void testLong2IntArray() {
	// Avoid seed == 0 - 0x9e3779b97f4a7c15L. See testLong2IntArrayLength2NotAllZero.
	long seed;
	do {
	seed = ThreadLocalRandom.current().nextLong();
	} while (seed == -GOLDEN_RATIO);
	final long v = seed;
	getIntLengths().forEach(len -> {
	final int longs = Conversions.longSizeFromIntSize(len);
	// Little-endian conversion
	final ByteBuffer bb = ByteBuffer.allocate(longs * Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
	LongStream.generate(new SplitMix64(v)::nextLong).limit(longs).forEach(bb::putLong);
	bb.clear();
	final int[] expected = new int[len];
	for (int i = 0; i < len; i++) {
	expected[i] = bb.getInt();
	}
	Assertions.assertArrayEquals(expected,
	Conversions.long2IntArray(v, len));

	// Note:
	// long -> int[] position[0] != long -> int
	// Reduction is done by folding upper and lower using xor
	});
	}

	/**
	* Test the long2IntArray conversion avoids an input that will generate a zero from the
	* SplitMix64-style RNG. This prevents creating an array of length 2 that is zero.
	*
	* <p>This special case avoids creating a small state Xor-based generator such as
	* XoRoShiRo64StarStar with a seed of all zeros.
	*/
	@Test
	void testLong2IntArrayLength2NotAllZero() {
	// The first output from the SplitMix64 is mix(seed + GOLDEN_RATIO).
	// Create the seed to ensure a zero output from the mix function.
	final long seed = -GOLDEN_RATIO;
	Assertions.assertEquals(0, new SplitMix64(seed).nextLong());

	// Note: This cannot occur for int2IntArray as the SplitMix64 is seeded with the int.
	// This ignores the case of an output int[] of length 1 which could be zero.
	// An int -> int[1] conversion is nonsensical and should not be performed by the library.
	Assertions.assertNotEquals(0, new SplitMix64((int) seed).nextLong());

	// The conversion should detect this case and a zero seed of length 2 should not happen.
	final int[] actual = Conversions.long2IntArray(seed, 2);
	Assertions.assertFalse(Arrays.equals(new int[2], actual));

	// Longer arrays may be a partially zero as the generator state passes through
	// the zero-point.
	Assertions.assertArrayEquals(
	Arrays.copyOf(Conversions.long2IntArray(seed - GOLDEN_RATIO, 2), 4),
	Conversions.long2IntArray(seed - GOLDEN_RATIO, 4));
	}

	@RepeatedTest(value = 5)
	void testLong2LongArray() {
	final long v = ThreadLocalRandom.current().nextLong();
	getIntLengths().forEach(len -> {
	Assertions.assertArrayEquals(LongStream.generate(new SplitMix64(v)::nextLong).limit(len).toArray(),
	Conversions.long2LongArray(v, len));
	});
	}

	@ParameterizedTest
	@MethodSource(value = {"getIntLengths"})
	void testIntArray2Int(int ints) {
	final int[] seed = ThreadLocalRandom.current().ints(ints).toArray();
	// xor all the bytes
	int expected = 0;
	for (final int i : seed) {
	expected ^= i;
	}
	Assertions.assertEquals(expected, Conversions.intArray2Int(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getIntLengths"})
	void testIntArray2Long(int ints) {
	final int[] seed = ThreadLocalRandom.current().ints(ints).toArray();

	// int[] -> long[] -> long
	// Concatenate all ints in little-endian order to bytes
	final int outLength = Conversions.longSizeFromIntSize(ints);
	final int[] filledSeed = Arrays.copyOf(seed, outLength * 2);
	final ByteBuffer bb = ByteBuffer.allocate(filledSeed.length * Integer.BYTES)
	.order(ByteOrder.LITTLE_ENDIAN);
	Arrays.stream(filledSeed).forEach(bb::putInt);
	// xor all the bytes read as longs
	long expected = 0;
	bb.flip();
	for (int i = outLength; i-- != 0;) {
	final long l = bb.getLong();
	expected ^= l;
	}

	Assertions.assertEquals(expected, Conversions.intArray2Long(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getIntLengths"})
	void testIntArray2LongComposed(int ints) {
	final int[] seed = ThreadLocalRandom.current().ints(ints).toArray();
	final long expected = new LongArray2Long().convert(new IntArray2LongArray().convert(seed));
	Assertions.assertEquals(expected, Conversions.intArray2Long(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getIntLengths"})
	void testIntArray2LongArray(int ints) {
	final int[] seed = ThreadLocalRandom.current().ints(ints).toArray();

	// Concatenate all bytes in little-endian order to bytes
	final int outLength = Conversions.longSizeFromIntSize(ints);
	final ByteBuffer bb = ByteBuffer.allocate(outLength * Long.BYTES)
	.order(ByteOrder.LITTLE_ENDIAN);
	Arrays.stream(seed).forEach(bb::putInt);
	bb.clear();
	final long[] expected = new long[outLength];
	for (int i = 0; i < outLength; i++) {
	expected[i] = bb.getLong();
	}

	Assertions.assertArrayEquals(expected, Conversions.intArray2LongArray(seed, outLength));
	// Zero fill
	Assertions.assertArrayEquals(Arrays.copyOf(expected, outLength * 2),
	Conversions.intArray2LongArray(seed, outLength * 2));
	// Truncation
	for (int i = 0; i < outLength; i++) {
	Assertions.assertArrayEquals(Arrays.copyOf(expected, i), Conversions.intArray2LongArray(seed, i));
	}
	}

	@ParameterizedTest
	@MethodSource(value = {"getLongLengths"})
	void testLongArray2Int(long longs) {
	final long[] seed = ThreadLocalRandom.current().longs(longs).toArray();
	// xor all the bytes
	long expected = 0;
	for (final long i : seed) {
	expected ^= i;
	}
	Assertions.assertEquals((int) (expected ^ expected >>> 32), Conversions.longArray2Int(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getLongLengths"})
	void testLongArray2Long(long longs) {
	final long[] seed = ThreadLocalRandom.current().longs(longs).toArray();
	// xor all the bytes
	long expected = 0;
	for (final long i : seed) {
	expected ^= i;
	}
	Assertions.assertEquals(expected, Conversions.longArray2Long(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getLongLengths"})
	void testLongArray2IntArray(int longs) {
	final long[] seed = ThreadLocalRandom.current().longs(longs).toArray();

	// Concatenate all bytes in little-endian order to bytes
	final int outLength = Conversions.intSizeFromLongSize(longs);
	final ByteBuffer bb = ByteBuffer.allocate(longs * Long.BYTES)
	.order(ByteOrder.LITTLE_ENDIAN);
	Arrays.stream(seed).forEach(bb::putLong);
	bb.clear();
	final int[] expected = new int[outLength];
	for (int i = 0; i < outLength; i++) {
	expected[i] = bb.getInt();
	}

	Assertions.assertArrayEquals(expected, Conversions.longArray2IntArray(seed, outLength));
	// Zero fill
	Assertions.assertArrayEquals(Arrays.copyOf(expected, outLength * 2),
	Conversions.longArray2IntArray(seed, outLength * 2));
	// Truncation
	for (int i = 0; i < outLength; i++) {
	Assertions.assertArrayEquals(Arrays.copyOf(expected, i), Conversions.longArray2IntArray(seed, i));
	}
	}

	@ParameterizedTest
	@MethodSource(value = {"getByteLengths"})
	void testByteArray2Int(int bytes) {
	final byte[] seed = new byte[bytes];
	ThreadLocalRandom.current().nextBytes(seed);

	// byte[] -> int[] -> int
	// Concatenate all bytes in little-endian order to bytes
	final int outLength = Conversions.intSizeFromByteSize(bytes);
	final byte[] filledSeed = Arrays.copyOf(seed, outLength * Integer.BYTES);
	final ByteBuffer bb = ByteBuffer.wrap(filledSeed)
	.order(ByteOrder.LITTLE_ENDIAN);
	// xor all the bytes read as ints
	int expected = 0;
	for (int i = outLength; i-- != 0;) {
	final long l = bb.getInt();
	expected ^= l;
	}

	Assertions.assertEquals(expected, Conversions.byteArray2Int(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getByteLengths"})
	void testByteArray2IntComposed(int bytes) {
	final byte[] seed = new byte[bytes];
	ThreadLocalRandom.current().nextBytes(seed);
	final int expected = new IntArray2Int().convert(new ByteArray2IntArray().convert(seed));
	Assertions.assertEquals(expected, Conversions.byteArray2Int(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getByteLengths"})
	void testByteArray2IntArray(int bytes) {
	final byte[] seed = new byte[bytes];
	ThreadLocalRandom.current().nextBytes(seed);

	// Concatenate all bytes in little-endian order to bytes
	final int outLength = Conversions.intSizeFromByteSize(bytes);
	final byte[] filledSeed = Arrays.copyOf(seed, outLength * Integer.BYTES);
	final ByteBuffer bb = ByteBuffer.wrap(filledSeed)
	.order(ByteOrder.LITTLE_ENDIAN);
	final int[] expected = new int[outLength];
	for (int i = 0; i < outLength; i++) {
	expected[i] = bb.getInt();
	}

	Assertions.assertArrayEquals(expected, Conversions.byteArray2IntArray(seed, outLength));
	// Zero fill
	Assertions.assertArrayEquals(Arrays.copyOf(expected, outLength * 2),
	Conversions.byteArray2IntArray(seed, outLength * 2));
	// Truncation
	for (int i = 0; i < outLength; i++) {
	Assertions.assertArrayEquals(Arrays.copyOf(expected, i), Conversions.byteArray2IntArray(seed, i));
	}
	}

	@ParameterizedTest
	@MethodSource(value = {"getByteLengths"})
	void testByteArray2Long(int bytes) {
	final byte[] seed = new byte[bytes];
	ThreadLocalRandom.current().nextBytes(seed);

	// byte[] -> long[] -> long
	// Concatenate all bytes in little-endian order to bytes
	final int outLength = Conversions.longSizeFromByteSize(bytes);
	final byte[] filledSeed = Arrays.copyOf(seed, outLength * Long.BYTES);
	final ByteBuffer bb = ByteBuffer.wrap(filledSeed)
	.order(ByteOrder.LITTLE_ENDIAN);
	// xor all the bytes read as longs
	long expected = 0;
	for (int i = outLength; i-- != 0;) {
	final long l = bb.getLong();
	expected ^= l;
	}

	Assertions.assertEquals(expected, Conversions.byteArray2Long(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getByteLengths"})
	void testByteArray2LongComposed(int bytes) {
	final byte[] seed = new byte[bytes];
	ThreadLocalRandom.current().nextBytes(seed);
	final long expected = new LongArray2Long().convert(new ByteArray2LongArray().convert(seed));
	Assertions.assertEquals(expected, Conversions.byteArray2Long(seed));
	}

	@ParameterizedTest
	@MethodSource(value = {"getByteLengths"})
	void testByteArray2LongArray(int bytes) {
	final byte[] seed = new byte[bytes];
	ThreadLocalRandom.current().nextBytes(seed);

	// Concatenate all bytes in little-endian order to bytes
	final int outLength = Conversions.longSizeFromByteSize(bytes);
	final byte[] filledSeed = Arrays.copyOf(seed, outLength * Long.BYTES);
	final ByteBuffer bb = ByteBuffer.wrap(filledSeed)
	.order(ByteOrder.LITTLE_ENDIAN);
	final long[] expected = new long[outLength];
	for (int i = 0; i < outLength; i++) {
	expected[i] = bb.getLong();
	}

	Assertions.assertArrayEquals(expected, Conversions.byteArray2LongArray(seed, outLength));
	// Zero fill
	Assertions.assertArrayEquals(Arrays.copyOf(expected, outLength * 2),
	Conversions.byteArray2LongArray(seed, outLength * 2));
	// Truncation
	for (int i = 0; i < outLength; i++) {
	Assertions.assertArrayEquals(Arrays.copyOf(expected, i), Conversions.byteArray2LongArray(seed, i));
	}
	}
	}