From 54ec1c4fe81672ca66f327ef6ae170f458cd79e5 Mon Sep 17 00:00:00 2001 From: shyouhei Date: Wed, 15 Aug 2007 20:57:30 +0000 Subject: sorry. I made wrong tags. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/tags/v1_8_5_54@13009 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ruby_1_8_5/test/ruby/test_iterator.rb | 465 ---------------------------------- 1 file changed, 465 deletions(-) delete mode 100644 ruby_1_8_5/test/ruby/test_iterator.rb (limited to 'ruby_1_8_5/test/ruby/test_iterator.rb') diff --git a/ruby_1_8_5/test/ruby/test_iterator.rb b/ruby_1_8_5/test/ruby/test_iterator.rb deleted file mode 100644 index 638916309e..0000000000 --- a/ruby_1_8_5/test/ruby/test_iterator.rb +++ /dev/null @@ -1,465 +0,0 @@ -require 'test/unit' - -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_equal($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_equal(5, i) - - assert_raises(ArgumentError) do - tt3{} - end - end - - def tt4 &block - tt2(raise(ArgumentError,""),&block) - end - - def test_block_argument_without_paren - assert_raises(ArgumentError) do - tt4{} - end - 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_equal(7, $x.size) - assert_equal([1, 2, 3, 4, 5, 6, 7], $x) - - $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_equal(10, $x.size) - assert_equal([1, 2, 3, 1, 2, 3, 4, 5, 6, 7], $x) - end - - def test_append_method_to_built_in_class - $x = [[1,2],[3,4],[5,6]] - assert_equal($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_equal([1], IterTest.new(nil).method(:f).to_proc.call([1])) - m = /\w+/.match("abc") - assert_equal([m], IterTest.new(nil).method(:f).to_proc.call([m])) - - IterTest.new([0]).each0 {|x| assert_equal(0, x)} - IterTest.new([1]).each1 {|x| assert_equal(1, x)} - IterTest.new([2]).each2 {|x| assert_equal([2], x)} - IterTest.new([3]).each3 {|x| assert_equal(3, x)} - IterTest.new([4]).each4 {|x| assert_equal(4, x)} - IterTest.new([5]).each5 {|x| assert_equal(5, x)} - IterTest.new([6]).each6 {|x| assert_equal([6], x)} - IterTest.new([7]).each7 {|x| assert_equal(7, x)} - IterTest.new([8]).each8 {|x| assert_equal(8, x)} - - IterTest.new([[0]]).each0 {|x| assert_equal([0], x)} - IterTest.new([[1]]).each1 {|x| assert_equal([1], x)} - IterTest.new([[2]]).each2 {|x| assert_equal([[2]], x)} - IterTest.new([[3]]).each3 {|x| assert_equal(3, x)} - IterTest.new([[4]]).each4 {|x| assert_equal([4], x)} - IterTest.new([[5]]).each5 {|x| assert_equal([5], x)} - IterTest.new([[6]]).each6 {|x| assert_equal([[6]], x)} - IterTest.new([[7]]).each7 {|x| assert_equal(7, x)} - IterTest.new([[8]]).each8 {|x| assert_equal([8], x)} - - IterTest.new([[0,0]]).each0 {|x| assert_equal([0,0], x)} - IterTest.new([[8,8]]).each8 {|x| assert_equal([8,8], x)} - end - - def m(var) - var - end - - def m1 - m(block_given?) - end - - def m2 - m(block_given?,&proc{}) - end - - def test_block_given - assert(m1{p 'test'}) - assert(m2{p 'test'}) - assert(!m1()) - assert(!m2()) - end - - def m3(var, &block) - m(yield(var), &block) - end - - def m4(&block) - m(m1(), &block) - end - - def test_block_passing - assert(!m4()) - assert(!m4 {}) - assert_equal(100, m3(10) {|x|x*x}) - end - - class C - include Enumerable - def initialize - @a = [1,2,3] - end - def each(&block) - @a.each(&block) - end - end - - def test_collect - assert_equal([1,2,3], C.new.collect{|n| n}) - end - - def test_proc - assert_instance_of(Proc, lambda{}) - assert_instance_of(Proc, Proc.new{}) - lambda{|a|assert_equal(a, 1)}.call(1) - end - - def test_block - assert_instance_of(NilClass, get_block) - assert_instance_of(Proc, get_block{}) - end - - def test_argument - assert_nothing_raised {lambda{||}.call} - assert_raises(ArgumentError) {lambda{||}.call(1)} - assert_nothing_raised {lambda{|a,|}.call(1)} - assert_raises(ArgumentError) {lambda{|a,|}.call()} - assert_raises(ArgumentError) {lambda{|a,|}.call(1,2)} - end - - def get_block(&block) - block - end - - def test_get_block - assert_instance_of(Proc, get_block{}) - assert_nothing_raised {get_block{||}.call()} - assert_nothing_raised {get_block{||}.call(1)} - assert_nothing_raised {get_block{|a,|}.call(1)} - assert_nothing_raised {get_block{|a,|}.call()} - assert_nothing_raised {get_block{|a,|}.call(1,2)} - - assert_nothing_raised {get_block(&lambda{||}).call()} - assert_raises(ArgumentError) {get_block(&lambda{||}).call(1)} - assert_nothing_raised {get_block(&lambda{|a,|}).call(1)} - assert_raises(ArgumentError) {get_block(&lambda{|a,|}).call(1,2)} - - block = get_block{11} - assert_instance_of(Proc, block) - assert_instance_of(Proc, block.to_proc) - assert_equal(block.clone.call, 11) - assert_instance_of(Proc, get_block(&block)) - - lambda = lambda{44} - assert_instance_of(Proc, lambda) - assert_instance_of(Proc, lambda.to_proc) - assert_equal(lambda.clone.call, 44) - assert_instance_of(Proc, get_block(&lambda)) - - assert_equal(1, Proc.new{|a,| a}.call(1,2,3)) - assert_nothing_raised {Proc.new{|a,|}.call(1,2)} - end - - def return1_test - Proc.new { - return 55 - }.call + 5 - end - - def test_return1 - assert_equal(55, return1_test()) - end - - def return2_test - lambda { - return 55 - }.call + 5 - end - - def test_return2 - assert_equal(60, return2_test()) - 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_equal(42, proc_return1()) - end - - def proc_return2 - proc_yield{return 42}+1 - end - - def test_proc_return2 - assert_equal(42, proc_return2()) - end - - def test_ljump - block = get_block{11} - lambda = lambda{44} - assert_raises(LocalJumpError) {get_block{break}.call} - assert_nothing_raised {lambda{break}.call} - assert_instance_of(LocalJumpError, (get_block{break}.call rescue $!)) - - assert_equal(-1, block.arity) - assert_equal(-1, lambda.arity) - assert_equal(0, lambda{||}.arity) - assert_equal(1, lambda{|a|}.arity) - assert_equal(1, lambda{|a,|}.arity) - assert_equal(2, lambda{|a,b|}.arity) - end - - def marity_test(m) - method = method(m) - assert_equal(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, "marity") - end - - def foo - yield([:key, :value]) - end - def bar(&blk) - blk.call([:key, :value]) - end - - def test_yield_vs_call - foo{|k,v| assert_equal([:key, :value], [k,v])} - bar{|k,v| assert_equal([:key, :value], [k,v])} - end - - class H - def each - yield [:key, :value] - end - end - - def test_assoc_yield - [{:key=>:value}, H.new].each {|h| - h.each{|a| assert_equal([:key, :value], a)} - h.each{|*a| assert_equal([[:key, :value]], a)} - h.each{|k,v| assert_equal([:key, :value], [k,v])} - } - 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_equal(super, yield) - assert_equal(x, super(x, &nil)) - end - end - - def test_iter4 - ITER_TEST4.new.foo(44){55} - end - - def test_break__nested_loop1 - _test_break__nested_loop1 do - break - end - end - - def _test_break__nested_loop1 - while true - yield - end - assert(false, "must not reach here") - end - - def test_break__nested_loop2 - _test_break__nested_loop2 do - break - end - end - - def _test_break__nested_loop2 - until false - yield - end - assert(false, "must not reach here") - end - - def test_break__nested_loop3 - _test_break__nested_loop3 do - break - end - end - - def _test_break__nested_loop3 - loop do - yield - end - assert(false, "must not reach here") - end - - def test_break_from_enum - result = ["a"].inject("ng") {|x,y| break "ok"} - assert_equal("ok", result) - end - - def _test_return_trace_func(x) - set_trace_func(proc {}) - [].fetch(2) {return x} - ensure - set_trace_func(nil) - end - - def test_return_trace_func - ok = "returned gracefully" - result = "skipped" - result = _test_return_trace_func(ok) - ensure - assert_equal(ok, result) - return - end -end -- cgit v1.2.3