Split tests into platform independent and JVM parts to run subset of tests in JS
This commit is contained in:
Ilya Ryzhenkov
committed by
Andrey Breslav
Andrey Breslav
parent
ee8a7d6825
commit
717f03f474
@@ -2,18 +2,6 @@ package language
|
||||
|
||||
import kotlin.test.assertEquals
|
||||
import org.junit.Test as test
|
||||
import java.lang as j
|
||||
|
||||
import java.lang.Integer.MAX_VALUE as MaxI
|
||||
import java.lang.Integer.MIN_VALUE as MinI
|
||||
import java.lang.Byte.MAX_VALUE as MaxB
|
||||
import java.lang.Byte.MIN_VALUE as MinB
|
||||
import java.lang.Short.MAX_VALUE as MaxS
|
||||
import java.lang.Short.MIN_VALUE as MinS
|
||||
import java.lang.Long.MAX_VALUE as MaxL
|
||||
import java.lang.Long.MIN_VALUE as MinL
|
||||
import java.lang.Character.MAX_VALUE as MaxC
|
||||
import java.lang.Character.MIN_VALUE as MinC
|
||||
|
||||
// Test data for codegen is generated from this class. If you change it, rerun GenerateTests
|
||||
public class RangeIterationTest {
|
||||
@@ -265,120 +253,4 @@ public class RangeIterationTest {
|
||||
doTest((5.8.toFloat() downTo 4.0.toFloat() step 0.5.toFloat()).reversed(), 4.0.toFloat(), 5.8.toFloat(), 0.5.toFloat(),
|
||||
listOf<Float>(4.0.toFloat(), 4.5.toFloat(), 5.0.toFloat(), 5.5.toFloat()))
|
||||
}
|
||||
|
||||
test fun infiniteSteps() {
|
||||
doTest(0.0..5.0 step j.Double.POSITIVE_INFINITY, 0.0, 5.0, j.Double.POSITIVE_INFINITY, listOf(0.0))
|
||||
doTest(0.0.toFloat()..5.0.toFloat() step j.Float.POSITIVE_INFINITY, 0.0.toFloat(), 5.0.toFloat(), j.Float.POSITIVE_INFINITY,
|
||||
listOf<Float>(0.0.toFloat()))
|
||||
doTest(5.0 downTo 0.0 step j.Double.POSITIVE_INFINITY, 5.0, 0.0, j.Double.NEGATIVE_INFINITY, listOf(5.0))
|
||||
doTest(5.0.toFloat() downTo 0.0.toFloat() step j.Float.POSITIVE_INFINITY, 5.0.toFloat(), 0.0.toFloat(), j.Float.NEGATIVE_INFINITY,
|
||||
listOf<Float>(5.0.toFloat()))
|
||||
}
|
||||
|
||||
test fun nanEnds() {
|
||||
doTest(j.Double.NaN..5.0, j.Double.NaN, 5.0, 1.0, listOf())
|
||||
doTest(j.Float.NaN.toFloat()..5.0.toFloat(), j.Float.NaN, 5.0.toFloat(), 1.0.toFloat(), listOf())
|
||||
doTest(j.Double.NaN downTo 0.0, j.Double.NaN, 0.0, -1.0, listOf())
|
||||
doTest(j.Float.NaN.toFloat() downTo 0.0.toFloat(), j.Float.NaN, 0.0.toFloat(), -1.0.toFloat(), listOf())
|
||||
|
||||
doTest(0.0..j.Double.NaN, 0.0, j.Double.NaN, 1.0, listOf())
|
||||
doTest(0.0.toFloat()..j.Float.NaN, 0.0.toFloat(), j.Float.NaN, 1.0.toFloat(), listOf())
|
||||
doTest(5.0 downTo j.Double.NaN, 5.0, j.Double.NaN, -1.0, listOf())
|
||||
doTest(5.0.toFloat() downTo j.Float.NaN, 5.0.toFloat(), j.Float.NaN, -1.0.toFloat(), listOf())
|
||||
|
||||
doTest(j.Double.NaN..j.Double.NaN, j.Double.NaN, j.Double.NaN, 1.0, listOf())
|
||||
doTest(j.Float.NaN..j.Float.NaN, j.Float.NaN, j.Float.NaN, 1.0.toFloat(), listOf())
|
||||
doTest(j.Double.NaN downTo j.Double.NaN, j.Double.NaN, j.Double.NaN, -1.0, listOf())
|
||||
doTest(j.Float.NaN downTo j.Float.NaN, j.Float.NaN, j.Float.NaN, -1.0.toFloat(), listOf())
|
||||
}
|
||||
|
||||
test fun maxValueToMaxValue() {
|
||||
doTest(MaxI..MaxI, MaxI, MaxI, 1, listOf(MaxI))
|
||||
doTest(MaxB..MaxB, MaxB, MaxB, 1, listOf(MaxB))
|
||||
doTest(MaxS..MaxS, MaxS, MaxS, 1, listOf(MaxS))
|
||||
doTest(MaxL..MaxL, MaxL, MaxL, 1.toLong(), listOf(MaxL))
|
||||
|
||||
doTest(MaxC..MaxC, MaxC, MaxC, 1, listOf(MaxC))
|
||||
}
|
||||
|
||||
test fun maxValueMinusTwoToMaxValue() {
|
||||
doTest((MaxI - 2)..MaxI, MaxI - 2, MaxI, 1, listOf(MaxI - 2, MaxI - 1, MaxI))
|
||||
doTest((MaxB - 2).toByte()..MaxB, (MaxB - 2).toByte(), MaxB, 1, listOf((MaxB - 2).toByte(), (MaxB - 1).toByte(), MaxB))
|
||||
doTest((MaxS - 2).toShort()..MaxS, (MaxS - 2).toShort(), MaxS, 1, listOf((MaxS - 2).toShort(), (MaxS - 1).toShort(), MaxS))
|
||||
doTest((MaxL - 2).toLong()..MaxL, (MaxL - 2).toLong(), MaxL, 1.toLong(), listOf((MaxL - 2).toLong(), (MaxL - 1).toLong(), MaxL))
|
||||
|
||||
doTest((MaxC - 2).toChar()..MaxC, (MaxC - 2).toChar(), MaxC, 1, listOf((MaxC - 2).toChar(), (MaxC - 1).toChar(), MaxC))
|
||||
}
|
||||
|
||||
test fun maxValueToMinValue() {
|
||||
doTest(MaxI..MinI, MaxI, MinI, 1, listOf())
|
||||
doTest(MaxB..MinB, MaxB, MinB, 1, listOf())
|
||||
doTest(MaxS..MinS, MaxS, MinS, 1, listOf())
|
||||
doTest(MaxL..MinL, MaxL, MinL, 1.toLong(), listOf())
|
||||
|
||||
doTest(MaxC..MinC, MaxC, MinC, 1, listOf())
|
||||
}
|
||||
|
||||
test fun progressionMaxValueToMaxValue() {
|
||||
doTest(MaxI..MaxI step 1, MaxI, MaxI, 1, listOf(MaxI))
|
||||
doTest(MaxB..MaxB step 1, MaxB, MaxB, 1, listOf(MaxB))
|
||||
doTest(MaxS..MaxS step 1, MaxS, MaxS, 1, listOf(MaxS))
|
||||
doTest(MaxL..MaxL step 1, MaxL, MaxL, 1.toLong(), listOf(MaxL))
|
||||
|
||||
doTest(MaxC..MaxC step 1, MaxC, MaxC, 1, listOf(MaxC))
|
||||
}
|
||||
|
||||
test fun progressionMaxValueMinusTwoToMaxValue() {
|
||||
doTest((MaxI - 2)..MaxI step 2, MaxI - 2, MaxI, 2, listOf(MaxI - 2, MaxI))
|
||||
doTest((MaxB - 2).toByte()..MaxB step 2, (MaxB - 2).toByte(), MaxB, 2, listOf((MaxB - 2).toByte(), MaxB))
|
||||
doTest((MaxS - 2).toShort()..MaxS step 2, (MaxS - 2).toShort(), MaxS, 2, listOf((MaxS - 2).toShort(), MaxS))
|
||||
doTest((MaxL - 2).toLong()..MaxL step 2, (MaxL - 2).toLong(), MaxL, 2.toLong(), listOf((MaxL - 2).toLong(), MaxL))
|
||||
|
||||
doTest((MaxC - 2).toChar()..MaxC step 2, (MaxC - 2).toChar(), MaxC, 2, listOf((MaxC - 2).toChar(), MaxC))
|
||||
}
|
||||
|
||||
test fun progressionMaxValueToMinValue() {
|
||||
doTest(MaxI..MinI step 1, MaxI, MinI, 1, listOf())
|
||||
doTest(MaxB..MinB step 1, MaxB, MinB, 1, listOf())
|
||||
doTest(MaxS..MinS step 1, MaxS, MinS, 1, listOf())
|
||||
doTest(MaxL..MinL step 1, MaxL, MinL, 1.toLong(), listOf())
|
||||
|
||||
doTest(MaxC..MinC step 1, MaxC, MinC, 1, listOf())
|
||||
}
|
||||
|
||||
test fun progressionMinValueToMinValue() {
|
||||
doTest(MinI..MinI step 1, MinI, MinI, 1, listOf(MinI))
|
||||
doTest(MinB..MinB step 1, MinB, MinB, 1, listOf(MinB))
|
||||
doTest(MinS..MinS step 1, MinS, MinS, 1, listOf(MinS))
|
||||
doTest(MinL..MinL step 1, MinL, MinL, 1.toLong(), listOf(MinL))
|
||||
|
||||
doTest(MinC..MinC step 1, MinC, MinC, 1, listOf(MinC))
|
||||
}
|
||||
|
||||
test fun inexactToMaxValue() {
|
||||
doTest((MaxI - 5)..MaxI step 3, MaxI - 5, MaxI, 3, listOf(MaxI - 5, MaxI - 2))
|
||||
doTest((MaxB - 5).toByte()..MaxB step 3, (MaxB - 5).toByte(), MaxB, 3, listOf((MaxB - 5).toByte(), (MaxB - 2).toByte()))
|
||||
doTest((MaxS - 5).toShort()..MaxS step 3, (MaxS - 5).toShort(), MaxS, 3, listOf((MaxS - 5).toShort(), (MaxS - 2).toShort()))
|
||||
doTest((MaxL - 5).toLong()..MaxL step 3, (MaxL - 5).toLong(), MaxL, 3.toLong(), listOf((MaxL - 5).toLong(), (MaxL - 2).toLong()))
|
||||
|
||||
doTest((MaxC - 5).toChar()..MaxC step 3, (MaxC - 5).toChar(), MaxC, 3, listOf((MaxC - 5).toChar(), (MaxC - 2).toChar()))
|
||||
}
|
||||
|
||||
test fun progressionDownToMinValue() {
|
||||
doTest((MinI + 2) downTo MinI step 1, MinI + 2, MinI, -1, listOf(MinI + 2, MinI + 1, MinI))
|
||||
doTest((MinB + 2).toByte() downTo MinB step 1, (MinB + 2).toByte(), MinB, -1, listOf((MinB + 2).toByte(), (MinB + 1).toByte(), MinB))
|
||||
doTest((MinS + 2).toShort() downTo MinS step 1, (MinS + 2).toShort(), MinS, -1, listOf((MinS + 2).toShort(), (MinS + 1).toShort(), MinS))
|
||||
doTest((MinL + 2).toLong() downTo MinL step 1, (MinL + 2).toLong(), MinL, -1.toLong(), listOf((MinL + 2).toLong(), (MinL + 1).toLong(), MinL))
|
||||
|
||||
doTest((MinC + 2).toChar() downTo MinC step 1, (MinC + 2).toChar(), MinC, -1, listOf((MinC + 2).toChar(), (MinC + 1).toChar(), MinC))
|
||||
}
|
||||
|
||||
test fun inexactDownToMinValue() {
|
||||
doTest((MinI + 5) downTo MinI step 3, MinI + 5, MinI, -3, listOf(MinI + 5, MinI + 2))
|
||||
doTest((MinB + 5).toByte() downTo MinB step 3, (MinB + 5).toByte(), MinB, -3, listOf((MinB + 5).toByte(), (MinB + 2).toByte()))
|
||||
doTest((MinS + 5).toShort() downTo MinS step 3, (MinS + 5).toShort(), MinS, -3, listOf((MinS + 5).toShort(), (MinS + 2).toShort()))
|
||||
doTest((MinL + 5).toLong() downTo MinL step 3, (MinL + 5).toLong(), MinL, -3.toLong(), listOf((MinL + 5).toLong(), (MinL + 2).toLong()))
|
||||
|
||||
doTest((MinC + 5).toChar() downTo MinC step 3, (MinC + 5).toChar(), MinC, -3, listOf((MinC + 5).toChar(), (MinC + 2).toChar()))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,148 @@
|
||||
package language
|
||||
|
||||
import java.lang as j
|
||||
|
||||
import java.lang.Integer.MAX_VALUE as MaxI
|
||||
import java.lang.Integer.MIN_VALUE as MinI
|
||||
import java.lang.Byte.MAX_VALUE as MaxB
|
||||
import java.lang.Byte.MIN_VALUE as MinB
|
||||
import java.lang.Short.MAX_VALUE as MaxS
|
||||
import java.lang.Short.MIN_VALUE as MinS
|
||||
import java.lang.Long.MAX_VALUE as MaxL
|
||||
import java.lang.Long.MIN_VALUE as MinL
|
||||
import java.lang.Character.MAX_VALUE as MaxC
|
||||
import java.lang.Character.MIN_VALUE as MinC
|
||||
import kotlin.test.assertEquals
|
||||
import org.junit.Test as test
|
||||
|
||||
public class RangeIterationTestJVM {
|
||||
private fun <N> doTest(
|
||||
sequence: Progression<N>,
|
||||
expectedStart: N,
|
||||
expectedEnd: N,
|
||||
expectedIncrement: Number,
|
||||
expectedElements: List<N>
|
||||
) {
|
||||
assertEquals(expectedStart, sequence.start)
|
||||
assertEquals(expectedEnd, sequence.end)
|
||||
assertEquals(expectedIncrement, sequence.increment)
|
||||
|
||||
assertEquals(expectedElements, sequence.toList())
|
||||
}
|
||||
|
||||
test fun infiniteSteps() {
|
||||
doTest(0.0..5.0 step j.Double.POSITIVE_INFINITY, 0.0, 5.0, j.Double.POSITIVE_INFINITY, listOf(0.0))
|
||||
doTest(0.0.toFloat()..5.0.toFloat() step j.Float.POSITIVE_INFINITY, 0.0.toFloat(), 5.0.toFloat(), j.Float.POSITIVE_INFINITY,
|
||||
listOf<Float>(0.0.toFloat()))
|
||||
doTest(5.0 downTo 0.0 step j.Double.POSITIVE_INFINITY, 5.0, 0.0, j.Double.NEGATIVE_INFINITY, listOf(5.0))
|
||||
doTest(5.0.toFloat() downTo 0.0.toFloat() step j.Float.POSITIVE_INFINITY, 5.0.toFloat(), 0.0.toFloat(), j.Float.NEGATIVE_INFINITY,
|
||||
listOf<Float>(5.0.toFloat()))
|
||||
}
|
||||
|
||||
test fun nanEnds() {
|
||||
doTest(j.Double.NaN..5.0, j.Double.NaN, 5.0, 1.0, listOf())
|
||||
doTest(j.Float.NaN.toFloat()..5.0.toFloat(), j.Float.NaN, 5.0.toFloat(), 1.0.toFloat(), listOf())
|
||||
doTest(j.Double.NaN downTo 0.0, j.Double.NaN, 0.0, -1.0, listOf())
|
||||
doTest(j.Float.NaN.toFloat() downTo 0.0.toFloat(), j.Float.NaN, 0.0.toFloat(), -1.0.toFloat(), listOf())
|
||||
|
||||
doTest(0.0..j.Double.NaN, 0.0, j.Double.NaN, 1.0, listOf())
|
||||
doTest(0.0.toFloat()..j.Float.NaN, 0.0.toFloat(), j.Float.NaN, 1.0.toFloat(), listOf())
|
||||
doTest(5.0 downTo j.Double.NaN, 5.0, j.Double.NaN, -1.0, listOf())
|
||||
doTest(5.0.toFloat() downTo j.Float.NaN, 5.0.toFloat(), j.Float.NaN, -1.0.toFloat(), listOf())
|
||||
|
||||
doTest(j.Double.NaN..j.Double.NaN, j.Double.NaN, j.Double.NaN, 1.0, listOf())
|
||||
doTest(j.Float.NaN..j.Float.NaN, j.Float.NaN, j.Float.NaN, 1.0.toFloat(), listOf())
|
||||
doTest(j.Double.NaN downTo j.Double.NaN, j.Double.NaN, j.Double.NaN, -1.0, listOf())
|
||||
doTest(j.Float.NaN downTo j.Float.NaN, j.Float.NaN, j.Float.NaN, -1.0.toFloat(), listOf())
|
||||
}
|
||||
|
||||
test fun maxValueToMaxValue() {
|
||||
doTest(MaxI..MaxI, MaxI, MaxI, 1, listOf(MaxI))
|
||||
doTest(MaxB..MaxB, MaxB, MaxB, 1, listOf(MaxB))
|
||||
doTest(MaxS..MaxS, MaxS, MaxS, 1, listOf(MaxS))
|
||||
doTest(MaxL..MaxL, MaxL, MaxL, 1.toLong(), listOf(MaxL))
|
||||
|
||||
doTest(MaxC..MaxC, MaxC, MaxC, 1, listOf(MaxC))
|
||||
}
|
||||
|
||||
test fun maxValueMinusTwoToMaxValue() {
|
||||
doTest((MaxI - 2)..MaxI, MaxI - 2, MaxI, 1, listOf(MaxI - 2, MaxI - 1, MaxI))
|
||||
doTest((MaxB - 2).toByte()..MaxB, (MaxB - 2).toByte(), MaxB, 1, listOf((MaxB - 2).toByte(), (MaxB - 1).toByte(), MaxB))
|
||||
doTest((MaxS - 2).toShort()..MaxS, (MaxS - 2).toShort(), MaxS, 1, listOf((MaxS - 2).toShort(), (MaxS - 1).toShort(), MaxS))
|
||||
doTest((MaxL - 2).toLong()..MaxL, (MaxL - 2).toLong(), MaxL, 1.toLong(), listOf((MaxL - 2).toLong(), (MaxL - 1).toLong(), MaxL))
|
||||
|
||||
doTest((MaxC - 2).toChar()..MaxC, (MaxC - 2).toChar(), MaxC, 1, listOf((MaxC - 2).toChar(), (MaxC - 1).toChar(), MaxC))
|
||||
}
|
||||
|
||||
test fun maxValueToMinValue() {
|
||||
doTest(MaxI..MinI, MaxI, MinI, 1, listOf())
|
||||
doTest(MaxB..MinB, MaxB, MinB, 1, listOf())
|
||||
doTest(MaxS..MinS, MaxS, MinS, 1, listOf())
|
||||
doTest(MaxL..MinL, MaxL, MinL, 1.toLong(), listOf())
|
||||
|
||||
doTest(MaxC..MinC, MaxC, MinC, 1, listOf())
|
||||
}
|
||||
|
||||
test fun progressionMaxValueToMaxValue() {
|
||||
doTest(MaxI..MaxI step 1, MaxI, MaxI, 1, listOf(MaxI))
|
||||
doTest(MaxB..MaxB step 1, MaxB, MaxB, 1, listOf(MaxB))
|
||||
doTest(MaxS..MaxS step 1, MaxS, MaxS, 1, listOf(MaxS))
|
||||
doTest(MaxL..MaxL step 1, MaxL, MaxL, 1.toLong(), listOf(MaxL))
|
||||
|
||||
doTest(MaxC..MaxC step 1, MaxC, MaxC, 1, listOf(MaxC))
|
||||
}
|
||||
|
||||
test fun progressionMaxValueMinusTwoToMaxValue() {
|
||||
doTest((MaxI - 2)..MaxI step 2, MaxI - 2, MaxI, 2, listOf(MaxI - 2, MaxI))
|
||||
doTest((MaxB - 2).toByte()..MaxB step 2, (MaxB - 2).toByte(), MaxB, 2, listOf((MaxB - 2).toByte(), MaxB))
|
||||
doTest((MaxS - 2).toShort()..MaxS step 2, (MaxS - 2).toShort(), MaxS, 2, listOf((MaxS - 2).toShort(), MaxS))
|
||||
doTest((MaxL - 2).toLong()..MaxL step 2, (MaxL - 2).toLong(), MaxL, 2.toLong(), listOf((MaxL - 2).toLong(), MaxL))
|
||||
|
||||
doTest((MaxC - 2).toChar()..MaxC step 2, (MaxC - 2).toChar(), MaxC, 2, listOf((MaxC - 2).toChar(), MaxC))
|
||||
}
|
||||
|
||||
test fun progressionMaxValueToMinValue() {
|
||||
doTest(MaxI..MinI step 1, MaxI, MinI, 1, listOf())
|
||||
doTest(MaxB..MinB step 1, MaxB, MinB, 1, listOf())
|
||||
doTest(MaxS..MinS step 1, MaxS, MinS, 1, listOf())
|
||||
doTest(MaxL..MinL step 1, MaxL, MinL, 1.toLong(), listOf())
|
||||
|
||||
doTest(MaxC..MinC step 1, MaxC, MinC, 1, listOf())
|
||||
}
|
||||
|
||||
test fun progressionMinValueToMinValue() {
|
||||
doTest(MinI..MinI step 1, MinI, MinI, 1, listOf(MinI))
|
||||
doTest(MinB..MinB step 1, MinB, MinB, 1, listOf(MinB))
|
||||
doTest(MinS..MinS step 1, MinS, MinS, 1, listOf(MinS))
|
||||
doTest(MinL..MinL step 1, MinL, MinL, 1.toLong(), listOf(MinL))
|
||||
|
||||
doTest(MinC..MinC step 1, MinC, MinC, 1, listOf(MinC))
|
||||
}
|
||||
|
||||
test fun inexactToMaxValue() {
|
||||
doTest((MaxI - 5)..MaxI step 3, MaxI - 5, MaxI, 3, listOf(MaxI - 5, MaxI - 2))
|
||||
doTest((MaxB - 5).toByte()..MaxB step 3, (MaxB - 5).toByte(), MaxB, 3, listOf((MaxB - 5).toByte(), (MaxB - 2).toByte()))
|
||||
doTest((MaxS - 5).toShort()..MaxS step 3, (MaxS - 5).toShort(), MaxS, 3, listOf((MaxS - 5).toShort(), (MaxS - 2).toShort()))
|
||||
doTest((MaxL - 5).toLong()..MaxL step 3, (MaxL - 5).toLong(), MaxL, 3.toLong(), listOf((MaxL - 5).toLong(), (MaxL - 2).toLong()))
|
||||
|
||||
doTest((MaxC - 5).toChar()..MaxC step 3, (MaxC - 5).toChar(), MaxC, 3, listOf((MaxC - 5).toChar(), (MaxC - 2).toChar()))
|
||||
}
|
||||
|
||||
test fun progressionDownToMinValue() {
|
||||
doTest((MinI + 2) downTo MinI step 1, MinI + 2, MinI, -1, listOf(MinI + 2, MinI + 1, MinI))
|
||||
doTest((MinB + 2).toByte() downTo MinB step 1, (MinB + 2).toByte(), MinB, -1, listOf((MinB + 2).toByte(), (MinB + 1).toByte(), MinB))
|
||||
doTest((MinS + 2).toShort() downTo MinS step 1, (MinS + 2).toShort(), MinS, -1, listOf((MinS + 2).toShort(), (MinS + 1).toShort(), MinS))
|
||||
doTest((MinL + 2).toLong() downTo MinL step 1, (MinL + 2).toLong(), MinL, -1.toLong(), listOf((MinL + 2).toLong(), (MinL + 1).toLong(), MinL))
|
||||
|
||||
doTest((MinC + 2).toChar() downTo MinC step 1, (MinC + 2).toChar(), MinC, -1, listOf((MinC + 2).toChar(), (MinC + 1).toChar(), MinC))
|
||||
}
|
||||
|
||||
test fun inexactDownToMinValue() {
|
||||
doTest((MinI + 5) downTo MinI step 3, MinI + 5, MinI, -3, listOf(MinI + 5, MinI + 2))
|
||||
doTest((MinB + 5).toByte() downTo MinB step 3, (MinB + 5).toByte(), MinB, -3, listOf((MinB + 5).toByte(), (MinB + 2).toByte()))
|
||||
doTest((MinS + 5).toShort() downTo MinS step 3, (MinS + 5).toShort(), MinS, -3, listOf((MinS + 5).toShort(), (MinS + 2).toShort()))
|
||||
doTest((MinL + 5).toLong() downTo MinL step 3, (MinL + 5).toLong(), MinL, -3.toLong(), listOf((MinL + 5).toLong(), (MinL + 2).toLong()))
|
||||
|
||||
doTest((MinC + 5).toChar() downTo MinC step 3, (MinC + 5).toChar(), MinC, -3, listOf((MinC + 5).toChar(), (MinC + 2).toChar()))
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,5 @@
|
||||
package language
|
||||
|
||||
import java.lang.Double as jDouble
|
||||
import java.lang.Float as jFloat
|
||||
import kotlin.test.*
|
||||
import org.junit.Test as test
|
||||
|
||||
@@ -88,7 +86,6 @@ public class RangeTest {
|
||||
|
||||
test fun doubleRange() {
|
||||
val range = -1.0..3.14159265358979
|
||||
assertFalse(jDouble.NEGATIVE_INFINITY in range)
|
||||
assertFalse(-1e200 in range)
|
||||
assertFalse(-100.0 in range)
|
||||
assertFalse(-1.00000000001 in range)
|
||||
@@ -103,14 +100,10 @@ public class RangeTest {
|
||||
assertFalse(3.15 in range)
|
||||
assertFalse(10.0 in range)
|
||||
assertFalse(1e200 in range)
|
||||
assertFalse(jDouble.POSITIVE_INFINITY in range)
|
||||
|
||||
assertFalse(jDouble.NaN in range)
|
||||
}
|
||||
|
||||
test fun floatRange() {
|
||||
val range = -1.0.toFloat()..3.14159.toFloat()
|
||||
assertFalse(jFloat.NEGATIVE_INFINITY in range)
|
||||
assertFalse(-1e30.toFloat() in range)
|
||||
assertFalse(-100.0.toFloat() in range)
|
||||
assertFalse(-1.00001.toFloat() in range)
|
||||
@@ -125,9 +118,6 @@ public class RangeTest {
|
||||
assertFalse(3.15.toFloat() in range)
|
||||
assertFalse(10.0.toFloat() in range)
|
||||
assertFalse(1e30.toFloat() in range)
|
||||
assertFalse(jFloat.POSITIVE_INFINITY in range)
|
||||
|
||||
assertFalse(jFloat.NaN in range)
|
||||
}
|
||||
|
||||
test fun comparableRange() {
|
||||
@@ -142,57 +132,4 @@ public class RangeTest {
|
||||
assertFalse("item" in range)
|
||||
assertFalse("trail" in range)
|
||||
}
|
||||
|
||||
test fun illegalProgressionCreation() {
|
||||
// create Progression explicitly with increment = 0
|
||||
failsWith(javaClass<IllegalArgumentException>()) { IntProgression(0, 5, 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { ByteProgression(0, 5, 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { ShortProgression(0, 5, 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { LongProgression(0, 5, 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { CharProgression('a', 'z', 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { DoubleProgression(0.0, 5.0, 0.0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { FloatProgression(0.0.toFloat(), 5.0.toFloat(), 0.0.toFloat()) }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0..5 step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toByte()..5.toByte() step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toShort()..5.toShort() step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toLong()..5.toLong() step 0.toLong() }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 'a'..'z' step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step 0.0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step 0.0.toFloat() }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0 downTo -5 step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toByte() downTo -5.toByte() step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toShort() downTo -5.toShort() step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toLong() downTo -5.toLong() step 0.toLong() }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 'z' downTo 'a' step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0 downTo -5.0 step 0.0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat() downTo -5.0.toFloat() step 0.0.toFloat() }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0..5 step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toByte()..5.toByte() step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toShort()..5.toShort() step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toLong()..5.toLong() step -2.toLong() }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 'a'..'z' step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step -0.5 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step -0.5.toFloat() }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0 downTo -5 step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toByte() downTo -5.toByte() step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toShort() downTo -5.toShort() step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toLong() downTo -5.toLong() step -2.toLong() }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 'z' downTo 'a' step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0 downTo -5.0 step -0.5 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat() downTo -5.0.toFloat() step -0.5.toFloat() }
|
||||
|
||||
// NaN increment or step
|
||||
failsWith(javaClass<IllegalArgumentException>()) { DoubleProgression(0.0, 5.0, jDouble.NaN) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { FloatProgression(0.0.toFloat(), 5.0.toFloat(), jFloat.NaN) }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step jDouble.NaN }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step jFloat.NaN }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 5.0 downTo 0.0 step jDouble.NaN }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 5.0.toFloat() downTo 0.0.toFloat() step jFloat.NaN }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package language
|
||||
|
||||
import java.lang.Double as jDouble
|
||||
import java.lang.Float as jFloat
|
||||
import org.junit.Test as test
|
||||
import kotlin.test.*
|
||||
|
||||
public class RangeTestJVM {
|
||||
|
||||
test fun doubleRange() {
|
||||
val range = -1.0..3.14159265358979
|
||||
assertFalse(jDouble.NEGATIVE_INFINITY in range)
|
||||
assertFalse(jDouble.POSITIVE_INFINITY in range)
|
||||
assertFalse(jDouble.NaN in range)
|
||||
}
|
||||
|
||||
test fun floatRange() {
|
||||
val range = -1.0.toFloat()..3.14159.toFloat()
|
||||
assertFalse(jFloat.NEGATIVE_INFINITY in range)
|
||||
assertFalse(jFloat.POSITIVE_INFINITY in range)
|
||||
|
||||
assertFalse(jFloat.NaN in range)
|
||||
}
|
||||
|
||||
test fun illegalProgressionCreation() {
|
||||
// create Progression explicitly with increment = 0
|
||||
failsWith(javaClass<IllegalArgumentException>()) { IntProgression(0, 5, 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { ByteProgression(0, 5, 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { ShortProgression(0, 5, 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { LongProgression(0, 5, 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { CharProgression('a', 'z', 0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { DoubleProgression(0.0, 5.0, 0.0) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { FloatProgression(0.0.toFloat(), 5.0.toFloat(), 0.0.toFloat()) }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0..5 step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toByte()..5.toByte() step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toShort()..5.toShort() step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toLong()..5.toLong() step 0.toLong() }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 'a'..'z' step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step 0.0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step 0.0.toFloat() }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0 downTo -5 step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toByte() downTo -5.toByte() step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toShort() downTo -5.toShort() step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toLong() downTo -5.toLong() step 0.toLong() }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 'z' downTo 'a' step 0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0 downTo -5.0 step 0.0 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat() downTo -5.0.toFloat() step 0.0.toFloat() }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0..5 step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toByte()..5.toByte() step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toShort()..5.toShort() step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toLong()..5.toLong() step -2.toLong() }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 'a'..'z' step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step -0.5 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step -0.5.toFloat() }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0 downTo -5 step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toByte() downTo -5.toByte() step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toShort() downTo -5.toShort() step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.toLong() downTo -5.toLong() step -2.toLong() }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 'z' downTo 'a' step -2 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0 downTo -5.0 step -0.5 }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat() downTo -5.0.toFloat() step -0.5.toFloat() }
|
||||
|
||||
// NaN increment or step
|
||||
failsWith(javaClass<IllegalArgumentException>()) { DoubleProgression(0.0, 5.0, jDouble.NaN) }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { FloatProgression(0.0.toFloat(), 5.0.toFloat(), jFloat.NaN) }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0..5.0 step jDouble.NaN }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 0.0.toFloat()..5.0.toFloat() step jFloat.NaN }
|
||||
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 5.0 downTo 0.0 step jDouble.NaN }
|
||||
failsWith(javaClass<IllegalArgumentException>()) { 5.0.toFloat() downTo 0.0.toFloat() step jFloat.NaN }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user