9 files changed, 30 insertions, 333 deletions
diff --git a/spec/ruby/core/enumerable/shared/collect.rb b/spec/ruby/core/enumerable/shared/collect.rb
deleted file mode 100644
index 05e94777c7..0000000000
--- a/spec/ruby/core/enumerable/shared/collect.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-require_relative 'enumerable_enumeratorized'
-
-describe :enumerable_collect, shared: true do
-  before :each do
-    ScratchPad.record []
-  end
-
-  it "returns a new array with the results of passing each element to block" do
-    entries = [0, 1, 3, 4, 5, 6]
-    numerous = EnumerableSpecs::Numerous.new(*entries)
-    numerous.send(@method) { |i| i % 2 }.should == [0, 1, 1, 0, 1, 0]
-    numerous.send(@method) { |i| i }.should == entries
-  end
-
-  it "passes through the values yielded by #each_with_index" do
-    [:a, :b].each_with_index.send(@method) { |x, i| ScratchPad << [x, i]; nil }
-    ScratchPad.recorded.should == [[:a, 0], [:b, 1]]
-  end
-
-  it "gathers initial args as elements when each yields multiple" do
-    multi = EnumerableSpecs::YieldsMulti.new
-    multi.send(@method) {|e| e}.should == [1,3,6]
-  end
-
-  it "only yields increasing values for a Range" do
-    (1..0).send(@method) { |x| x }.should == []
-    (1..1).send(@method) { |x| x }.should == [1]
-    (1..2).send(@method) { |x| x }.should == [1, 2]
-  end
-
-  it "returns an enumerator when no block given" do
-    enum = EnumerableSpecs::Numerous.new.send(@method)
-    enum.should be_an_instance_of(Enumerator)
-    enum.each { |i| -i }.should == [-2, -5, -3, -6, -1, -4]
-  end
-
-  it_should_behave_like :enumerable_enumeratorized_with_origin_size
-end
diff --git a/spec/ruby/core/enumerable/shared/collect_concat.rb b/spec/ruby/core/enumerable/shared/collect_concat.rb
deleted file mode 100644
index ddd431baeb..0000000000
--- a/spec/ruby/core/enumerable/shared/collect_concat.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-require_relative 'enumerable_enumeratorized'
-
-describe :enumerable_collect_concat, shared: true do
-  it "yields elements to the block and flattens one level" do
-    numerous = EnumerableSpecs::Numerous.new(1, [2, 3], [4, [5, 6]], {foo: :bar})
-    numerous.send(@method) { |i| i }.should == [1, 2, 3, 4, [5, 6], {foo: :bar}]
-  end
-
-  it "appends non-Array elements that do not define #to_ary" do
-    obj = mock("to_ary undefined")
-
-    numerous = EnumerableSpecs::Numerous.new(1, obj, 2)
-    numerous.send(@method) { |i| i }.should == [1, obj, 2]
-  end
-
-  it "concatenates the result of calling #to_ary if it returns an Array" do
-    obj = mock("to_ary defined")
-    obj.should_receive(:to_ary).and_return([:a, :b])
-
-    numerous = EnumerableSpecs::Numerous.new(1, obj, 2)
-    numerous.send(@method) { |i| i }.should == [1, :a, :b, 2]
-  end
-
-  it "does not call #to_a" do
-    obj = mock("to_ary undefined")
-    obj.should_not_receive(:to_a)
-
-    numerous = EnumerableSpecs::Numerous.new(1, obj, 2)
-    numerous.send(@method) { |i| i }.should == [1, obj, 2]
-  end
-
-  it "appends an element that defines #to_ary that returns nil" do
-    obj = mock("to_ary defined")
-    obj.should_receive(:to_ary).and_return(nil)
-
-    numerous = EnumerableSpecs::Numerous.new(1, obj, 2)
-    numerous.send(@method) { |i| i }.should == [1, obj, 2]
-  end
-
-  it "raises a TypeError if an element defining #to_ary does not return an Array or nil"  do
-    obj = mock("to_ary defined")
-    obj.should_receive(:to_ary).and_return("array")
-
-    -> { [1, obj, 3].send(@method) { |i| i } }.should raise_error(TypeError)
-  end
-
-  it "returns an enumerator when no block given" do
-    enum = EnumerableSpecs::Numerous.new(1, 2).send(@method)
-    enum.should be_an_instance_of(Enumerator)
-    enum.each{ |i| [i] * i }.should == [1, 2, 2]
-  end
-
-  it_should_behave_like :enumerable_enumeratorized_with_origin_size
-end
diff --git a/spec/ruby/core/enumerable/shared/entries.rb b/spec/ruby/core/enumerable/shared/entries.rb
deleted file mode 100644
index 590ce73bcf..0000000000
--- a/spec/ruby/core/enumerable/shared/entries.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-describe :enumerable_entries, shared: true do
-  it "returns an array containing the elements" do
-    numerous = EnumerableSpecs::Numerous.new(1, nil, 'a', 2, false, true)
-    numerous.send(@method).should == [1, nil, "a", 2, false, true]
-  end
-
-  it "passes through the values yielded by #each_with_index" do
-    [:a, :b].each_with_index.send(@method).should == [[:a, 0], [:b, 1]]
-  end
-
-  it "passes arguments to each" do
-    count = EnumerableSpecs::EachCounter.new(1, 2, 3)
-    count.send(@method, :hello, "world").should == [1, 2, 3]
-    count.arguments_passed.should == [:hello, "world"]
-  end
-
-  ruby_version_is ''...'2.7' do
-    it "returns a tainted array if self is tainted" do
-      EnumerableSpecs::Empty.new.taint.send(@method).tainted?.should be_true
-    end
-
-    it "returns an untrusted array if self is untrusted" do
-      EnumerableSpecs::Empty.new.untrust.send(@method).untrusted?.should be_true
-    end
-  end
-end
diff --git a/spec/ruby/core/enumerable/shared/find.rb b/spec/ruby/core/enumerable/shared/find.rb
deleted file mode 100644
index 61d63ba3d5..0000000000
--- a/spec/ruby/core/enumerable/shared/find.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-require_relative 'enumerable_enumeratorized'
-
-describe :enumerable_find, shared: true do
-  # #detect and #find are aliases, so we only need one function
-  before :each do
-    ScratchPad.record []
-    @elements = [2, 4, 6, 8, 10]
-    @numerous = EnumerableSpecs::Numerous.new(*@elements)
-    @empty = []
-  end
-
-  it "passes each entry in enum to block while block when block is false" do
-    visited_elements = []
-    @numerous.send(@method) do |element|
-      visited_elements << element
-      false
-    end
-    visited_elements.should == @elements
-  end
-
-  it "returns nil when the block is false and there is no ifnone proc given" do
-    @numerous.send(@method) {|e| false }.should == nil
-  end
-
-  it "returns the first element for which the block is not false" do
-    @elements.each do |element|
-      @numerous.send(@method) {|e| e > element - 1 }.should == element
-    end
-  end
-
-  it "returns the value of the ifnone proc if the block is false" do
-    fail_proc = -> { "cheeseburgers" }
-    @numerous.send(@method, fail_proc) {|e| false }.should == "cheeseburgers"
-  end
-
-  it "doesn't call the ifnone proc if an element is found" do
-    fail_proc = -> { raise "This shouldn't have been called" }
-    @numerous.send(@method, fail_proc) {|e| e == @elements.first }.should == 2
-  end
-
-  it "calls the ifnone proc only once when the block is false" do
-    times = 0
-    fail_proc = -> { times += 1; raise if times > 1; "cheeseburgers" }
-    @numerous.send(@method, fail_proc) {|e| false }.should == "cheeseburgers"
-  end
-
-  it "calls the ifnone proc when there are no elements" do
-    fail_proc = -> { "yay" }
-    @empty.send(@method, fail_proc) {|e| true}.should == "yay"
-  end
-
-  it "ignores the ifnone argument when nil" do
-    @numerous.send(@method, nil) {|e| false }.should == nil
-  end
-
-  it "passes through the values yielded by #each_with_index" do
-    [:a, :b].each_with_index.send(@method) { |x, i| ScratchPad << [x, i]; nil }
-    ScratchPad.recorded.should == [[:a, 0], [:b, 1]]
-  end
-
-  it "returns an enumerator when no block given" do
-    @numerous.send(@method).should be_an_instance_of(Enumerator)
-  end
-
-  it "passes the ifnone proc to the enumerator" do
-    times = 0
-    fail_proc = -> { times += 1; raise if times > 1; "cheeseburgers" }
-    @numerous.send(@method, fail_proc).each {|e| false }.should == "cheeseburgers"
-  end
-
-  it "gathers whole arrays as elements when each yields multiple" do
-    multi = EnumerableSpecs::YieldsMulti.new
-    multi.send(@method) {|e| e == [1, 2] }.should == [1, 2]
-  end
-
-  it_should_behave_like :enumerable_enumeratorized_with_unknown_size
-end
diff --git a/spec/ruby/core/enumerable/shared/find_all.rb b/spec/ruby/core/enumerable/shared/find_all.rb
deleted file mode 100644
index 1bbe71f372..0000000000
--- a/spec/ruby/core/enumerable/shared/find_all.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-require_relative 'enumerable_enumeratorized'
-
-describe :enumerable_find_all, shared: true do
-  before :each do
-    ScratchPad.record []
-    @elements = (1..10).to_a
-    @numerous = EnumerableSpecs::Numerous.new(*@elements)
-  end
-
-  it "returns all elements for which the block is not false" do
-    @numerous.send(@method) {|i| i % 3 == 0 }.should == [3, 6, 9]
-    @numerous.send(@method) {|i| true }.should == @elements
-    @numerous.send(@method) {|i| false }.should == []
-  end
-
-  it "returns an enumerator when no block given" do
-    @numerous.send(@method).should be_an_instance_of(Enumerator)
-  end
-
-  it "passes through the values yielded by #each_with_index" do
-    [:a, :b].each_with_index.send(@method) { |x, i| ScratchPad << [x, i] }
-    ScratchPad.recorded.should == [[:a, 0], [:b, 1]]
-  end
-
-  it "gathers whole arrays as elements when each yields multiple" do
-    multi = EnumerableSpecs::YieldsMulti.new
-    multi.send(@method) {|e| e == [3, 4, 5] }.should == [[3, 4, 5]]
-  end
-
-  it_should_behave_like :enumerable_enumeratorized_with_origin_size
-end
diff --git a/spec/ruby/core/enumerable/shared/include.rb b/spec/ruby/core/enumerable/shared/include.rb
deleted file mode 100644
index 569f350fd5..0000000000
--- a/spec/ruby/core/enumerable/shared/include.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-describe :enumerable_include, shared: true do
-  it "returns true if any element == argument for numbers" do
-    class EnumerableSpecIncludeP; def ==(obj) obj == 5; end; end
-
-    elements = (0..5).to_a
-    EnumerableSpecs::Numerous.new(*elements).send(@method,5).should == true
-    EnumerableSpecs::Numerous.new(*elements).send(@method,10).should == false
-    EnumerableSpecs::Numerous.new(*elements).send(@method,EnumerableSpecIncludeP.new).should == true
-  end
-
-  it "returns true if any element == argument for other objects" do
-    class EnumerableSpecIncludeP11; def ==(obj); obj == '11'; end; end
-
-    elements = ('0'..'5').to_a + [EnumerableSpecIncludeP11.new]
-    EnumerableSpecs::Numerous.new(*elements).send(@method,'5').should == true
-    EnumerableSpecs::Numerous.new(*elements).send(@method,'10').should == false
-    EnumerableSpecs::Numerous.new(*elements).send(@method,EnumerableSpecIncludeP11.new).should == true
-    EnumerableSpecs::Numerous.new(*elements).send(@method,'11').should == true
-  end
-
-
-  it "returns true if any member of enum equals obj when == compare different classes (legacy rubycon)" do
-    # equality is tested with ==
-    EnumerableSpecs::Numerous.new(2,4,6,8,10).send(@method, 2.0).should == true
-    EnumerableSpecs::Numerous.new(2,4,[6,8],10).send(@method, [6, 8]).should == true
-    EnumerableSpecs::Numerous.new(2,4,[6,8],10).send(@method, [6.0, 8.0]).should == true
-  end
-
-  it "gathers whole arrays as elements when each yields multiple" do
-    multi = EnumerableSpecs::YieldsMulti.new
-    multi.send(@method, [1,2]).should be_true
-  end
-
-end
diff --git a/spec/ruby/core/enumerable/shared/inject.rb b/spec/ruby/core/enumerable/shared/inject.rb
deleted file mode 100644
index 12e0665dda..0000000000
--- a/spec/ruby/core/enumerable/shared/inject.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-describe :enumerable_inject, shared: true do
-  it "with argument takes a block with an accumulator (with argument as initial value) and the current element. Value of block becomes new accumulator" do
-    a = []
-    EnumerableSpecs::Numerous.new.send(@method, 0) { |memo, i| a << [memo, i]; i }
-    a.should == [[0, 2], [2, 5], [5, 3], [3, 6], [6, 1], [1, 4]]
-    EnumerableSpecs::EachDefiner.new(true, true, true).send(@method, nil) {|result, i| i && result}.should == nil
-  end
-
-  it "produces an array of the accumulator and the argument when given a block with a *arg" do
-    a = []
-    [1,2].send(@method, 0) {|*args| a << args; args[0] + args[1]}
-    a.should == [[0, 1], [1, 2]]
-  end
-
-  it "can take two argument" do
-    EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, :-).should == 4
-  end
-
-  it "ignores the block if two arguments" do
-    EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, :-){ raise "we never get here"}.should == 4
-  end
-
-  it "can take a symbol argument" do
-    EnumerableSpecs::Numerous.new(10, 1, 2, 3).send(@method, :-).should == 4
-  end
-
-  it "without argument takes a block with an accumulator (with first element as initial value) and the current element. Value of block becomes new accumulator" do
-    a = []
-    EnumerableSpecs::Numerous.new.send(@method) { |memo, i| a << [memo, i]; i }
-    a.should == [[2, 5], [5, 3], [3, 6], [6, 1], [1, 4]]
-  end
-
-   it "gathers whole arrays as elements when each yields multiple" do
-     multi = EnumerableSpecs::YieldsMulti.new
-     multi.send(@method, []) {|acc, e| acc << e }.should == [[1, 2], [3, 4, 5], [6, 7, 8, 9]]
-   end
-
-  it "with inject arguments(legacy rubycon)" do
-    # with inject argument
-    EnumerableSpecs::EachDefiner.new().send(@method, 1) {|acc,x| 999 }.should == 1
-    EnumerableSpecs::EachDefiner.new(2).send(@method, 1) {|acc,x| 999 }.should ==  999
-    EnumerableSpecs::EachDefiner.new(2).send(@method, 1) {|acc,x| acc }.should == 1
-    EnumerableSpecs::EachDefiner.new(2).send(@method, 1) {|acc,x| x }.should == 2
-
-    EnumerableSpecs::EachDefiner.new(1,2,3,4).send(@method, 100) {|acc,x| acc + x }.should == 110
-    EnumerableSpecs::EachDefiner.new(1,2,3,4).send(@method, 100) {|acc,x| acc * x }.should == 2400
-
-    EnumerableSpecs::EachDefiner.new('a','b','c').send(@method, "z") {|result, i| i+result}.should == "cbaz"
-  end
-
-  it "without inject arguments(legacy rubycon)" do
-    # no inject argument
-    EnumerableSpecs::EachDefiner.new(2).send(@method) {|acc,x| 999 } .should == 2
-    EnumerableSpecs::EachDefiner.new(2).send(@method) {|acc,x| acc }.should == 2
-    EnumerableSpecs::EachDefiner.new(2).send(@method) {|acc,x| x }.should == 2
-
-    EnumerableSpecs::EachDefiner.new(1,2,3,4).send(@method) {|acc,x| acc + x }.should == 10
-    EnumerableSpecs::EachDefiner.new(1,2,3,4).send(@method) {|acc,x| acc * x }.should == 24
-
-    EnumerableSpecs::EachDefiner.new('a','b','c').send(@method) {|result, i| i+result}.should == "cba"
-    EnumerableSpecs::EachDefiner.new(3, 4, 5).send(@method) {|result, i| result*i}.should == 60
-    EnumerableSpecs::EachDefiner.new([1], 2, 'a','b').send(@method){|r,i| r<<i}.should == [1, 2, 'a', 'b']
-
-  end
-
-  it "returns nil when fails(legacy rubycon)" do
-    EnumerableSpecs::EachDefiner.new().send(@method) {|acc,x| 999 }.should == nil
-  end
-end
diff --git a/spec/ruby/core/enumerable/shared/take.rb b/spec/ruby/core/enumerable/shared/take.rb
index ce2ace20fa..a6da06325f 100644
--- a/spec/ruby/core/enumerable/shared/take.rb
+++ b/spec/ruby/core/enumerable/shared/take.rb
@@ -25,7 +25,7 @@ describe :enumerable_take, shared: true do
   end
 
   it "raises an ArgumentError when count is negative" do
-    -> { @enum.send(@method, -1) }.should raise_error(ArgumentError)
+    -> { @enum.send(@method, -1) }.should.raise(ArgumentError)
   end
 
   it "returns the entire array when count > length" do
@@ -40,11 +40,11 @@ describe :enumerable_take, shared: true do
   end
 
   it "raises a TypeError if the passed argument is not numeric" do
-    -> { @enum.send(@method, nil) }.should raise_error(TypeError)
-    -> { @enum.send(@method, "a") }.should raise_error(TypeError)
+    -> { @enum.send(@method, nil) }.should.raise(TypeError)
+    -> { @enum.send(@method, "a") }.should.raise(TypeError)
 
     obj = mock("nonnumeric")
-    -> { @enum.send(@method, obj) }.should raise_error(TypeError)
+    -> { @enum.send(@method, obj) }.should.raise(TypeError)
   end
 
   it "gathers whole arrays as elements when each yields multiple" do
diff --git a/spec/ruby/core/enumerable/shared/value_packing.rb b/spec/ruby/core/enumerable/shared/value_packing.rb
new file mode 100644
index 0000000000..ff77f45cdf
--- /dev/null
+++ b/spec/ruby/core/enumerable/shared/value_packing.rb
@@ -0,0 +1,26 @@
+# This is the behavior of rb_enum_values_pack() in CRuby
+describe :enumerable_value_packing, shared: true do
+  # @take must be set to a Proc that returns the take-result whose #each
+  # yields packed values (e.g. -> e { e.take(1) } or -> e { e.lazy.take(1) }).
+
+  it "yields a single nil for a zero-argument source yield" do
+    e = Enumerator.new { |y| y.yield }
+    args = nil
+    @take.call(e).each { |*a| args = a }
+    args.should == [nil]
+  end
+
+  it "yields the value for a single-argument source yield" do
+    e = Enumerator.new { |y| y.yield :v }
+    args = nil
+    @take.call(e).each { |*a| args = a }
+    args.should == [:v]
+  end
+
+  it "yields a packed Array for a multi-argument source yield" do
+    e = Enumerator.new { |y| y.yield 1, 2 }
+    args = nil
+    @take.call(e).each { |*a| args = a }
+    args.should == [[1, 2]]
+  end
+end