enum.c: yield multiple values
* enum.c (find_i): yield multiple values instead of a packed array, so that lambda block can work. with tests by Alex Rothenberg. [ruby-core:61340] [Bug #9605] git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@45286 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
parent
cfe3d98999
commit
c052c80cda
35
enum.c
35
enum.c
@ -62,7 +62,7 @@ grep_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
if (RTEST(rb_funcall(memo->u1.value, id_eqq, 1, i))) {
|
if (RTEST(rb_funcall(memo->u1.value, id_eqq, 1, i))) {
|
||||||
rb_ary_push(memo->u2.value, rb_yield(i));
|
rb_ary_push(memo->u2.value, enum_yield(argc, argv));
|
||||||
}
|
}
|
||||||
return Qnil;
|
return Qnil;
|
||||||
}
|
}
|
||||||
@ -180,7 +180,7 @@ find_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
|
|||||||
{
|
{
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
if (RTEST(rb_yield(i))) {
|
if (RTEST(enum_yield(argc, argv))) {
|
||||||
NODE *memo = RNODE(memop);
|
NODE *memo = RNODE(memop);
|
||||||
memo->u1.value = i;
|
memo->u1.value = i;
|
||||||
memo->u3.cnt = 1;
|
memo->u3.cnt = 1;
|
||||||
@ -303,7 +303,7 @@ find_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|||||||
{
|
{
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
if (RTEST(rb_yield(i))) {
|
if (RTEST(enum_yield(argc, argv))) {
|
||||||
rb_ary_push(ary, i);
|
rb_ary_push(ary, i);
|
||||||
}
|
}
|
||||||
return Qnil;
|
return Qnil;
|
||||||
@ -355,7 +355,7 @@ reject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|||||||
{
|
{
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
if (!RTEST(rb_yield(i))) {
|
if (!RTEST(enum_yield(argc, argv))) {
|
||||||
rb_ary_push(ary, i);
|
rb_ary_push(ary, i);
|
||||||
}
|
}
|
||||||
return Qnil;
|
return Qnil;
|
||||||
@ -674,7 +674,7 @@ partition_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, arys))
|
|||||||
VALUE ary;
|
VALUE ary;
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
if (RTEST(rb_yield(i))) {
|
if (RTEST(enum_yield(argc, argv))) {
|
||||||
ary = memo->u1.value;
|
ary = memo->u1.value;
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
@ -720,7 +720,7 @@ group_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
|
|||||||
|
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
group = rb_yield(i);
|
group = enum_yield(argc, argv);
|
||||||
values = rb_hash_aref(hash, group);
|
values = rb_hash_aref(hash, group);
|
||||||
if (!RB_TYPE_P(values, T_ARRAY)) {
|
if (!RB_TYPE_P(values, T_ARRAY)) {
|
||||||
values = rb_ary_new3(1, i);
|
values = rb_ary_new3(1, i);
|
||||||
@ -846,7 +846,7 @@ sort_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data))
|
|||||||
|
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
v = rb_yield(i);
|
v = enum_yield(argc, argv);
|
||||||
|
|
||||||
if (RBASIC(ary)->klass) {
|
if (RBASIC(ary)->klass) {
|
||||||
rb_raise(rb_eRuntimeError, "sort_by reentered");
|
rb_raise(rb_eRuntimeError, "sort_by reentered");
|
||||||
@ -1249,7 +1249,7 @@ nmin_i(VALUE i, VALUE *_data, int argc, VALUE *argv)
|
|||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
if (data->by)
|
if (data->by)
|
||||||
rb_ary_push(data->buf, rb_yield(i));
|
rb_ary_push(data->buf, enum_yield(argc, argv));
|
||||||
rb_ary_push(data->buf, i);
|
rb_ary_push(data->buf, i);
|
||||||
|
|
||||||
data->curlen++;
|
data->curlen++;
|
||||||
@ -1685,7 +1685,7 @@ min_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|||||||
|
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
v = rb_yield(i);
|
v = enum_yield(argc, argv);
|
||||||
if (memo->u1.value == Qundef) {
|
if (memo->u1.value == Qundef) {
|
||||||
memo->u1.value = v;
|
memo->u1.value = v;
|
||||||
memo->u2.value = i;
|
memo->u2.value = i;
|
||||||
@ -1745,7 +1745,7 @@ max_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|||||||
|
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
v = rb_yield(i);
|
v = enum_yield(argc, argv);
|
||||||
if (memo->u1.value == Qundef) {
|
if (memo->u1.value == Qundef) {
|
||||||
memo->u1.value = v;
|
memo->u1.value = v;
|
||||||
memo->u2.value = i;
|
memo->u2.value = i;
|
||||||
@ -1836,7 +1836,7 @@ minmax_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
|
|||||||
|
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
vi = rb_yield(i);
|
vi = enum_yield(argc, argv);
|
||||||
|
|
||||||
if (memo->last_bv == Qundef) {
|
if (memo->last_bv == Qundef) {
|
||||||
memo->last_bv = vi;
|
memo->last_bv = vi;
|
||||||
@ -2017,7 +2017,7 @@ static VALUE
|
|||||||
each_val_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p))
|
each_val_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p))
|
||||||
{
|
{
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
rb_yield(i);
|
enum_yield(argc, argv);
|
||||||
return Qnil;
|
return Qnil;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -2247,7 +2247,7 @@ zip_ary(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval))
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (NIL_P(result)) {
|
if (NIL_P(result)) {
|
||||||
rb_yield(tmp);
|
rb_yield_splat(tmp);
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
rb_ary_push(result, tmp);
|
rb_ary_push(result, tmp);
|
||||||
@ -2295,7 +2295,7 @@ zip_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval))
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (NIL_P(result)) {
|
if (NIL_P(result)) {
|
||||||
rb_yield(tmp);
|
rb_yield_splat(tmp);
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
rb_ary_push(result, tmp);
|
rb_ary_push(result, tmp);
|
||||||
@ -2489,7 +2489,7 @@ drop_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
|
|||||||
NODE *memo = RNODE(args);
|
NODE *memo = RNODE(args);
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
if (!memo->u3.state && !RTEST(rb_yield(i))) {
|
if (!memo->u3.state && !RTEST(enum_yield(argc, argv))) {
|
||||||
memo->u3.state = TRUE;
|
memo->u3.state = TRUE;
|
||||||
}
|
}
|
||||||
if (memo->u3.state) {
|
if (memo->u3.state) {
|
||||||
@ -2532,8 +2532,9 @@ cycle_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
|
|||||||
{
|
{
|
||||||
ENUM_WANT_SVALUE();
|
ENUM_WANT_SVALUE();
|
||||||
|
|
||||||
|
if (argc == 1) i = rb_ary_new4(argc, argv);
|
||||||
rb_ary_push(ary, i);
|
rb_ary_push(ary, i);
|
||||||
rb_yield(i);
|
enum_yield(argc, argv);
|
||||||
return Qnil;
|
return Qnil;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -2600,7 +2601,7 @@ enum_cycle(int argc, VALUE *argv, VALUE obj)
|
|||||||
if (len == 0) return Qnil;
|
if (len == 0) return Qnil;
|
||||||
while (n < 0 || 0 < --n) {
|
while (n < 0 || 0 < --n) {
|
||||||
for (i=0; i<len; i++) {
|
for (i=0; i<len; i++) {
|
||||||
rb_yield(RARRAY_AREF(ary, i));
|
rb_yield_splat(RARRAY_AREF(ary, i));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return Qnil;
|
return Qnil;
|
||||||
|
@ -56,6 +56,11 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
bug5801 = '[ruby-dev:45041]'
|
bug5801 = '[ruby-dev:45041]'
|
||||||
@empty.grep(//)
|
@empty.grep(//)
|
||||||
assert_nothing_raised(bug5801) {100.times {@empty.block.call}}
|
assert_nothing_raised(bug5801) {100.times {@empty.block.call}}
|
||||||
|
|
||||||
|
a = []
|
||||||
|
lambda = ->(x, i) {a << [x, i]}
|
||||||
|
@obj.each_with_index.grep(proc{|x,i|x==2}, &lambda)
|
||||||
|
assert_equal([[2, 1], [2, 4]], a)
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_count
|
def test_count
|
||||||
@ -81,6 +86,8 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
assert_equal(2, @obj.find {|x| x % 2 == 0 })
|
assert_equal(2, @obj.find {|x| x % 2 == 0 })
|
||||||
assert_equal(nil, @obj.find {|x| false })
|
assert_equal(nil, @obj.find {|x| false })
|
||||||
assert_equal(:foo, @obj.find(proc { :foo }) {|x| false })
|
assert_equal(:foo, @obj.find(proc { :foo }) {|x| false })
|
||||||
|
cond = ->(x, i) { x % 2 == 0 }
|
||||||
|
assert_equal([2, 1], @obj.each_with_index.find(&cond))
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_find_index
|
def test_find_index
|
||||||
@ -93,10 +100,14 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
|
|
||||||
def test_find_all
|
def test_find_all
|
||||||
assert_equal([1, 3, 1], @obj.find_all {|x| x % 2 == 1 })
|
assert_equal([1, 3, 1], @obj.find_all {|x| x % 2 == 1 })
|
||||||
|
cond = ->(x, i) { x % 2 == 1 }
|
||||||
|
assert_equal([[1, 0], [3, 2], [1, 3]], @obj.each_with_index.find_all(&cond))
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_reject
|
def test_reject
|
||||||
assert_equal([2, 3, 2], @obj.reject {|x| x < 2 })
|
assert_equal([2, 3, 2], @obj.reject {|x| x < 2 })
|
||||||
|
cond = ->(x, i) {x < 2}
|
||||||
|
assert_equal([[2, 1], [3, 2], [2, 4]], @obj.each_with_index.reject(&cond))
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_to_a
|
def test_to_a
|
||||||
@ -144,11 +155,17 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
|
|
||||||
def test_partition
|
def test_partition
|
||||||
assert_equal([[1, 3, 1], [2, 2]], @obj.partition {|x| x % 2 == 1 })
|
assert_equal([[1, 3, 1], [2, 2]], @obj.partition {|x| x % 2 == 1 })
|
||||||
|
cond = ->(x, i) { x % 2 == 1 }
|
||||||
|
assert_equal([[[1, 0], [3, 2], [1, 3]], [[2, 1], [2, 4]]], @obj.each_with_index.partition(&cond))
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_group_by
|
def test_group_by
|
||||||
h = { 1 => [1, 1], 2 => [2, 2], 3 => [3] }
|
h = { 1 => [1, 1], 2 => [2, 2], 3 => [3] }
|
||||||
assert_equal(h, @obj.group_by {|x| x })
|
assert_equal(h, @obj.group_by {|x| x })
|
||||||
|
|
||||||
|
h = {1=>[[1, 0], [1, 3]], 2=>[[2, 1], [2, 4]], 3=>[[3, 2]]}
|
||||||
|
cond = ->(x, i) { x }
|
||||||
|
assert_equal(h, @obj.each_with_index.group_by(&cond))
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_first
|
def test_first
|
||||||
@ -164,6 +181,9 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
def test_sort_by
|
def test_sort_by
|
||||||
assert_equal([3, 2, 2, 1, 1], @obj.sort_by {|x| -x })
|
assert_equal([3, 2, 2, 1, 1], @obj.sort_by {|x| -x })
|
||||||
assert_equal((1..300).to_a.reverse, (1..300).sort_by {|x| -x })
|
assert_equal((1..300).to_a.reverse, (1..300).sort_by {|x| -x })
|
||||||
|
|
||||||
|
cond = ->(x, i) { [-x, i] }
|
||||||
|
assert_equal([[3, 2], [2, 1], [2, 4], [1, 0], [1, 3]], @obj.each_with_index.sort_by(&cond))
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_all
|
def test_all
|
||||||
@ -205,6 +225,8 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
def test_min
|
def test_min
|
||||||
assert_equal(1, @obj.min)
|
assert_equal(1, @obj.min)
|
||||||
assert_equal(3, @obj.min {|a,b| b <=> a })
|
assert_equal(3, @obj.min {|a,b| b <=> a })
|
||||||
|
cond = ->((a, ia), (b, ib)) { (b <=> a).nonzero? or ia <=> ib }
|
||||||
|
assert_equal([3, 2], @obj.each_with_index.min(&cond))
|
||||||
ary = %w(albatross dog horse)
|
ary = %w(albatross dog horse)
|
||||||
assert_equal("albatross", ary.min)
|
assert_equal("albatross", ary.min)
|
||||||
assert_equal("dog", ary.min {|a,b| a.length <=> b.length })
|
assert_equal("dog", ary.min {|a,b| a.length <=> b.length })
|
||||||
@ -217,6 +239,8 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
def test_max
|
def test_max
|
||||||
assert_equal(3, @obj.max)
|
assert_equal(3, @obj.max)
|
||||||
assert_equal(1, @obj.max {|a,b| b <=> a })
|
assert_equal(1, @obj.max {|a,b| b <=> a })
|
||||||
|
cond = ->((a, ia), (b, ib)) { (b <=> a).nonzero? or ia <=> ib }
|
||||||
|
assert_equal([1, 3], @obj.each_with_index.max(&cond))
|
||||||
ary = %w(albatross dog horse)
|
ary = %w(albatross dog horse)
|
||||||
assert_equal("horse", ary.max)
|
assert_equal("horse", ary.max)
|
||||||
assert_equal("albatross", ary.max {|a,b| a.length <=> b.length })
|
assert_equal("albatross", ary.max {|a,b| a.length <=> b.length })
|
||||||
@ -239,6 +263,8 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
|
|
||||||
def test_min_by
|
def test_min_by
|
||||||
assert_equal(3, @obj.min_by {|x| -x })
|
assert_equal(3, @obj.min_by {|x| -x })
|
||||||
|
cond = ->(x, i) { -x }
|
||||||
|
assert_equal([3, 2], @obj.each_with_index.min_by(&cond))
|
||||||
a = %w(albatross dog horse)
|
a = %w(albatross dog horse)
|
||||||
assert_equal("dog", a.min_by {|x| x.length })
|
assert_equal("dog", a.min_by {|x| x.length })
|
||||||
assert_equal(3, [2,3,1].min_by {|x| -x })
|
assert_equal(3, [2,3,1].min_by {|x| -x })
|
||||||
@ -247,6 +273,8 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
|
|
||||||
def test_max_by
|
def test_max_by
|
||||||
assert_equal(1, @obj.max_by {|x| -x })
|
assert_equal(1, @obj.max_by {|x| -x })
|
||||||
|
cond = ->(x, i) { -x }
|
||||||
|
assert_equal([1, 0], @obj.each_with_index.max_by(&cond))
|
||||||
a = %w(albatross dog horse)
|
a = %w(albatross dog horse)
|
||||||
assert_equal("albatross", a.max_by {|x| x.length })
|
assert_equal("albatross", a.max_by {|x| x.length })
|
||||||
assert_equal(1, [2,3,1].max_by {|x| -x })
|
assert_equal(1, [2,3,1].max_by {|x| -x })
|
||||||
@ -255,6 +283,8 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
|
|
||||||
def test_minmax_by
|
def test_minmax_by
|
||||||
assert_equal([3, 1], @obj.minmax_by {|x| -x })
|
assert_equal([3, 1], @obj.minmax_by {|x| -x })
|
||||||
|
cond = ->(x, i) { -x }
|
||||||
|
assert_equal([[3, 2], [1, 0]], @obj.each_with_index.minmax_by(&cond))
|
||||||
a = %w(albatross dog horse)
|
a = %w(albatross dog horse)
|
||||||
assert_equal(["dog", "albatross"], a.minmax_by {|x| x.length })
|
assert_equal(["dog", "albatross"], a.minmax_by {|x| x.length })
|
||||||
assert_equal([3, 1], [2,3,1].minmax_by {|x| -x })
|
assert_equal([3, 1], [2,3,1].minmax_by {|x| -x })
|
||||||
@ -302,6 +332,10 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
def test_each_entry
|
def test_each_entry
|
||||||
assert_equal([1, 2, 3], [1, 2, 3].each_entry.to_a)
|
assert_equal([1, 2, 3], [1, 2, 3].each_entry.to_a)
|
||||||
assert_equal([1, [1, 2]], Foo.new.each_entry.to_a)
|
assert_equal([1, [1, 2]], Foo.new.each_entry.to_a)
|
||||||
|
a = []
|
||||||
|
cond = ->(x, i) { a << x }
|
||||||
|
@obj.each_with_index.each_entry(&cond)
|
||||||
|
assert_equal([1, 2, 3, 1, 2], a)
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_zip
|
def test_zip
|
||||||
@ -310,6 +344,11 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
@obj.zip([:a, :b, :c]) {|x,y| a << [x, y] }
|
@obj.zip([:a, :b, :c]) {|x,y| a << [x, y] }
|
||||||
assert_equal([[1,:a],[2,:b],[3,:c],[1,nil],[2,nil]], a)
|
assert_equal([[1,:a],[2,:b],[3,:c],[1,nil],[2,nil]], a)
|
||||||
|
|
||||||
|
a = []
|
||||||
|
cond = ->((x, i), y) { a << [x, y, i] }
|
||||||
|
@obj.each_with_index.zip([:a, :b, :c], &cond)
|
||||||
|
assert_equal([[1,:a,0],[2,:b,1],[3,:c,2],[1,nil,3],[2,nil,4]], a)
|
||||||
|
|
||||||
a = []
|
a = []
|
||||||
@obj.zip({a: "A", b: "B", c: "C"}) {|x,y| a << [x, y] }
|
@obj.zip({a: "A", b: "B", c: "C"}) {|x,y| a << [x, y] }
|
||||||
assert_equal([[1,[:a,"A"]],[2,[:b,"B"]],[3,[:c,"C"]],[1,nil],[2,nil]], a)
|
assert_equal([[1,[:a,"A"]],[2,[:b,"B"]],[3,[:c,"C"]],[1,nil],[2,nil]], a)
|
||||||
@ -329,6 +368,8 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
|
|
||||||
def test_take_while
|
def test_take_while
|
||||||
assert_equal([1,2], @obj.take_while {|x| x <= 2})
|
assert_equal([1,2], @obj.take_while {|x| x <= 2})
|
||||||
|
cond = ->(x, i) {x <= 2}
|
||||||
|
assert_equal([[1, 0], [2, 1]], @obj.each_with_index.take_while(&cond))
|
||||||
|
|
||||||
bug5801 = '[ruby-dev:45040]'
|
bug5801 = '[ruby-dev:45040]'
|
||||||
@empty.take_while {true}
|
@empty.take_while {true}
|
||||||
@ -341,10 +382,19 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
|
|
||||||
def test_drop_while
|
def test_drop_while
|
||||||
assert_equal([3,1,2], @obj.drop_while {|x| x <= 2})
|
assert_equal([3,1,2], @obj.drop_while {|x| x <= 2})
|
||||||
|
cond = ->(x, i) {x <= 2}
|
||||||
|
assert_equal([[3, 2], [1, 3], [2, 4]], @obj.each_with_index.drop_while(&cond))
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_cycle
|
def test_cycle
|
||||||
assert_equal([1,2,3,1,2,1,2,3,1,2], @obj.cycle.take(10))
|
assert_equal([1,2,3,1,2,1,2,3,1,2], @obj.cycle.take(10))
|
||||||
|
a = []
|
||||||
|
@obj.cycle(2) {|x| a << x}
|
||||||
|
assert_equal([1,2,3,1,2,1,2,3,1,2], a)
|
||||||
|
a = []
|
||||||
|
cond = ->(x, i) {a << x}
|
||||||
|
@obj.each_with_index.cycle(2, &cond)
|
||||||
|
assert_equal([1,2,3,1,2,1,2,3,1,2], a)
|
||||||
end
|
end
|
||||||
|
|
||||||
def test_callcc
|
def test_callcc
|
||||||
@ -459,4 +509,65 @@ class TestEnumerable < Test::Unit::TestCase
|
|||||||
assert_not_warn{ss.slice_before(/\A...\z/).to_a}
|
assert_not_warn{ss.slice_before(/\A...\z/).to_a}
|
||||||
end
|
end
|
||||||
|
|
||||||
|
def test_detect
|
||||||
|
@obj = ('a'..'z')
|
||||||
|
assert_equal('c', @obj.detect {|x| x == 'c' })
|
||||||
|
|
||||||
|
proc = Proc.new {|x| x == 'c' }
|
||||||
|
assert_equal('c', @obj.detect(&proc))
|
||||||
|
|
||||||
|
lambda = ->(x) { x == 'c' }
|
||||||
|
assert_equal('c', @obj.detect(&lambda))
|
||||||
|
|
||||||
|
assert_equal(['c',2], @obj.each_with_index.detect {|x, i| x == 'c' })
|
||||||
|
|
||||||
|
proc2 = Proc.new {|x, i| x == 'c' }
|
||||||
|
assert_equal(['c',2], @obj.each_with_index.detect(&proc2))
|
||||||
|
|
||||||
|
bug9605 = '[ruby-core:61340]'
|
||||||
|
lambda2 = ->(x, i) { x == 'c' }
|
||||||
|
assert_equal(['c',2], @obj.each_with_index.detect(&lambda2))
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_select
|
||||||
|
@obj = ('a'..'z')
|
||||||
|
assert_equal(['c'], @obj.select {|x| x == 'c' })
|
||||||
|
|
||||||
|
proc = Proc.new {|x| x == 'c' }
|
||||||
|
assert_equal(['c'], @obj.select(&proc))
|
||||||
|
|
||||||
|
lambda = ->(x) { x == 'c' }
|
||||||
|
assert_equal(['c'], @obj.select(&lambda))
|
||||||
|
|
||||||
|
assert_equal([['c',2]], @obj.each_with_index.select {|x, i| x == 'c' })
|
||||||
|
|
||||||
|
proc2 = Proc.new {|x, i| x == 'c' }
|
||||||
|
assert_equal([['c',2]], @obj.each_with_index.select(&proc2))
|
||||||
|
|
||||||
|
bug9605 = '[ruby-core:61340]'
|
||||||
|
lambda2 = ->(x, i) { x == 'c' }
|
||||||
|
assert_equal([['c',2]], @obj.each_with_index.select(&lambda2))
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_map
|
||||||
|
@obj = ('a'..'e')
|
||||||
|
assert_equal(['A', 'B', 'C', 'D', 'E'], @obj.map {|x| x.upcase })
|
||||||
|
|
||||||
|
proc = Proc.new {|x| x.upcase }
|
||||||
|
assert_equal(['A', 'B', 'C', 'D', 'E'], @obj.map(&proc))
|
||||||
|
|
||||||
|
lambda = ->(x) { x.upcase }
|
||||||
|
assert_equal(['A', 'B', 'C', 'D', 'E'], @obj.map(&lambda))
|
||||||
|
|
||||||
|
assert_equal([['A',0], ['B',1], ['C',2], ['D',3], ['E',4]],
|
||||||
|
@obj.each_with_index.map {|x, i| [x.upcase, i] })
|
||||||
|
|
||||||
|
proc2 = Proc.new {|x, i| [x.upcase, i] }
|
||||||
|
assert_equal([['A',0], ['B',1], ['C',2], ['D',3], ['E',4]],
|
||||||
|
@obj.each_with_index.map(&proc2))
|
||||||
|
|
||||||
|
lambda2 = ->(x, i) { [x.upcase, i] }
|
||||||
|
assert_equal([['A',0], ['B',1], ['C',2], ['D',3], ['E',4]],
|
||||||
|
@obj.each_with_index.map(&lambda2))
|
||||||
|
end
|
||||||
end
|
end
|
||||||
|
Loading…
x
Reference in New Issue
Block a user