summaryrefslogtreecommitdiff
path: root/test/ruby/test_iterator.rb
diff options
context:
space:
mode:
Diffstat (limited to 'test/ruby/test_iterator.rb')
-rw-r--r--test/ruby/test_iterator.rb128
1 files changed, 80 insertions, 48 deletions
diff --git a/test/ruby/test_iterator.rb b/test/ruby/test_iterator.rb
index 638916309e..362becc0e0 100644
--- a/test/ruby/test_iterator.rb
+++ b/test/ruby/test_iterator.rb
@@ -5,8 +5,8 @@ class Array
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]}
+ ary = collect{|e| [e, yield(e)]}
+ ary.sort{|a,b|a[1]<=>b[1]}
end
end
@@ -51,10 +51,10 @@ class TestIterator < Test::Unit::TestCase
def test_nested_iterator
i = 0
- tt{|i| break if i == 5}
- assert_equal(5, i)
+ tt{|j| break if j == 5}
+ assert_equal(0, i)
- assert_raises(ArgumentError) do
+ assert_raise(ArgumentError) do
tt3{}
end
end
@@ -64,12 +64,12 @@ class TestIterator < Test::Unit::TestCase
end
def test_block_argument_without_paren
- assert_raises(ArgumentError) do
+ assert_raise(ArgumentError) do
tt4{}
end
end
- # iterator break/redo/next/retry
+ # iterator break/redo/next
def test_break
done = true
loop{
@@ -104,18 +104,6 @@ class TestIterator < Test::Unit::TestCase
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
@@ -149,11 +137,9 @@ class TestIterator < Test::Unit::TestCase
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)}
@@ -166,8 +152,8 @@ class TestIterator < Test::Unit::TestCase
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)}
+ 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)
@@ -230,10 +216,10 @@ class TestIterator < Test::Unit::TestCase
def test_argument
assert_nothing_raised {lambda{||}.call}
- assert_raises(ArgumentError) {lambda{||}.call(1)}
+ assert_raise(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)}
+ assert_raise(ArgumentError) {lambda{|a,|}.call()}
+ assert_raise(ArgumentError) {lambda{|a,|}.call(1,2)}
end
def get_block(&block)
@@ -249,9 +235,9 @@ class TestIterator < Test::Unit::TestCase
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_raise(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)}
+ assert_raise(ArgumentError) {get_block(&lambda{|a,|}).call(1,2)}
block = get_block{11}
assert_instance_of(Proc, block)
@@ -259,11 +245,11 @@ class TestIterator < Test::Unit::TestCase
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))
+ lmd = lambda{44}
+ assert_instance_of(Proc, lmd)
+ assert_instance_of(Proc, lmd.to_proc)
+ assert_equal(lmd.clone.call, 44)
+ assert_instance_of(Proc, get_block(&lmd))
assert_equal(1, Proc.new{|a,| a}.call(1,2,3))
assert_nothing_raised {Proc.new{|a,|}.call(1,2)}
@@ -312,14 +298,21 @@ class TestIterator < Test::Unit::TestCase
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_raise(LocalJumpError) {get_block{break}.call}
+
+ # cannot use assert_nothing_raised due to passing block.
+ begin
+ val = lambda{break 11}.call
+ rescue LocalJumpError
+ assert(false, "LocalJumpError occurred from break in lambda")
+ else
+ assert_equal(11, val)
+ end
- assert_equal(-1, block.arity)
- assert_equal(-1, lambda.arity)
+ block = get_block{11}
+ lmd = lambda{44}
+ assert_equal(0, block.arity)
+ assert_equal(0, lmd.arity)
assert_equal(0, lambda{||}.arity)
assert_equal(1, lambda{|a|}.arity)
assert_equal(1, lambda{|a,|}.arity)
@@ -327,8 +320,8 @@ class TestIterator < Test::Unit::TestCase
end
def marity_test(m)
- method = method(m)
- assert_equal(method.arity, method.to_proc.arity)
+ mobj = method(m)
+ assert_equal(mobj.arity, mobj.to_proc.arity)
end
def test_marity
@@ -341,10 +334,10 @@ class TestIterator < Test::Unit::TestCase
end
def foo
- yield([:key, :value])
+ yield(:key, :value)
end
def bar(&blk)
- blk.call([:key, :value])
+ blk.call(:key, :value)
end
def test_yield_vs_call
@@ -356,13 +349,19 @@ class TestIterator < Test::Unit::TestCase
def each
yield [:key, :value]
end
+ alias each_pair each
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])}
+ [{:key=>:value}, H.new].each {|h|
+ h.each{|a| assert_equal([:key, :value], a)}
+ h.each{|a,| assert_equal(:key, a)}
+ h.each{|*a| assert_equal([[:key, :value]], a)}
+ h.each{|k,v| assert_equal([:key, :value], [k,v])}
+ h.each_pair{|a| assert_equal([:key, :value], a)}
+ h.each_pair{|a,| assert_equal(:key, a)}
+ h.each_pair{|*a| assert_equal([[:key, :value]], a)}
+ h.each_pair{|k,v| assert_equal([:key, :value], [k,v])}
}
end
@@ -462,4 +461,37 @@ class TestIterator < Test::Unit::TestCase
assert_equal(ok, result)
return
end
+
+ class IterString < ::String
+ def ===(other)
+ super if !block_given?
+ end
+ end
+
+ # Check that the block passed to an iterator
+ # does not get propagated inappropriately
+ def test_block_given_within_iterator
+ assert_equal(["b"], ["a", "b", "c"].grep(IterString.new("b")) {|s| s})
+ end
+
+ def test_enumerator
+ [1,2,3].each.with_index {|x,i|
+ assert_equal(x, i+1)
+ }
+
+ e = [1,2,3].each
+ assert_equal(1, e.next)
+ assert_equal(2, e.next)
+ assert_equal(3, e.next)
+ assert_raise(StopIteration){e.next}
+ e.rewind
+ assert_equal(1, e.next)
+ e.rewind
+ a = []
+ loop{a.push e.next}
+ assert_equal([1,2,3], a)
+
+ assert_equal([[8, 1, 10], [6, 2, 11], [4, 3, 12]],
+ [8,6,4].zip((1..10),(10..100)).to_a)
+ end
end
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 22:02:09 +0000