diff options
Diffstat (limited to 'spec/ruby/core/kernel')
114 files changed, 1981 insertions, 1342 deletions
diff --git a/spec/ruby/core/kernel/Array_spec.rb b/spec/ruby/core/kernel/Array_spec.rb index b4a8bb7599..063faf7097 100644 --- a/spec/ruby/core/kernel/Array_spec.rb +++ b/spec/ruby/core/kernel/Array_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel" do it "has private instance method Array()" do - Kernel.should have_private_instance_method(:Array) + Kernel.private_instance_methods(false).should.include?(:Array) end end @@ -77,14 +77,14 @@ describe :kernel_Array, shared: true do obj = mock("Array() string") obj.should_receive(:to_ary).and_return("string") - -> { @object.send(@method, obj) }.should raise_error(TypeError) + -> { @object.send(@method, obj) }.should.raise(TypeError) end it "raises a TypeError if #to_a does not return an Array" do obj = mock("Array() string") obj.should_receive(:to_a).and_return("string") - -> { @object.send(@method, obj) }.should raise_error(TypeError) + -> { @object.send(@method, obj) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/kernel/Complex_spec.rb b/spec/ruby/core/kernel/Complex_spec.rb index 346d50ab5e..92ce183cc8 100644 --- a/spec/ruby/core/kernel/Complex_spec.rb +++ b/spec/ruby/core/kernel/Complex_spec.rb @@ -19,19 +19,19 @@ describe "Kernel.Complex()" do describe "when passed [Integer, Integer]" do it "returns a new Complex number" do - Complex(1, 2).should be_an_instance_of(Complex) + Complex(1, 2).should.instance_of?(Complex) Complex(1, 2).real.should == 1 Complex(1, 2).imag.should == 2 - Complex(-3, -5).should be_an_instance_of(Complex) + Complex(-3, -5).should.instance_of?(Complex) Complex(-3, -5).real.should == -3 Complex(-3, -5).imag.should == -5 - Complex(3.5, -4.5).should be_an_instance_of(Complex) + Complex(3.5, -4.5).should.instance_of?(Complex) Complex(3.5, -4.5).real.should == 3.5 Complex(3.5, -4.5).imag.should == -4.5 - Complex(bignum_value, 30).should be_an_instance_of(Complex) + Complex(bignum_value, 30).should.instance_of?(Complex) Complex(bignum_value, 30).real.should == bignum_value Complex(bignum_value, 30).imag.should == 30 end @@ -41,19 +41,19 @@ describe "Kernel.Complex()" do it "returns a new Complex number with 0 as the imaginary component" do # Guard against the Mathn library guard -> { !defined?(Math.rsqrt) } do - Complex(1).should be_an_instance_of(Complex) + Complex(1).should.instance_of?(Complex) Complex(1).imag.should == 0 Complex(1).real.should == 1 - Complex(-3).should be_an_instance_of(Complex) + Complex(-3).should.instance_of?(Complex) Complex(-3).imag.should == 0 Complex(-3).real.should == -3 - Complex(-4.5).should be_an_instance_of(Complex) + Complex(-4.5).should.instance_of?(Complex) Complex(-4.5).imag.should == 0 Complex(-4.5).real.should == -4.5 - Complex(bignum_value).should be_an_instance_of(Complex) + Complex(bignum_value).should.instance_of?(Complex) Complex(bignum_value).imag.should == 0 Complex(bignum_value).real.should == bignum_value end @@ -67,47 +67,47 @@ describe "Kernel.Complex()" do it "raises Encoding::CompatibilityError if String is in not ASCII-compatible encoding" do -> { Complex("79+4i".encode("UTF-16")) - }.should raise_error(Encoding::CompatibilityError, "ASCII incompatible encoding: UTF-16") + }.should.raise(Encoding::CompatibilityError, "ASCII incompatible encoding: UTF-16") end it "raises ArgumentError for unrecognised Strings" do -> { Complex("ruby") - }.should raise_error(ArgumentError, 'invalid value for convert(): "ruby"') + }.should.raise(ArgumentError, 'invalid value for convert(): "ruby"') end it "raises ArgumentError for trailing garbage" do -> { Complex("79+4iruby") - }.should raise_error(ArgumentError, 'invalid value for convert(): "79+4iruby"') + }.should.raise(ArgumentError, 'invalid value for convert(): "79+4iruby"') end it "does not understand Float::INFINITY" do -> { Complex("Infinity") - }.should raise_error(ArgumentError, 'invalid value for convert(): "Infinity"') + }.should.raise(ArgumentError, 'invalid value for convert(): "Infinity"') -> { Complex("-Infinity") - }.should raise_error(ArgumentError, 'invalid value for convert(): "-Infinity"') + }.should.raise(ArgumentError, 'invalid value for convert(): "-Infinity"') end it "does not understand Float::NAN" do -> { Complex("NaN") - }.should raise_error(ArgumentError, 'invalid value for convert(): "NaN"') + }.should.raise(ArgumentError, 'invalid value for convert(): "NaN"') end it "does not understand a sequence of _" do -> { Complex("7__9+4__0i") - }.should raise_error(ArgumentError, 'invalid value for convert(): "7__9+4__0i"') + }.should.raise(ArgumentError, 'invalid value for convert(): "7__9+4__0i"') end it "does not allow null-byte" do -> { Complex("1-2i\0") - }.should raise_error(ArgumentError, "string contains null byte") + }.should.raise(ArgumentError, "string contains null byte") end end @@ -115,7 +115,7 @@ describe "Kernel.Complex()" do it "raises Encoding::CompatibilityError if String is in not ASCII-compatible encoding" do -> { Complex("79+4i".encode("UTF-16"), exception: false) - }.should raise_error(Encoding::CompatibilityError, "ASCII incompatible encoding: UTF-16") + }.should.raise(Encoding::CompatibilityError, "ASCII incompatible encoding: UTF-16") end it "returns nil for unrecognised Strings" do @@ -160,7 +160,7 @@ describe "Kernel.Complex()" do it "returns the passed argument" do n = mock_numeric("unreal") n.should_receive(:real?).any_number_of_times.and_return(false) - Complex(n).should equal(n) + Complex(n).should.equal?(n) end end @@ -169,8 +169,8 @@ describe "Kernel.Complex()" do n = mock_numeric("real") n.should_receive(:real?).any_number_of_times.and_return(true) result = Complex(n) - result.real.should equal(n) - result.imag.should equal(0) + result.real.should.equal?(n) + result.imag.should.equal?(0) end end @@ -185,7 +185,7 @@ describe "Kernel.Complex()" do n2.should_receive(:real?).any_number_of_times.and_return(r2) n2.should_receive(:*).with(Complex(0, 1)).and_return(n3) n1.should_receive(:+).with(n3).and_return(n4) - Complex(n1, n2).should equal(n4) + Complex(n1, n2).should.equal?(n4) end end end @@ -197,8 +197,8 @@ describe "Kernel.Complex()" do n1.should_receive(:real?).any_number_of_times.and_return(true) n2.should_receive(:real?).any_number_of_times.and_return(true) result = Complex(n1, n2) - result.real.should equal(n1) - result.imag.should equal(n2) + result.real.should.equal?(n1) + result.imag.should.equal?(n2) end end @@ -207,22 +207,22 @@ describe "Kernel.Complex()" do n = mock("n") c = Complex(0, 0) n.should_receive(:to_c).and_return(c) - Complex(n).should equal(c) + Complex(n).should.equal?(c) end end describe "when passed a non-Numeric second argument" do it "raises TypeError" do - -> { Complex(:sym, :sym) }.should raise_error(TypeError) - -> { Complex(0, :sym) }.should raise_error(TypeError) + -> { Complex(:sym, :sym) }.should.raise(TypeError) + -> { Complex(0, :sym) }.should.raise(TypeError) end end describe "when passed nil" do it "raises TypeError" do - -> { Complex(nil) }.should raise_error(TypeError, "can't convert nil into Complex") - -> { Complex(0, nil) }.should raise_error(TypeError, "can't convert nil into Complex") - -> { Complex(nil, 0) }.should raise_error(TypeError, "can't convert nil into Complex") + -> { Complex(nil) }.should.raise(TypeError, "can't convert nil into Complex") + -> { Complex(0, nil) }.should.raise(TypeError, "can't convert nil into Complex") + -> { Complex(nil, 0) }.should.raise(TypeError, "can't convert nil into Complex") end end @@ -241,7 +241,7 @@ describe "Kernel.Complex()" do describe "and [non-Numeric, Numeric] argument" do it "throws a TypeError" do - -> { Complex(:sym, 0, exception: false) }.should raise_error(TypeError, "not a real") + -> { Complex(:sym, 0, exception: false) }.should.raise(TypeError, "not a real") end end diff --git a/spec/ruby/core/kernel/Float_spec.rb b/spec/ruby/core/kernel/Float_spec.rb index 6cedfe0617..f5566067ba 100644 --- a/spec/ruby/core/kernel/Float_spec.rb +++ b/spec/ruby/core/kernel/Float_spec.rb @@ -6,7 +6,7 @@ describe :kernel_float, shared: true do float = 1.12 float2 = @object.send(:Float, float) float2.should == float - float2.should equal float + float2.should.equal? float end it "returns a Float for Fixnums" do @@ -22,22 +22,22 @@ describe :kernel_float, shared: true do end it "raises an ArgumentError for nil" do - -> { @object.send(:Float, nil) }.should raise_error(TypeError) + -> { @object.send(:Float, nil) }.should.raise(TypeError) end it "returns the identical NaN for NaN" do nan = nan_value - nan.nan?.should be_true + nan.nan?.should == true nan2 = @object.send(:Float, nan) - nan2.nan?.should be_true - nan2.should equal(nan) + nan2.nan?.should == true + nan2.should.equal?(nan) end it "returns the same Infinity for Infinity" do infinity = infinity_value infinity2 = @object.send(:Float, infinity) infinity2.should == infinity_value - infinity.should equal(infinity2) + infinity.should.equal?(infinity2) end it "converts Strings to floats without calling #to_f" do @@ -51,30 +51,30 @@ describe :kernel_float, shared: true do end it "raises an ArgumentError for a String of word characters" do - -> { @object.send(:Float, "float") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "float") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String with string in error message" do - -> { @object.send(:Float, "foo") }.should raise_error(ArgumentError) { |e| + -> { @object.send(:Float, "foo") }.should.raise(ArgumentError) { |e| e.message.should == 'invalid value for Float(): "foo"' } end it "raises an ArgumentError if there are two decimal points in the String" do - -> { @object.send(:Float, "10.0.0") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "10.0.0") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String of numbers followed by word characters" do - -> { @object.send(:Float, "10D") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "10D") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String of word characters followed by numbers" do - -> { @object.send(:Float, "D10") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "D10") }.should.raise(ArgumentError) end it "is strict about the string form even across newlines" do - -> { @object.send(:Float, "not a number\n10") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "10\nnot a number") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "not a number\n10") }.should.raise(ArgumentError) + -> { @object.send(:Float, "10\nnot a number") }.should.raise(ArgumentError) end it "converts String subclasses to floats without calling #to_f" do @@ -96,17 +96,17 @@ describe :kernel_float, shared: true do end it "raises an ArgumentError if a + or - is embedded in a String" do - -> { @object.send(:Float, "1+1") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "1-1") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "1+1") }.should.raise(ArgumentError) + -> { @object.send(:Float, "1-1") }.should.raise(ArgumentError) end it "raises an ArgumentError if a String has a trailing + or -" do - -> { @object.send(:Float, "11+") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "11-") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "11+") }.should.raise(ArgumentError) + -> { @object.send(:Float, "11-") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String with a leading _" do - -> { @object.send(:Float, "_1") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "_1") }.should.raise(ArgumentError) end it "returns a value for a String with an embedded _" do @@ -114,31 +114,31 @@ describe :kernel_float, shared: true do end it "raises an ArgumentError for a String with a trailing _" do - -> { @object.send(:Float, "10_") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "10_") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String of \\0" do - -> { @object.send(:Float, "\0") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "\0") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String with a leading \\0" do - -> { @object.send(:Float, "\01") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "\01") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String with an embedded \\0" do - -> { @object.send(:Float, "1\01") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "1\01") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String with a trailing \\0" do - -> { @object.send(:Float, "1\0") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "1\0") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String that is just an empty space" do - -> { @object.send(:Float, " ") }.should raise_error(ArgumentError) + -> { @object.send(:Float, " ") }.should.raise(ArgumentError) end it "raises an ArgumentError for a String that with an embedded space" do - -> { @object.send(:Float, "1 2") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "1 2") }.should.raise(ArgumentError) end it "returns a value for a String with a leading space" do @@ -159,10 +159,11 @@ describe :kernel_float, shared: true do ruby_version_is ""..."3.4" do it "raises ArgumentError if a fractional part is missing" do - -> { @object.send(:Float, "1.") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "+1.") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "-1.") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "1.e+0") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "1.") }.should.raise(ArgumentError) + -> { @object.send(:Float, "+1.") }.should.raise(ArgumentError) + -> { @object.send(:Float, "-1.") }.should.raise(ArgumentError) + -> { @object.send(:Float, "1.e+0") }.should.raise(ArgumentError) + -> { @object.send(:Float, "1.e-2") }.should.raise(ArgumentError) end end @@ -172,16 +173,17 @@ describe :kernel_float, shared: true do @object.send(:Float, "+1.").should == 1.0 @object.send(:Float, "-1.").should == -1.0 @object.send(:Float, "1.e+0").should == 1.0 + @object.send(:Float, "1.e-2").should be_close(0.01, TOLERANCE) end end %w(e E).each do |e| it "raises an ArgumentError if #{e} is the trailing character" do - -> { @object.send(:Float, "2#{e}") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "2#{e}") }.should.raise(ArgumentError) end it "raises an ArgumentError if #{e} is the leading character" do - -> { @object.send(:Float, "#{e}2") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "#{e}2") }.should.raise(ArgumentError) end it "returns Infinity for '2#{e}1000'" do @@ -199,18 +201,18 @@ describe :kernel_float, shared: true do end it "raises an exception if a space is embedded on either side of the '#{e}'" do - -> { @object.send(:Float, "2 0#{e}100") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "20#{e}1 00") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "2 0#{e}100") }.should.raise(ArgumentError) + -> { @object.send(:Float, "20#{e}1 00") }.should.raise(ArgumentError) end it "raises an exception if there's a leading _ on either side of the '#{e}'" do - -> { @object.send(:Float, "_20#{e}100") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "20#{e}_100") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "_20#{e}100") }.should.raise(ArgumentError) + -> { @object.send(:Float, "20#{e}_100") }.should.raise(ArgumentError) end it "raises an exception if there's a trailing _ on either side of the '#{e}'" do - -> { @object.send(:Float, "20_#{e}100") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "20#{e}100_") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "20_#{e}100") }.should.raise(ArgumentError) + -> { @object.send(:Float, "20#{e}100_") }.should.raise(ArgumentError) end it "allows decimal points on the left side of the '#{e}'" do @@ -218,63 +220,111 @@ describe :kernel_float, shared: true do end it "raises an ArgumentError if there's a decimal point on the right side of the '#{e}'" do - -> { @object.send(:Float, "20#{e}2.0") }.should raise_error(ArgumentError) + -> { @object.send(:Float, "20#{e}2.0") }.should.raise(ArgumentError) end end - describe "for hexadecimal literals with binary exponent" do - %w(p P).each do |p| - it "interprets the fractional part (on the left side of '#{p}') in hexadecimal" do - @object.send(:Float, "0x10#{p}0").should == 16.0 - end - - it "interprets the exponent (on the right of '#{p}') in decimal" do - @object.send(:Float, "0x1#{p}10").should == 1024.0 - end - - it "raises an ArgumentError if #{p} is the trailing character" do - -> { @object.send(:Float, "0x1#{p}") }.should raise_error(ArgumentError) - end - - it "raises an ArgumentError if #{p} is the leading character" do - -> { @object.send(:Float, "0x#{p}1") }.should raise_error(ArgumentError) - end + context "for hexadecimal literals" do + it "interprets the 0x prefix as hexadecimal" do + @object.send(:Float, "0x10").should == 16.0 + @object.send(:Float, "0x0F").should == 15.0 + @object.send(:Float, "0x0f").should == 15.0 + end - it "returns Infinity for '0x1#{p}10000'" do - @object.send(:Float, "0x1#{p}10000").should == Float::INFINITY - end + it "interprets negative hex value" do + @object.send(:Float, "-0x10").should == -16.0 + end - it "returns 0 for '0x1#{p}-10000'" do - @object.send(:Float, "0x1#{p}-10000").should == 0 - end + it "accepts embedded _ if the number does not contain a-f" do + @object.send(:Float, "0x1_0").should == 16.0 + end - it "allows embedded _ in a number on either side of the #{p}" do - @object.send(:Float, "0x1_0#{p}10").should == 16384.0 - @object.send(:Float, "0x10#{p}1_0").should == 16384.0 - @object.send(:Float, "0x1_0#{p}1_0").should == 16384.0 + ruby_version_is ""..."3.4.3" do + it "does not accept embedded _ if the number contains a-f" do + -> { @object.send(:Float, "0x1_0a") }.should.raise(ArgumentError) + @object.send(:Float, "0x1_0a", exception: false).should == nil end + end - it "raises an exception if a space is embedded on either side of the '#{p}'" do - -> { @object.send(:Float, "0x1 0#{p}10") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "0x10#{p}1 0") }.should raise_error(ArgumentError) + ruby_version_is "3.4.3" do + it "accepts embedded _ if the number contains a-f" do + @object.send(:Float, "0x1_0a").should == 0x10a.to_f end + end - it "raises an exception if there's a leading _ on either side of the '#{p}'" do - -> { @object.send(:Float, "0x_10#{p}10") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "0x10#{p}_10") }.should raise_error(ArgumentError) - end + it "does not accept _ before, after or inside the 0x prefix" do + -> { @object.send(:Float, "_0x10") }.should.raise(ArgumentError) + -> { @object.send(:Float, "0_x10") }.should.raise(ArgumentError) + -> { @object.send(:Float, "0x_10") }.should.raise(ArgumentError) + @object.send(:Float, "_0x10", exception: false).should == nil + @object.send(:Float, "0_x10", exception: false).should == nil + @object.send(:Float, "0x_10", exception: false).should == nil + end - it "raises an exception if there's a trailing _ on either side of the '#{p}'" do - -> { @object.send(:Float, "0x10_#{p}10") }.should raise_error(ArgumentError) - -> { @object.send(:Float, "0x10#{p}10_") }.should raise_error(ArgumentError) - end + it "parses negative hexadecimal string as negative float" do + @object.send(:Float, "-0x7b").should == -123.0 + end - it "allows hexadecimal points on the left side of the '#{p}'" do - @object.send(:Float, "0x1.8#{p}0").should == 1.5 + ruby_version_is "3.4" do + it "accepts a fractional part" do + @object.send(:Float, "0x0.8").should == 0.5 end + end - it "raises an ArgumentError if there's a decimal point on the right side of the '#{p}'" do - -> { @object.send(:Float, "0x1#{p}1.0") }.should raise_error(ArgumentError) + describe "with binary exponent" do + %w(p P).each do |p| + it "interprets the fractional part (on the left side of '#{p}') in hexadecimal" do + @object.send(:Float, "0x10#{p}0").should == 16.0 + end + + it "interprets the exponent (on the right of '#{p}') in decimal" do + @object.send(:Float, "0x1#{p}10").should == 1024.0 + end + + it "raises an ArgumentError if #{p} is the trailing character" do + -> { @object.send(:Float, "0x1#{p}") }.should.raise(ArgumentError) + end + + it "raises an ArgumentError if #{p} is the leading character" do + -> { @object.send(:Float, "0x#{p}1") }.should.raise(ArgumentError) + end + + it "returns Infinity for '0x1#{p}10000'" do + @object.send(:Float, "0x1#{p}10000").should == Float::INFINITY + end + + it "returns 0 for '0x1#{p}-10000'" do + @object.send(:Float, "0x1#{p}-10000").should == 0 + end + + it "allows embedded _ in a number on either side of the #{p}" do + @object.send(:Float, "0x1_0#{p}10").should == 16384.0 + @object.send(:Float, "0x10#{p}1_0").should == 16384.0 + @object.send(:Float, "0x1_0#{p}1_0").should == 16384.0 + end + + it "raises an exception if a space is embedded on either side of the '#{p}'" do + -> { @object.send(:Float, "0x1 0#{p}10") }.should.raise(ArgumentError) + -> { @object.send(:Float, "0x10#{p}1 0") }.should.raise(ArgumentError) + end + + it "raises an exception if there's a leading _ on either side of the '#{p}'" do + -> { @object.send(:Float, "0x_10#{p}10") }.should.raise(ArgumentError) + -> { @object.send(:Float, "0x10#{p}_10") }.should.raise(ArgumentError) + end + + it "raises an exception if there's a trailing _ on either side of the '#{p}'" do + -> { @object.send(:Float, "0x10_#{p}10") }.should.raise(ArgumentError) + -> { @object.send(:Float, "0x10#{p}10_") }.should.raise(ArgumentError) + end + + it "allows hexadecimal points on the left side of the '#{p}'" do + @object.send(:Float, "0x1.8#{p}0").should == 1.5 + end + + it "raises an ArgumentError if there's a decimal point on the right side of the '#{p}'" do + -> { @object.send(:Float, "0x1#{p}1.0") }.should.raise(ArgumentError) + end end end end @@ -294,34 +344,34 @@ describe :kernel_float, shared: true do nan = nan_value (nan_to_f = mock('NaN')).should_receive(:to_f).once.and_return(nan) nan2 = @object.send(:Float, nan_to_f) - nan2.nan?.should be_true - nan2.should equal(nan) + nan2.nan?.should == true + nan2.should.equal?(nan) end it "returns the identical Infinity if #to_f is called and it returns Infinity" do infinity = infinity_value (infinity_to_f = mock('Infinity')).should_receive(:to_f).once.and_return(infinity) infinity2 = @object.send(:Float, infinity_to_f) - infinity2.should equal(infinity) + infinity2.should.equal?(infinity) end it "raises a TypeError if #to_f is not provided" do - -> { @object.send(:Float, mock('x')) }.should raise_error(TypeError) + -> { @object.send(:Float, mock('x')) }.should.raise(TypeError) end it "raises a TypeError if #to_f returns a String" do (obj = mock('ha!')).should_receive(:to_f).once.and_return('ha!') - -> { @object.send(:Float, obj) }.should raise_error(TypeError) + -> { @object.send(:Float, obj) }.should.raise(TypeError) end it "raises a TypeError if #to_f returns an Integer" do (obj = mock('123')).should_receive(:to_f).once.and_return(123) - -> { @object.send(:Float, obj) }.should raise_error(TypeError) + -> { @object.send(:Float, obj) }.should.raise(TypeError) end it "raises a RangeError when passed a Complex argument" do c = Complex(2, 3) - -> { @object.send(:Float, c) }.should raise_error(RangeError) + -> { @object.send(:Float, c) }.should.raise(RangeError) end describe "when passed exception: false" do @@ -358,6 +408,6 @@ end describe "Kernel#Float" do it "is a private method" do - Kernel.should have_private_instance_method(:Float) + Kernel.private_instance_methods(false).should.include?(:Float) end end diff --git a/spec/ruby/core/kernel/Hash_spec.rb b/spec/ruby/core/kernel/Hash_spec.rb index cbe098a8ac..ee16f56a90 100644 --- a/spec/ruby/core/kernel/Hash_spec.rb +++ b/spec/ruby/core/kernel/Hash_spec.rb @@ -13,7 +13,7 @@ end describe "Kernel" do it "has private instance method Hash()" do - Kernel.should have_private_instance_method(:Hash) + Kernel.private_instance_methods(false).should.include?(:Hash) end end @@ -43,14 +43,14 @@ describe :kernel_Hash, shared: true do end it "raises a TypeError if it doesn't respond to #to_hash" do - -> { @object.send(@method, mock("")) }.should raise_error(TypeError) + -> { @object.send(@method, mock("")) }.should.raise(TypeError) end it "raises a TypeError if #to_hash does not return an Hash" do obj = mock("Hash() string") obj.should_receive(:to_hash).and_return("string") - -> { @object.send(@method, obj) }.should raise_error(TypeError) + -> { @object.send(@method, obj) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/kernel/Integer_spec.rb b/spec/ruby/core/kernel/Integer_spec.rb index 74dd3e0dd2..978fd8ef08 100644 --- a/spec/ruby/core/kernel/Integer_spec.rb +++ b/spec/ruby/core/kernel/Integer_spec.rb @@ -14,7 +14,9 @@ describe :kernel_integer, shared: true do obj = mock("object") obj.should_receive(:to_int).and_return("1") obj.should_receive(:to_i).and_return(nil) - -> { Integer(obj) }.should raise_error(TypeError) + -> { + Integer(obj) + }.should raise_consistent_error(TypeError, "can't convert MockObject into Integer (MockObject#to_i gives nil)") end it "return a result of to_i when to_int does not return an Integer" do @@ -24,13 +26,36 @@ describe :kernel_integer, shared: true do Integer(obj).should == 42 end + it "returns a result of to_str" do + obj = mock("obj") + obj.should_receive(:to_str).and_return("1") + + Integer(obj).should == 1 + end + + it "returns a result of to_int when both to_int and to_str are defined" do + obj = mock("obj") + obj.should_receive(:to_int).and_return(1) + obj.should_not_receive(:to_str) + + Integer(obj).should == 1 + end + + it "returns a result of to_str when both to_str and to_i are defined" do + obj = mock("obj") + obj.should_receive(:to_str).and_return("1") + obj.should_not_receive(:to_i) + + Integer(obj).should == 1 + end + it "raises a TypeError when passed nil" do - -> { Integer(nil) }.should raise_error(TypeError) + -> { Integer(nil) }.should.raise(TypeError, "can't convert nil into Integer") end it "returns an Integer object" do - Integer(2).should be_an_instance_of(Integer) - Integer(9**99).should be_an_instance_of(Integer) + Integer(2).should.instance_of?(Integer) + Integer(9**99).should.instance_of?(Integer) end it "truncates Floats" do @@ -67,26 +92,32 @@ describe :kernel_integer, shared: true do it "raises a TypeError if to_i returns a value that is not an Integer" do obj = mock("object") obj.should_receive(:to_i).and_return("1") - -> { Integer(obj) }.should raise_error(TypeError) + -> { + Integer(obj) + }.should raise_consistent_error(TypeError, "can't convert MockObject into Integer (MockObject#to_i gives String)") end it "raises a TypeError if no to_int or to_i methods exist" do obj = mock("object") - -> { Integer(obj) }.should raise_error(TypeError) + -> { + Integer(obj) + }.should.raise(TypeError, "can't convert MockObject into Integer") end it "raises a TypeError if to_int returns nil and no to_i exists" do obj = mock("object") obj.should_receive(:to_i).and_return(nil) - -> { Integer(obj) }.should raise_error(TypeError) + -> { + Integer(obj) + }.should raise_consistent_error(TypeError, "can't convert MockObject into Integer (MockObject#to_i gives nil)") end it "raises a FloatDomainError when passed NaN" do - -> { Integer(nan_value) }.should raise_error(FloatDomainError) + -> { Integer(nan_value) }.should.raise(FloatDomainError) end it "raises a FloatDomainError when passed Infinity" do - -> { Integer(infinity_value) }.should raise_error(FloatDomainError) + -> { Integer(infinity_value) }.should.raise(FloatDomainError) end describe "when passed exception: false" do @@ -147,19 +178,19 @@ end describe :kernel_integer_string, shared: true do it "raises an ArgumentError if the String is a null byte" do - -> { Integer("\0") }.should raise_error(ArgumentError) + -> { Integer("\0") }.should.raise(ArgumentError) end it "raises an ArgumentError if the String starts with a null byte" do - -> { Integer("\01") }.should raise_error(ArgumentError) + -> { Integer("\01") }.should.raise(ArgumentError) end it "raises an ArgumentError if the String ends with a null byte" do - -> { Integer("1\0") }.should raise_error(ArgumentError) + -> { Integer("1\0") }.should.raise(ArgumentError) end it "raises an ArgumentError if the String contains a null byte" do - -> { Integer("1\01") }.should raise_error(ArgumentError) + -> { Integer("1\01") }.should.raise(ArgumentError) end it "ignores leading whitespace" do @@ -175,13 +206,13 @@ describe :kernel_integer_string, shared: true do end it "raises an ArgumentError if there are leading _s" do - -> { Integer("_1") }.should raise_error(ArgumentError) - -> { Integer("___1") }.should raise_error(ArgumentError) + -> { Integer("_1") }.should.raise(ArgumentError) + -> { Integer("___1") }.should.raise(ArgumentError) end it "raises an ArgumentError if there are trailing _s" do - -> { Integer("1_") }.should raise_error(ArgumentError) - -> { Integer("1___") }.should raise_error(ArgumentError) + -> { Integer("1_") }.should.raise(ArgumentError) + -> { Integer("1___") }.should.raise(ArgumentError) end it "ignores an embedded _" do @@ -189,8 +220,8 @@ describe :kernel_integer_string, shared: true do end it "raises an ArgumentError if there are multiple embedded _s" do - -> { Integer("1__1") }.should raise_error(ArgumentError) - -> { Integer("1___1") }.should raise_error(ArgumentError) + -> { Integer("1__1") }.should.raise(ArgumentError) + -> { Integer("1___1") }.should.raise(ArgumentError) end it "ignores a single leading +" do @@ -198,17 +229,17 @@ describe :kernel_integer_string, shared: true do end it "raises an ArgumentError if there is a space between the + and number" do - -> { Integer("+ 1") }.should raise_error(ArgumentError) + -> { Integer("+ 1") }.should.raise(ArgumentError) end it "raises an ArgumentError if there are multiple leading +s" do - -> { Integer("++1") }.should raise_error(ArgumentError) - -> { Integer("+++1") }.should raise_error(ArgumentError) + -> { Integer("++1") }.should.raise(ArgumentError) + -> { Integer("+++1") }.should.raise(ArgumentError) end it "raises an ArgumentError if there are trailing +s" do - -> { Integer("1+") }.should raise_error(ArgumentError) - -> { Integer("1+++") }.should raise_error(ArgumentError) + -> { Integer("1+") }.should.raise(ArgumentError) + -> { Integer("1+++") }.should.raise(ArgumentError) end it "makes the number negative if there's a leading -" do @@ -216,21 +247,21 @@ describe :kernel_integer_string, shared: true do end it "raises an ArgumentError if there are multiple leading -s" do - -> { Integer("--1") }.should raise_error(ArgumentError) - -> { Integer("---1") }.should raise_error(ArgumentError) + -> { Integer("--1") }.should.raise(ArgumentError) + -> { Integer("---1") }.should.raise(ArgumentError) end it "raises an ArgumentError if there are trailing -s" do - -> { Integer("1-") }.should raise_error(ArgumentError) - -> { Integer("1---") }.should raise_error(ArgumentError) + -> { Integer("1-") }.should.raise(ArgumentError) + -> { Integer("1---") }.should.raise(ArgumentError) end it "raises an ArgumentError if there is a period" do - -> { Integer("0.0") }.should raise_error(ArgumentError) + -> { Integer("0.0") }.should.raise(ArgumentError) end it "raises an ArgumentError for an empty String" do - -> { Integer("") }.should raise_error(ArgumentError) + -> { Integer("") }.should.raise(ArgumentError) end describe "when passed exception: false" do @@ -280,7 +311,7 @@ describe :kernel_integer_string, shared: true do end it "raises an ArgumentError if the number cannot be parsed as hex" do - -> { Integer("0#{x}g") }.should raise_error(ArgumentError) + -> { Integer("0#{x}g") }.should.raise(ArgumentError) end end @@ -301,7 +332,7 @@ describe :kernel_integer_string, shared: true do end it "raises an ArgumentError if the number cannot be parsed as binary" do - -> { Integer("0#{b}2") }.should raise_error(ArgumentError) + -> { Integer("0#{b}2") }.should.raise(ArgumentError) end end @@ -322,7 +353,7 @@ describe :kernel_integer_string, shared: true do end it "raises an ArgumentError if the number cannot be parsed as octal" do - -> { Integer("0#{o}9") }.should raise_error(ArgumentError) + -> { Integer("0#{o}9") }.should.raise(ArgumentError) end end @@ -343,26 +374,26 @@ describe :kernel_integer_string, shared: true do end it "raises an ArgumentError if the number cannot be parsed as decimal" do - -> { Integer("0#{d}a") }.should raise_error(ArgumentError) + -> { Integer("0#{d}a") }.should.raise(ArgumentError) end end end describe :kernel_integer_string_base, shared: true do it "raises an ArgumentError if the String is a null byte" do - -> { Integer("\0", 2) }.should raise_error(ArgumentError) + -> { Integer("\0", 2) }.should.raise(ArgumentError) end it "raises an ArgumentError if the String starts with a null byte" do - -> { Integer("\01", 3) }.should raise_error(ArgumentError) + -> { Integer("\01", 3) }.should.raise(ArgumentError) end it "raises an ArgumentError if the String ends with a null byte" do - -> { Integer("1\0", 4) }.should raise_error(ArgumentError) + -> { Integer("1\0", 4) }.should.raise(ArgumentError) end it "raises an ArgumentError if the String contains a null byte" do - -> { Integer("1\01", 5) }.should raise_error(ArgumentError) + -> { Integer("1\01", 5) }.should.raise(ArgumentError) end it "ignores leading whitespace" do @@ -378,13 +409,13 @@ describe :kernel_integer_string_base, shared: true do end it "raises an ArgumentError if there are leading _s" do - -> { Integer("_1", 7) }.should raise_error(ArgumentError) - -> { Integer("___1", 7) }.should raise_error(ArgumentError) + -> { Integer("_1", 7) }.should.raise(ArgumentError) + -> { Integer("___1", 7) }.should.raise(ArgumentError) end it "raises an ArgumentError if there are trailing _s" do - -> { Integer("1_", 12) }.should raise_error(ArgumentError) - -> { Integer("1___", 12) }.should raise_error(ArgumentError) + -> { Integer("1_", 12) }.should.raise(ArgumentError) + -> { Integer("1___", 12) }.should.raise(ArgumentError) end it "ignores an embedded _" do @@ -392,8 +423,8 @@ describe :kernel_integer_string_base, shared: true do end it "raises an ArgumentError if there are multiple embedded _s" do - -> { Integer("1__1", 4) }.should raise_error(ArgumentError) - -> { Integer("1___1", 4) }.should raise_error(ArgumentError) + -> { Integer("1__1", 4) }.should.raise(ArgumentError) + -> { Integer("1___1", 4) }.should.raise(ArgumentError) end it "ignores a single leading +" do @@ -401,17 +432,17 @@ describe :kernel_integer_string_base, shared: true do end it "raises an ArgumentError if there is a space between the + and number" do - -> { Integer("+ 1", 3) }.should raise_error(ArgumentError) + -> { Integer("+ 1", 3) }.should.raise(ArgumentError) end it "raises an ArgumentError if there are multiple leading +s" do - -> { Integer("++1", 3) }.should raise_error(ArgumentError) - -> { Integer("+++1", 3) }.should raise_error(ArgumentError) + -> { Integer("++1", 3) }.should.raise(ArgumentError) + -> { Integer("+++1", 3) }.should.raise(ArgumentError) end it "raises an ArgumentError if there are trailing +s" do - -> { Integer("1+", 3) }.should raise_error(ArgumentError) - -> { Integer("1+++", 12) }.should raise_error(ArgumentError) + -> { Integer("1+", 3) }.should.raise(ArgumentError) + -> { Integer("1+++", 12) }.should.raise(ArgumentError) end it "makes the number negative if there's a leading -" do @@ -419,29 +450,29 @@ describe :kernel_integer_string_base, shared: true do end it "raises an ArgumentError if there are multiple leading -s" do - -> { Integer("--1", 9) }.should raise_error(ArgumentError) - -> { Integer("---1", 9) }.should raise_error(ArgumentError) + -> { Integer("--1", 9) }.should.raise(ArgumentError) + -> { Integer("---1", 9) }.should.raise(ArgumentError) end it "raises an ArgumentError if there are trailing -s" do - -> { Integer("1-", 12) }.should raise_error(ArgumentError) - -> { Integer("1---", 12) }.should raise_error(ArgumentError) + -> { Integer("1-", 12) }.should.raise(ArgumentError) + -> { Integer("1---", 12) }.should.raise(ArgumentError) end it "raises an ArgumentError if there is a period" do - -> { Integer("0.0", 3) }.should raise_error(ArgumentError) + -> { Integer("0.0", 3) }.should.raise(ArgumentError) end it "raises an ArgumentError for an empty String" do - -> { Integer("", 12) }.should raise_error(ArgumentError) + -> { Integer("", 12) }.should.raise(ArgumentError) end it "raises an ArgumentError for a base of 1" do - -> { Integer("1", 1) }.should raise_error(ArgumentError) + -> { Integer("1", 1) }.should.raise(ArgumentError) end it "raises an ArgumentError for a base of 37" do - -> { Integer("1", 37) }.should raise_error(ArgumentError) + -> { Integer("1", 37) }.should.raise(ArgumentError) end it "accepts wholly lowercase alphabetic strings for bases > 10" do @@ -469,8 +500,8 @@ describe :kernel_integer_string_base, shared: true do end it "raises an ArgumentError for letters invalid in the given base" do - -> { Integer('z',19) }.should raise_error(ArgumentError) - -> { Integer('c00o',2) }.should raise_error(ArgumentError) + -> { Integer('z',19) }.should.raise(ArgumentError) + -> { Integer('c00o',2) }.should.raise(ArgumentError) end %w(x X).each do |x| @@ -491,12 +522,12 @@ describe :kernel_integer_string_base, shared: true do 2.upto(15) do |base| it "raises an ArgumentError if the number begins with 0#{x} and the base is #{base}" do - -> { Integer("0#{x}1", base) }.should raise_error(ArgumentError) + -> { Integer("0#{x}1", base) }.should.raise(ArgumentError) end end it "raises an ArgumentError if the number cannot be parsed as hex and the base is 16" do - -> { Integer("0#{x}g", 16) }.should raise_error(ArgumentError) + -> { Integer("0#{x}g", 16) }.should.raise(ArgumentError) end end @@ -517,7 +548,7 @@ describe :kernel_integer_string_base, shared: true do end it "raises an ArgumentError if the number cannot be parsed as binary and the base is 2" do - -> { Integer("0#{b}2", 2) }.should raise_error(ArgumentError) + -> { Integer("0#{b}2", 2) }.should.raise(ArgumentError) end end @@ -538,12 +569,12 @@ describe :kernel_integer_string_base, shared: true do end it "raises an ArgumentError if the number cannot be parsed as octal and the base is 8" do - -> { Integer("0#{o}9", 8) }.should raise_error(ArgumentError) + -> { Integer("0#{o}9", 8) }.should.raise(ArgumentError) end 2.upto(7) do |base| it "raises an ArgumentError if the number begins with 0#{o} and the base is #{base}" do - -> { Integer("0#{o}1", base) }.should raise_error(ArgumentError) + -> { Integer("0#{o}1", base) }.should.raise(ArgumentError) end end end @@ -565,18 +596,18 @@ describe :kernel_integer_string_base, shared: true do end it "raises an ArgumentError if the number cannot be parsed as decimal and the base is 10" do - -> { Integer("0#{d}a", 10) }.should raise_error(ArgumentError) + -> { Integer("0#{d}a", 10) }.should.raise(ArgumentError) end 2.upto(9) do |base| it "raises an ArgumentError if the number begins with 0#{d} and the base is #{base}" do - -> { Integer("0#{d}1", base) }.should raise_error(ArgumentError) + -> { Integer("0#{d}1", base) }.should.raise(ArgumentError) end end end it "raises an ArgumentError if a base is given for a non-String value" do - -> { Integer(98, 15) }.should raise_error(ArgumentError) + -> { Integer(98, 15) }.should.raise(ArgumentError, "base specified for non string value") end it "tries to convert the base to an integer using to_int" do @@ -586,19 +617,10 @@ describe :kernel_integer_string_base, shared: true do Integer("777", obj).should == 0777 end - # https://bugs.ruby-lang.org/issues/19349 - ruby_version_is ''...'3.3' do - it "ignores the base if it is not an integer and does not respond to #to_i" do - Integer("777", "8").should == 777 - end - end - - ruby_version_is '3.3' do - it "raises a TypeError if it is not an integer and does not respond to #to_i" do - -> { - Integer("777", "8") - }.should raise_error(TypeError, "no implicit conversion of String into Integer") - end + it "raises a TypeError if it is not an integer and does not respond to #to_i" do + -> { + Integer("777", "8") + }.should.raise(TypeError, "no implicit conversion of String into Integer") end describe "when passed exception: false" do @@ -621,176 +643,176 @@ end describe :kernel_Integer, shared: true do it "raises an ArgumentError when the String contains digits out of range of radix 2" do str = "23456789abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 2) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 2) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 3" do str = "3456789abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 3) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 3) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 4" do str = "456789abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 4) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 4) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 5" do str = "56789abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 5) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 5) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 6" do str = "6789abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 6) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 6) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 7" do str = "789abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 7) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 7) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 8" do str = "89abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 8) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 8) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 9" do str = "9abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 9) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 9) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 10" do str = "abcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 10) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 10) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 11" do str = "bcdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 11) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 11) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 12" do str = "cdefghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 12) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 12) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 13" do str = "defghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 13) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 13) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 14" do str = "efghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 14) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 14) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 15" do str = "fghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 15) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 15) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 16" do str = "ghijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 16) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 16) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 17" do str = "hijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 17) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 17) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 18" do str = "ijklmnopqrstuvwxyz" - -> { @object.send(@method, str, 18) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 18) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 19" do str = "jklmnopqrstuvwxyz" - -> { @object.send(@method, str, 19) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 19) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 20" do str = "klmnopqrstuvwxyz" - -> { @object.send(@method, str, 20) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 20) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 21" do str = "lmnopqrstuvwxyz" - -> { @object.send(@method, str, 21) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 21) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 22" do str = "mnopqrstuvwxyz" - -> { @object.send(@method, str, 22) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 22) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 23" do str = "nopqrstuvwxyz" - -> { @object.send(@method, str, 23) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 23) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 24" do str = "opqrstuvwxyz" - -> { @object.send(@method, str, 24) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 24) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 25" do str = "pqrstuvwxyz" - -> { @object.send(@method, str, 25) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 25) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 26" do str = "qrstuvwxyz" - -> { @object.send(@method, str, 26) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 26) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 27" do str = "rstuvwxyz" - -> { @object.send(@method, str, 27) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 27) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 28" do str = "stuvwxyz" - -> { @object.send(@method, str, 28) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 28) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 29" do str = "tuvwxyz" - -> { @object.send(@method, str, 29) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 29) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 30" do str = "uvwxyz" - -> { @object.send(@method, str, 30) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 30) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 31" do str = "vwxyz" - -> { @object.send(@method, str, 31) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 31) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 32" do str = "wxyz" - -> { @object.send(@method, str, 32) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 32) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 33" do str = "xyz" - -> { @object.send(@method, str, 33) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 33) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 34" do str = "yz" - -> { @object.send(@method, str, 34) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 34) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 35" do str = "z" - -> { @object.send(@method, str, 35) }.should raise_error(ArgumentError) + -> { @object.send(@method, str, 35) }.should.raise(ArgumentError) end it "raises an ArgumentError when the String contains digits out of range of radix 36" do - -> { @object.send(@method, "{", 36) }.should raise_error(ArgumentError) + -> { @object.send(@method, "{", 36) }.should.raise(ArgumentError) end end @@ -818,6 +840,6 @@ describe "Kernel#Integer" do it_behaves_like :kernel_integer_string_base, :Integer it "is a private method" do - Kernel.should have_private_instance_method(:Integer) + Kernel.private_instance_methods(false).should.include?(:Integer) end end diff --git a/spec/ruby/core/kernel/Rational_spec.rb b/spec/ruby/core/kernel/Rational_spec.rb index 841c8e8c64..b13ab4cf55 100644 --- a/spec/ruby/core/kernel/Rational_spec.rb +++ b/spec/ruby/core/kernel/Rational_spec.rb @@ -6,9 +6,9 @@ describe "Kernel.Rational" do # Guard against the Mathn library guard -> { !defined?(Math.rsqrt) } do it "returns a new Rational number with 1 as the denominator" do - Rational(1).should eql(Rational(1, 1)) - Rational(-3).should eql(Rational(-3, 1)) - Rational(bignum_value).should eql(Rational(bignum_value, 1)) + Rational(1).should.eql?(Rational(1, 1)) + Rational(-3).should.eql?(Rational(-3, 1)) + Rational(bignum_value).should.eql?(Rational(bignum_value, 1)) end end end @@ -18,17 +18,17 @@ describe "Kernel.Rational" do rat = Rational(1, 2) rat.numerator.should == 1 rat.denominator.should == 2 - rat.should be_an_instance_of(Rational) + rat.should.instance_of?(Rational) rat = Rational(-3, -5) rat.numerator.should == 3 rat.denominator.should == 5 - rat.should be_an_instance_of(Rational) + rat.should.instance_of?(Rational) rat = Rational(bignum_value, 3) rat.numerator.should == bignum_value rat.denominator.should == 3 - rat.should be_an_instance_of(Rational) + rat.should.instance_of?(Rational) end it "reduces the Rational" do @@ -76,34 +76,84 @@ describe "Kernel.Rational" do end describe "when passed a Complex" do - it "returns a Rational from the real part if the imaginary part is 0" do - Rational(Complex(1, 0)).should == Rational(1) + context "[Complex]" do + it "returns a Rational from the real part if the imaginary part is 0" do + Rational(Complex(1, 0)).should == Rational(1) + end + + it "raises a RangeError if the imaginary part is not 0" do + -> { Rational(Complex(1, 2)) }.should.raise(RangeError, "can't convert 1+2i into Rational") + end end - it "raises a RangeError if the imaginary part is not 0" do - -> { Rational(Complex(1, 2)) }.should raise_error(RangeError) + context "[Numeric, Complex]" do + it "uses the real part if the imaginary part is 0" do + Rational(1, Complex(2, 0)).should == Rational(1, 2) + end + + it "divides a numerator by the Complex denominator if the imaginary part is not 0" do + Rational(1, Complex(2, 1)).should == Complex(2/5r, -1/5r) + end + end + end + + context "when passed neither a Numeric nor a String" do + it "converts to Rational with #to_r method" do + obj = Object.new + def obj.to_r; 1/2r; end + + Rational(obj).should == 1/2r + end + + it "tries to convert to Integer with #to_int method if it does not respond to #to_r" do + obj = Object.new + def obj.to_int; 1; end + + Rational(obj).should == 1r + end + + it "raises TypeError if it neither responds to #to_r nor #to_int method" do + -> { Rational([]) }.should.raise(TypeError, "can't convert Array into Rational") + -> { Rational({}) }.should.raise(TypeError, "can't convert Hash into Rational") + -> { Rational(nil) }.should.raise(TypeError, "can't convert nil into Rational") + end + + it "swallows exception raised in #to_int method" do + object = Object.new + def object.to_int() raise NoMethodError; end + + -> { Rational(object) }.should.raise(TypeError) + -> { Rational(object, 1) }.should.raise(TypeError) + -> { Rational(1, object) }.should.raise(TypeError) + end + + it "raises TypeError if #to_r does not return Rational" do + obj = Object.new + def obj.to_r; []; end + + -> { Rational(obj) }.should raise_consistent_error(TypeError, "can't convert Object into Rational (Object#to_r gives Array)") end end it "raises a ZeroDivisionError if the second argument is 0" do - -> { Rational(1, 0) }.should raise_error(ZeroDivisionError, "divided by 0") - -> { Rational(1, 0.0) }.should raise_error(ZeroDivisionError, "divided by 0") + -> { Rational(1, 0) }.should.raise(ZeroDivisionError, "divided by 0") + -> { Rational(1, 0.0) }.should.raise(ZeroDivisionError, "divided by 0") end it "raises a TypeError if the first argument is nil" do - -> { Rational(nil) }.should raise_error(TypeError) + -> { Rational(nil) }.should.raise(TypeError, "can't convert nil into Rational") end it "raises a TypeError if the second argument is nil" do - -> { Rational(1, nil) }.should raise_error(TypeError) + -> { Rational(1, nil) }.should.raise(TypeError, "can't convert nil into Rational") end it "raises a TypeError if the first argument is a Symbol" do - -> { Rational(:sym) }.should raise_error(TypeError) + -> { Rational(:sym) }.should.raise(TypeError) end it "raises a TypeError if the second argument is a Symbol" do - -> { Rational(1, :sym) }.should raise_error(TypeError) + -> { Rational(1, :sym) }.should.raise(TypeError) end describe "when passed exception: false" do @@ -112,6 +162,18 @@ describe "Kernel.Rational" do Rational(:sym, exception: false).should == nil Rational("abc", exception: false).should == nil end + + it "swallows an exception raised in #to_r" do + obj = Object.new + def obj.to_r; raise; end + Rational(obj, exception: false).should == nil + end + + it "swallows an exception raised in #to_int" do + obj = Object.new + def obj.to_int; raise; end + Rational(obj, exception: false).should == nil + end end describe "and [non-Numeric, Numeric]" do @@ -119,6 +181,18 @@ describe "Kernel.Rational" do Rational(:sym, 1, exception: false).should == nil Rational("abc", 1, exception: false).should == nil end + + it "swallows an exception raised in #to_r" do + obj = Object.new + def obj.to_r; raise; end + Rational(obj, 1, exception: false).should == nil + end + + it "swallows an exception raised in #to_int" do + obj = Object.new + def obj.to_int; raise; end + Rational(obj, 1, exception: false).should == nil + end end describe "and [anything, non-Numeric]" do @@ -126,6 +200,18 @@ describe "Kernel.Rational" do Rational(:sym, :sym, exception: false).should == nil Rational("abc", :sym, exception: false).should == nil end + + it "swallows an exception raised in #to_r" do + obj = Object.new + def obj.to_r; raise; end + Rational(obj, obj, exception: false).should == nil + end + + it "swallows an exception raised in #to_int" do + obj = Object.new + def obj.to_int; raise; end + Rational(obj, obj, exception: false).should == nil + end end describe "and non-Numeric String arguments" do diff --git a/spec/ruby/core/kernel/String_spec.rb b/spec/ruby/core/kernel/String_spec.rb index 7caec6eda5..a9b0758ad7 100644 --- a/spec/ruby/core/kernel/String_spec.rb +++ b/spec/ruby/core/kernel/String_spec.rb @@ -32,7 +32,7 @@ describe :kernel_String, shared: true do undef_method :to_s end - -> { @object.send(@method, obj) }.should raise_error(TypeError) + -> { @object.send(@method, obj) }.should.raise(TypeError) end # #5158 @@ -44,7 +44,7 @@ describe :kernel_String, shared: true do end end - -> { @object.send(@method, obj) }.should raise_error(TypeError) + -> { @object.send(@method, obj) }.should.raise(TypeError) end it "raises a TypeError if #to_s is not defined, even though #respond_to?(:to_s) returns true" do @@ -57,7 +57,7 @@ describe :kernel_String, shared: true do end end - -> { @object.send(@method, obj) }.should raise_error(TypeError) + -> { @object.send(@method, obj) }.should.raise(TypeError) end it "calls #to_s if #respond_to?(:to_s) returns true" do @@ -74,14 +74,14 @@ describe :kernel_String, shared: true do it "raises a TypeError if #to_s does not return a String" do (obj = mock('123')).should_receive(:to_s).and_return(123) - -> { @object.send(@method, obj) }.should raise_error(TypeError) + -> { @object.send(@method, obj) }.should.raise(TypeError) end it "returns the same object if it is already a String" do string = +"Hello" string.should_not_receive(:to_s) string2 = @object.send(@method, string) - string.should equal(string2) + string.should.equal?(string2) end it "returns the same object if it is an instance of a String subclass" do @@ -89,7 +89,7 @@ describe :kernel_String, shared: true do string = subklass.new("Hello") string.should_not_receive(:to_s) string2 = @object.send(@method, string) - string.should equal(string2) + string.should.equal?(string2) end end @@ -101,6 +101,6 @@ describe "Kernel#String" do it_behaves_like :kernel_String, :String, Object.new it "is a private method" do - Kernel.should have_private_instance_method(:String) + Kernel.private_instance_methods(false).should.include?(:String) end end diff --git a/spec/ruby/core/kernel/abort_spec.rb b/spec/ruby/core/kernel/abort_spec.rb index f8152718c5..b75138182d 100644 --- a/spec/ruby/core/kernel/abort_spec.rb +++ b/spec/ruby/core/kernel/abort_spec.rb @@ -4,7 +4,7 @@ require_relative '../../shared/process/abort' describe "Kernel#abort" do it "is a private method" do - Kernel.should have_private_instance_method(:abort) + Kernel.private_instance_methods(false).should.include?(:abort) end it_behaves_like :process_abort, :abort, KernelSpecs::Method.new diff --git a/spec/ruby/core/kernel/at_exit_spec.rb b/spec/ruby/core/kernel/at_exit_spec.rb index ebd9a71d15..fdb0eaf34c 100644 --- a/spec/ruby/core/kernel/at_exit_spec.rb +++ b/spec/ruby/core/kernel/at_exit_spec.rb @@ -6,11 +6,11 @@ describe "Kernel.at_exit" do it_behaves_like :kernel_at_exit, :at_exit it "is a private method" do - Kernel.should have_private_instance_method(:at_exit) + Kernel.private_instance_methods(false).should.include?(:at_exit) end it "raises ArgumentError if called without a block" do - -> { at_exit }.should raise_error(ArgumentError, "called without a block") + -> { at_exit }.should.raise(ArgumentError, "called without a block") end end diff --git a/spec/ruby/core/kernel/autoload_relative_spec.rb b/spec/ruby/core/kernel/autoload_relative_spec.rb new file mode 100644 index 0000000000..7d03da8a40 --- /dev/null +++ b/spec/ruby/core/kernel/autoload_relative_spec.rb @@ -0,0 +1,114 @@ +require_relative '../../spec_helper' +require_relative 'fixtures/classes' + +# Specs for Kernel#autoload_relative + +ruby_version_is "4.1" do + describe "Kernel#autoload_relative" do + before :each do + @loaded_features = $".dup + end + + after :each do + $".replace @loaded_features + # Clean up constants defined by these tests + [:KSAutoloadRelativeA, :KSAutoloadRelativeB, :KSAutoloadRelativeC, + :KSAutoloadRelativeE, :KSAutoloadRelativeF, :KSAutoloadRelativeG, + :KSAutoloadRelativeH, :KSAutoloadRelativeI].each do |const| + KernelSpecs.send(:remove_const, const) if KernelSpecs.const_defined?(const, false) + end + [:KSAutoloadRelativeD, :NestedTest].each do |const| + Object.send(:remove_const, const) if Object.const_defined?(const, false) + end + end + + it "is a private method" do + Kernel.private_instance_methods(false).should.include?(:autoload_relative) + end + + it "registers a file to load relative to the current file" do + KernelSpecs.autoload_relative :KSAutoloadRelativeA, "fixtures/autoload_relative_b.rb" + path = KernelSpecs.autoload?(:KSAutoloadRelativeA) + path.should_not == nil + path.should.end_with?("autoload_relative_b.rb") + File.exist?(path).should == true + end + + it "loads the file when the constant is accessed" do + KernelSpecs.autoload_relative :KSAutoloadRelativeB, "fixtures/autoload_relative_b.rb" + KernelSpecs::KSAutoloadRelativeB.loaded.should == :ksautoload_b + end + + it "sets the autoload constant in the constant table" do + KernelSpecs.autoload_relative :KSAutoloadRelativeC, "fixtures/autoload_relative_b.rb" + KernelSpecs.should.const_defined?(:KSAutoloadRelativeC, false) + end + + it "can autoload in instance_eval with a file context" do + result = Object.new.instance_eval(<<-CODE, __FILE__, __LINE__) + autoload_relative :KSAutoloadRelativeD, "fixtures/autoload_relative_d.rb" + KSAutoloadRelativeD.loaded + CODE + result.should == :ksautoload_d + end + + it "raises LoadError if called from eval without file context" do + -> { + eval('autoload_relative :Foo, "foo.rb"') + }.should.raise(LoadError, /autoload_relative called without file context/) + end + + it "accepts both string and symbol for constant name" do + KernelSpecs.autoload_relative :KSAutoloadRelativeE, "fixtures/autoload_relative_b.rb" + KernelSpecs.autoload_relative "KSAutoloadRelativeF", "fixtures/autoload_relative_b.rb" + + KernelSpecs.should.const_defined?(:KSAutoloadRelativeE, false) + KernelSpecs.should.const_defined?(:KSAutoloadRelativeF, false) + end + + it "returns nil" do + KernelSpecs.autoload_relative(:KSAutoloadRelativeG, "fixtures/autoload_relative_b.rb").should == nil + end + + it "resolves nested directory paths correctly" do + -> { + autoload_relative :NestedTest, "../kernel/fixtures/autoload_relative_b.rb" + autoload?(:NestedTest) + }.should_not.raise + end + + it "resolves paths starting with ./" do + KernelSpecs.autoload_relative :KSAutoloadRelativeH, "./fixtures/autoload_relative_b.rb" + path = KernelSpecs.autoload?(:KSAutoloadRelativeH) + path.should_not == nil + path.should.end_with?("autoload_relative_b.rb") + end + + it "ignores $LOAD_PATH and uses only relative path resolution" do + original_load_path = $LOAD_PATH.dup + $LOAD_PATH.clear + begin + KernelSpecs.autoload_relative :KSAutoloadRelativeI, "fixtures/autoload_relative_b.rb" + path = KernelSpecs.autoload?(:KSAutoloadRelativeI) + path.should_not == nil + # Should still resolve even with empty $LOAD_PATH + File.exist?(path).should == true + ensure + $LOAD_PATH.replace(original_load_path) + end + end + + describe "when Object is frozen" do + it "raises a FrozenError before defining the constant" do + ruby_exe(<<-RUBY).should.include?("FrozenError") + Object.freeze + begin + autoload_relative :Foo, "autoload_b.rb" + rescue => e + puts e.class + end + RUBY + end + end + end +end diff --git a/spec/ruby/core/kernel/autoload_spec.rb b/spec/ruby/core/kernel/autoload_spec.rb index 0404caec6d..46783734c4 100644 --- a/spec/ruby/core/kernel/autoload_spec.rb +++ b/spec/ruby/core/kernel/autoload_spec.rb @@ -7,7 +7,9 @@ require_relative 'fixtures/classes' autoload :KSAutoloadA, "autoload_a.rb" autoload :KSAutoloadB, fixture(__FILE__, "autoload_b.rb") -autoload :KSAutoloadCallsRequire, "main_autoload_not_exist.rb" +define_autoload_KSAutoloadCallsRequire = -> { + autoload :KSAutoloadCallsRequire, "main_autoload_not_exist.rb" +} def check_autoload(const) autoload? const @@ -23,7 +25,7 @@ describe "Kernel#autoload" do end it "is a private method" do - Kernel.should have_private_instance_method(:autoload) + Kernel.private_instance_methods(false).should.include?(:autoload) end it "registers a file to load the first time the named constant is accessed" do @@ -35,7 +37,7 @@ describe "Kernel#autoload" do end it "sets the autoload constant in Object's constant table" do - Object.should have_constant(:KSAutoloadA) + Object.should.const_defined?(:KSAutoloadA, false) end it "loads the file when the constant is accessed" do @@ -43,10 +45,11 @@ describe "Kernel#autoload" do end it "calls main.require(path) to load the file" do + define_autoload_KSAutoloadCallsRequire.call main = TOPLEVEL_BINDING.eval("self") main.should_receive(:require).with("main_autoload_not_exist.rb") # The constant won't be defined since require is mocked to do nothing - -> { KSAutoloadCallsRequire }.should raise_error(NameError) + -> { KSAutoloadCallsRequire }.should.raise(NameError) end it "can autoload in instance_eval" do @@ -99,7 +102,7 @@ end describe "Kernel#autoload?" do it "is a private method" do - Kernel.should have_private_instance_method(:autoload?) + Kernel.private_instance_methods(false).should.include?(:autoload?) end it "returns the name of the file that will be autoloaded" do @@ -107,7 +110,7 @@ describe "Kernel#autoload?" do end it "returns nil if no file has been registered for a constant" do - check_autoload(:Manualload).should be_nil + check_autoload(:Manualload).should == nil end end @@ -134,7 +137,7 @@ describe "Kernel.autoload" do end it "sets the autoload constant in Object's constant table" do - Object.should have_constant(:KSAutoloadBB) + Object.should.const_defined?(:KSAutoloadBB, false) end it "calls #to_path on non-String filenames" do @@ -170,6 +173,6 @@ describe "Kernel.autoload?" do end it "returns nil if no file has been registered for a constant" do - Kernel.autoload?(:Manualload).should be_nil + Kernel.autoload?(:Manualload).should == nil end end diff --git a/spec/ruby/core/kernel/backtick_spec.rb b/spec/ruby/core/kernel/backtick_spec.rb index 834d5636c1..42e0f975f5 100644 --- a/spec/ruby/core/kernel/backtick_spec.rb +++ b/spec/ruby/core/kernel/backtick_spec.rb @@ -11,7 +11,7 @@ describe "Kernel#`" do end it "is a private method" do - Kernel.should have_private_instance_method(:`) + Kernel.private_instance_methods(false).should.include?(:`) end it "returns the standard output of the executed sub-process" do @@ -28,11 +28,11 @@ describe "Kernel#`" do it "produces a String in the default external encoding" do Encoding.default_external = Encoding::SHIFT_JIS - `echo disc`.encoding.should equal(Encoding::SHIFT_JIS) + `echo disc`.encoding.should.equal?(Encoding::SHIFT_JIS) end it "raises an Errno::ENOENT if the command is not executable" do - -> { `nonexistent_command` }.should raise_error(Errno::ENOENT) + -> { `nonexistent_command` }.should.raise(Errno::ENOENT) end platform_is_not :windows do @@ -43,13 +43,13 @@ describe "Kernel#`" do it "sets $? to the exit status of the executed sub-process" do ip = 'world' `echo disc #{ip}` - $?.should be_kind_of(Process::Status) + $?.should.is_a?(Process::Status) $?.should_not.stopped? $?.should.exited? $?.exitstatus.should == 0 $?.should.success? `echo disc #{ip}; exit 99` - $?.should be_kind_of(Process::Status) + $?.should.is_a?(Process::Status) $?.should_not.stopped? $?.should.exited? $?.exitstatus.should == 99 @@ -61,13 +61,13 @@ describe "Kernel#`" do it "sets $? to the exit status of the executed sub-process" do ip = 'world' `echo disc #{ip}` - $?.should be_kind_of(Process::Status) + $?.should.is_a?(Process::Status) $?.should_not.stopped? $?.should.exited? $?.exitstatus.should == 0 $?.should.success? `echo disc #{ip}& exit 99` - $?.should be_kind_of(Process::Status) + $?.should.is_a?(Process::Status) $?.should_not.stopped? $?.should.exited? $?.exitstatus.should == 99 diff --git a/spec/ruby/core/kernel/binding_spec.rb b/spec/ruby/core/kernel/binding_spec.rb index f1c9c6ec9f..6f27b26f37 100644 --- a/spec/ruby/core/kernel/binding_spec.rb +++ b/spec/ruby/core/kernel/binding_spec.rb @@ -9,7 +9,7 @@ end describe "Kernel#binding" do it "is a private method" do - Kernel.should have_private_instance_method(:binding) + Kernel.private_instance_methods(false).should.include?(:binding) end before :each do @@ -35,7 +35,7 @@ describe "Kernel#binding" do end it "raises a NameError on undefined variable" do - -> { eval("a_fake_variable", @b1) }.should raise_error(NameError) + -> { eval("a_fake_variable", @b1) }.should.raise(NameError) end it "uses the closure's self as self in the binding" do diff --git a/spec/ruby/core/kernel/block_given_spec.rb b/spec/ruby/core/kernel/block_given_spec.rb index aece4c821d..20bb90ae96 100644 --- a/spec/ruby/core/kernel/block_given_spec.rb +++ b/spec/ruby/core/kernel/block_given_spec.rb @@ -30,7 +30,7 @@ describe "Kernel#block_given?" do end it "is a private method" do - Kernel.should have_private_instance_method(:block_given?) + Kernel.private_instance_methods(false).should.include?(:block_given?) end end diff --git a/spec/ruby/core/kernel/caller_locations_spec.rb b/spec/ruby/core/kernel/caller_locations_spec.rb index aaacd9a910..04cf806ef4 100644 --- a/spec/ruby/core/kernel/caller_locations_spec.rb +++ b/spec/ruby/core/kernel/caller_locations_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/caller_locations' describe 'Kernel#caller_locations' do it 'is a private method' do - Kernel.should have_private_instance_method(:caller_locations) + Kernel.private_instance_methods(false).should.include?(:caller_locations) end it 'returns an Array of caller locations' do @@ -83,7 +83,7 @@ describe 'Kernel#caller_locations' do end end - ruby_version_is "3.4" do + ruby_version_is "3.4"..."4.0" do it "includes core library methods defined in Ruby" do file, line = Kernel.instance_method(:tap).source_location file.should.start_with?('<internal:') @@ -94,5 +94,20 @@ describe 'Kernel#caller_locations' do loc.path.should.start_with? "<internal:" end end + + ruby_version_is "4.0" do + it "does not include core library methods defined in Ruby" do + file, line = Kernel.instance_method(:tap).source_location + file.should.start_with?('<internal:') + + loc = nil + tap { loc = caller_locations(1, 1)[0] } + loc.label.should == "Kernel#tap" + # CRuby hides the file which defines the method: https://bugs.ruby-lang.org/issues/20968 + unless loc.path == __FILE__ + loc.path.should.start_with? "<internal:" + end + end + end end end diff --git a/spec/ruby/core/kernel/caller_spec.rb b/spec/ruby/core/kernel/caller_spec.rb index 33c7929a31..225f6fc458 100644 --- a/spec/ruby/core/kernel/caller_spec.rb +++ b/spec/ruby/core/kernel/caller_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/caller' describe 'Kernel#caller' do it 'is a private method' do - Kernel.should have_private_instance_method(:caller) + Kernel.private_instance_methods(false).should.include?(:caller) end it 'returns an Array of caller locations' do @@ -32,7 +32,7 @@ describe 'Kernel#caller' do locations = KernelSpecs::CallerTest.locations line = __LINE__ - 1 - locations[0].should include("#{__FILE__}:#{line}:in") + locations[0].should.include?("#{__FILE__}:#{line}:in") end it "returns an Array with the block given to #at_exit at the base of the stack" do @@ -84,13 +84,38 @@ describe 'Kernel#caller' do end guard -> { Kernel.instance_method(:tap).source_location } do - it "includes core library methods defined in Ruby" do - file, line = Kernel.instance_method(:tap).source_location - file.should.start_with?('<internal:') + ruby_version_is ""..."3.4" do + it "includes core library methods defined in Ruby" do + file, line = Kernel.instance_method(:tap).source_location + file.should.start_with?('<internal:') + + loc = nil + tap { loc = caller(1, 1)[0] } + loc.should =~ /\A<internal:.*in `tap'\z/ + end + end + + ruby_version_is "3.4"..."4.0" do + it "includes core library methods defined in Ruby" do + file, line = Kernel.instance_method(:tap).source_location + file.should.start_with?('<internal:') + + loc = nil + tap { loc = caller(1, 1)[0] } + loc.should =~ /\A<internal:.*in 'Kernel#tap'\z/ + end + end + + ruby_version_is "4.0" do + it "does not include core library methods defined in Ruby" do + file, line = Kernel.instance_method(:tap).source_location + file.should.start_with?('<internal:') - loc = nil - tap { loc = caller(1, 1)[0] } - loc.should =~ /\A<internal:.*in [`'](?:Kernel#)?tap'\z/ + loc = nil + tap { loc = caller(1, 1)[0] } + # CRuby hides the file which defines the method: https://bugs.ruby-lang.org/issues/20968 + loc.should =~ /\A(<internal:|#{__FILE__}:).*in 'Kernel#tap'\z/ + end end end end diff --git a/spec/ruby/core/kernel/case_compare_spec.rb b/spec/ruby/core/kernel/case_compare_spec.rb index b8d30960e8..c74bbf63b9 100644 --- a/spec/ruby/core/kernel/case_compare_spec.rb +++ b/spec/ruby/core/kernel/case_compare_spec.rb @@ -58,18 +58,18 @@ describe "Kernel#=== for a class with #== overridden to consider other object's end it "returns true if #== returns true even if #equal? is false" do - @o1.should_not equal(@o2) + @o1.should_not.equal?(@o2) (@o1 == @o2).should == true (@o1 === @o2).should == true end it "returns true if #equal? returns true" do - @o1.should equal(@o1) + @o1.should.equal?(@o1) (@o1 === @o1).should == true end it "returns false if neither #== nor #equal? returns true" do - @o1.should_not equal(@o) + @o1.should_not.equal?(@o) (@o1 == @o).should == false (@o1 === @o).should == false end @@ -83,13 +83,13 @@ describe "Kernel#=== for a class with #equal? overridden to always be false" do end it "returns true if #== returns true even if #equal? is false" do - @o1.should_not equal(@o1) + @o1.should_not.equal?(@o1) (@o1 == @o1).should == true (@o1 === @o1).should == true end it "returns false if neither #== nor #equal? returns true" do - @o1.should_not equal(@o) + @o1.should_not.equal?(@o) (@o1 == @o).should == false (@o1 === @o).should == false end @@ -105,7 +105,7 @@ describe "Kernel#=== for a class with #== and #equal? overridden to always be fa it "returns true if the object id is the same even if both #== and #equal? return false" do @o1.object_id.should == @o1.object_id - @o1.should_not equal(@o1) + @o1.should_not.equal?(@o1) (@o1 == @o1).should == false (@o1 === @o1).should == true @@ -114,7 +114,7 @@ describe "Kernel#=== for a class with #== and #equal? overridden to always be fa it "returns false if the object id is not the same and both #== and #equal? return false" do @o1.object_id.should_not == @o2.object_id - @o1.should_not equal(@o2) + @o1.should_not.equal?(@o2) (@o1 == @o2).should == false (@o1 === @o2).should == false diff --git a/spec/ruby/core/kernel/catch_spec.rb b/spec/ruby/core/kernel/catch_spec.rb index 9f59d3b384..9f02303678 100644 --- a/spec/ruby/core/kernel/catch_spec.rb +++ b/spec/ruby/core/kernel/catch_spec.rb @@ -31,11 +31,11 @@ describe "Kernel.catch" do end it "raises an ArgumentError if a Symbol is thrown for a String catch value" do - -> { catch("exit") { throw :exit } }.should raise_error(ArgumentError) + -> { catch("exit") { throw :exit } }.should.raise(ArgumentError) end it "raises an ArgumentError if a String with different identity is thrown" do - -> { catch("exit".dup) { throw "exit".dup } }.should raise_error(ArgumentError) + -> { catch("exit".dup) { throw "exit".dup } }.should.raise(ArgumentError) end it "catches a Symbol when thrown a matching Symbol" do @@ -60,7 +60,7 @@ describe "Kernel.catch" do end it "yields an object when called without arguments" do - catch { |tag| tag }.should be_an_instance_of(Object) + catch { |tag| tag }.should.instance_of?(Object) end it "can be used even in a method different from where throw is called" do @@ -116,12 +116,12 @@ describe "Kernel.catch" do end it "raises LocalJumpError if no block is given" do - -> { catch :blah }.should raise_error(LocalJumpError) + -> { catch :blah }.should.raise(LocalJumpError) end end describe "Kernel#catch" do it "is a private method" do - Kernel.should have_private_instance_method(:catch) + Kernel.private_instance_methods(false).should.include?(:catch) end end diff --git a/spec/ruby/core/kernel/chomp_spec.rb b/spec/ruby/core/kernel/chomp_spec.rb index d30e77c35a..434bf652f9 100644 --- a/spec/ruby/core/kernel/chomp_spec.rb +++ b/spec/ruby/core/kernel/chomp_spec.rb @@ -26,7 +26,7 @@ end describe :kernel_chomp_private, shared: true do it "is a private method" do - KernelSpecs.has_private_method(@method).should be_true + KernelSpecs.has_private_method(@method).should == true end end diff --git a/spec/ruby/core/kernel/chop_spec.rb b/spec/ruby/core/kernel/chop_spec.rb index 9b91c011bc..bbf3c3f724 100644 --- a/spec/ruby/core/kernel/chop_spec.rb +++ b/spec/ruby/core/kernel/chop_spec.rb @@ -14,7 +14,7 @@ end describe :kernel_chop_private, shared: true do it "is a private method" do - KernelSpecs.has_private_method(@method).should be_true + KernelSpecs.has_private_method(@method).should == true end end diff --git a/spec/ruby/core/kernel/class_spec.rb b/spec/ruby/core/kernel/class_spec.rb index b1d9df1671..0a7f774d14 100644 --- a/spec/ruby/core/kernel/class_spec.rb +++ b/spec/ruby/core/kernel/class_spec.rb @@ -3,24 +3,24 @@ require_relative 'fixtures/classes' describe "Kernel#class" do it "returns the class of the object" do - Object.new.class.should equal(Object) + Object.new.class.should.equal?(Object) - 1.class.should equal(Integer) - 3.14.class.should equal(Float) - :hello.class.should equal(Symbol) - "hello".class.should equal(String) - [1, 2].class.should equal(Array) - { 1 => 2 }.class.should equal(Hash) + 1.class.should.equal?(Integer) + 3.14.class.should.equal?(Float) + :hello.class.should.equal?(Symbol) + "hello".class.should.equal?(String) + [1, 2].class.should.equal?(Array) + { 1 => 2 }.class.should.equal?(Hash) end it "returns Class for a class" do - BasicObject.class.should equal(Class) - String.class.should equal(Class) + BasicObject.class.should.equal?(Class) + String.class.should.equal?(Class) end it "returns the first non-singleton class" do a = +"hello" def a.my_singleton_method; end - a.class.should equal(String) + a.class.should.equal?(String) end end diff --git a/spec/ruby/core/kernel/clone_spec.rb b/spec/ruby/core/kernel/clone_spec.rb index 5adcbbe603..4ddb23d6e6 100644 --- a/spec/ruby/core/kernel/clone_spec.rb +++ b/spec/ruby/core/kernel/clone_spec.rb @@ -25,7 +25,7 @@ describe "Kernel#clone" do end clone = instance.clone - clone.class.should equal klass + clone.class.should.equal? klass end describe "with no arguments" do @@ -40,7 +40,7 @@ describe "Kernel#clone" do it 'copies frozen?' do o = ''.freeze.clone - o.frozen?.should be_true + o.frozen?.should == true end end @@ -56,7 +56,7 @@ describe "Kernel#clone" do it "copies frozen?" do o = "".freeze.clone(freeze: nil) - o.frozen?.should be_true + o.frozen?.should == true end end @@ -78,7 +78,7 @@ describe "Kernel#clone" do it "calls #initialize_clone with kwargs freeze: true even if #initialize_clone only takes a single argument" do obj = KernelSpecs::Clone.new - -> { obj.clone(freeze: true) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)') + -> { obj.clone(freeze: true) }.should.raise(ArgumentError, 'wrong number of arguments (given 2, expected 1)') end end @@ -100,15 +100,15 @@ describe "Kernel#clone" do it "calls #initialize_clone with kwargs freeze: false even if #initialize_clone only takes a single argument" do obj = KernelSpecs::Clone.new - -> { obj.clone(freeze: false) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)') + -> { obj.clone(freeze: false) }.should.raise(ArgumentError, 'wrong number of arguments (given 2, expected 1)') end end describe "with freeze: anything else" do it 'raises ArgumentError when passed not true/false/nil' do - -> { @obj.clone(freeze: 1) }.should raise_error(ArgumentError, /unexpected value for freeze: Integer/) - -> { @obj.clone(freeze: "") }.should raise_error(ArgumentError, /unexpected value for freeze: String/) - -> { @obj.clone(freeze: Object.new) }.should raise_error(ArgumentError, /unexpected value for freeze: Object/) + -> { @obj.clone(freeze: 1) }.should.raise(ArgumentError, /unexpected value for freeze: Integer/) + -> { @obj.clone(freeze: "") }.should.raise(ArgumentError, /unexpected value for freeze: String/) + -> { @obj.clone(freeze: Object.new) }.should.raise(ArgumentError, /unexpected value for freeze: Object/) end end diff --git a/spec/ruby/core/kernel/comparison_spec.rb b/spec/ruby/core/kernel/comparison_spec.rb index affdc5c00d..48f17e1172 100644 --- a/spec/ruby/core/kernel/comparison_spec.rb +++ b/spec/ruby/core/kernel/comparison_spec.rb @@ -15,17 +15,17 @@ describe "Kernel#<=>" do it "returns nil if self is eql? but not == to the argument" do obj = mock('has eql?') obj.should_not_receive(:eql?) - obj.<=>(Object.new).should be_nil + obj.<=>(Object.new).should == nil end it "returns nil if self.==(arg) returns nil" do obj = mock('wrong ==') obj.should_receive(:==).and_return(nil) - obj.<=>(Object.new).should be_nil + obj.<=>(Object.new).should == nil end it "returns nil if self is not == to the argument" do obj = Object.new - obj.<=>(3.14).should be_nil + obj.<=>(3.14).should == nil end end diff --git a/spec/ruby/core/kernel/define_singleton_method_spec.rb b/spec/ruby/core/kernel/define_singleton_method_spec.rb index 24acec84f5..ec48581db8 100644 --- a/spec/ruby/core/kernel/define_singleton_method_spec.rb +++ b/spec/ruby/core/kernel/define_singleton_method_spec.rb @@ -14,14 +14,14 @@ describe "Kernel#define_singleton_method" do end it "adds the new method to the methods list" do - DefineSingletonMethodSpecClass.should have_method(:another_test_method) + DefineSingletonMethodSpecClass.should.respond_to?(:another_test_method) end it "defines any Child class method from any Parent's class methods" do um = KernelSpecs::Parent.method(:parent_class_method).unbind KernelSpecs::Child.send :define_singleton_method, :child_class_method, um KernelSpecs::Child.child_class_method.should == :foo - ->{KernelSpecs::Parent.child_class_method}.should raise_error(NoMethodError) + ->{KernelSpecs::Parent.child_class_method}.should.raise(NoMethodError) end it "will raise when attempting to define an object's singleton method from another object's singleton method" do @@ -33,7 +33,7 @@ describe "Kernel#define_singleton_method" do end end um = p.method(:singleton_method).unbind - ->{ other.send :define_singleton_method, :other_singleton_method, um }.should raise_error(TypeError) + ->{ other.send :define_singleton_method, :other_singleton_method, um }.should.raise(TypeError) end end @@ -52,11 +52,11 @@ describe "Kernel#define_singleton_method" do it "raises a TypeError when the given method is no Method/Proc" do -> { Class.new { define_singleton_method(:test, "self") } - }.should raise_error(TypeError) + }.should.raise(TypeError) -> { Class.new { define_singleton_method(:test, 1234) } - }.should raise_error(TypeError) + }.should.raise(TypeError) end it "defines a new singleton method for objects" do @@ -65,7 +65,7 @@ describe "Kernel#define_singleton_method" do obj.test.should == "world!" -> { Object.new.test - }.should raise_error(NoMethodError) + }.should.raise(NoMethodError) end it "maintains the Proc's scope" do @@ -83,7 +83,7 @@ describe "Kernel#define_singleton_method" do obj = Object.new -> { obj.define_singleton_method(:test) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "does not use the caller block when no block is given" do @@ -94,7 +94,7 @@ describe "Kernel#define_singleton_method" do -> { o.define(:foo) { raise "not used" } - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "always defines the method with public visibility" do @@ -109,12 +109,12 @@ describe "Kernel#define_singleton_method" do cls.define(:foo) { :ok } end cls.foo.should == :ok - }.should_not raise_error(NoMethodError) + }.should_not.raise(NoMethodError) end it "cannot define a singleton method with a frozen singleton class" do o = Object.new o.freeze - -> { o.define_singleton_method(:foo) { 1 } }.should raise_error(FrozenError) + -> { o.define_singleton_method(:foo) { 1 } }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/kernel/dup_spec.rb b/spec/ruby/core/kernel/dup_spec.rb index 70198abdb7..99de5e3732 100644 --- a/spec/ruby/core/kernel/dup_spec.rb +++ b/spec/ruby/core/kernel/dup_spec.rb @@ -25,7 +25,7 @@ describe "Kernel#dup" do end dup = instance.dup - dup.class.should equal klass + dup.class.should.equal? klass end it "does not copy frozen state from the original" do @@ -44,7 +44,7 @@ describe "Kernel#dup" do it "does not copy singleton methods" do def @obj.special() :the_one end dup = @obj.dup - -> { dup.special }.should raise_error(NameError) + -> { dup.special }.should.raise(NameError) end it "does not copy modules included in the singleton class" do @@ -53,7 +53,7 @@ describe "Kernel#dup" do end dup = @obj.dup - -> { dup.repr }.should raise_error(NameError) + -> { dup.repr }.should.raise(NameError) end it "does not copy constants defined in the singleton class" do @@ -62,6 +62,6 @@ describe "Kernel#dup" do end dup = @obj.dup - -> { class << dup; CLONE; end }.should raise_error(NameError) + -> { class << dup; CLONE; end }.should.raise(NameError) end end diff --git a/spec/ruby/core/kernel/eql_spec.rb b/spec/ruby/core/kernel/eql_spec.rb index e62a601a79..b3289090e5 100644 --- a/spec/ruby/core/kernel/eql_spec.rb +++ b/spec/ruby/core/kernel/eql_spec.rb @@ -3,7 +3,7 @@ require_relative '../../shared/kernel/equal' describe "Kernel#eql?" do it "is a public instance method" do - Kernel.should have_public_instance_method(:eql?) + Kernel.public_instance_methods(false).should.include?(:eql?) end it_behaves_like :object_equal, :eql? diff --git a/spec/ruby/core/kernel/eval_spec.rb b/spec/ruby/core/kernel/eval_spec.rb index c189d5f0a2..f9ca47866e 100644 --- a/spec/ruby/core/kernel/eval_spec.rb +++ b/spec/ruby/core/kernel/eval_spec.rb @@ -5,7 +5,7 @@ EvalSpecs::A.new.c describe "Kernel#eval" do it "is a private method" do - Kernel.should have_private_instance_method(:eval) + Kernel.private_instance_methods(false).should.include?(:eval) end it "is a module function" do @@ -76,12 +76,12 @@ describe "Kernel#eval" do x = 1 bind = proc {} - -> { eval("x", bind) }.should raise_error(TypeError) + -> { eval("x", bind) }.should.raise(TypeError) end it "does not make Proc locals visible to evaluated code" do bind = proc { inner = 4 } - -> { eval("inner", bind.binding) }.should raise_error(NameError) + -> { eval("inner", bind.binding) }.should.raise(NameError) end # REWRITE ME: This obscures the real behavior of where locals are stored @@ -119,7 +119,7 @@ describe "Kernel#eval" do outer_binding = binding eval("if false; a = 1; end", outer_binding) - eval("a", outer_binding).should be_nil + eval("a", outer_binding).should == nil end it "allows creating a new class in a binding" do @@ -136,7 +136,7 @@ describe "Kernel#eval" do expected = 'speccing.rb' -> { eval('if true', TOPLEVEL_BINDING, expected) - }.should raise_error(SyntaxError) { |e| + }.should.raise(SyntaxError) { |e| e.message.should =~ /#{expected}:1:.+/ } end @@ -145,7 +145,7 @@ describe "Kernel#eval" do expected_file = 'speccing.rb' -> { eval('if true', TOPLEVEL_BINDING, expected_file, -100) - }.should raise_error(SyntaxError) { |e| + }.should.raise(SyntaxError) { |e| e.message.should =~ /#{expected_file}:-100:.+/ } end @@ -159,36 +159,87 @@ describe "Kernel#eval" do end end - ruby_version_is ""..."3.3" do - it "uses (eval) filename if none is provided" do - eval("__FILE__").should == "(eval)" - eval("__FILE__", binding).should == "(eval)" - eval("__FILE__", binding, "success").should == "success" - eval("eval '__FILE__', binding").should == "(eval)" - eval("eval '__FILE__', binding", binding).should == "(eval)" - eval("eval '__FILE__', binding", binding, 'success').should == '(eval)' - eval("eval '__FILE__', binding, 'success'", binding).should == 'success' + context "parameter forwarding" do + it "allows anonymous rest parameter forwarding" do + object = Object.new + def object.foo(a, b, c) + [a, b, c] + end + def object.bar(*) + eval "foo(*)" + end + + object.bar(1, 2, 3).should == [1, 2, 3] end - it 'uses (eval) for __FILE__ and 1 for __LINE__ with a binding argument' do - eval("[__FILE__, __LINE__]", binding).should == ["(eval)", 1] + it "allows anonymous keyword parameters forwarding" do + object = Object.new + def object.foo(a:, b:, c:) + [a, b, c] + end + def object.bar(**) + eval "foo(**)" + end + + object.bar(a: 1, b: 2, c: 3).should == [1, 2, 3] end - end - ruby_version_is "3.3" do - it "uses (eval at __FILE__:__LINE__) if none is provided" do - eval("__FILE__").should == "(eval at #{__FILE__}:#{__LINE__})" - eval("__FILE__", binding).should == "(eval at #{__FILE__}:#{__LINE__})" - eval("__FILE__", binding, "success").should == "success" - eval("eval '__FILE__', binding").should == "(eval at (eval at #{__FILE__}:#{__LINE__}):1)" - eval("eval '__FILE__', binding", binding).should == "(eval at (eval at #{__FILE__}:#{__LINE__}):1)" - eval("eval '__FILE__', binding", binding, 'success').should == "(eval at success:1)" - eval("eval '__FILE__', binding, 'success'", binding).should == 'success' + it "allows anonymous block parameter forwarding" do + object = Object.new + def object.foo(&block) + block.call + end + def object.bar(&) + eval "foo(&)" + end + + object.bar { :foobar }.should == :foobar end - it 'uses (eval at __FILE__:__LINE__) for __FILE__ and 1 for __LINE__ with a binding argument' do - eval("[__FILE__, __LINE__]", binding).should == ["(eval at #{__FILE__}:#{__LINE__})", 1] + it "allows ... forwarding" do + object = Object.new + def object.foo(a, b:, &block) + [a, b, block.call] + end + def object.bar(...) + eval "foo(...)" + end + + object.bar(1, b: 2) { 3 }.should == [1, 2, 3] end + + it "allows parameter forwarding to super" do + m = Module.new do + def foo(a, b:, &block) + [a, b, block.call] + end + end + + c = Class.new do + include m + + def foo(a, b:, &block) + eval "super" + end + end + + object = c.new + object.foo(1, b: 2) { 3 }.should == [1, 2, 3] + end + end + + it "uses (eval at __FILE__:__LINE__) if none is provided" do + eval("__FILE__").should == "(eval at #{__FILE__}:#{__LINE__})" + eval("__FILE__", binding).should == "(eval at #{__FILE__}:#{__LINE__})" + eval("__FILE__", binding, "success").should == "success" + eval("eval '__FILE__', binding").should == "(eval at (eval at #{__FILE__}:#{__LINE__}):1)" + eval("eval '__FILE__', binding", binding).should == "(eval at (eval at #{__FILE__}:#{__LINE__}):1)" + eval("eval '__FILE__', binding", binding, 'success').should == "(eval at success:1)" + eval("eval '__FILE__', binding, 'success'", binding).should == 'success' + end + + it 'uses (eval at __FILE__:__LINE__) for __FILE__ and 1 for __LINE__ with a binding argument' do + eval("[__FILE__, __LINE__]", binding).should == ["(eval at #{__FILE__}:#{__LINE__})", 1] end # Found via Rubinius bug github:#149 it "does not alter the value of __FILE__ in the binding" do @@ -212,14 +263,14 @@ describe "Kernel#eval" do # See http://jira.codehaus.org/browse/JRUBY-5163 it "uses the receiver as self inside the eval" do - eval("self").should equal(self) - Kernel.eval("self").should equal(Kernel) + eval("self").should.equal?(self) + Kernel.eval("self").should.equal?(Kernel) end it "does not pass the block to the method being eval'ed" do -> { eval('KernelSpecs::EvalTest.call_yield') { "content" } - }.should raise_error(LocalJumpError) + }.should.raise(LocalJumpError) end it "returns from the scope calling #eval when evaluating 'return'" do @@ -257,7 +308,7 @@ describe "Kernel#eval" do it "has the correct default definee when called through Method#call" do class EvalSpecs method(:eval).call("def eval_spec_method_call; end") - EvalSpecs.should have_instance_method(:eval_spec_method_call) + EvalSpecs.should.method_defined?(:eval_spec_method_call, false) end end @@ -311,7 +362,7 @@ end CODE code.encoding.should == Encoding::BINARY eval(code) - EvalSpecs.constants(false).should include(:"Vπ") + EvalSpecs.constants(false).should.include?(:"Vπ") EvalSpecs::Vπ.should == 3.14 ensure EvalSpecs.send(:remove_const, :Vπ) @@ -326,7 +377,7 @@ end CODE code.encoding.should == Encoding::BINARY eval(code) - EvalSpecs.constants(false).should include(:"Vπemacs") + EvalSpecs.constants(false).should.include?(:"Vπemacs") EvalSpecs::Vπemacs.should == 3.14 ensure EvalSpecs.send(:remove_const, :Vπemacs) @@ -341,7 +392,7 @@ end CODE code.encoding.should == Encoding::BINARY eval(code) - EvalSpecs.constants(false).should include(:"Vπspaces") + EvalSpecs.constants(false).should.include?(:"Vπspaces") EvalSpecs::Vπspaces.should == 3.14 ensure EvalSpecs.send(:remove_const, :Vπspaces) @@ -357,7 +408,7 @@ end CODE code.encoding.should == Encoding::BINARY eval(code) - EvalSpecs.constants(false).should include(:"Vπshebang") + EvalSpecs.constants(false).should.include?(:"Vπshebang") EvalSpecs::Vπshebang.should == 3.14 ensure EvalSpecs.send(:remove_const, :Vπshebang) @@ -373,7 +424,7 @@ end CODE code.encoding.should == Encoding::BINARY eval(code) - EvalSpecs.constants(false).should include(:"Vπshebang_spaces") + EvalSpecs.constants(false).should.include?(:"Vπshebang_spaces") EvalSpecs::Vπshebang_spaces.should == 3.14 ensure EvalSpecs.send(:remove_const, :Vπshebang_spaces) @@ -391,7 +442,7 @@ end CODE code.encoding.should == Encoding::BINARY eval(code) - EvalSpecs.constants(false).should include(:"Vπstring") + EvalSpecs.constants(false).should.include?(:"Vπstring") EvalSpecs::Vπstring.should == "frozen" EvalSpecs::Vπstring.encoding.should == Encoding::UTF_8 EvalSpecs::Vπstring.frozen?.should == !frozen_string_default @@ -408,10 +459,10 @@ end CODE code.encoding.should == Encoding::BINARY eval(code) - EvalSpecs.constants(false).should include(:"Vπsame_line") + EvalSpecs.constants(false).should.include?(:"Vπsame_line") EvalSpecs::Vπsame_line.should == "frozen" EvalSpecs::Vπsame_line.encoding.should == Encoding::UTF_8 - EvalSpecs::Vπsame_line.frozen?.should be_true + EvalSpecs::Vπsame_line.frozen?.should == true ensure EvalSpecs.send(:remove_const, :Vπsame_line) end @@ -427,9 +478,9 @@ end CODE code.encoding.should == Encoding::BINARY eval(code) - EvalSpecs.constants(false).should_not include(:"Vπfrozen_first") + EvalSpecs.constants(false).should_not.include?(:"Vπfrozen_first") binary_constant = "Vπfrozen_first".b.to_sym - EvalSpecs.constants(false).should include(binary_constant) + EvalSpecs.constants(false).should.include?(binary_constant) value = EvalSpecs.const_get(binary_constant) value.should == "frozen" value.encoding.should == Encoding::BINARY diff --git a/spec/ruby/core/kernel/exec_spec.rb b/spec/ruby/core/kernel/exec_spec.rb index 3d9520ad67..fd8485791a 100644 --- a/spec/ruby/core/kernel/exec_spec.rb +++ b/spec/ruby/core/kernel/exec_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#exec" do it "is a private method" do - Kernel.should have_private_instance_method(:exec) + Kernel.private_instance_methods(false).should.include?(:exec) end it "runs the specified command, replacing current process" do diff --git a/spec/ruby/core/kernel/exit_spec.rb b/spec/ruby/core/kernel/exit_spec.rb index 93cec3fee5..864ff84449 100644 --- a/spec/ruby/core/kernel/exit_spec.rb +++ b/spec/ruby/core/kernel/exit_spec.rb @@ -4,7 +4,7 @@ require_relative '../../shared/process/exit' describe "Kernel#exit" do it "is a private method" do - Kernel.should have_private_instance_method(:exit) + Kernel.private_instance_methods(false).should.include?(:exit) end it_behaves_like :process_exit, :exit, KernelSpecs::Method.new @@ -16,7 +16,7 @@ end describe "Kernel#exit!" do it "is a private method" do - Kernel.should have_private_instance_method(:exit!) + Kernel.private_instance_methods(false).should.include?(:exit!) end it_behaves_like :process_exit!, :exit!, "self" diff --git a/spec/ruby/core/kernel/extend_spec.rb b/spec/ruby/core/kernel/extend_spec.rb index 6342d8cae1..a344c7b5ca 100644 --- a/spec/ruby/core/kernel/extend_spec.rb +++ b/spec/ruby/core/kernel/extend_spec.rb @@ -53,13 +53,13 @@ describe "Kernel#extend" do end it "raises an ArgumentError when no arguments given" do - -> { Object.new.extend }.should raise_error(ArgumentError) + -> { Object.new.extend }.should.raise(ArgumentError) end it "raises a TypeError when the argument is not a Module" do o = mock('o') klass = Class.new - -> { o.extend(klass) }.should raise_error(TypeError) + -> { o.extend(klass) }.should.raise(TypeError) end describe "on frozen instance" do @@ -69,11 +69,11 @@ describe "Kernel#extend" do end it "raises an ArgumentError when no arguments given" do - -> { @frozen.extend }.should raise_error(ArgumentError) + -> { @frozen.extend }.should.raise(ArgumentError) end it "raises a FrozenError" do - -> { @frozen.extend @module }.should raise_error(FrozenError) + -> { @frozen.extend @module }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/kernel/fail_spec.rb b/spec/ruby/core/kernel/fail_spec.rb index fab622037e..ac379b67d5 100644 --- a/spec/ruby/core/kernel/fail_spec.rb +++ b/spec/ruby/core/kernel/fail_spec.rb @@ -3,11 +3,11 @@ require_relative 'fixtures/classes' describe "Kernel#fail" do it "is a private method" do - Kernel.should have_private_instance_method(:fail) + Kernel.private_instance_methods(false).should.include?(:fail) end it "raises a RuntimeError" do - -> { fail }.should raise_error(RuntimeError) + -> { fail }.should.raise(RuntimeError) end it "accepts an Object with an exception method returning an Exception" do @@ -15,12 +15,12 @@ describe "Kernel#fail" do def obj.exception(msg) StandardError.new msg end - -> { fail obj, "..." }.should raise_error(StandardError, "...") + -> { fail obj, "..." }.should.raise(StandardError, "...") end it "instantiates the specified exception class" do error_class = Class.new(RuntimeError) - -> { fail error_class }.should raise_error(error_class) + -> { fail error_class }.should.raise(error_class) end it "uses the specified message" do @@ -33,7 +33,7 @@ describe "Kernel#fail" do else raise Exception end - }.should raise_error(RuntimeError) + }.should.raise(RuntimeError) end end diff --git a/spec/ruby/core/kernel/fixtures/autoload_relative_b.rb b/spec/ruby/core/kernel/fixtures/autoload_relative_b.rb new file mode 100644 index 0000000000..6de6f5091d --- /dev/null +++ b/spec/ruby/core/kernel/fixtures/autoload_relative_b.rb @@ -0,0 +1,7 @@ +module KernelSpecs + module KSAutoloadRelativeB + def self.loaded + :ksautoload_b + end + end +end diff --git a/spec/ruby/core/kernel/fixtures/autoload_relative_d.rb b/spec/ruby/core/kernel/fixtures/autoload_relative_d.rb new file mode 100644 index 0000000000..5b6b5e1fa2 --- /dev/null +++ b/spec/ruby/core/kernel/fixtures/autoload_relative_d.rb @@ -0,0 +1,5 @@ +module KSAutoloadRelativeD + def self.loaded + :ksautoload_d + end +end diff --git a/spec/ruby/core/kernel/fixtures/classes.rb b/spec/ruby/core/kernel/fixtures/classes.rb index 0e2b81988f..ad82f3cef5 100644 --- a/spec/ruby/core/kernel/fixtures/classes.rb +++ b/spec/ruby/core/kernel/fixtures/classes.rb @@ -180,6 +180,25 @@ module KernelSpecs alias aliased_pub_method pub_method end + class BasicA < BasicObject + define_method(:respond_to?, ::Kernel.instance_method(:respond_to?)) + + def pub_method; :public_method; end + + def undefed_method; :undefed_method; end + undef_method :undefed_method + + protected + def protected_method; :protected_method; end + + private + def private_method; :private_method; end + end + + class MissingA < A + undef :respond_to_missing? + end + class VisibilityChange class << self private :new diff --git a/spec/ruby/core/kernel/fork_spec.rb b/spec/ruby/core/kernel/fork_spec.rb index b37f9980e0..4a2c848202 100644 --- a/spec/ruby/core/kernel/fork_spec.rb +++ b/spec/ruby/core/kernel/fork_spec.rb @@ -4,7 +4,7 @@ require_relative '../../shared/process/fork' describe "Kernel#fork" do it "is a private method" do - Kernel.should have_private_instance_method(:fork) + Kernel.private_instance_methods(false).should.include?(:fork) end it_behaves_like :process_fork, :fork, KernelSpecs::Method.new diff --git a/spec/ruby/core/kernel/format_spec.rb b/spec/ruby/core/kernel/format_spec.rb index 1d0c000c15..35c752b1ab 100644 --- a/spec/ruby/core/kernel/format_spec.rb +++ b/spec/ruby/core/kernel/format_spec.rb @@ -4,7 +4,7 @@ require_relative 'fixtures/classes' # NOTE: most specs are in sprintf_spec.rb, this is just an alias describe "Kernel#format" do it "is a private method" do - Kernel.should have_private_instance_method(:format) + Kernel.private_instance_methods(false).should.include?(:format) end end @@ -20,7 +20,7 @@ describe "Kernel.format" do format("test", 1) RUBY - ruby_exe(code, args: "2>&1").should include("warning: too many arguments for format string") + ruby_exe(code, args: "2>&1").should.include?("warning: too many arguments for format string") end it "does not warns if too many keyword arguments are passed" do @@ -29,7 +29,7 @@ describe "Kernel.format" do format("test %{test}", test: 1, unused: 2) RUBY - ruby_exe(code, args: "2>&1").should_not include("warning") + ruby_exe(code, args: "2>&1").should_not.include?("warning") end ruby_bug "#20593", ""..."3.4" do @@ -40,7 +40,7 @@ describe "Kernel.format" do format("test", {}) RUBY - ruby_exe(code, args: "2>&1").should_not include("warning") + ruby_exe(code, args: "2>&1").should_not.include?("warning") end end end diff --git a/spec/ruby/core/kernel/freeze_spec.rb b/spec/ruby/core/kernel/freeze_spec.rb index fa32d321cf..079617dce4 100644 --- a/spec/ruby/core/kernel/freeze_spec.rb +++ b/spec/ruby/core/kernel/freeze_spec.rb @@ -4,46 +4,46 @@ require_relative 'fixtures/classes' describe "Kernel#freeze" do it "prevents self from being further modified" do o = mock('o') - o.frozen?.should be_false + o.frozen?.should == false o.freeze - o.frozen?.should be_true + o.frozen?.should == true end it "returns self" do o = Object.new - o.freeze.should equal(o) + o.freeze.should.equal?(o) end describe "on integers" do it "has no effect since they are already frozen" do - 1.frozen?.should be_true + 1.frozen?.should == true 1.freeze bignum = bignum_value - bignum.frozen?.should be_true + bignum.frozen?.should == true bignum.freeze end end describe "on a Float" do it "has no effect since it is already frozen" do - 1.2.frozen?.should be_true + 1.2.frozen?.should == true 1.2.freeze end end describe "on a Symbol" do it "has no effect since it is already frozen" do - :sym.frozen?.should be_true + :sym.frozen?.should == true :sym.freeze end end describe "on true, false and nil" do it "has no effect since they are already frozen" do - nil.frozen?.should be_true - true.frozen?.should be_true - false.frozen?.should be_true + nil.frozen?.should == true + true.frozen?.should == true + false.frozen?.should == true nil.freeze true.freeze @@ -54,7 +54,7 @@ describe "Kernel#freeze" do describe "on a Complex" do it "has no effect since it is already frozen" do c = Complex(1.3, 3.1) - c.frozen?.should be_true + c.frozen?.should == true c.freeze end end @@ -62,7 +62,7 @@ describe "Kernel#freeze" do describe "on a Rational" do it "has no effect since it is already frozen" do r = Rational(1, 3) - r.frozen?.should be_true + r.frozen?.should == true r.freeze end end @@ -72,13 +72,13 @@ describe "Kernel#freeze" do def mutate; @foo = 1; end end.new o.freeze - -> {o.mutate}.should raise_error(RuntimeError) + -> {o.mutate}.should.raise(RuntimeError) end it "causes instance_variable_set to raise RuntimeError" do o = Object.new o.freeze - -> {o.instance_variable_set(:@foo, 1)}.should raise_error(RuntimeError) + -> {o.instance_variable_set(:@foo, 1)}.should.raise(RuntimeError) end it "freezes an object's singleton class" do diff --git a/spec/ruby/core/kernel/frozen_spec.rb b/spec/ruby/core/kernel/frozen_spec.rb index a4cec4263d..8b8fad3de7 100644 --- a/spec/ruby/core/kernel/frozen_spec.rb +++ b/spec/ruby/core/kernel/frozen_spec.rb @@ -12,9 +12,9 @@ describe "Kernel#frozen?" do describe "on true, false and nil" do it "returns true" do - true.frozen?.should be_true - false.frozen?.should be_true - nil.frozen?.should be_true + true.frozen?.should == true + false.frozen?.should == true + nil.frozen?.should == true end end @@ -25,8 +25,8 @@ describe "Kernel#frozen?" do end it "returns true" do - @fixnum.frozen?.should be_true - @bignum.frozen?.should be_true + @fixnum.frozen?.should == true + @bignum.frozen?.should == true end end @@ -36,7 +36,7 @@ describe "Kernel#frozen?" do end it "returns true" do - @float.frozen?.should be_true + @float.frozen?.should == true end end @@ -46,31 +46,31 @@ describe "Kernel#frozen?" do end it "returns true" do - @symbol.frozen?.should be_true + @symbol.frozen?.should == true end end describe "on a Complex" do it "returns true" do c = Complex(1.3, 3.1) - c.frozen?.should be_true + c.frozen?.should == true end it "literal returns true" do c = eval "1.3i" - c.frozen?.should be_true + c.frozen?.should == true end end describe "on a Rational" do it "returns true" do r = Rational(1, 3) - r.frozen?.should be_true + r.frozen?.should == true end it "literal returns true" do r = eval "1/3r" - r.frozen?.should be_true + r.frozen?.should == true end end end diff --git a/spec/ruby/core/kernel/gets_spec.rb b/spec/ruby/core/kernel/gets_spec.rb index 104613dbfa..1b2b36fbb9 100644 --- a/spec/ruby/core/kernel/gets_spec.rb +++ b/spec/ruby/core/kernel/gets_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#gets" do it "is a private method" do - Kernel.should have_private_instance_method(:gets) + Kernel.private_instance_methods(false).should.include?(:gets) end it "calls ARGF.gets" do diff --git a/spec/ruby/core/kernel/global_variables_spec.rb b/spec/ruby/core/kernel/global_variables_spec.rb index 8bce8e25b7..d41bdff49a 100644 --- a/spec/ruby/core/kernel/global_variables_spec.rb +++ b/spec/ruby/core/kernel/global_variables_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel.global_variables" do it "is a private method" do - Kernel.should have_private_instance_method(:global_variables) + Kernel.private_instance_methods(false).should.include?(:global_variables) end before :all do @@ -11,13 +11,13 @@ describe "Kernel.global_variables" do end it "finds subset starting with std" do - global_variables.grep(/std/).should include(:$stderr, :$stdin, :$stdout) + global_variables.grep(/std/).to_set.should >= Set[:$stderr, :$stdin, :$stdout] a = global_variables.size gvar_name = "$foolish_global_var#{@i += 1}" global_variables.include?(gvar_name.to_sym).should == false eval("#{gvar_name} = 1") global_variables.size.should == a+1 - global_variables.should include(gvar_name.to_sym) + global_variables.should.include?(gvar_name.to_sym) end end diff --git a/spec/ruby/core/kernel/gsub_spec.rb b/spec/ruby/core/kernel/gsub_spec.rb index a0cb9f2a70..e05349e2b5 100644 --- a/spec/ruby/core/kernel/gsub_spec.rb +++ b/spec/ruby/core/kernel/gsub_spec.rb @@ -6,20 +6,20 @@ require_relative 'fixtures/classes' ruby_version_is ""..."1.9" do describe "Kernel#gsub" do it "is a private method" do - Kernel.should have_private_instance_method(:gsub) + Kernel.private_instance_methods(false).should.include?(:gsub) end it "raises a TypeError if $_ is not a String" do -> { $_ = 123 gsub(/./, "!") - }.should raise_error(TypeError) + }.should.raise(TypeError) end it "when matches sets $_ to a new string, leaving the former value unaltered" do orig_value = $_ = "hello" gsub("ello", "ola") - $_.should_not equal(orig_value) + $_.should_not.equal?(orig_value) $_.should == "hola" orig_value.should == "hello" end @@ -86,7 +86,7 @@ ruby_version_is ""..."1.9" do describe "Kernel#gsub!" do it "is a private method" do - Kernel.should have_private_instance_method(:gsub!) + Kernel.private_instance_methods(false).should.include?(:gsub!) end end diff --git a/spec/ruby/core/kernel/initialize_clone_spec.rb b/spec/ruby/core/kernel/initialize_clone_spec.rb index 21a90c19f0..0033eadffb 100644 --- a/spec/ruby/core/kernel/initialize_clone_spec.rb +++ b/spec/ruby/core/kernel/initialize_clone_spec.rb @@ -2,7 +2,7 @@ require_relative '../../spec_helper' describe "Kernel#initialize_clone" do it "is a private instance method" do - Kernel.should have_private_instance_method(:initialize_clone) + Kernel.private_instance_methods(false).should.include?(:initialize_clone) end it "returns the receiver" do diff --git a/spec/ruby/core/kernel/initialize_copy_spec.rb b/spec/ruby/core/kernel/initialize_copy_spec.rb index d71ca9f60f..ebac0c14de 100644 --- a/spec/ruby/core/kernel/initialize_copy_spec.rb +++ b/spec/ruby/core/kernel/initialize_copy_spec.rb @@ -17,8 +17,8 @@ describe "Kernel#initialize_copy" do end it "raises FrozenError if the receiver is frozen" do - -> { Object.new.freeze.send(:initialize_copy, Object.new) }.should raise_error(FrozenError) - -> { 1.send(:initialize_copy, Object.new) }.should raise_error(FrozenError) + -> { Object.new.freeze.send(:initialize_copy, Object.new) }.should.raise(FrozenError) + -> { 1.send(:initialize_copy, Object.new) }.should.raise(FrozenError) end it "raises TypeError if the objects are of different class" do @@ -27,10 +27,10 @@ describe "Kernel#initialize_copy" do a = klass.new b = sub.new message = 'initialize_copy should take same class object' - -> { a.send(:initialize_copy, b) }.should raise_error(TypeError, message) - -> { b.send(:initialize_copy, a) }.should raise_error(TypeError, message) + -> { a.send(:initialize_copy, b) }.should.raise(TypeError, message) + -> { b.send(:initialize_copy, a) }.should.raise(TypeError, message) - -> { a.send(:initialize_copy, 1) }.should raise_error(TypeError, message) - -> { a.send(:initialize_copy, 1.0) }.should raise_error(TypeError, message) + -> { a.send(:initialize_copy, 1) }.should.raise(TypeError, message) + -> { a.send(:initialize_copy, 1.0) }.should.raise(TypeError, message) end end diff --git a/spec/ruby/core/kernel/initialize_dup_spec.rb b/spec/ruby/core/kernel/initialize_dup_spec.rb index 6dff34b7ad..f144647eb8 100644 --- a/spec/ruby/core/kernel/initialize_dup_spec.rb +++ b/spec/ruby/core/kernel/initialize_dup_spec.rb @@ -2,7 +2,7 @@ require_relative '../../spec_helper' describe "Kernel#initialize_dup" do it "is a private instance method" do - Kernel.should have_private_instance_method(:initialize_dup) + Kernel.private_instance_methods(false).should.include?(:initialize_dup) end it "returns the receiver" do diff --git a/spec/ruby/core/kernel/inspect_spec.rb b/spec/ruby/core/kernel/inspect_spec.rb index 1f9ce834ab..8fc3ab51cd 100644 --- a/spec/ruby/core/kernel/inspect_spec.rb +++ b/spec/ruby/core/kernel/inspect_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#inspect" do it "returns a String" do - Object.new.inspect.should be_an_instance_of(String) + Object.new.inspect.should.instance_of?(String) end it "does not call #to_s if it is defined" do @@ -26,6 +26,78 @@ describe "Kernel#inspect" do class << obj undef_method :class end - obj.inspect.should be_kind_of(String) + obj.inspect.should.is_a?(String) + end + + ruby_version_is "4.0" do + it "calls #instance_variables_to_inspect private method to know which variables to display" do + obj = Object.new + obj.instance_eval do + @host = "localhost" + @user = "root" + @password = "hunter2" + end + obj.singleton_class.class_eval do + private def instance_variables_to_inspect = %i[@host @user @does_not_exist] + end + + inspected = obj.inspect.sub(/^#<Object:0x[0-9a-f]+/, '#<Object:0x00') + inspected.should == '#<Object:0x00 @host="localhost", @user="root">' + + obj = Object.new + obj.instance_eval do + @host = "localhost" + @user = "root" + @password = "hunter2" + end + obj.singleton_class.class_eval do + private def instance_variables_to_inspect = [] + end + + inspected = obj.inspect.sub(/^#<Object:0x[0-9a-f]+/, '#<Object:0x00') + inspected.should == "#<Object:0x00>" + end + + it "displays all instance variables if #instance_variables_to_inspect returns nil" do + obj = Object.new + obj.instance_eval do + @host = "localhost" + @user = "root" + @password = "hunter2" + end + obj.singleton_class.class_eval do + private def instance_variables_to_inspect = nil + end + + inspected = obj.inspect.sub(/^#<Object:0x[0-9a-f]+/, '#<Object:0x00') + inspected.should == %{#<Object:0x00 @host="localhost", @user="root", @password="hunter2">} + end + + it "displays all instance variables if #instance_variables_to_inspect is not defined" do + obj = BasicObject.new + obj.instance_eval do + @host = "localhost" + @user = "root" + @password = "hunter2" + end + method_inspect = Kernel.instance_method(:inspect) + + inspected = method_inspect.bind(obj).call.sub(/^#<BasicObject:0x[0-9a-f]+/, '#<BasicObject:0x00') + inspected.should == %{#<BasicObject:0x00 @host="localhost", @user="root", @password="hunter2">} + end + + it "raises an error if #instance_variables_to_inspect returns an invalid value" do + obj = Object.new + obj.instance_eval do + @host = "localhost" + @user = "root" + @password = "hunter2" + end + obj.singleton_class.class_eval do + private def instance_variables_to_inspect = {} + end + + ->{ obj.inspect }.should.raise(TypeError, "Expected #instance_variables_to_inspect to return an Array or nil, but it returned Hash") + end end end diff --git a/spec/ruby/core/kernel/instance_of_spec.rb b/spec/ruby/core/kernel/instance_of_spec.rb index d1170d5047..8d19974aa3 100644 --- a/spec/ruby/core/kernel/instance_of_spec.rb +++ b/spec/ruby/core/kernel/instance_of_spec.rb @@ -33,8 +33,8 @@ describe "Kernel#instance_of?" do end it "raises a TypeError if given an object that is not a Class nor a Module" do - -> { @o.instance_of?(Object.new) }.should raise_error(TypeError) - -> { @o.instance_of?('KernelSpecs::InstanceClass') }.should raise_error(TypeError) - -> { @o.instance_of?(1) }.should raise_error(TypeError) + -> { @o.instance_of?(Object.new) }.should.raise(TypeError) + -> { @o.instance_of?('KernelSpecs::InstanceClass') }.should.raise(TypeError) + -> { @o.instance_of?(1) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/kernel/instance_variable_defined_spec.rb b/spec/ruby/core/kernel/instance_variable_defined_spec.rb index 2ebb582b43..512f811393 100644 --- a/spec/ruby/core/kernel/instance_variable_defined_spec.rb +++ b/spec/ruby/core/kernel/instance_variable_defined_spec.rb @@ -8,21 +8,21 @@ describe "Kernel#instance_variable_defined?" do describe "when passed a String" do it "returns false if the instance variable is not defined" do - @instance.instance_variable_defined?("@goodbye").should be_false + @instance.instance_variable_defined?("@goodbye").should == false end it "returns true if the instance variable is defined" do - @instance.instance_variable_defined?("@greeting").should be_true + @instance.instance_variable_defined?("@greeting").should == true end end describe "when passed a Symbol" do it "returns false if the instance variable is not defined" do - @instance.instance_variable_defined?(:@goodbye).should be_false + @instance.instance_variable_defined?(:@goodbye).should == false end it "returns true if the instance variable is defined" do - @instance.instance_variable_defined?(:@greeting).should be_true + @instance.instance_variable_defined?(:@greeting).should == true end end @@ -30,12 +30,12 @@ describe "Kernel#instance_variable_defined?" do -> do obj = mock("kernel instance_variable_defined?") @instance.instance_variable_defined? obj - end.should raise_error(TypeError) + end.should.raise(TypeError) end it "returns false if the instance variable is not defined for different types" do [nil, false, true, 1, 2.0, :test, "test"].each do |obj| - obj.instance_variable_defined?("@goodbye").should be_false + obj.instance_variable_defined?("@goodbye").should == false end end end diff --git a/spec/ruby/core/kernel/instance_variable_get_spec.rb b/spec/ruby/core/kernel/instance_variable_get_spec.rb index f1d2a45df8..8404c94192 100644 --- a/spec/ruby/core/kernel/instance_variable_get_spec.rb +++ b/spec/ruby/core/kernel/instance_variable_get_spec.rb @@ -20,29 +20,29 @@ describe "Kernel#instance_variable_get" do end it "returns nil when the referred instance variable does not exist" do - @obj.instance_variable_get(:@does_not_exist).should be_nil + @obj.instance_variable_get(:@does_not_exist).should == nil end it "raises a TypeError when the passed argument does not respond to #to_str" do - -> { @obj.instance_variable_get(Object.new) }.should raise_error(TypeError) + -> { @obj.instance_variable_get(Object.new) }.should.raise(TypeError) end it "raises a TypeError when the passed argument can't be converted to a String" do obj = mock("to_str") obj.stub!(:to_str).and_return(123) - -> { @obj.instance_variable_get(obj) }.should raise_error(TypeError) + -> { @obj.instance_variable_get(obj) }.should.raise(TypeError) end it "raises a NameError when the conversion result does not start with an '@'" do obj = mock("to_str") obj.stub!(:to_str).and_return("test") - -> { @obj.instance_variable_get(obj) }.should raise_error(NameError) + -> { @obj.instance_variable_get(obj) }.should.raise(NameError) end it "raises a NameError when passed just '@'" do obj = mock("to_str") obj.stub!(:to_str).and_return('@') - -> { @obj.instance_variable_get(obj) }.should raise_error(NameError) + -> { @obj.instance_variable_get(obj) }.should.raise(NameError) end end @@ -57,20 +57,20 @@ describe "Kernel#instance_variable_get when passed Symbol" do end it "raises a NameError when passed :@ as an instance variable name" do - -> { @obj.instance_variable_get(:"@") }.should raise_error(NameError) + -> { @obj.instance_variable_get(:"@") }.should.raise(NameError) end it "raises a NameError when the passed Symbol does not start with an '@'" do - -> { @obj.instance_variable_get(:test) }.should raise_error(NameError) + -> { @obj.instance_variable_get(:test) }.should.raise(NameError) end it "raises a NameError when the passed Symbol is an invalid instance variable name" do - -> { @obj.instance_variable_get(:"@0") }.should raise_error(NameError) + -> { @obj.instance_variable_get(:"@0") }.should.raise(NameError) end it "returns nil or raises for frozen objects" do nil.instance_variable_get(:@foo).should == nil - -> { nil.instance_variable_get(:foo) }.should raise_error(NameError) + -> { nil.instance_variable_get(:foo) }.should.raise(NameError) :foo.instance_variable_get(:@foo).should == nil end end @@ -86,15 +86,15 @@ describe "Kernel#instance_variable_get when passed String" do end it "raises a NameError when the passed String does not start with an '@'" do - -> { @obj.instance_variable_get("test") }.should raise_error(NameError) + -> { @obj.instance_variable_get("test") }.should.raise(NameError) end it "raises a NameError when the passed String is an invalid instance variable name" do - -> { @obj.instance_variable_get("@0") }.should raise_error(NameError) + -> { @obj.instance_variable_get("@0") }.should.raise(NameError) end it "raises a NameError when passed '@' as an instance variable name" do - -> { @obj.instance_variable_get("@") }.should raise_error(NameError) + -> { @obj.instance_variable_get("@") }.should.raise(NameError) end end @@ -105,7 +105,7 @@ describe "Kernel#instance_variable_get when passed Integer" do end it "raises a TypeError" do - -> { @obj.instance_variable_get(10) }.should raise_error(TypeError) - -> { @obj.instance_variable_get(-10) }.should raise_error(TypeError) + -> { @obj.instance_variable_get(10) }.should.raise(TypeError) + -> { @obj.instance_variable_get(-10) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/kernel/instance_variable_set_spec.rb b/spec/ruby/core/kernel/instance_variable_set_spec.rb index 2c25f4366f..bf165a824e 100644 --- a/spec/ruby/core/kernel/instance_variable_set_spec.rb +++ b/spec/ruby/core/kernel/instance_variable_set_spec.rb @@ -18,26 +18,26 @@ describe "Kernel#instance_variable_set" do it "raises a NameError exception if the argument is not of form '@x'" do no_dog = Class.new - -> { no_dog.new.instance_variable_set(:c, "cat") }.should raise_error(NameError) + -> { no_dog.new.instance_variable_set(:c, "cat") }.should.raise(NameError) end it "raises a NameError exception if the argument is an invalid instance variable name" do digit_dog = Class.new - -> { digit_dog.new.instance_variable_set(:"@0", "cat") }.should raise_error(NameError) + -> { digit_dog.new.instance_variable_set(:"@0", "cat") }.should.raise(NameError) end it "raises a NameError when the argument is '@'" do dog_at = Class.new - -> { dog_at.new.instance_variable_set(:"@", "cat") }.should raise_error(NameError) + -> { dog_at.new.instance_variable_set(:"@", "cat") }.should.raise(NameError) end it "raises a TypeError if the instance variable name is an Integer" do - -> { "".instance_variable_set(1, 2) }.should raise_error(TypeError) + -> { "".instance_variable_set(1, 2) }.should.raise(TypeError) end it "raises a TypeError if the instance variable name is an object that does not respond to to_str" do class KernelSpecs::A; end - -> { "".instance_variable_set(KernelSpecs::A.new, 3) }.should raise_error(TypeError) + -> { "".instance_variable_set(KernelSpecs::A.new, 3) }.should.raise(TypeError) end it "raises a NameError if the passed object, when coerced with to_str, does not start with @" do @@ -46,11 +46,11 @@ describe "Kernel#instance_variable_set" do ":c" end end - -> { "".instance_variable_set(KernelSpecs::B.new, 4) }.should raise_error(NameError) + -> { "".instance_variable_set(KernelSpecs::B.new, 4) }.should.raise(NameError) end it "raises a NameError if pass an object that cannot be a symbol" do - -> { "".instance_variable_set(:c, 1) }.should raise_error(NameError) + -> { "".instance_variable_set(:c, 1) }.should.raise(NameError) end it "accepts as instance variable name any instance of a class that responds to to_str" do @@ -78,16 +78,16 @@ describe "Kernel#instance_variable_set" do end it "keeps stored object after any exceptions" do - -> { @frozen.instance_variable_set(:@ivar, :replacement) }.should raise_error(Exception) - @frozen.ivar.should equal(:origin) + -> { @frozen.instance_variable_set(:@ivar, :replacement) }.should.raise(Exception) + @frozen.ivar.should.equal?(:origin) end it "raises a FrozenError when passed replacement is identical to stored object" do - -> { @frozen.instance_variable_set(:@ivar, :origin) }.should raise_error(FrozenError) + -> { @frozen.instance_variable_set(:@ivar, :origin) }.should.raise(FrozenError) end it "raises a FrozenError when passed replacement is different from stored object" do - -> { @frozen.instance_variable_set(:@ivar, :replacement) }.should raise_error(FrozenError) + -> { @frozen.instance_variable_set(:@ivar, :replacement) }.should.raise(FrozenError) end it "accepts unicode instance variable names" do @@ -97,9 +97,9 @@ describe "Kernel#instance_variable_set" do end it "raises for frozen objects" do - -> { nil.instance_variable_set(:@foo, 42) }.should raise_error(FrozenError) - -> { nil.instance_variable_set(:foo, 42) }.should raise_error(NameError) - -> { :foo.instance_variable_set(:@foo, 42) }.should raise_error(FrozenError) + -> { nil.instance_variable_set(:@foo, 42) }.should.raise(FrozenError) + -> { nil.instance_variable_set(:foo, 42) }.should.raise(NameError) + -> { :foo.instance_variable_set(:@foo, 42) }.should.raise(FrozenError) end end end diff --git a/spec/ruby/core/kernel/instance_variables_spec.rb b/spec/ruby/core/kernel/instance_variables_spec.rb index 677d8bb7b2..75c1d8f752 100644 --- a/spec/ruby/core/kernel/instance_variables_spec.rb +++ b/spec/ruby/core/kernel/instance_variables_spec.rb @@ -11,7 +11,7 @@ describe "Kernel#instance_variables" do it "returns the correct array if an instance variable is added" do a = 0 - ->{ a.instance_variable_set("@test", 1) }.should raise_error(RuntimeError) + ->{ a.instance_variable_set("@test", 1) }.should.raise(RuntimeError) end end diff --git a/spec/ruby/core/kernel/itself_spec.rb b/spec/ruby/core/kernel/itself_spec.rb index c906d7c3e8..c1f01fdc5e 100644 --- a/spec/ruby/core/kernel/itself_spec.rb +++ b/spec/ruby/core/kernel/itself_spec.rb @@ -4,6 +4,6 @@ require_relative 'fixtures/classes' describe "Kernel#itself" do it "returns the receiver itself" do foo = Object.new - foo.itself.should equal foo + foo.itself.should.equal? foo end end diff --git a/spec/ruby/core/kernel/lambda_spec.rb b/spec/ruby/core/kernel/lambda_spec.rb index 565536ac0d..6ab89c2bbb 100644 --- a/spec/ruby/core/kernel/lambda_spec.rb +++ b/spec/ruby/core/kernel/lambda_spec.rb @@ -8,92 +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 - - ruby_version_is ""..."3.3" do - 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 - end + 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 @@ -101,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 @@ -119,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 @@ -134,21 +94,13 @@ 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 - ruby_version_is ""..."3.3" do - it "warns when proc isn't a lambda" do - -> { lambda(&proc{}) }.should complain("#{__FILE__}:#{__LINE__}: warning: lambda without a literal block is deprecated; use the proc without lambda instead\n") - end - end - - ruby_version_is "3.3" do - it "raises when proc isn't a lambda" do - -> { lambda(&proc{}) }.should raise_error(ArgumentError, /the lambda method requires a literal block/) - end + 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 diff --git a/spec/ruby/core/kernel/load_spec.rb b/spec/ruby/core/kernel/load_spec.rb index a165cc4acd..890aab8c27 100644 --- a/spec/ruby/core/kernel/load_spec.rb +++ b/spec/ruby/core/kernel/load_spec.rb @@ -13,7 +13,7 @@ describe "Kernel#load" do end it "is a private method" do - Kernel.should have_private_instance_method(:load) + Kernel.private_instance_methods(false).should.include?(:load) end it_behaves_like :kernel_require_basic, :load, CodeLoadingSpecs::Method.new diff --git a/spec/ruby/core/kernel/local_variables_spec.rb b/spec/ruby/core/kernel/local_variables_spec.rb index f6f1e15f52..40c343f7e4 100644 --- a/spec/ruby/core/kernel/local_variables_spec.rb +++ b/spec/ruby/core/kernel/local_variables_spec.rb @@ -7,14 +7,13 @@ describe "Kernel#local_variables" do end it "is a private method" do - Kernel.should have_private_instance_method(:local_variables) + Kernel.private_instance_methods(false).should.include?(:local_variables) end it "contains locals as they are added" do a = 1 b = 2 - local_variables.should include(:a, :b) - local_variables.length.should == 2 + local_variables.sort.should == [:a, :b] end it "is accessible from bindings" do @@ -25,14 +24,12 @@ describe "Kernel#local_variables" do end foo_binding = local_var_foo() res = eval("local_variables",foo_binding) - res.should include(:a, :b) - res.length.should == 2 + res.sort.should == [:a, :b] end it "is accessible in eval" do eval "a=1; b=2; ScratchPad.record local_variables" - ScratchPad.recorded.should include(:a, :b) - ScratchPad.recorded.length.should == 2 + ScratchPad.recorded.sort.should == [:a, :b] end it "includes only unique variable names" do diff --git a/spec/ruby/core/kernel/loop_spec.rb b/spec/ruby/core/kernel/loop_spec.rb index 7c76c7d28e..c2976e5cc5 100644 --- a/spec/ruby/core/kernel/loop_spec.rb +++ b/spec/ruby/core/kernel/loop_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel.loop" do it "is a private method" do - Kernel.should have_private_instance_method(:loop) + Kernel.private_instance_methods(false).should.include?(:loop) end it "calls block until it is terminated by a break" do @@ -30,7 +30,7 @@ describe "Kernel.loop" do it "returns an enumerator if no block given" do enum = loop - enum.instance_of?(Enumerator).should be_true + enum.instance_of?(Enumerator).should == true cnt = 0 enum.each do |*args| raise "Args should be empty #{args.inspect}" unless args.empty? @@ -55,7 +55,7 @@ describe "Kernel.loop" do end it "does not rescue other errors" do - ->{ loop do raise StandardError end }.should raise_error( StandardError ) + ->{ loop do raise StandardError end }.should.raise( StandardError ) end it "returns StopIteration#result, the result value of a finished iterator" do diff --git a/spec/ruby/core/kernel/match_spec.rb b/spec/ruby/core/kernel/match_spec.rb index aa25006163..cd6330fe91 100644 --- a/spec/ruby/core/kernel/match_spec.rb +++ b/spec/ruby/core/kernel/match_spec.rb @@ -1,30 +1,7 @@ require_relative '../../spec_helper' describe "Kernel#=~" do - ruby_version_is ''...'3.2' do - it "returns nil matching any object" do - o = Object.new - - suppress_warning do - (o =~ /Object/).should be_nil - (o =~ 'Object').should be_nil - (o =~ Object).should be_nil - (o =~ Object.new).should be_nil - (o =~ nil).should be_nil - (o =~ true).should be_nil - end - end - - it "is deprecated" do - -> do - Object.new =~ /regexp/ - end.should complain(/deprecated Object#=~ is called on Object/, verbose: true) - end - end - - ruby_version_is '3.2' do - it "is no longer defined" do - Object.new.should_not.respond_to?(:=~) - end + it "is no longer defined" do + Object.new.should_not.respond_to?(:=~) end end diff --git a/spec/ruby/core/kernel/method_spec.rb b/spec/ruby/core/kernel/method_spec.rb index 3fc566d6a6..9187b8c7e7 100644 --- a/spec/ruby/core/kernel/method_spec.rb +++ b/spec/ruby/core/kernel/method_spec.rb @@ -11,12 +11,12 @@ describe "Kernel#method" do it "can be called on a private method" do @obj.send(:private_method).should == :private_method - @obj.method(:private_method).should be_an_instance_of(Method) + @obj.method(:private_method).should.instance_of?(Method) end it "can be called on a protected method" do @obj.send(:protected_method).should == :protected_method - @obj.method(:protected_method).should be_an_instance_of(Method) + @obj.method(:protected_method).should.instance_of?(Method) end it "will see an alias of the original method as == when in a derived class" do @@ -31,7 +31,7 @@ describe "Kernel#method" do it "can be called even if we only respond_to_missing? method, true" do m = KernelSpecs::RespondViaMissing.new.method(:handled_privately) - m.should be_an_instance_of(Method) + m.should.instance_of?(Method) m.call(1, 2, 3).should == "Done handled_privately([1, 2, 3])" end @@ -45,7 +45,7 @@ describe "Kernel#method" do end end m = cls.new.method(:foo) - -> { m.call }.should raise_error(ArgumentError) + -> { m.call }.should.raise(ArgumentError) cls = Class.new do def respond_to_missing?(name, *) @@ -67,14 +67,22 @@ describe "Kernel#method" do end it "raises a TypeError if the given name can't be converted to a String" do - -> { Object.method(nil) }.should raise_error(TypeError) - -> { Object.method([]) }.should raise_error(TypeError) + -> { Object.method(nil) }.should.raise(TypeError) + -> { Object.method([]) }.should.raise(TypeError) end it "raises a NoMethodError if the given argument raises a NoMethodError during type coercion to a String" do name = mock("method-name") name.should_receive(:to_str).and_raise(NoMethodError) - -> { Object.method(name) }.should raise_error(NoMethodError) + -> { Object.method(name) }.should.raise(NoMethodError) + + name = mock("method-name") + name.should_receive(:to_str).and_raise(NoMethodError) + begin + raise RuntimeError.new + rescue => cause + -> { Object.method(name) }.should.raise(NoMethodError, cause:) + end end end end diff --git a/spec/ruby/core/kernel/methods_spec.rb b/spec/ruby/core/kernel/methods_spec.rb index fb7a7e8be9..cfa22aa05a 100644 --- a/spec/ruby/core/kernel/methods_spec.rb +++ b/spec/ruby/core/kernel/methods_spec.rb @@ -5,67 +5,67 @@ require_relative '../../fixtures/reflection' # TODO: rewrite describe "Kernel#methods" do it "returns singleton methods defined by obj.meth" do - KernelSpecs::Methods.methods(false).should include(:ichi) + KernelSpecs::Methods.methods(false).should.include?(:ichi) end it "returns singleton methods defined in 'class << self'" do - KernelSpecs::Methods.methods(false).should include(:san) + KernelSpecs::Methods.methods(false).should.include?(:san) end it "returns private singleton methods defined by obj.meth" do - KernelSpecs::Methods.methods(false).should include(:shi) + KernelSpecs::Methods.methods(false).should.include?(:shi) end it "returns singleton methods defined in 'class << self' when it follows 'private'" do - KernelSpecs::Methods.methods(false).should include(:roku) + KernelSpecs::Methods.methods(false).should.include?(:roku) end it "does not return private singleton methods defined in 'class << self'" do - KernelSpecs::Methods.methods(false).should_not include(:shichi) + KernelSpecs::Methods.methods(false).should_not.include?(:shichi) end it "returns the publicly accessible methods of the object" do meths = KernelSpecs::Methods.methods(false) - meths.should include(:hachi, :ichi, :juu, :juu_ichi, - :juu_ni, :roku, :san, :shi) + meths.to_set.should >= Set[:hachi, :ichi, :juu, :juu_ichi, + :juu_ni, :roku, :san, :shi] KernelSpecs::Methods.new.methods(false).should == [] end it "returns the publicly accessible methods in the object, its ancestors and mixed-in modules" do meths = KernelSpecs::Methods.methods(false) & KernelSpecs::Methods.methods - meths.should include(:hachi, :ichi, :juu, :juu_ichi, - :juu_ni, :roku, :san, :shi) + meths.to_set.should >= Set[:hachi, :ichi, :juu, :juu_ichi, + :juu_ni, :roku, :san, :shi] - KernelSpecs::Methods.new.methods.should include(:ku, :ni, :juu_san) + KernelSpecs::Methods.new.methods.to_set.should >= Set[:ku, :ni, :juu_san] end it "returns methods added to the metaclass through extend" do meth = KernelSpecs::Methods.new - meth.methods.should_not include(:peekaboo) + meth.methods.should_not.include?(:peekaboo) meth.extend(KernelSpecs::Methods::MetaclassMethods) - meth.methods.should include(:peekaboo) + meth.methods.should.include?(:peekaboo) end it "does not return undefined singleton methods defined by obj.meth" do o = KernelSpecs::Child.new def o.single; end - o.methods.should include(:single) + o.methods.should.include?(:single) class << o; self; end.send :undef_method, :single - o.methods.should_not include(:single) + o.methods.should_not.include?(:single) end it "does not return superclass methods undefined in the object's class" do - KernelSpecs::Child.new.methods.should_not include(:parent_method) + KernelSpecs::Child.new.methods.should_not.include?(:parent_method) end it "does not return superclass methods undefined in a superclass" do - KernelSpecs::Grandchild.new.methods.should_not include(:parent_method) + KernelSpecs::Grandchild.new.methods.should_not.include?(:parent_method) end it "does not return included module methods undefined in the object's class" do - KernelSpecs::Grandchild.new.methods.should_not include(:parent_mixin_method) + KernelSpecs::Grandchild.new.methods.should_not.include?(:parent_mixin_method) end end diff --git a/spec/ruby/core/kernel/not_match_spec.rb b/spec/ruby/core/kernel/not_match_spec.rb index f8dd82fad8..4ed7ea7b42 100644 --- a/spec/ruby/core/kernel/not_match_spec.rb +++ b/spec/ruby/core/kernel/not_match_spec.rb @@ -14,18 +14,8 @@ describe "Kernel#!~" do (obj !~ :foo).should == false end - ruby_version_is ""..."3.2" do - it "returns true if self does not respond to #=~" do - suppress_warning do - (Object.new !~ :foo).should == true - end - end - end - - ruby_version_is "3.2" do - it "raises NoMethodError if self does not respond to #=~" do - -> { Object.new !~ :foo }.should raise_error(NoMethodError) - end + it "raises NoMethodError if self does not respond to #=~" do + -> { Object.new !~ :foo }.should.raise(NoMethodError) end it 'can be overridden in subclasses' do diff --git a/spec/ruby/core/kernel/open_spec.rb b/spec/ruby/core/kernel/open_spec.rb index bb42c31f31..14a3c43cad 100644 --- a/spec/ruby/core/kernel/open_spec.rb +++ b/spec/ruby/core/kernel/open_spec.rb @@ -15,70 +15,70 @@ describe "Kernel#open" do end it "is a private method" do - Kernel.should have_private_instance_method(:open) + Kernel.private_instance_methods(false).should.include?(:open) end it "opens a file when given a valid filename" do @file = open(@name) - @file.should be_kind_of(File) + @file.should.is_a?(File) end it "opens a file when called with a block" do open(@name, "r") { |f| f.gets }.should == @content end - platform_is_not :windows, :wasi do - it "opens an io when path starts with a pipe" do - suppress_warning do # https://bugs.ruby-lang.org/issues/19630 - @io = open("|date") + ruby_version_is ""..."4.0" do + platform_is_not :windows, :wasi do + it "opens an io when path starts with a pipe" do + suppress_warning do # https://bugs.ruby-lang.org/issues/19630 + @io = open("|date") + end + begin + @io.should.is_a?(IO) + @io.read + ensure + @io.close + end end - begin - @io.should be_kind_of(IO) - @io.read - ensure - @io.close - end - end - it "opens an io when called with a block" do - suppress_warning do # https://bugs.ruby-lang.org/issues/19630 - @output = open("|date") { |f| f.read } + it "opens an io when called with a block" do + suppress_warning do # https://bugs.ruby-lang.org/issues/19630 + @output = open("|date") { |f| f.read } + end + @output.should_not == '' end - @output.should_not == '' - end - it "opens an io for writing" do - suppress_warning do # https://bugs.ruby-lang.org/issues/19630 - -> { - bytes = open("|cat", "w") { |io| io.write(".") } - bytes.should == 1 - }.should output_to_fd(".") + it "opens an io for writing" do + suppress_warning do # https://bugs.ruby-lang.org/issues/19630 + -> { + bytes = open("|cat", "w") { |io| io.write(".") } + bytes.should == 1 + }.should output_to_fd(".") + end end end - end - platform_is :windows do - it "opens an io when path starts with a pipe" do - suppress_warning do # https://bugs.ruby-lang.org/issues/19630 - @io = open("|date /t") + platform_is :windows do + it "opens an io when path starts with a pipe" do + suppress_warning do # https://bugs.ruby-lang.org/issues/19630 + @io = open("|date /t") + end + begin + @io.should.is_a?(IO) + @io.read + ensure + @io.close + end end - begin - @io.should be_kind_of(IO) - @io.read - ensure - @io.close - end - end - it "opens an io when called with a block" do - suppress_warning do # https://bugs.ruby-lang.org/issues/19630 - @output = open("|date /t") { |f| f.read } + it "opens an io when called with a block" do + suppress_warning do # https://bugs.ruby-lang.org/issues/19630 + @output = open("|date /t") { |f| f.read } + end + @output.should_not == '' end - @output.should_not == '' end - end - ruby_version_is "3.3" do # https://bugs.ruby-lang.org/issues/19630 it "warns about deprecation given a path with a pipe" do cmd = "|echo ok" @@ -89,16 +89,16 @@ describe "Kernel#open" do end it "raises an ArgumentError if not passed one argument" do - -> { open }.should raise_error(ArgumentError) + -> { open }.should.raise(ArgumentError) end it "accepts options as keyword arguments" do @file = open(@name, "r", 0666, flags: File::CREAT) - @file.should be_kind_of(File) + @file.should.is_a?(File) -> { open(@name, "r", 0666, {flags: File::CREAT}) - }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)") + }.should.raise(ArgumentError, "wrong number of arguments (given 4, expected 1..3)") end describe "when given an object that responds to to_open" do @@ -106,7 +106,7 @@ describe "Kernel#open" do ScratchPad.clear end - it "calls #to_path to covert the argument to a String before calling #to_str" do + it "calls #to_path to convert the argument to a String before calling #to_str" do obj = mock("open to_path") obj.should_receive(:to_path).at_least(1).times.and_return(@name) obj.should_not_receive(:to_str) @@ -126,7 +126,7 @@ describe "Kernel#open" do @file = File.open(@name) obj.should_receive(:to_open).and_return(@file) @file = open(obj) - @file.should be_kind_of(File) + @file.should.is_a?(File) end it "returns the value from #to_open" do @@ -167,9 +167,9 @@ describe "Kernel#open" do it "raises a TypeError if passed a non-String that does not respond to #to_open" do obj = mock('non-fileish') - -> { open(obj) }.should raise_error(TypeError) - -> { open(nil) }.should raise_error(TypeError) - -> { open(7) }.should raise_error(TypeError) + -> { open(obj) }.should.raise(TypeError) + -> { open(nil) }.should.raise(TypeError) + -> { open(7) }.should.raise(TypeError) end it "accepts nil for mode and permission" do diff --git a/spec/ruby/core/kernel/p_spec.rb b/spec/ruby/core/kernel/p_spec.rb index eae191aa54..f89716899a 100644 --- a/spec/ruby/core/kernel/p_spec.rb +++ b/spec/ruby/core/kernel/p_spec.rb @@ -13,7 +13,7 @@ describe "Kernel#p" do end it "is a private method" do - Kernel.should have_private_instance_method(:p) + Kernel.private_instance_methods(false).should.include?(:p) end # TODO: fix diff --git a/spec/ruby/core/kernel/print_spec.rb b/spec/ruby/core/kernel/print_spec.rb index 7e7c9b822d..5473d22f71 100644 --- a/spec/ruby/core/kernel/print_spec.rb +++ b/spec/ruby/core/kernel/print_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#print" do it "is a private method" do - Kernel.should have_private_instance_method(:print) + Kernel.private_instance_methods(false).should.include?(:print) end it "delegates to $stdout" do diff --git a/spec/ruby/core/kernel/printf_spec.rb b/spec/ruby/core/kernel/printf_spec.rb index 61bf955c25..50939b3794 100644 --- a/spec/ruby/core/kernel/printf_spec.rb +++ b/spec/ruby/core/kernel/printf_spec.rb @@ -4,7 +4,7 @@ require_relative 'shared/sprintf' describe "Kernel#printf" do it "is a private method" do - Kernel.should have_private_instance_method(:printf) + Kernel.private_instance_methods(false).should.include?(:printf) end end diff --git a/spec/ruby/core/kernel/private_methods_spec.rb b/spec/ruby/core/kernel/private_methods_spec.rb index 041634d1e5..b0e6d042a9 100644 --- a/spec/ruby/core/kernel/private_methods_spec.rb +++ b/spec/ruby/core/kernel/private_methods_spec.rb @@ -6,23 +6,23 @@ require_relative '../../fixtures/reflection' describe "Kernel#private_methods" do it "returns a list of the names of privately accessible methods in the object" do m = KernelSpecs::Methods.private_methods(false) - m.should include(:shichi) + m.should.include?(:shichi) m = KernelSpecs::Methods.new.private_methods(false) - m.should include(:juu_shi) + m.should.include?(:juu_shi) end it "returns a list of the names of privately accessible methods in the object and its ancestors and mixed-in modules" do m = (KernelSpecs::Methods.private_methods(false) & KernelSpecs::Methods.private_methods) - m.should include(:shichi) + m.should.include?(:shichi) m = KernelSpecs::Methods.new.private_methods - m.should include(:juu_shi) + m.should.include?(:juu_shi) end it "returns private methods mixed in to the metaclass" do m = KernelSpecs::Methods.new m.extend(KernelSpecs::Methods::MetaclassMethods) - m.private_methods.should include(:shoo) + m.private_methods.should.include?(:shoo) end end diff --git a/spec/ruby/core/kernel/proc_spec.rb b/spec/ruby/core/kernel/proc_spec.rb index 6553b8fd04..1ba662177b 100644 --- a/spec/ruby/core/kernel/proc_spec.rb +++ b/spec/ruby/core/kernel/proc_spec.rb @@ -6,20 +6,20 @@ require_relative 'shared/lambda' describe "Kernel.proc" do it "is a private method" do - Kernel.should have_private_instance_method(:proc) + Kernel.private_instance_methods(false).should.include?(:proc) end it "creates a proc-style Proc if given a literal block" do l = proc { 42 } - l.lambda?.should be_false + l.lambda?.should == false end it "returned the passed Proc if given an existing Proc" do some_lambda = -> {} - some_lambda.lambda?.should be_true + some_lambda.lambda?.should == true l = proc(&some_lambda) - l.should equal(some_lambda) - l.lambda?.should be_true + l.should.equal?(some_lambda) + l.lambda?.should == true end it_behaves_like :kernel_lambda, :proc @@ -31,7 +31,7 @@ describe "Kernel.proc" do @reached_end_of_method = true end test - @reached_end_of_method.should be_nil + @reached_end_of_method.should == nil end end @@ -43,6 +43,6 @@ describe "Kernel#proc" do it "raises an ArgumentError when passed no block" do -> { some_method { "hello" } - }.should raise_error(ArgumentError, 'tried to create Proc object without a block') + }.should.raise(ArgumentError, 'tried to create Proc object without a block') end end diff --git a/spec/ruby/core/kernel/protected_methods_spec.rb b/spec/ruby/core/kernel/protected_methods_spec.rb index d3334e886b..aecb9f5ffb 100644 --- a/spec/ruby/core/kernel/protected_methods_spec.rb +++ b/spec/ruby/core/kernel/protected_methods_spec.rb @@ -8,21 +8,21 @@ require_relative '../../fixtures/reflection' # You should use have_protected_method() with the exception of this spec. describe "Kernel#protected_methods" do it "returns a list of the names of protected methods accessible in the object" do - KernelSpecs::Methods.protected_methods(false).sort.should include(:juu_ichi) - KernelSpecs::Methods.new.protected_methods(false).should include(:ku) + KernelSpecs::Methods.protected_methods(false).sort.should.include?(:juu_ichi) + KernelSpecs::Methods.new.protected_methods(false).should.include?(:ku) end it "returns a list of the names of protected methods accessible in the object and from its ancestors and mixed-in modules" do l1 = KernelSpecs::Methods.protected_methods(false) l2 = KernelSpecs::Methods.protected_methods - (l1 & l2).should include(:juu_ichi) - KernelSpecs::Methods.new.protected_methods.should include(:ku) + (l1 & l2).should.include?(:juu_ichi) + KernelSpecs::Methods.new.protected_methods.should.include?(:ku) end it "returns methods mixed in to the metaclass" do m = KernelSpecs::Methods.new m.extend(KernelSpecs::Methods::MetaclassMethods) - m.protected_methods.should include(:nopeeking) + m.protected_methods.should.include?(:nopeeking) end end diff --git a/spec/ruby/core/kernel/public_method_spec.rb b/spec/ruby/core/kernel/public_method_spec.rb index c5d54c777e..42b8f797d3 100644 --- a/spec/ruby/core/kernel/public_method_spec.rb +++ b/spec/ruby/core/kernel/public_method_spec.rb @@ -13,20 +13,20 @@ describe "Kernel#public_method" do @obj.send(:private_method).should == :private_method -> do @obj.public_method(:private_method) - end.should raise_error(NameError) + end.should.raise(NameError) end it "raises a NameError when called on a protected method" do @obj.send(:protected_method).should == :protected_method -> { @obj.public_method(:protected_method) - }.should raise_error(NameError) + }.should.raise(NameError) end it "raises a NameError if we only repond_to_missing? method, true" do obj = KernelSpecs::RespondViaMissing.new -> do obj.public_method(:handled_privately) - end.should raise_error(NameError) + end.should.raise(NameError) end end diff --git a/spec/ruby/core/kernel/public_methods_spec.rb b/spec/ruby/core/kernel/public_methods_spec.rb index a5512784fb..e334ac9a55 100644 --- a/spec/ruby/core/kernel/public_methods_spec.rb +++ b/spec/ruby/core/kernel/public_methods_spec.rb @@ -5,31 +5,30 @@ require_relative '../../fixtures/reflection' # TODO: rewrite describe "Kernel#public_methods" do it "returns a list of the names of publicly accessible methods in the object" do - KernelSpecs::Methods.public_methods(false).sort.should include(:hachi, - :ichi, :juu, :juu_ni, :roku, :san, :shi) - KernelSpecs::Methods.new.public_methods(false).sort.should include(:juu_san, :ni) + KernelSpecs::Methods.public_methods(false).to_set.should >= Set[:hachi, :ichi, :juu, :juu_ni, :roku, :san, :shi] + KernelSpecs::Methods.new.public_methods(false).to_set.should >= Set[:juu_san, :ni] end it "returns a list of names without protected accessible methods in the object" do - KernelSpecs::Methods.public_methods(false).sort.should_not include(:juu_ichi) - KernelSpecs::Methods.new.public_methods(false).sort.should_not include(:ku) + KernelSpecs::Methods.public_methods(false).sort.should_not.include?(:juu_ichi) + KernelSpecs::Methods.new.public_methods(false).sort.should_not.include?(:ku) end it "returns a list of the names of publicly accessible methods in the object and its ancestors and mixed-in modules" do - (KernelSpecs::Methods.public_methods(false) & KernelSpecs::Methods.public_methods).sort.should include( - :hachi, :ichi, :juu, :juu_ni, :roku, :san, :shi) + (KernelSpecs::Methods.public_methods(false) & KernelSpecs::Methods.public_methods).to_set.should >= Set[ + :hachi, :ichi, :juu, :juu_ni, :roku, :san, :shi] m = KernelSpecs::Methods.new.public_methods - m.should include(:ni, :juu_san) + m.to_set.should >= Set[:ni, :juu_san] end it "returns methods mixed in to the metaclass" do m = KernelSpecs::Methods.new m.extend(KernelSpecs::Methods::MetaclassMethods) - m.public_methods.should include(:peekaboo) + m.public_methods.should.include?(:peekaboo) end it "returns public methods for immediates" do - 10.public_methods.should include(:divmod) + 10.public_methods.should.include?(:divmod) end end diff --git a/spec/ruby/core/kernel/public_send_spec.rb b/spec/ruby/core/kernel/public_send_spec.rb index b684b1729c..6a4a969c77 100644 --- a/spec/ruby/core/kernel/public_send_spec.rb +++ b/spec/ruby/core/kernel/public_send_spec.rb @@ -29,7 +29,7 @@ describe "Kernel#public_send" do 'done' end end - -> { KernelSpecs::Foo.new.public_send(:bar)}.should raise_error(NoMethodError) + -> { KernelSpecs::Foo.new.public_send(:bar)}.should.raise(NoMethodError) end it "raises a NoMethodError if the named method is private" do @@ -41,7 +41,7 @@ describe "Kernel#public_send" do end -> { KernelSpecs::Foo.new.public_send(:bar) - }.should raise_error(NoMethodError) + }.should.raise(NoMethodError) end context 'called from own public method' do @@ -70,11 +70,11 @@ describe "Kernel#public_send" do end it "raises a NoMethodError if the method is protected" do - -> { @receiver.call_protected_method }.should raise_error(NoMethodError) + -> { @receiver.call_protected_method }.should.raise(NoMethodError) end it "raises a NoMethodError if the method is private" do - -> { @receiver.call_private_method }.should raise_error(NoMethodError) + -> { @receiver.call_private_method }.should.raise(NoMethodError) end end @@ -88,7 +88,7 @@ describe "Kernel#public_send" do end -> { KernelSpecs::Foo.new.public_send(:aka) - }.should raise_error(NoMethodError) + }.should.raise(NoMethodError) end it "raises a NoMethodError if the named method is an alias of a protected method" do @@ -101,15 +101,15 @@ describe "Kernel#public_send" do end -> { KernelSpecs::Foo.new.public_send(:aka) - }.should raise_error(NoMethodError) + }.should.raise(NoMethodError) end it "includes `public_send` in the backtrace when passed not enough arguments" do - -> { public_send() }.should raise_error(ArgumentError) { |e| e.backtrace[0].should =~ /[`'](?:Kernel#)?public_send'/ } + -> { public_send() }.should.raise(ArgumentError) { |e| e.backtrace[0].should =~ /[`'](?:Kernel#)?public_send'/ } end it "includes `public_send` in the backtrace when passed a single incorrect argument" do - -> { public_send(Object.new) }.should raise_error(TypeError) { |e| e.backtrace[0].should =~ /[`'](?:Kernel#)?public_send'/ } + -> { public_send(Object.new) }.should.raise(TypeError) { |e| e.backtrace[0].should =~ /[`'](?:Kernel#)?public_send'/ } end it_behaves_like :basicobject_send, :public_send diff --git a/spec/ruby/core/kernel/putc_spec.rb b/spec/ruby/core/kernel/putc_spec.rb index 74bd3765db..e6a20a9af1 100644 --- a/spec/ruby/core/kernel/putc_spec.rb +++ b/spec/ruby/core/kernel/putc_spec.rb @@ -4,7 +4,7 @@ require_relative '../../shared/io/putc' describe "Kernel#putc" do it "is a private instance method" do - Kernel.should have_private_instance_method(:putc) + Kernel.private_instance_methods(false).should.include?(:putc) end end diff --git a/spec/ruby/core/kernel/puts_spec.rb b/spec/ruby/core/kernel/puts_spec.rb index 6eb38e8fcf..eed18fcd50 100644 --- a/spec/ruby/core/kernel/puts_spec.rb +++ b/spec/ruby/core/kernel/puts_spec.rb @@ -15,7 +15,7 @@ describe "Kernel#puts" do end it "is a private method" do - Kernel.should have_private_instance_method(:puts) + Kernel.private_instance_methods(false).should.include?(:puts) end it "delegates to $stdout.puts" do diff --git a/spec/ruby/core/kernel/raise_spec.rb b/spec/ruby/core/kernel/raise_spec.rb index a038dcf031..6162677e17 100644 --- a/spec/ruby/core/kernel/raise_spec.rb +++ b/spec/ruby/core/kernel/raise_spec.rb @@ -4,9 +4,19 @@ require_relative '../../shared/kernel/raise' describe "Kernel#raise" do it "is a private method" do - Kernel.should have_private_instance_method(:raise) + Kernel.private_instance_methods.should.include?(:raise) end + # Shared specs expect a public #raise method. + public_raiser = Object.new + class << public_raiser + public :raise + end + it_behaves_like :kernel_raise, :raise, public_raiser + it_behaves_like :kernel_raise_with_cause, :raise, public_raiser +end + +describe "Kernel#raise with previously rescued exception" do it "re-raises the previously rescued exception if no exception is specified" do ScratchPad.record nil @@ -23,51 +33,190 @@ describe "Kernel#raise" do raise ScratchPad.record :no_reraise end - end.should raise_error(Exception, "outer") + end.should.raise(Exception, "outer") - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end - it "accepts a cause keyword argument that sets the cause" do - cause = StandardError.new - -> { raise("error", cause: cause) }.should raise_error(RuntimeError) { |e| e.cause.should == cause } + it "re-raises a previously rescued exception without overwriting the cause" do + begin + begin + begin + begin + raise "Error 1" + rescue => e1 + raise "Error 2" + end + rescue => e2 + raise "Error 3" + end + rescue + e2.cause.should == e1 + raise e2 + end + rescue => e + e.cause.should == e1 + end + end + + it "re-raises a previously rescued exception with overwriting the cause when it's explicitly specified with :cause option" do + e4 = RuntimeError.new("Error 4") + + begin + begin + begin + begin + raise "Error 1" + rescue => e1 + raise "Error 2" + end + rescue => e2 + raise "Error 3" + end + rescue + e2.cause.should == e1 + raise e2, cause: e4 + end + rescue => e + e.cause.should == e4 + end end - it "accepts a cause keyword argument that overrides the last exception" do + it "re-raises a previously rescued exception without overwriting the cause when it's explicitly specified with :cause option and has nil value" do begin - raise "first raise" - rescue => ignored - cause = StandardError.new - -> { raise("error", cause: cause) }.should raise_error(RuntimeError) { |e| e.cause.should == cause } + begin + begin + begin + raise "Error 1" + rescue => e1 + raise "Error 2" + end + rescue => e2 + raise "Error 3" + end + rescue + e2.cause.should == e1 + raise e2, cause: nil + end + rescue => e + e.cause.should == e1 end end - it "raises an ArgumentError when only cause is given" do - cause = StandardError.new - -> { raise(cause: cause) }.should raise_error(ArgumentError) + it "re-raises a previously rescued exception without setting a cause implicitly" do + begin + begin + raise "Error 1" + rescue => e1 + raise + end + rescue => e + e.should == e1 + e.cause.should == nil + end end - it "re-raises a rescued exception" do - -> do + it "re-raises a previously rescued exception that has a cause without setting a cause implicitly" do + begin begin - raise StandardError, "aaa" - rescue Exception + raise "Error 1" + rescue => e1 begin - raise ArgumentError - rescue ArgumentError + raise "Error 2" + rescue => e2 + raise end + end + rescue => e + e.should == e2 + e.cause.should == e1 + end + end - # should raise StandardError "aaa" - raise + it "re-raises a previously rescued exception that doesn't have a cause and isn't a cause of any other exception with setting a cause implicitly" do + begin + begin + raise "Error 1" + rescue => e1 + begin + raise "Error 2" + rescue => e2 + raise "Error 3" + end end - end.should raise_error(StandardError, "aaa") + rescue => e + e.message.should == "Error 3" + e.cause.should == e2 + end end -end -describe "Kernel#raise" do - it_behaves_like :kernel_raise, :raise, Kernel + it "re-raises a previously rescued exception that doesn't have a cause and is a cause of other exception without setting a cause implicitly" do + begin + begin + raise "Error 1" + rescue => e1 + begin + raise "Error 2" + rescue => e2 + e1.cause.should == nil + e2.cause.should == e1 + raise e1 + end + end + rescue => e + e.should == e1 + e.cause.should == nil + end + end + + it "re-raises a previously rescued exception that doesn't have a cause and is a cause of other exception (that wasn't raised explicitly) without setting a cause implicitly" do + begin + begin + raise "Error 1" + rescue => e1 + begin + foo # raises NameError + rescue => e2 + e1.cause.should == nil + e2.cause.should == e1 + raise e1 + end + end + rescue => e + e.should == e1 + e.cause.should == nil + end + end + + it "re-raises a previously rescued exception that has a cause but isn't a cause of any other exception without setting a cause implicitly" do + begin + begin + raise "Error 1" + rescue => e1 + begin + raise "Error 2" + rescue => e2 + begin + raise "Error 3", cause: RuntimeError.new("Error 4") + rescue => e3 + e2.cause.should == e1 + e3.cause.should_not == e2 + raise e2 + end + end + end + rescue => e + e.should == e2 + e.cause.should == e1 + end + end end describe "Kernel.raise" do - it "needs to be reviewed for spec completeness" + it "is a public method" do + Kernel.singleton_class.should.public_method_defined?(:raise) + end + + it_behaves_like :kernel_raise, :raise, Kernel + it_behaves_like :kernel_raise_with_cause, :raise, Kernel end diff --git a/spec/ruby/core/kernel/rand_spec.rb b/spec/ruby/core/kernel/rand_spec.rb index 355e425792..1bf5e225d9 100644 --- a/spec/ruby/core/kernel/rand_spec.rb +++ b/spec/ruby/core/kernel/rand_spec.rb @@ -3,42 +3,42 @@ require_relative 'fixtures/classes' describe "Kernel#rand" do it "is a private method" do - Kernel.should have_private_instance_method(:rand) + Kernel.private_instance_methods(false).should.include?(:rand) end it "returns a float if no argument is passed" do - rand.should be_kind_of(Float) + rand.should.is_a?(Float) end it "returns an integer for an integer argument" do - rand(77).should be_kind_of(Integer) + rand(77).should.is_a?(Integer) end it "returns an integer for a float argument greater than 1" do - rand(1.3).should be_kind_of(Integer) + rand(1.3).should.is_a?(Integer) end it "returns a float for an argument between -1 and 1" do - rand(-0.999).should be_kind_of(Float) - rand(-0.01).should be_kind_of(Float) - rand(0).should be_kind_of(Float) - rand(0.01).should be_kind_of(Float) - rand(0.999).should be_kind_of(Float) + rand(-0.999).should.is_a?(Float) + rand(-0.01).should.is_a?(Float) + rand(0).should.is_a?(Float) + rand(0.01).should.is_a?(Float) + rand(0.999).should.is_a?(Float) end it "ignores the sign of the argument" do - [0, 1, 2, 3].should include(rand(-4)) + [0, 1, 2, 3].should.include?(rand(-4)) end it "never returns a value greater or equal to 1.0 with no arguments" do 1000.times do - (0...1.0).should include(rand) + (0...1.0).should.include?(rand) end end it "never returns a value greater or equal to any passed in max argument" do 1000.times do - (0...100).to_a.should include(rand(100)) + (0...100).to_a.should.include?(rand(100)) end end @@ -53,32 +53,32 @@ describe "Kernel#rand" do it "returns an Integer between the two Integers" do 1000.times do x = rand(4...6) - x.should be_kind_of(Integer) - (4...6).should include(x) + x.should.is_a?(Integer) + (4...6).should.include?(x) end end it "returns a Float between the given Integer and Float" do 1000.times do x = rand(4...6.5) - x.should be_kind_of(Float) - (4...6.5).should include(x) + x.should.is_a?(Float) + (4...6.5).should.include?(x) end end it "returns a Float between the given Float and Integer" do 1000.times do x = rand(3.5...6) - x.should be_kind_of(Float) - (3.5...6).should include(x) + x.should.is_a?(Float) + (3.5...6).should.include?(x) end end it "returns a Float between the two given Floats" do 1000.times do x = rand(3.5...6.5) - x.should be_kind_of(Float) - (3.5...6.5).should include(x) + x.should.is_a?(Float) + (3.5...6.5).should.include?(x) end end end @@ -87,32 +87,32 @@ describe "Kernel#rand" do it "returns an Integer between the two Integers" do 1000.times do x = rand(4..6) - x.should be_kind_of(Integer) - (4..6).should include(x) + x.should.is_a?(Integer) + (4..6).should.include?(x) end end it "returns a Float between the given Integer and Float" do 1000.times do x = rand(4..6.5) - x.should be_kind_of(Float) - (4..6.5).should include(x) + x.should.is_a?(Float) + (4..6.5).should.include?(x) end end it "returns a Float between the given Float and Integer" do 1000.times do x = rand(3.5..6) - x.should be_kind_of(Float) - (3.5..6).should include(x) + x.should.is_a?(Float) + (3.5..6).should.include?(x) end end it "returns a Float between the two given Floats" do 1000.times do x = rand(3.5..6.5) - x.should be_kind_of(Float) - (3.5..6.5).should include(x) + x.should.is_a?(Float) + (3.5..6.5).should.include?(x) end end end @@ -120,8 +120,8 @@ describe "Kernel#rand" do context "given an inclusive range between 0 and 1" do it "returns an Integer between the two Integers" do x = rand(0..1) - x.should be_kind_of(Integer) - (0..1).should include(x) + x.should.is_a?(Integer) + (0..1).should.include?(x) end it "returns a Float if at least one side is Float" do @@ -130,19 +130,19 @@ describe "Kernel#rand" do x2 = Random.new(seed).rand(0.0..1.0) x3 = Random.new(seed).rand(0.0..1) - x3.should be_kind_of(Float) - x1.should eql(x3) - x2.should eql(x3) + x3.should.is_a?(Float) + x1.should.eql?(x3) + x2.should.eql?(x3) - (0.0..1.0).should include(x3) + (0.0..1.0).should.include?(x3) end end context "given an exclusive range between 0 and 1" do it "returns zero as an Integer" do x = rand(0...1) - x.should be_kind_of(Integer) - x.should eql(0) + x.should.is_a?(Integer) + x.should.eql?(0) end it "returns a Float if at least one side is Float" do @@ -151,34 +151,34 @@ describe "Kernel#rand" do x2 = Random.new(seed).rand(0.0...1.0) x3 = Random.new(seed).rand(0.0...1) - x3.should be_kind_of(Float) - x1.should eql(x3) - x2.should eql(x3) + x3.should.is_a?(Float) + x1.should.eql?(x3) + x2.should.eql?(x3) - (0.0...1.0).should include(x3) + (0.0...1.0).should.include?(x3) end end it "returns a numeric for an range argument where max is < 1" do - rand(0.25..0.75).should be_kind_of(Numeric) + rand(0.25..0.75).should.is_a?(Numeric) end it "returns nil when range is backwards" do - rand(1..0).should be_nil + rand(1..0).should == nil end it "returns the range start/end when Float range is 0" do - rand(1.0..1.0).should eql(1.0) + rand(1.0..1.0).should.eql?(1.0) end it "returns the range start/end when Integer range is 0" do - rand(42..42).should eql(42) + rand(42..42).should.eql?(42) end it "supports custom object types" do - rand(KernelSpecs::CustomRangeInteger.new(1)..KernelSpecs::CustomRangeInteger.new(42)).should be_an_instance_of(KernelSpecs::CustomRangeInteger) - rand(KernelSpecs::CustomRangeFloat.new(1.0)..KernelSpecs::CustomRangeFloat.new(42.0)).should be_an_instance_of(KernelSpecs::CustomRangeFloat) - rand(Time.now..Time.now).should be_an_instance_of(Time) + rand(KernelSpecs::CustomRangeInteger.new(1)..KernelSpecs::CustomRangeInteger.new(42)).should.instance_of?(KernelSpecs::CustomRangeInteger) + rand(KernelSpecs::CustomRangeFloat.new(1.0)..KernelSpecs::CustomRangeFloat.new(42.0)).should.instance_of?(KernelSpecs::CustomRangeFloat) + rand(Time.now..Time.now).should.instance_of?(Time) end it "is random on boot" do diff --git a/spec/ruby/core/kernel/readline_spec.rb b/spec/ruby/core/kernel/readline_spec.rb index dce7b03dc8..86899d78d2 100644 --- a/spec/ruby/core/kernel/readline_spec.rb +++ b/spec/ruby/core/kernel/readline_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#readline" do it "is a private method" do - Kernel.should have_private_instance_method(:readline) + Kernel.private_instance_methods(false).should.include?(:readline) end end diff --git a/spec/ruby/core/kernel/readlines_spec.rb b/spec/ruby/core/kernel/readlines_spec.rb index 2b6d65fff2..c758014aab 100644 --- a/spec/ruby/core/kernel/readlines_spec.rb +++ b/spec/ruby/core/kernel/readlines_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#readlines" do it "is a private method" do - Kernel.should have_private_instance_method(:readlines) + Kernel.private_instance_methods(false).should.include?(:readlines) end end diff --git a/spec/ruby/core/kernel/remove_instance_variable_spec.rb b/spec/ruby/core/kernel/remove_instance_variable_spec.rb index 4e5ba5e018..114536064f 100644 --- a/spec/ruby/core/kernel/remove_instance_variable_spec.rb +++ b/spec/ruby/core/kernel/remove_instance_variable_spec.rb @@ -9,7 +9,7 @@ describe :kernel_remove_instance_variable, shared: true do it "removes the instance variable" do @instance.send :remove_instance_variable, @object - @instance.instance_variable_defined?(@object).should be_false + @instance.instance_variable_defined?(@object).should == false end end @@ -19,39 +19,39 @@ describe "Kernel#remove_instance_variable" do end it "is a public method" do - Kernel.should have_public_instance_method(:remove_instance_variable, false) + Kernel.public_instance_methods(false).should.include?(:remove_instance_variable) end it "raises a NameError if the instance variable is not defined" do -> do @instance.send :remove_instance_variable, :@unknown - end.should raise_error(NameError) + end.should.raise(NameError) end it "raises a NameError if the argument is not a valid instance variable name" do -> do @instance.send :remove_instance_variable, :"@0" - end.should raise_error(NameError) + end.should.raise(NameError) end it "raises a TypeError if passed an Object not defining #to_str" do -> do obj = mock("kernel remove_instance_variable") @instance.send :remove_instance_variable, obj - end.should raise_error(TypeError) + end.should.raise(TypeError) end it "raises a FrozenError if self is frozen" do o = Object.new o.freeze - -> { o.remove_instance_variable(:@foo) }.should raise_error(FrozenError) - -> { o.remove_instance_variable(:foo) }.should raise_error(NameError) + -> { o.remove_instance_variable(:@foo) }.should.raise(FrozenError) + -> { o.remove_instance_variable(:foo) }.should.raise(NameError) end it "raises for frozen objects" do - -> { nil.remove_instance_variable(:@foo) }.should raise_error(FrozenError) - -> { nil.remove_instance_variable(:foo) }.should raise_error(NameError) - -> { :foo.remove_instance_variable(:@foo) }.should raise_error(FrozenError) + -> { nil.remove_instance_variable(:@foo) }.should.raise(FrozenError) + -> { nil.remove_instance_variable(:foo) }.should.raise(NameError) + -> { :foo.remove_instance_variable(:@foo) }.should.raise(FrozenError) end describe "when passed a String" do diff --git a/spec/ruby/core/kernel/require_relative_spec.rb b/spec/ruby/core/kernel/require_relative_spec.rb index 6188d13a4e..332045b200 100644 --- a/spec/ruby/core/kernel/require_relative_spec.rb +++ b/spec/ruby/core/kernel/require_relative_spec.rb @@ -27,14 +27,14 @@ describe "Kernel#require_relative with a relative path" do end it "loads a path relative to current file" do - require_relative(@link).should be_true + require_relative(@link).should == true ScratchPad.recorded.should == [:loaded] end end end it "loads a path relative to the current file" do - require_relative(@path).should be_true + require_relative(@path).should == true ScratchPad.recorded.should == [:loaded] end @@ -42,14 +42,14 @@ describe "Kernel#require_relative with a relative path" do it "synthetic file base name loads a file base name relative to the working directory" do Dir.chdir @abs_dir do - Object.new.instance_eval("require_relative(#{File.basename(@path).inspect})", "foo.rb").should be_true + Object.new.instance_eval("require_relative(#{File.basename(@path).inspect})", "foo.rb").should == true end ScratchPad.recorded.should == [:loaded] end it "synthetic file path loads a relative path relative to the working directory plus the directory of the synthetic path" do Dir.chdir @abs_dir do - Object.new.instance_eval("require_relative(File.join('..', #{File.basename(@path).inspect}))", "bar/foo.rb").should be_true + Object.new.instance_eval("require_relative(File.join('..', #{File.basename(@path).inspect}))", "bar/foo.rb").should == true end ScratchPad.recorded.should == [:loaded] end @@ -57,14 +57,14 @@ describe "Kernel#require_relative with a relative path" do platform_is_not :windows do it "synthetic relative file path with a Windows path separator specified loads a relative path relative to the working directory" do Dir.chdir @abs_dir do - Object.new.instance_eval("require_relative(#{File.basename(@path).inspect})", "bar\\foo.rb").should be_true + Object.new.instance_eval("require_relative(#{File.basename(@path).inspect})", "bar\\foo.rb").should == true end ScratchPad.recorded.should == [:loaded] end end it "absolute file path loads a path relative to the absolute path" do - Object.new.instance_eval("require_relative(#{@path.inspect})", __FILE__).should be_true + Object.new.instance_eval("require_relative(#{@path.inspect})", __FILE__).should == true ScratchPad.recorded.should == [:loaded] end @@ -74,34 +74,34 @@ describe "Kernel#require_relative with a relative path" do root = File.dirname(root) end root_relative = @abs_path[root.size..-1] - Object.new.instance_eval("require_relative(#{root_relative.inspect})", "/").should be_true + Object.new.instance_eval("require_relative(#{root_relative.inspect})", "/").should == true ScratchPad.recorded.should == [:loaded] end end it "loads a file defining many methods" do - require_relative("#{@dir}/methods_fixture.rb").should be_true + require_relative("#{@dir}/methods_fixture.rb").should == true ScratchPad.recorded.should == [:loaded] end it "raises a LoadError if the file does not exist" do - -> { require_relative("#{@dir}/nonexistent.rb") }.should raise_error(LoadError) + -> { require_relative("#{@dir}/nonexistent.rb") }.should.raise(LoadError) ScratchPad.recorded.should == [] end it "raises a LoadError that includes the missing path" do missing_path = "#{@dir}/nonexistent.rb" expanded_missing_path = File.expand_path(missing_path, __dir__) - -> { require_relative(missing_path) }.should raise_error(LoadError) { |e| - e.message.should include(expanded_missing_path) + -> { require_relative(missing_path) }.should.raise(LoadError) { |e| + e.message.should.include?(expanded_missing_path) e.path.should == expanded_missing_path } ScratchPad.recorded.should == [] end it "raises a LoadError if basepath does not exist" do - -> { eval("require_relative('#{@dir}/nonexistent.rb')") }.should raise_error(LoadError) + -> { eval("require_relative('#{@dir}/nonexistent.rb')") }.should.raise(LoadError) end it "stores the missing path in a LoadError object" do @@ -117,34 +117,34 @@ describe "Kernel#require_relative with a relative path" do it "calls #to_str on non-String objects" do name = mock("load_fixture.rb mock") name.should_receive(:to_str).and_return(@path) - require_relative(name).should be_true + require_relative(name).should == true ScratchPad.recorded.should == [:loaded] end it "raises a TypeError if argument does not respond to #to_str" do - -> { require_relative(nil) }.should raise_error(TypeError) - -> { require_relative(42) }.should raise_error(TypeError) + -> { require_relative(nil) }.should.raise(TypeError) + -> { require_relative(42) }.should.raise(TypeError) -> { require_relative([@path,@path]) - }.should raise_error(TypeError) + }.should.raise(TypeError) end it "raises a TypeError if passed an object that has #to_s but not #to_str" do name = mock("load_fixture.rb mock") name.stub!(:to_s).and_return(@path) - -> { require_relative(name) }.should raise_error(TypeError) + -> { require_relative(name) }.should.raise(TypeError) end it "raises a TypeError if #to_str does not return a String" do name = mock("#to_str returns nil") name.should_receive(:to_str).at_least(1).times.and_return(nil) - -> { require_relative(name) }.should raise_error(TypeError) + -> { require_relative(name) }.should.raise(TypeError) end it "calls #to_path on non-String objects" do name = mock("load_fixture.rb mock") name.should_receive(:to_path).and_return(@path) - require_relative(name).should be_true + require_relative(name).should == true ScratchPad.recorded.should == [:loaded] end @@ -153,13 +153,13 @@ describe "Kernel#require_relative with a relative path" do to_path = mock("load_fixture_rb #to_path mock") name.should_receive(:to_path).and_return(to_path) to_path.should_receive(:to_str).and_return(@path) - require_relative(name).should be_true + require_relative(name).should == true ScratchPad.recorded.should == [:loaded] end describe "(file extensions)" do it "loads a .rb extensioned file when passed a non-extensioned path" do - require_relative("#{@dir}/load_fixture").should be_true + require_relative("#{@dir}/load_fixture").should == true ScratchPad.recorded.should == [:loaded] end @@ -168,20 +168,20 @@ describe "Kernel#require_relative with a relative path" do $LOADED_FEATURES << "#{@abs_dir}/load_fixture.dylib" $LOADED_FEATURES << "#{@abs_dir}/load_fixture.so" $LOADED_FEATURES << "#{@abs_dir}/load_fixture.dll" - require_relative(@path).should be_true + require_relative(@path).should == true ScratchPad.recorded.should == [:loaded] end it "does not load a C-extension file if a .rb extensioned file is already loaded" do $LOADED_FEATURES << "#{@abs_dir}/load_fixture.rb" - require_relative("#{@dir}/load_fixture").should be_false + require_relative("#{@dir}/load_fixture").should == false ScratchPad.recorded.should == [] end it "loads a .rb extensioned file when passed a non-.rb extensioned path" do - require_relative("#{@dir}/load_fixture.ext").should be_true + require_relative("#{@dir}/load_fixture.ext").should == true ScratchPad.recorded.should == [:loaded] - $LOADED_FEATURES.should include "#{@abs_dir}/load_fixture.ext.rb" + $LOADED_FEATURES.should.include? "#{@abs_dir}/load_fixture.ext.rb" end it "loads a .rb extensioned file when a complex-extensioned C-extension file of the same name is loaded" do @@ -189,22 +189,22 @@ describe "Kernel#require_relative with a relative path" do $LOADED_FEATURES << "#{@abs_dir}/load_fixture.ext.dylib" $LOADED_FEATURES << "#{@abs_dir}/load_fixture.ext.so" $LOADED_FEATURES << "#{@abs_dir}/load_fixture.ext.dll" - require_relative("#{@dir}/load_fixture.ext").should be_true + require_relative("#{@dir}/load_fixture.ext").should == true ScratchPad.recorded.should == [:loaded] - $LOADED_FEATURES.should include "#{@abs_dir}/load_fixture.ext.rb" + $LOADED_FEATURES.should.include? "#{@abs_dir}/load_fixture.ext.rb" end it "does not load a C-extension file if a complex-extensioned .rb file is already loaded" do $LOADED_FEATURES << "#{@abs_dir}/load_fixture.ext.rb" - require_relative("#{@dir}/load_fixture.ext").should be_false + require_relative("#{@dir}/load_fixture.ext").should == false ScratchPad.recorded.should == [] end end describe "($LOADED_FEATURES)" do it "stores an absolute path" do - require_relative(@path).should be_true - $LOADED_FEATURES.should include(@abs_path) + require_relative(@path).should == true + $LOADED_FEATURES.should.include?(@abs_path) end platform_is_not :windows, :wasi do @@ -231,8 +231,8 @@ describe "Kernel#require_relative with a relative path" do ScratchPad.recorded.should == [:loaded] features = $LOADED_FEATURES.select { |path| path.end_with?('load_fixture.rb') } - features.should include(absolute_path) - features.should_not include(canonical_path) + features.should.include?(absolute_path) + features.should_not.include?(canonical_path) end it "stores the same path that __FILE__ returns in the required file" do @@ -249,26 +249,26 @@ describe "Kernel#require_relative with a relative path" do it "does not store the path if the load fails" do saved_loaded_features = $LOADED_FEATURES.dup - -> { require_relative("#{@dir}/raise_fixture.rb") }.should raise_error(RuntimeError) + -> { require_relative("#{@dir}/raise_fixture.rb") }.should.raise(RuntimeError) $LOADED_FEATURES.should == saved_loaded_features end it "does not load an absolute path that is already stored" do $LOADED_FEATURES << @abs_path - require_relative(@path).should be_false + require_relative(@path).should == false ScratchPad.recorded.should == [] end it "adds the suffix of the resolved filename" do - require_relative("#{@dir}/load_fixture").should be_true - $LOADED_FEATURES.should include("#{@abs_dir}/load_fixture.rb") + require_relative("#{@dir}/load_fixture").should == true + $LOADED_FEATURES.should.include?("#{@abs_dir}/load_fixture.rb") end it "loads a path for a file already loaded with a relative path" do $LOAD_PATH << File.expand_path(@dir) $LOADED_FEATURES << "load_fixture.rb" << "load_fixture" - require_relative(@path).should be_true - $LOADED_FEATURES.should include(@abs_path) + require_relative(@path).should == true + $LOADED_FEATURES.should.include?(@abs_path) ScratchPad.recorded.should == [:loaded] end end @@ -288,22 +288,22 @@ describe "Kernel#require_relative with an absolute path" do end it "loads a path relative to the current file" do - require_relative(@path).should be_true + require_relative(@path).should == true ScratchPad.recorded.should == [:loaded] end it "loads a file defining many methods" do - require_relative("#{@dir}/methods_fixture.rb").should be_true + require_relative("#{@dir}/methods_fixture.rb").should == true ScratchPad.recorded.should == [:loaded] end it "raises a LoadError if the file does not exist" do - -> { require_relative("#{@dir}/nonexistent.rb") }.should raise_error(LoadError) + -> { require_relative("#{@dir}/nonexistent.rb") }.should.raise(LoadError) ScratchPad.recorded.should == [] end it "raises a LoadError if basepath does not exist" do - -> { eval("require_relative('#{@dir}/nonexistent.rb')") }.should raise_error(LoadError) + -> { eval("require_relative('#{@dir}/nonexistent.rb')") }.should.raise(LoadError) end it "stores the missing path in a LoadError object" do @@ -319,34 +319,34 @@ describe "Kernel#require_relative with an absolute path" do it "calls #to_str on non-String objects" do name = mock("load_fixture.rb mock") name.should_receive(:to_str).and_return(@path) - require_relative(name).should be_true + require_relative(name).should == true ScratchPad.recorded.should == [:loaded] end it "raises a TypeError if argument does not respond to #to_str" do - -> { require_relative(nil) }.should raise_error(TypeError) - -> { require_relative(42) }.should raise_error(TypeError) + -> { require_relative(nil) }.should.raise(TypeError) + -> { require_relative(42) }.should.raise(TypeError) -> { require_relative([@path,@path]) - }.should raise_error(TypeError) + }.should.raise(TypeError) end it "raises a TypeError if passed an object that has #to_s but not #to_str" do name = mock("load_fixture.rb mock") name.stub!(:to_s).and_return(@path) - -> { require_relative(name) }.should raise_error(TypeError) + -> { require_relative(name) }.should.raise(TypeError) end it "raises a TypeError if #to_str does not return a String" do name = mock("#to_str returns nil") name.should_receive(:to_str).at_least(1).times.and_return(nil) - -> { require_relative(name) }.should raise_error(TypeError) + -> { require_relative(name) }.should.raise(TypeError) end it "calls #to_path on non-String objects" do name = mock("load_fixture.rb mock") name.should_receive(:to_path).and_return(@path) - require_relative(name).should be_true + require_relative(name).should == true ScratchPad.recorded.should == [:loaded] end @@ -355,13 +355,13 @@ describe "Kernel#require_relative with an absolute path" do to_path = mock("load_fixture_rb #to_path mock") name.should_receive(:to_path).and_return(to_path) to_path.should_receive(:to_str).and_return(@path) - require_relative(name).should be_true + require_relative(name).should == true ScratchPad.recorded.should == [:loaded] end describe "(file extensions)" do it "loads a .rb extensioned file when passed a non-extensioned path" do - require_relative("#{@dir}/load_fixture").should be_true + require_relative("#{@dir}/load_fixture").should == true ScratchPad.recorded.should == [:loaded] end @@ -370,20 +370,20 @@ describe "Kernel#require_relative with an absolute path" do $LOADED_FEATURES << "#{@abs_dir}/load_fixture.dylib" $LOADED_FEATURES << "#{@abs_dir}/load_fixture.so" $LOADED_FEATURES << "#{@abs_dir}/load_fixture.dll" - require_relative(@path).should be_true + require_relative(@path).should == true ScratchPad.recorded.should == [:loaded] end it "does not load a C-extension file if a .rb extensioned file is already loaded" do $LOADED_FEATURES << "#{@abs_dir}/load_fixture.rb" - require_relative("#{@dir}/load_fixture").should be_false + require_relative("#{@dir}/load_fixture").should == false ScratchPad.recorded.should == [] end it "loads a .rb extensioned file when passed a non-.rb extensioned path" do - require_relative("#{@dir}/load_fixture.ext").should be_true + require_relative("#{@dir}/load_fixture.ext").should == true ScratchPad.recorded.should == [:loaded] - $LOADED_FEATURES.should include "#{@abs_dir}/load_fixture.ext.rb" + $LOADED_FEATURES.should.include? "#{@abs_dir}/load_fixture.ext.rb" end it "loads a .rb extensioned file when a complex-extensioned C-extension file of the same name is loaded" do @@ -391,46 +391,46 @@ describe "Kernel#require_relative with an absolute path" do $LOADED_FEATURES << "#{@abs_dir}/load_fixture.ext.dylib" $LOADED_FEATURES << "#{@abs_dir}/load_fixture.ext.so" $LOADED_FEATURES << "#{@abs_dir}/load_fixture.ext.dll" - require_relative("#{@dir}/load_fixture.ext").should be_true + require_relative("#{@dir}/load_fixture.ext").should == true ScratchPad.recorded.should == [:loaded] - $LOADED_FEATURES.should include "#{@abs_dir}/load_fixture.ext.rb" + $LOADED_FEATURES.should.include? "#{@abs_dir}/load_fixture.ext.rb" end it "does not load a C-extension file if a complex-extensioned .rb file is already loaded" do $LOADED_FEATURES << "#{@abs_dir}/load_fixture.ext.rb" - require_relative("#{@dir}/load_fixture.ext").should be_false + require_relative("#{@dir}/load_fixture.ext").should == false ScratchPad.recorded.should == [] end end describe "($LOAD_FEATURES)" do it "stores an absolute path" do - require_relative(@path).should be_true - $LOADED_FEATURES.should include(@abs_path) + require_relative(@path).should == true + $LOADED_FEATURES.should.include?(@abs_path) end it "does not store the path if the load fails" do saved_loaded_features = $LOADED_FEATURES.dup - -> { require_relative("#{@dir}/raise_fixture.rb") }.should raise_error(RuntimeError) + -> { require_relative("#{@dir}/raise_fixture.rb") }.should.raise(RuntimeError) $LOADED_FEATURES.should == saved_loaded_features end it "does not load an absolute path that is already stored" do $LOADED_FEATURES << @abs_path - require_relative(@path).should be_false + require_relative(@path).should == false ScratchPad.recorded.should == [] end it "adds the suffix of the resolved filename" do - require_relative("#{@dir}/load_fixture").should be_true - $LOADED_FEATURES.should include("#{@abs_dir}/load_fixture.rb") + require_relative("#{@dir}/load_fixture").should == true + $LOADED_FEATURES.should.include?("#{@abs_dir}/load_fixture.rb") end it "loads a path for a file already loaded with a relative path" do $LOAD_PATH << File.expand_path(@dir) $LOADED_FEATURES << "load_fixture.rb" << "load_fixture" - require_relative(@path).should be_true - $LOADED_FEATURES.should include(@abs_path) + require_relative(@path).should == true + $LOADED_FEATURES.should.include?(@abs_path) ScratchPad.recorded.should == [:loaded] end end diff --git a/spec/ruby/core/kernel/require_spec.rb b/spec/ruby/core/kernel/require_spec.rb index 945f68aba9..62d954c2bf 100644 --- a/spec/ruby/core/kernel/require_spec.rb +++ b/spec/ruby/core/kernel/require_spec.rb @@ -13,27 +13,40 @@ describe "Kernel#require" do # if this fails, update your rubygems it "is a private method" do - Kernel.should have_private_instance_method(:require) + Kernel.private_instance_methods(false).should.include?(:require) end - provided = %w[complex enumerator fiber rational thread ruby2_keywords] - ruby_version_is "3.5" do - provided << "set" - end + it "provided features are already required" do + provided = %w[complex enumerator fiber rational thread ruby2_keywords] + ruby_version_is "4.0" do + provided += %w[set pathname] + end + ruby_version_is "4.1" do + provided += %w[monitor] + end - it "#{provided.join(', ')} are already required" do out = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems --disable-did-you-mean') - features = out.lines.map { |line| File.basename(line.chomp, '.*') } + features = out.lines.map(&:chomp) - # Ignore CRuby internals - features -= %w[encdb transdb windows_1252 windows_31j] - features.reject! { |feature| feature.end_with?('-fake') } + # Ignore engine-specific internals + case RUBY_ENGINE + when "jruby" + features -= %w[java.rb jruby/util.rb] + when "ruby" + so = RbConfig::CONFIG['DLEXT'] + features -= ["windows_1252.#{so}", "windows_31.#{so}"] + features.reject! { |feature| feature.end_with? "encdb.#{so}" } + features.reject! { |feature| feature.end_with? "transdb.#{so}" } + features.reject! { |feature| feature.include?('-fake') } + end - features.sort.should == provided.sort + features_no_ext = features.map { |path| File.basename(path, '.*') } + features_no_ext.sort.should == provided.sort - code = provided.map { |f| "puts require #{f.inspect}\n" }.join + requires = features + code = requires.map { |f| "puts require #{f.inspect}\n" }.join required = ruby_exe(code, options: '--disable-gems') - required.should == "false\n" * provided.size + required.should == "false\n" * requires.size end it_behaves_like :kernel_require_basic, :require, CodeLoadingSpecs::Method.new diff --git a/spec/ruby/core/kernel/respond_to_missing_spec.rb b/spec/ruby/core/kernel/respond_to_missing_spec.rb index cc82031e26..08c9184fb4 100644 --- a/spec/ruby/core/kernel/respond_to_missing_spec.rb +++ b/spec/ruby/core/kernel/respond_to_missing_spec.rb @@ -7,7 +7,7 @@ describe "Kernel#respond_to_missing?" do end it "is a private method" do - Kernel.should have_private_instance_method(:respond_to_missing?, false) + Kernel.private_instance_methods(false).should.include?(:respond_to_missing?) end it "is only an instance method" do @@ -18,7 +18,7 @@ describe "Kernel#respond_to_missing?" do obj = mock('object') obj.stub!(:glark) obj.should_not_receive(:respond_to_missing?) - obj.respond_to?(:glark).should be_true + obj.respond_to?(:glark).should == true end it "is called with a 2nd argument of false when #respond_to? is" do @@ -48,39 +48,39 @@ describe "Kernel#respond_to_missing?" do it "causes #respond_to? to return true if called and not returning false" do obj = mock('object') obj.should_receive(:respond_to_missing?).with(:undefined_method, false).and_return(:glark) - obj.respond_to?(:undefined_method).should be_true + obj.respond_to?(:undefined_method).should == true end it "causes #respond_to? to return false if called and returning false" do obj = mock('object') obj.should_receive(:respond_to_missing?).with(:undefined_method, false).and_return(false) - obj.respond_to?(:undefined_method).should be_false + obj.respond_to?(:undefined_method).should == false end it "causes #respond_to? to return false if called and returning nil" do obj = mock('object') obj.should_receive(:respond_to_missing?).with(:undefined_method, false).and_return(nil) - obj.respond_to?(:undefined_method).should be_false + obj.respond_to?(:undefined_method).should == false end it "isn't called when obj responds to the given public method" do @a.should_not_receive(:respond_to_missing?) - @a.respond_to?(:pub_method).should be_true + @a.respond_to?(:pub_method).should == true end it "isn't called when obj responds to the given public method, include_private = true" do @a.should_not_receive(:respond_to_missing?) - @a.respond_to?(:pub_method, true).should be_true + @a.respond_to?(:pub_method, true).should == true end it "is called when obj responds to the given protected method, include_private = false" do @a.should_receive(:respond_to_missing?) - @a.respond_to?(:protected_method, false).should be_false + @a.respond_to?(:protected_method, false).should == false end it "isn't called when obj responds to the given protected method, include_private = true" do @a.should_not_receive(:respond_to_missing?) - @a.respond_to?(:protected_method, true).should be_true + @a.respond_to?(:protected_method, true).should == true end it "is called when obj responds to the given private method, include_private = false" do @@ -90,7 +90,7 @@ describe "Kernel#respond_to_missing?" do it "isn't called when obj responds to the given private method, include_private = true" do @a.should_not_receive(:respond_to_missing?) - @a.respond_to?(:private_method, true).should be_true + @a.respond_to?(:private_method, true).should == true end it "is called for missing class methods" do diff --git a/spec/ruby/core/kernel/respond_to_spec.rb b/spec/ruby/core/kernel/respond_to_spec.rb index 5b3ea3f651..72ab4eebe1 100644 --- a/spec/ruby/core/kernel/respond_to_spec.rb +++ b/spec/ruby/core/kernel/respond_to_spec.rb @@ -7,7 +7,7 @@ describe "Kernel#respond_to?" do end it "is a public method" do - Kernel.should have_public_instance_method(:respond_to?, false) + Kernel.public_instance_methods(false).should.include?(:respond_to?) end it "is only an instance method" do @@ -25,7 +25,7 @@ describe "Kernel#respond_to?" do end it "throws a type error if argument can't be coerced into a Symbol" do - -> { @a.respond_to?(Object.new) }.should raise_error(TypeError, /is not a symbol nor a string/) + -> { @a.respond_to?(Object.new) }.should.raise(TypeError, /is not a symbol nor a string/) end it "returns false if obj responds to the given protected method" do @@ -61,7 +61,7 @@ describe "Kernel#respond_to?" do it "does not change method visibility when finding private method" do KernelSpecs::VisibilityChange.respond_to?(:new, false).should == false KernelSpecs::VisibilityChange.respond_to?(:new, true).should == true - -> { KernelSpecs::VisibilityChange.new }.should raise_error(NoMethodError) + -> { KernelSpecs::VisibilityChange.new }.should.raise(NoMethodError) end it "indicates if an object responds to a particular message" do @@ -69,4 +69,31 @@ describe "Kernel#respond_to?" do KernelSpecs::Foo.new.respond_to?(:bar).should == true KernelSpecs::Foo.new.respond_to?(:invalid_and_silly_method_name).should == false end + + context "if object does not have #respond_to_missing?" do + it "returns true if object responds to the given public method" do + KernelSpecs::BasicA.new.respond_to?(:pub_method).should == true + KernelSpecs::MissingA.new.respond_to?(:pub_method).should == true + end + + it "returns false if object responds to the given protected method" do + KernelSpecs::BasicA.new.respond_to?(:protected_method).should == false + KernelSpecs::MissingA.new.respond_to?(:protected_method).should == false + end + + it "returns false if object responds to the given private method" do + KernelSpecs::BasicA.new.respond_to?(:private_method).should == false + KernelSpecs::MissingA.new.respond_to?(:private_method).should == false + end + + it "returns false if the given method was undefined" do + KernelSpecs::BasicA.new.respond_to?(:undefed_method).should == false + KernelSpecs::MissingA.new.respond_to?(:undefed_method).should == false + end + + it "returns false if the given method never existed" do + KernelSpecs::BasicA.new.respond_to?(:invalid_and_silly_method_name).should == false + KernelSpecs::MissingA.new.respond_to?(:invalid_and_silly_method_name).should == false + end + end end diff --git a/spec/ruby/core/kernel/select_spec.rb b/spec/ruby/core/kernel/select_spec.rb index df23414b28..58c963c1a4 100644 --- a/spec/ruby/core/kernel/select_spec.rb +++ b/spec/ruby/core/kernel/select_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#select" do it "is a private method" do - Kernel.should have_private_instance_method(:select) + Kernel.private_instance_methods(false).should.include?(:select) end end diff --git a/spec/ruby/core/kernel/set_trace_func_spec.rb b/spec/ruby/core/kernel/set_trace_func_spec.rb index 1f43e7a009..5201812f2f 100644 --- a/spec/ruby/core/kernel/set_trace_func_spec.rb +++ b/spec/ruby/core/kernel/set_trace_func_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#set_trace_func" do it "is a private method" do - Kernel.should have_private_instance_method(:set_trace_func) + Kernel.private_instance_methods(false).should.include?(:set_trace_func) end end diff --git a/spec/ruby/core/kernel/shared/dup_clone.rb b/spec/ruby/core/kernel/shared/dup_clone.rb index 4fac6006e1..3fbf918283 100644 --- a/spec/ruby/core/kernel/shared/dup_clone.rb +++ b/spec/ruby/core/kernel/shared/dup_clone.rb @@ -40,7 +40,7 @@ describe :kernel_dup_clone, shared: true do o.obj = array o2 = o.send(@method) - o2.obj.should equal(o.obj) + o2.obj.should.equal?(o.obj) end it "calls #initialize_copy on the NEW object if available, passing in original object" do @@ -49,7 +49,7 @@ describe :kernel_dup_clone, shared: true do o.obj.should == :original o2.obj.should == :init_copy - o2.original.should equal(o) + o2.original.should.equal?(o) end it "does not preserve the object_id" do @@ -81,11 +81,11 @@ describe :kernel_dup_clone, shared: true do it "returns self for Complex" do c = Complex(1.3, 3.1) - c.send(@method).should equal c + c.send(@method).should.equal? c end it "returns self for Rational" do r = Rational(1, 3) - r.send(@method).should equal r + r.send(@method).should.equal? r end end diff --git a/spec/ruby/core/kernel/shared/kind_of.rb b/spec/ruby/core/kernel/shared/kind_of.rb index aef6f1c1d8..a5e0eab08f 100644 --- a/spec/ruby/core/kernel/shared/kind_of.rb +++ b/spec/ruby/core/kernel/shared/kind_of.rb @@ -40,10 +40,10 @@ describe :kernel_kind_of, shared: true do end it "raises a TypeError if given an object that is not a Class nor a Module" do - -> { @o.send(@method, 1) }.should raise_error(TypeError) - -> { @o.send(@method, 'KindaClass') }.should raise_error(TypeError) - -> { @o.send(@method, :KindaClass) }.should raise_error(TypeError) - -> { @o.send(@method, Object.new) }.should raise_error(TypeError) + -> { @o.send(@method, 1) }.should.raise(TypeError) + -> { @o.send(@method, 'KindaClass') }.should.raise(TypeError) + -> { @o.send(@method, :KindaClass) }.should.raise(TypeError) + -> { @o.send(@method, Object.new) }.should.raise(TypeError) end it "does not take into account `class` method overriding" do diff --git a/spec/ruby/core/kernel/shared/lambda.rb b/spec/ruby/core/kernel/shared/lambda.rb index c70640082a..83de06bb41 100644 --- a/spec/ruby/core/kernel/shared/lambda.rb +++ b/spec/ruby/core/kernel/shared/lambda.rb @@ -5,7 +5,7 @@ describe :kernel_lambda, shared: true do it "raises an ArgumentError when no block is given" do suppress_warning do - -> { send(@method) }.should raise_error(ArgumentError) + -> { send(@method) }.should.raise(ArgumentError) end end end diff --git a/spec/ruby/core/kernel/shared/load.rb b/spec/ruby/core/kernel/shared/load.rb index 62c5c7be9b..20d23a623e 100644 --- a/spec/ruby/core/kernel/shared/load.rb +++ b/spec/ruby/core/kernel/shared/load.rb @@ -15,19 +15,19 @@ describe :kernel_load, shared: true do # This behavior is specific to Kernel#load, it differs for Kernel#require it "loads a non-extensioned file as a Ruby source file" do path = File.expand_path "load_fixture", CODE_LOADING_DIR - @object.load(path).should be_true + @object.load(path).should == true ScratchPad.recorded.should == [:no_ext] end it "loads a non .rb extensioned file as a Ruby source file" do path = File.expand_path "load_fixture.ext", CODE_LOADING_DIR - @object.load(path).should be_true + @object.load(path).should == true ScratchPad.recorded.should == [:no_rb_ext] end it "loads from the current working directory" do Dir.chdir CODE_LOADING_DIR do - @object.load("load_fixture.rb").should be_true + @object.load("load_fixture.rb").should == true ScratchPad.recorded.should == [:loaded] end end @@ -35,88 +35,88 @@ describe :kernel_load, shared: true do # This behavior is specific to Kernel#load, it differs for Kernel#require it "does not look for a c-extension file when passed a path without extension (when no .rb is present)" do path = File.join CODE_LOADING_DIR, "a", "load_fixture" - -> { @object.send(@method, path) }.should raise_error(LoadError) + -> { @object.send(@method, path) }.should.raise(LoadError) end end it "loads a file that recursively requires itself" do path = File.expand_path "recursive_require_fixture.rb", CODE_LOADING_DIR -> { - @object.load(path).should be_true + @object.load(path).should == true }.should complain(/circular require considered harmful/, verbose: true) ScratchPad.recorded.should == [:loaded, :loaded] end it "loads a file that recursively loads itself" do path = File.expand_path "recursive_load_fixture.rb", CODE_LOADING_DIR - @object.load(path).should be_true + @object.load(path).should == true ScratchPad.recorded.should == [:loaded, :loaded] end it "loads a file each time the method is called" do - @object.load(@path).should be_true - @object.load(@path).should be_true + @object.load(@path).should == true + @object.load(@path).should == true ScratchPad.recorded.should == [:loaded, :loaded] end it "loads a file even when the name appears in $LOADED_FEATURES" do $LOADED_FEATURES << @path - @object.load(@path).should be_true + @object.load(@path).should == true ScratchPad.recorded.should == [:loaded] end it "loads a file that has been loaded by #require" do - @object.require(@path).should be_true - @object.load(@path).should be_true + @object.require(@path).should == true + @object.load(@path).should == true ScratchPad.recorded.should == [:loaded, :loaded] end it "loads file even after $LOAD_PATH change" do $LOAD_PATH << CODE_LOADING_DIR - @object.load("load_fixture.rb").should be_true + @object.load("load_fixture.rb").should == true $LOAD_PATH.unshift CODE_LOADING_DIR + "/gem" - @object.load("load_fixture.rb").should be_true + @object.load("load_fixture.rb").should == true ScratchPad.recorded.should == [:loaded, :loaded_gem] end it "does not cause #require with the same path to fail" do - @object.load(@path).should be_true - @object.require(@path).should be_true + @object.load(@path).should == true + @object.require(@path).should == true ScratchPad.recorded.should == [:loaded, :loaded] end it "does not add the loaded path to $LOADED_FEATURES" do saved_loaded_features = $LOADED_FEATURES.dup - @object.load(@path).should be_true + @object.load(@path).should == true $LOADED_FEATURES.should == saved_loaded_features end it "raises a LoadError if passed a non-extensioned path that does not exist but a .rb extensioned path does exist" do path = File.expand_path "load_ext_fixture", CODE_LOADING_DIR - -> { @object.load(path) }.should raise_error(LoadError) + -> { @object.load(path) }.should.raise(LoadError) end describe "when passed true for 'wrap'" do it "loads from an existing path" do path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR - @object.load(path, true).should be_true + @object.load(path, true).should == true end it "sets the enclosing scope to an anonymous module" do path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR @object.load(path, true) - Object.const_defined?(:LoadSpecWrap).should be_false + Object.const_defined?(:LoadSpecWrap).should == false wrap_module = ScratchPad.recorded[1] - wrap_module.should be_an_instance_of(Module) + wrap_module.should.instance_of?(Module) end it "allows referencing outside namespaces" do path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR @object.load(path, true) - ScratchPad.recorded[0].should equal(String) + ScratchPad.recorded[0].should.equal?(String) end it "sets self as a copy of the top-level main" do @@ -126,8 +126,8 @@ describe :kernel_load, shared: true do top_level = ScratchPad.recorded[2] top_level.to_s.should == "main" top_level.method(:to_s).owner.should == top_level.singleton_class - top_level.should_not equal(main) - top_level.should be_an_instance_of(Object) + top_level.should_not.equal?(main) + top_level.should.instance_of?(Object) end it "includes modules included in main's singleton class in self's class" do @@ -159,7 +159,7 @@ describe :kernel_load, shared: true do end it "does not pollute the receiver" do - -> { @object.send(:top_level_method) }.should raise_error(NameError) + -> { @object.send(:top_level_method) }.should.raise(NameError) end end end @@ -170,8 +170,8 @@ describe :kernel_load, shared: true do mod = Module.new @object.load(path, mod) - Object.const_defined?(:LoadSpecWrap).should be_false - mod.const_defined?(:LoadSpecWrap).should be_true + Object.const_defined?(:LoadSpecWrap).should == false + mod.const_defined?(:LoadSpecWrap).should == true wrap_module = ScratchPad.recorded[1] wrap_module.should == mod @@ -208,7 +208,7 @@ describe :kernel_load, shared: true do end it "expands a tilde to the HOME environment variable as the path to load" do - @object.require("~/load_fixture.rb").should be_true + @object.require("~/load_fixture.rb").should == true ScratchPad.recorded.should == [:loaded] end end diff --git a/spec/ruby/core/kernel/shared/method.rb b/spec/ruby/core/kernel/shared/method.rb index 8b6ab23fd3..82abc287d1 100644 --- a/spec/ruby/core/kernel/shared/method.rb +++ b/spec/ruby/core/kernel/shared/method.rb @@ -4,26 +4,26 @@ describe :kernel_method, shared: true do it "returns a method object for a valid method" do class KernelSpecs::Foo; def bar; 'done'; end; end m = KernelSpecs::Foo.new.send(@method, :bar) - m.should be_an_instance_of Method + m.should.instance_of? Method m.call.should == 'done' end it "returns a method object for a valid singleton method" do class KernelSpecs::Foo; def self.bar; 'class done'; end; end m = KernelSpecs::Foo.send(@method, :bar) - m.should be_an_instance_of Method + m.should.instance_of? Method m.call.should == 'class done' end it "returns a method object if respond_to_missing?(method) is true" do m = KernelSpecs::RespondViaMissing.new.send(@method, :handled_publicly) - m.should be_an_instance_of Method + m.should.instance_of? Method m.call(42).should == "Done handled_publicly([42])" end it "the returned method object if respond_to_missing?(method) calls #method_missing with a Symbol name" do m = KernelSpecs::RespondViaMissing.new.send(@method, "handled_publicly") - m.should be_an_instance_of Method + m.should.instance_of? Method m.call(42).should == "Done handled_publicly([42])" end @@ -31,12 +31,12 @@ describe :kernel_method, shared: true do class KernelSpecs::Foo; def bar; 'done'; end; end -> { KernelSpecs::Foo.new.send(@method, :invalid_and_silly_method_name) - }.should raise_error(NameError) + }.should.raise(NameError) end it "raises a NameError for an invalid singleton method name" do class KernelSpecs::Foo; def self.bar; 'done'; end; end - -> { KernelSpecs::Foo.send(@method, :baz) }.should raise_error(NameError) + -> { KernelSpecs::Foo.send(@method, :baz) }.should.raise(NameError) end it "changes the method called for super on a target aliased method" do diff --git a/spec/ruby/core/kernel/shared/require.rb b/spec/ruby/core/kernel/shared/require.rb index b31c89e3bf..6272b00665 100644 --- a/spec/ruby/core/kernel/shared/require.rb +++ b/spec/ruby/core/kernel/shared/require.rb @@ -2,26 +2,26 @@ describe :kernel_require_basic, shared: true do describe "(path resolution)" do it "loads an absolute path" do path = File.expand_path "load_fixture.rb", CODE_LOADING_DIR - @object.send(@method, path).should be_true + @object.send(@method, path).should == true ScratchPad.recorded.should == [:loaded] end it "loads a non-canonical absolute path" do path = File.join CODE_LOADING_DIR, "..", "code", "load_fixture.rb" - @object.send(@method, path).should be_true + @object.send(@method, path).should == true ScratchPad.recorded.should == [:loaded] end it "loads a file defining many methods" do path = File.expand_path "methods_fixture.rb", CODE_LOADING_DIR - @object.send(@method, path).should be_true + @object.send(@method, path).should == true ScratchPad.recorded.should == [:loaded] end it "raises a LoadError if the file does not exist" do path = File.expand_path "nonexistent.rb", CODE_LOADING_DIR File.should_not.exist?(path) - -> { @object.send(@method, path) }.should raise_error(LoadError) + -> { @object.send(@method, path) }.should.raise(LoadError) ScratchPad.recorded.should == [] end @@ -42,7 +42,7 @@ describe :kernel_require_basic, shared: true do it "raises a LoadError" do File.should.exist?(@path) - -> { @object.send(@method, @path) }.should raise_error(LoadError) + -> { @object.send(@method, @path) }.should.raise(LoadError) end end end @@ -52,24 +52,24 @@ describe :kernel_require_basic, shared: true do path = File.expand_path "load_fixture.rb", CODE_LOADING_DIR name = mock("load_fixture.rb mock") name.should_receive(:to_str).and_return(path) - @object.send(@method, name).should be_true + @object.send(@method, name).should == true ScratchPad.recorded.should == [:loaded] end it "raises a TypeError if passed nil" do - -> { @object.send(@method, nil) }.should raise_error(TypeError) + -> { @object.send(@method, nil) }.should.raise(TypeError) end it "raises a TypeError if passed an Integer" do - -> { @object.send(@method, 42) }.should raise_error(TypeError) + -> { @object.send(@method, 42) }.should.raise(TypeError) end it "raises a TypeError if passed an Array" do - -> { @object.send(@method, []) }.should raise_error(TypeError) + -> { @object.send(@method, []) }.should.raise(TypeError) end it "raises a TypeError if passed an object that does not provide #to_str" do - -> { @object.send(@method, mock("not a filename")) }.should raise_error(TypeError) + -> { @object.send(@method, mock("not a filename")) }.should.raise(TypeError) end it "raises a TypeError if passed an object that has #to_s but not #to_str" do @@ -77,14 +77,14 @@ describe :kernel_require_basic, shared: true do name.stub!(:to_s).and_return("load_fixture.rb") $LOAD_PATH << "." Dir.chdir CODE_LOADING_DIR do - -> { @object.send(@method, name) }.should raise_error(TypeError) + -> { @object.send(@method, name) }.should.raise(TypeError) end end it "raises a TypeError if #to_str does not return a String" do name = mock("#to_str returns nil") name.should_receive(:to_str).at_least(1).times.and_return(nil) - -> { @object.send(@method, name) }.should raise_error(TypeError) + -> { @object.send(@method, name) }.should.raise(TypeError) end it "calls #to_path on non-String objects" do @@ -92,7 +92,7 @@ describe :kernel_require_basic, shared: true do name.stub!(:to_path).and_return("load_fixture.rb") $LOAD_PATH << "." Dir.chdir CODE_LOADING_DIR do - @object.send(@method, name).should be_true + @object.send(@method, name).should == true end ScratchPad.recorded.should == [:loaded] end @@ -101,7 +101,7 @@ describe :kernel_require_basic, shared: true do path = File.expand_path "load_fixture.rb", CODE_LOADING_DIR str = mock("load_fixture.rb mock") str.should_receive(:to_path).and_return(path) - @object.send(@method, str).should be_true + @object.send(@method, str).should == true ScratchPad.recorded.should == [:loaded] end @@ -111,21 +111,21 @@ describe :kernel_require_basic, shared: true do to_path = mock("load_fixture_rb #to_path mock") name.should_receive(:to_path).and_return(to_path) to_path.should_receive(:to_str).and_return(path) - @object.send(@method, name).should be_true + @object.send(@method, name).should == true ScratchPad.recorded.should == [:loaded] end # "http://redmine.ruby-lang.org/issues/show/2578" it "loads a ./ relative path from the current working directory with empty $LOAD_PATH" do Dir.chdir CODE_LOADING_DIR do - @object.send(@method, "./load_fixture.rb").should be_true + @object.send(@method, "./load_fixture.rb").should == true end ScratchPad.recorded.should == [:loaded] end it "loads a ../ relative path from the current working directory with empty $LOAD_PATH" do Dir.chdir CODE_LOADING_DIR do - @object.send(@method, "../code/load_fixture.rb").should be_true + @object.send(@method, "../code/load_fixture.rb").should == true end ScratchPad.recorded.should == [:loaded] end @@ -133,7 +133,7 @@ describe :kernel_require_basic, shared: true do it "loads a ./ relative path from the current working directory with non-empty $LOAD_PATH" do $LOAD_PATH << "an_irrelevant_dir" Dir.chdir CODE_LOADING_DIR do - @object.send(@method, "./load_fixture.rb").should be_true + @object.send(@method, "./load_fixture.rb").should == true end ScratchPad.recorded.should == [:loaded] end @@ -141,7 +141,7 @@ describe :kernel_require_basic, shared: true do it "loads a ../ relative path from the current working directory with non-empty $LOAD_PATH" do $LOAD_PATH << "an_irrelevant_dir" Dir.chdir CODE_LOADING_DIR do - @object.send(@method, "../code/load_fixture.rb").should be_true + @object.send(@method, "../code/load_fixture.rb").should == true end ScratchPad.recorded.should == [:loaded] end @@ -149,14 +149,14 @@ describe :kernel_require_basic, shared: true do it "loads a non-canonical path from the current working directory with non-empty $LOAD_PATH" do $LOAD_PATH << "an_irrelevant_dir" Dir.chdir CODE_LOADING_DIR do - @object.send(@method, "../code/../code/load_fixture.rb").should be_true + @object.send(@method, "../code/../code/load_fixture.rb").should == true end ScratchPad.recorded.should == [:loaded] end it "resolves a filename against $LOAD_PATH entries" do $LOAD_PATH << CODE_LOADING_DIR - @object.send(@method, "load_fixture.rb").should be_true + @object.send(@method, "load_fixture.rb").should == true ScratchPad.recorded.should == [:loaded] end @@ -164,15 +164,15 @@ describe :kernel_require_basic, shared: true do obj = mock("to_path") obj.should_receive(:to_path).at_least(:once).and_return(CODE_LOADING_DIR) $LOAD_PATH << obj - @object.send(@method, "load_fixture.rb").should be_true + @object.send(@method, "load_fixture.rb").should == true ScratchPad.recorded.should == [:loaded] end it "does not require file twice after $LOAD_PATH change" do $LOAD_PATH << CODE_LOADING_DIR - @object.require("load_fixture.rb").should be_true + @object.require("load_fixture.rb").should == true $LOAD_PATH.push CODE_LOADING_DIR + "/gem" - @object.require("load_fixture.rb").should be_false + @object.require("load_fixture.rb").should == false ScratchPad.recorded.should == [:loaded] end @@ -180,7 +180,7 @@ describe :kernel_require_basic, shared: true do $LOAD_PATH << CODE_LOADING_DIR -> do @object.send(@method, "./load_fixture.rb") - end.should raise_error(LoadError) + end.should.raise(LoadError) ScratchPad.recorded.should == [] end @@ -188,13 +188,13 @@ describe :kernel_require_basic, shared: true do $LOAD_PATH << CODE_LOADING_DIR -> do @object.send(@method, "../code/load_fixture.rb") - end.should raise_error(LoadError) + end.should.raise(LoadError) ScratchPad.recorded.should == [] end it "resolves a non-canonical path against $LOAD_PATH entries" do $LOAD_PATH << File.dirname(CODE_LOADING_DIR) - @object.send(@method, "code/../code/load_fixture.rb").should be_true + @object.send(@method, "code/../code/load_fixture.rb").should == true ScratchPad.recorded.should == [:loaded] end @@ -203,7 +203,7 @@ describe :kernel_require_basic, shared: true do sep = File::Separator + File::Separator path = ["..", "code", "load_fixture.rb"].join(sep) Dir.chdir CODE_LOADING_DIR do - @object.send(@method, path).should be_true + @object.send(@method, path).should == true end ScratchPad.recorded.should == [:loaded] end @@ -214,7 +214,7 @@ describe :kernel_require, shared: true do describe "(path resolution)" do it "loads .rb file when passed absolute path without extension" do path = File.expand_path "load_fixture", CODE_LOADING_DIR - @object.send(@method, path).should be_true + @object.send(@method, path).should == true # This should _not_ be [:no_ext] ScratchPad.recorded.should == [:loaded] end @@ -223,7 +223,7 @@ describe :kernel_require, shared: true do it "loads c-extension file when passed absolute path without extension when no .rb is present" do # the error message is specific to what dlerror() returns path = File.join CODE_LOADING_DIR, "a", "load_fixture" - -> { @object.send(@method, path) }.should raise_error(LoadError) + -> { @object.send(@method, path) }.should.raise(LoadError) end end @@ -231,20 +231,20 @@ describe :kernel_require, shared: true do it "loads .bundle file when passed absolute path with .so" do # the error message is specific to what dlerror() returns path = File.join CODE_LOADING_DIR, "a", "load_fixture.so" - -> { @object.send(@method, path) }.should raise_error(LoadError) + -> { @object.send(@method, path) }.should.raise(LoadError) end end it "does not try an extra .rb if the path already ends in .rb" do path = File.join CODE_LOADING_DIR, "d", "load_fixture.rb" - -> { @object.send(@method, path) }.should raise_error(LoadError) + -> { @object.send(@method, path) }.should.raise(LoadError) end # For reference see [ruby-core:24155] in which matz confirms this feature is # intentional for security reasons. it "does not load a bare filename unless the current working directory is in $LOAD_PATH" do Dir.chdir CODE_LOADING_DIR do - -> { @object.require("load_fixture.rb") }.should raise_error(LoadError) + -> { @object.require("load_fixture.rb") }.should.raise(LoadError) ScratchPad.recorded.should == [] end end @@ -253,7 +253,7 @@ describe :kernel_require, shared: true do Dir.chdir File.dirname(CODE_LOADING_DIR) do -> do @object.require("code/load_fixture.rb") - end.should raise_error(LoadError) + end.should.raise(LoadError) ScratchPad.recorded.should == [] end end @@ -261,20 +261,18 @@ describe :kernel_require, shared: true do it "loads a file that recursively requires itself" do path = File.expand_path "recursive_require_fixture.rb", CODE_LOADING_DIR -> { - @object.require(path).should be_true + @object.require(path).should == true }.should complain(/circular require considered harmful/, verbose: true) ScratchPad.recorded.should == [:loaded] end - ruby_bug "#17340", ''...'3.3' do - it "loads a file concurrently" do - path = File.expand_path "concurrent_require_fixture.rb", CODE_LOADING_DIR - ScratchPad.record(@object) - -> { - @object.require(path) - }.should_not complain(/circular require considered harmful/, verbose: true) - ScratchPad.recorded.join - end + it "loads a file concurrently" do + path = File.expand_path "concurrent_require_fixture.rb", CODE_LOADING_DIR + ScratchPad.record(@object) + -> { + @object.require(path) + }.should_not complain(/circular require considered harmful/, verbose: true) + ScratchPad.recorded.join end end @@ -286,15 +284,25 @@ describe :kernel_require, shared: true do end it "loads a .rb extensioned file when a C-extension file exists on an earlier load path" do - @object.require("load_fixture").should be_true + @object.require("load_fixture").should == true ScratchPad.recorded.should == [:loaded] end it "does not load a feature twice when $LOAD_PATH has been modified" do $LOAD_PATH.replace [CODE_LOADING_DIR] - @object.require("load_fixture").should be_true + @object.require("load_fixture").should == true $LOAD_PATH.replace [File.expand_path("b", CODE_LOADING_DIR), CODE_LOADING_DIR] - @object.require("load_fixture").should be_false + @object.require("load_fixture").should == false + end + + it "stores the missing path in a LoadError object" do + path = "abcd1234" + + -> { + @object.send(@method, path) + }.should.raise(LoadError) { |e| + e.path.should == path + } end end @@ -302,7 +310,7 @@ describe :kernel_require, shared: true do it "loads a .rb extensioned file when passed a non-extensioned path" do path = File.expand_path "load_fixture", CODE_LOADING_DIR File.should.exist?(path) - @object.require(path).should be_true + @object.require(path).should == true ScratchPad.recorded.should == [:loaded] end @@ -312,21 +320,21 @@ describe :kernel_require, shared: true do $LOADED_FEATURES << File.expand_path("load_fixture.so", CODE_LOADING_DIR) $LOADED_FEATURES << File.expand_path("load_fixture.dll", CODE_LOADING_DIR) path = File.expand_path "load_fixture", CODE_LOADING_DIR - @object.require(path).should be_true + @object.require(path).should == true ScratchPad.recorded.should == [:loaded] end it "does not load a C-extension file if a .rb extensioned file is already loaded" do $LOADED_FEATURES << File.expand_path("load_fixture.rb", CODE_LOADING_DIR) path = File.expand_path "load_fixture", CODE_LOADING_DIR - @object.require(path).should be_false + @object.require(path).should == false ScratchPad.recorded.should == [] end it "loads a .rb extensioned file when passed a non-.rb extensioned path" do path = File.expand_path "load_fixture.ext", CODE_LOADING_DIR File.should.exist?(path) - @object.require(path).should be_true + @object.require(path).should == true ScratchPad.recorded.should == [:loaded] end @@ -336,14 +344,14 @@ describe :kernel_require, shared: true do $LOADED_FEATURES << File.expand_path("load_fixture.ext.so", CODE_LOADING_DIR) $LOADED_FEATURES << File.expand_path("load_fixture.ext.dll", CODE_LOADING_DIR) path = File.expand_path "load_fixture.ext", CODE_LOADING_DIR - @object.require(path).should be_true + @object.require(path).should == true ScratchPad.recorded.should == [:loaded] end it "does not load a C-extension file if a complex-extensioned .rb file is already loaded" do $LOADED_FEATURES << File.expand_path("load_fixture.ext.rb", CODE_LOADING_DIR) path = File.expand_path "load_fixture.ext", CODE_LOADING_DIR - @object.require(path).should be_false + @object.require(path).should == false ScratchPad.recorded.should == [] end end @@ -354,8 +362,8 @@ describe :kernel_require, shared: true do end it "stores an absolute path" do - @object.require(@path).should be_true - $LOADED_FEATURES.should include(@path) + @object.require(@path).should == true + $LOADED_FEATURES.should.include?(@path) end platform_is_not :windows do @@ -375,23 +383,23 @@ describe :kernel_require, shared: true do it "does not canonicalize the path and stores a path with symlinks" do symlink_path = "#{@symlink_to_code_dir}/load_fixture.rb" canonical_path = "#{CODE_LOADING_DIR}/load_fixture.rb" - @object.require(symlink_path).should be_true + @object.require(symlink_path).should == true ScratchPad.recorded.should == [:loaded] features = $LOADED_FEATURES.select { |path| path.end_with?('load_fixture.rb') } - features.should include(symlink_path) - features.should_not include(canonical_path) + features.should.include?(symlink_path) + features.should_not.include?(canonical_path) end it "stores the same path that __FILE__ returns in the required file" do symlink_path = "#{@symlink_to_code_dir}/load_fixture_and__FILE__.rb" - @object.require(symlink_path).should be_true + @object.require(symlink_path).should == true loaded_feature = $LOADED_FEATURES.last ScratchPad.recorded.should == [loaded_feature] end it "requires only once when a new matching file added to path" do - @object.require('load_fixture').should be_true + @object.require('load_fixture').should == true ScratchPad.recorded.should == [:loaded] symlink_to_code_dir_two = tmp("codesymlinktwo") @@ -399,7 +407,7 @@ describe :kernel_require, shared: true do begin $LOAD_PATH.unshift(symlink_to_code_dir_two) - @object.require('load_fixture').should be_false + @object.require('load_fixture').should == false ensure rm_r symlink_to_code_dir_two end @@ -425,7 +433,7 @@ describe :kernel_require, shared: true do it "canonicalizes the entry in $LOAD_PATH but not the filename passed to #require" do $LOAD_PATH.unshift(@symlink_to_dir) - @object.require("symfile").should be_true + @object.require("symfile").should == true loaded_feature = "#{@dir}/symfile.rb" ScratchPad.recorded.should == [loaded_feature] $".last.should == loaded_feature @@ -437,20 +445,20 @@ describe :kernel_require, shared: true do it "does not store the path if the load fails" do $LOAD_PATH << CODE_LOADING_DIR saved_loaded_features = $LOADED_FEATURES.dup - -> { @object.require("raise_fixture.rb") }.should raise_error(RuntimeError) + -> { @object.require("raise_fixture.rb") }.should.raise(RuntimeError) $LOADED_FEATURES.should == saved_loaded_features end it "does not load an absolute path that is already stored" do $LOADED_FEATURES << @path - @object.require(@path).should be_false + @object.require(@path).should == false ScratchPad.recorded.should == [] end it "does not load a ./ relative path that is already stored" do $LOADED_FEATURES << "./load_fixture.rb" Dir.chdir CODE_LOADING_DIR do - @object.require("./load_fixture.rb").should be_false + @object.require("./load_fixture.rb").should == false end ScratchPad.recorded.should == [] end @@ -458,7 +466,7 @@ describe :kernel_require, shared: true do it "does not load a ../ relative path that is already stored" do $LOADED_FEATURES << "../load_fixture.rb" Dir.chdir CODE_LOADING_DIR do - @object.require("../load_fixture.rb").should be_false + @object.require("../load_fixture.rb").should == false end ScratchPad.recorded.should == [] end @@ -466,27 +474,27 @@ describe :kernel_require, shared: true do it "does not load a non-canonical path that is already stored" do $LOADED_FEATURES << "code/../code/load_fixture.rb" $LOAD_PATH << File.dirname(CODE_LOADING_DIR) - @object.require("code/../code/load_fixture.rb").should be_false + @object.require("code/../code/load_fixture.rb").should == false ScratchPad.recorded.should == [] end it "respects being replaced with a new array" do prev = $LOADED_FEATURES.dup - @object.require(@path).should be_true - $LOADED_FEATURES.should include(@path) + @object.require(@path).should == true + $LOADED_FEATURES.should.include?(@path) $LOADED_FEATURES.replace(prev) - $LOADED_FEATURES.should_not include(@path) - @object.require(@path).should be_true - $LOADED_FEATURES.should include(@path) + $LOADED_FEATURES.should_not.include?(@path) + @object.require(@path).should == true + $LOADED_FEATURES.should.include?(@path) end it "does not load twice the same file with and without extension" do $LOAD_PATH << CODE_LOADING_DIR - @object.require("load_fixture.rb").should be_true - @object.require("load_fixture").should be_false + @object.require("load_fixture.rb").should == true + @object.require("load_fixture").should == false end describe "when a non-extensioned file is in $LOADED_FEATURES" do @@ -496,19 +504,19 @@ describe :kernel_require, shared: true do it "loads a .rb extensioned file when a non extensioned file is in $LOADED_FEATURES" do $LOAD_PATH << CODE_LOADING_DIR - @object.require("load_fixture").should be_true + @object.require("load_fixture").should == true ScratchPad.recorded.should == [:loaded] end it "loads a .rb extensioned file from a subdirectory" do $LOAD_PATH << File.dirname(CODE_LOADING_DIR) - @object.require("code/load_fixture").should be_true + @object.require("code/load_fixture").should == true ScratchPad.recorded.should == [:loaded] end it "returns false if the file is not found" do Dir.chdir File.dirname(CODE_LOADING_DIR) do - @object.require("load_fixture").should be_false + @object.require("load_fixture").should == false ScratchPad.recorded.should == [] end end @@ -516,7 +524,7 @@ describe :kernel_require, shared: true do it "returns false when passed a path and the file is not found" do $LOADED_FEATURES << "code/load_fixture" Dir.chdir CODE_LOADING_DIR do - @object.require("code/load_fixture").should be_false + @object.require("code/load_fixture").should == false ScratchPad.recorded.should == [] end end @@ -524,16 +532,16 @@ describe :kernel_require, shared: true do it "stores ../ relative paths as absolute paths" do Dir.chdir CODE_LOADING_DIR do - @object.require("../code/load_fixture.rb").should be_true + @object.require("../code/load_fixture.rb").should == true end - $LOADED_FEATURES.should include(@path) + $LOADED_FEATURES.should.include?(@path) end it "stores ./ relative paths as absolute paths" do Dir.chdir CODE_LOADING_DIR do - @object.require("./load_fixture.rb").should be_true + @object.require("./load_fixture.rb").should == true end - $LOADED_FEATURES.should include(@path) + $LOADED_FEATURES.should.include?(@path) end it "collapses duplicate path separators" do @@ -541,27 +549,27 @@ describe :kernel_require, shared: true do sep = File::Separator + File::Separator path = ["..", "code", "load_fixture.rb"].join(sep) Dir.chdir CODE_LOADING_DIR do - @object.require(path).should be_true + @object.require(path).should == true end - $LOADED_FEATURES.should include(@path) + $LOADED_FEATURES.should.include?(@path) end it "expands absolute paths containing .." do path = File.join CODE_LOADING_DIR, "..", "code", "load_fixture.rb" - @object.require(path).should be_true - $LOADED_FEATURES.should include(@path) + @object.require(path).should == true + $LOADED_FEATURES.should.include?(@path) end it "adds the suffix of the resolved filename" do $LOAD_PATH << CODE_LOADING_DIR - @object.require("load_fixture").should be_true - $LOADED_FEATURES.should include(@path) + @object.require("load_fixture").should == true + $LOADED_FEATURES.should.include?(@path) end it "does not load a non-canonical path for a file already loaded" do $LOADED_FEATURES << @path $LOAD_PATH << File.dirname(CODE_LOADING_DIR) - @object.require("code/../code/load_fixture.rb").should be_false + @object.require("code/../code/load_fixture.rb").should == false ScratchPad.recorded.should == [] end @@ -569,7 +577,7 @@ describe :kernel_require, shared: true do $LOADED_FEATURES << @path $LOAD_PATH << "an_irrelevant_dir" Dir.chdir CODE_LOADING_DIR do - @object.require("./load_fixture.rb").should be_false + @object.require("./load_fixture.rb").should == false end ScratchPad.recorded.should == [] end @@ -578,7 +586,7 @@ describe :kernel_require, shared: true do $LOADED_FEATURES << @path $LOAD_PATH << "an_irrelevant_dir" Dir.chdir CODE_LOADING_DIR do - @object.require("../code/load_fixture.rb").should be_false + @object.require("../code/load_fixture.rb").should == false end ScratchPad.recorded.should == [] end @@ -586,26 +594,26 @@ describe :kernel_require, shared: true do it "unicode_normalize is part of core and not $LOADED_FEATURES" do features = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems') features.lines.each { |feature| - feature.should_not include("unicode_normalize") + feature.should_not.include?("unicode_normalize") } - -> { @object.require("unicode_normalize") }.should raise_error(LoadError) + -> { @object.require("unicode_normalize") }.should.raise(LoadError) end it "does not load a file earlier on the $LOAD_PATH when other similar features were already loaded" do Dir.chdir CODE_LOADING_DIR do - @object.send(@method, "../code/load_fixture").should be_true + @object.send(@method, "../code/load_fixture").should == true end ScratchPad.recorded.should == [:loaded] $LOAD_PATH.unshift "#{CODE_LOADING_DIR}/b" # This loads because the above load was not on the $LOAD_PATH - @object.send(@method, "load_fixture").should be_true + @object.send(@method, "load_fixture").should == true ScratchPad.recorded.should == [:loaded, :loaded] $LOAD_PATH.unshift "#{CODE_LOADING_DIR}/c" # This does not load because the above load was on the $LOAD_PATH - @object.send(@method, "load_fixture").should be_false + @object.send(@method, "load_fixture").should == false ScratchPad.recorded.should == [:loaded, :loaded] end end @@ -623,13 +631,13 @@ describe :kernel_require, shared: true do # "#3171" it "performs tilde expansion on a .rb file before storing paths in $LOADED_FEATURES" do - @object.require("~/load_fixture.rb").should be_true - $LOADED_FEATURES.should include(@path) + @object.require("~/load_fixture.rb").should == true + $LOADED_FEATURES.should.include?(@path) end it "performs tilde expansion on a non-extensioned file before storing paths in $LOADED_FEATURES" do - @object.require("~/load_fixture").should be_true - $LOADED_FEATURES.should include(@path) + @object.require("~/load_fixture").should == true + $LOADED_FEATURES.should.include?(@path) end end @@ -686,8 +694,8 @@ describe :kernel_require, shared: true do t1.join t2.join - t1_res.should be_true - t2_res.should be_false + t1_res.should == true + t2_res.should == false ScratchPad.recorded.should == [:con_pre, :con_post, :t2_post, :t1_post] end @@ -711,8 +719,8 @@ describe :kernel_require, shared: true do t1.join t2.join - t1_res.should be_true - t2_res.should be_true + t1_res.should == true + t2_res.should == true ScratchPad.recorded.should == [:con2_pre, :con3, :con2_post] end @@ -730,7 +738,7 @@ describe :kernel_require, shared: true do -> { @object.require(@path) - }.should raise_error(RuntimeError) + }.should.raise(RuntimeError) Thread.pass until fin ScratchPad.recorded << :t1_post @@ -751,7 +759,7 @@ describe :kernel_require, shared: true do t1.join t2.join - t2_res.should be_true + t2_res.should == true ScratchPad.recorded.should == [:con_pre, :con_pre, :con_post, :t2_post, :t1_post] end @@ -771,7 +779,7 @@ describe :kernel_require, shared: true do -> { @object.require(@path) - }.should raise_error(RuntimeError) + }.should.raise(RuntimeError) raised = true @@ -799,8 +807,8 @@ describe :kernel_require, shared: true do t1.join t2.join - t1_res.should be_false - t2_res.should be_true + t1_res.should == false + t2_res.should == true ScratchPad.recorded.should == [:con_pre, :con_pre, :con_post, :t2_post, :t1_post] end @@ -811,8 +819,28 @@ describe :kernel_require, shared: true do -> { @object.send(@method, path) - }.should raise_error(LoadError) { |e| + }.should.raise(LoadError) { |e| e.path.should == path } end + + platform_is :linux, :darwin do + it "does not store the missing path in a LoadError object when c-extension file exists but loading fails and passed absolute path without extension" do + # the error message is specific to what dlerror() returns + path = File.join CODE_LOADING_DIR, "a", "load_fixture" + -> { @object.send(@method, path) }.should.raise(LoadError) { |e| + e.path.should == nil + } + end + end + + platform_is :darwin do + it "does not store the missing path in a LoadError object when c-extension file exists but loading fails and passed absolute path with extension" do + # the error message is specific to what dlerror() returns + path = File.join CODE_LOADING_DIR, "a", "load_fixture.bundle" + -> { @object.send(@method, path) }.should.raise(LoadError) { |e| + e.path.should == nil + } + end + end end diff --git a/spec/ruby/core/kernel/shared/sprintf.rb b/spec/ruby/core/kernel/shared/sprintf.rb index 13dc6e97f0..b40bd95f59 100644 --- a/spec/ruby/core/kernel/shared/sprintf.rb +++ b/spec/ruby/core/kernel/shared/sprintf.rb @@ -22,12 +22,13 @@ describe :kernel_sprintf, shared: true do @method.call("%d", "112").should == "112" @method.call("%d", "0127").should == "87" @method.call("%d", "0xc4").should == "196" + @method.call("%d", "0").should == "0" end it "raises TypeError exception if cannot convert to Integer" do -> { @method.call("%b", Object.new) - }.should raise_error(TypeError) + }.should.raise(TypeError) end ["b", "B"].each do |f| @@ -104,6 +105,20 @@ describe :kernel_sprintf, shared: true do @method.call("%X", -1).should == "..F" end end + + %w[b B d i u o x X].each do |f| + describe f do + it "converts to the empty string if precision is 0 and value is 0" do + @method.call("%.#{f}", 0).should == "" + @method.call("%.0#{f}", 0).should == "" + end + + it "pads the empty string if precision is 0 and value is 0" do + @method.call("%2.#{f}", 0).should == " " + @method.call("%2.0#{f}", 0).should == " " + end + end + end end describe "float formats" do @@ -116,7 +131,7 @@ describe :kernel_sprintf, shared: true do it "raises TypeError exception if cannot convert to Float" do -> { @method.call("%f", Object.new) - }.should raise_error(TypeError) + }.should.raise(TypeError) end {"e" => "e", "E" => "E"}.each_pair do |f, exp| @@ -289,40 +304,28 @@ describe :kernel_sprintf, shared: true do @method.call("%c", "a").should == "a" end - ruby_version_is ""..."3.2" do - it "raises ArgumentError if argument is a string of several characters" do - -> { - @method.call("%c", "abc") - }.should raise_error(ArgumentError, /%c requires a character/) - end - - it "raises ArgumentError if argument is an empty string" do - -> { - @method.call("%c", "") - }.should raise_error(ArgumentError, /%c requires a character/) - end + it "displays only the first character if argument is a string of several characters" do + @method.call("%c", "abc").should == "a" end - ruby_version_is "3.2" do - it "displays only the first character if argument is a string of several characters" do - @method.call("%c", "abc").should == "a" - end + it "displays only the first character if argument is a string of several multibyte characters" do + @method.call("%c", "あいうえお").should == "あ" + end - it "displays no characters if argument is an empty string" do - @method.call("%c", "").should == "" - end + it "displays no characters if argument is an empty string" do + @method.call("%c", "").should == "" end it "raises TypeError if argument is not String or Integer and cannot be converted to them" do -> { @method.call("%c", []) - }.should raise_error(TypeError, /no implicit conversion of Array into Integer/) + }.should raise_consistent_error(TypeError, /no implicit conversion of Array into Integer/) end it "raises TypeError if argument is nil" do -> { @method.call("%c", nil) - }.should raise_error(TypeError, /no implicit conversion from nil to integer/) + }.should raise_consistent_error(TypeError, /no implicit conversion of nil into Integer/) end it "tries to convert argument to String with to_str" do @@ -351,7 +354,7 @@ describe :kernel_sprintf, shared: true do -> { @method.call("%c", obj) - }.should raise_error(TypeError, /can't convert BasicObject to String/) + }.should raise_consistent_error(TypeError, /can't convert BasicObject into String/) end it "raises TypeError if converting to Integer with to_int returns non-Integer" do @@ -362,7 +365,7 @@ describe :kernel_sprintf, shared: true do -> { @method.call("%c", obj) - }.should raise_error(TypeError, /can't convert BasicObject to Integer/) + }.should raise_consistent_error(TypeError, /can't convert BasicObject into Integer/) end end @@ -372,6 +375,10 @@ describe :kernel_sprintf, shared: true do obj.should_receive(:inspect).and_return("<inspect-result>") @method.call("%p", obj).should == "<inspect-result>" end + + it "substitutes 'nil' for nil" do + @method.call("%p", nil).should == "nil" + end end describe "s" do @@ -397,7 +404,7 @@ describe :kernel_sprintf, shared: true do -> { @method.call("%s", obj) - }.should raise_error(NoMethodError) + }.should.raise(NoMethodError) end it "formats a partial substring without including omitted characters" do @@ -450,12 +457,12 @@ describe :kernel_sprintf, shared: true do it "alone raises an ArgumentError" do -> { @method.call("%") - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "is escaped by %" do @method.call("%%").should == "%" - @method.call("%%d", 10).should == "%d" + @method.call("%%d").should == "%d" end end end @@ -557,7 +564,7 @@ describe :kernel_sprintf, shared: true do it "raises exception if argument number is bigger than actual arguments list" do -> { @method.call("%4$d", 1, 2, 3) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "ignores '-' sign" do @@ -568,7 +575,7 @@ describe :kernel_sprintf, shared: true do it "raises ArgumentError exception when absolute and relative argument numbers are mixed" do -> { @method.call("%1$d %d", 1, 2) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end end @@ -600,11 +607,28 @@ describe :kernel_sprintf, shared: true do @method.call("%#b", 0).should == "0" @method.call("%#B", 0).should == "0" - @method.call("%#o", 0).should == "0" - @method.call("%#x", 0).should == "0" @method.call("%#X", 0).should == "0" end + + it "does nothing for zero argument when combined with zero precision" do + @method.call("%#.0b", 0).should == "" + @method.call("%#.0B", 0).should == "" + + @method.call("%#.0x", 0).should == "" + @method.call("%#.0X", 0).should == "" + end + end + + context "applies to format o" do + it "does nothing for zero argument" do + @method.call("%#o", 0).should == "0" + @method.call("%#.1o", 0).should == "0" + end + + it "increases the precision if precision zero is requested with zero argument" do + @method.call("%#.0o", 0).should == "0" + end end context "applies to formats aAeEfgG" do @@ -818,7 +842,7 @@ describe :kernel_sprintf, shared: true do it "raises ArgumentError when is mixed with width" do -> { @method.call("%*10d", 10, 112) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end end end @@ -917,7 +941,7 @@ describe :kernel_sprintf, shared: true do it "cannot be mixed with unnamed style" do -> { @method.call("%d %<foo>d", 1, foo: "123") - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end end @@ -937,13 +961,30 @@ describe :kernel_sprintf, shared: true do it "cannot be mixed with unnamed style" do -> { @method.call("%d %{foo}", 1, foo: "123") - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) + end + + it "respects Hash#default when there is no set key" do + @method.call("%{foo}", Hash.new(123)).should == "123" + @method.call("%{foo}", Hash.new { 123 }).should == "123" end - it "raises KeyError when there is no matching key" do + it "raises KeyError when Hash#default returns nil" do -> { @method.call("%{foo}", {}) - }.should raise_error(KeyError) + }.should.raise(KeyError, 'key{foo} not found') + + -> { + @method.call("%{foo}", Hash.new(nil)) + }.should.raise(KeyError, 'key{foo} not found') + + -> { + @method.call("%{foo}", Hash.new { nil }) + }.should.raise(KeyError, 'key{foo} not found') + end + + it "accepts a nil value for an existing key" do + @method.call("%{foo}", { foo: nil }).should == "" end it "converts value to String with to_s" do @@ -967,21 +1008,21 @@ describe :kernel_sprintf, shared: true do it "raises a KeyError" do -> { @method.call("%<foo>s", @object) - }.should raise_error(KeyError) + }.should.raise(KeyError) end it "sets the Hash as the receiver of KeyError" do -> { @method.call("%<foo>s", @object) - }.should raise_error(KeyError) { |err| - err.receiver.should equal(@object) + }.should.raise(KeyError) { |err| + err.receiver.should.equal?(@object) } end it "sets the unmatched key as the key of KeyError" do -> { @method.call("%<foo>s", @object) - }.should raise_error(KeyError) { |err| + }.should.raise(KeyError) { |err| err.key.to_s.should == 'foo' } end diff --git a/spec/ruby/core/kernel/shared/sprintf_encoding.rb b/spec/ruby/core/kernel/shared/sprintf_encoding.rb index 7ec0fe4c48..849c95cbb7 100644 --- a/spec/ruby/core/kernel/shared/sprintf_encoding.rb +++ b/spec/ruby/core/kernel/shared/sprintf_encoding.rb @@ -4,19 +4,19 @@ describe :kernel_sprintf_encoding, shared: true do it "can produce a string with valid encoding" do string = @method.call("good day %{valid}", valid: "e") string.encoding.should == Encoding::UTF_8 - string.valid_encoding?.should be_true + string.valid_encoding?.should == true end it "can produce a string with invalid encoding" do string = @method.call("good day %{invalid}", invalid: "\x80") string.encoding.should == Encoding::UTF_8 - string.valid_encoding?.should be_false + string.valid_encoding?.should == false end it "returns a String in the same encoding as the format String if compatible" do string = "%s".dup.force_encoding(Encoding::KOI8_U) result = @method.call(string, "dogs") - result.encoding.should equal(Encoding::KOI8_U) + result.encoding.should.equal?(Encoding::KOI8_U) end it "returns a String in the argument's encoding if format encoding is more restrictive" do @@ -24,7 +24,7 @@ describe :kernel_sprintf_encoding, shared: true do argument = "b\303\274r".dup.force_encoding(Encoding::UTF_8) result = @method.call(string, argument) - result.encoding.should equal(Encoding::UTF_8) + result.encoding.should.equal?(Encoding::UTF_8) end it "raises Encoding::CompatibilityError if both encodings are ASCII compatible and there are not ASCII characters" do @@ -33,7 +33,7 @@ describe :kernel_sprintf_encoding, shared: true do -> { @method.call(string, argument) - }.should raise_error(Encoding::CompatibilityError) + }.should.raise(Encoding::CompatibilityError) end describe "%c" do @@ -52,7 +52,7 @@ describe :kernel_sprintf_encoding, shared: true do -> { @method.call(format, 1286) - }.should raise_error(RangeError, /out of char range/) + }.should.raise(RangeError, /out of char range/) end it "uses the encoding of the format string to interpret codepoints" do diff --git a/spec/ruby/core/kernel/shared/then.rb b/spec/ruby/core/kernel/shared/then.rb index b52075371f..c71393bf50 100644 --- a/spec/ruby/core/kernel/shared/then.rb +++ b/spec/ruby/core/kernel/shared/then.rb @@ -1,20 +1,20 @@ describe :kernel_then, shared: true do it "yields self" do object = Object.new - object.send(@method) { |o| o.should equal object } + object.send(@method) { |o| o.should.equal? object } end it "returns the block return value" do object = Object.new - object.send(@method) { 42 }.should equal 42 + object.send(@method) { 42 }.should.equal? 42 end it "returns a sized Enumerator when no block given" do object = Object.new enum = object.send(@method) - enum.should be_an_instance_of Enumerator - enum.size.should equal 1 - enum.peek.should equal object - enum.first.should equal object + enum.should.instance_of? Enumerator + enum.size.should.equal? 1 + enum.peek.should.equal? object + enum.first.should.equal? object end end diff --git a/spec/ruby/core/kernel/singleton_class_spec.rb b/spec/ruby/core/kernel/singleton_class_spec.rb index 23c400f9bd..7915272937 100644 --- a/spec/ruby/core/kernel/singleton_class_spec.rb +++ b/spec/ruby/core/kernel/singleton_class_spec.rb @@ -21,27 +21,27 @@ describe "Kernel#singleton_class" do end it "raises TypeError for Integer" do - -> { 123.singleton_class }.should raise_error(TypeError, "can't define singleton") + -> { 123.singleton_class }.should.raise(TypeError, "can't define singleton") end it "raises TypeError for Float" do - -> { 3.14.singleton_class }.should raise_error(TypeError, "can't define singleton") + -> { 3.14.singleton_class }.should.raise(TypeError, "can't define singleton") end it "raises TypeError for Symbol" do - -> { :foo.singleton_class }.should raise_error(TypeError, "can't define singleton") + -> { :foo.singleton_class }.should.raise(TypeError, "can't define singleton") end it "raises TypeError for a frozen deduplicated String" do - -> { (-"string").singleton_class }.should raise_error(TypeError, "can't define singleton") - -> { a = -"string"; a.singleton_class }.should raise_error(TypeError, "can't define singleton") - -> { a = "string"; (-a).singleton_class }.should raise_error(TypeError, "can't define singleton") + -> { (-"string").singleton_class }.should.raise(TypeError, "can't define singleton") + -> { a = -"string"; a.singleton_class }.should.raise(TypeError, "can't define singleton") + -> { a = "string"; (-a).singleton_class }.should.raise(TypeError, "can't define singleton") end it "returns a frozen singleton class if object is frozen" do obj = Object.new obj.freeze - obj.singleton_class.frozen?.should be_true + obj.singleton_class.frozen?.should == true end context "for an IO object with a replaced singleton class" do diff --git a/spec/ruby/core/kernel/singleton_method_spec.rb b/spec/ruby/core/kernel/singleton_method_spec.rb index 0bdf125ad8..fe8e23eb02 100644 --- a/spec/ruby/core/kernel/singleton_method_spec.rb +++ b/spec/ruby/core/kernel/singleton_method_spec.rb @@ -1,10 +1,10 @@ require_relative '../../spec_helper' describe "Kernel#singleton_method" do - it "find a method defined on the singleton class" do + it "finds a method defined on the singleton class" do obj = Object.new def obj.foo; end - obj.singleton_method(:foo).should be_an_instance_of(Method) + obj.singleton_method(:foo).should.instance_of?(Method) end it "returns a Method which can be called" do @@ -23,7 +23,7 @@ describe "Kernel#singleton_method" do obj.foo.should == 42 -> { obj.singleton_method(:foo) - }.should raise_error(NameError) { |e| + }.should.raise(NameError) { |e| # a NameError and not a NoMethodError e.class.should == NameError } @@ -33,9 +33,53 @@ describe "Kernel#singleton_method" do obj = Object.new -> { obj.singleton_method(:not_existing) - }.should raise_error(NameError) { |e| + }.should.raise(NameError) { |e| # a NameError and not a NoMethodError e.class.should == NameError } end + + ruby_bug "#20620", ""..."3.4" do + it "finds a method defined in a module included in the singleton class" do + m = Module.new do + def foo + :foo + end + end + + obj = Object.new + obj.singleton_class.include(m) + + obj.singleton_method(:foo).should.instance_of?(Method) + obj.singleton_method(:foo).call.should == :foo + end + + it "finds a method defined in a module prepended in the singleton class" do + m = Module.new do + def foo + :foo + end + end + + obj = Object.new + obj.singleton_class.prepend(m) + + obj.singleton_method(:foo).should.instance_of?(Method) + obj.singleton_method(:foo).call.should == :foo + end + + it "finds a method defined in a module that an object is extended with" do + m = Module.new do + def foo + :foo + end + end + + obj = Object.new + obj.extend(m) + + obj.singleton_method(:foo).should.instance_of?(Method) + obj.singleton_method(:foo).call.should == :foo + end + end end diff --git a/spec/ruby/core/kernel/singleton_methods_spec.rb b/spec/ruby/core/kernel/singleton_methods_spec.rb index a127a439de..a7f6969519 100644 --- a/spec/ruby/core/kernel/singleton_methods_spec.rb +++ b/spec/ruby/core/kernel/singleton_methods_spec.rb @@ -8,33 +8,33 @@ describe :kernel_singleton_methods, shared: true do end it "returns the names of module methods for a module" do - ReflectSpecs::M.singleton_methods(*@object).should include(:ms_pro, :ms_pub) + ReflectSpecs::M.singleton_methods(*@object).to_set.should >= Set[:ms_pro, :ms_pub] end it "does not return private module methods for a module" do - ReflectSpecs::M.singleton_methods(*@object).should_not include(:ms_pri) + ReflectSpecs::M.singleton_methods(*@object).should_not.include?(:ms_pri) end it "returns the names of class methods for a class" do - ReflectSpecs::A.singleton_methods(*@object).should include(:as_pro, :as_pub) + ReflectSpecs::A.singleton_methods(*@object).to_set.should >= Set[:as_pro, :as_pub] end it "does not return private class methods for a class" do - ReflectSpecs::A.singleton_methods(*@object).should_not include(:as_pri) + ReflectSpecs::A.singleton_methods(*@object).should_not.include?(:as_pri) end it "returns the names of singleton methods for an object" do - ReflectSpecs.os.singleton_methods(*@object).should include(:os_pro, :os_pub) + ReflectSpecs.os.singleton_methods(*@object).to_set.should >= Set[:os_pro, :os_pub] end end describe :kernel_singleton_methods_modules, shared: true do it "does not return any included methods for a module including a module" do - ReflectSpecs::N.singleton_methods(*@object).should include(:ns_pro, :ns_pub) + ReflectSpecs::N.singleton_methods(*@object).to_set.should >= Set[:ns_pro, :ns_pub] end it "does not return any included methods for a class including a module" do - ReflectSpecs::D.singleton_methods(*@object).should include(:ds_pro, :ds_pub) + ReflectSpecs::D.singleton_methods(*@object).to_set.should >= Set[:ds_pro, :ds_pub] end it "for a module does not return methods in a module prepended to Module itself" do @@ -44,7 +44,7 @@ describe :kernel_singleton_methods_modules, shared: true do ancestors = mod.singleton_class.ancestors ancestors[0...2].should == [ mod.singleton_class, mod ] - ancestors.should include(SingletonMethodsSpecs::Prepended) + ancestors.should.include?(SingletonMethodsSpecs::Prepended) # Do not search prepended modules of `Module`, as that's a non-singleton class mod.singleton_methods.should == [] @@ -53,7 +53,7 @@ end describe :kernel_singleton_methods_supers, shared: true do it "returns the names of singleton methods for an object extended with a module" do - ReflectSpecs.oe.singleton_methods(*@object).should include(:m_pro, :m_pub) + ReflectSpecs.oe.singleton_methods(*@object).to_set.should >= Set[:m_pro, :m_pub] end it "returns a unique list for an object extended with a module" do @@ -63,15 +63,15 @@ describe :kernel_singleton_methods_supers, shared: true do end it "returns the names of singleton methods for an object extended with two modules" do - ReflectSpecs.oee.singleton_methods(*@object).should include(:m_pro, :m_pub, :n_pro, :n_pub) + ReflectSpecs.oee.singleton_methods(*@object).to_set.should >= Set[:m_pro, :m_pub, :n_pro, :n_pub] end it "returns the names of singleton methods for an object extended with a module including a module" do - ReflectSpecs.oei.singleton_methods(*@object).should include(:n_pro, :n_pub, :m_pro, :m_pub) + ReflectSpecs.oei.singleton_methods(*@object).to_set.should >= Set[:n_pro, :n_pub, :m_pro, :m_pub] end it "returns the names of inherited singleton methods for a subclass" do - ReflectSpecs::B.singleton_methods(*@object).should include(:as_pro, :as_pub, :bs_pro, :bs_pub) + ReflectSpecs::B.singleton_methods(*@object).to_set.should >= Set[:as_pro, :as_pub, :bs_pro, :bs_pub] end it "returns a unique list for a subclass" do @@ -81,7 +81,7 @@ describe :kernel_singleton_methods_supers, shared: true do end it "returns the names of inherited singleton methods for a subclass including a module" do - ReflectSpecs::C.singleton_methods(*@object).should include(:as_pro, :as_pub, :cs_pro, :cs_pub) + ReflectSpecs::C.singleton_methods(*@object).to_set.should >= Set[:as_pro, :as_pub, :cs_pro, :cs_pub] end it "returns a unique list for a subclass including a module" do @@ -91,57 +91,62 @@ describe :kernel_singleton_methods_supers, shared: true do end it "returns the names of inherited singleton methods for a subclass of a class including a module" do - ReflectSpecs::E.singleton_methods(*@object).should include(:ds_pro, :ds_pub, :es_pro, :es_pub) + ReflectSpecs::E.singleton_methods(*@object).to_set.should >= Set[:ds_pro, :ds_pub, :es_pro, :es_pub] end it "returns the names of inherited singleton methods for a subclass of a class that includes a module, where the subclass also includes a module" do - ReflectSpecs::F.singleton_methods(*@object).should include(:ds_pro, :ds_pub, :fs_pro, :fs_pub) + ReflectSpecs::F.singleton_methods(*@object).to_set.should >= Set[:ds_pro, :ds_pub, :fs_pro, :fs_pub] end it "returns the names of inherited singleton methods for a class extended with a module" do - ReflectSpecs::P.singleton_methods(*@object).should include(:m_pro, :m_pub) + ReflectSpecs::P.singleton_methods(*@object).to_set.should >= Set[:m_pro, :m_pub] end end describe :kernel_singleton_methods_private_supers, shared: true do it "does not return private singleton methods for an object extended with a module" do - ReflectSpecs.oe.singleton_methods(*@object).should_not include(:m_pri) + ReflectSpecs.oe.singleton_methods(*@object).should_not.include?(:m_pri) end it "does not return private singleton methods for an object extended with two modules" do - ReflectSpecs.oee.singleton_methods(*@object).should_not include(:m_pri) + ReflectSpecs.oee.singleton_methods(*@object).should_not.include?(:m_pri) end it "does not return private singleton methods for an object extended with a module including a module" do - ReflectSpecs.oei.singleton_methods(*@object).should_not include(:n_pri, :m_pri) + ReflectSpecs.oei.singleton_methods(*@object).should_not.include?(:n_pri) + ReflectSpecs.oei.singleton_methods(*@object).should_not.include?(:m_pri) end it "does not return private singleton methods for a class extended with a module" do - ReflectSpecs::P.singleton_methods(*@object).should_not include(:m_pri) + ReflectSpecs::P.singleton_methods(*@object).should_not.include?(:m_pri) end it "does not return private inherited singleton methods for a module including a module" do - ReflectSpecs::N.singleton_methods(*@object).should_not include(:ns_pri) + ReflectSpecs::N.singleton_methods(*@object).should_not.include?(:ns_pri) end it "does not return private inherited singleton methods for a class including a module" do - ReflectSpecs::D.singleton_methods(*@object).should_not include(:ds_pri) + ReflectSpecs::D.singleton_methods(*@object).should_not.include?(:ds_pri) end it "does not return private inherited singleton methods for a subclass" do - ReflectSpecs::B.singleton_methods(*@object).should_not include(:as_pri, :bs_pri) + ReflectSpecs::B.singleton_methods(*@object).should_not.include?(:as_pri) + ReflectSpecs::B.singleton_methods(*@object).should_not.include?(:bs_pri) end it "does not return private inherited singleton methods for a subclass including a module" do - ReflectSpecs::C.singleton_methods(*@object).should_not include(:as_pri, :cs_pri) + ReflectSpecs::C.singleton_methods(*@object).should_not.include?(:as_pri) + ReflectSpecs::C.singleton_methods(*@object).should_not.include?(:cs_pri) end it "does not return private inherited singleton methods for a subclass of a class including a module" do - ReflectSpecs::E.singleton_methods(*@object).should_not include(:ds_pri, :es_pri) + ReflectSpecs::E.singleton_methods(*@object).should_not.include?(:ds_pri) + ReflectSpecs::E.singleton_methods(*@object).should_not.include?(:es_pri) end it "does not return private inherited singleton methods for a subclass of a class that includes a module, where the subclass also includes a module" do - ReflectSpecs::F.singleton_methods(*@object).should_not include(:ds_pri, :fs_pri) + ReflectSpecs::F.singleton_methods(*@object).should_not.include?(:ds_pri) + ReflectSpecs::F.singleton_methods(*@object).should_not.include?(:fs_pri) end end @@ -178,15 +183,17 @@ describe "Kernel#singleton_methods" do end it "returns the names of singleton methods of the subclass" do - ReflectSpecs::B.singleton_methods(false).should include(:bs_pro, :bs_pub) + ReflectSpecs::B.singleton_methods(false).to_set.should >= Set[:bs_pro, :bs_pub] end it "does not return names of inherited singleton methods for a subclass" do - ReflectSpecs::B.singleton_methods(false).should_not include(:as_pro, :as_pub) + ReflectSpecs::B.singleton_methods(false).should_not.include?(:as_pro) + ReflectSpecs::B.singleton_methods(false).should_not.include?(:as_pub) end it "does not return the names of inherited singleton methods for a class extended with a module" do - ReflectSpecs::P.singleton_methods(false).should_not include(:m_pro, :m_pub) + ReflectSpecs::P.singleton_methods(false).should_not.include?(:m_pro) + ReflectSpecs::P.singleton_methods(false).should_not.include?(:m_pub) end end end diff --git a/spec/ruby/core/kernel/sleep_spec.rb b/spec/ruby/core/kernel/sleep_spec.rb index 4401e54256..61d8cc2380 100644 --- a/spec/ruby/core/kernel/sleep_spec.rb +++ b/spec/ruby/core/kernel/sleep_spec.rb @@ -1,12 +1,13 @@ require_relative '../../spec_helper' +require_relative '../fiber/fixtures/scheduler' describe "Kernel#sleep" do it "is a private method" do - Kernel.should have_private_instance_method(:sleep) + Kernel.private_instance_methods(false).should.include?(:sleep) end it "returns an Integer" do - sleep(0.001).should be_kind_of(Integer) + sleep(0.001).should.is_a?(Integer) end it "accepts a Float" do @@ -28,12 +29,12 @@ describe "Kernel#sleep" do end it "raises an ArgumentError when passed a negative duration" do - -> { sleep(-0.1) }.should raise_error(ArgumentError) - -> { sleep(-1) }.should raise_error(ArgumentError) + -> { sleep(-0.1) }.should.raise(ArgumentError) + -> { sleep(-1) }.should.raise(ArgumentError) end it "raises a TypeError when passed a String" do - -> { sleep('2') }.should raise_error(TypeError) + -> { sleep('2') }.should.raise(TypeError) end it "pauses execution indefinitely if not given a duration" do @@ -62,26 +63,52 @@ describe "Kernel#sleep" do actual_duration.should > 0.01 # 100 * 0.0001 => 0.01 end - ruby_version_is ""..."3.3" do - it "raises a TypeError when passed nil" do - -> { sleep(nil) }.should raise_error(TypeError) + it "accepts a nil duration" do + running = false + t = Thread.new do + running = true + sleep(nil) + 5 end + + Thread.pass until running + Thread.pass while t.status and t.status != "sleep" + + t.wakeup + t.value.should == 5 end - ruby_version_is "3.3" do - it "accepts a nil duration" do - running = false - t = Thread.new do - running = true - sleep(nil) - 5 + context "Kernel.sleep with Fiber scheduler" do + before :each do + Fiber.set_scheduler(FiberSpecs::LoggingScheduler.new) + end + + after :each do + Fiber.set_scheduler(nil) + end + + it "calls the scheduler without arguments when no duration is given" do + sleeper = Fiber.new(blocking: false) do + sleep end + sleeper.resume + Fiber.scheduler.events.should == [{ event: :kernel_sleep, fiber: sleeper, args: [] }] + end - Thread.pass until running - Thread.pass while t.status and t.status != "sleep" + it "calls the scheduler with the given duration" do + sleeper = Fiber.new(blocking: false) do + sleep(0.01) + end + sleeper.resume + Fiber.scheduler.events.should == [{ event: :kernel_sleep, fiber: sleeper, args: [0.01] }] + end - t.wakeup - t.value.should == 5 + it "does not call the scheduler if the fiber is blocking" do + sleeper = Fiber.new(blocking: true) do + sleep(0.01) + end + sleeper.resume + Fiber.scheduler.events.should == [] end end end diff --git a/spec/ruby/core/kernel/spawn_spec.rb b/spec/ruby/core/kernel/spawn_spec.rb index ba05b629d5..3432fc31da 100644 --- a/spec/ruby/core/kernel/spawn_spec.rb +++ b/spec/ruby/core/kernel/spawn_spec.rb @@ -6,7 +6,7 @@ require_relative 'fixtures/classes' # run here as it is redundant and takes too long for little gain. describe "Kernel#spawn" do it "is a private method" do - Kernel.should have_private_instance_method(:spawn) + Kernel.private_instance_methods(false).should.include?(:spawn) end it "executes the given command" do diff --git a/spec/ruby/core/kernel/sprintf_spec.rb b/spec/ruby/core/kernel/sprintf_spec.rb index 9ef7f86f16..5a4a90ff7a 100644 --- a/spec/ruby/core/kernel/sprintf_spec.rb +++ b/spec/ruby/core/kernel/sprintf_spec.rb @@ -13,28 +13,52 @@ end describe "Kernel#sprintf" do it_behaves_like :kernel_sprintf, -> format, *args { - sprintf(format, *args) + r = nil + -> { + r = sprintf(format, *args) + }.should_not complain(verbose: true) + r } it_behaves_like :kernel_sprintf_encoding, -> format, *args { - sprintf(format, *args) + r = nil + -> { + r = sprintf(format, *args) + }.should_not complain(verbose: true) + r } it_behaves_like :kernel_sprintf_to_str, -> format, *args { - sprintf(format, *args) + r = nil + -> { + r = sprintf(format, *args) + }.should_not complain(verbose: true) + r } end describe "Kernel.sprintf" do it_behaves_like :kernel_sprintf, -> format, *args { - Kernel.sprintf(format, *args) + r = nil + -> { + r = Kernel.sprintf(format, *args) + }.should_not complain(verbose: true) + r } it_behaves_like :kernel_sprintf_encoding, -> format, *args { - Kernel.sprintf(format, *args) + r = nil + -> { + r = Kernel.sprintf(format, *args) + }.should_not complain(verbose: true) + r } it_behaves_like :kernel_sprintf_to_str, -> format, *args { - Kernel.sprintf(format, *args) + r = nil + -> { + r = Kernel.sprintf(format, *args) + }.should_not complain(verbose: true) + r } end diff --git a/spec/ruby/core/kernel/srand_spec.rb b/spec/ruby/core/kernel/srand_spec.rb index 95bb406f46..cbc3a7f4b8 100644 --- a/spec/ruby/core/kernel/srand_spec.rb +++ b/spec/ruby/core/kernel/srand_spec.rb @@ -11,7 +11,7 @@ describe "Kernel#srand" do end it "is a private method" do - Kernel.should have_private_instance_method(:srand) + Kernel.private_instance_methods(false).should.include?(:srand) end it "returns the previous seed value" do @@ -31,7 +31,7 @@ describe "Kernel#srand" do end it "defaults number to a random value" do - -> { srand }.should_not raise_error + -> { srand }.should_not.raise srand.should_not == 0 end @@ -60,11 +60,11 @@ describe "Kernel#srand" do end it "raises a TypeError when passed nil" do - -> { srand(nil) }.should raise_error(TypeError) + -> { srand(nil) }.should.raise(TypeError) end it "raises a TypeError when passed a String" do - -> { srand("7") }.should raise_error(TypeError) + -> { srand("7") }.should.raise(TypeError) end end diff --git a/spec/ruby/core/kernel/sub_spec.rb b/spec/ruby/core/kernel/sub_spec.rb index 9130bd159c..b175e371dc 100644 --- a/spec/ruby/core/kernel/sub_spec.rb +++ b/spec/ruby/core/kernel/sub_spec.rb @@ -6,13 +6,13 @@ require_relative 'fixtures/classes' ruby_version_is ""..."1.9" do describe "Kernel#sub" do it "is a private method" do - Kernel.should have_private_instance_method(:sub) + Kernel.private_instance_methods(false).should.include?(:sub) end end describe "Kernel#sub!" do it "is a private method" do - Kernel.should have_private_instance_method(:sub!) + Kernel.private_instance_methods(false).should.include?(:sub!) end end diff --git a/spec/ruby/core/kernel/syscall_spec.rb b/spec/ruby/core/kernel/syscall_spec.rb index 32d07b3ae2..63943cdad5 100644 --- a/spec/ruby/core/kernel/syscall_spec.rb +++ b/spec/ruby/core/kernel/syscall_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#syscall" do it "is a private method" do - Kernel.should have_private_instance_method(:syscall) + Kernel.private_instance_methods(false).should.include?(:syscall) end end diff --git a/spec/ruby/core/kernel/system_spec.rb b/spec/ruby/core/kernel/system_spec.rb index 9bc03924dd..b24956104a 100644 --- a/spec/ruby/core/kernel/system_spec.rb +++ b/spec/ruby/core/kernel/system_spec.rb @@ -5,14 +5,14 @@ describe :kernel_system, shared: true do it "executes the specified command in a subprocess" do -> { @object.system("echo a") }.should output_to_fd("a\n") - $?.should be_an_instance_of Process::Status + $?.should.instance_of? Process::Status $?.should.success? end it "returns true when the command exits with a zero exit status" do @object.system(ruby_cmd('exit 0')).should == true - $?.should be_an_instance_of Process::Status + $?.should.instance_of? Process::Status $?.should.success? $?.exitstatus.should == 0 end @@ -20,24 +20,24 @@ describe :kernel_system, shared: true do it "returns false when the command exits with a non-zero exit status" do @object.system(ruby_cmd('exit 1')).should == false - $?.should be_an_instance_of Process::Status + $?.should.instance_of? Process::Status $?.should_not.success? $?.exitstatus.should == 1 end it "raises RuntimeError when `exception: true` is given and the command exits with a non-zero exit status" do - -> { @object.system(ruby_cmd('exit 1'), exception: true) }.should raise_error(RuntimeError) + -> { @object.system(ruby_cmd('exit 1'), exception: true) }.should.raise(RuntimeError) end it "raises Errno::ENOENT when `exception: true` is given and the specified command does not exist" do - -> { @object.system('feature_14386', exception: true) }.should raise_error(Errno::ENOENT) + -> { @object.system('feature_14386', exception: true) }.should.raise(Errno::ENOENT) end it "returns nil when command execution fails" do - @object.system("sad").should be_nil + @object.system("sad").should == nil - $?.should be_an_instance_of Process::Status - $?.pid.should be_kind_of(Integer) + $?.should.instance_of? Process::Status + $?.pid.should.is_a?(Integer) $?.should_not.success? end @@ -121,7 +121,7 @@ end describe "Kernel#system" do it "is a private method" do - Kernel.should have_private_instance_method(:system) + Kernel.private_instance_methods(false).should.include?(:system) end it_behaves_like :kernel_system, :system, KernelSpecs::Method.new diff --git a/spec/ruby/core/kernel/taint_spec.rb b/spec/ruby/core/kernel/taint_spec.rb index 0c16b1dbbf..9a2efbaea0 100644 --- a/spec/ruby/core/kernel/taint_spec.rb +++ b/spec/ruby/core/kernel/taint_spec.rb @@ -2,26 +2,7 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' describe "Kernel#taint" do - ruby_version_is ""..."3.2" do - it "is a no-op" do - suppress_warning do - o = Object.new - o.taint - o.should_not.tainted? - end - end - - it "warns in verbose mode" do - -> { - obj = mock("tainted") - obj.taint - }.should complain(/Object#taint is deprecated and will be removed in Ruby 3.2/, verbose: true) - end - end - - ruby_version_is "3.2" do - it "has been removed" do - Object.new.should_not.respond_to?(:taint) - end + it "has been removed" do + Object.new.should_not.respond_to?(:taint) end end diff --git a/spec/ruby/core/kernel/tainted_spec.rb b/spec/ruby/core/kernel/tainted_spec.rb index fcae433069..837eb1dafb 100644 --- a/spec/ruby/core/kernel/tainted_spec.rb +++ b/spec/ruby/core/kernel/tainted_spec.rb @@ -2,28 +2,7 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' describe "Kernel#tainted?" do - ruby_version_is ""..."3.2" do - it "is a no-op" do - suppress_warning do - o = mock('o') - p = mock('p') - p.taint - o.should_not.tainted? - p.should_not.tainted? - end - end - - it "warns in verbose mode" do - -> { - o = mock('o') - o.tainted? - }.should complain(/Object#tainted\? is deprecated and will be removed in Ruby 3.2/, verbose: true) - end - end - - ruby_version_is "3.2" do - it "has been removed" do - Object.new.should_not.respond_to?(:tainted?) - end + it "has been removed" do + Object.new.should_not.respond_to?(:tainted?) end end diff --git a/spec/ruby/core/kernel/tap_spec.rb b/spec/ruby/core/kernel/tap_spec.rb index f7720a6dc7..453b9b84d5 100644 --- a/spec/ruby/core/kernel/tap_spec.rb +++ b/spec/ruby/core/kernel/tap_spec.rb @@ -4,10 +4,10 @@ require_relative 'fixtures/classes' describe "Kernel#tap" do it "always yields self and returns self" do a = KernelSpecs::A.new - a.tap{|o| o.should equal(a); 42}.should equal(a) + a.tap{|o| o.should.equal?(a); 42}.should.equal?(a) end it "raises a LocalJumpError when no block given" do - -> { 3.tap }.should raise_error(LocalJumpError) + -> { 3.tap }.should.raise(LocalJumpError) end end diff --git a/spec/ruby/core/kernel/test_spec.rb b/spec/ruby/core/kernel/test_spec.rb index d26dc06361..30717dfd98 100644 --- a/spec/ruby/core/kernel/test_spec.rb +++ b/spec/ruby/core/kernel/test_spec.rb @@ -8,7 +8,7 @@ describe "Kernel#test" do end it "is a private method" do - Kernel.should have_private_instance_method(:test) + Kernel.private_instance_methods(false).should.include?(:test) end it "returns true when passed ?f if the argument is a regular file" do @@ -28,7 +28,7 @@ describe "Kernel#test" do link = tmp("file_symlink.lnk") File.symlink(@file, link) begin - Kernel.test(?l, link).should be_true + Kernel.test(?l, link).should == true ensure rm_r link end @@ -36,11 +36,11 @@ describe "Kernel#test" do end it "returns true when passed ?r if the argument is readable by the effective uid" do - Kernel.test(?r, @file).should be_true + Kernel.test(?r, @file).should == true end it "returns true when passed ?R if the argument is readable by the real uid" do - Kernel.test(?R, @file).should be_true + Kernel.test(?R, @file).should == true end context "writable test" do @@ -54,11 +54,11 @@ describe "Kernel#test" do end it "returns true when passed ?w if the argument is readable by the effective uid" do - Kernel.test(?w, @tmp_file).should be_true + Kernel.test(?w, @tmp_file).should == true end it "returns true when passed ?W if the argument is readable by the real uid" do - Kernel.test(?W, @tmp_file).should be_true + Kernel.test(?W, @tmp_file).should == true end end diff --git a/spec/ruby/core/kernel/throw_spec.rb b/spec/ruby/core/kernel/throw_spec.rb index 64bfccb413..1086126176 100644 --- a/spec/ruby/core/kernel/throw_spec.rb +++ b/spec/ruby/core/kernel/throw_spec.rb @@ -7,7 +7,7 @@ describe "Kernel.throw" do :value throw :blah fail("throw didn't transfer the control") - end.should be_nil + end.should == nil end it "transfers control to the innermost catch block waiting for the same symbol" do @@ -42,11 +42,11 @@ describe "Kernel.throw" do end it "raises an ArgumentError if there is no catch block for the symbol" do - -> { throw :blah }.should raise_error(ArgumentError) + -> { throw :blah }.should.raise(ArgumentError) end it "raises an UncaughtThrowError if there is no catch block for the symbol" do - -> { throw :blah }.should raise_error(UncaughtThrowError) + -> { throw :blah }.should.raise(UncaughtThrowError) end it "raises ArgumentError if 3 or more arguments provided" do @@ -54,13 +54,13 @@ describe "Kernel.throw" do catch :blah do throw :blah, :return_value, 2 end - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) -> { catch :blah do throw :blah, :return_value, 2, 3, 4, 5 end - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "can throw an object" do @@ -69,12 +69,12 @@ describe "Kernel.throw" do catch obj do throw obj end - }.should_not raise_error(NameError) + }.should_not.raise(NameError) end end describe "Kernel#throw" do it "is a private method" do - Kernel.should have_private_instance_method(:throw) + Kernel.private_instance_methods(false).should.include?(:throw) end end diff --git a/spec/ruby/core/kernel/trace_var_spec.rb b/spec/ruby/core/kernel/trace_var_spec.rb index 3c84aa5e60..150c3da266 100644 --- a/spec/ruby/core/kernel/trace_var_spec.rb +++ b/spec/ruby/core/kernel/trace_var_spec.rb @@ -14,7 +14,7 @@ describe "Kernel#trace_var" do end it "is a private method" do - Kernel.should have_private_instance_method(:trace_var) + Kernel.private_instance_methods(false).should.include?(:trace_var) end it "hooks assignments to a global variable" do @@ -49,6 +49,6 @@ describe "Kernel#trace_var" do it "raises ArgumentError if no block or proc is provided" do -> do trace_var :$Kernel_trace_var_global - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) end end diff --git a/spec/ruby/core/kernel/trap_spec.rb b/spec/ruby/core/kernel/trap_spec.rb index 4c801a7215..8f44f3af4b 100644 --- a/spec/ruby/core/kernel/trap_spec.rb +++ b/spec/ruby/core/kernel/trap_spec.rb @@ -2,7 +2,7 @@ require_relative '../../spec_helper' describe "Kernel#trap" do it "is a private method" do - Kernel.should have_private_instance_method(:trap) + Kernel.private_instance_methods(false).should.include?(:trap) end # Behaviour is specified for Signal.trap diff --git a/spec/ruby/core/kernel/trust_spec.rb b/spec/ruby/core/kernel/trust_spec.rb index db6f17e0fb..ef3fa9a3e1 100644 --- a/spec/ruby/core/kernel/trust_spec.rb +++ b/spec/ruby/core/kernel/trust_spec.rb @@ -2,27 +2,7 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' describe "Kernel#trust" do - ruby_version_is ""..."3.2" do - it "is a no-op" do - suppress_warning do - o = Object.new.untrust - o.should_not.untrusted? - o.trust - o.should_not.untrusted? - end - end - - it "warns in verbose mode" do - -> { - o = Object.new.untrust - o.trust - }.should complain(/Object#trust is deprecated and will be removed in Ruby 3.2/, verbose: true) - end - end - - ruby_version_is "3.2" do - it "has been removed" do - Object.new.should_not.respond_to?(:trust) - end + it "has been removed" do + Object.new.should_not.respond_to?(:trust) end end diff --git a/spec/ruby/core/kernel/untaint_spec.rb b/spec/ruby/core/kernel/untaint_spec.rb index 26b2aabbe9..47e8544bd4 100644 --- a/spec/ruby/core/kernel/untaint_spec.rb +++ b/spec/ruby/core/kernel/untaint_spec.rb @@ -2,27 +2,7 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' describe "Kernel#untaint" do - ruby_version_is ""..."3.2" do - it "is a no-op" do - suppress_warning do - o = Object.new.taint - o.should_not.tainted? - o.untaint - o.should_not.tainted? - end - end - - it "warns in verbose mode" do - -> { - o = Object.new.taint - o.untaint - }.should complain(/Object#untaint is deprecated and will be removed in Ruby 3.2/, verbose: true) - end - end - - ruby_version_is "3.2" do - it "has been removed" do - Object.new.should_not.respond_to?(:untaint) - end + it "has been removed" do + Object.new.should_not.respond_to?(:untaint) end end diff --git a/spec/ruby/core/kernel/untrace_var_spec.rb b/spec/ruby/core/kernel/untrace_var_spec.rb index 1925a3a836..8b219801c8 100644 --- a/spec/ruby/core/kernel/untrace_var_spec.rb +++ b/spec/ruby/core/kernel/untrace_var_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Kernel#untrace_var" do it "is a private method" do - Kernel.should have_private_instance_method(:untrace_var) + Kernel.private_instance_methods(false).should.include?(:untrace_var) end end diff --git a/spec/ruby/core/kernel/untrust_spec.rb b/spec/ruby/core/kernel/untrust_spec.rb index 5310cd8eb4..8787ab3fc9 100644 --- a/spec/ruby/core/kernel/untrust_spec.rb +++ b/spec/ruby/core/kernel/untrust_spec.rb @@ -2,26 +2,7 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' describe "Kernel#untrust" do - ruby_version_is ""..."3.2" do - it "is a no-op" do - suppress_warning do - o = Object.new - o.untrust - o.should_not.untrusted? - end - end - - it "warns in verbose mode" do - -> { - o = Object.new - o.untrust - }.should complain(/Object#untrust is deprecated and will be removed in Ruby 3.2/, verbose: true) - end - end - - ruby_version_is "3.2" do - it "has been removed" do - Object.new.should_not.respond_to?(:untrust) - end + it "has been removed" do + Object.new.should_not.respond_to?(:untrust) end end diff --git a/spec/ruby/core/kernel/untrusted_spec.rb b/spec/ruby/core/kernel/untrusted_spec.rb index ea36d6c98c..29261be9c4 100644 --- a/spec/ruby/core/kernel/untrusted_spec.rb +++ b/spec/ruby/core/kernel/untrusted_spec.rb @@ -2,27 +2,7 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' describe "Kernel#untrusted?" do - ruby_version_is ""..."3.2" do - it "is a no-op" do - suppress_warning do - o = mock('o') - o.should_not.untrusted? - o.untrust - o.should_not.untrusted? - end - end - - it "warns in verbose mode" do - -> { - o = mock('o') - o.untrusted? - }.should complain(/Object#untrusted\? is deprecated and will be removed in Ruby 3.2/, verbose: true) - end - end - - ruby_version_is "3.2" do - it "has been removed" do - Object.new.should_not.respond_to?(:untrusted?) - end + it "has been removed" do + Object.new.should_not.respond_to?(:untrusted?) end end diff --git a/spec/ruby/core/kernel/warn_spec.rb b/spec/ruby/core/kernel/warn_spec.rb index 00164ad90b..189129dd31 100644 --- a/spec/ruby/core/kernel/warn_spec.rb +++ b/spec/ruby/core/kernel/warn_spec.rb @@ -14,7 +14,7 @@ describe "Kernel#warn" do end it "is a private method" do - Kernel.should have_private_instance_method(:warn) + Kernel.private_instance_methods(false).should.include?(:warn) end it "accepts multiple arguments" do @@ -112,6 +112,12 @@ describe "Kernel#warn" do ruby_exe(file, options: "-rrubygems", args: "2>&1").should == "#{file}:2: warning: warn-require-warning\n" end + it "doesn't show the caller when the uplevel is `nil`" do + w = KernelSpecs::WarnInNestedCall.new + + -> { w.f4("foo", nil) }.should output(nil, "foo\n") + end + guard -> { Kernel.instance_method(:tap).source_location } do it "skips <internal: core library methods defined in Ruby" do file, line = Kernel.instance_method(:tap).source_location @@ -155,7 +161,7 @@ describe "Kernel#warn" do -> { $VERBOSE = true warn("message", category: Object.new) - }.should raise_error(TypeError) + }.should.raise(TypeError) end it "converts first arg using to_s" do @@ -188,19 +194,19 @@ describe "Kernel#warn" do end it "raises ArgumentError if passed negative value" do - -> { warn "", uplevel: -2 }.should raise_error(ArgumentError) - -> { warn "", uplevel: -100 }.should raise_error(ArgumentError) + -> { warn "", uplevel: -2 }.should.raise(ArgumentError) + -> { warn "", uplevel: -100 }.should.raise(ArgumentError) end it "raises ArgumentError if passed -1" do - -> { warn "", uplevel: -1 }.should raise_error(ArgumentError) + -> { warn "", uplevel: -1 }.should.raise(ArgumentError) end it "raises TypeError if passed not Integer" do - -> { warn "", uplevel: "" }.should raise_error(TypeError) - -> { warn "", uplevel: [] }.should raise_error(TypeError) - -> { warn "", uplevel: {} }.should raise_error(TypeError) - -> { warn "", uplevel: Object.new }.should raise_error(TypeError) + -> { warn "", uplevel: "" }.should.raise(TypeError) + -> { warn "", uplevel: [] }.should.raise(TypeError) + -> { warn "", uplevel: {} }.should.raise(TypeError) + -> { warn "", uplevel: Object.new }.should.raise(TypeError) end end |