| class RangeTest extends GroovyTestCase { |
| |
| void testRange() { |
| x = 0 |
| |
| for ( i in 0..9 ) { |
| x = x + i |
| } |
| |
| assert x == 45 |
| |
| x = 0 |
| |
| for ( i in 0...10 ) { |
| x = x + i |
| } |
| |
| assert x == 45 |
| |
| x = 0 |
| |
| for ( i in 0..'\u0009' ) { |
| x = x + i |
| } |
| |
| assert x == 45 |
| } |
| |
| void testRangeEach() { |
| x = 0 |
| |
| (0..9).each { |
| x = x + it |
| } |
| |
| assert x == 45 |
| |
| x = 0 |
| |
| (0...10).each { |
| x = x + it |
| } |
| |
| assert x == 45 |
| } |
| |
| void testIntStep() { |
| assertStep(0..9, 3, [0, 3, 6, 9]) |
| assertStep(0...10, 3, [0, 3, 6, 9]) |
| |
| assertStep(9..0, 3, [9, 6, 3, 0]) |
| assertStep(9...0, 3, [9, 6, 3]) |
| } |
| |
| void testObjectStep() { |
| assertStep('a'..'f', 2, ['a', 'c', 'e']) |
| assertStep('a'...'e', 2, ['a', 'c']) |
| |
| assertStep('z'..'v', 2, ['z', 'x', 'v']) |
| assertStep('z'...'v', 2, ['z', 'x']) |
| } |
| |
| void testIterateIntRange() { |
| assertIterate(0..9, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) |
| assertIterate(1...8, [1, 2, 3, 4, 5, 6, 7]) |
| assertIterate(7..1, [7, 6, 5, 4, 3, 2, 1]) |
| assertIterate(6...1, [6, 5, 4, 3, 2]) |
| } |
| |
| void testIterateObjectRange() { |
| assertIterate('a'..'d', ['a', 'b', 'c', 'd']) |
| assertIterate('a'...'d', ['a', 'b', 'c']) |
| assertIterate('z'..'x', ['z', 'y', 'x']) |
| assertIterate('z'...'x', ['z', 'y']) |
| } |
| |
| void testRangeContains() { |
| range = 0..10 |
| assert range.contains(0) |
| assert range.contains(10) |
| |
| range = 0...5 |
| assert range.contains(0) |
| assert ! range.contains(5) |
| } |
| |
| void testBackwardsRangeContains() { |
| range = 10..0 |
| assert range.contains(0) |
| assert range.contains(10) |
| |
| range = 5...1 |
| assert range.contains(5) |
| assert ! range.contains(1) |
| } |
| |
| void testObjectRangeContains() { |
| range = 'a'..'x' |
| assert range.contains('a') |
| assert range.contains('x') |
| assert range.contains('z') == false |
| |
| range = 'b'...'f' |
| assert range.contains('b') |
| assert ! range.contains('g') |
| assert ! range.contains('f') |
| assert ! range.contains('a') |
| } |
| |
| void testBackwardsObjectRangeContains() { |
| range = 'x'..'a' |
| assert range.contains('a') |
| assert range.contains('x') |
| assert range.contains('z') == false |
| |
| range = 'f'...'b' |
| assert ! range.contains('g') |
| assert range.contains('f') |
| assert range.contains('c') |
| assert ! range.contains('b') |
| } |
| |
| void testIntRangeToString() { |
| assertToString(0..10, "0..10") |
| assertToString([1, 4..10, 9], "[1, 4..10, 9]") |
| |
| assertToString(0...11, "0..10") |
| assertToString([1, 4...11, 9], "[1, 4..10, 9]") |
| |
| |
| assertToString(10..0, "10..0") |
| assertToString([1, 10..4, 9], "[1, 10..4, 9]") |
| |
| assertToString(11...0, "11..1") |
| assertToString([1, 11...4, 9], "[1, 11..5, 9]") |
| } |
| |
| void testObjectRangeToString() { |
| assertToString('a'..'d', 'a..d', '"a".."d"') |
| assertToString('a'...'d', 'a..c', '"a".."c"') |
| assertToString('z'..'x', 'z..x', '"z".."x"') |
| assertToString('z'...'x', 'z..y', '"z".."y"') |
| } |
| |
| void testRangeSize() { |
| assertSize(1..10, 10) |
| assertSize(11...21, 10) |
| assertSize(30..21, 10) |
| assertSize(40...30, 10) |
| } |
| |
| void testStringRange() { |
| range = 'a'..'d' |
| |
| list = [] |
| range.each { list << it } |
| assert list == ['a', 'b', 'c', 'd'] |
| |
| s = range.size() |
| assert s == 4 |
| } |
| |
| void testBackwardsStringRange() { |
| range = 'd'..'a' |
| |
| list = [] |
| range.each { list << it } |
| assert list == ['d', 'c', 'b', 'a'] |
| |
| s = range.size() |
| assert s == 4 |
| } |
| |
| protected void assertIterate(range, expected) { |
| list = [] |
| for (it in range) { |
| list << it |
| } |
| assert list == expected : "for loop on ${range}" |
| |
| list = [] |
| range.each { list << it} |
| assert list == expected : "each() on ${range}" |
| } |
| |
| protected void assertSize(range, expected) { |
| size = range.size() |
| assert size == expected : range |
| } |
| |
| protected void assertToString(range, expected) { |
| text = range.toString() |
| assert text == expected : "toString() for ${range}" |
| text = range.inspect() |
| assert text == expected : "inspect() for ${range}" |
| } |
| |
| protected void assertToString(range, expectedString, expectedInspect) { |
| text = range.toString() |
| assert text == expectedString : "toString() for ${range}" |
| text = range.inspect() |
| assert text == expectedInspect : "inspect() for ${range}" |
| } |
| |
| protected void assertStep(range, stepValue, expected) { |
| list = [] |
| range.step(stepValue) { |
| list << it |
| } |
| assert list == expected |
| |
| list = [] |
| for (it in range.step(stepValue)) { |
| list << it |
| } |
| assert list == expected |
| } |
| } |