From 2fd143032915d0ed8fa9b0371dec79914dc5c4ea Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Sun, 27 Jan 2013 00:12:29 +0400 Subject: [PATCH] Tests for all kinds of ranges and sequences. --- .../test/language/RangeIterationTest.kt | 241 ++++++++++++++++++ libraries/stdlib/test/language/RangeTest.kt | 207 ++++++++++++--- 2 files changed, 413 insertions(+), 35 deletions(-) create mode 100644 libraries/stdlib/test/language/RangeIterationTest.kt diff --git a/libraries/stdlib/test/language/RangeIterationTest.kt b/libraries/stdlib/test/language/RangeIterationTest.kt new file mode 100644 index 00000000000..1a19067fd89 --- /dev/null +++ b/libraries/stdlib/test/language/RangeIterationTest.kt @@ -0,0 +1,241 @@ +package language + +import kotlin.test.assertEquals +import org.junit.Test as test + +public class RangeIterationTest { + private fun doTest( + sequence: NumberSequence, + expectedStart: N, + expectedEnd: N, + expectedIncrement: Number, + expectedElements: List + ) { + assertEquals(expectedStart, sequence.start) + assertEquals(expectedEnd, sequence.end) + assertEquals(expectedIncrement, sequence.increment) + + assertEquals(expectedElements, sequence.toList()) + } + + test fun emptyConstant() { + doTest(IntRange.EMPTY, 1, 0, 1, listOf()) + doTest(ByteRange.EMPTY, 1.toByte(), 0.toByte(), 1, listOf()) + doTest(ShortRange.EMPTY, 1.toShort(), 0.toShort(), 1, listOf()) + doTest(LongRange.EMPTY, 1.toLong(), 0.toLong(), 1.toLong(), listOf()) + + doTest(CharRange.EMPTY, 1.toChar(), 0.toChar(), 1, listOf()) + + doTest(DoubleRange.EMPTY, 1.0, 0.0, 1.0, listOf()) + doTest(FloatRange.EMPTY, 1.0.toFloat(), 0.0.toFloat(), 1.0.toFloat(), listOf()) + } + + test fun emptyRange() { + doTest(10..5, 10, 5, 1, listOf()) + doTest(10.toByte()..-5.toByte(), 10.toByte(), -5.toByte(), 1, listOf()) + doTest(10.toShort()..-5.toShort(), 10.toShort(), -5.toShort(), 1, listOf()) + doTest(10.toLong()..-5.toLong(), 10.toLong(), -5.toLong(), 1.toLong(), listOf()) + + doTest('z'..'a', 'z', 'a', 1, listOf()) + + doTest(5.0..-1.0, 5.0, -1.0, 1.0, listOf()) + doTest(5.0.toFloat()..-1.0.toFloat(), 5.0.toFloat(), -1.0.toFloat(), 1.toFloat(), listOf()) + } + + test fun oneElementRange() { + doTest(5..5, 5, 5, 1, listOf(5)) + doTest(5.toByte()..5.toByte(), 5.toByte(), 5.toByte(), 1, listOf(5.toByte())) + doTest(5.toShort()..5.toShort(), 5.toShort(), 5.toShort(), 1, listOf(5.toShort())) + doTest(5.toLong()..5.toLong(), 5.toLong(), 5.toLong(), 1.toLong(), listOf(5.toLong())) + + doTest('k'..'k', 'k', 'k', 1, listOf('k')) + + doTest(5.0..5.0, 5.0, 5.0, 1.0, listOf(5.0)) + doTest(5.0.toFloat()..5.0.toFloat(), 5.0.toFloat(), 5.0.toFloat(), 1.toFloat(), listOf(5.0.toFloat())) + } + + test fun simpleRange() { + doTest(3..9, 3, 9, 1, listOf(3, 4, 5, 6, 7, 8, 9)) + doTest(3.toByte()..9.toByte(), 3.toByte(), 9.toByte(), 1, listOf(3, 4, 5, 6, 7, 8, 9)) + doTest(3.toShort()..9.toShort(), 3.toShort(), 9.toShort(), 1, listOf(3, 4, 5, 6, 7, 8, 9)) + doTest(3.toLong()..9.toLong(), 3.toLong(), 9.toLong(), 1.toLong(), listOf(3, 4, 5, 6, 7, 8, 9)) + + doTest('c'..'g', 'c', 'g', 1, listOf('c', 'd', 'e', 'f', 'g')) + + doTest(3.0..9.0, 3.0, 9.0, 1.0, listOf(3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0)) + doTest(3.0.toFloat()..9.0.toFloat(), 3.0.toFloat(), 9.0.toFloat(), 1.toFloat(), + listOf(3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0)) + } + + + test fun emptyDownto() { + doTest(5 downTo 10, 5, 10, -1, listOf()) + doTest(5.toByte() downTo 10.toByte(), 5.toByte(), 10.toByte(), -1, listOf()) + doTest(5.toShort() downTo 10.toShort(), 5.toShort(), 10.toShort(), -1, listOf()) + doTest(5.toLong() downTo 10.toLong(), 5.toLong(), 10.toLong(), -1.toLong(), listOf()) + + doTest('a' downTo 'z', 'a', 'z', -1, listOf()) + + doTest(-1.0 downTo 5.0, -1.0, 5.0, -1.0, listOf()) + doTest(-1.0.toFloat() downTo 5.0.toFloat(), -1.0.toFloat(), 5.0.toFloat(), -1.0.toFloat(), listOf()) + } + + test fun oneElementDownTo() { + doTest(5 downTo 5, 5, 5, -1, listOf(5)) + doTest(5.toByte() downTo 5.toByte(), 5.toByte(), 5.toByte(), -1, listOf(5.toByte())) + doTest(5.toShort() downTo 5.toShort(), 5.toShort(), 5.toShort(), -1, listOf(5.toShort())) + doTest(5.toLong() downTo 5.toLong(), 5.toLong(), 5.toLong(), -1.toLong(), listOf(5.toLong())) + + doTest('k' downTo 'k', 'k', 'k', -1, listOf('k')) + + doTest(5.0 downTo 5.0, 5.0, 5.0, -1.0, listOf(5.0)) + doTest(5.0.toFloat() downTo 5.0.toFloat(), 5.0.toFloat(), 5.0.toFloat(), -1.0.toFloat(), listOf(5.0.toFloat())) + } + + test fun simpleDownTo() { + doTest(9 downTo 3, 9, 3, -1, listOf(9, 8, 7, 6, 5, 4, 3)) + doTest(9.toByte() downTo 3.toByte(), 9.toByte(), 3.toByte(), -1, listOf(9, 8, 7, 6, 5, 4, 3)) + doTest(9.toShort() downTo 3.toShort(), 9.toShort(), 3.toShort(), -1, listOf(9, 8, 7, 6, 5, 4, 3)) + doTest(9.toLong() downTo 3.toLong(), 9.toLong(), 3.toLong(), -1.toLong(), listOf(9, 8, 7, 6, 5, 4, 3)) + + doTest('g' downTo 'c', 'g', 'c', -1, listOf('g', 'f', 'e', 'd', 'c')) + + doTest(9.0 downTo 3.0, 9.0, 3.0, -1.0, listOf(9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0)) + doTest(9.0.toFloat() downTo 3.0.toFloat(), 9.0.toFloat(), 3.0.toFloat(), -1.0.toFloat(), + listOf(9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0)) + } + + + test fun simpleSteppedRange() { + doTest(3..9 step 2, 3, 9, 2, listOf(3, 5, 7, 9)) + doTest(3.toByte()..9.toByte() step 2, 3.toByte(), 9.toByte(), 2, listOf(3, 5, 7, 9)) + doTest(3.toShort()..9.toShort() step 2, 3.toShort(), 9.toShort(), 2, listOf(3, 5, 7, 9)) + doTest(3.toLong()..9.toLong() step 2.toLong(), 3.toLong(), 9.toLong(), 2.toLong(), listOf(3, 5, 7, 9)) + + doTest('c'..'g' step 2, 'c', 'g', 2, listOf('c', 'e', 'g')) + + doTest(4.0..6.0 step 0.5, 4.0, 6.0, 0.5, listOf(4.0, 4.5, 5.0, 5.5, 6.0)) + doTest(4.0.toFloat()..6.0.toFloat() step 0.5.toFloat(), 4.0.toFloat(), 6.0.toFloat(), 0.5.toFloat(), + listOf(4.0, 4.5, 5.0, 5.5, 6.0)) + } + + test fun simpleSteppedDownTo() { + doTest(9 downTo 3 step 2, 9, 3, -2, listOf(9, 7, 5, 3)) + doTest(9.toByte() downTo 3.toByte() step 2, 9.toByte(), 3.toByte(), -2, listOf(9, 7, 5, 3)) + doTest(9.toShort() downTo 3.toShort() step 2, 9.toShort(), 3.toShort(), -2, listOf(9, 7, 5, 3)) + doTest(9.toLong() downTo 3.toLong() step 2.toLong(), 9.toLong(), 3.toLong(), -2.toLong(), listOf(9, 7, 5, 3)) + + doTest('g' downTo 'c' step 2, 'g', 'c', -2, listOf('g', 'e', 'c')) + + doTest(6.0 downTo 4.0 step 0.5, 6.0, 4.0, -0.5, listOf(6.0, 5.5, 5.0, 4.5, 4.0)) + doTest(6.0.toFloat() downTo 4.0.toFloat() step 0.5.toFloat(), 6.0.toFloat(), 4.0.toFloat(), -0.5.toFloat(), + listOf(6.0, 5.5, 5.0, 4.5, 4.0)) + } + + + // 'inexact' means last element is not equal to sequence end + test fun inexactSteppedRange() { + doTest(3..8 step 2, 3, 8, 2, listOf(3, 5, 7)) + doTest(3.toByte()..8.toByte() step 2, 3.toByte(), 8.toByte(), 2, listOf(3, 5, 7)) + doTest(3.toShort()..8.toShort() step 2, 3.toShort(), 8.toShort(), 2, listOf(3, 5, 7)) + doTest(3.toLong()..8.toLong() step 2.toLong(), 3.toLong(), 8.toLong(), 2.toLong(), listOf(3, 5, 7)) + + doTest('a'..'d' step 2, 'a', 'd', 2, listOf('a', 'c')) + + doTest(4.0..5.8 step 0.5, 4.0, 5.8, 0.5, listOf(4.0, 4.5, 5.0, 5.5)) + doTest(4.0.toFloat()..5.8.toFloat() step 0.5.toFloat(), 4.0.toFloat(), 5.8.toFloat(), 0.5.toFloat(), + listOf(4.0, 4.5, 5.0, 5.5)) + } + + // 'inexact' means last element is not equal to sequence end + test fun inexactSteppedDownTo() { + doTest(8 downTo 3 step 2, 8, 3, -2, listOf(8, 6, 4)) + doTest(8.toByte() downTo 3.toByte() step 2, 8.toByte(), 3.toByte(), -2, listOf(8, 6, 4)) + doTest(8.toShort() downTo 3.toShort() step 2, 8.toShort(), 3.toShort(), -2, listOf(8, 6, 4)) + doTest(8.toLong() downTo 3.toLong() step 2.toLong(), 8.toLong(), 3.toLong(), -2.toLong(), listOf(8, 6, 4)) + + doTest('d' downTo 'a' step 2, 'd', 'a', -2, listOf('d', 'b')) + + doTest(5.5 downTo 3.7 step 0.5, 5.5, 3.7, -0.5, listOf(5.5, 5.0, 4.5, 4.0)) + doTest(5.5.toFloat() downTo 3.7.toFloat() step 0.5.toFloat(), 5.5.toFloat(), 3.7.toFloat(), -0.5.toFloat(), + listOf(5.5, 5.0, 4.5, 4.0)) + } + + + test fun reversedEmptyRange() { + doTest((5..3).reversed(), 3, 5, -1, listOf()) + doTest((5.toByte()..3.toByte()).reversed(), 3.toByte(), 5.toByte(), -1, listOf()) + doTest((5.toShort()..3.toShort()).reversed(), 3.toShort(), 5.toShort(), -1, listOf()) + doTest((5.toLong()..3.toLong()).reversed(), 3.toLong(), 5.toLong(), -1.toLong(), listOf()) + + doTest(('c'..'a').reversed(), 'a', 'c', -1, listOf()) + + doTest((5.0..3.0).reversed(), 3.0, 5.0, -1.0, listOf()) + doTest((5.0.toFloat()..3.0.toFloat()).reversed(), 3.0.toFloat(), 5.0.toFloat(), -1.toFloat(), listOf()) + } + + test fun reversedEmptyBackSequence() { + doTest((3 downTo 5).reversed(), 5, 3, 1, listOf()) + doTest((3.toByte() downTo 5.toByte()).reversed(), 5.toByte(), 3.toByte(), 1, listOf()) + doTest((3.toShort() downTo 5.toShort()).reversed(), 5.toShort(), 3.toShort(), 1, listOf()) + doTest((3.toLong() downTo 5.toLong()).reversed(), 5.toLong(), 3.toLong(), 1.toLong(), listOf()) + + doTest(('a' downTo 'c').reversed(), 'c', 'a', 1, listOf()) + + doTest((3.0 downTo 5.0).reversed(), 5.0, 3.0, 1.0, listOf()) + doTest((3.0.toFloat() downTo 5.0.toFloat()).reversed(), 5.0.toFloat(), 3.0.toFloat(), 1.toFloat(), listOf()) + } + + test fun reversedRange() { + doTest((3..5).reversed(), 5, 3, -1, listOf(5, 4, 3)) + doTest((3.toByte()..5.toByte()).reversed(), 5.toByte(), 3.toByte(), -1, listOf(5, 4, 3)) + doTest((3.toShort()..5.toShort()).reversed(), 5.toShort(), 3.toShort(), -1, listOf(5, 4, 3)) + doTest((3.toLong()..5.toLong()).reversed(), 5.toLong(), 3.toLong(), -1.toLong(), listOf(5, 4, 3)) + + doTest(('a'..'c').reversed(), 'c', 'a', -1, listOf('c', 'b', 'a')) + + doTest((3.0..5.0).reversed(), 5.0, 3.0, -1.0, listOf(5.0, 4.0, 3.0)) + doTest((3.0.toFloat()..5.0.toFloat()).reversed(), 5.0.toFloat(), 3.0.toFloat(), -1.toFloat(), + listOf(5.0, 4.0, 3.0)) + } + + test fun reversedBackSequence() { + doTest((5 downTo 3).reversed(), 3, 5, 1, listOf(3, 4, 5)) + doTest((5.toByte() downTo 3.toByte()).reversed(), 3.toByte(), 5.toByte(), 1, listOf(3, 4, 5)) + doTest((5.toShort() downTo 3.toShort()).reversed(), 3.toShort(), 5.toShort(), 1, listOf(3, 4, 5)) + doTest((5.toLong() downTo 3.toLong()).reversed(), 3.toLong(), 5.toLong(), 1.toLong(), listOf(3, 4, 5)) + + doTest(('c' downTo 'a').reversed(), 'a', 'c', 1, listOf('a', 'b', 'c')) + + doTest((5.0 downTo 3.0).reversed(), 3.0, 5.0, 1.0, listOf(3.0, 4.0, 5.0)) + doTest((5.0.toFloat() downTo 3.0.toFloat()).reversed(), 3.0.toFloat(), 5.0.toFloat(), 1.toFloat(), + listOf(3.0, 4.0, 5.0)) + } + + test fun reversedSimpleSteppedRange() { + doTest((3..9 step 2).reversed(), 9, 3, -2, listOf(9, 7, 5, 3)) + doTest((3.toByte()..9.toByte() step 2).reversed(), 9.toByte(), 3.toByte(), -2, listOf(9, 7, 5, 3)) + doTest((3.toShort()..9.toShort() step 2).reversed(), 9.toShort(), 3.toShort(), -2, listOf(9, 7, 5, 3)) + doTest((3.toLong()..9.toLong() step 2.toLong()).reversed(), 9.toLong(), 3.toLong(), -2.toLong(), listOf(9, 7, 5, 3)) + + doTest(('c'..'g' step 2).reversed(), 'g', 'c', -2, listOf('g', 'e', 'c')) + + doTest((4.0..6.0 step 0.5).reversed(), 6.0, 4.0, -0.5, listOf(6.0, 5.5, 5.0, 4.5, 4.0)) + doTest((4.0.toFloat()..6.0.toFloat() step 0.5).reversed(), 6.0.toFloat(), 4.0.toFloat(), -0.5.toFloat(), + listOf(6.0, 5.5, 5.0, 4.5, 4.0)) + } + + // 'inexact' means last element is not equal to sequence end + test fun reversedInexactSteppedDownTo() { + doTest((8 downTo 3 step 2).reversed(), 3, 8, 2, listOf(3, 5, 7)) + doTest((8.toByte() downTo 3.toByte() step 2).reversed(), 3.toByte(), 8.toByte(), 2, listOf(3, 5, 7)) + doTest((8.toShort() downTo 3.toShort() step 2).reversed(), 3.toShort(), 8.toShort(), 2, listOf(3, 5, 7)) + doTest((8.toLong() downTo 3.toLong() step 2.toLong()).reversed(), 3.toLong(), 8.toLong(), 2.toLong(), listOf(3, 5, 7)) + + doTest(('d' downTo 'a' step 2).reversed(), 'a', 'd', 2, listOf('a', 'c')) + + doTest((5.8 downTo 4.0 step 0.5).reversed(), 4.0, 5.8, 0.5, listOf(4.0, 4.5, 5.0, 5.5)) + doTest((5.8.toFloat() downTo 4.0.toFloat() step 0.5).reversed(), 4.0.toFloat(), 5.8.toFloat(), 0.5.toFloat(), + listOf(4.0, 4.5, 5.0, 5.5)) + } +} \ No newline at end of file diff --git a/libraries/stdlib/test/language/RangeTest.kt b/libraries/stdlib/test/language/RangeTest.kt index 7b4b5275bce..5fe74b03196 100644 --- a/libraries/stdlib/test/language/RangeTest.kt +++ b/libraries/stdlib/test/language/RangeTest.kt @@ -1,51 +1,188 @@ package language -import org.junit.Test as test +import java.lang.Double as jDouble +import java.lang.Float as jFloat import kotlin.test.* +import org.junit.Test as test -class RangeTest { - test fun upRange() { - val range = 0.rangeTo(9) - println("Have created up range: $range") - assertTrue(range.contains(0)) - assertTrue(range.contains(1)) - assertTrue(range.contains(9)) - assertFalse(range.contains(10)) +public class RangeTest { + test fun intRange() { + val range = -5..9 + assertFalse(-1000 in range) + assertFalse(-6 in range) + + assertTrue(-5 in range) + assertTrue(-4 in range) + assertTrue(0 in range) + assertTrue(3 in range) + assertTrue(8 in range) + assertTrue(9 in range) + + assertFalse(10 in range) + assertFalse(9000 in range) } - test fun downRange() { - val range = 9.downTo(0) - println("Have created down range: $range") - assertTrue(range.contains(0)) - assertTrue(range.contains(1)) - assertTrue(range.contains(9)) - assertFalse(range.contains(10)) + test fun byteRange() { + val range = -5.toByte()..9.toByte() + assertFalse(-100.toByte() in range) + assertFalse(-6.toByte() in range) + + assertTrue(-5.toByte() in range) + assertTrue(-4.toByte() in range) + assertTrue(0.toByte() in range) + assertTrue(3.toByte() in range) + assertTrue(8.toByte() in range) + assertTrue(9.toByte() in range) + + assertFalse(10.toByte() in range) + assertFalse(111.toByte() in range) } - test fun reversedRanges() { - val intRange = 0..9 - val reversedIntRange = intRange.reversed() - assertEquals(9, reversedIntRange.start) - assertEquals(0, reversedIntRange.end) - assertEquals(intRange.toList(), reversedIntRange.reversed().toList()) + test fun shortRange() { + val range = -5.toShort()..9.toShort() + assertFalse(-1000.toShort() in range) + assertFalse(-6.toShort() in range) - val doubleRange = 0.0..9.0 - val reversedDoubleRange = doubleRange.reversed() - assertEquals(9.0, reversedDoubleRange.start) - assertEquals(0.0, reversedDoubleRange.end) - assertEquals(doubleRange.toList(), reversedDoubleRange.reversed().toList()) + assertTrue(-5.toShort() in range) + assertTrue(-4.toShort() in range) + assertTrue(0.toShort() in range) + assertTrue(3.toShort() in range) + assertTrue(8.toShort() in range) + assertTrue(9.toShort() in range) + + assertFalse(10.toShort() in range) + assertFalse(239.toShort() in range) + } + + test fun longRange() { + val range = -5.toLong()..9.toLong() + assertFalse(-10000000.toLong() in range) + assertFalse(-6.toLong() in range) + + assertTrue(-5.toLong() in range) + assertTrue(-4.toLong() in range) + assertTrue(0.toLong() in range) + assertTrue(3.toLong() in range) + assertTrue(8.toLong() in range) + assertTrue(9.toLong() in range) + + assertFalse(10.toLong() in range) + assertFalse(10000000.toLong() in range) + } + + test fun charRange() { + val range = 'c'..'w' + assertFalse('0' in range) + assertFalse('b' in range) + + assertTrue('c' in range) + assertTrue('d' in range) + assertTrue('h' in range) + assertTrue('m' in range) + assertTrue('v' in range) + assertTrue('w' in range) + + assertFalse('z' in range) + assertFalse('\u1000' in range) + } + + 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) + + assertTrue(-1.0 in range) + assertTrue(-0.99999999999 in range) + assertTrue(0.0 in range) + assertTrue(1.5 in range) + assertTrue(3.1415 in range) + assertTrue(3.14159265358979 in range) + + 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) + + assertTrue(-1.0.toFloat() in range) + assertTrue(-0.99999.toFloat() in range) + assertTrue(0.0.toFloat() in range) + assertTrue(1.5.toFloat() in range) + assertTrue(3.1415.toFloat() in range) + assertTrue(3.14159.toFloat() in range) + + 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() { - val range1 = "island".."isle" - assertTrue("island" in range1) - assertTrue("isle" in range1) - assertTrue("islandic" in range1) + val range = "island".."isle" + assertFalse("apple" in range) + assertFalse("icicle" in range) - assertFalse("apple" in range1) - assertFalse("icicle" in range1) + assertTrue("island" in range) + assertTrue("isle" in range) + assertTrue("islandic" in range) - assertFalse("item" in range1) - assertFalse("trail" in range1) + assertFalse("item" in range) + assertFalse("trail" in range) + } + + test fun illegalSequenceCreation() { + // create sequence explicitly with increment = 0 + failsWith { IntSequence(0, 5, 0) } + failsWith { ByteSequence(0, 5, 0) } + failsWith { ShortSequence(0, 5, 0) } + failsWith { LongSequence(0, 5, 0) } + failsWith { CharacterSequence('a', 'z', 0) } + failsWith { DoubleSequence(0.0, 5.0, 0.0) } + failsWith { FloatSequence(0.0.toFloat(), 5.0.toFloat(), 0.0.toFloat()) } + + failsWith { 0..5 step 0 } + failsWith { 0.toByte()..5.toByte() step 0 } + failsWith { 0.toShort()..5.toShort() step 0 } + failsWith { 0.toLong()..5.toLong() step 0.toLong() } + failsWith { 'a'..'z' step 0 } + failsWith { 0.0..5.0 step 0.0 } + failsWith { 0.0.toFloat()..5.0.toFloat() step 0.0.toFloat() } + + failsWith { 0 downTo -5 step 0 } + failsWith { 0.toByte() downTo -5.toByte() step 0 } + failsWith { 0.toShort() downTo -5.toShort() step 0 } + failsWith { 0.toLong() downTo -5.toLong() step 0.toLong() } + failsWith { 'z' downTo 'a' step 0 } + failsWith { 0.0 downTo -5.0 step 0.0 } + failsWith { 0.0.toFloat() downTo -5.0.toFloat() step 0.0.toFloat() } + + failsWith { 0..5 step -2 } + failsWith { 0.toByte()..5.toByte() step -2 } + failsWith { 0.toShort()..5.toShort() step -2 } + failsWith { 0.toLong()..5.toLong() step -2.toLong() } + failsWith { 'a'..'z' step -2 } + failsWith { 0.0..5.0 step -0.5 } + failsWith { 0.0.toFloat()..5.0.toFloat() step -0.5.toFloat() } + + failsWith { 0 downTo -5 step -2 } + failsWith { 0.toByte() downTo -5.toByte() step -2 } + failsWith { 0.toShort() downTo -5.toShort() step -2 } + failsWith { 0.toLong() downTo -5.toLong() step -2.toLong() } + failsWith { 'z' downTo 'a' step -2 } + failsWith { 0.0 downTo -5.0 step -0.5 } + failsWith { 0.0.toFloat() downTo -5.0.toFloat() step -0.5.toFloat() } } } \ No newline at end of file