From 45cf4f218728a15eb36d14a6c9912086525f5e3f Mon Sep 17 00:00:00 2001
From: Benoit Daloze <eregontp@gmail.com>
Date: Mon, 25 Apr 2022 14:53:54 +0200
Subject: Update to ruby/spec@3affe1e

---
 spec/ruby/language/method_spec.rb | 274 ++++++--------------------------------
 1 file changed, 38 insertions(+), 236 deletions(-)

(limited to 'spec/ruby/language/method_spec.rb')

diff --git a/spec/ruby/language/method_spec.rb b/spec/ruby/language/method_spec.rb
index 0a5bb99d0b..d464e79403 100644
--- a/spec/ruby/language/method_spec.rb
+++ b/spec/ruby/language/method_spec.rb
@@ -602,13 +602,11 @@ describe "A method" do
       -> { m(2) }.should raise_error(ArgumentError)
     end
 
-    ruby_version_is "2.7" do
-      evaluate <<-ruby do
-        def m(**k); k end;
-        ruby
+    evaluate <<-ruby do
+      def m(**k); k end;
+      ruby
 
-        m("a" => 1).should == { "a" => 1 }
-      end
+      m("a" => 1).should == { "a" => 1 }
     end
 
     evaluate <<-ruby do
@@ -962,26 +960,13 @@ describe "A method" do
       end
     end
 
-    ruby_version_is ""..."2.7" do
-      evaluate <<-ruby do
-          def m(a=1, **) a end
-        ruby
-
-        m().should == 1
-        m(2, a: 1, b: 0).should == 2
-        m("a" => 1, a: 2).should == {"a" => 1}
-      end
-    end
-
-    ruby_version_is "2.7" do
-      evaluate <<-ruby do
-          def m(a=1, **) a end
-        ruby
+    evaluate <<-ruby do
+        def m(a=1, **) a end
+      ruby
 
-        m().should == 1
-        m(2, a: 1, b: 0).should == 2
-        m("a" => 1, a: 2).should == 1
-      end
+      m().should == 1
+      m(2, a: 1, b: 0).should == 2
+      m("a" => 1, a: 2).should == 1
     end
 
     evaluate <<-ruby do
@@ -1021,164 +1006,7 @@ describe "A method" do
       m(1, 2, 3).should == [[1, 2], 3]
     end
 
-    ruby_version_is ""..."2.7" do
-      evaluate <<-ruby do
-          def m(*, a:) a end
-        ruby
-
-        m(a: 1).should == 1
-        m(1, 2, a: 3).should == 3
-        suppress_keyword_warning do
-          m("a" => 1, a: 2).should == 2
-        end
-      end
-
-      evaluate <<-ruby do
-          def m(*a, b:) [a, b] end
-        ruby
-
-        m(b: 1).should == [[], 1]
-        m(1, 2, b: 3).should == [[1, 2], 3]
-        suppress_keyword_warning do
-          m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
-        end
-      end
-
-      evaluate <<-ruby do
-          def m(*, a: 1) a end
-        ruby
-
-        m().should == 1
-        m(1, 2).should == 1
-        m(a: 2).should == 2
-        m(1, a: 2).should == 2
-        suppress_keyword_warning do
-          m("a" => 1, a: 2).should == 2
-        end
-      end
-
-      evaluate <<-ruby do
-          def m(*a, b: 1) [a, b] end
-        ruby
-
-        m().should == [[], 1]
-        m(1, 2, 3, b: 4).should == [[1, 2, 3], 4]
-        suppress_keyword_warning do
-          m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
-        end
-
-        a = mock("splat")
-        a.should_not_receive(:to_ary)
-        m(*a).should == [[a], 1]
-      end
-
-      evaluate <<-ruby do
-          def m(*, **) end
-        ruby
-
-        m().should be_nil
-        m(a: 1, b: 2).should be_nil
-        m(1, 2, 3, a: 4, b: 5).should be_nil
-
-        h = mock("keyword splat")
-        h.should_receive(:to_hash).and_return({a: 1})
-        suppress_keyword_warning do
-          m(h).should be_nil
-        end
-
-        h = mock("keyword splat")
-        error = RuntimeError.new("error while converting to a hash")
-        h.should_receive(:to_hash).and_raise(error)
-        -> { m(h) }.should raise_error(error)
-      end
-
-      evaluate <<-ruby do
-          def m(*a, **) a end
-        ruby
-
-        m().should == []
-        m(1, 2, 3, a: 4, b: 5).should == [1, 2, 3]
-        m("a" => 1, a: 1).should == [{"a" => 1}]
-        m(1, **{a: 2}).should == [1]
-
-        h = mock("keyword splat")
-        h.should_receive(:to_hash)
-        -> { m(**h) }.should raise_error(TypeError)
-      end
-
-      evaluate <<-ruby do
-          def m(*, **k) k end
-        ruby
-
-        m().should == {}
-        m(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
-        m("a" => 1, a: 1).should == {a: 1}
-
-        h = mock("keyword splat")
-        h.should_receive(:to_hash).and_return({a: 1})
-        m(h).should == {a: 1}
-      end
-
-      evaluate <<-ruby do
-          def m(a = nil, **k) [a, k] end
-        ruby
-
-        m().should == [nil, {}]
-        m("a" => 1).should == [{"a" => 1}, {}]
-        m(a: 1).should == [nil, {a: 1}]
-        m("a" => 1, a: 1).should == [{"a" => 1}, {a: 1}]
-        m({ "a" => 1 }, a: 1).should == [{"a" => 1}, {a: 1}]
-        m({a: 1}, {}).should == [{a: 1}, {}]
-
-        h = {"a" => 1, b: 2}
-        m(h).should == [{"a" => 1}, {b: 2}]
-        h.should == {"a" => 1, b: 2}
-
-        h = {"a" => 1}
-        m(h).first.should == h
-
-        h = {}
-        r = m(h)
-        r.first.should be_nil
-        r.last.should == {}
-
-        hh = {}
-        h = mock("keyword splat empty hash")
-        h.should_receive(:to_hash).and_return(hh)
-        r = m(h)
-        r.first.should be_nil
-        r.last.should == {}
-
-        h = mock("keyword splat")
-        h.should_receive(:to_hash).and_return({"a" => 1, a: 2})
-        m(h).should == [{"a" => 1}, {a: 2}]
-      end
-
-      evaluate <<-ruby do
-          def m(*a, **k) [a, k] end
-        ruby
-
-        m().should == [[], {}]
-        m(1).should == [[1], {}]
-        m(a: 1, b: 2).should == [[], {a: 1, b: 2}]
-        m(1, 2, 3, a: 2).should == [[1, 2, 3], {a: 2}]
-
-        m("a" => 1).should == [[{"a" => 1}], {}]
-        m(a: 1).should == [[], {a: 1}]
-        m("a" => 1, a: 1).should == [[{"a" => 1}], {a: 1}]
-        m({ "a" => 1 }, a: 1).should == [[{"a" => 1}], {a: 1}]
-        m({a: 1}, {}).should == [[{a: 1}], {}]
-        m({a: 1}, {"a" => 1}).should == [[{a: 1}, {"a" => 1}], {}]
-
-        bo = BasicObject.new
-        def bo.to_a; [1, 2, 3]; end
-        def bo.to_hash; {:b => 2, :c => 3}; end
-
-        m(*bo, **bo).should == [[1, 2, 3], {:b => 2, :c => 3}]
-      end
-    end
-
-    ruby_version_is "2.7"...'3.0' do
+    ruby_version_is ""...'3.0' do
       evaluate <<-ruby do
           def m(*, a:) a end
         ruby
@@ -1503,44 +1331,22 @@ describe "A method" do
       end
     end
 
-    ruby_version_is ''...'2.7' do
-      evaluate <<-ruby do
-          def m(a:, **) a end
-        ruby
-
-        m(a: 1).should == 1
-        m(a: 1, b: 2).should == 1
-        -> { m("a" => 1, a: 1, b: 2) }.should raise_error(ArgumentError)
-      end
-
-      evaluate <<-ruby do
-          def m(a:, **k) [a, k] end
-        ruby
+    evaluate <<-ruby do
+        def m(a:, **) a end
+      ruby
 
-        m(a: 1).should == [1, {}]
-        m(a: 1, b: 2, c: 3).should == [1, {b: 2, c: 3}]
-        -> { m("a" => 1, a: 1, b: 2) }.should raise_error(ArgumentError)
-      end
+      m(a: 1).should == 1
+      m(a: 1, b: 2).should == 1
+      m("a" => 1, a: 1, b: 2).should == 1
     end
 
-    ruby_version_is '2.7' do
-      evaluate <<-ruby do
-          def m(a:, **) a end
-        ruby
-
-        m(a: 1).should == 1
-        m(a: 1, b: 2).should == 1
-        m("a" => 1, a: 1, b: 2).should == 1
-      end
-
-      evaluate <<-ruby do
-          def m(a:, **k) [a, k] end
-        ruby
+    evaluate <<-ruby do
+        def m(a:, **k) [a, k] end
+      ruby
 
-        m(a: 1).should == [1, {}]
-        m(a: 1, b: 2, c: 3).should == [1, {b: 2, c: 3}]
-        m("a" => 1, a: 1, b: 2).should == [1, {"a" => 1, b: 2}]
-      end
+      m(a: 1).should == [1, {}]
+      m(a: 1, b: 2, c: 3).should == [1, {b: 2, c: 3}]
+      m("a" => 1, a: 1, b: 2).should == [1, {"a" => 1, b: 2}]
     end
 
     evaluate <<-ruby do
@@ -1637,18 +1443,16 @@ describe "A method" do
       result.should == [1, 1, [], 2, 3, 2, 4, { h: 5, i: 6 }, l]
     end
 
-    ruby_version_is "2.7" do
-      evaluate <<-ruby do
-        def m(a, **nil); a end;
-        ruby
+    evaluate <<-ruby do
+      def m(a, **nil); a end;
+      ruby
 
-        m({a: 1}).should == {a: 1}
-        m({"a" => 1}).should == {"a" => 1}
+      m({a: 1}).should == {a: 1}
+      m({"a" => 1}).should == {"a" => 1}
 
-        -> { m(a: 1) }.should raise_error(ArgumentError)
-        -> { m(**{a: 1}) }.should raise_error(ArgumentError)
-        -> { m("a" => 1) }.should raise_error(ArgumentError)
-      end
+      -> { m(a: 1) }.should raise_error(ArgumentError)
+      -> { m(**{a: 1}) }.should raise_error(ArgumentError)
+      -> { m("a" => 1) }.should raise_error(ArgumentError)
     end
 
     ruby_version_is ''...'3.0' do
@@ -1690,19 +1494,17 @@ describe "A method" do
     end
   end
 
-  ruby_version_is '2.7' do
-    context 'when passing an empty keyword splat to a method that does not accept keywords' do
-      evaluate <<-ruby do
-          def m(*a); a; end
-        ruby
+  context 'when passing an empty keyword splat to a method that does not accept keywords' do
+    evaluate <<-ruby do
+        def m(*a); a; end
+      ruby
 
-        h = {}
-        m(**h).should == []
-      end
+      h = {}
+      m(**h).should == []
     end
   end
 
-  ruby_version_is '2.7'...'3.0' do
+  ruby_version_is ''...'3.0' do
     context 'when passing an empty keyword splat to a method that does not accept keywords' do
       evaluate <<-ruby do
           def m(a); a; end
-- 
cgit v1.2.1