1 files changed, 91 insertions, 38 deletions

diff --git a/spec/ruby/optional/capi/proc_spec.rb b/spec/ruby/optional/capi/proc_spec.rb
index ff119416f6..1c250fee76 100644
--- a/spec/ruby/optional/capi/proc_spec.rb
+++ b/spec/ruby/optional/capi/proc_spec.rb
@@ -7,6 +7,8 @@ describe "C-API Proc function" do
   before :each do
     @p = CApiProcSpecs.new
     @prc = @p.rb_proc_new
+    @prc2 = @p.rb_proc_new_argv_n
+    @prc3 = @p.rb_proc_new_argc
   end
 
   describe "rb_proc_new" do
@@ -15,6 +17,7 @@ describe "C-API Proc function" do
     end
 
     it "calls the C function wrapped by the Proc instance when sent #call" do
+      @p.rb_proc_new_arg.call().should == nil
       @prc.call(:foo_bar).should == ":foo_bar"
       @prc.call([:foo, :bar]).should == "[:foo, :bar]"
     end
@@ -24,6 +27,30 @@ describe "C-API Proc function" do
       @prc[[:foo, :bar]].should == "[:foo, :bar]"
     end
 
+    it "calls the C function with the arg count in argc" do
+      @prc3.call().should == 0
+      @prc3.call(:foo).should == 1
+      @prc3.call(:foo, :bar).should == 2
+    end
+
+    it "calls the C function with arguments in argv" do
+      @prc2.call(1, :foo).should == :foo
+      @prc2.call(2, :foo, :bar).should == :bar
+      -> { @prc2.call(3, :foo, :bar) }.should.raise(ArgumentError)
+    end
+
+    it "calls the C function with the block passed in blockarg" do
+      a_block = :foo.to_proc
+      @p.rb_proc_new_blockarg.call(&a_block).should == a_block
+      @p.rb_proc_new_blockarg.call().should == nil
+    end
+
+    it "calls the C function and yields to the block passed in blockarg" do
+      @p.rb_proc_new_block_given_p.call() do
+      end.should == false
+      @p.rb_proc_new_block_given_p.call().should == false
+    end
+
     it "returns a Proc instance correctly described in #inspect without source location" do
       @prc.inspect.should =~ /^#<Proc:([^ :@]*?)>$/
     end
@@ -55,22 +82,75 @@ describe "C-API Proc function" do
     end
   end
 
+  describe "rb_proc_call_kw" do
+    it "passes keyword arguments to the proc" do
+      prc = proc { |*args, **kw| [args, kw] }
+
+      @p.rb_proc_call_kw(prc, [{}]).should == [[], {}]
+      @p.rb_proc_call_kw(prc, [{a: 1}]).should == [[], {a: 1}]
+      @p.rb_proc_call_kw(prc, [{b: 2}, {a: 1}]).should == [[{b: 2}], {a: 1}]
+      @p.rb_proc_call_kw(prc, [{b: 2}, {}]).should == [[{b: 2}], {}]
+    end
+
+    it "raises TypeError if the last argument is not a Hash" do
+      -> {
+        @p.rb_proc_call_kw(proc {}, [42])
+      }.should.raise(TypeError, 'no implicit conversion of Integer into Hash')
+    end
+  end
+
+  describe "rb_proc_call_with_block" do
+    it "calls the Proc and passes arguments and a block" do
+      prc = Proc.new { |a, b, &block| block.call(a * b) }
+      @p.rb_proc_call_with_block(prc, [6, 7], proc { |n| n * 2 }).should == 6 * 7 * 2
+    end
+
+    it "calls the Proc and passes arguments when a block is nil" do
+      prc = Proc.new { |a, b| a * b }
+      @p.rb_proc_call_with_block(prc, [6, 7], nil).should == 6 * 7
+    end
+  end
+
+  describe "rb_proc_call_with_block_kw" do
+    it "passes keyword arguments and a block to the proc" do
+      prc = proc { |*args, **kw, &block| [args, kw, block.call(42)] }
+      block = proc { |n| n }
+
+      @p.rb_proc_call_with_block_kw(prc, [{}], block).should == [[], {}, 42]
+      @p.rb_proc_call_with_block_kw(prc, [{a: 1}], block).should == [[], {a: 1}, 42]
+      @p.rb_proc_call_with_block_kw(prc, [{b: 2}, {a: 1}], block).should == [[{b: 2}], {a: 1}, 42]
+      @p.rb_proc_call_with_block_kw(prc, [{b: 2}, {}], block).should == [[{b: 2}], {}, 42]
+    end
+
+    it "raises TypeError if the last argument is not a Hash" do
+      -> {
+        @p.rb_proc_call_with_block_kw(proc {}, [42], proc {})
+      }.should.raise(TypeError, 'no implicit conversion of Integer into Hash')
+    end
+
+    it "passes keyword arguments to the proc when a block is nil" do
+      prc = proc { |*args, **kw| [args, kw] }
+
+      @p.rb_proc_call_with_block_kw(prc, [{}], nil).should == [[], {}]
+    end
+  end
+
   describe "rb_obj_is_proc" do
     it "returns true for Proc" do
       prc = Proc.new {|a,b| a * b }
-      @p.rb_obj_is_proc(prc).should be_true
+      @p.rb_obj_is_proc(prc).should == true
     end
 
     it "returns true for subclass of Proc" do
       prc = Class.new(Proc).new {}
-      @p.rb_obj_is_proc(prc).should be_true
+      @p.rb_obj_is_proc(prc).should == true
     end
 
     it "returns false for non Proc instances" do
-      @p.rb_obj_is_proc("aoeui").should be_false
-      @p.rb_obj_is_proc(123).should be_false
-      @p.rb_obj_is_proc(true).should be_false
-      @p.rb_obj_is_proc([]).should be_false
+      @p.rb_obj_is_proc("aoeui").should == false
+      @p.rb_obj_is_proc(123).should == false
+      @p.rb_obj_is_proc(true).should == false
+      @p.rb_obj_is_proc([]).should == false
     end
   end
 end
@@ -88,48 +168,21 @@ describe "C-API when calling Proc.new from a C function" do
   # For example: C -> Ruby <- C -> Ruby means a C function called into Ruby
   # code which returned to C, then C called into Ruby code again.
 
-  ruby_version_is ""..."2.7" do
-    #   Ruby -> C -> rb_funcall(Proc.new)
-    it "returns the Proc passed by the Ruby code calling the C function" do
-      prc = @p.rb_Proc_new(0) { :called }
-      prc.call.should == :called
-    end
-
-    #   Ruby -> C -> Ruby <- C -> rb_funcall(Proc.new)
-    it "returns the Proc passed to the Ruby method when the C function calls other Ruby methods before calling Proc.new" do
-      prc = @p.rb_Proc_new(1) { :called }
-      prc.call.should == :called
-    end
-  end
-
   # Ruby -> C -> Ruby -> Proc.new
   it "raises an ArgumentError when the C function calls a Ruby method that calls Proc.new" do
-    def @p.Proc_new() Proc.new end
-    -> { @p.rb_Proc_new(2) { :called } }.should raise_error(ArgumentError)
+    -> {
+      @p.rb_Proc_new(2) { :called }
+    }.should.raise(ArgumentError)
   end
 
   # Ruby -> C -> Ruby -> C -> rb_funcall(Proc.new)
   it "raises an ArgumentError when the C function calls a Ruby method and that method calls a C function that calls Proc.new" do
     def @p.redispatch() rb_Proc_new(0) end
-    -> { @p.rb_Proc_new(3) { :called } }.should raise_error(ArgumentError)
-  end
-
-  ruby_version_is ""..."2.7" do
-    # Ruby -> C -> Ruby -> C (with new block) -> rb_funcall(Proc.new)
-    it "returns the most recent Proc passed when the Ruby method called the C function" do
-      prc = @p.rb_Proc_new(4) { :called }
-      prc.call.should == :calling_with_block
-    end
-
-    # Ruby -> C -> Ruby -> C (with new block) <- Ruby <- C -> # rb_funcall(Proc.new)
-    it "returns the Proc passed from the original Ruby call to the C function" do
-      prc = @p.rb_Proc_new(5) { :called }
-      prc.call.should == :called
-    end
+    -> { @p.rb_Proc_new(3) { :called } }.should.raise(ArgumentError)
   end
 
   # Ruby -> C -> Ruby -> block_given?
   it "returns false from block_given? in a Ruby method called by the C function" do
-    @p.rb_Proc_new(6).should be_false
+    @p.rb_Proc_new(6).should == false
   end
 end