kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Update to ruby/spec@875a09e

Browse source
This commit is contained in:
Benoit Daloze 2019-07-27 12:40:09 +02:00
parent a06301b103
commit 5c276e1cc9
1247 changed files with 5316 additions and 5028 deletions
Download patch file Download diff file Expand all files Collapse all files

18
spec/ruby/library/bigdecimal/BigDecimal_spec.rb
View file

@ -51,16 +51,16 @@ describe "Kernel#BigDecimal" do
ruby_version_is "2.6" do
it "does not ignores trailing garbage" do
lambda { BigDecimal("123E45ruby") }.should raise_error(ArgumentError)
lambda { BigDecimal("123x45") }.should raise_error(ArgumentError)
lambda { BigDecimal("123.4%E5") }.should raise_error(ArgumentError)
lambda { BigDecimal("1E2E3E4E5E") }.should raise_error(ArgumentError)
-> { BigDecimal("123E45ruby") }.should raise_error(ArgumentError)
-> { BigDecimal("123x45") }.should raise_error(ArgumentError)
-> { BigDecimal("123.4%E5") }.should raise_error(ArgumentError)
-> { BigDecimal("1E2E3E4E5E") }.should raise_error(ArgumentError)
end
end
it "raises ArgumentError for invalid strings" do
lambda { BigDecimal("ruby") }.should raise_error(ArgumentError)
lambda { BigDecimal(" \t\n \r-\t\t\tInfinity \n") }.should raise_error(ArgumentError)
-> { BigDecimal("ruby") }.should raise_error(ArgumentError)
-> { BigDecimal(" \t\n \r-\t\t\tInfinity \n") }.should raise_error(ArgumentError)
end
it "allows omitting the integer part" do
@ -82,8 +82,8 @@ describe "Kernel#BigDecimal" do
reference = BigDecimal("12345.67E89")
BigDecimal("12_345.67E89").should == reference
lambda { BigDecimal("1_2_3_4_5_._6____7_E89") }.should raise_error(ArgumentError)
lambda { BigDecimal("12345_.67E_8__9_") }.should raise_error(ArgumentError)
-> { BigDecimal("1_2_3_4_5_._6____7_E89") }.should raise_error(ArgumentError)
-> { BigDecimal("12345_.67E_8__9_") }.should raise_error(ArgumentError)
end
end
@ -151,7 +151,7 @@ describe "Kernel#BigDecimal" do
end
it "raises ArgumentError when Float is used without precision" do
lambda { BigDecimal(1.0) }.should raise_error(ArgumentError)
-> { BigDecimal(1.0) }.should raise_error(ArgumentError)
end
it "returns appropriate BigDecimal zero for signed zero" do

14
spec/ruby/library/bigdecimal/add_spec.rb
View file

@ -81,6 +81,12 @@ describe "BigDecimal#add" do
end
end
describe "with Rational" do
it "produces a BigDecimal" do
(@three + Rational(500, 2)).should == BigDecimal("0.253e3")
end
end
it "favors the precision specified in the second argument over the global limit" do
BigDecimalSpecs.with_limit(1) do
BigDecimal('0.888').add(@zero, 3).should == BigDecimal('0.888')
@ -165,22 +171,22 @@ describe "BigDecimal#add" do
end
it "raises TypeError when adds nil" do
lambda {
-> {
@one.add(nil, 10)
}.should raise_error(TypeError)
lambda {
-> {
@one.add(nil, 0)
}.should raise_error(TypeError)
end
it "raises TypeError when precision parameter is nil" do
lambda {
-> {
@one.add(@one, nil)
}.should raise_error(TypeError)
end
it "raises ArgumentError when precision parameter is negative" do
lambda {
-> {
@one.add(@one, -10)
}.should raise_error(ArgumentError)
end

6
spec/ruby/library/bigdecimal/ceil_spec.rb
View file

@ -48,9 +48,9 @@ describe "BigDecimal#ceil" do
end
it "raise exception, if self is special value" do
lambda { @infinity.ceil }.should raise_error(FloatDomainError)
lambda { @infinity_neg.ceil }.should raise_error(FloatDomainError)
lambda { @nan.ceil }.should raise_error(FloatDomainError)
-> { @infinity.ceil }.should raise_error(FloatDomainError)
-> { @infinity_neg.ceil }.should raise_error(FloatDomainError)
-> { @nan.ceil }.should raise_error(FloatDomainError)
end
it "returns n digits right of the decimal point if given n > 0" do

26
spec/ruby/library/bigdecimal/div_spec.rb
View file

@ -51,9 +51,9 @@ describe "BigDecimal#div" do
end
it "raises FloatDomainError if NaN is involved" do
lambda { @one.div(@nan) }.should raise_error(FloatDomainError)
lambda { @nan.div(@one) }.should raise_error(FloatDomainError)
lambda { @nan.div(@nan) }.should raise_error(FloatDomainError)
-> { @one.div(@nan) }.should raise_error(FloatDomainError)
-> { @nan.div(@one) }.should raise_error(FloatDomainError)
-> { @nan.div(@nan) }.should raise_error(FloatDomainError)
end
it "returns 0 if divided by Infinity and no precision given" do
@ -69,14 +69,14 @@ describe "BigDecimal#div" do
end
it "raises ZeroDivisionError if divided by zero and no precision given" do
lambda { @one.div(@zero) }.should raise_error(ZeroDivisionError)
lambda { @one.div(@zero_plus) }.should raise_error(ZeroDivisionError)
lambda { @one.div(@zero_minus) }.should raise_error(ZeroDivisionError)
-> { @one.div(@zero) }.should raise_error(ZeroDivisionError)
-> { @one.div(@zero_plus) }.should raise_error(ZeroDivisionError)
-> { @one.div(@zero_minus) }.should raise_error(ZeroDivisionError)
lambda { @zero.div(@zero) }.should raise_error(ZeroDivisionError)
lambda { @zero_minus.div(@zero_plus) }.should raise_error(ZeroDivisionError)
lambda { @zero_minus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
lambda { @zero_plus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
-> { @zero.div(@zero) }.should raise_error(ZeroDivisionError)
-> { @zero_minus.div(@zero_plus) }.should raise_error(ZeroDivisionError)
-> { @zero_minus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
-> { @zero_plus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
end
it "returns NaN if zero is divided by zero" do
@ -90,9 +90,9 @@ describe "BigDecimal#div" do
end
it "raises FloatDomainError if (+|-) Infinity divided by 1 and no precision given" do
lambda { @infinity_minus.div(@one) }.should raise_error(FloatDomainError)
lambda { @infinity.div(@one) }.should raise_error(FloatDomainError)
lambda { @infinity_minus.div(@one_minus) }.should raise_error(FloatDomainError)
-> { @infinity_minus.div(@one) }.should raise_error(FloatDomainError)
-> { @infinity.div(@one) }.should raise_error(FloatDomainError)
-> { @infinity_minus.div(@one_minus) }.should raise_error(FloatDomainError)
end
it "returns (+|-)Infinity if (+|-)Infinity by 1 and precision given" do

10
spec/ruby/library/bigdecimal/divide_spec.rb
View file

@ -4,4 +4,14 @@ require 'bigdecimal'
describe "BigDecimal#/" do
it_behaves_like :bigdecimal_quo, :/, []
before :each do
@three = BigDecimal("3")
end
describe "with Rational" do
it "produces a BigDecimal" do
(@three / Rational(500, 2)).should == BigDecimal("0.12e-1")
end
end
end

10
spec/ruby/library/bigdecimal/divmod_spec.rb
View file

@ -38,9 +38,9 @@ describe "BigDecimal#mod_part_of_divmod" do
it "raises ZeroDivisionError if other is zero" do
bd5667 = BigDecimal("5667.19")
lambda { bd5667.mod_part_of_divmod(0) }.should raise_error(ZeroDivisionError)
lambda { bd5667.mod_part_of_divmod(BigDecimal("0")) }.should raise_error(ZeroDivisionError)
lambda { @zero.mod_part_of_divmod(@zero) }.should raise_error(ZeroDivisionError)
-> { bd5667.mod_part_of_divmod(0) }.should raise_error(ZeroDivisionError)
-> { bd5667.mod_part_of_divmod(BigDecimal("0")) }.should raise_error(ZeroDivisionError)
-> { @zero.mod_part_of_divmod(@zero) }.should raise_error(ZeroDivisionError)
end
end
@ -140,7 +140,7 @@ describe "BigDecimal#divmod" do
it "raises ZeroDivisionError if the divisor is zero" do
(@special_vals + @regular_vals + @zeroes - [@nan]).each do |val|
@zeroes.each do |zero|
lambda { val.divmod(zero) }.should raise_error(ZeroDivisionError)
-> { val.divmod(zero) }.should raise_error(ZeroDivisionError)
end
end
end
@ -172,7 +172,7 @@ describe "BigDecimal#divmod" do
end
it "raises TypeError if the argument cannot be coerced to BigDecimal" do
lambda {
-> {
@one.divmod('1')
}.should raise_error(TypeError)
end

2
spec/ruby/library/bigdecimal/fix_spec.rb
View file

@ -49,7 +49,7 @@ describe "BigDecimal#fix" do
end
it "does not allow any arguments" do
lambda {
-> {
@mixed.fix(10)
}.should raise_error(ArgumentError)
end

6
spec/ruby/library/bigdecimal/floor_spec.rb
View file

@ -41,9 +41,9 @@ describe "BigDecimal#floor" do
end
it "raise exception, if self is special value" do
lambda { @infinity.floor }.should raise_error(FloatDomainError)
lambda { @infinity_neg.floor }.should raise_error(FloatDomainError)
lambda { @nan.floor }.should raise_error(FloatDomainError)
-> { @infinity.floor }.should raise_error(FloatDomainError)
-> { @infinity_neg.floor }.should raise_error(FloatDomainError)
-> { @nan.floor }.should raise_error(FloatDomainError)
end
it "returns n digits right of the decimal point if given n > 0" do

12
spec/ruby/library/bigdecimal/gt_spec.rb
View file

@ -86,11 +86,11 @@ describe "BigDecimal#>" do
end
it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do
lambda {@zero > nil }.should raise_error(ArgumentError)
lambda {@infinity > nil }.should raise_error(ArgumentError)
lambda {@infinity_neg > nil }.should raise_error(ArgumentError)
lambda {@mixed > nil }.should raise_error(ArgumentError)
lambda {@pos_int > nil }.should raise_error(ArgumentError)
lambda {@neg_frac > nil }.should raise_error(ArgumentError)
-> {@zero > nil }.should raise_error(ArgumentError)
-> {@infinity > nil }.should raise_error(ArgumentError)
-> {@infinity_neg > nil }.should raise_error(ArgumentError)
-> {@mixed > nil }.should raise_error(ArgumentError)
-> {@pos_int > nil }.should raise_error(ArgumentError)
-> {@neg_frac > nil }.should raise_error(ArgumentError)
end
end

12
spec/ruby/library/bigdecimal/gte_spec.rb
View file

@ -90,11 +90,11 @@ describe "BigDecimal#>=" do
end
it "returns nil if the argument is nil" do
lambda {@zero >= nil }.should raise_error(ArgumentError)
lambda {@infinity >= nil }.should raise_error(ArgumentError)
lambda {@infinity_neg >= nil }.should raise_error(ArgumentError)
lambda {@mixed >= nil }.should raise_error(ArgumentError)
lambda {@pos_int >= nil }.should raise_error(ArgumentError)
lambda {@neg_frac >= nil }.should raise_error(ArgumentError)
-> {@zero >= nil }.should raise_error(ArgumentError)
-> {@infinity >= nil }.should raise_error(ArgumentError)
-> {@infinity_neg >= nil }.should raise_error(ArgumentError)
-> {@mixed >= nil }.should raise_error(ArgumentError)
-> {@pos_int >= nil }.should raise_error(ArgumentError)
-> {@neg_frac >= nil }.should raise_error(ArgumentError)
end
end

12
spec/ruby/library/bigdecimal/lt_spec.rb
View file

@ -84,11 +84,11 @@ describe "BigDecimal#<" do
end
it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do
lambda {@zero < nil }.should raise_error(ArgumentError)
lambda {@infinity < nil }.should raise_error(ArgumentError)
lambda {@infinity_neg < nil }.should raise_error(ArgumentError)
lambda {@mixed < nil }.should raise_error(ArgumentError)
lambda {@pos_int < nil }.should raise_error(ArgumentError)
lambda {@neg_frac < nil }.should raise_error(ArgumentError)
-> {@zero < nil }.should raise_error(ArgumentError)
-> {@infinity < nil }.should raise_error(ArgumentError)
-> {@infinity_neg < nil }.should raise_error(ArgumentError)
-> {@mixed < nil }.should raise_error(ArgumentError)
-> {@pos_int < nil }.should raise_error(ArgumentError)
-> {@neg_frac < nil }.should raise_error(ArgumentError)
end
end

12
spec/ruby/library/bigdecimal/lte_spec.rb
View file

@ -90,11 +90,11 @@ describe "BigDecimal#<=" do
end
it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do
lambda {@zero <= nil }.should raise_error(ArgumentError)
lambda {@infinity <= nil }.should raise_error(ArgumentError)
lambda {@infinity_neg <= nil }.should raise_error(ArgumentError)
lambda {@mixed <= nil }.should raise_error(ArgumentError)
lambda {@pos_int <= nil }.should raise_error(ArgumentError)
lambda {@neg_frac <= nil }.should raise_error(ArgumentError)
-> {@zero <= nil }.should raise_error(ArgumentError)
-> {@infinity <= nil }.should raise_error(ArgumentError)
-> {@infinity_neg <= nil }.should raise_error(ArgumentError)
-> {@mixed <= nil }.should raise_error(ArgumentError)
-> {@pos_int <= nil }.should raise_error(ArgumentError)
-> {@neg_frac <= nil }.should raise_error(ArgumentError)
end
end

10
spec/ruby/library/bigdecimal/mode_spec.rb
View file

@ -24,13 +24,13 @@ describe "BigDecimal.mode" do
it "raise an exception if the flag is true" do
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, true)
lambda { BigDecimal("NaN").add(BigDecimal("1"),0) }.should raise_error(FloatDomainError)
-> { BigDecimal("NaN").add(BigDecimal("1"),0) }.should raise_error(FloatDomainError)
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, true)
lambda { BigDecimal("0").add(BigDecimal("Infinity"),0) }.should raise_error(FloatDomainError)
-> { BigDecimal("0").add(BigDecimal("Infinity"),0) }.should raise_error(FloatDomainError)
BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, true)
lambda { BigDecimal("1").quo(BigDecimal("0")) }.should raise_error(FloatDomainError)
-> { BigDecimal("1").quo(BigDecimal("0")) }.should raise_error(FloatDomainError)
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, true)
lambda { BigDecimal("1E11111111111111111111") }.should raise_error(FloatDomainError)
lambda { (BigDecimal("1E1000000000000000000")**10) }.should raise_error(FloatDomainError)
-> { BigDecimal("1E11111111111111111111") }.should raise_error(FloatDomainError)
-> { (BigDecimal("1E1000000000000000000")**10) }.should raise_error(FloatDomainError)
end
end

7
spec/ruby/library/bigdecimal/multiply_spec.rb
View file

@ -8,6 +8,7 @@ end
describe "BigDecimal#*" do
before :each do
@three = BigDecimal("3")
@e3_minus = BigDecimal("3E-20001")
@e3_plus = BigDecimal("3E20001")
@e = BigDecimal("1.00000000000000000000123456789")
@ -31,4 +32,10 @@ describe "BigDecimal#*" do
(@e3_minus * object).should == BigDecimal("9")
end
end
describe "with Rational" do
it "produces a BigDecimal" do
(@three * Rational(500, 2)).should == BigDecimal("0.75e3")
end
end
end

2
spec/ruby/library/bigdecimal/remainder_spec.rb
View file

@ -84,7 +84,7 @@ describe "BigDecimal#remainder" do
end
it "raises TypeError if the argument cannot be coerced to BigDecimal" do
lambda {
-> {
@one.remainder('2')
}.should raise_error(TypeError)
end

14
spec/ruby/library/bigdecimal/round_spec.rb
View file

@ -217,18 +217,18 @@ describe "BigDecimal#round" do
end
it 'raise exception, if self is special value' do
lambda { BigDecimal('NaN').round }.should raise_error(FloatDomainError)
lambda { BigDecimal('Infinity').round }.should raise_error(FloatDomainError)
lambda { BigDecimal('-Infinity').round }.should raise_error(FloatDomainError)
-> { BigDecimal('NaN').round }.should raise_error(FloatDomainError)
-> { BigDecimal('Infinity').round }.should raise_error(FloatDomainError)
-> { BigDecimal('-Infinity').round }.should raise_error(FloatDomainError)
end
it 'do not raise exception, if self is special value and precision is given' do
lambda { BigDecimal('NaN').round(2) }.should_not raise_error(FloatDomainError)
lambda { BigDecimal('Infinity').round(2) }.should_not raise_error(FloatDomainError)
lambda { BigDecimal('-Infinity').round(2) }.should_not raise_error(FloatDomainError)
-> { BigDecimal('NaN').round(2) }.should_not raise_error(FloatDomainError)
-> { BigDecimal('Infinity').round(2) }.should_not raise_error(FloatDomainError)
-> { BigDecimal('-Infinity').round(2) }.should_not raise_error(FloatDomainError)
end
it "raise for a non-existent round mode" do
lambda { @p1_50.round(0, :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode")
-> { @p1_50.round(0, :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode")
end
end

8
spec/ruby/library/bigdecimal/shared/modulo.rb
View file

@ -108,7 +108,7 @@ describe :bigdecimal_modulo, shared: true do
end
it "raises TypeError if the argument cannot be coerced to BigDecimal" do
lambda {
-> {
@one.send(@method, '2')
}.should raise_error(TypeError)
end
@ -118,8 +118,8 @@ describe :bigdecimal_modulo_zerodivisionerror, shared: true do
it "raises ZeroDivisionError if other is zero" do
bd5667 = BigDecimal("5667.19")
lambda { bd5667.send(@method, 0) }.should raise_error(ZeroDivisionError)
lambda { bd5667.send(@method, BigDecimal("0")) }.should raise_error(ZeroDivisionError)
lambda { @zero.send(@method, @zero) }.should raise_error(ZeroDivisionError)
-> { bd5667.send(@method, 0) }.should raise_error(ZeroDivisionError)
-> { bd5667.send(@method, BigDecimal("0")) }.should raise_error(ZeroDivisionError)
-> { @zero.send(@method, @zero) }.should raise_error(ZeroDivisionError)
end
end

4
spec/ruby/library/bigdecimal/shared/to_int.rb
View file

@ -2,8 +2,8 @@ require 'bigdecimal'
describe :bigdecimal_to_int , shared: true do
it "raises FloatDomainError if BigDecimal is infinity or NaN" do
lambda { BigDecimal("Infinity").send(@method) }.should raise_error(FloatDomainError)
lambda { BigDecimal("NaN").send(@method) }.should raise_error(FloatDomainError)
-> { BigDecimal("Infinity").send(@method) }.should raise_error(FloatDomainError)
-> { BigDecimal("NaN").send(@method) }.should raise_error(FloatDomainError)
end
it "returns Integer or Bignum otherwise" do

18
spec/ruby/library/bigdecimal/sqrt_spec.rb
View file

@ -41,37 +41,37 @@ describe "BigDecimal#sqrt" do
end
it "raises ArgumentError when no argument is given" do
lambda {
-> {
@one.sqrt
}.should raise_error(ArgumentError)
end
it "raises ArgumentError if a negative number is given" do
lambda {
-> {
@one.sqrt(-1)
}.should raise_error(ArgumentError)
end
it "raises ArgumentError if 2 arguments are given" do
lambda {
-> {
@one.sqrt(1, 1)
}.should raise_error(ArgumentError)
end
it "raises TypeError if nil is given" do
lambda {
-> {
@one.sqrt(nil)
}.should raise_error(TypeError)
end
it "raises TypeError if a string is given" do
lambda {
-> {
@one.sqrt("stuff")
}.should raise_error(TypeError)
end
it "raises TypeError if a plain Object is given" do
lambda {
-> {
@one.sqrt(Object.new)
}.should raise_error(TypeError)
end
@ -82,7 +82,7 @@ describe "BigDecimal#sqrt" do
end
it "raises FloatDomainError on negative values" do
lambda {
-> {
BigDecimal('-1').sqrt(10)
}.should raise_error(FloatDomainError)
end
@ -92,13 +92,13 @@ describe "BigDecimal#sqrt" do
end
it "raises FloatDomainError for negative infinity" do
lambda {
-> {
@infinity_minus.sqrt(1)
}.should raise_error(FloatDomainError)
end
it "raises FloatDomainError for NaN" do
lambda {
-> {
@nan.sqrt(1)
}.should raise_error(FloatDomainError)
end

7
spec/ruby/library/bigdecimal/sub_spec.rb
View file

@ -7,6 +7,7 @@ describe "BigDecimal#sub" do
@one = BigDecimal("1")
@zero = BigDecimal("0")
@two = BigDecimal("2")
@three = BigDecimal("3")
@nan = BigDecimal("NaN")
@infinity = BigDecimal("Infinity")
@infinity_minus = BigDecimal("-Infinity")
@ -42,6 +43,12 @@ describe "BigDecimal#sub" do
end
end
describe "with Rational" do
it "produces a BigDecimal" do
(@three - Rational(500, 2)).should == BigDecimal('-0.247e3')
end
end
it "returns NaN if NaN is involved" do
@one.sub(@nan, 1).nan?.should == true
@nan.sub(@one, 1).nan?.should == true

2
spec/ruby/library/bigdecimal/to_s_spec.rb
View file

@ -26,7 +26,7 @@ describe "BigDecimal#to_s" do
end
it "takes an optional argument" do
lambda {@bigdec.to_s("F")}.should_not raise_error()
-> {@bigdec.to_s("F")}.should_not raise_error()
end
it "starts with + if + is supplied and value is positive" do

6
spec/ruby/library/bigdecimal/truncate_spec.rb
View file

@ -74,8 +74,8 @@ describe "BigDecimal#truncate" do
end
it "returns the same value if self is special value" do
lambda { @nan.truncate }.should raise_error(FloatDomainError)
lambda { @infinity.truncate }.should raise_error(FloatDomainError)
lambda { @infinity_negative.truncate }.should raise_error(FloatDomainError)
-> { @nan.truncate }.should raise_error(FloatDomainError)
-> { @infinity.truncate }.should raise_error(FloatDomainError)
-> { @infinity_negative.truncate }.should raise_error(FloatDomainError)
end
end