1 files changed, 25 insertions, 53 deletions

diff --git a/spec/ruby/core/kernel/lambda_spec.rb b/spec/ruby/core/kernel/lambda_spec.rb
index 9a960f3589..6ab89c2bbb 100644
--- a/spec/ruby/core/kernel/lambda_spec.rb
+++ b/spec/ruby/core/kernel/lambda_spec.rb
@@ -8,90 +8,52 @@ describe "Kernel.lambda" do
   it_behaves_like :kernel_lambda, :lambda
 
   it "is a private method" do
-    Kernel.should have_private_instance_method(:lambda)
+    Kernel.private_instance_methods(false).should.include?(:lambda)
   end
 
   it "creates a lambda-style Proc if given a literal block" do
     l = lambda { 42 }
-    l.lambda?.should be_true
+    l.lambda?.should == true
   end
 
   it "creates a lambda-style Proc if given a literal block via #send" do
     l = send(:lambda) { 42 }
-    l.lambda?.should be_true
+    l.lambda?.should == true
   end
 
   it "creates a lambda-style Proc if given a literal block via #__send__" do
     l = __send__(:lambda) { 42 }
-    l.lambda?.should be_true
-  end
-
-  it "creates a lambda-style Proc if given a literal block via Kernel.public_send" do
-    suppress_warning do
-      l = Kernel.public_send(:lambda) { 42 }
-      l.lambda?.should be_true
-    end
-  end
-
-  it "returns the passed Proc if given an existing Proc" do
-    some_proc = proc {}
-    l = suppress_warning {lambda(&some_proc)}
-    l.should equal(some_proc)
-    l.lambda?.should be_false
-  end
-
-  it "creates a lambda-style Proc when called with zsuper" do
-    suppress_warning do
-      l = KernelSpecs::LambdaSpecs::ForwardBlockWithZSuper.new.lambda { 42 }
-      l.lambda?.should be_true
-      l.call.should == 42
-
-      lambda { l.call(:extra) }.should raise_error(ArgumentError)
-    end
-  end
-
-  it "returns the passed Proc if given an existing Proc through super" do
-    some_proc = proc { }
-    l = KernelSpecs::LambdaSpecs::SuperAmpersand.new.lambda(&some_proc)
-    l.should equal(some_proc)
-    l.lambda?.should be_false
-  end
-
-  it "does not create lambda-style Procs when captured with #method" do
-    kernel_lambda = method(:lambda)
-    l = suppress_warning {kernel_lambda.call { 42 }}
-    l.lambda?.should be_false
-    l.call(:extra).should == 42
+    l.lambda?.should == true
   end
 
   it "checks the arity of the call when no args are specified" do
     l = lambda { :called }
     l.call.should == :called
 
-    lambda { l.call(1) }.should raise_error(ArgumentError)
-    lambda { l.call(1, 2) }.should raise_error(ArgumentError)
+    lambda { l.call(1) }.should.raise(ArgumentError)
+    lambda { l.call(1, 2) }.should.raise(ArgumentError)
   end
 
   it "checks the arity when 1 arg is specified" do
     l = lambda { |a| :called }
     l.call(1).should == :called
 
-    lambda { l.call }.should raise_error(ArgumentError)
-    lambda { l.call(1, 2) }.should raise_error(ArgumentError)
+    lambda { l.call }.should.raise(ArgumentError)
+    lambda { l.call(1, 2) }.should.raise(ArgumentError)
   end
 
   it "does not check the arity when passing a Proc with &" do
     l = lambda { || :called }
     p = proc { || :called }
 
-    lambda { l.call(1) }.should raise_error(ArgumentError)
+    lambda { l.call(1) }.should.raise(ArgumentError)
     p.call(1).should == :called
   end
 
   it "accepts 0 arguments when used with ||" do
     lambda {
       lambda { || }.call(1)
-    }.should raise_error(ArgumentError)
+    }.should.raise(ArgumentError)
   end
 
   it "strictly checks the arity when 0 or 2..inf args are specified" do
@@ -99,15 +61,15 @@ describe "Kernel.lambda" do
 
     lambda {
       l.call
-    }.should raise_error(ArgumentError)
+    }.should.raise(ArgumentError)
 
     lambda {
       l.call(1)
-    }.should raise_error(ArgumentError)
+    }.should.raise(ArgumentError)
 
     lambda {
       l.call(1,2)
-    }.should_not raise_error(ArgumentError)
+    }.should_not.raise(ArgumentError)
   end
 
   it "returns from the lambda itself, not the creation site of the lambda" do
@@ -117,7 +79,7 @@ describe "Kernel.lambda" do
       @reached_end_of_method = true
     end
     test
-    @reached_end_of_method.should be_true
+    @reached_end_of_method.should == true
   end
 
   it "allows long returns to flow through it" do
@@ -132,7 +94,17 @@ describe "Kernel.lambda" do
         2
       end
     end
-    klass.new.lambda { 42 }.should be_an_instance_of Proc
+    klass.new.lambda { 42 }.should.instance_of? Proc
     klass.new.ret.should == 1
   end
+
+  context "when called without a literal block" do
+    it "raises when proc isn't a lambda" do
+      -> { lambda(&proc{}) }.should.raise(ArgumentError, /the lambda method requires a literal block/)
+    end
+
+    it "doesn't warn when proc is lambda" do
+      -> { lambda(&lambda{}) }.should_not complain(verbose: true)
+    end
+  end
 end