1 files changed, 31 insertions, 31 deletions

diff --git a/spec/ruby/core/module/const_defined_spec.rb b/spec/ruby/core/module/const_defined_spec.rb
index 8b137cd134..9d973c2b2b 100644
--- a/spec/ruby/core/module/const_defined_spec.rb
+++ b/spec/ruby/core/module/const_defined_spec.rb
@@ -14,40 +14,40 @@ describe "Module#const_defined?" do
 
   it "returns true if the constant is defined in the receiver's superclass" do
     # CS_CONST4 is defined in the superclass of ChildA
-    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4).should be_true
+    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4).should == true
   end
 
   it "returns true if the constant is defined in a mixed-in module of the receiver's parent" do
     # CS_CONST10 is defined in a module included by ChildA
-    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST10).should be_true
+    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST10).should == true
   end
 
   it "returns true if the constant is defined in a mixed-in module (with prepends) of the receiver" do
     # CS_CONST11 is defined in the module included by ContainerPrepend
-    ConstantSpecs::ContainerPrepend.const_defined?(:CS_CONST11).should be_true
+    ConstantSpecs::ContainerPrepend.const_defined?(:CS_CONST11).should == true
   end
 
   it "returns true if the constant is defined in Object and the receiver is a module" do
     # CS_CONST1 is defined in Object
-    ConstantSpecs::ModuleA.const_defined?(:CS_CONST1).should be_true
+    ConstantSpecs::ModuleA.const_defined?(:CS_CONST1).should == true
   end
 
   it "returns true if the constant is defined in Object and the receiver is a class that has Object among its ancestors" do
     # CS_CONST1 is defined in Object
-    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST1).should be_true
+    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST1).should == true
   end
 
   it "returns false if the constant is defined in the receiver's superclass and the inherit flag is false" do
-    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4, false).should be_false
+    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4, false).should == false
   end
 
   it "returns true if the constant is defined in the receiver's superclass and the inherit flag is true" do
-    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4, true).should be_true
+    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4, true).should == true
   end
 
   it "coerces the inherit flag to a boolean" do
-    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4, nil).should be_false
-    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4, :true).should be_true
+    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4, nil).should == false
+    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4, :true).should == true
   end
 
   it "returns true if the given String names a constant defined in the receiver" do
@@ -58,23 +58,23 @@ describe "Module#const_defined?" do
   end
 
   it "returns true when passed a constant name with unicode characters" do
-    ConstantUnicodeSpecs.const_defined?("CS_CONSTλ").should be_true
+    ConstantUnicodeSpecs.const_defined?("CS_CONSTλ").should == true
   end
 
   it "returns true when passed a constant name with EUC-JP characters" do
     str = "CS_CONSTλ".encode("euc-jp")
     ConstantSpecs.const_set str, 1
-    ConstantSpecs.const_defined?(str).should be_true
+    ConstantSpecs.const_defined?(str).should == true
   ensure
     ConstantSpecs.send(:remove_const, str)
   end
 
   it "returns false if the constant is not defined in the receiver, its superclass, or any included modules" do
     # The following constant isn't defined at all.
-    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4726).should be_false
+    ConstantSpecs::ContainerA::ChildA.const_defined?(:CS_CONST4726).should == false
     # DETACHED_CONSTANT is defined in ConstantSpecs::Detached, which isn't
     # included by or inherited from ParentA
-    ConstantSpecs::ParentA.const_defined?(:DETACHED_CONSTANT).should be_false
+    ConstantSpecs::ParentA.const_defined?(:DETACHED_CONSTANT).should == false
   end
 
   it "does not call #const_missing if the constant is not defined in the receiver" do
@@ -90,59 +90,59 @@ describe "Module#const_defined?" do
     end
 
     it "raises a TypeError if the given name can't be converted to a String" do
-      -> { ConstantSpecs.const_defined?(nil) }.should raise_error(TypeError)
-      -> { ConstantSpecs.const_defined?([])  }.should raise_error(TypeError)
+      -> { ConstantSpecs.const_defined?(nil) }.should.raise(TypeError)
+      -> { ConstantSpecs.const_defined?([])  }.should.raise(TypeError)
     end
 
     it "raises a NoMethodError if the given argument raises a NoMethodError during type coercion to a String" do
       name = mock("classA")
       name.should_receive(:to_str).and_raise(NoMethodError)
-      -> { ConstantSpecs.const_defined?(name) }.should raise_error(NoMethodError)
+      -> { ConstantSpecs.const_defined?(name) }.should.raise(NoMethodError)
     end
   end
 
   it "special cases Object and checks it's included Modules" do
-    Object.const_defined?(:CS_CONST10).should be_true
+    Object.const_defined?(:CS_CONST10).should == true
   end
 
   it "returns true for toplevel constant when the name begins with '::'" do
-    ConstantSpecs.const_defined?("::Array").should be_true
+    ConstantSpecs.const_defined?("::Array").should == true
   end
 
   it "returns true when passed a scoped constant name" do
-    ConstantSpecs.const_defined?("ClassC::CS_CONST1").should be_true
+    ConstantSpecs.const_defined?("ClassC::CS_CONST1").should == true
   end
 
   it "returns true when passed a scoped constant name for a constant in the inheritance hierarchy and the inherited flag is default" do
-    ConstantSpecs::ClassD.const_defined?("ClassE::CS_CONST2").should be_true
+    ConstantSpecs::ClassD.const_defined?("ClassE::CS_CONST2").should == true
   end
 
   it "returns true when passed a scoped constant name for a constant in the inheritance hierarchy and the inherited flag is true" do
-    ConstantSpecs::ClassD.const_defined?("ClassE::CS_CONST2", true).should be_true
+    ConstantSpecs::ClassD.const_defined?("ClassE::CS_CONST2", true).should == true
   end
 
   it "returns false when passed a scoped constant name for a constant in the inheritance hierarchy and the inherited flag is false" do
-    ConstantSpecs::ClassD.const_defined?("ClassE::CS_CONST2", false).should be_false
+    ConstantSpecs::ClassD.const_defined?("ClassE::CS_CONST2", false).should == false
   end
 
   it "returns false when the name begins with '::' and the toplevel constant does not exist" do
-    ConstantSpecs.const_defined?("::Name").should be_false
+    ConstantSpecs.const_defined?("::Name").should == false
   end
 
   it "raises a NameError if the name does not start with a capital letter" do
-    -> { ConstantSpecs.const_defined? "name" }.should raise_error(NameError)
+    -> { ConstantSpecs.const_defined? "name" }.should.raise(NameError)
   end
 
   it "raises a NameError if the name starts with '_'" do
-    -> { ConstantSpecs.const_defined? "__CONSTX__" }.should raise_error(NameError)
+    -> { ConstantSpecs.const_defined? "__CONSTX__" }.should.raise(NameError)
   end
 
   it "raises a NameError if the name starts with '@'" do
-    -> { ConstantSpecs.const_defined? "@Name" }.should raise_error(NameError)
+    -> { ConstantSpecs.const_defined? "@Name" }.should.raise(NameError)
   end
 
   it "raises a NameError if the name starts with '!'" do
-    -> { ConstantSpecs.const_defined? "!Name" }.should raise_error(NameError)
+    -> { ConstantSpecs.const_defined? "!Name" }.should.raise(NameError)
   end
 
   it "returns true or false for the nested name" do
@@ -155,15 +155,15 @@ describe "Module#const_defined?" do
 
   it "raises a NameError if the name contains non-alphabetic characters except '_'" do
     ConstantSpecs.const_defined?("CS_CONSTX").should == false
-    -> { ConstantSpecs.const_defined? "Name=" }.should raise_error(NameError)
-    -> { ConstantSpecs.const_defined? "Name?" }.should raise_error(NameError)
+    -> { ConstantSpecs.const_defined? "Name=" }.should.raise(NameError)
+    -> { ConstantSpecs.const_defined? "Name?" }.should.raise(NameError)
   end
 
   it "raises a TypeError if conversion to a String by calling #to_str fails" do
     name = mock('123')
-    -> { ConstantSpecs.const_defined? name }.should raise_error(TypeError)
+    -> { ConstantSpecs.const_defined? name }.should.raise(TypeError)
 
     name.should_receive(:to_str).and_return(123)
-    -> { ConstantSpecs.const_defined? name }.should raise_error(TypeError)
+    -> { ConstantSpecs.const_defined? name }.should.raise(TypeError)
   end
 end