diff options
author | nahi <nahi@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2003-09-04 16:18:59 +0000 |
---|---|---|
committer | nahi <nahi@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2003-09-04 16:18:59 +0000 |
commit | aaf5d9c03cd41818edb34a154ac570b7fe61687c (patch) | |
tree | 5bc96fa0c702404154d3ba936276873cc7cc242f /test/ruby/test_iterator.rb | |
parent | 822a72b8ee2752051e11b3b62fc6c5cd21c9409e (diff) |
* test/ruby: tests for ruby itself.
* test/ruby/test_*.rb: split sample/test.rb into 28 test/unit testcases. some
tests could not be translates... search '!!' mark to see it.
* test/csv/test_csv.rb: should require 'csv', not '../lib/csv'. test runner
should set load path correctly.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4498 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'test/ruby/test_iterator.rb')
-rw-r--r-- | test/ruby/test_iterator.rb | 383 |
1 files changed, 383 insertions, 0 deletions
diff --git a/test/ruby/test_iterator.rb b/test/ruby/test_iterator.rb new file mode 100644 index 0000000000..3d7e6cbcd2 --- /dev/null +++ b/test/ruby/test_iterator.rb @@ -0,0 +1,383 @@ +require 'test/unit' + +$KCODE = 'none' + +class Array + def iter_test1 + collect{|e| [e, yield(e)]}.sort{|a,b|a[1]<=>b[1]} + end + def iter_test2 + a = collect{|e| [e, yield(e)]} + a.sort{|a,b|a[1]<=>b[1]} + end +end + +class TestIterator < Test::Unit::TestCase + def ttt + assert(iterator?) + end + + def test_iterator + assert(!iterator?) + + ttt{} + + # yield at top level !! here's not toplevel + assert(!defined?(yield)) + end + + def test_array + $x = [1, 2, 3, 4] + $y = [] + + # iterator over array + for i in $x + $y.push i + end + assert($x == $y) + end + + def tt + 1.upto(10) {|i| + yield i + } + end + + def tt2(dummy) + yield 1 + end + + def tt3(&block) + tt2(raise(ArgumentError,""),&block) + end + + def test_nested_iterator + i = 0 + tt{|i| break if i == 5} + assert(i == 5) + + $x = false + begin + tt3{} + rescue ArgumentError + $x = true + rescue Exception + end + assert($x) + end + + # iterator break/redo/next/retry + def test_break + done = true + loop{ + break + done = false # should not reach here + } + assert(done) + + done = false + $bad = false + loop { + break if done + done = true + next + $bad = true # should not reach here + } + assert(!$bad) + + done = false + $bad = false + loop { + break if done + done = true + redo + $bad = true # should not reach here + } + assert(!$bad) + + $x = [] + for i in 1 .. 7 + $x.push i + end + assert($x.size == 7) + assert($x == [1, 2, 3, 4, 5, 6, 7]) + + $done = false + $x = [] + for i in 1 .. 7 # see how retry works in iterator loop + if i == 4 and not $done + $done = true + retry + end + $x.push(i) + end + assert($x.size == 10) + assert($x == [1, 2, 3, 1, 2, 3, 4, 5, 6, 7]) + end + + def test_append_method_to_built_in_class + $x = [[1,2],[3,4],[5,6]] + assert($x.iter_test1{|x|x} == $x.iter_test2{|x|x}) + end + + class IterTest + def initialize(e); @body = e; end + + def each0(&block); @body.each(&block); end + def each1(&block); @body.each {|*x| block.call(*x) } end + def each2(&block); @body.each {|*x| block.call(x) } end + def each3(&block); @body.each {|x| block.call(*x) } end + def each4(&block); @body.each {|x| block.call(x) } end + def each5; @body.each {|*x| yield(*x) } end + def each6; @body.each {|*x| yield(x) } end + def each7; @body.each {|x| yield(*x) } end + def each8; @body.each {|x| yield(x) } end + + def f(a) + a + end + end + + def test_itertest + assert(IterTest.new(nil).method(:f).to_proc.call([1]) == [1]) + m = /\w+/.match("abc") + assert(IterTest.new(nil).method(:f).to_proc.call([m]) == [m]) + + IterTest.new([0]).each0 {|x| assert(x == 0)} + IterTest.new([1]).each1 {|x| assert(x == 1)} + IterTest.new([2]).each2 {|x| assert(x == [2])} + IterTest.new([3]).each3 {|x| assert(x == 3)} + IterTest.new([4]).each4 {|x| assert(x == 4)} + IterTest.new([5]).each5 {|x| assert(x == 5)} + IterTest.new([6]).each6 {|x| assert(x == [6])} + IterTest.new([7]).each7 {|x| assert(x == 7)} + IterTest.new([8]).each8 {|x| assert(x == 8)} + + IterTest.new([[0]]).each0 {|x| assert(x == [0])} + IterTest.new([[1]]).each1 {|x| assert(x == [1])} + IterTest.new([[2]]).each2 {|x| assert(x == [[2]])} + IterTest.new([[3]]).each3 {|x| assert(x == 3)} + IterTest.new([[4]]).each4 {|x| assert(x == [4])} + IterTest.new([[5]]).each5 {|x| assert(x == [5])} + IterTest.new([[6]]).each6 {|x| assert(x == [[6]])} + IterTest.new([[7]]).each7 {|x| assert(x == 7)} + IterTest.new([[8]]).each8 {|x| assert(x == [8])} + + IterTest.new([[0,0]]).each0 {|x| assert(x == [0,0])} + IterTest.new([[8,8]]).each8 {|x| assert(x == [8,8])} + end + + def m(var) + assert(var) + end + + def m1 + m(block_given?) + end + + def m2 + m(block_given?,&proc{}) + end + + def test_foo + m1{p 'test'} + m2{p 'test'} + end + + class C + include Enumerable + def initialize + @a = [1,2,3] + end + def each(&block) + @a.each(&block) + end + end + + def test_collect + assert(C.new.collect{|n| n} == [1,2,3]) + end + + def test_proc + assert(Proc == lambda{}.class) + assert(Proc == Proc.new{}.class) + lambda{|a|assert(a==1)}.call(1) + end + + def block_test(klass, &block) + assert(klass === block) + end + + def test_block + block_test(NilClass) + block_test(Proc){} + end + + def argument_test(state, proc, *args) + x = state + begin + proc.call(*args) + rescue ArgumentError + x = !x + end + assert(x,2) + end + + def test_argument + argument_test(true, lambda{||}) + argument_test(false, lambda{||}, 1) + argument_test(true, lambda{|a,|}, 1) + argument_test(false, lambda{|a,|}) + argument_test(false, lambda{|a,|}, 1,2) + end + + def get_block(&block) + block + end + + def test_get_block + assert(Proc == get_block{}.class) + argument_test(true, get_block{||}) + argument_test(true, get_block{||}, 1) + argument_test(true, get_block{|a,|}, 1) + argument_test(true, get_block{|a,|}) + argument_test(true, get_block{|a,|}, 1,2) + + argument_test(true, get_block(&lambda{||})) + argument_test(false, get_block(&lambda{||}),1) + argument_test(true, get_block(&lambda{|a,|}),1) + argument_test(false, get_block(&lambda{|a,|}),1,2) + + block = get_block{11} + assert(block.class == Proc) + assert(block.to_proc.class == Proc) + assert(block.clone.call == 11) + assert(get_block(&block).class == Proc) + + lambda = lambda{44} + assert(lambda.class == Proc) + assert(lambda.to_proc.class == Proc) + assert(lambda.clone.call == 44) + assert(get_block(&lambda).class == Proc) + + assert(Proc.new{|a,| a}.call(1,2,3) == 1) + argument_test(true, Proc.new{|a,|}, 1,2) + end + + def return1_test # !! test_return1 -> return1_test + Proc.new { + return 55 + }.call + 5 + end + + def test_return1 + assert(return1_test() == 55) + end + + def return2_test # !! test_return2 -> return2_test + lambda { + return 55 + }.call + 5 + end + + def test_return2 + assert(return2_test() == 60) + end + + def proc_call(&b) + b.call + end + def proc_yield() + yield + end + def proc_return1 + proc_call{return 42}+1 + end + + def test_proc_return1 + assert(proc_return1() == 42) + end + + def proc_return2 + proc_yield{return 42}+1 + end + + def test_proc_return2 + assert(proc_return2() == 42) + end + + def ljump_test(state, proc, *args) + x = state + begin + proc.call(*args) + rescue LocalJumpError + x = !x + end + assert(x,2) + end + + def test_ljump + block = get_block{11} + lambda = lambda{44} + # ljump_test(false, get_block{break}) # !! This line terminates testrunner... please sombody fix it. + ljump_test(true, lambda{break}) + + assert(block.arity == -1) + assert(lambda.arity == -1) + assert(lambda{||}.arity == 0) + assert(lambda{|a|}.arity == 1) + assert(lambda{|a,|}.arity == 1) + assert(lambda{|a,b|}.arity == 2) + end + + def marity_test(m) + method = method(m) + assert(method.arity == method.to_proc.arity) + end + + def test_marity + marity_test(:assert) + marity_test(:marity_test) + marity_test(:p) + + lambda(&method(:assert)).call(true) + lambda(&get_block{|a,n| assert(a,n)}).call(true, 2) + end + + class ITER_TEST1 + def a + block_given? + end + end + + class ITER_TEST2 < ITER_TEST1 + include Test::Unit::Assertions + def a + assert(super) + super + end + end + + def test_iter_test2 + assert(ITER_TEST2.new.a {}) + end + + class ITER_TEST3 + def foo x + return yield if block_given? + x + end + end + + class ITER_TEST4 < ITER_TEST3 + include Test::Unit::Assertions + def foo x + assert(super == yield) + assert(super(x, &nil) == x) + end + end + + def test_iter4 + ITER_TEST4.new.foo(44){55} + end +end |