libraries/stdlib/test/random/RandomTest.kt - third_party/github/JetBrains/kotlin - Git at Google

 /*
  * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */

 package test.random

 import kotlin.math.*
 import kotlin.native.concurrent.ThreadLocal
 import kotlin.random.*
 import kotlin.test.*

 abstract class RandomSmokeTest {
     abstract val subject: Random

     @Test
     fun nextBits() {
         repeat(100) {
             assertEquals(0, subject.nextBits(0))
         }

         for (bitCount in 1..32) {
             val upperBitCount = 32 - bitCount
             var result1 = 0
             var result2 = -1
             repeat(1000) {
                 val bits = subject.nextBits(bitCount)
                 result1 = result1 or bits
                 result2 = result2 and bits

                 assertEquals(0, bits.ushr(bitCount - 1).ushr(1), "Upper $upperBitCount bits should be zero")
             }

             assertEquals(1.shl(bitCount - 1).shl(1) - 1, result1, "Lower $bitCount bits should be filled")
             assertEquals(0, result2, "All zero bits should present")
         }
     }


     @Test
     fun nextInt() {
         var result1 = 0
         var result2 = -1
         repeat(1000) {
             val r = subject.nextInt()
             result1 = result1 or r
             result2 = result2 and r
         }
         assertEquals(-1, result1, "All one bits should present")
         assertEquals(0, result2, "All zero bits should present")
     }

     @Test
     fun nextUInt() {
         var result1 = 0u
         var result2 = UInt.MAX_VALUE
         repeat(1000) {
             val r = subject.nextUInt()
             result1 = result1 or r
             result2 = result2 and r
         }
         assertEquals(UInt.MAX_VALUE, result1, "All one bits should be present")
         assertEquals(0u, result2, "All zero bits should present")

     }

     @Test
     fun nextIntUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextInt(0) }
         assertFailsWith<IllegalArgumentException> { subject.nextInt(-1) }
         assertFailsWith<IllegalArgumentException> { subject.nextInt(Int.MIN_VALUE) }

         repeat(1000) {
             assertEquals(0, subject.nextInt(1))
         }

         for (bound in listOf(2, 3, 7, 16, 32, 0x4000_0000, Int.MAX_VALUE)) {
             repeat(1000) {
                 val x = subject.nextInt(bound)
                 if (x !in 0 until bound)
                     fail("Value $x must be in range [0, $bound)")
             }
         }
     }

     @Test
     fun nextUIntUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextUInt(UInt.MIN_VALUE) }

         repeat(1000) {
             assertEquals(0u, subject.nextUInt(1u))
         }

         for (bound in listOf(2u, 3u, 7u, 16u, 32u, 0x4000_0000u, UInt.MAX_VALUE)) {
             repeat(1000) {
                 val x = subject.nextUInt(bound)
                 if (x !in 0u until bound)
                     fail("Value $x must be in range [0, $bound)")
             }
         }
     }

     @Test
     fun nextIntFromUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextInt(0, 0) }
         assertFailsWith<IllegalArgumentException> { subject.nextInt(-1, -2) }
         assertFailsWith<IllegalArgumentException> { subject.nextInt(Int.MIN_VALUE, Int.MIN_VALUE) }

         for (n in Int.MIN_VALUE until Int.MAX_VALUE step 0x10000) {
             assertEquals(n, subject.nextInt(n, n + 1))
         }
         (Int.MAX_VALUE - 1).let { n ->
             assertEquals(n, subject.nextInt(n, n + 1))
         }

         for ((from, until) in listOf((0 to 2), (-1 to 5), (0 to 32), (0 to Int.MAX_VALUE), (-1 to Int.MAX_VALUE), (Int.MIN_VALUE to Int.MAX_VALUE))) {
             repeat(1000) {
                 val x = subject.nextInt(from, until)
                 if (x !in from until until)
                     fail("Value $x must be in range [$from, $until)")
             }
         }
     }

     @Test
     fun nextUIntFromUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextUInt(0u, 0u) }
         assertFailsWith<IllegalArgumentException> { subject.nextUInt((-1).toUInt(), (-2).toUInt()) }
         assertFailsWith<IllegalArgumentException> { subject.nextUInt(UInt.MIN_VALUE, UInt.MIN_VALUE) }

         for (n in UInt.MIN_VALUE until UInt.MAX_VALUE step 0x10000) {
             assertEquals(n, subject.nextUInt(n, n + 1u))
         }
         (UInt.MAX_VALUE - 1u).let { n ->
             assertEquals(n, subject.nextUInt(n, n + 1u))
         }

         for ((from, until) in listOf((0u to 2u), (1u to 6u), (0u to 32u), (0u to UInt.MAX_VALUE), (1u to (Int.MAX_VALUE.toUInt() + 1u)), (UInt.MIN_VALUE to UInt.MAX_VALUE))) {
             repeat(1000) {
                 val x = subject.nextUInt(from, until)
                 if (x !in from until until)
                     fail("Value $x must be in range [$from, $until)")
             }
         }
     }

     @Suppress("EmptyRange")
     @Test
     fun nextIntInIntRange() {
         assertFailsWith<IllegalArgumentException> { subject.nextInt(0 until 0) }
         assertFailsWith<IllegalArgumentException> { subject.nextInt(-1..Int.MIN_VALUE) }
         assertFailsWith<IllegalArgumentException> { subject.nextInt(Int.MAX_VALUE until Int.MAX_VALUE) }

         repeat(1000) { n ->
             assertEquals(n, subject.nextInt(n..n))
         }

         for (range in listOf((0 until 2), (-1 until 5), (0 until 32), (0 until Int.MAX_VALUE),
                              (0..Int.MAX_VALUE), (Int.MIN_VALUE..0), (Int.MIN_VALUE..Int.MAX_VALUE))) {
             repeat(1000) {
                 val x = subject.nextInt(range)
                 if (x !in range)
                     fail("Value $x must be in range $range")
             }
         }
     }

     @Test
     fun nextUIntInUIntRange() {
         assertFailsWith<IllegalArgumentException> { subject.nextUInt(1u..0u) }
         assertFailsWith<IllegalArgumentException> { subject.nextUInt(UInt.MAX_VALUE..UInt.MIN_VALUE) }
         assertFailsWith<IllegalArgumentException> { subject.nextUInt(UInt.MAX_VALUE..(UInt.MAX_VALUE - 1u)) }

         repeat(1000) { it ->
             val n = it.toUInt()
             assertEquals(n, subject.nextUInt(n..n))
         }

         for (range in listOf(
             (0u..1u),
             (1u..5u),
             (0u..31u),
             (0u..UInt.MAX_VALUE - 1u),
             (1u..UInt.MAX_VALUE),
             (0u..UInt.MAX_VALUE)
         )) {
             repeat(1000) {
                 val x = subject.nextUInt(range)
                 if (x !in range)
                     fail("Value $x must be in range $range")
             }
         }
     }

     @Test
     fun nextLong() {
         var result1 = 0L
         var result2 = -1L
         repeat(1000) {
             val r = subject.nextLong()
             result1 = result1 or r
             result2 = result2 and r
         }
         assertEquals(-1, result1, "All one bits should present")
         assertEquals(0, result2, "All zero bits should present")
     }

     @Test
     fun nextULong() {
         var result1 = 0uL
         var result2 = ULong.MAX_VALUE
         repeat(1000) {
             val r = subject.nextULong()
             result1 = result1 or r
             result2 = result2 and r
         }

         assertEquals(ULong.MAX_VALUE, result1, "All one bits should be present")
         assertEquals(0uL, result2, "All zero bits should be present")
     }

     @Test
     fun nextLongUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextLong(0) }
         assertFailsWith<IllegalArgumentException> { subject.nextLong(-1) }
         assertFailsWith<IllegalArgumentException> { subject.nextLong(Long.MIN_VALUE) }

         repeat(1000) {
             assertEquals(0L, subject.nextLong(1))
         }

         for (bound in listOf(2, 23, 32, 0x1_0000_0000, 0x4_0000_0000, 0x4000_0000_0000_0000, Long.MAX_VALUE)) {
             repeat(1000) {
                 val x = subject.nextLong(bound)
                 if (x !in 0L until bound)
                     fail("Value $x must be in range [0, $bound)")
             }
         }
     }

     @Test
     fun nextULongUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextULong(ULong.MIN_VALUE) }

         repeat(1000) {
             assertEquals(0uL, subject.nextULong(1uL))
         }

         for (bound in listOf(2uL, 23uL, 32uL, 0x1_0000_0000uL, 0x4_0000_0000uL, 0x8000_0000_0000_000uL, ULong.MAX_VALUE)) {
             repeat(1000) {
                 val x = subject.nextULong(bound)
                 if (x !in 0uL until bound) {
                     fail("Value $x must be in range [0, $bound)")
                 }
             }
         }
     }

     @Test
     fun nextLongFromUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextLong(0, 0) }
         assertFailsWith<IllegalArgumentException> { subject.nextLong(-1, -2) }
         assertFailsWith<IllegalArgumentException> { subject.nextLong(Long.MIN_VALUE, Long.MIN_VALUE) }

         for (i in -500..500) {
             val n = 0x1_0000_0000 + i
             assertEquals(n, subject.nextLong(n, n + 1))
         }

         for ((from, until) in listOf((0L to 32L), (-1L to 5L), (0L to 0x1_0000_0000), (-0x10L to 0x3_FFFF_FFF0L),
                                      (0L to Long.MAX_VALUE), (-1L to Long.MAX_VALUE), (Long.MIN_VALUE to Long.MAX_VALUE))) {
             repeat(1000) {
                 val x = subject.nextLong(from, until)
                 if (x !in from until until)
                     fail("Value $x must be in range [$from, $until)")
             }
         }
     }

     @Test
     fun nextULongFromUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextULong(0uL, 0uL) }
         assertFailsWith<IllegalArgumentException> { subject.nextULong((-1).toULong(), (-2).toULong()) }

         for (i in 0u..1000u) {
             val n = 0x1_0000_0000uL - 500u + i
             assertEquals(n, subject.nextULong(n, n + 1uL))
         }

         for ((from, until) in listOf(
             (0uL to 32uL),
             (1uL to 6uL),
             (0uL to 0x1_0000_0000.toULong()),
             (0x10uL to 0x4_0000_0010.toULong()),
             (0uL to ULong.MAX_VALUE)
         )) {
             repeat(1000) {
                 val x = subject.nextULong(from, until)
                 if (x !in from until until) {
                     fail("Value $x must be in range [$from, $until)")
                 }
             }
         }
     }

     @Suppress("EmptyRange")
     @Test
     fun nextLongInLongRange() {
         assertFailsWith<IllegalArgumentException> { subject.nextLong(0L until 0L) }
         assertFailsWith<IllegalArgumentException> { subject.nextLong(-1..Long.MIN_VALUE) }
         assertFailsWith<IllegalArgumentException> { subject.nextLong(Long.MAX_VALUE until Long.MAX_VALUE) }

         repeat(1000) { i ->
             val n = 0x1_0000_0000 - 500 + i
             assertEquals(n, subject.nextLong(n..n))
         }

         for (range in listOf((0L until 2L), (-1L until 5L), (0L until 32L), (0L until 1L.shl(33)), (0L until Long.MAX_VALUE),
                              (0L..Long.MAX_VALUE), (Long.MIN_VALUE..0L), (Long.MIN_VALUE..Long.MAX_VALUE))) {
             repeat(1000) {
                 val x = subject.nextLong(range)
                 if (x !in range)
                     fail("Value $x must be in range $range")
             }
         }
     }

     @Test
     fun nextULongInULongRange() {
         assertFailsWith<IllegalArgumentException> { subject.nextULong(1uL..0uL) }
         assertFailsWith<IllegalArgumentException> { subject.nextULong(ULong.MAX_VALUE..ULong.MIN_VALUE) }
         assertFailsWith<IllegalArgumentException> { subject.nextULong(ULong.MAX_VALUE..(ULong.MAX_VALUE - 1uL))}

         repeat(1000) { i ->
             val n = (0x1_0000_0000).toULong() - 500uL + i.toULong()
             assertEquals(n, subject.nextULong(n..n))
         }

         for (range in listOf(
             (0uL..1uL),
             (1uL..5uL),
             (0uL..31uL),
             (0uL until 0x4_0000_0000uL),
             (0uL..(ULong.MAX_VALUE - 1uL)),
             (1uL..ULong.MAX_VALUE),
             (0uL..ULong.MAX_VALUE)
         )) {
             repeat(1000) {
                 val x = subject.nextULong(range)
                 if (x !in range) {
                     fail("Value $x must be in range $range")
                 }
             }
         }

     }


     @Test
     fun nextDouble() {
         repeat(10000) {
             val d = subject.nextDouble()
             if (!(d >= 0.0 && d < 1)) {
                 fail("Random double $d is out of range")
             }
         }
     }

     @Test
     fun nextDoubleUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(-1.0) }
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(-0.0) }
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(0.0) }
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(Double.NaN) }

         repeat(100) {
             assertEquals(0.0, subject.nextDouble(0.0.nextUp()))
         }

         assertTrue(subject.nextDouble(Double.POSITIVE_INFINITY).isFinite(), "Infinity is exclusive")

         for (bound in listOf(1.0, 100.0, 1024.0, Double.MAX_VALUE)) {
             repeat(1000) {
                 val d = subject.nextDouble(bound)
                 if (!(d >= 0.0 && d < bound)) {
                     fail("Random double $d is out of range [0, $bound)")
                 }
             }
         }
     }

     @Test
     fun nextDoubleFromUntil() {
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(0.0, -1.0) }
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(0.0, Double.NaN) }
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(Double.NaN, 0.0) }
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(Double.NaN, Double.POSITIVE_INFINITY) }
         assertFailsWith<IllegalArgumentException> { subject.nextDouble(Double.MAX_VALUE, Double.MAX_VALUE) }

         for (exp in -1022..1023) {
             val origin = 2.0.pow(exp)
             assertEquals(origin, subject.nextDouble(origin, origin.nextUp()), "2^$exp")
             assertEquals(-origin, subject.nextDouble(-origin, (-origin).nextUp()), "-(2^$exp)")
         }

         run {
             val size = 1000
             val fullRangeValues = (1..size).map { subject.nextDouble(-Double.MAX_VALUE, Double.MAX_VALUE) }.distinct()
             fullRangeValues.forEach {
                 assertTrue(it.isFinite() && it < Double.MAX_VALUE)
             }
             assertTrue(fullRangeValues.size >= (size * 0.995), "All values should be distinct, but only ${fullRangeValues.size} of them are")
         }

         for ((from, until) in listOf(0.0 to 1.0, -1.0 to 1.0, 0.0 to 100.0, -PI to PI, 0.0 to Double.MAX_VALUE)) {
             repeat(1000) {
                 val d = subject.nextDouble(from, until)
                 if (!(d >= from && d < until)) {
                     fail("Random double $d is out of range [$from, $until)")
                 }
             }
         }
     }

     @Test
     fun nextFloat() {
         repeat(10000) {
             val d = subject.nextFloat()
             if (!(d >= 0.0F && d < 1.0F)) {
                 fail("Random float $d is out of range")
             }
         }
     }

     @Test
     fun nextBoolean() {
         val size = 10000
         val booleans = (1..size).map { subject.nextBoolean() }.groupingBy { it }.eachCount()
         val ts = booleans[true]!!
         val fs = booleans[false]!!

         assertNotEquals(0, ts)
         assertNotEquals(0, fs)

         val skew = abs(ts.toDouble() - fs.toDouble()) / size
         assertTrue(skew < 0.10, "Boolean generator is skewed: $booleans, delta is $skew")
     }

     @Test
     fun nextBytes() {
         val size = 20
         val bytes1 = subject.nextBytes(size)
         assertEquals(size, bytes1.size)
         assertTrue(bytes1.any { it != 0.toByte() })

         val bytes2 = subject.nextBytes(ByteArray(size))
         assertEquals(size, bytes2.size)
         assertTrue(bytes2.any { it != 0.toByte() })

         assertFalse(bytes1 contentEquals bytes2)
     }

     @Test
     fun nextUBytes() {
         val size = 20
         val ubytes1 = subject.nextUBytes(size)
         assertEquals(size, ubytes1.size)
         assertTrue(ubytes1.any { it != 0.toUByte() })

         val ubytes2 = subject.nextUBytes(UByteArray(size))
         assertEquals(size, ubytes2.size)
         assertTrue(ubytes2.any { it != 0.toUByte() })

         assertFalse(ubytes1 contentEquals ubytes2)
     }

     @Test
     fun nextBytesRange() {
         val size = 100
         val array = subject.nextBytes(size)

         assertFailsWith<IllegalArgumentException> { subject.nextBytes(array, -1, 10) }
         assertFailsWith<IllegalArgumentException> { subject.nextBytes(array, 0, size + 10) }
         assertFailsWith<IllegalArgumentException> { subject.nextBytes(array, 10, 0) }

         repeat(10000) {
             val from = subject.nextInt(0, size - 1)
             val to = subject.nextInt(from + 1, size)

             val prev = array.copyOf()
             subject.nextBytes(array, from, to)

             var noChanges = array contentEquals prev
             val rangeSize = to - from
             val retries = 4 / rangeSize
             var n = 0
             while (noChanges && n < retries) {
                 // there's a small chance that a small range will get the same value as before
                 // run randomization again
                 subject.nextBytes(array, from, to)
                 noChanges = array contentEquals prev
                 n++
             }

             if (noChanges) {
                 fail("Something should have changed in array after subrange [$from, $to) randomization (${1 + retries} times): " +
                              array.copyOfRange(from, to).contentToString())
             }

             for (p in 0 until from) {
                 assertEquals(prev[p], array[p])
             }
             for (p in to until size) {
                 assertEquals(prev[p], array[p])
             }
         }
     }

     @Test
     fun nextUBytesRange() {
         val size = 100
         val array = subject.nextUBytes(size)

         assertFailsWith<IllegalArgumentException> { subject.nextUBytes(array, -1, 10) }
         assertFailsWith<IllegalArgumentException> { subject.nextUBytes(array, 0, size + 10) }
         assertFailsWith<IllegalArgumentException> { subject.nextUBytes(array, 10, 0) }

         repeat(10000) {
             val from = subject.nextInt(0, size - 1)
             val to = subject.nextInt(from + 1, size)

             val prev = array.copyOf()

             subject.nextUBytes(array, from, to)

             var noChanges = array contentEquals prev
             val rangeSize = to - from

             val retries = 4 / rangeSize

             var n = 0
             while(noChanges && n < retries) {
                 // there's a small chance that a small range will get the same value as before
                 // run randomization again
                 subject.nextUBytes(array, from, to)
                 noChanges = array contentEquals prev
                 n++
             }

             if(noChanges) {
                 fail("Something should have changed in array after subrange [$from, $to) randomization (${1 + retries} times: " +
                              array.copyOfRange(from, to).contentToString())
             }

             for (p in 0 until from) {
                 assertEquals(prev[p], array[p])
             }

             for (p in to until size) {
                 assertEquals(prev[p], array[p])
             }

         }
     }
 }


 class DefaultRandomSmokeTest : RandomSmokeTest() {
     override val subject: Random get() = Random
 }

 @ThreadLocal
 internal val seededRandomSmokeTestSubject = Random(Random.nextInt().also { println("Seed: $it") })

 class SeededRandomSmokeTest : RandomSmokeTest() {
     override val subject: Random get() = seededRandomSmokeTestSubject

     @Test
     fun sameIntSeed() {
         val v = subject.nextInt(1..Int.MAX_VALUE)
         for (seed in listOf(v, -v)) {
             testSameSeededRandoms(Random(seed), Random(seed), seed)
         }
     }

     @Test
     fun sameLongSeed() {
         val v = subject.nextLong(1..Long.MAX_VALUE)
         for (seed in listOf(v, -v)) {
             testSameSeededRandoms(Random(seed), Random(seed), seed)
         }
     }

     @Test
     fun sameIntLongSeed() {
         val v = subject.nextInt(1..Int.MAX_VALUE)
         for (seed in listOf(v, 0, -v)) {
             testSameSeededRandoms(Random(seed), Random(seed.toLong()), seed)
         }
     }

     private fun testSameSeededRandoms(r1: Random, r2: Random, seed: Any) {
         val seq1 = List(10) { r1.nextInt() }
         val seq2 = List(10) { r2.nextInt() }
 //        println("$seed: $seq1")

         assertEquals(seq1, seq2, "Generators seeded with $seed should produce the same output")
     }
 }
	/*
	* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
	* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
	*/

	package test.random

	import kotlin.math.*
	import kotlin.native.concurrent.ThreadLocal
	import kotlin.random.*
	import kotlin.test.*

	abstract class RandomSmokeTest {
	abstract val subject: Random

	@Test
	fun nextBits() {
	repeat(100) {
	assertEquals(0, subject.nextBits(0))
	}

	for (bitCount in 1..32) {
	val upperBitCount = 32 - bitCount
	var result1 = 0
	var result2 = -1
	repeat(1000) {
	val bits = subject.nextBits(bitCount)
	result1 = result1 or bits
	result2 = result2 and bits

	assertEquals(0, bits.ushr(bitCount - 1).ushr(1), "Upper $upperBitCount bits should be zero")
	}

	assertEquals(1.shl(bitCount - 1).shl(1) - 1, result1, "Lower $bitCount bits should be filled")
	assertEquals(0, result2, "All zero bits should present")
	}
	}


	@Test
	fun nextInt() {
	var result1 = 0
	var result2 = -1
	repeat(1000) {
	val r = subject.nextInt()
	result1 = result1 or r
	result2 = result2 and r
	}
	assertEquals(-1, result1, "All one bits should present")
	assertEquals(0, result2, "All zero bits should present")
	}

	@Test
	fun nextUInt() {
	var result1 = 0u
	var result2 = UInt.MAX_VALUE
	repeat(1000) {
	val r = subject.nextUInt()
	result1 = result1 or r
	result2 = result2 and r
	}
	assertEquals(UInt.MAX_VALUE, result1, "All one bits should be present")
	assertEquals(0u, result2, "All zero bits should present")

	}

	@Test
	fun nextIntUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextInt(0) }
	assertFailsWith<IllegalArgumentException> { subject.nextInt(-1) }
	assertFailsWith<IllegalArgumentException> { subject.nextInt(Int.MIN_VALUE) }

	repeat(1000) {
	assertEquals(0, subject.nextInt(1))
	}

	for (bound in listOf(2, 3, 7, 16, 32, 0x4000_0000, Int.MAX_VALUE)) {
	repeat(1000) {
	val x = subject.nextInt(bound)
	if (x !in 0 until bound)
	fail("Value $x must be in range [0, $bound)")
	}
	}
	}

	@Test
	fun nextUIntUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextUInt(UInt.MIN_VALUE) }

	repeat(1000) {
	assertEquals(0u, subject.nextUInt(1u))
	}

	for (bound in listOf(2u, 3u, 7u, 16u, 32u, 0x4000_0000u, UInt.MAX_VALUE)) {
	repeat(1000) {
	val x = subject.nextUInt(bound)
	if (x !in 0u until bound)
	fail("Value $x must be in range [0, $bound)")
	}
	}
	}

	@Test
	fun nextIntFromUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextInt(0, 0) }
	assertFailsWith<IllegalArgumentException> { subject.nextInt(-1, -2) }
	assertFailsWith<IllegalArgumentException> { subject.nextInt(Int.MIN_VALUE, Int.MIN_VALUE) }

	for (n in Int.MIN_VALUE until Int.MAX_VALUE step 0x10000) {
	assertEquals(n, subject.nextInt(n, n + 1))
	}
	(Int.MAX_VALUE - 1).let { n ->
	assertEquals(n, subject.nextInt(n, n + 1))
	}

	for ((from, until) in listOf((0 to 2), (-1 to 5), (0 to 32), (0 to Int.MAX_VALUE), (-1 to Int.MAX_VALUE), (Int.MIN_VALUE to Int.MAX_VALUE))) {
	repeat(1000) {
	val x = subject.nextInt(from, until)
	if (x !in from until until)
	fail("Value $x must be in range [$from, $until)")
	}
	}
	}

	@Test
	fun nextUIntFromUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextUInt(0u, 0u) }
	assertFailsWith<IllegalArgumentException> { subject.nextUInt((-1).toUInt(), (-2).toUInt()) }
	assertFailsWith<IllegalArgumentException> { subject.nextUInt(UInt.MIN_VALUE, UInt.MIN_VALUE) }

	for (n in UInt.MIN_VALUE until UInt.MAX_VALUE step 0x10000) {
	assertEquals(n, subject.nextUInt(n, n + 1u))
	}
	(UInt.MAX_VALUE - 1u).let { n ->
	assertEquals(n, subject.nextUInt(n, n + 1u))
	}

	for ((from, until) in listOf((0u to 2u), (1u to 6u), (0u to 32u), (0u to UInt.MAX_VALUE), (1u to (Int.MAX_VALUE.toUInt() + 1u)), (UInt.MIN_VALUE to UInt.MAX_VALUE))) {
	repeat(1000) {
	val x = subject.nextUInt(from, until)
	if (x !in from until until)
	fail("Value $x must be in range [$from, $until)")
	}
	}
	}

	@Suppress("EmptyRange")
	@Test
	fun nextIntInIntRange() {
	assertFailsWith<IllegalArgumentException> { subject.nextInt(0 until 0) }
	assertFailsWith<IllegalArgumentException> { subject.nextInt(-1..Int.MIN_VALUE) }
	assertFailsWith<IllegalArgumentException> { subject.nextInt(Int.MAX_VALUE until Int.MAX_VALUE) }

	repeat(1000) { n ->
	assertEquals(n, subject.nextInt(n..n))
	}

	for (range in listOf((0 until 2), (-1 until 5), (0 until 32), (0 until Int.MAX_VALUE),
	(0..Int.MAX_VALUE), (Int.MIN_VALUE..0), (Int.MIN_VALUE..Int.MAX_VALUE))) {
	repeat(1000) {
	val x = subject.nextInt(range)
	if (x !in range)
	fail("Value $x must be in range $range")
	}
	}
	}

	@Test
	fun nextUIntInUIntRange() {
	assertFailsWith<IllegalArgumentException> { subject.nextUInt(1u..0u) }
	assertFailsWith<IllegalArgumentException> { subject.nextUInt(UInt.MAX_VALUE..UInt.MIN_VALUE) }
	assertFailsWith<IllegalArgumentException> { subject.nextUInt(UInt.MAX_VALUE..(UInt.MAX_VALUE - 1u)) }

	repeat(1000) { it ->
	val n = it.toUInt()
	assertEquals(n, subject.nextUInt(n..n))
	}

	for (range in listOf(
	(0u..1u),
	(1u..5u),
	(0u..31u),
	(0u..UInt.MAX_VALUE - 1u),
	(1u..UInt.MAX_VALUE),
	(0u..UInt.MAX_VALUE)
	)) {
	repeat(1000) {
	val x = subject.nextUInt(range)
	if (x !in range)
	fail("Value $x must be in range $range")
	}
	}
	}

	@Test
	fun nextLong() {
	var result1 = 0L
	var result2 = -1L
	repeat(1000) {
	val r = subject.nextLong()
	result1 = result1 or r
	result2 = result2 and r
	}
	assertEquals(-1, result1, "All one bits should present")
	assertEquals(0, result2, "All zero bits should present")
	}

	@Test
	fun nextULong() {
	var result1 = 0uL
	var result2 = ULong.MAX_VALUE
	repeat(1000) {
	val r = subject.nextULong()
	result1 = result1 or r
	result2 = result2 and r
	}

	assertEquals(ULong.MAX_VALUE, result1, "All one bits should be present")
	assertEquals(0uL, result2, "All zero bits should be present")
	}

	@Test
	fun nextLongUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextLong(0) }
	assertFailsWith<IllegalArgumentException> { subject.nextLong(-1) }
	assertFailsWith<IllegalArgumentException> { subject.nextLong(Long.MIN_VALUE) }

	repeat(1000) {
	assertEquals(0L, subject.nextLong(1))
	}

	for (bound in listOf(2, 23, 32, 0x1_0000_0000, 0x4_0000_0000, 0x4000_0000_0000_0000, Long.MAX_VALUE)) {
	repeat(1000) {
	val x = subject.nextLong(bound)
	if (x !in 0L until bound)
	fail("Value $x must be in range [0, $bound)")
	}
	}
	}

	@Test
	fun nextULongUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextULong(ULong.MIN_VALUE) }

	repeat(1000) {
	assertEquals(0uL, subject.nextULong(1uL))
	}

	for (bound in listOf(2uL, 23uL, 32uL, 0x1_0000_0000uL, 0x4_0000_0000uL, 0x8000_0000_0000_000uL, ULong.MAX_VALUE)) {
	repeat(1000) {
	val x = subject.nextULong(bound)
	if (x !in 0uL until bound) {
	fail("Value $x must be in range [0, $bound)")
	}
	}
	}
	}

	@Test
	fun nextLongFromUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextLong(0, 0) }
	assertFailsWith<IllegalArgumentException> { subject.nextLong(-1, -2) }
	assertFailsWith<IllegalArgumentException> { subject.nextLong(Long.MIN_VALUE, Long.MIN_VALUE) }

	for (i in -500..500) {
	val n = 0x1_0000_0000 + i
	assertEquals(n, subject.nextLong(n, n + 1))
	}

	for ((from, until) in listOf((0L to 32L), (-1L to 5L), (0L to 0x1_0000_0000), (-0x10L to 0x3_FFFF_FFF0L),
	(0L to Long.MAX_VALUE), (-1L to Long.MAX_VALUE), (Long.MIN_VALUE to Long.MAX_VALUE))) {
	repeat(1000) {
	val x = subject.nextLong(from, until)
	if (x !in from until until)
	fail("Value $x must be in range [$from, $until)")
	}
	}
	}

	@Test
	fun nextULongFromUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextULong(0uL, 0uL) }
	assertFailsWith<IllegalArgumentException> { subject.nextULong((-1).toULong(), (-2).toULong()) }

	for (i in 0u..1000u) {
	val n = 0x1_0000_0000uL - 500u + i
	assertEquals(n, subject.nextULong(n, n + 1uL))
	}

	for ((from, until) in listOf(
	(0uL to 32uL),
	(1uL to 6uL),
	(0uL to 0x1_0000_0000.toULong()),
	(0x10uL to 0x4_0000_0010.toULong()),
	(0uL to ULong.MAX_VALUE)
	)) {
	repeat(1000) {
	val x = subject.nextULong(from, until)
	if (x !in from until until) {
	fail("Value $x must be in range [$from, $until)")
	}
	}
	}
	}

	@Suppress("EmptyRange")
	@Test
	fun nextLongInLongRange() {
	assertFailsWith<IllegalArgumentException> { subject.nextLong(0L until 0L) }
	assertFailsWith<IllegalArgumentException> { subject.nextLong(-1..Long.MIN_VALUE) }
	assertFailsWith<IllegalArgumentException> { subject.nextLong(Long.MAX_VALUE until Long.MAX_VALUE) }

	repeat(1000) { i ->
	val n = 0x1_0000_0000 - 500 + i
	assertEquals(n, subject.nextLong(n..n))
	}

	for (range in listOf((0L until 2L), (-1L until 5L), (0L until 32L), (0L until 1L.shl(33)), (0L until Long.MAX_VALUE),
	(0L..Long.MAX_VALUE), (Long.MIN_VALUE..0L), (Long.MIN_VALUE..Long.MAX_VALUE))) {
	repeat(1000) {
	val x = subject.nextLong(range)
	if (x !in range)
	fail("Value $x must be in range $range")
	}
	}
	}

	@Test
	fun nextULongInULongRange() {
	assertFailsWith<IllegalArgumentException> { subject.nextULong(1uL..0uL) }
	assertFailsWith<IllegalArgumentException> { subject.nextULong(ULong.MAX_VALUE..ULong.MIN_VALUE) }
	assertFailsWith<IllegalArgumentException> { subject.nextULong(ULong.MAX_VALUE..(ULong.MAX_VALUE - 1uL))}

	repeat(1000) { i ->
	val n = (0x1_0000_0000).toULong() - 500uL + i.toULong()
	assertEquals(n, subject.nextULong(n..n))
	}

	for (range in listOf(
	(0uL..1uL),
	(1uL..5uL),
	(0uL..31uL),
	(0uL until 0x4_0000_0000uL),
	(0uL..(ULong.MAX_VALUE - 1uL)),
	(1uL..ULong.MAX_VALUE),
	(0uL..ULong.MAX_VALUE)
	)) {
	repeat(1000) {
	val x = subject.nextULong(range)
	if (x !in range) {
	fail("Value $x must be in range $range")
	}
	}
	}

	}


	@Test
	fun nextDouble() {
	repeat(10000) {
	val d = subject.nextDouble()
	if (!(d >= 0.0 && d < 1)) {
	fail("Random double $d is out of range")
	}
	}
	}

	@Test
	fun nextDoubleUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(-1.0) }
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(-0.0) }
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(0.0) }
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(Double.NaN) }

	repeat(100) {
	assertEquals(0.0, subject.nextDouble(0.0.nextUp()))
	}

	assertTrue(subject.nextDouble(Double.POSITIVE_INFINITY).isFinite(), "Infinity is exclusive")

	for (bound in listOf(1.0, 100.0, 1024.0, Double.MAX_VALUE)) {
	repeat(1000) {
	val d = subject.nextDouble(bound)
	if (!(d >= 0.0 && d < bound)) {
	fail("Random double $d is out of range [0, $bound)")
	}
	}
	}
	}

	@Test
	fun nextDoubleFromUntil() {
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(0.0, -1.0) }
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(0.0, Double.NaN) }
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(Double.NaN, 0.0) }
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(Double.NaN, Double.POSITIVE_INFINITY) }
	assertFailsWith<IllegalArgumentException> { subject.nextDouble(Double.MAX_VALUE, Double.MAX_VALUE) }

	for (exp in -1022..1023) {
	val origin = 2.0.pow(exp)
	assertEquals(origin, subject.nextDouble(origin, origin.nextUp()), "2^$exp")
	assertEquals(-origin, subject.nextDouble(-origin, (-origin).nextUp()), "-(2^$exp)")
	}

	run {
	val size = 1000
	val fullRangeValues = (1..size).map { subject.nextDouble(-Double.MAX_VALUE, Double.MAX_VALUE) }.distinct()
	fullRangeValues.forEach {
	assertTrue(it.isFinite() && it < Double.MAX_VALUE)
	}
	assertTrue(fullRangeValues.size >= (size * 0.995), "All values should be distinct, but only ${fullRangeValues.size} of them are")
	}

	for ((from, until) in listOf(0.0 to 1.0, -1.0 to 1.0, 0.0 to 100.0, -PI to PI, 0.0 to Double.MAX_VALUE)) {
	repeat(1000) {
	val d = subject.nextDouble(from, until)
	if (!(d >= from && d < until)) {
	fail("Random double $d is out of range [$from, $until)")
	}
	}
	}
	}

	@Test
	fun nextFloat() {
	repeat(10000) {
	val d = subject.nextFloat()
	if (!(d >= 0.0F && d < 1.0F)) {
	fail("Random float $d is out of range")
	}
	}
	}

	@Test
	fun nextBoolean() {
	val size = 10000
	val booleans = (1..size).map { subject.nextBoolean() }.groupingBy { it }.eachCount()
	val ts = booleans[true]!!
	val fs = booleans[false]!!

	assertNotEquals(0, ts)
	assertNotEquals(0, fs)

	val skew = abs(ts.toDouble() - fs.toDouble()) / size
	assertTrue(skew < 0.10, "Boolean generator is skewed: $booleans, delta is $skew")
	}

	@Test
	fun nextBytes() {
	val size = 20
	val bytes1 = subject.nextBytes(size)
	assertEquals(size, bytes1.size)
	assertTrue(bytes1.any { it != 0.toByte() })

	val bytes2 = subject.nextBytes(ByteArray(size))
	assertEquals(size, bytes2.size)
	assertTrue(bytes2.any { it != 0.toByte() })

	assertFalse(bytes1 contentEquals bytes2)
	}

	@Test
	fun nextUBytes() {
	val size = 20
	val ubytes1 = subject.nextUBytes(size)
	assertEquals(size, ubytes1.size)
	assertTrue(ubytes1.any { it != 0.toUByte() })

	val ubytes2 = subject.nextUBytes(UByteArray(size))
	assertEquals(size, ubytes2.size)
	assertTrue(ubytes2.any { it != 0.toUByte() })

	assertFalse(ubytes1 contentEquals ubytes2)
	}

	@Test
	fun nextBytesRange() {
	val size = 100
	val array = subject.nextBytes(size)

	assertFailsWith<IllegalArgumentException> { subject.nextBytes(array, -1, 10) }
	assertFailsWith<IllegalArgumentException> { subject.nextBytes(array, 0, size + 10) }
	assertFailsWith<IllegalArgumentException> { subject.nextBytes(array, 10, 0) }

	repeat(10000) {
	val from = subject.nextInt(0, size - 1)
	val to = subject.nextInt(from + 1, size)

	val prev = array.copyOf()
	subject.nextBytes(array, from, to)

	var noChanges = array contentEquals prev
	val rangeSize = to - from
	val retries = 4 / rangeSize
	var n = 0
	while (noChanges && n < retries) {
	// there's a small chance that a small range will get the same value as before
	// run randomization again
	subject.nextBytes(array, from, to)
	noChanges = array contentEquals prev
	n++
	}

	if (noChanges) {
	fail("Something should have changed in array after subrange [$from, $to) randomization (${1 + retries} times): " +
	array.copyOfRange(from, to).contentToString())
	}

	for (p in 0 until from) {
	assertEquals(prev[p], array[p])
	}
	for (p in to until size) {
	assertEquals(prev[p], array[p])
	}
	}
	}

	@Test
	fun nextUBytesRange() {
	val size = 100
	val array = subject.nextUBytes(size)

	assertFailsWith<IllegalArgumentException> { subject.nextUBytes(array, -1, 10) }
	assertFailsWith<IllegalArgumentException> { subject.nextUBytes(array, 0, size + 10) }
	assertFailsWith<IllegalArgumentException> { subject.nextUBytes(array, 10, 0) }

	repeat(10000) {
	val from = subject.nextInt(0, size - 1)
	val to = subject.nextInt(from + 1, size)

	val prev = array.copyOf()

	subject.nextUBytes(array, from, to)

	var noChanges = array contentEquals prev
	val rangeSize = to - from

	val retries = 4 / rangeSize

	var n = 0
	while(noChanges && n < retries) {
	// there's a small chance that a small range will get the same value as before
	// run randomization again
	subject.nextUBytes(array, from, to)
	noChanges = array contentEquals prev
	n++
	}

	if(noChanges) {
	fail("Something should have changed in array after subrange [$from, $to) randomization (${1 + retries} times: " +
	array.copyOfRange(from, to).contentToString())
	}

	for (p in 0 until from) {
	assertEquals(prev[p], array[p])
	}

	for (p in to until size) {
	assertEquals(prev[p], array[p])
	}

	}
	}
	}


	class DefaultRandomSmokeTest : RandomSmokeTest() {
	override val subject: Random get() = Random
	}

	@ThreadLocal
	internal val seededRandomSmokeTestSubject = Random(Random.nextInt().also { println("Seed: $it") })

	class SeededRandomSmokeTest : RandomSmokeTest() {
	override val subject: Random get() = seededRandomSmokeTestSubject

	@Test
	fun sameIntSeed() {
	val v = subject.nextInt(1..Int.MAX_VALUE)
	for (seed in listOf(v, -v)) {
	testSameSeededRandoms(Random(seed), Random(seed), seed)
	}
	}

	@Test
	fun sameLongSeed() {
	val v = subject.nextLong(1..Long.MAX_VALUE)
	for (seed in listOf(v, -v)) {
	testSameSeededRandoms(Random(seed), Random(seed), seed)
	}
	}

	@Test
	fun sameIntLongSeed() {
	val v = subject.nextInt(1..Int.MAX_VALUE)
	for (seed in listOf(v, 0, -v)) {
	testSameSeededRandoms(Random(seed), Random(seed.toLong()), seed)
	}
	}

	private fun testSameSeededRandoms(r1: Random, r2: Random, seed: Any) {
	val seq1 = List(10) { r1.nextInt() }
	val seq2 = List(10) { r2.nextInt() }
	// println("$seed: $seq1")

	assertEquals(seq1, seq2, "Generators seeded with $seed should produce the same output")
	}
	}